spawn-cli 0.1.13__tar.gz → 0.1.15__tar.gz

{spawn_cli-0.1.13/src/spawn_cli.egg-info → spawn_cli-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawn-cli
-Version: 0.1.13
+Version: 0.1.15
 Summary: A minimal installable Python CLI package.
 License: MIT
 Classifier: License :: OSI Approved :: MIT License

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spawn-cli"
-version = "0.1.13"
+version = "0.1.15"
 description = "A minimal installable Python CLI package."
 readme = "README.md"
 requires-python = ">=3.10"

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/cli.py

@@ -8,6 +8,7 @@ from spawn_cli import __version__
 from spawn_cli.core import download as dl
 from spawn_cli.core import high_level as hl
 from spawn_cli.core import low_level as ll
+from spawn_cli.core import mcp_stdio
 from spawn_cli.core.errors import SpawnError
 from spawn_cli.ide.registry import DetectResult, detect_supported_ides
 from spawn_cli.io.lock import spawn_lock
@@ -210,7 +211,7 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help=(
             "Fail on issues that default to warnings "
-            "(missing skill files, bad mcp.json, empty file descriptions)."
+            "(missing skill files, invalid extsrc/mcp/*.json, empty file descriptions)."
         ),
     )
 
@@ -298,6 +299,38 @@ def build_parser() -> argparse.ArgumentParser:
         help="Fallback Git revision applied when entries lack branch.",
     )
 
+    mcp_stdio_p = sub.add_parser(
+        "mcp_stdio",
+        help="Run stdio MCP for an extension server (IDE-stable wrapper)",
+        description=(
+            "Resolve the inner stdio command from installed extension MCP JSON for this OS "
+            "and relay MCP traffic on stdin/stdout. Intended as the IDE MCP entrypoint when "
+            "spawn_stdio_proxy is enabled; does not acquire the repository lock."
+        ),
+    )
+    mcp_stdio_l1 = mcp_stdio_p.add_subparsers(dest="mcp_stdio_l1", required=True)
+    mcp_stdio_ext = mcp_stdio_l1.add_parser(
+        "extension",
+        help="Pick installed extension id",
+        description="Extension directory name under spawn/.extend/ (same ids as spawn extension list).",
+    )
+    mcp_stdio_ext.add_argument(
+        "mcp_stdio_extension_id",
+        metavar="EXTENSION_ID",
+        help="Installed extension id (folder under spawn/.extend/).",
+    )
+    mcp_stdio_l2 = mcp_stdio_ext.add_subparsers(dest="mcp_stdio_l2", required=True)
+    mcp_stdio_name = mcp_stdio_l2.add_parser(
+        "name",
+        help="Pick MCP server by declared name",
+        description="Must match servers[].name in mcp/<platform>.json for the current OS.",
+    )
+    mcp_stdio_name.add_argument(
+        "mcp_stdio_server_name",
+        metavar="SERVER_NAME",
+        help="MCP server name from the extension platform MCP file.",
+    )
+
     return parser
 
 
@@ -327,6 +360,9 @@ def _dispatch(args: argparse.Namespace, target_root: Path) -> int:
 
     _require_init(target_root)
 
+    if cmd == "mcp_stdio":
+        return _dispatch_mcp_stdio(args, target_root)
+
     with spawn_lock(target_root):
         if cmd == "rules":
             return _dispatch_rules(args, target_root)
@@ -343,6 +379,12 @@ def _dispatch(args: argparse.Namespace, target_root: Path) -> int:
     return 1
 
 
+def _dispatch_mcp_stdio(args: argparse.Namespace, target_root: Path) -> int:
+    return mcp_stdio.run_mcp_stdio_proxy(
+        target_root, args.mcp_stdio_extension_id, args.mcp_stdio_server_name
+    )
+
+
 def _dispatch_rules(args: argparse.Namespace, target_root: Path) -> int:
     sub = args.rules_command
     if sub == "refresh":

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/core/download.py

@@ -21,7 +21,6 @@ from ruamel.yaml import YAML
 from spawn_cli.core import low_level as ll
 from spawn_cli.core.errors import SpawnError, SpawnWarning
 from spawn_cli.core import scripts
