command-gate 0.2.4__py3-none-any.whl

cgate/cli/main.py

@@ -0,0 +1,115 @@
+"""Top-level command-gate CLI."""
+
+from __future__ import annotations
+
+import sqlite3
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+from cgate import __version__
+from cgate.cli.connections import connections_app
+from cgate.cli.history import history_app
+from cgate.cli.install import install_cmd, maybe_auto_install
+from cgate.cli.mcp import mcp_app
+from cgate.cli.uninstall import uninstall_cmd
+from cgate.cli.update import update_app
+from cgate.cli.watch import watch_app
+from cgate.update import maybe_heal_pending_update
+
+app = typer.Typer(
+    name="cgate",
+    help="Middleware/CLI between AI agents and servers -- IA proposes, human approves.",
+    invoke_without_command=True,
+)
+app.add_typer(connections_app, name="connections")
+app.add_typer(history_app, name="history")
+app.add_typer(mcp_app, name="mcp")
+app.add_typer(update_app, name="update")
+app.add_typer(watch_app, name="watch")
+app.command("install")(install_cmd)
+app.command("uninstall")(uninstall_cmd)
+
+
+def _version_callback(*, value: bool) -> None:
+    if value:
+        typer.echo(f"cgate {__version__}")
+        raise typer.Exit(code=0)
+
+
+@app.callback()
+def root(
+    ctx: typer.Context,
+    *,
+    _version: Annotated[
+        bool,
+        typer.Option(
+            "--version",
+            "-V",
+            callback=_version_callback,
+            is_eager=True,
+            help="Show version and exit.",
+        ),
+    ] = False,
+    unattended: Annotated[
+        bool,
+        typer.Option(
+            "--unattended",
+            help=(
+                "For first-run auto-install only: skip the 'Press Enter to "
+                "close' pause and exit immediately once done. No prompts "
+                "happen either way -- this only controls the pause, for "
+                "scripted/silent deployment."
+            ),
+        ),
+    ] = False,
+) -> None:
+    """Display help or route to a command group.
+
+    A completely bare invocation (no subcommand, no options) used to
+    just print help via Typer's ``no_args_is_help``. Now it first checks
+    whether this is a freshly downloaded binary that isn't installed
+    yet -- if so, ``maybe_auto_install()`` runs the full first-run setup
+    instead, so "download and double-click" is enough on its own. Once
+    properly installed, bare `cgate` goes back to printing help, exactly
+    as before.
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+    if maybe_auto_install(unattended=unattended):
+        return
+    typer.echo(ctx.get_help())
+
+
+def main() -> None:
+    """Run the CLI, turning an uncaught sqlite3.Error into a clean exit.
+
+    Every command opens its own SQLite connection with no shared boundary
+    that catches DB failures; a locked database (another cgate process
+    holding it) or a corrupted file otherwise surfaces as a raw traceback
+    from deep inside whichever command hit it first, instead of a clear
+    message (issue #12). This is the entry point PyInstaller's bundled
+    binary and the pip console-script both call, so it covers every
+    command without needing its own try/except.
+
+    Before dispatching the command, attempt to self-heal a staged update
+    left behind by a previous failed ``update apply``: if ``<binary>.new``
+    is on disk and no other ``cgate.exe`` is alive, we spawn the helper
+    (detached, waiting on our PID) so the swap completes the moment we
+    exit. Fire-and-forget, silent on any condition that prevents it.
+    """
+    maybe_heal_pending_update()
+    try:
+        app()
+    except sqlite3.Error as exc:
+        Console(stderr=True).print(
+            f"[red]cgate's local database is locked or corrupted:[/red] {exc}\n"
+            "[dim]Another cgate process may be holding it, or the file may "
+            "be damaged.[/dim]"
+        )
+        raise SystemExit(1) from exc
+
+
+if __name__ == "__main__":
+    main()

cgate/cli/mcp.py

@@ -0,0 +1,197 @@
+"""Manage cgate MCP server registration and stdio serving."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.rule import Rule
+from rich.table import Table
+
+from cgate.cli._console import should_pause, wait_for_enter
+from cgate.mcp_installer import (
+    CLIENTS,
+    current_binary_command,
+    detect_clients,
+    is_registered,
+    register,
+    unregister,
+)
+
+mcp_app = typer.Typer(
+    help="Manage the MCP server: register with IA clients, run as server."
+)
+console = Console()
+
+
+@mcp_app.command("install")
+def install_cmd(
+    *,
+    yes: Annotated[
+        bool,
+        typer.Option(
+            "--yes", "-y", help="Skip Y/N confirmation per detected client."
+        ),
+    ] = False,
+    dry_run: Annotated[
+        bool,
+        typer.Option(
+            "--dry-run",
+            help="Show what would be done without modifying any config files.",
+        ),
+    ] = False,
+    no_pause: Annotated[
+        bool,
+        typer.Option(
+            "--no-pause",
+            help=(
+                "Skip the 'Press Enter to close' wait at the end. "
+                "Combine with --yes for a fully unattended install."
+            ),
+        ),
+    ] = False,
+) -> None:
+    """Detect IA clients and register cgate's MCP server with each."""
+    clients = detect_clients()
+    if not clients:
+        console.print("[yellow]No IA clients detected.[/yellow]")
+        console.print("Expected config paths under your home:")
+        all_paths = (path for spec in CLIENTS.values() for path in spec.config_paths)
+        for relative in all_paths:
+            console.print(f"  - [dim]~/{relative}[/dim]")
+        return
+
+    console.print(f"Detected {len(clients)} IA client(s):")
+    for client in clients:
+        status = (
+            "[green]registered[/green]"
+            if is_registered(client)
+            else "[red]not registered[/red]"
+        )
+        console.print(
+            f"  - {client.label} [dim]({client.config_path})[/dim] -- {status}"
+        )
+
+    command, args = current_binary_command()
+    console.print(
+        f"\ncgate command to register: [bold]{command}[/bold] {' '.join(args)}"
+    )
+
+    if dry_run:
+        console.print()
+        console.print(Rule("[yellow]DRY RUN -- no changes will be made[/yellow]"))
+        for client in clients:
+            action = "Re-register" if is_registered(client) else "Register"
+            console.print(f"  Would {action} {client.label} -> {client.config_path}")
+        console.print(
+            f"  With command: [bold]{command}[/bold] {' '.join(args)}"
+        )
+        return
+
+    succeeded: list[str] = []
+    skipped: list[str] = []
+    failed: list[tuple[str, str]] = []
+    for client in clients:
+        registered = is_registered(client)
+        prompt = (
+            f"Re-register {client.label}? (updates existing entry)"
+            if registered
+            else f"Register {client.label}?"
+        )
+        if not yes and not typer.confirm(prompt, default=not registered):
+            skipped.append(client.label)
+            continue
+        try:
+            register(client, command, args)
+        except OSError as exc:
+            failed.append((client.label, str(exc)))
+            console.print(f"[red]Failed to write {client.config_path}: {exc}[/red]")
+            continue
+        succeeded.append(client.label)
+        console.print(
+            f"[green]Registered {client.label}.[/green] "
+            "Restart your client to load the new MCP server."
+        )
+
+    console.print()
+    console.print(Rule("Summary"))
+    console.print(f"  [green]Registered: {len(succeeded)}[/green]")
+    if skipped:
+        console.print(
+            f"  [yellow]Skipped:    {len(skipped)}[/yellow]  ({', '.join(skipped)})"
+        )
+    if failed:
+        console.print(
+            f"  [red]Failed:     {len(failed)}[/red]   "
+            f"({', '.join(label for label, _ in failed)})"
+        )
+
+    if should_pause(no_pause):
+        console.print()
+        wait_for_enter()
+
+    if failed:
+        raise typer.Exit(code=1)
+
+
+@mcp_app.command("uninstall")
+def uninstall_cmd(
+    *,
+    yes: Annotated[
+        bool, typer.Option("--yes", "-y", help="Skip confirmation.")
+    ] = False,
+) -> None:
+    """Remove cgate from all detected IA client configs."""
+    clients = [client for client in detect_clients() if is_registered(client)]
+    if not clients:
+        console.print(
+            "[dim]cgate is not registered with any detected IA client.[/dim]"
+        )
+        return
+    write_failed = False
+    for client in clients:
+        if not yes and not typer.confirm(
+            f"Unregister from {client.label}?", default=True
+        ):
+            continue
+        try:
+            _ = unregister(client)
+        except OSError as exc:
+            write_failed = True
+            console.print(f"[red]Failed to write {client.config_path}: {exc}[/red]")
+            continue
+        console.print(f"[green]Unregistered {client.label}.[/green]")
+    if write_failed:
+        raise typer.Exit(code=1)
+
+
+@mcp_app.command("status")
+def status_cmd() -> None:
+    """Show which detected IA clients have cgate registered."""
+    clients = detect_clients()
+    if not clients:
+        console.print(
+            "[dim]No IA clients detected (no Claude Code/opencode/Cursor config files found).[/dim]"
+        )
+        return
+    table = Table(title="cgate MCP registration status")
+    table.add_column("Client", style="bold")
+    table.add_column("Config path")
+    table.add_column("Status")
+    for client in clients:
+        status = (
+            "[green][OK] registered[/green]"
+            if is_registered(client)
+            else "[dim]not registered[/dim]"
+        )
+        table.add_row(client.label, str(client.config_path), status)
+    console.print(table)
+
+
+@mcp_app.command("serve")
+def serve_cmd() -> None:
+    """Run the MCP server on standard input and output for IA clients."""
+    from cgate.mcp_server.server import main as serve_main  # noqa: PLC0415
+
+    serve_main()