evo-cli 0.8.0__tar.gz → 0.9.0__tar.gz

{evo_cli-0.8.0 → evo_cli-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.8.0
+Version: 0.9.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

evo_cli-0.9.0/evo_cli/VERSION

@@ -0,0 +1 @@
+0.9.0

{evo_cli-0.8.0 → evo_cli-0.9.0}/evo_cli/cli.py

@@ -5,6 +5,7 @@ from evo_cli.commands.cloudflare import cfssh
 from evo_cli.commands.fix_claude import f_claude
 from evo_cli.commands.gdrive import gdrive
 from evo_cli.commands.localproxy import localproxy
+from evo_cli.commands.mcp import mcp_group
 from evo_cli.commands.miniconda import miniconda
 from evo_cli.commands.netcheck import netcheck
 from evo_cli.commands.opencode import setup_opencode
@@ -50,6 +51,7 @@ cli.add_command(f_claude)
 cli.add_command(gdrive)
 cli.add_command(site2s)
 cli.add_command(localproxy)
+cli.add_command(mcp_group)
 cli.add_command(netcheck)
 cli.add_command(plantuml)
 cli.add_command(sysmon)

evo_cli-0.9.0/evo_cli/commands/mcp.py

@@ -0,0 +1,234 @@
+"""Set up MCP servers for Claude Code and OpenCode in one shot."""
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import rich_click as click
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from evo_cli.commands.opencode import (
+    get_global_config_path,
+    load_jsonc,
+    save_jsonc,
+)
+from evo_cli.console import console, error, info, run_command, step, success, warning
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo mcp list[/cyan]\n"
+    "  [cyan]evo mcp add notion[/cyan]\n"
+    "  [cyan]evo mcp add notion --claude-only[/cyan]\n"
+    "  [cyan]evo mcp add notion --opencode-only --project .[/cyan]\n"
+    "  [cyan]evo mcp add my-server --url https://example.com/mcp --transport http[/cyan]"
+)
+
+MCP_REGISTRY = {
+    "notion": {
+        "transport": "http",
+        "url": "https://mcp.notion.com/mcp",
+        "description": "Notion workspace - pages, databases, search. OAuth on first use.",
+    },
+    "context7": {
+        "transport": "http",
+        "url": "https://mcp.context7.com/mcp",
+        "description": "Context7 - up-to-date library docs and code examples.",
+    },
+    "deepwiki": {
+        "transport": "sse",
+        "url": "https://mcp.deepwiki.com/sse",
+        "description": "DeepWiki - ask questions about any public GitHub repo.",
+    },
+}
+
+
+def to_opencode_config(spec):
+    if spec["transport"] in ("http", "sse"):
+        config = {"type": "remote", "url": spec["url"], "enabled": True}
+        if spec.get("headers"):
+            config["headers"] = dict(spec["headers"])
+        return config
+    config = {"type": "local", "command": list(spec["command"]), "enabled": True}
+    if spec.get("env"):
+        config["environment"] = dict(spec["env"])
+    return config
+
+
+def claude_has_server(name):
+    result = subprocess.run(
+        ["claude", "mcp", "get", name],
+        capture_output=True,
+        text=True,
+    )
+    return result.returncode == 0
+
+
+def add_to_claude(name, spec, scope):
+    step("Adding to Claude Code")
+    if not shutil.which("claude"):
+        warning("`claude` CLI not found on PATH; skipping Claude Code")
+        info("Install Claude Code, then re-run to register this MCP server")
+        return False
+
+    if claude_has_server(name):
+        info(f"MCP server [accent]{name}[/accent] already in Claude Code; skipping")
+        return True
+
+    cmd = ["claude", "mcp", "add", "--scope", scope]
+    if spec["transport"] in ("http", "sse"):
+        cmd += ["--transport", spec["transport"], name, spec["url"]]
+    else:
+        for key, value in (spec.get("env") or {}).items():
+            cmd += ["-e", f"{key}={value}"]
+        cmd += [name, "--", *spec["command"]]
+    if spec.get("headers"):
+        for key, value in spec["headers"].items():
+            cmd += ["--header", f"{key}: {value}"]
+
+    try:
+        run_command(cmd)
+    except Exception as exc:
+        error(f"Could not add to Claude Code: {exc}")
+        return False
+    success(f"Added [accent]{name}[/accent] to Claude Code ({scope} scope)")
+    info("Run /mcp inside Claude Code to authenticate if the server needs OAuth")
+    return True
+
+
+def add_to_opencode(name, spec, project):
+    step("Adding to OpenCode")
+    server_config = to_opencode_config(spec)
+
+    config_path = get_global_config_path()
+    existing = load_jsonc(config_path) if config_path.exists() else {}
+    mcp = existing.setdefault("mcp", {})
+    if name in mcp:
+        info(f"MCP server [accent]{name}[/accent] already in OpenCode global; skipping")
+    else:
+        mcp[name] = server_config
+        header = "// OpenCode global configuration generated by evo"
+        save_jsonc(config_path, existing, header=header)
+        success(f"Added [accent]{name}[/accent] to OpenCode global config")
+    info(f"Config: [accent]{config_path}[/accent]")
+
+    if project:
+        target = Path(project).resolve()
+        proj_path = target / "opencode.json"
+        proj_existing = load_jsonc(proj_path) if proj_path.exists() else {}
+        proj_mcp = proj_existing.setdefault("mcp", {})
+        if name in proj_mcp:
+            info(f"MCP server [accent]{name}[/accent] already in project config; skipping")
+        else:
+            proj_mcp[name] = server_config
+            header = "// OpenCode project configuration generated by evo"
+            save_jsonc(proj_path, proj_existing, header=header)
+            success(f"Added [accent]{name}[/accent] to project config [accent]{proj_path}[/accent]")
+    return True
+
+
+def resolve_spec(name, url, transport):
+    if url:
+        if transport not in ("http", "sse"):
+            raise click.BadParameter("--transport must be http or sse when using --url")
+        return {"transport": transport, "url": url, "description": "custom"}
+    if name in MCP_REGISTRY:
+        return MCP_REGISTRY[name]
+    raise click.BadParameter(
+        f"Unknown MCP server '{name}'. Run `evo mcp list` to see known servers, or pass --url to add a custom one."
+    )
+
+
+@click.group("mcp", help="Set up MCP servers for Claude Code and OpenCode.")
+def mcp_group():
+    """Register MCP servers across your AI coding tools at once."""
+
+
+@mcp_group.command("list")
+def list_servers():
+    """List the MCP servers bundled in the registry."""
+    table = Table(title="Known MCP servers", title_style="step", expand=False)
+    table.add_column("Name", style="accent")
+    table.add_column("Transport", style="info")
+    table.add_column("Endpoint", style="dim")
+    table.add_column("Description")
+    for name, spec in MCP_REGISTRY.items():
+        endpoint = spec.get("url") or " ".join(spec.get("command", []))
+        table.add_row(name, spec["transport"], endpoint, spec["description"])
+    console.print(table)
+    console.print(
+        "\nAdd one with [accent]evo mcp add <name>[/accent], "
+        "or a custom server with [accent]evo mcp add <name> --url <url>[/accent]."
+    )
+
+
+@mcp_group.command("add", epilog=EPILOG)
+@click.argument("name")
+@click.option("--url", help="Custom remote MCP endpoint (for servers not in the registry).")
+@click.option(
+    "--transport",
+    type=click.Choice(["http", "sse"]),
+    default="http",
+    show_default=True,
+    help="Transport for a custom --url server.",
+)
+@click.option(
+    "--scope",
+    type=click.Choice(["local", "user", "project"]),
+    default="user",
+    show_default=True,
+    help="Claude Code config scope.",
+)
+@click.option("--claude-only", is_flag=True, help="Only configure Claude Code.")
+@click.option("--opencode-only", is_flag=True, help="Only configure OpenCode.")
+@click.option(
+    "--project",
+    type=click.Path(file_okay=False, dir_okay=True),
+    help="Also write into a project-level opencode.json at this directory.",
+)
+def add_server(name, url, transport, scope, claude_only, opencode_only, project):
+    """Add an MCP server to Claude Code and OpenCode.
+
+    NAME is a key from the registry (`evo mcp list`) or any label when paired
+    with --url for a custom remote server. By default the server is registered
+    in both tools; use --claude-only or --opencode-only to limit the scope.
+
+    Remote servers that use OAuth (like notion) prompt for sign-in on first use:
+    run /mcp inside Claude Code, and OpenCode triggers the flow on next launch.
+    """
+    if claude_only and opencode_only:
+        error("--claude-only and --opencode-only are mutually exclusive")
+        return
+
+    try:
+        spec = resolve_spec(name, url, transport)
+    except click.BadParameter as exc:
+        error(str(exc))
+        return
+
+    step(f"evo mcp add {name}")
+    info(spec.get("description", "custom"))
+
+    did_claude = did_opencode = False
+    if not opencode_only:
+        did_claude = add_to_claude(name, spec, scope)
+    if not claude_only:
+        did_opencode = add_to_opencode(name, spec, project)
+
+    console.print()
+    targets = []
+    if did_claude:
+        targets.append("Claude Code")
+    if did_opencode:
+        targets.append("OpenCode")
+    summary = ", ".join(targets) if targets else "no tools (check warnings above)"
+    console.print(
+        Panel(
+            f"MCP server [accent]{name}[/accent] configured for: {summary}.\n\n"
+            "Restart OpenCode and authenticate in Claude Code (/mcp) if prompted.",
+            title="mcp add complete",
+            border_style="success",
+            expand=False,
+        )
+    )

