pythinker-code 2.0.0__py3-none-any.whl

pythinker_code/cli/mcp.py

@@ -0,0 +1,349 @@
+import json
+from pathlib import Path
+from typing import Annotated, Any, Literal
+
+import typer
+
+cli = typer.Typer(help="Manage MCP server configurations.")
+
+
+def get_global_mcp_config_file() -> Path:
+    """Get the global MCP config file path."""
+    from pythinker_code.share import get_share_dir
+
+    return get_share_dir() / "mcp.json"
+
+
+def _load_mcp_config() -> dict[str, Any]:
+    """Load MCP config from global mcp config file."""
+    from fastmcp.mcp_config import MCPConfig
+    from pydantic import ValidationError
+
+    mcp_file = get_global_mcp_config_file()
+    if not mcp_file.exists():
+        return {"mcpServers": {}}
+    try:
+        config = json.loads(mcp_file.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as e:
+        raise typer.BadParameter(f"Invalid JSON in MCP config file '{mcp_file}': {e}") from e
+
+    try:
+        MCPConfig.model_validate(config)
+    except ValidationError as e:
+        raise typer.BadParameter(f"Invalid MCP config in '{mcp_file}': {e}") from e
+
+    return config
+
+
+def _save_mcp_config(config: dict[str, Any]) -> None:
+    """Save MCP config to default file."""
+    mcp_file = get_global_mcp_config_file()
+    mcp_file.write_text(json.dumps(config, indent=2, ensure_ascii=False), encoding="utf-8")
+
+
+def _get_mcp_server(name: str, *, require_remote: bool = False) -> dict[str, Any]:
+    """Get MCP server config by name."""
+    config = _load_mcp_config()
+    servers = config.get("mcpServers", {})
+    if name not in servers:
+        typer.echo(f"MCP server '{name}' not found.", err=True)
+        raise typer.Exit(code=1)
+    server = servers[name]
+    if require_remote and "url" not in server:
+        typer.echo(f"MCP server '{name}' is not a remote server.", err=True)
+        raise typer.Exit(code=1)
+    return server
+
+
+def _parse_key_value_pairs(
+    items: list[str], option_name: str, *, separator: str = "=", strip_whitespace: bool = False
+) -> dict[str, str]:
+    """Parse key/value pairs from CLI options."""
+    parsed: dict[str, str] = {}
+    for item in items:
+        if separator not in item:
+            typer.echo(
+                f"Invalid {option_name} format: {item} (expected KEY{separator}VALUE).",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+        key, value = item.split(separator, 1)
+        if strip_whitespace:
+            key, value = key.strip(), value.strip()
+        if not key:
+            typer.echo(f"Invalid {option_name} format: {item} (empty key).", err=True)
+            raise typer.Exit(code=1)
+        parsed[key] = value
+    return parsed
+
+
+Transport = Literal["stdio", "http"]
+
+
+@cli.command(
+    "add",
+    epilog="""
+    Examples:\n
+      \n
+      # Add streamable HTTP server:\n
+      pythinker mcp add --transport http context7 https://mcp.context7.com/mcp --header \"CONTEXT7_API_KEY: ctx7sk-your-key\"\n
+      \n
+      # Add streamable HTTP server with OAuth authorization:\n
+      pythinker mcp add --transport http --auth oauth linear https://mcp.linear.app/mcp\n
+      \n
+      # Add stdio server:\n
+      pythinker mcp add --transport stdio chrome-devtools -- npx chrome-devtools-mcp@latest
+    """.strip(),  # noqa: E501
+)
+def mcp_add(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to add."),
+    ],
+    server_args: Annotated[
+        list[str] | None,
+        typer.Argument(
+            metavar="TARGET_OR_COMMAND...",
+            help="For http: server URL. For stdio: command to run (prefix with `--`).",
+        ),
+    ] = None,
+    transport: Annotated[
+        Transport,
+        typer.Option(
+            "--transport",
+            "-t",
+            help="Transport type for the MCP server. Default: stdio.",
+        ),
+    ] = "stdio",
+    env: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--env",
+            "-e",
+            help="Environment variables in KEY=VALUE format. Can be specified multiple times.",
+        ),
+    ] = None,
+    header: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--header",
+            "-H",
+            help="HTTP headers in KEY:VALUE format. Can be specified multiple times.",
+        ),
+    ] = None,
+    auth: Annotated[
+        str | None,
+        typer.Option(
+            "--auth",
+            "-a",
+            help="Authorization type (e.g., 'oauth').",
+        ),
+    ] = None,
+):
+    """Add an MCP server."""
+    config = _load_mcp_config()
+    server_args = server_args or []
+
+    if transport not in {"stdio", "http"}:
+        typer.echo(f"Unsupported transport: {transport}.", err=True)
+        raise typer.Exit(code=1)
+
+    if transport == "stdio":
+        if not server_args:
+            typer.echo(
+                "For stdio transport, provide the command to start the MCP server after `--`.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+        if header:
+            typer.echo("--header is only valid for http transport.", err=True)
+            raise typer.Exit(code=1)
+        if auth:
+            typer.echo("--auth is only valid for http transport.", err=True)
+            raise typer.Exit(code=1)
+        command, *command_args = server_args
+        server_config: dict[str, Any] = {"command": command, "args": command_args}
+        if env:
+            server_config["env"] = _parse_key_value_pairs(env, "env")
+    else:
+        if env:
+            typer.echo("--env is only supported for stdio transport.", err=True)
+            raise typer.Exit(code=1)
+        if not server_args:
+            typer.echo("URL is required for http transport.", err=True)
+            raise typer.Exit(code=1)
+        if len(server_args) > 1:
+            typer.echo(
+                "Multiple targets provided. Supply a single URL for http transport.",
+                err=True,
+            )
+            raise typer.Exit(code=1)
+        server_config = {"url": server_args[0], "transport": "http"}
+        if header:
+            server_config["headers"] = _parse_key_value_pairs(
+                header, "header", separator=":", strip_whitespace=True
+            )
+        if auth:
+            server_config["auth"] = auth
+
+    if "mcpServers" not in config:
+        config["mcpServers"] = {}
+    config["mcpServers"][name] = server_config
+    _save_mcp_config(config)
+    typer.echo(f"Added MCP server '{name}' to {get_global_mcp_config_file()}.")
+
+
+@cli.command("remove")
+def mcp_remove(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to remove."),
+    ],
+):
+    """Remove an MCP server."""
+    _get_mcp_server(name)
+    config = _load_mcp_config()
+    del config["mcpServers"][name]
+    _save_mcp_config(config)
+    typer.echo(f"Removed MCP server '{name}' from {get_global_mcp_config_file()}.")
+
+
+def _has_oauth_tokens(server_url: str) -> bool:
+    """Check if OAuth tokens exist for the server."""
+    import asyncio
+
+    async def _check() -> bool:
+        try:
+            from fastmcp.client.auth.oauth import FileTokenStorage
+
+            storage = FileTokenStorage(server_url=server_url)
+            tokens = await storage.get_tokens()
+            return tokens is not None
+        except Exception:
+            return False
+
+    return asyncio.run(_check())
+
+
+@cli.command("list")
+def mcp_list():
+    """List all MCP servers."""
+    config_file = get_global_mcp_config_file()
+    config = _load_mcp_config()
+    servers: dict[str, Any] = config.get("mcpServers", {})
+
+    typer.echo(f"MCP config file: {config_file}")
+    if not servers:
+        typer.echo("No MCP servers configured.")
+        return
+
+    for name, server in servers.items():
+        if "command" in server:
+            cmd = server["command"]
+            cmd_args = " ".join(server.get("args", []))
+            line = f"{name} (stdio): {cmd} {cmd_args}".rstrip()
+        elif "url" in server:
+            transport = server.get("transport") or "http"
+            if transport == "streamable-http":
+                transport = "http"
+            line = f"{name} ({transport}): {server['url']}"
+            if server.get("auth") == "oauth" and not _has_oauth_tokens(server["url"]):
+                line += " [authorization required - run: pythinker mcp auth " + name + "]"
+        else:
+            line = f"{name}: {server}"
+        typer.echo(f"  {line}")
+
+
+@cli.command("auth")
+def mcp_auth(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to authorize."),
+    ],
+):
+    """Authorize with an OAuth-enabled MCP server."""
+    import asyncio
+
+    server = _get_mcp_server(name, require_remote=True)
+    if server.get("auth") != "oauth":
+        typer.echo(f"MCP server '{name}' does not use OAuth. Add with --auth oauth.", err=True)
+        raise typer.Exit(code=1)
+
+    async def _auth() -> None:
+        import fastmcp
+
+        typer.echo(f"Authorizing with '{name}'...")
+        typer.echo("A browser window will open for authorization.")
+
+        client = fastmcp.Client({"mcpServers": {name: server}})
+        try:
+            async with client:
+                tools = await client.list_tools()
+                typer.echo(f"Successfully authorized with '{name}'.")
+                typer.echo(f"Available tools: {len(tools)}")
+        except Exception as e:
+            typer.echo(f"Authorization failed: {type(e).__name__}: {e}", err=True)
+            raise typer.Exit(code=1) from None
+
+    asyncio.run(_auth())
+
+
+@cli.command("reset-auth")
+def mcp_reset_auth(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to reset authorization."),
+    ],
+):
+    """Reset OAuth authorization for an MCP server (clear cached tokens)."""
+    server = _get_mcp_server(name, require_remote=True)
+
+    try:
+        from fastmcp.client.auth.oauth import FileTokenStorage
+
+        storage = FileTokenStorage(server_url=server["url"])
+        storage.clear()
+        typer.echo(f"OAuth tokens cleared for '{name}'.")
+    except ImportError:
+        typer.echo("OAuth support not available.", err=True)
+        raise typer.Exit(code=1) from None
+    except Exception as e:
+        typer.echo(f"Failed to clear tokens: {type(e).__name__}: {e}", err=True)
+        raise typer.Exit(code=1) from None
+
+
+@cli.command("test")
+def mcp_test(
+    name: Annotated[
+        str,
+        typer.Argument(help="Name of the MCP server to test."),
+    ],
+):
+    """Test connection to an MCP server and list available tools."""
+    import asyncio
+
+    server = _get_mcp_server(name)
+
+    async def _test() -> None:
+        import fastmcp
+
+        typer.echo(f"Testing connection to '{name}'...")
+        client = fastmcp.Client({"mcpServers": {name: server}})
+
+        try:
+            async with client:
+                tools = await client.list_tools()
+                typer.echo(f"✓ Connected to '{name}'")
+                typer.echo(f"  Available tools: {len(tools)}")
+                if tools:
+                    typer.echo("  Tools:")
+                    for tool in tools:
+                        desc = tool.description or ""
+                        if len(desc) > 50:
+                            desc = desc[:47] + "..."
+                        typer.echo(f"    - {tool.name}: {desc}")
+        except Exception as e:
+            typer.echo(f"✗ Connection failed: {type(e).__name__}: {e}", err=True)
+            raise typer.Exit(code=1) from None
+
+    asyncio.run(_test())

