diff --git a/README.md b/README.md index ad458bb..234c423 100644 --- a/README.md +++ b/README.md @@ -23,7 +23,7 @@ The official Model Context Protocol plugin for [Infernux](https://github.com/Che New Infernux projects include this official plugin by default. Existing projects can install or update it from the Editor's **Plugins** window. You can disable or uninstall it there when agent access is not needed. -The Editor writes standard stdio client configurations for Cursor, Claude Code, VS Code, Trae and Gemini. Their small proxy forwards to `http://127.0.0.1:9713/mcp` and reads the current user's private credential for every request, including after an Editor restart. It does not initialize the engine. Direct HTTP clients must send a bearer credential; the built-in Python client handles this automatically. No credential is stored in project files, process arguments, or environment variables. Set `INFERNUX_MCP_PORT` before starting the Editor to choose another loopback port. +Point an MCP-compatible client to `http://127.0.0.1:9713/mcp`; no credential is needed. The Editor also writes ready-to-use client configurations for Cursor, Claude Code, VS Code, Trae and Gemini. The server accepts localhost connections only, and all capabilities are granted by default (narrow them in `ProjectSettings/mcp_capabilities.json`). Set `INFERNUX_MCP_PORT` before starting the Editor to choose another loopback port. Start a session with `host_session_status`, then read `operation_schema_list`. Search the catalog with `operation_schema_search`, inspect the exact schema you need, and call it through `operation_command_execute`. Long-running builds belong in `operation_job_submit`; known ordered calls can be grouped with `operation_batch_execute`. diff --git a/README.zh-CN.md b/README.zh-CN.md index 24b4e84..fe3a276 100644 --- a/README.zh-CN.md +++ b/README.zh-CN.md @@ -23,7 +23,7 @@ Infernux 新项目默认带有这个官方插件。已有项目可以在编辑器的**插件**窗口中安装或更新;不需要 Agent 操作时,也可以在同一位置禁用或卸载。 -编辑器为 Cursor、Claude Code、VS Code、Trae 和 Gemini 生成标准 stdio 配置。轻量代理把请求转发至 `http://127.0.0.1:9713/mcp`,每次请求读取当前用户的私有凭据,编辑器重启后也会使用新凭据;代理不会初始化引擎。直接连接 HTTP 的客户端必须携带 bearer 凭据,内置 Python 客户端会自动处理。凭据不会写入项目文件、进程参数或环境变量。如需更换端口,请在启动编辑器前设置 `INFERNUX_MCP_PORT`。 +把支持 MCP 的客户端连接到 `http://127.0.0.1:9713/mcp` 即可,不需要凭据。编辑器也会为 Cursor、Claude Code、VS Code、Trae 和 Gemini 写好现成的客户端配置。服务只接受本机连接,默认授予全部能力(可在 `ProjectSettings/mcp_capabilities.json` 中收窄)。如需更换端口,请在启动编辑器前设置 `INFERNUX_MCP_PORT`。 Agent 应先调用 `host_session_status`,再读取 `operation_schema_list`。通过 `operation_schema_search` 找到所需能力、读取准确 schema,最后用 `operation_command_execute` 执行。构建等耗时任务使用 `operation_job_submit`,一组顺序明确的操作可以交给 `operation_batch_execute`,减少通信往返。 diff --git a/package/editor/infernux_mcp/bridge.py b/package/editor/infernux_mcp/bridge.py deleted file mode 100644 index 1453bf3..0000000 --- a/package/editor/infernux_mcp/bridge.py +++ /dev/null @@ -1,19 +0,0 @@ -"""Standard stdio MCP entry point; forwards to the authenticated Editor HTTP host.""" - -import argparse - -from client import create_loopback_client - - -def main(): - parser = argparse.ArgumentParser() - parser.add_argument("--endpoint", required=True) - args = parser.parse_args() - from fastmcp.server import create_proxy - - proxy = create_proxy(create_loopback_client(args.endpoint), name="Infernux Editor") - proxy.run(transport="stdio", show_banner=False) - - -if __name__ == "__main__": - main() diff --git a/package/editor/infernux_mcp/capabilities.py b/package/editor/infernux_mcp/capabilities.py index 0f0c148..99425fe 100644 --- a/package/editor/infernux_mcp/capabilities.py +++ b/package/editor/infernux_mcp/capabilities.py @@ -16,43 +16,9 @@ VALID_PROFILES = frozenset({"developer_assist", "global_validation"}) -# Capability domains served by the built-in operation set. The default grant -# is an explicit enumeration instead of "*": the persisted project config -# shows the user exactly what the agent may touch, grants can be trimmed per -# project, and capabilities added by future operation domains are never -# granted silently. test_mcp_server guards this list against drift. -READ_CAPABILITY_DOMAINS = ( - "asset", - "camera", - "capture", - "console", - "docs", - "input", - "material", - "particle", - "player", - "project", - "runtime", - "scene", - "session", - "ui", -) -WRITE_CAPABILITY_DOMAINS = ( - "asset", - "camera", - "capture", - "input", - "material", - "particle", - "player", - "runtime", - "scene", - "session", - "ui", -) -DEFAULT_GRANTED_CAPABILITIES: tuple[str, ...] = tuple( - f"{domain}.read" for domain in READ_CAPABILITY_DOMAINS -) + tuple(f"{domain}.write" for domain in WRITE_CAPABILITY_DOMAINS) +# MCP is a user-directed development tool: every capability is granted unless +# the project narrows granted_capabilities (fnmatch patterns, e.g. "*.read"). +DEFAULT_GRANTED_CAPABILITIES: tuple[str, ...] = ("*",) DEFAULT_CAPABILITY_CONFIG: dict[str, Any] = { "enabled": True, @@ -236,7 +202,6 @@ def _normalized_config(config: dict[str, Any]) -> dict[str, Any]: raise ValueError("configuration must be a JSON object") source = config normalized = copy.deepcopy(DEFAULT_CAPABILITY_CONFIG) - normalized["granted_capabilities"] = [] for key in ("enabled", "write_default_config_on_bootstrap"): if key in source: _validate_value(key, source[key], bool) diff --git a/package/editor/infernux_mcp/client.py b/package/editor/infernux_mcp/client.py index 47f68a3..01e017a 100644 --- a/package/editor/infernux_mcp/client.py +++ b/package/editor/infernux_mcp/client.py @@ -33,15 +33,6 @@ def create_loopback_client(endpoint: str, *, timeout_seconds: float | None = Non import httpx from fastmcp import Client from fastmcp.client.transports.http import StreamableHttpTransport - if __package__: - from .credentials import load_token - else: - from credentials import load_token - - class EditorCredentialAuth(httpx.Auth): - async def async_auth_flow(self, request): - request.headers["Authorization"] = f"Bearer {load_token(endpoint)}" - yield request def http_client_factory(headers=None, auth=None, follow_redirects=True, timeout=None): return httpx.AsyncClient( @@ -52,10 +43,7 @@ def http_client_factory(headers=None, auth=None, follow_redirects=True, timeout= trust_env=False, ) - transport = StreamableHttpTransport( - str(endpoint), auth=EditorCredentialAuth(), - httpx_client_factory=http_client_factory, - ) + transport = StreamableHttpTransport(str(endpoint), httpx_client_factory=http_client_factory) return Client(transport, timeout=timeout_seconds, init_timeout=timeout_seconds) diff --git a/package/editor/infernux_mcp/credentials.py b/package/editor/infernux_mcp/credentials.py deleted file mode 100644 index c19f977..0000000 --- a/package/editor/infernux_mcp/credentials.py +++ /dev/null @@ -1,108 +0,0 @@ -"""Per-user credentials for the loopback Editor transport.""" - -from __future__ import annotations - -import ctypes -import json -import os -from pathlib import Path -import secrets -from urllib.parse import urlsplit - - -def credential_path(endpoint: str) -> Path: - parsed = urlsplit(endpoint) - if (parsed.scheme != "http" or parsed.hostname not in {"127.0.0.1", "localhost"} - or parsed.path != "/mcp" or parsed.username or parsed.password - or parsed.query or parsed.fragment or not parsed.port): - raise ValueError("MCP credentials require a loopback HTTP /mcp endpoint") - if os.name == "nt": - directory = Path(os.environ["LOCALAPPDATA"]) / "Infernux" / "MCP" - else: - directory = Path(os.environ.get("XDG_STATE_HOME", Path.home() / ".local/state")) / "infernux/mcp" - return directory / f"{parsed.port}.json" - - -def _protect_directory(path: Path) -> None: - if os.name != "nt": - path.chmod(0o700) - return - from ctypes import wintypes - - kernel = ctypes.WinDLL("kernel32", use_last_error=True) - advapi = ctypes.WinDLL("advapi32", use_last_error=True) - kernel.GetCurrentProcess.restype = wintypes.HANDLE - kernel.CloseHandle.argtypes = [wintypes.HANDLE] - kernel.LocalFree.argtypes = [ctypes.c_void_p] - advapi.OpenProcessToken.argtypes = [wintypes.HANDLE, wintypes.DWORD, ctypes.POINTER(wintypes.HANDLE)] - advapi.GetTokenInformation.argtypes = [wintypes.HANDLE, ctypes.c_int, ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(wintypes.DWORD)] - advapi.ConvertSidToStringSidW.argtypes = [ctypes.c_void_p, ctypes.POINTER(wintypes.LPWSTR)] - advapi.ConvertStringSecurityDescriptorToSecurityDescriptorW.argtypes = [wintypes.LPCWSTR, wintypes.DWORD, ctypes.POINTER(ctypes.c_void_p), ctypes.c_void_p] - advapi.GetSecurityDescriptorDacl.argtypes = [ctypes.c_void_p, ctypes.POINTER(wintypes.BOOL), ctypes.POINTER(ctypes.c_void_p), ctypes.POINTER(wintypes.BOOL)] - advapi.SetNamedSecurityInfoW.argtypes = [wintypes.LPWSTR, ctypes.c_int, wintypes.DWORD, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p] - - def checked(ok): - if not ok: - raise ctypes.WinError(ctypes.get_last_error()) - - token = wintypes.HANDLE() - sid_string = wintypes.LPWSTR() - descriptor = ctypes.c_void_p() - checked(advapi.OpenProcessToken(kernel.GetCurrentProcess(), 0x0008, ctypes.byref(token))) - try: - size = wintypes.DWORD() - advapi.GetTokenInformation(token, 1, None, 0, ctypes.byref(size)) - data = ctypes.create_string_buffer(size.value) - checked(advapi.GetTokenInformation(token, 1, data, size, ctypes.byref(size))) - sid = ctypes.cast(data, ctypes.POINTER(ctypes.c_void_p))[0] - checked(advapi.ConvertSidToStringSidW(sid, ctypes.byref(sid_string))) - checked(advapi.ConvertStringSecurityDescriptorToSecurityDescriptorW( - f"D:P(A;OICI;FA;;;{sid_string.value})", 1, ctypes.byref(descriptor), None)) - present, defaulted, dacl = wintypes.BOOL(), wintypes.BOOL(), ctypes.c_void_p() - checked(advapi.GetSecurityDescriptorDacl(descriptor, ctypes.byref(present), ctypes.byref(dacl), ctypes.byref(defaulted))) - result = advapi.SetNamedSecurityInfoW(str(path), 1, 0x80000004, None, None, dacl, None) - if result: - raise ctypes.WinError(result) - finally: - kernel.CloseHandle(token) - if sid_string: - kernel.LocalFree(sid_string) - if descriptor: - kernel.LocalFree(descriptor) - - -def publish_credentials(endpoint: str) -> tuple[Path, str]: - path = credential_path(endpoint) - path.parent.mkdir(parents=True, exist_ok=True, mode=0o700) - _protect_directory(path.parent) - token = secrets.token_urlsafe(32) - staging = path.with_name(f".{path.name}.{os.getpid()}") - try: - with open(staging, "w", encoding="utf-8") as handle: - if os.name != "nt": - os.fchmod(handle.fileno(), 0o600) - json.dump({"endpoint": endpoint, "pid": os.getpid(), "token": token}, handle) - os.replace(staging, path) - finally: - staging.unlink(missing_ok=True) - return path, token - - -def load_token(endpoint: str) -> str: - document = json.loads(credential_path(endpoint).read_text(encoding="utf-8")) - if urlsplit(document["endpoint"]).port != urlsplit(endpoint).port: - raise ValueError("MCP credential endpoint does not match") - token = document["token"] - if not isinstance(token, str) or not token: - raise ValueError("MCP credential token is missing") - return token - - -def remove_credentials(endpoint: str, token: str) -> None: - path = credential_path(endpoint) - try: - current = json.loads(path.read_text(encoding="utf-8")) - except FileNotFoundError: - return - if current.get("token") == token: - path.unlink() diff --git a/package/editor/infernux_mcp/player_operations.py b/package/editor/infernux_mcp/player_operations.py index 43d8ae6..8d849f7 100644 --- a/package/editor/infernux_mcp/player_operations.py +++ b/package/editor/infernux_mcp/player_operations.py @@ -4,6 +4,7 @@ import json import os +import threading from infernux.host import EditorAutomationHost, Operation, OperationError, OperationKind, resolve_project_path @@ -13,6 +14,7 @@ _LOCAL_SUPERVISORS: dict[tuple[str, str], SupervisorSession] = {} +_LOCAL_SUPERVISORS_LOCK = threading.Lock() def build_player_operations(project_path: str) -> tuple[Operation, ...]: @@ -245,22 +247,23 @@ def _supervisor() -> SupervisorSession: if active.build_profile != "debug_feedback": raise OperationError("player.unavailable", "Player validation requires debug_feedback.") key = (active.project_root, active.session_id) - supervisor = _LOCAL_SUPERVISORS.get(key) - if supervisor is None: - try: - supervisor = SupervisorSession.attach_current_host( - active.project_root, - active.session_id, - mode=active.mode, - build_profile=active.build_profile, - editor_instance_id=active.editor_instance_id, - mcp_host=os.environ.get("INFERNUX_MCP_HOST", "127.0.0.1"), - mcp_port=int(os.environ.get("INFERNUX_MCP_PORT", "9713")), - ) - except (OSError, RuntimeError, ValueError) as exc: - raise OperationError("player.supervisor_attach", str(exc)) from exc - _LOCAL_SUPERVISORS[key] = supervisor - return supervisor + with _LOCAL_SUPERVISORS_LOCK: + supervisor = _LOCAL_SUPERVISORS.get(key) + if supervisor is None: + try: + supervisor = SupervisorSession.attach_current_host( + active.project_root, + active.session_id, + mode=active.mode, + build_profile=active.build_profile, + editor_instance_id=active.editor_instance_id, + mcp_host=os.environ.get("INFERNUX_MCP_HOST", "127.0.0.1"), + mcp_port=int(os.environ.get("INFERNUX_MCP_PORT", "9713")), + ) + except (OSError, RuntimeError, ValueError) as exc: + raise OperationError("player.supervisor_attach", str(exc)) from exc + _LOCAL_SUPERVISORS[key] = supervisor + return supervisor def _build( diff --git a/package/editor/infernux_mcp/server.py b/package/editor/infernux_mcp/server.py index ba3c86a..dc2c92b 100644 --- a/package/editor/infernux_mcp/server.py +++ b/package/editor/infernux_mcp/server.py @@ -6,7 +6,6 @@ import os import threading import time -import sys import socket from contextvars import copy_context from dataclasses import dataclass, field @@ -26,7 +25,7 @@ HEALTH_PATH = "/health" SERVER_NAME = "Infernux Editor" _RUNTIME_SERVICE_NAME = "infernux.editor.mcp.http" -_TRANSPORT_CONTRACT = 1 +_TRANSPORT_CONTRACT = 2 @dataclass @@ -37,7 +36,6 @@ class _ServerState: mcp: object transport: object adapter_shutdown: object - credential_token: str = field(default="", repr=False) transport_contract: int = _TRANSPORT_CONTRACT adapter_begin_shutdown: object = None thread: Optional[threading.Thread] = None @@ -95,11 +93,11 @@ def start_server(project_path: str, *, host: str = HOST, port: int = PORT) -> bo with _lifecycle_lock: existing = _active_state() contract = getattr(existing, "transport_contract", 0) if existing is not None else _TRANSPORT_CONTRACT - if contract not in {0, _TRANSPORT_CONTRACT}: + if contract > _TRANSPORT_CONTRACT: raise RuntimeError("Infernux MCP transport owner has an unsupported version contract") - if existing is not None and contract == 0: - # Pre-authentication owners can survive module reload. Retire that - # concrete legacy transport before publishing an authenticated one. + if existing is not None and contract < _TRANSPORT_CONTRACT: + # Owners from an older plugin generation survive module reload. + # Retire that transport before publishing the current one. _stop_state(existing) existing = _active_state() if existing is not None: @@ -160,12 +158,15 @@ def start_server(project_path: str, *, host: str = HOST, port: int = PORT) -> bo except Exception as exc: Debug.log_suppressed("infernux_mcp.start_session_log", exc) from mcp.server.transport_security import TransportSecuritySettings + # No authentication: MCP is driven by the local user. The SDK guard only + # stops remote web pages from reaching the loopback port via DNS + # rebinding; local browser tools (e.g. MCP Inspector) stay allowed. mcp = FastMCP( SERVER_NAME, stateless_http=True, json_response=True, log_level="WARNING", transport_security=TransportSecuritySettings( enable_dns_rebinding_protection=True, allowed_hosts=[f"127.0.0.1:{port}", f"localhost:{port}"], - allowed_origins=[], + allowed_origins=["http://127.0.0.1:*", "http://localhost:*"], ), ) @@ -188,8 +189,6 @@ async def _mcp_health_probe(request: Request) -> JSONResponse: import uvicorn - from infernux_mcp.credentials import publish_credentials - from infernux_mcp.transport_security import EditorTransportSecurity listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: listener.setsockopt(socket.SOL_SOCKET, @@ -197,16 +196,14 @@ async def _mcp_health_probe(request: Request) -> JSONResponse: listener.bind((host, port)) listener.listen(2048) listener.setblocking(False) - _, credential_token = publish_credentials(endpoint_url(host=host, port=port)) except OSError as exc: listener.close() shutdown_adapter() raise RuntimeError("Infernux MCP transport failed before becoming ready") from exc - app = EditorTransportSecurity(mcp.streamable_http_app(), port=port, token=credential_token) transport = uvicorn.Server( uvicorn.Config( - app, + mcp.streamable_http_app(), host=str(host), port=int(port), log_config=None, @@ -225,7 +222,6 @@ async def _mcp_health_probe(request: Request) -> JSONResponse: transport=transport, adapter_shutdown=shutdown_adapter, adapter_begin_shutdown=begin_shutdown_adapter, - credential_token=credential_token, ) def _run() -> None: @@ -308,9 +304,6 @@ def _reap_state(state: _ServerState) -> None: if thread is not None and thread is not threading.current_thread(): thread.join() try: - if getattr(state, "transport_contract", 0) == _TRANSPORT_CONTRACT: - from infernux_mcp.credentials import remove_credentials - remove_credentials(endpoint_url(host=state.host, port=state.port), state.credential_token) state.adapter_shutdown() if state.project_path: _remove_discovery_files( @@ -360,7 +353,6 @@ def connection_info(*, host: str | None = None, port: int | None = None) -> dict (state.port if state is not None else PORT) if port is None else int(port) ) url = endpoint_url(host=resolved_host, port=resolved_port) - from infernux_mcp.credentials import credential_path return { "name": SERVER_NAME, "transport": "streamable-http", @@ -369,28 +361,26 @@ def connection_info(*, host: str | None = None, port: int | None = None) -> dict "path": PATH, "url": url, "health_url": health_url(host=resolved_host, port=resolved_port), - "authentication": {"type": "bearer", "token_file": str(credential_path(url))}, "clients": _client_connection_configs(url), } def _client_connection_configs(url: str) -> dict: - bridge = os.path.join(os.path.dirname(__file__), "bridge.py") - command = {"command": sys.executable, "args": [bridge, "--endpoint", url]} + """Direct streamable-HTTP entries in each client's own config dialect.""" + streamable = {"url": url, "transport": "streamable-http"} + typed_http = {"type": "http", "url": url} clients = {} - for name, file, root_key, typed in ( - ("generic", "mcp.json", "mcpServers", False), - ("cursor", ".cursor/mcp.json", "mcpServers", False), - ("claude_code", ".mcp.json", "mcpServers", True), - ("vscode_copilot", ".vscode/mcp.json", "servers", True), - ("trae", ".trae/mcp.json", "mcpServers", True), - ("gemini", ".gemini/settings.json", "mcpServers", False), + for name, file, root_key, entry in ( + ("generic", "mcp.json", "mcpServers", streamable), + ("cursor", ".cursor/mcp.json", "mcpServers", streamable), + ("claude_code", ".mcp.json", "mcpServers", typed_http), + ("vscode_copilot", ".vscode/mcp.json", "servers", typed_http), + ("trae", ".trae/mcp.json", "mcpServers", typed_http), + ("gemini", ".gemini/settings.json", "mcpServers", + {"httpUrl": url, "timeout": 600000, "trust": False}), ): - entry = dict(command) - if typed: - entry["type"] = "stdio" clients[name] = {"file": file, "format": root_key, - "config": {root_key: {"infernux-editor": entry}}} + "config": {root_key: {"infernux-editor": dict(entry)}}} return clients @@ -496,7 +486,6 @@ def _write_generic_manifest_file(path: str, info: dict) -> None: "port": info["port"], "path": info["path"], "url": info["url"], - "authentication": info["authentication"], } data["clients"] = { name: {"file": client["file"], "format": client["format"]} diff --git a/package/editor/infernux_mcp/supervisor.py b/package/editor/infernux_mcp/supervisor.py index 5f7b07f..5025e1d 100644 --- a/package/editor/infernux_mcp/supervisor.py +++ b/package/editor/infernux_mcp/supervisor.py @@ -108,6 +108,7 @@ class SupervisorSession: _editor_log_handle: Any = field(default=None, init=False, repr=False) _player_log_handle: Any = field(default=None, init=False, repr=False) _last_handoff: dict[str, Any] = field(default_factory=dict, init=False, repr=False) + _operation_thread_lock: threading.Lock = field(default_factory=threading.Lock, init=False, repr=False) def __post_init__(self) -> None: self.project_root = resolved_path(self.project_root) @@ -471,60 +472,62 @@ def launch_player( timeout_seconds: float = 30.0, ) -> dict[str, Any]: """Launch a Debug Player with a constrained, engine-owned validation channel.""" - if self.build_profile != "debug_feedback": - raise RuntimeError("Supervisor-managed Player validation requires the debug_feedback profile.") - if self._player_state()["running"]: - status = self.status() | {"already_running": True} - return self.wait_for_player_ready(timeout_seconds=timeout_seconds) if wait_for_ready else status - - executable, manifest = _validate_player_executable(executable_path, self.project_root) - self._player_executable = executable - self._player_start_scene = _resolve_player_start_scene(start_scene, self.project_root, manifest) - self._player_control_token = secrets.token_urlsafe(32) - self._player_ready = False - self._attached_player_pid = 0 - self._player_log_baselines = { - "runtime": _text_file_baseline(self.player_runtime_log_path), - "debug": _text_file_baseline(self.player_debug_log_path), - "crash": _text_file_baseline(self.player_crash_log_path), - } - for path in (self.player_control_path, self.player_response_path, self.player_ready_path): - try: - os.remove(path) - except FileNotFoundError: - pass + with self._operation_lock(): + if self.build_profile != "debug_feedback": + raise RuntimeError("Supervisor-managed Player validation requires the debug_feedback profile.") + if self._player_state()["running"]: + status = self.wait_for_player_ready(timeout_seconds=timeout_seconds) if wait_for_ready else self.status() + return status | {"already_running": True} + + executable, manifest = _validate_player_executable(executable_path, self.project_root) + self._player_executable = executable + self._player_start_scene = _resolve_player_start_scene(start_scene, self.project_root, manifest) + self._player_control_token = secrets.token_urlsafe(32) + self._player_ready = False + self._attached_player_pid = 0 + self._player_log_baselines = { + "runtime": _text_file_baseline(self.player_runtime_log_path), + "debug": _text_file_baseline(self.player_debug_log_path), + "crash": _text_file_baseline(self.player_crash_log_path), + } + for path in (self.player_control_path, self.player_response_path, self.player_ready_path): + try: + os.remove(path) + except FileNotFoundError: + pass - self._close_player_log() - os.makedirs(self.artifact_root, exist_ok=True) - self._player_log_handle = open(self.player_stdout_path, "w", encoding="utf-8", newline="\n") - env = os.environ.copy() - env["_INFERNUX_READY_FILE"] = self.player_ready_path - env["_INFERNUX_PLAYER_CONTROL_FILE"] = self.player_control_path - env["_INFERNUX_PLAYER_RESPONSE_FILE"] = self.player_response_path - env["_INFERNUX_PLAYER_CONTROL_TOKEN"] = self._player_control_token - env["_INFERNUX_PLAYER_ARTIFACT_ROOT"] = self.artifact_root - data_root = _player_data_root(self._player_executable) - env["_INFERNUX_PLAYER_RUNTIME_ROOT"] = os.path.dirname(self._player_executable) - env["_INFERNUX_PLAYER_DATA_ROOT"] = data_root - env["_INFERNUX_PLAYER_MODULE_ROOT"] = os.path.join(data_root, "RuntimeModules") - if self._player_start_scene: - env["_INFERNUX_PLAYER_START_SCENE_GUID"] = self._player_start_scene - try: - self._player_process = subprocess.Popen( - [self._player_executable], - cwd=os.path.dirname(self._player_executable), - env=env, - stdout=self._player_log_handle, - stderr=subprocess.STDOUT, - text=True, - ) - except Exception: self._close_player_log() - self._player_process = None - self._player_control_token = "" - raise - self._persist_state() - return self.wait_for_player_ready(timeout_seconds=timeout_seconds) if wait_for_ready else self.status() + os.makedirs(self.artifact_root, exist_ok=True) + self._player_log_handle = open(self.player_stdout_path, "w", encoding="utf-8", newline="\n") + env = os.environ.copy() + env["_INFERNUX_READY_FILE"] = self.player_ready_path + env["_INFERNUX_PLAYER_CONTROL_FILE"] = self.player_control_path + env["_INFERNUX_PLAYER_RESPONSE_FILE"] = self.player_response_path + env["_INFERNUX_PLAYER_CONTROL_TOKEN"] = self._player_control_token + env["_INFERNUX_PLAYER_ARTIFACT_ROOT"] = self.artifact_root + data_root = _player_data_root(self._player_executable) + env["_INFERNUX_PLAYER_RUNTIME_ROOT"] = os.path.dirname(self._player_executable) + env["_INFERNUX_PLAYER_DATA_ROOT"] = data_root + env["_INFERNUX_PLAYER_MODULE_ROOT"] = os.path.join(data_root, "RuntimeModules") + if self._player_start_scene: + env["_INFERNUX_PLAYER_START_SCENE_GUID"] = self._player_start_scene + try: + self._player_process = subprocess.Popen( + [self._player_executable], + cwd=os.path.dirname(self._player_executable), + env=env, + stdout=self._player_log_handle, + stderr=subprocess.STDOUT, + text=True, + ) + except Exception: + self._player_process = None + self._player_control_token = "" + raise + finally: + self._close_player_log() + self._persist_state() + return self.wait_for_player_ready(timeout_seconds=timeout_seconds) if wait_for_ready else self.status() def wait_for_player_ready(self, *, timeout_seconds: float = 30.0) -> dict[str, Any]: deadline = time.monotonic() + max(float(timeout_seconds), 0.1) @@ -1766,38 +1769,39 @@ def _remove_stale_owned_project_lock(self, editor_pid: int) -> bool: @contextmanager def _operation_lock(self): - """Prevent two external Supervisors from mutating a session artifact concurrently.""" - os.makedirs(self.artifact_root, exist_ok=True) - token = secrets.token_urlsafe(18) - payload = {"pid": os.getpid(), "token": token, "started_at": time.time()} - while True: - try: - descriptor = os.open(self.operation_lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY) - except FileExistsError: - existing = _read_json_object(self.operation_lock_path) - existing_pid = int(existing.get("pid", 0) or 0) - if existing_pid > 0 and _pid_is_running(existing_pid): - raise RuntimeError("Another Supervisor operation is already active for this project session.") + """Serialize this owner's operations and exclude other session Supervisors.""" + with self._operation_thread_lock: + os.makedirs(self.artifact_root, exist_ok=True) + token = secrets.token_urlsafe(18) + payload = {"pid": os.getpid(), "token": token, "started_at": time.time()} + while True: try: - os.remove(self.operation_lock_path) - except FileNotFoundError: - pass - continue - try: - with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as f: - json.dump(payload, f, ensure_ascii=False) - f.write("\n") - f.flush() - os.fsync(f.fileno()) - yield - finally: - current = _read_json_object(self.operation_lock_path) - if current.get("token") == token: + descriptor = os.open(self.operation_lock_path, os.O_CREAT | os.O_EXCL | os.O_WRONLY) + except FileExistsError: + existing = _read_json_object(self.operation_lock_path) + existing_pid = int(existing.get("pid", 0) or 0) + if existing_pid > 0 and _pid_is_running(existing_pid): + raise RuntimeError("Another Supervisor operation is already active for this project session.") try: os.remove(self.operation_lock_path) except FileNotFoundError: pass - return + continue + try: + with os.fdopen(descriptor, "w", encoding="utf-8", newline="\n") as f: + json.dump(payload, f, ensure_ascii=False) + f.write("\n") + f.flush() + os.fsync(f.fileno()) + yield + finally: + current = _read_json_object(self.operation_lock_path) + if current.get("token") == token: + try: + os.remove(self.operation_lock_path) + except FileNotFoundError: + pass + return def _close_editor_log(self) -> None: handle = self._editor_log_handle diff --git a/package/editor/infernux_mcp/transport_security.py b/package/editor/infernux_mcp/transport_security.py deleted file mode 100644 index a384602..0000000 --- a/package/editor/infernux_mcp/transport_security.py +++ /dev/null @@ -1,32 +0,0 @@ -"""Authentication and browser boundaries shared by every HTTP route.""" - -import hmac - -from starlette.responses import JSONResponse - - -class EditorTransportSecurity: - def __init__(self, app, *, port: int, token: str): - self.app = app - self.hosts = {f"127.0.0.1:{port}", f"localhost:{port}"} - self.authorization = f"Bearer {token}".encode("ascii") - - async def __call__(self, scope, receive, send): - if scope["type"] == "http": - headers = scope["headers"] - hosts = [value.decode("ascii", errors="replace").lower() for name, value in headers if name.lower() == b"host"] - origins = [value for name, value in headers if name.lower() == b"origin"] - error = None - if len(hosts) != 1 or hosts[0] not in self.hosts: - error = JSONResponse({"error": "Invalid Host"}, status_code=421) - elif origins: - error = JSONResponse({"error": "Browser origins are not allowed"}, status_code=403) - elif scope["path"] != "/health": - authorization = [value for name, value in headers if name.lower() == b"authorization"] - if len(authorization) != 1 or not hmac.compare_digest(authorization[0], self.authorization): - error = JSONResponse({"error": "Authentication required"}, status_code=401, - headers={"WWW-Authenticate": "Bearer"}) - if error is not None: - await error(scope, receive, send) - return - await self.app(scope, receive, send) diff --git a/package/plugin_pages/operations.md b/package/plugin_pages/operations.md index 52a681e..b665aea 100644 --- a/package/plugin_pages/operations.md +++ b/package/plugin_pages/operations.md @@ -19,20 +19,15 @@ Player builds and other slow work should go through `operation_job_submit`. Poll ## Python client -The Editor regenerates its `infernux-editor` entries as standard stdio proxy -configurations. Valid JSON configurations retain unrelated servers and settings; -old HTTP entries owned by this plugin are replaced. JSONC, malformed JSON and +The Editor regenerates its `infernux-editor` entries as direct streamable-HTTP +configurations pointing at `http://127.0.0.1:9713/mcp`. Valid JSON +configurations retain unrelated servers and settings. JSONC, malformed JSON and non-object documents are left untouched and reported in the Console; other client files still update. Merge the corresponding `connection_info()["clients"]` -configuration into such a file yourself. Restart the client if it was using an old HTTP -configuration. An existing stdio proxy reads the current credential on every -request and remains usable after an Editor restart on the same port. - -The server binds only to loopback and requires bearer authorization. The Python -client reads its credential from the current user's private state directory, -outside the project. Do not copy credentials into client JSON, Git, process -arguments or environment variables. Browser Origin requests are rejected; -`/health` reports readiness only and is not an MCP client endpoint. +configuration into such a file yourself. + +The server binds only to loopback and needs no credential. `/health` reports +readiness only and is not an MCP client endpoint. Use the same Python environment as the Editor. From this plugin checkout, add `package/editor` to `PYTHONPATH` (preserving existing entries). For example in diff --git a/package/plugin_pages/operations.zh-CN.md b/package/plugin_pages/operations.zh-CN.md index b037d93..5008f4d 100644 --- a/package/plugin_pages/operations.zh-CN.md +++ b/package/plugin_pages/operations.zh-CN.md @@ -19,9 +19,9 @@ ## Python 客户端 -编辑器会把它拥有的 `infernux-editor` 配置重新生成为标准 stdio 代理配置。有效 JSON 中的其他服务器和设置会保留,旧的本插件 HTTP 配置会被替换。JSONC、损坏 JSON 或非对象文档不会被覆盖,Console 会报告问题,其他客户端文件仍会更新;这类文件可按 `connection_info()["clients"]` 中的对应配置手动合入。已使用旧 HTTP 配置的客户端需要重启;现有 stdio 代理每次读取当前凭据,编辑器在同端口重启后仍可继续使用。 +编辑器会把它拥有的 `infernux-editor` 配置重新生成为直连 `http://127.0.0.1:9713/mcp` 的 streamable-HTTP 配置。有效 JSON 中的其他服务器和设置会保留。JSONC、损坏 JSON 或非对象文档不会被覆盖,Console 会报告问题,其他客户端文件仍会更新;这类文件可按 `connection_info()["clients"]` 中的对应配置手动合入。 -服务只监听本机,并要求 bearer 认证。Python 客户端会从当前用户的私有状态目录读取凭据,不需要项目文件保存凭据。不要把凭据放进客户端 JSON、Git、进程参数或环境变量。带浏览器 Origin 的请求会被拒绝;`/health` 只报告就绪状态,不能用于 MCP 调用。 +服务只监听本机,不需要凭据。`/health` 只报告就绪状态,不能用于 MCP 调用。 使用编辑器的同一个 Python 环境。在插件源码目录中,把 `package/editor` 加到 `PYTHONPATH`,保留原有条目;Bash 示例:`export PYTHONPATH="$PWD/package/editor${PYTHONPATH:+:$PYTHONPATH}"`。项目中已安装的插件对应路径为 `Packages/infernux/mcp/editor`。 diff --git a/package/plugin_pages/trust.md b/package/plugin_pages/trust.md index 56a4e1f..4be783c 100644 --- a/package/plugin_pages/trust.md +++ b/package/plugin_pages/trust.md @@ -9,6 +9,6 @@ Every call is checked against the operation schema and `ProjectSettings/mcp_capa Screenshots come from the engine's Scene, Game, or composed Editor render targets, never from the desktop. A few short-lived tokens exist for shutting down the Editor, locking the current project, and talking to a Debug Player. Status calls never return the secret itself. -HTTP requests require a per-user bearer credential. The credential lives under the user state directory, never the project. Standard IDE configurations use a stdio proxy which reads the current credential automatically; direct HTTP clients need authorization. Host checks apply to every route and browser Origin headers are rejected. `/health` is a credential-free readiness probe and exposes no project or owner state. +The HTTP endpoint has no authentication: MCP access is directed by the local user, and every capability is granted by default. To restrict an agent, narrow `granted_capabilities` (for example `["*.read"]`). Requests whose Host is not `127.0.0.1`/`localhost`, or whose browser Origin is not a local page, are rejected so a remote web page cannot reach the port through DNS rebinding. -Authenticated development access is trusted access, not a sandbox. Writing project Python or building a Player can execute code with the Editor user's privileges. Capability profiles select the intended workflow; they do not isolate code from that user. +Development access is trusted access, not a sandbox. Writing project Python or building a Player can execute code with the Editor user's privileges. diff --git a/package/plugin_pages/trust.zh-CN.md b/package/plugin_pages/trust.zh-CN.md index 3e38f5b..0b31141 100644 --- a/package/plugin_pages/trust.zh-CN.md +++ b/package/plugin_pages/trust.zh-CN.md @@ -10,6 +10,6 @@ 关编辑器、认准当前项目、跟 Debug Player 说话,各有一个短期口令。状态接口不会把口令原文吐出来。 -HTTP 请求必须携带当前用户的 bearer 凭据。凭据保存在用户状态目录中,不进入项目;IDE 的标准 stdio 代理会自动读取当前凭据,直接连接 HTTP 的客户端需要认证。所有路由都检查 Host,并拒绝带浏览器 Origin 的请求。`/health` 无需凭据,只报告服务是否就绪,不提供项目或所有者信息。 +HTTP 接口不做鉴权:MCP 由本机用户主导,默认授予全部能力。需要限制 Agent 时,把 `granted_capabilities` 改窄即可(例如 `["*.read"]`)。Host 不是 `127.0.0.1`/`localhost`,或带有非本机页面 Origin 的请求会被拒绝,防止外部网页借 DNS rebinding 访问这个端口。 -认证后的开发权限属于可信访问,不是沙箱。编写项目 Python 或构建 Player 可以使用编辑器用户的权限执行代码。能力配置用于选择工作流,不隔离代码和该用户。 +开发权限属于可信访问,不是沙箱。编写项目 Python 或构建 Player 可以使用编辑器用户的权限执行代码。 diff --git a/test/test_client_transport.py b/test/test_client_transport.py index 34db984..b42d201 100644 --- a/test/test_client_transport.py +++ b/test/test_client_transport.py @@ -15,8 +15,6 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "package" / "editor")) from infernux_mcp.client import create_loopback_client -from infernux_mcp.credentials import publish_credentials, remove_credentials -from infernux_mcp.transport_security import EditorTransportSecurity try: from mcp.server.fastmcp import FastMCP @@ -48,11 +46,8 @@ async def slow_query() -> dict[str, object]: cls.sock = socket.socket() cls.sock.bind(("127.0.0.1", 0)) - port = cls.sock.getsockname()[1] - cls.endpoint = f"http://127.0.0.1:{port}/mcp" - _, cls.token = publish_credentials(cls.endpoint) - app = EditorTransportSecurity(mcp.streamable_http_app(), port=port, token=cls.token) - cls.server = uvicorn.Server(uvicorn.Config(app, log_level="error")) + cls.endpoint = f"http://127.0.0.1:{cls.sock.getsockname()[1]}/mcp" + cls.server = uvicorn.Server(uvicorn.Config(mcp.streamable_http_app(), log_level="error")) cls.thread = threading.Thread(target=cls.server.run, kwargs={"sockets": [cls.sock]}, daemon=True) cls.thread.start() deadline = time.monotonic() + 5 @@ -68,7 +63,6 @@ def tearDownClass(cls): cls.sock.close() if cls.thread.is_alive(): raise RuntimeError("Test MCP server did not shut down") - remove_credentials(cls.endpoint, cls.token) def cli(self, *args): env = dict(os.environ)