{evo_cli-0.8.0 → evo_cli-0.9.0}/evo_cli/commands/opencode.py

@@ -112,15 +112,29 @@ def ensure_node_installed():
 
 
 def install_mcp_servers():
-    """Install MCP server npm packages globally via npx."""
+    """Pre-fetch MCP server npm packages into the npx cache.
+
+    MCP servers speak JSON-RPC over stdio, so most do not implement a real
+    ``--version`` flag - they simply start up and block reading stdin. Run with
+    stdin detached (DEVNULL) so a server that ignores ``--version`` sees EOF and
+    exits right away instead of hanging on the terminal, and cap each call with a
+    timeout as a safety net. ``check=False`` keeps a non-zero exit from aborting
+    the whole setup; the verify step confirms the servers actually work.
+    """
     step("Installing MCP servers")
     servers = [
         "@mcp-server/google-search-mcp@latest",
         "@playwright/mcp@latest",
     ]
     for server in servers:
-        info(f"Installing {server}")
-        run_command(["npx", "-y", server, "--version"], status=f"Fetching {server}")
+        info(f"Fetching {server}")
+        run_command(
+            ["npx", "-y", server, "--version"],
+            status=f"Fetching {server}",
+            stdin=subprocess.DEVNULL,
+            timeout=180,
+            check=False,
+        )
     success("MCP server packages ready")
 
 