-from spawn_cli.io.json_io import load_json
 from spawn_cli.io.paths import ensure_dir, safe_path
 from spawn_cli.io.yaml_io import load_yaml, save_yaml
 from spawn_cli.models.config import ExtensionConfig, ExtensionsMeta, FileMode, SourceYaml
@@ -128,15 +127,7 @@ def _candidate_norm_skill_names(extsrc_dir: Path) -> list[str]:
 
 
 def _candidate_mcp_server_names(extsrc_dir: Path) -> list[str]:
-    path = extsrc_dir / "mcp.json"
-    if not path.is_file():
-        return []
-    data = load_json(path)
-    names: list[str] = []
-    for s in data.get("servers") or []:
-        if isinstance(s, dict) and s.get("name"):
-            names.append(str(s["name"]))
-    return names
+    return ll.extsrc_mcp_server_names_for_staging(extsrc_dir)
 
 
 def _validate_render_identity_for_new_extension(target_root: Path, new_name: str, extsrc_dir: Path) -> None:

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/core/high_level.py

@@ -10,7 +10,7 @@ from spawn_cli.core import low_level as ll
 from spawn_cli.core import scripts
 from spawn_cli.core.errors import SpawnError, SpawnWarning
 from spawn_cli.ide.registry import IdeCapabilities, get as ide_get
-from spawn_cli.io.json_io import load_json
+from spawn_cli.io.json_io import save_json
 from spawn_cli.io.paths import ensure_dir, safe_path
 from spawn_cli.io.yaml_io import load_yaml, save_yaml
 from spawn_cli.models.config import ExtensionConfig, ReadFlag
@@ -417,6 +417,16 @@ def extension_healthcheck(target_root: Path, extension: str) -> bool:
     return scripts.run_healthcheck_scripts(target_root, extension)
 
 
+def _ensure_empty_mcp_platform_files(extsrc: Path) -> None:
+    mdir = extsrc / "mcp"
+    ensure_dir(mdir)
+    empty: dict = {"servers": []}
+    for stem in ("windows", "linux", "macos"):
+        p = mdir / f"{stem}.json"
+        if not p.is_file():
+            save_json(p, empty)
+
+
 def extension_init(path: Path, name: str) -> None:
     extsrc = path / "extsrc"
     cfg_path = extsrc / "config.yaml"
@@ -429,6 +439,7 @@ def extension_init(path: Path, name: str) -> None:
     ensure_dir(extsrc / "skills")
     ensure_dir(extsrc / "files")
     ensure_dir(extsrc / "setup")