pythinker_code/cli/plugin.py

@@ -0,0 +1,351 @@
+"""CLI commands for plugin management."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+from pythinker_code.plugin import PluginError
+
+cli = typer.Typer(help="Manage plugins.")
+
+
+def _parse_git_url(target: str) -> tuple[str, str | None, str | None]:
+    """Parse a git URL into (clone_url, subpath, branch).
+
+    Splits .git URLs at the .git boundary. For GitHub/GitLab short URLs,
+    treats the first two path segments as owner/repo and the rest as subpath.
+    Strips ``tree/{branch}/`` or ``-/tree/{branch}/`` prefixes from
+    browser-copied URLs and returns the branch name.
+    """
+    # Path 1: URL contains .git followed by / or end-of-string
+    idx = target.find(".git/")
+    if idx == -1 and target.endswith(".git"):
+        return target, None, None
+    if idx != -1:
+        clone_url = target[: idx + 4]  # up to and including ".git"
+        rest = target[idx + 5 :]  # after ".git/"
+        subpath = rest.strip("/") or None
+        return clone_url, subpath, None
+
+    # Path 2: GitHub/GitLab short URL (no .git)
+    from urllib.parse import urlparse
+
+    parsed = urlparse(target)
+    segments = [s for s in parsed.path.split("/") if s]
+    if len(segments) < 2:
+        return target, None, None
+
+    owner_repo = "/".join(segments[:2])
+    clone_url = f"{parsed.scheme}://{parsed.netloc}/{owner_repo}"
+    rest_segments = segments[2:]
+
+    # GitLab uses /-/tree/{branch}/, strip leading "-"
+    if rest_segments and rest_segments[0] == "-":
+        rest_segments = rest_segments[1:]
+
+    # Strip tree/{branch}/ prefix and extract branch
+    branch: str | None = None
+    if len(rest_segments) >= 2 and rest_segments[0] == "tree":
+        branch = rest_segments[1]
+        rest_segments = rest_segments[2:]
+
+    subpath = "/".join(rest_segments) or None
+    return clone_url, subpath, branch
+
+
+def _extract_zip_to_plugin(zip_path: Path, tmp: Path) -> tuple[Path, Path]:
+    """Extract zip_path into tmp and locate the plugin directory.
+
+    Returns ``(plugin_dir, tmp)`` for cleanup by the caller. Rejects zip
+    members whose paths escape ``tmp``. Searches the extraction root and
+    one level deep for ``plugin.json``.
+    """
+    import shutil
+    import zipfile
+
+    try:
+        with zipfile.ZipFile(zip_path, "r") as zf:
+            for member in zf.namelist():
+                member_path = (tmp / member).resolve()
+                if not member_path.is_relative_to(tmp.resolve()):
+                    shutil.rmtree(tmp, ignore_errors=True)
+                    typer.echo(f"Error: zip contains unsafe path: {member}", err=True)
+                    raise typer.Exit(1)
+            zf.extractall(tmp)
+    except zipfile.BadZipFile as exc:
+        shutil.rmtree(tmp, ignore_errors=True)
+        typer.echo(f"Error: invalid zip archive: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+    for candidate in [tmp] + sorted(tmp.iterdir()):
+        if candidate.is_dir() and (candidate / "plugin.json").exists():
+            return candidate, tmp
+    dirs = [d for d in tmp.iterdir() if d.is_dir() and not d.name.startswith("_")]
+    if len(dirs) == 1 and (dirs[0] / "plugin.json").exists():
+        return dirs[0], tmp
+
+    shutil.rmtree(tmp, ignore_errors=True)
+    typer.echo("Error: No plugin.json found in zip", err=True)
+    raise typer.Exit(1)
+
+
+def _resolve_source(target: str) -> tuple[Path, Path | None]:
+    """Resolve plugin source to (local_dir, tmp_to_cleanup).
+
+    Returns the source directory and an optional temp directory that
+    the caller must clean up after use.
+    """
+    import shutil
+    import tempfile
+    from urllib.parse import urlparse
+
+    # HTTP(S) URL pointing to a .zip — download then extract.
+    # Checked before the git-URL branch so GitHub/GitLab archive links
+    # like .../archive/refs/heads/main.zip take this path.
+    parsed = urlparse(target)
+    if parsed.scheme in ("http", "https") and parsed.path.lower().endswith(".zip"):
+        import httpx
+
+        tmp = Path(tempfile.mkdtemp(prefix="pythinker-plugin-"))
+        zip_path = tmp / "_download.zip"
+        typer.echo(f"Downloading {target}...")
+        try:
+            with httpx.stream("GET", target, follow_redirects=True, timeout=60.0) as resp:
+                resp.raise_for_status()
+                with zip_path.open("wb") as f:
+                    for chunk in resp.iter_bytes():
+                        f.write(chunk)
+        except httpx.HTTPError as exc:
+            shutil.rmtree(tmp, ignore_errors=True)
+            typer.echo(f"Error: download failed: {exc}", err=True)
+            raise typer.Exit(1) from exc
+
+        return _extract_zip_to_plugin(zip_path, tmp)
+
+    # Git URL
+    if target.startswith(("https://", "git@", "http://")) and (
+        ".git/" in target
+        or target.endswith(".git")
+        or "github.com/" in target
+        or "gitlab.com/" in target
+    ):
+        import subprocess
+
+        clone_url, subpath, branch = _parse_git_url(target)
+
+        tmp = Path(tempfile.mkdtemp(prefix="pythinker-plugin-"))
+        typer.echo(f"Cloning {clone_url}...")
+        clone_cmd = ["git", "clone", "--depth", "1"]
+        if branch:
+            clone_cmd += ["--branch", branch]
+        clone_cmd += [clone_url, str(tmp / "repo")]
+        result = subprocess.run(
+            clone_cmd,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+        )
+        if result.returncode != 0:
+            shutil.rmtree(tmp, ignore_errors=True)
+            typer.echo(
+                f"Error: git clone failed: {result.stderr.strip()}",
+                err=True,
+            )
+            raise typer.Exit(1)
+
+        repo_root = tmp / "repo"
+
+        if subpath:
+            source = (repo_root / subpath).resolve()
+            if not source.is_relative_to(repo_root.resolve()):
+                shutil.rmtree(tmp, ignore_errors=True)
+                typer.echo(
+                    f"Error: subpath escapes repository: {subpath}",
+                    err=True,
+                )
+                raise typer.Exit(1)
+            if not source.is_dir():
+                shutil.rmtree(tmp, ignore_errors=True)
+                typer.echo(
+                    f"Error: subpath '{subpath}' not found in repository",
+                    err=True,
+                )
+                raise typer.Exit(1)
+            if not (source / "plugin.json").exists():
+                shutil.rmtree(tmp, ignore_errors=True)
+                typer.echo(
+                    f"Error: no plugin.json in '{subpath}'",
+                    err=True,
+                )
+                raise typer.Exit(1)
+            return source, tmp
+
+        # No subpath — check root first
+        if (repo_root / "plugin.json").exists():
+            return repo_root, tmp
+
+        # Scan one level for available plugins
+        available = sorted(
+            d.name for d in repo_root.iterdir() if d.is_dir() and (d / "plugin.json").exists()
+        )
+        if available:
+            names = "\n".join(f"  - {n}" for n in available)
+            typer.echo(
+                f"Error: No plugin.json at repository root. "
+                f"Available plugins:\n{names}\n"
+                f"Use: pythinker plugin install <url>/<plugin-name>",
+                err=True,
+            )
+        else:
+            typer.echo(
+                "Error: No plugin.json found in repository",
+                err=True,
+            )
+        shutil.rmtree(tmp, ignore_errors=True)
+        raise typer.Exit(1)
+
+    p = Path(target).expanduser().resolve()
+
+    # Zip file
+    if p.is_file() and p.suffix == ".zip":
+        tmp = Path(tempfile.mkdtemp(prefix="pythinker-plugin-"))
+        typer.echo(f"Extracting {p.name}...")
+        return _extract_zip_to_plugin(p, tmp)
+
+    # Local directory
+    if p.is_dir():
+        return p, None
+
+    typer.echo(
+        f"Error: {target} is not a directory, zip file, zip URL, or git URL",
+        err=True,
+    )
+    raise typer.Exit(1)
+
+
+@cli.command("install")
+def install_cmd(
+    target: Annotated[
+        str,
+        typer.Argument(help="Plugin source: directory, .zip file, .zip URL, or git URL"),
+    ],
+) -> None:
+    """Install a plugin and inject host configuration."""
+    import shutil
+
+    from pythinker_code.config import load_config
+    from pythinker_code.constant import VERSION
+    from pythinker_code.plugin.manager import get_plugins_dir, install_plugin
+
+    source, tmp_dir = _resolve_source(target)
+
+    try:
+        config = load_config()
+
+        from pythinker_code.auth.oauth import OAuthManager
+        from pythinker_code.llm import augment_provider_with_env_vars
+        from pythinker_code.plugin.manager import collect_host_values
+
+        # Apply env var overrides (install runs outside normal startup)
+        if config.default_model and config.default_model in config.models:
+            model = config.models[config.default_model]
+            if model.provider in config.providers:
+                augment_provider_with_env_vars(
+                    config.providers[model.provider], model, provider_key=model.provider
+                )
+
+        oauth = OAuthManager(config)
+        host_values = collect_host_values(config, oauth)
+
+        if not host_values.get("api_key"):
+            typer.echo(
+                "Warning: No LLM provider configured. "
+                "Plugins requiring API key injection will fail. "
+                "Run 'pythinker login' or configure a provider first.",
+                err=True,
+            )
+
+        spec = install_plugin(
+            source=source,
+            plugins_dir=get_plugins_dir(),
+            host_values=host_values,
+            host_name="pythinker-code",
+            host_version=VERSION,
+        )
+    except PluginError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+    finally:
+        # Clean up temp directory from zip/git extraction
+        if tmp_dir is not None:
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+
+    typer.echo(f"Installed plugin '{spec.name}' v{spec.version}")
+    if spec.runtime:
+        typer.echo(f"  runtime: host={spec.runtime.host}, version={spec.runtime.host_version}")
+
+
+@cli.command("list")
+def list_cmd() -> None:
+    """List installed plugins."""
+    from pythinker_code.plugin.manager import get_plugins_dir, list_plugins
+
+    plugins = list_plugins(get_plugins_dir())
+    if not plugins:
+        typer.echo("No plugins installed.")
+        return
+
+    for p in plugins:
+        status = "installed" if p.runtime else "not configured"
+        typer.echo(f"  {p.name} v{p.version} ({status})")
+
+
+@cli.command("remove")
+def remove_cmd(
+    name: Annotated[str, typer.Argument(help="Plugin name to remove")],
+) -> None:
+    """Remove an installed plugin."""
+    from pythinker_code.plugin.manager import get_plugins_dir, remove_plugin
+
+    try:
+        remove_plugin(name, get_plugins_dir())
+    except PluginError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(f"Removed plugin '{name}'")
+
+
+@cli.command("info")
+def info_cmd(
+    name: Annotated[str, typer.Argument(help="Plugin name")],
+) -> None:
+    """Show plugin details."""
+    from pythinker_code.plugin import parse_plugin_json
+    from pythinker_code.plugin.manager import get_plugins_dir
+
+    plugin_json = get_plugins_dir() / name / "plugin.json"
+    if not plugin_json.exists():
+        typer.echo(f"Error: Plugin '{name}' not found", err=True)
+        raise typer.Exit(1)
+
+    try:
+        spec = parse_plugin_json(plugin_json)
+    except PluginError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+    typer.echo(f"Name:        {spec.name}")
+    typer.echo(f"Version:     {spec.version}")
+    typer.echo(f"Description: {spec.description or '(none)'}")
+    typer.echo(f"Config file: {spec.config_file or '(none)'}")
+    if spec.inject:
+        typer.echo(f"Inject:      {', '.join(f'{k} <- {v}' for k, v in spec.inject.items())}")
+    if spec.runtime:
+        typer.echo(f"Runtime:     host={spec.runtime.host}, version={spec.runtime.host_version}")
+    else:
+        typer.echo("Runtime:     (not installed via host)")