@@ -131,6 +145,8 @@ def install_playwright_browsers():
         run_command(
             ["npx", "playwright", "install", "chromium"],
             status="Downloading Chromium for Playwright",
+            stdin=subprocess.DEVNULL,
+            timeout=600,
         )
         success("Playwright Chromium installed")
     except Exception as exc:
@@ -213,7 +229,7 @@ def configure_opencode_global():
     existing = load_jsonc(config_path) if config_path.exists() else {}
     merged = merge_mcp_config(existing, DEFAULT_MCP_SERVERS)
 
-    header = "// OpenCode global configuration generated by evo setup opencode"
+    header = "// OpenCode global configuration generated by evo"
     save_jsonc(config_path, merged, header=header)
     success(f"Global config written to [accent]{config_path}[/accent]")
     return config_path
@@ -228,7 +244,7 @@ def configure_opencode_project(project_path):
     existing = load_jsonc(config_path) if config_path.exists() else {}
     merged = merge_mcp_config(existing, DEFAULT_MCP_SERVERS)
 
-    header = "// OpenCode project configuration generated by evo setup opencode"
+    header = "// OpenCode project configuration generated by evo"
     save_jsonc(config_path, merged, header=header)
     success(f"Project config written to [accent]{config_path}[/accent]")
     return config_path

{evo_cli-0.8.0 → evo_cli-0.9.0}/evo_cli/console.py

@@ -52,17 +52,31 @@ def step(title):
     console.rule(f"[step]{title}[/step]", style="step", align="left")
 
 