+    _ensure_empty_mcp_platform_files(extsrc)
     template = {
         "name": name,
         "schema": 1,
@@ -475,15 +486,58 @@ def extension_check(path: Path, strict: bool = False) -> list[str]:
                 if strict:
                     raise SpawnError(msg)
                 warnings_out.append(msg)
-    mcp_path = extsrc / "mcp.json"
-    if mcp_path.is_file():
-        try:
-            load_json(mcp_path)
-        except Exception as e:
-            msg = f"mcp.json not parseable: {e}"
+    root_mcp = extsrc / "mcp.json"
+    if root_mcp.is_file():
+        msg = (
+            "obsolete extsrc/mcp.json is not used; remove it and use "
+            "extsrc/mcp/windows.json, linux.json, and macos.json only"
+        )
+        if strict:
+            raise SpawnError(msg)
+        warnings_out.append(msg)
+    mcp_dir = extsrc / "mcp"
+    if not mcp_dir.is_dir():
+        msg = "missing extsrc/mcp/ directory (expected windows.json, linux.json, macos.json)"
+        if strict:
+            raise SpawnError(msg)
+        warnings_out.append(msg)
+    else:
+        paths = ll.extension_mcp_platform_json_paths(extsrc)
+        if not all(p.is_file() for p in paths):
+            missing = [p.name for p in paths if not p.is_file()]
+            msg = f"incomplete extsrc/mcp layout (missing {', '.join(missing)})"
             if strict:
-                raise SpawnError(msg) from e
+                raise SpawnError(msg)
             warnings_out.append(msg)
+        else:
+            name_sets: list[frozenset[str]] = []
+            for p in paths:
+                try:
+                    nm = ll.normalized_mcp_from_mcp_json_path(p, cfg.name or "extension")
+                except Exception as e:
+                    if strict:
+                        raise SpawnError(f"MCP file invalid ({p}): {e}") from e
+                    warnings_out.append(f"MCP file invalid ({p}): {e}")
+                    name_sets = []
+                    break
+                for srv in nm.servers:
+                    if srv.spawn_stdio_proxy and srv.transport.type != "stdio":
+                        msg = (
+                            f"MCP server {srv.name!r} in {p}: spawn_stdio_proxy requires "
+                            f"transport.type 'stdio' (got {srv.transport.type!r})"
+                        )
+                        if strict:
+                            raise SpawnError(msg)
+                        warnings_out.append(msg)
+                name_sets.append(frozenset(s.name for s in nm.servers))
+            if name_sets and len(set(name_sets)) != 1:
+                msg = (
+                    "MCP server names must match across mcp/windows.json, "
+                    "linux.json, and macos.json"
+                )
+                if strict:
+                    raise SpawnError(msg)
+                warnings_out.append(msg)
     if cfg.setup:
         for _phase, rel in (
             ("before-install", cfg.setup.before_install),
@@ -555,6 +609,7 @@ def extension_from_rules(source: str, output_path: Path, name: str, branch: str
         )
         ensure_dir(extsrc / "skills")
         ensure_dir(extsrc / "setup")
+        _ensure_empty_mcp_platform_files(extsrc)
     finally:
         shutil.rmtree(tmp, ignore_errors=True)
 

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/core/low_level.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import re
 import shutil
+import sys
 import time
 import uuid
 import warnings
@@ -22,6 +23,8 @@ from spawn_cli.models.config import CoreConfig, ExtensionConfig, FileMode, IdeLi
 from spawn_cli.models.mcp import McpCapabilities, McpEnvVar, McpServer, McpTransport, NormalizedMcp
 from spawn_cli.models.skill import SkillFileRef, SkillMetadata, SkillRawInfo
 
+MCP_PLATFORM_STEMS: tuple[str, ...] = ("windows", "linux", "macos")
+
 CANONICAL_IDE_KEYS: tuple[str, ...] = (
     "cursor",
     "codex",
@@ -653,14 +656,51 @@ def _parse_mcp_env(env_raw: dict[str, Any]) -> dict[str, McpEnvVar]:
     return out
 
 
+def merged_os_environ_with_mcp_env(
+    base: dict[str, str], mcp_env: dict[str, McpEnvVar]
+) -> dict[str, str]:
+    out = dict(base)
+    for key, spec in mcp_env.items():
+        if spec.value is not None:
+            out[key] = spec.value
+    return out
+
+
 def _mcp_capabilities(raw: dict[str, Any]) -> McpCapabilities:
     c = raw.get("capabilities") or {}
     return McpCapabilities.model_validate(c) if isinstance(c, dict) else McpCapabilities()
 
 
-def list_mcp(target_root: Path, extension: str) -> NormalizedMcp:
-    path = _extend_root(target_root) / extension / "mcp.json"
-    data = load_json(path)
+def mcp_host_platform_stem() -> str:
+    plat = sys.platform
+    if plat == "win32":
+        return "windows"
+    if plat == "darwin":
+        return "macos"
+    if plat.startswith("linux"):
+        return "linux"
+    raise SpawnError(
+        f"unsupported platform for MCP selection: {plat!r} (expected Windows, Linux, or macOS)"
+    )
+
+
+def extension_mcp_platform_json_paths(extension_root: Path) -> tuple[Path, Path, Path]:
+    d = extension_root / "mcp"
+    return tuple(d / f"{s}.json" for s in MCP_PLATFORM_STEMS)
+
+
+def _mcp_spawn_stdio_proxy_from_server(server: dict, path: Path, server_name: str) -> bool:
+    if "spawn_stdio_proxy" not in server:
+        return False
+    v = server["spawn_stdio_proxy"]
+    if isinstance(v, bool):
+        return v
+    raise SpawnError(
+        f"spawn_stdio_proxy must be a boolean for server {server_name!r} in {path}"
+    )
+
+
+def _normalized_mcp_from_loaded(data: dict, path: Path, extension: str) -> NormalizedMcp:
     servers_out: list[McpServer] = []
     for s in data.get("servers") or []:
         if not isinstance(s, dict):
@@ -668,6 +708,8 @@ def list_mcp(target_root: Path, extension: str) -> NormalizedMcp:
         nm = s.get("name")
         if nm is None:
             raise SpawnError(f"missing MCP server name in {path}")
+        str_name = str(nm)
+        spawn_proxy = _mcp_spawn_stdio_proxy_from_server(s, path, str_name)
         tr_raw = s.get("transport") or {}
         transport = McpTransport(
             type=str(tr_raw.get("type", "stdio")),
@@ -680,9 +722,10 @@ def list_mcp(target_root: Path, extension: str) -> NormalizedMcp:
         env = _parse_mcp_env(env_in) if isinstance(env_in, dict) else {}
         servers_out.append(
             McpServer(
-                name=str(nm),
+                name=str_name,
                 extension=extension,
                 transport=transport,
+                spawn_stdio_proxy=spawn_proxy,
                 env=env,
                 capabilities=_mcp_capabilities(s),
             )
@@ -690,6 +733,49 @@ def list_mcp(target_root: Path, extension: str) -> NormalizedMcp:
     return NormalizedMcp(servers=servers_out)
 
 
+def normalized_mcp_from_mcp_json_path(path: Path, extension: str) -> NormalizedMcp:
+    data = load_json(path)
+    return _normalized_mcp_from_loaded(data, path, extension)
+
+
+def list_mcp(target_root: Path, extension: str) -> NormalizedMcp:
+    ext_root = _extend_root(target_root) / extension
+    mcp_dir = ext_root / "mcp"
+    if not mcp_dir.is_dir():
+        return NormalizedMcp(servers=[])
+    stem = mcp_host_platform_stem()
+    path = mcp_dir / f"{stem}.json"
+    if not path.is_file():
+        raise SpawnError(f"missing MCP platform file for this OS: {path}")
+    return normalized_mcp_from_mcp_json_path(path, extension)
+
+
+def extsrc_mcp_server_names_for_staging(extsrc_dir: Path) -> list[str]:
+    """Return sorted MCP server names from extsrc ``mcp/*.json`` or [] if ``mcp/`` is absent.
+
+    When ``mcp/`` exists, all three platform files must be present and declare the same
+    server ``name`` set.
+    """
+    mcp_dir = extsrc_dir / "mcp"
+    if not mcp_dir.is_dir():
+        return []
+    paths = list(extension_mcp_platform_json_paths(extsrc_dir))
+    if not all(p.is_file() for p in paths):
+        missing = [p.name for p in paths if not p.is_file()]
+        raise SpawnError(
+            f"extsrc/mcp layout incomplete (missing {', '.join(missing)}) under {mcp_dir}"
+        )
+    name_sets: list[frozenset[str]] = []
+    for p in paths:
+        nm = normalized_mcp_from_mcp_json_path(p, "_staging")
+        name_sets.append(frozenset(s.name for s in nm.servers))
+    if len(set(name_sets)) != 1:
+        raise SpawnError(
+            "MCP server names must be identical across mcp/windows.json, linux.json, macos.json"
+        )
+    return sorted(name_sets[0])
+
+
 def get_navigation_metadata(target_root: Path, extension: str) -> dict:
     return {
         "required": [x.model_dump(by_alias=True) for x in get_required_read_global(target_root, extension)],
@@ -1205,14 +1291,18 @@ __all__ = [
     "get_required_read_global_all",
     "get_skill_raw_info",
     "init",
+    "extsrc_mcp_server_names_for_staging",
+    "extension_mcp_platform_json_paths",
     "list_extensions",
     "list_ides",
     "list_mcp",
     "list_skills",
+    "mcp_host_platform_stem",
     "sync_core_config_from_defaults",
     "merge_core_and_extension_agent_ignore",
     "METADATA_TEMP_MAX_AGE_SECONDS",
     "normalize_skill_name",
+    "normalized_mcp_from_mcp_json_path",
     "prune_metadata_temp",
     "push_to_global_gitignore",
     "remove_from_global_gitignore",

spawn_cli-0.1.15/src/spawn_cli/core/mcp_stdio.py

@@ -0,0 +1,67 @@
+"""Runtime stdio MCP proxy: resolve server from platform JSON and exec inner command."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from spawn_cli.core.errors import SpawnError
+from spawn_cli.core.low_level import list_extensions, list_mcp, merged_os_environ_with_mcp_env
+
+
+def run_mcp_stdio_proxy(target_root: Path, extension_id: str, server_name: str) -> int:
+    if extension_id not in list_extensions(target_root):
+        raise SpawnError(
+            f"unknown extension {extension_id!r}: install it under spawn/.extend/<id>/ "
+            f"(see: spawn extension list)."
+        )
+
+    nm = list_mcp(target_root, extension_id)
+    srv = next((s for s in nm.servers if s.name == server_name), None)
+    existing = [s.name for s in nm.servers]
+    if srv is None:
+        raise SpawnError(
+            f"unknown MCP server {server_name!r} for extension {extension_id!r}; "
+            f"declared servers: {existing}"
+        )
+
+    if not srv.spawn_stdio_proxy:
+        raise SpawnError(
+            f"MCP server {server_name!r} in extension {extension_id!r} is not enabled for "
+            f"stdio proxy: set \"spawn_stdio_proxy\": true on that server in "
+            f"extsrc/mcp/*.json (then reinstall or refresh)."
+        )
+
+    if srv.transport.type != "stdio":
+        raise SpawnError(
+            f"MCP server {server_name!r} uses transport type {srv.transport.type!r}; "
+            f"spawn mcp_stdio requires type \"stdio\"."
+        )
+
+    cmd = srv.transport.command
+    if not cmd:
+        raise SpawnError(
+            f"MCP server {server_name!r} has no transport.command; "
+            f"fix stdio transport in extension MCP JSON."
+        )
+
+    argv = [cmd, *srv.transport.args]
+    cwd_path = (target_root / srv.transport.cwd).resolve()
+    child_env = merged_os_environ_with_mcp_env(os.environ, srv.env)
+
+    try:
+        with subprocess.Popen(
+            argv,
+            cwd=str(cwd_path),
+            env=child_env,
+            stdin=sys.stdin.buffer,
+            stdout=sys.stdout.buffer,
+            stderr=None,
+            shell=False,
+            bufsize=0,
+        ) as proc:
+            return int(proc.wait())
+    except OSError as e:
+        raise SpawnError(f"failed to start MCP server {server_name!r}: {e}") from e

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/ide/__init__.py

@@ -14,6 +14,7 @@ from .codex import CodexAdapter
 from .cursor import CursorAdapter
 from .gemini_cli import GeminiCliAdapter
 from .github_copilot import GitHubCopilotAdapter
+from .mcp_stdio_argv import mcp_stdio_argv
 from .windsurf import WindsurfAdapter
 from .registry import (
     ALIASES,
@@ -55,6 +56,7 @@ __all__ = [
     "IGNORE_BLOCK_START",
     "IdeAdapter",
     "IdeCapabilities",
+    "mcp_stdio_argv",
     "SPAWN_BLOCK_END",
     "SPAWN_BLOCK_START",
     "StubAdapter",

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/ide/claude_code.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 from spawn_cli.core import low_level as ll
 from spawn_cli.ide import _vacancy as _vac
+from spawn_cli.ide.mcp_stdio_argv import mcp_stdio_argv
 from spawn_cli.ide.registry import (
     DetectResult,
     IdeAdapter,
@@ -24,7 +25,10 @@ from spawn_cli.models.skill import SkillMetadata
 def _build_generic_mcp_entry(server: McpServer) -> dict:
     transport = server.transport
     if transport.type == "stdio":
-        entry: dict = {"command": transport.command, "args": list(transport.args)}
+        if server.spawn_stdio_proxy:
+            entry = {"command": "spawn", "args": mcp_stdio_argv(server.extension, server.name)}
+        else:
+            entry = {"command": transport.command, "args": list(transport.args)}
     elif transport.type in ("streamable-http", "sse"):
         entry = {"type": transport.type, "url": transport.url}
         if transport.headers:

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/ide/codex.py

@@ -6,6 +6,7 @@ import warnings
 from pathlib import Path
 
 from spawn_cli.ide import _vacancy as _vac
+from spawn_cli.ide.mcp_stdio_argv import mcp_stdio_argv
 from spawn_cli.ide.registry import (
     DetectResult,
     IdeAdapter,
@@ -24,8 +25,12 @@ def _build_toml_server_entry(server: McpServer) -> dict:
     transport = server.transport
     entry: dict = {}
     if transport.type == "stdio":
-        entry["command"] = transport.command
-        entry["args"] = list(transport.args)
+        if server.spawn_stdio_proxy:
+            entry["command"] = "spawn"
+            entry["args"] = mcp_stdio_argv(server.extension, server.name)
+        else:
+            entry["command"] = transport.command
+            entry["args"] = list(transport.args)
     else:
         entry["url"] = transport.url
     if server.env:

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/ide/cursor.py

@@ -7,6 +7,7 @@ import warnings
 from pathlib import Path
 
 from spawn_cli.ide import _vacancy as _vac
+from spawn_cli.ide.mcp_stdio_argv import mcp_stdio_argv
 from spawn_cli.ide._helpers import (
     clear_split_agent_ignore_file,
     remove_ignore_block,
@@ -31,7 +32,10 @@ def _build_mcp_server_entry(server: McpServer) -> dict:
     """Convert McpServer to .cursor/mcp.json entry (mcpServers format)."""
     transport = server.transport
     if transport.type == "stdio":
-        entry: dict = {"command": transport.command, "args": transport.args}
+        if server.spawn_stdio_proxy:
+            entry = {"command": "spawn", "args": mcp_stdio_argv(server.extension, server.name)}
+        else:
+            entry = {"command": transport.command, "args": transport.args}
     elif transport.type in ("streamable-http", "sse"):
         entry = {"type": transport.type, "url": transport.url}
         if transport.headers:

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/ide/gemini_cli.py

@@ -7,6 +7,7 @@ import warnings
 from pathlib import Path
 
 from spawn_cli.ide import _vacancy as _vac
+from spawn_cli.ide.mcp_stdio_argv import mcp_stdio_argv
 from spawn_cli.ide._helpers import (
     clear_split_agent_ignore_file,
     remove_ignore_block,
@@ -31,8 +32,12 @@ def _build_gemini_mcp_entry(server: McpServer) -> dict:
     transport = server.transport
     entry: dict = {}
     if transport.type == "stdio":
-        entry["command"] = transport.command
-        entry["args"] = list(transport.args)
+        if server.spawn_stdio_proxy:
+            entry["command"] = "spawn"
+            entry["args"] = mcp_stdio_argv(server.extension, server.name)
+        else:
+            entry["command"] = transport.command
+            entry["args"] = list(transport.args)
     elif transport.type == "streamable-http":
         entry["httpUrl"] = transport.url or ""
         if transport.headers:

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/ide/github_copilot.py

@@ -7,6 +7,7 @@ import warnings
 from pathlib import Path
 
 from spawn_cli.ide import _vacancy as _vac
+from spawn_cli.ide.mcp_stdio_argv import mcp_stdio_argv
 from spawn_cli.ide.registry import (
     DetectResult,
     IdeAdapter,
@@ -31,8 +32,12 @@ def _build_vscode_mcp_entry(server: McpServer) -> tuple[dict, list[dict]]:
 
     if transport.type == "stdio":
         entry["type"] = "stdio"
-        entry["command"] = transport.command
-        entry["args"] = list(transport.args)
+        if server.spawn_stdio_proxy:
+            entry["command"] = "spawn"
+            entry["args"] = mcp_stdio_argv(server.extension, server.name)
+        else:
+            entry["command"] = transport.command
+            entry["args"] = list(transport.args)
     else:
         entry["type"] = transport.type
         entry["url"] = transport.url

spawn_cli-0.1.15/src/spawn_cli/ide/mcp_stdio_argv.py

@@ -0,0 +1,10 @@
+"""Shared argv list for IDE MCP configs that launch ``spawn mcp_stdio``."""
+
+from __future__ import annotations
+
+
+def mcp_stdio_argv(extension_id: str, server_name: str) -> list[str]:
+    return ["mcp_stdio", "extension", extension_id, "name", server_name]
+
+
+__all__ = ["mcp_stdio_argv"]

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli/models/mcp.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import Optional
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, StrictBool
 
 
 class McpEnvVar(BaseModel):
@@ -39,6 +39,7 @@ class McpServer(BaseModel):
     name: str
     extension: str
     transport: McpTransport
+    spawn_stdio_proxy: StrictBool = False
     env: dict[str, McpEnvVar] = Field(default_factory=dict)
     capabilities: McpCapabilities = Field(default_factory=McpCapabilities)
 

{spawn_cli-0.1.13 → spawn_cli-0.1.15/src/spawn_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spawn-cli
-Version: 0.1.13
+Version: 0.1.15
 Summary: A minimal installable Python CLI package.
 License: MIT
 Classifier: License :: OSI Approved :: MIT License

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/src/spawn_cli.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ src/spawn_cli/core/download.py
 src/spawn_cli/core/errors.py
 src/spawn_cli/core/high_level.py
 src/spawn_cli/core/low_level.py
+src/spawn_cli/core/mcp_stdio.py
 src/spawn_cli/core/scripts.py
 src/spawn_cli/ide/__init__.py
 src/spawn_cli/ide/_helpers.py
@@ -26,6 +27,7 @@ src/spawn_cli/ide/codex.py
 src/spawn_cli/ide/cursor.py
 src/spawn_cli/ide/gemini_cli.py
 src/spawn_cli/ide/github_copilot.py
+src/spawn_cli/ide/mcp_stdio_argv.py
 src/spawn_cli/ide/registry.py
 src/spawn_cli/ide/windsurf.py
 src/spawn_cli/io/__init__.py

{spawn_cli-0.1.13 → spawn_cli-0.1.15}/tests/test_cli.py

@@ -349,3 +349,67 @@ def test_spawn_error_exit_code(tmp_path, monkeypatch, capsys):
         assert main(["rules", "refresh"]) == 1
 
     assert "planned failure" in capsys.readouterr().err
+
+
+@contextlib.contextmanager
+def _lock_must_not_be_used(_target_root: Path):
+    raise AssertionError("spawn_lock must not be used for mcp_stdio")
+
+
+def test_spawn_mcp_stdio_parses_nested_argv_fragments(tmp_path, monkeypatch):
+    """Argv may arrive shell-fragmented; argparse still sees one token list."""
+    monkeypatch.chdir(tmp_path)
+    from spawn_cli.core import low_level as ll
+
+    ll.init(tmp_path)
+    root = tmp_path.resolve()
+    mock_run = MagicMock(return_value=0)
+    pieces = (["mcp_stdio", "extension"], ["myext"], ["name"], ["srv_name"])
+    argv = [tok for part in pieces for tok in part]
+
+    with patch("spawn_cli.cli.spawn_lock", _lock_must_not_be_used), patch(
+        "spawn_cli.cli.mcp_stdio.run_mcp_stdio_proxy", mock_run
+    ):
+        assert main(argv) == 0
+
+    mock_run.assert_called_once_with(root, "myext", "srv_name")
+
+
+def test_spawn_mcp_stdio_never_calls_spawn_lock_factory(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    from spawn_cli.core import low_level as ll
+
+    ll.init(tmp_path)
+    root = tmp_path.resolve()
+    lock_factory = MagicMock()
+    mock_run = MagicMock(return_value=0)
+    with patch("spawn_cli.cli.spawn_lock", lock_factory), patch(
+        "spawn_cli.cli.mcp_stdio.run_mcp_stdio_proxy", mock_run
+    ):
+        assert main(["mcp_stdio", "extension", "e1", "name", "n1"]) == 0
+
+    lock_factory.assert_not_called()
+    mock_run.assert_called_once_with(root, "e1", "n1")
+
+
+def test_spawn_mcp_stdio_parses_nested_argv(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    (tmp_path / "spawn").mkdir()
+    root = tmp_path.resolve()
+    mock_run = MagicMock(return_value=0)
+
+    with patch("spawn_cli.cli.spawn_lock", _lock_must_not_be_used), patch(
+        "spawn_cli.cli.mcp_stdio.run_mcp_stdio_proxy", mock_run
+    ):
+        assert main(["mcp_stdio", "extension", "myext", "name", "srv"]) == 0
+
+    mock_run.assert_called_once_with(root, "myext", "srv")
+
+
+def test_spawn_mcp_stdio_help(capsys):
+    with pytest.raises(SystemExit) as exc:
+        main(["mcp_stdio", "--help"])
+    assert exc.value.code == 0
+    out = capsys.readouterr().out
+    assert "mcp_stdio" in out
+    assert "repository lock" in out.lower() or "lock" in out.lower()