evo-cli 0.7.0__tar.gz → 0.8.1__tar.gz

{evo_cli-0.7.0 → evo_cli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.7.0
+Version: 0.8.1
 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.1/evo_cli/VERSION

@@ -0,0 +1 @@
+0.8.1

{evo_cli-0.7.0 → evo_cli-0.8.1}/evo_cli/cli.py

@@ -7,12 +7,18 @@ from evo_cli.commands.gdrive import gdrive
 from evo_cli.commands.localproxy import localproxy
 from evo_cli.commands.miniconda import miniconda
 from evo_cli.commands.netcheck import netcheck
+from evo_cli.commands.opencode import setup_opencode
 from evo_cli.commands.plantuml import plantuml
 from evo_cli.commands.site2s import site2s
 from evo_cli.commands.ssh import setupssh
 from evo_cli.commands.sysmon import sysmon
 from evo_cli.commands.wifi import wifi
 
+
+@click.group("setup", help="Set up development tools and environments.")
+def setup_group():
+    """Commands for bootstrapping tools on a fresh machine."""
+
 click.rich_click.USE_MARKDOWN = True
 click.rich_click.SHOW_ARGUMENTS = True
 click.rich_click.STYLE_OPTIONS_TABLE_BOX = "SIMPLE"
@@ -34,8 +40,11 @@ def cli():
     """
 
 
-cli.add_command(setupssh)
-cli.add_command(miniconda)
+setup_group.add_command(setup_opencode)
+setup_group.add_command(miniconda)
+setup_group.add_command(setupssh)
+
+cli.add_command(setup_group)
 cli.add_command(cfssh)
 cli.add_command(f_claude)
 cli.add_command(gdrive)

evo_cli-0.8.1/evo_cli/commands/opencode.py

@@ -0,0 +1,339 @@
+"""Install and configure OpenCode with common MCP servers."""
+
+import json
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+
+import rich_click as click
+from rich.panel import Panel
+from rich.text import Text
+
+from evo_cli.console import console, error, info, run_command, step, success, warning
+
+EPILOG = Text.from_markup(
+    "[bold]Examples[/bold]\n\n"
+    "  [cyan]evo setup opencode[/cyan]\n"
+    "  [cyan]evo setup opencode --global-only[/cyan]\n"
+    "  [cyan]evo setup opencode --project .[/cyan]"
+)
+
+DEFAULT_MCP_SERVERS = {
+    "google-search": {
+        "type": "local",
+        "command": ["npx", "-y", "@mcp-server/google-search-mcp@latest"],
+        "enabled": True,
+    },
+    "playwright": {
+        "type": "local",
+        "command": ["npx", "-y", "@playwright/mcp@latest", "--headless"],
+        "enabled": True,
+    },
+}
+
+
+def is_windows():
+    return platform.system() == "Windows"
+
+
+def get_global_config_dir():
+    home = Path.home()
+    if is_windows():
+        return home / "AppData" / "Roaming" / "opencode"
+    return home / ".config" / "opencode"
+
+
+def get_global_config_path():
+    return get_global_config_dir() / "opencode.jsonc"
+
+
+def ensure_node_installed():
+    """Ensure Node.js and npm are available; return their paths."""
+    node_cmd = shutil.which("node")
+    npm_cmd = shutil.which("npm")
+    npx_cmd = shutil.which("npx")
+
+    if node_cmd and npm_cmd and npx_cmd:
+        result = subprocess.run(["node", "--version"], capture_output=True, text=True, check=True)
+        info(f"Node.js found: {result.stdout.strip()}")
+        return node_cmd, npm_cmd, npx_cmd
+
+    info("Node.js/npm not found. Installing via package manager...")
+    system = platform.system()
+    if system == "Linux":
+        try:
+            if shutil.which("apt-get"):
+                run_command(
+                    ["sudo", "apt-get", "update"],
+                    status="Updating apt package lists",
+                )
+                run_command(
+                    ["sudo", "apt-get", "install", "-y", "nodejs", "npm"],
+                    status="Installing nodejs and npm",
+                )
+            elif shutil.which("dnf"):
+                run_command(
+                    ["sudo", "dnf", "install", "-y", "nodejs", "npm"],
+                    status="Installing nodejs and npm",
+                )
+            elif shutil.which("pacman"):
+                run_command(
+                    ["sudo", "pacman", "-Sy", "--noconfirm", "nodejs", "npm"],
+                    status="Installing nodejs and npm",
+                )
+            elif shutil.which("apk"):
+                run_command(
+                    ["sudo", "apk", "add", "nodejs", "npm"],
+                    status="Installing nodejs and npm",
+                )
+            else:
+                raise RuntimeError("No supported package manager found (apt-get, dnf, pacman, apk)")
+        except Exception as exc:
+            error(f"Could not install Node.js automatically: {exc}")
+            info("Please install Node.js 18+ manually from https://nodejs.org/")
+            raise
+    elif system == "Darwin":
+        if shutil.which("brew"):
+            run_command(["brew", "install", "node"], status="Installing Node.js via Homebrew")
+        else:
+            raise RuntimeError("Homebrew not found. Please install Node.js 18+ manually.")
+    elif system == "Windows":
+        raise RuntimeError("Please install Node.js 18+ manually from https://nodejs.org/")
+    else:
+        raise RuntimeError(f"Unsupported platform: {system}")
+
+    node_cmd = shutil.which("node")
+    npm_cmd = shutil.which("npm")
+    npx_cmd = shutil.which("npx")
+    if not (node_cmd and npm_cmd and npx_cmd):
+        raise RuntimeError("Node.js installation succeeded but binaries are not on PATH")
+    return node_cmd, npm_cmd, npx_cmd
+
+
+def install_mcp_servers():
+    """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"Fetching {server}")
+        run_command(
+            ["npx", "-y", server, "--version"],
+            status=f"Fetching {server}",
+            stdin=subprocess.DEVNULL,
+            timeout=180,
+            check=False,
+        )
+    success("MCP server packages ready")
+
+
+def install_playwright_browsers():
+    """Install Playwright Chromium browser binaries."""
+    step("Installing Playwright browsers")
+    try:
+        run_command(
+            ["npx", "playwright", "install", "chromium"],
+            status="Downloading Chromium for Playwright",
+            stdin=subprocess.DEVNULL,
+            timeout=600,
+        )
+        success("Playwright Chromium installed")
+    except Exception as exc:
+        warning(f"Playwright browser install failed: {exc}")
+        info("You can retry later with: npx playwright install chromium")
+
+
+def load_jsonc(path):
+    """Load a JSONC file, stripping // comments.
+
+    Be careful not to truncate URLs that contain '://' inside a JSON string.
+    """
+    path = Path(path)
+    if not path.exists():
+        return {}
+    text = path.read_text(encoding="utf-8")
+    cleaned_lines = []
+    for line in text.splitlines():
+        new_line = []
+        in_string = False
+        escape = False
+        for idx, ch in enumerate(line):
+            if escape:
+                new_line.append(ch)
+                escape = False
+                continue
+            if ch == "\\":
+                new_line.append(ch)
+                escape = True
+                continue
+            if ch == '"':
+                in_string = not in_string
+                new_line.append(ch)
+                continue
+            if not in_string and ch == "/" and idx + 1 < len(line) and line[idx + 1] == "/":
+                break
+            new_line.append(ch)
+        stripped = "".join(new_line).strip()
+        if stripped.startswith("//"):
+            continue
+        cleaned_lines.append("".join(new_line))
+    cleaned = "\n".join(cleaned_lines)
+    if not cleaned.strip():
+        return {}
+    try:
+        return json.loads(cleaned)
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Invalid JSON in {path}: {exc}") from exc
+
+
+def save_jsonc(path, data, header=None):
+    """Save data as pretty-printed JSONC."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    content = json.dumps(data, indent=2, ensure_ascii=False)
+    if header:
+        content = header + "\n" + content
+    path.write_text(content + "\n", encoding="utf-8")
+
+
+def merge_mcp_config(existing, new_servers):
+    """Merge new MCP servers into existing config, preserving user values."""
+    result = dict(existing)
+    mcp = result.setdefault("mcp", {})
+    for name, config in new_servers.items():
+        if name in mcp:
+            info(f"MCP server [accent]{name}[/accent] already configured; skipping")
+            continue
+        mcp[name] = dict(config)
+        success(f"Added MCP server [accent]{name}[/accent]")
+    return result
+
+
+def configure_opencode_global():
+    """Write/update the global OpenCode config with MCP servers."""
+    step("Configuring global OpenCode")
+    config_path = get_global_config_path()
+    config_dir = config_path.parent
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    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"
+    save_jsonc(config_path, merged, header=header)
+    success(f"Global config written to [accent]{config_path}[/accent]")
+    return config_path
+
+
+def configure_opencode_project(project_path):
+    """Write/update a project-level OpenCode config with MCP servers."""
+    step("Configuring project OpenCode")
+    project_dir = Path(project_path).resolve()
+    config_path = project_dir / "opencode.json"
+
+    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"
+    save_jsonc(config_path, merged, header=header)
+    success(f"Project config written to [accent]{config_path}[/accent]")
+    return config_path
+
+
+def verify_mcp_servers():
+    """Run a basic JSON-RPC initialize check against installed MCP servers."""
+    step("Verifying MCP servers")
+    init_message = (
+        '{"jsonrpc":"2.0","id":1,"method":"initialize",'
+        '"params":{"protocolVersion":"2024-11-05","capabilities":{},'
+        '"clientInfo":{"name":"evo-cli","version":"1.0"}}}'
+    )
+    checks = [
+        ("playwright", ["npx", "-y", "@playwright/mcp@latest", "--headless"]),
+        ("google-search", ["npx", "-y", "@mcp-server/google-search-mcp@latest"]),
+    ]
+    for name, cmd in checks:
+        try:
+            result = subprocess.run(
+                cmd,
+                input=init_message,
+                capture_output=True,
+                text=True,
+                timeout=30,
+            )
+            if result.returncode == 0 and '"jsonrpc":"2.0"' in result.stdout:
+                success(f"MCP server [accent]{name}[/accent] responded to initialize")
+            else:
+                warning(f"MCP server [accent]{name}[/accent] did not respond as expected")
+        except Exception as exc:
+            warning(f"Could not verify MCP server [accent]{name}[/accent]: {exc}")
+
+
+def run_setup_opencode(global_only, project):
+    step("evo setup opencode")
+
+    try:
+        ensure_node_installed()
+    except Exception as exc:
+        error(str(exc))
+        return
+
+    install_mcp_servers()
+    install_playwright_browsers()
+
+    global_path = configure_opencode_global()
+    project_path = None
+    if not global_only:
+        target = project or Path.cwd()
+        project_path = configure_opencode_project(target)
+
+    verify_mcp_servers()
+
+    console.print()
+    paths_text = f"Global: [accent]{global_path}[/accent]"
+    if project_path:
+        paths_text += f"\nProject: [accent]{project_path}[/accent]"
+
+    console.print(
+        Panel(
+            f"OpenCode configured with google-search and playwright MCP servers.\n\n{paths_text}\n\n"
+            "Restart OpenCode to load the new MCP tools.",
+            title="setup opencode complete",
+            border_style="success",
+            expand=False,
+        )
+    )
+
+
+@click.command("opencode", epilog=EPILOG)
+@click.option(
+    "--global-only",
+    is_flag=True,
+    help="Only update the global OpenCode config; skip project-level config.",
+)
+@click.option(
+    "--project",
+    type=click.Path(file_okay=False, dir_okay=True, writable=True),
+    help="Project directory to write opencode.json into. Defaults to the current directory.",
+)
+def setup_opencode(global_only, project):
+    """Install Node.js (if needed), OpenCode MCP servers, and write config files.
+
+    This command bootstraps a fresh machine with the same OpenCode + MCP setup
+    used across devices. It installs the google-search and playwright MCP servers,
+    downloads the Playwright Chromium browser, and writes both global
+    (~/.config/opencode/opencode.jsonc) and project-level (opencode.json) configs.
+
+    No credentials are bundled; only public MCP server references are added.
+    """
+    run_setup_opencode(global_only, project)

{evo_cli-0.7.0 → evo_cli-0.8.1}/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.7.0 → evo_cli-0.8.1}/evo_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evo_cli
-Version: 0.7.0
+Version: 0.8.1
 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.7.0 → evo_cli-0.8.1}/evo_cli.egg-info/SOURCES.txt

@@ -23,6 +23,7 @@ evo_cli/commands/gdrive.py
 evo_cli/commands/localproxy.py
 evo_cli/commands/miniconda.py
 evo_cli/commands/netcheck.py
+evo_cli/commands/opencode.py
 evo_cli/commands/plantuml.py
 evo_cli/commands/site2s.py
 evo_cli/commands/ssh.py
@@ -30,7 +31,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_opencode.py
 tests/test_plantuml.py
 tests/test_sysmon.py
 tests/test_wifi.py

{evo_cli-0.7.0 → evo_cli-0.8.1}/tests/test_cli.py

@@ -4,10 +4,16 @@ from evo_cli.cli import cli
 
 
 def test_all_commands_are_registered():
-    for name in ("setupssh", "miniconda", "cfssh", "f-claude"):
+    for name in ("setup", "cfssh", "f-claude"):
         assert name in cli.commands
 
 
+def test_setup_subgroup_commands_are_registered():
+    setup_group = cli.commands["setup"]
+    for name in ("opencode", "miniconda", "setupssh"):
+        assert name in setup_group.commands
+
+
 def test_group_help_runs():
     result = CliRunner().invoke(cli, ["--help"])
     assert result.exit_code == 0
@@ -16,3 +22,8 @@ def test_group_help_runs():
 def test_fix_claude_help_runs():
     result = CliRunner().invoke(cli, ["f-claude", "--help"])
     assert result.exit_code == 0
+
+
+def test_setup_opencode_help_runs():
+    result = CliRunner().invoke(cli, ["setup", "opencode", "--help"])
+    assert result.exit_code == 0

evo_cli-0.8.1/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.8.1/tests/test_opencode.py

@@ -0,0 +1,137 @@
+import json
+import subprocess
+
+import pytest
+from click.testing import CliRunner
+
+from evo_cli.cli import cli
+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,
+)
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+def test_opencode_command_is_registered():
+    assert "setup" in cli.commands
+    assert "opencode" in cli.commands["setup"].commands
+
+
+def test_opencode_help_runs(runner):
+    result = runner.invoke(cli, ["setup", "opencode", "--help"])
+    assert result.exit_code == 0
+    assert "Install Node.js" in result.output or "OpenCode" in result.output
+
+
+def test_load_jsonc_ignores_comments(tmp_path):
+    path = tmp_path / "config.jsonc"
+    path.write_text("// header\n{\"a\": 1}\n// footer")
+    assert load_jsonc(path) == {"a": 1}
+
+
+def test_load_jsonc_missing_file(tmp_path):
+    assert load_jsonc(tmp_path / "nope.jsonc") == {}
+
+
+def test_save_and_load_jsonc(tmp_path):
+    path = tmp_path / "config.jsonc"
+    save_jsonc(path, {"foo": "bar"}, header="// test")
+    data = load_jsonc(path)
+    assert data == {"foo": "bar"}
+    assert path.read_text().startswith("// test")
+
+
+def test_merge_mcp_config_preserves_existing():
+    existing = {"mcp": {"playwright": {"enabled": False}}}
+    merged = merge_mcp_config(existing, DEFAULT_MCP_SERVERS)
+    assert merged["mcp"]["playwright"]["enabled"] is False
+    assert merged["mcp"]["google-search"]["enabled"] is True
+
+
+def test_configure_opencode_global(tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.get_global_config_path",
+        lambda: tmp_path / "opencode" / "opencode.jsonc",
+    )
+    path = configure_opencode_global()
+    data = load_jsonc(path)
+    assert "mcp" in data
+    assert set(data["mcp"].keys()) == {"google-search", "playwright"}
+
+
+def test_configure_opencode_project(tmp_path):
+    path = configure_opencode_project(tmp_path)
+    data = load_jsonc(path)
+    assert "mcp" in data
+    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",
+        lambda: tmp_path / "global.jsonc",
+    )
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.ensure_node_installed",
+        lambda: ("node", "npm", "npx"),
+    )
+    monkeypatch.setattr("evo_cli.commands.opencode.install_mcp_servers", lambda: None)
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.install_playwright_browsers", lambda: None
+    )
+    monkeypatch.setattr("evo_cli.commands.opencode.verify_mcp_servers", lambda: None)
+
+    result = runner.invoke(cli, ["setup", "opencode", "--project", str(tmp_path)])
+    assert result.exit_code == 0
+    assert (tmp_path / "opencode.json").exists()
+    project_data = json.loads((tmp_path / "opencode.json").read_text().split("\n", 1)[1])
+    assert "mcp" in project_data
+
+
+def test_setup_opencode_global_only(runner, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.get_global_config_path",
+        lambda: tmp_path / "global.jsonc",
+    )
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.ensure_node_installed",
+        lambda: ("node", "npm", "npx"),
+    )
+    monkeypatch.setattr("evo_cli.commands.opencode.install_mcp_servers", lambda: None)
+    monkeypatch.setattr(
+        "evo_cli.commands.opencode.install_playwright_browsers", lambda: None
+    )
+    monkeypatch.setattr("evo_cli.commands.opencode.verify_mcp_servers", lambda: None)
+
+    project = tmp_path / "project"
+    project.mkdir()
+    result = runner.invoke(cli, ["setup", "opencode", "--global-only", "--project", str(project)])
+    assert result.exit_code == 0
+    assert not (project / "opencode.json").exists()

evo_cli-0.7.0/evo_cli/VERSION

@@ -1 +0,0 @@
-0.7.0