-def run_command(cmd, capture=False, check=True, input_text=None, status=None):
+def run_command(cmd, capture=False, check=True, input_text=None, status=None, timeout=None, stdin=None):
     cmd = [str(part) for part in cmd]
     console.print(f"[cmd]$ {' '.join(cmd)}[/cmd]")
-    if status:
-        with console.status(f"[info]{status}[/info]", spinner="dots"):
-            result = subprocess.run(cmd, capture_output=True, text=True, input=input_text)
-        output = (result.stdout or "").strip()
-        if output:
-            console.print(output)
-    else:
-        result = subprocess.run(cmd, capture_output=capture, text=True, input=input_text)
+
+    run_kwargs = {"text": True, "input": input_text, "timeout": timeout}
+    # subprocess.run rejects passing both `input` and `stdin`. Only attach an
+    # explicit stdin (e.g. DEVNULL) when we are not feeding input, so callers can
+    # detach a child from the terminal and avoid it blocking on an inherited TTY.
+    if input_text is None and stdin is not None:
+        run_kwargs["stdin"] = stdin
+
+    try:
+        if status:
+            with console.status(f"[info]{status}[/info]", spinner="dots"):
+                result = subprocess.run(cmd, capture_output=True, **run_kwargs)
+            output = (result.stdout or "").strip()
+            if output:
+                console.print(output)
+        else:
+            result = subprocess.run(cmd, capture_output=capture, **run_kwargs)
+    except subprocess.TimeoutExpired as exc:
+        console.print(f"[error]command timed out after {timeout}s: {' '.join(cmd)}[/error]")
+        if check:
+            raise CommandError(f"command timed out after {timeout}s: {' '.join(cmd)}") from exc
+        return exc
 
     if result.returncode != 0:
         message = (result.stderr or "").strip()

{evo_cli-0.8.0 → evo_cli-0.9.0}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.8.0
+Version: 0.9.0
 Summary: Evolution CLI - a developer toolbox for setting up dev machines
 Author: maycuatroi
 Project-URL: Homepage, https://github.com/maycuatroi/evo-cli

{evo_cli-0.8.0 → evo_cli-0.9.0}/evo_cli.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ evo_cli/commands/cloudflare.py
 evo_cli/commands/fix_claude.py
 evo_cli/commands/gdrive.py
 evo_cli/commands/localproxy.py
+evo_cli/commands/mcp.py
 evo_cli/commands/miniconda.py
 evo_cli/commands/netcheck.py
 evo_cli/commands/opencode.py
@@ -31,7 +32,9 @@ evo_cli/commands/sysmon.py
 evo_cli/commands/wifi.py
 tests/__init__.py
 tests/test_cli.py
+tests/test_console.py
 tests/test_fix_claude.py
+tests/test_mcp.py
 tests/test_opencode.py
 tests/test_plantuml.py
 tests/test_sysmon.py

evo_cli-0.9.0/tests/test_console.py

@@ -0,0 +1,32 @@
+import subprocess
+import sys
+
+import pytest
+
+from evo_cli.console import CommandError, run_command
+
+
+def test_run_command_raises_on_timeout():
+    # A command that outlives the timeout must not hang; it should raise.
+    with pytest.raises(CommandError, match="timed out"):
+        run_command([sys.executable, "-c", "import time; time.sleep(5)"], timeout=1)
+
+
+def test_run_command_timeout_without_check_returns_exception():
+    result = run_command(
+        [sys.executable, "-c", "import time; time.sleep(5)"],
+        timeout=1,
+        check=False,
+    )
+    assert isinstance(result, subprocess.TimeoutExpired)
+
+
+def test_run_command_detaches_stdin_when_requested():
+    # With stdin=DEVNULL a child that reads stdin sees EOF immediately instead
+    # of blocking on an inherited terminal.
+    result = run_command(
+        [sys.executable, "-c", "import sys; sys.exit(0 if sys.stdin.read() == '' else 1)"],
+        stdin=subprocess.DEVNULL,
+        timeout=10,
+    )
+    assert result.returncode == 0

evo_cli-0.9.0/tests/test_mcp.py

@@ -0,0 +1,88 @@
+import pytest
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+from evo_cli.commands.mcp import resolve_spec, to_opencode_config
+from evo_cli.commands.opencode import load_jsonc
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+def test_mcp_command_is_registered():
+    assert "mcp" in cli.commands
+    assert "add" in cli.commands["mcp"].commands
+    assert "list" in cli.commands["mcp"].commands
+
+
+def test_mcp_list_runs(runner):
+    result = runner.invoke(cli, ["mcp", "list"])
+    assert result.exit_code == 0
+    assert "notion" in result.output
+
+
+def test_to_opencode_config_remote():
+    spec = {"transport": "http", "url": "https://example.com/mcp"}
+    assert to_opencode_config(spec) == {
+        "type": "remote",
+        "url": "https://example.com/mcp",
+        "enabled": True,
+    }
+
+
+def test_to_opencode_config_local():
+    spec = {"transport": "stdio", "command": ["npx", "-y", "thing"]}
+    assert to_opencode_config(spec) == {
+        "type": "local",
+        "command": ["npx", "-y", "thing"],
+        "enabled": True,
+    }
+
+
+def test_resolve_spec_from_registry():
+    spec = resolve_spec("notion", None, "http")
+    assert spec["url"] == "https://mcp.notion.com/mcp"
+
+
+def test_resolve_spec_custom_url():
+    spec = resolve_spec("anything", "https://x.dev/mcp", "http")
+    assert spec["transport"] == "http"
+    assert spec["url"] == "https://x.dev/mcp"
+
+
+def test_resolve_spec_unknown_raises():
+    with pytest.raises(Exception):
+        resolve_spec("nope", None, "http")
+
+
+def test_add_opencode_only_writes_configs(runner, tmp_path, monkeypatch):
+    global_path = tmp_path / "global.jsonc"
+    monkeypatch.setattr(
+        "evo_cli.commands.mcp.get_global_config_path",
+        lambda: global_path,
+    )
+    project = tmp_path / "project"
+    project.mkdir()
+
+    result = runner.invoke(
+        cli,
+        ["mcp", "add", "notion", "--opencode-only", "--project", str(project)],
+    )
+    assert result.exit_code == 0
+    assert load_jsonc(global_path)["mcp"]["notion"]["url"] == "https://mcp.notion.com/mcp"
+    assert load_jsonc(project / "opencode.json")["mcp"]["notion"]["type"] == "remote"
+
+
+def test_add_rejects_both_only_flags(runner, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        "evo_cli.commands.mcp.get_global_config_path",
+        lambda: tmp_path / "global.jsonc",
+    )
+    result = runner.invoke(
+        cli,
+        ["mcp", "add", "notion", "--claude-only", "--opencode-only"],
+    )
+    assert result.exit_code == 0
+    assert "mutually exclusive" in result.output

{evo_cli-0.8.0 → evo_cli-0.9.0}/tests/test_opencode.py

@@ -1,4 +1,5 @@
 import json
+import subprocess
 
 import pytest
 from click.testing import CliRunner
@@ -8,6 +9,7 @@ from evo_cli.commands.opencode import (
     DEFAULT_MCP_SERVERS,
     configure_opencode_global,
     configure_opencode_project,
+    install_mcp_servers,
     load_jsonc,
     merge_mcp_config,
     save_jsonc,
@@ -73,6 +75,24 @@ def test_configure_opencode_project(tmp_path):
     assert set(data["mcp"].keys()) == {"google-search", "playwright"}
 
 
+def test_install_mcp_servers_detaches_stdin_and_sets_timeout(monkeypatch):
+    """Regression: MCP servers read stdin, so the fetch must not block on a TTY."""
+    calls = []
+
+    def fake_run_command(cmd, **kwargs):
+        calls.append((cmd, kwargs))
+
+    monkeypatch.setattr("evo_cli.commands.opencode.run_command", fake_run_command)
+    install_mcp_servers()
+
+    assert calls, "expected at least one MCP server fetch"
+    for cmd, kwargs in calls:
+        assert kwargs.get("stdin") is subprocess.DEVNULL
+        assert kwargs.get("timeout")
+        # A server that ignores --version must not abort the whole setup.
+        assert kwargs.get("check") is False
+
+
 def test_setup_opencode_writes_global_and_project(runner, tmp_path, monkeypatch):
     monkeypatch.setattr(
         "evo_cli.commands.opencode.get_global_config_path",

evo_cli-0.8.0/evo_cli/VERSION

@@ -1 +0,0 @@
-0.8.0