ags-cli 0.1.0__py3-none-any.whl

harness/eventbus/inprocess_bus.py

@@ -0,0 +1,85 @@
+"""In-process pub/sub event bus for this daemonless, SQLite-only setup.
+
+The API and the in-process worker share one event loop and process, so events can be
+handed straight from the engine to the SSE endpoint for low-latency live streaming.
+Each run keeps a **buffer** of every event published, so a subscriber that connects
+mid-run (or just after it starts) still receives the full backlog and then the live
+tail — no lost-event race.
+
+The durable ``run_events`` ledger remains the source of truth; this bus is purely the
+live channel."""
+
+from __future__ import annotations
+
+import asyncio
+from collections import OrderedDict
+from collections.abc import AsyncIterator
+
+# Bound memory: retain channels for the most recent runs only. Runs are sequential and
+# small for a single-user local instance, so this is ample for live + brief reconnects.
+_MAX_RUNS = 32
+
+
+class _Channel:
+    __slots__ = ("buffer", "subscribers", "done")
+
+    def __init__(self) -> None:
+        self.buffer: list[dict] = []
+        self.subscribers: set[asyncio.Queue] = set()
+        self.done: bool = False
+
+
+class InProcessEventBus:
+    def __init__(self) -> None:
+        self._runs: OrderedDict[str, _Channel] = OrderedDict()
+
+    def _channel(self, run_id: str) -> _Channel:
+        ch = self._runs.get(run_id)
+        if ch is None:
+            ch = _Channel()
+            self._runs[run_id] = ch
+            while len(self._runs) > _MAX_RUNS:
+                self._runs.popitem(last=False)  # evict oldest
+        else:
+            self._runs.move_to_end(run_id)
+        return ch
+
+    async def publish(self, run_id: str, event: dict) -> None:
+        ch = self._channel(run_id)
+        ch.buffer.append(event)
+        for q in ch.subscribers:
+            q.put_nowait(event)
+
+    async def publish_done(self, run_id: str) -> None:
+        ch = self._channel(run_id)
+        ch.done = True
+        for q in ch.subscribers:
+            q.put_nowait(None)  # terminator sentinel
+
+    async def subscribe(self, run_id: str) -> AsyncIterator[dict]:
+        """Yield the run's buffered backlog, then live events, until done.
+
+        Backlog snapshot and queue registration happen with no ``await`` between them, so
+        they are atomic w.r.t. other coroutines: an event is in exactly one of the two
+        (no loss, no duplicate)."""
+        ch = self._channel(run_id)
+        q: asyncio.Queue = asyncio.Queue()
+        backlog = list(ch.buffer)
+        ch.subscribers.add(q)
+        # If the run already finished, ensure this late subscriber still gets a terminator
+        # (publish_done ran before our queue existed).
+        if ch.done:
+            q.put_nowait(None)
+        try:
+            for event in backlog:
+                yield event
+            while True:
+                event = await q.get()
+                if event is None:  # done
+                    return
+                yield event
+        finally:
+            ch.subscribers.discard(q)
+
+    async def aclose(self) -> None:
+        self._runs.clear()

harness/main.py

@@ -0,0 +1,144 @@
+"""FastAPI application factory."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.responses import RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+
+from harness.api.router import api_router
+from harness.observability.logging import configure_logging, get_logger
+from harness.observability.tracing import setup_tracing
+from harness.settings import get_settings
+
+# Keep background startup compaction tasks alive so they aren't GC'd.
+_startup_tasks: set[asyncio.Task[None]] = set()
+
+
+def _gui_dir() -> Path | None:
+    """The built web GUI, if present. Served at /ui so the GUI and API share an origin.
+    Looked up in order: ``AGS_GUI_DIR`` env → packaged ``harness/_gui`` (in an installed
+    wheel) → repo ``webgui/out`` (dev). Built with ``scripts/build_gui.sh``."""
+    here = Path(__file__).resolve().parent
+    candidates = []
+    if override := os.environ.get("AGS_GUI_DIR"):
+        candidates.append(Path(override))
+    candidates.append(here / "_gui")                       # packaged
+    candidates.append(here.parent / "webgui" / "out")      # repo dev
+    for c in candidates:
+        if (c / "index.html").is_file():
+            return c
+    return None
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    configure_logging()
+    log = get_logger("api")
+    settings = get_settings()
+    log.info("api_starting", env=settings.env)
+    # Ensure the SQLite schema + seed exist so the very first request works with no
+    # manual bootstrap. Idempotent.
+    from harness.bootstrap import init_local
+
+    await init_local()
+    # Reconcile runs left in non-terminal states by a server crash/restart.
+    from harness.db import get_sessionmaker
+    from harness.orchestrator.reconcile import reconcile_interrupted
+    async with get_sessionmaker()() as db:
+        await reconcile_interrupted(db)
+        await db.commit()
+    # Auto-compact old sessions when retention_days is configured (> 0).
+    # Fire-and-forget so a big DELETE doesn't block startup.
+    if settings.retention_days > 0:
+        async def _run_compact() -> None:
+            try:
+                from harness.services.retention import compact_sessions
+                async with get_sessionmaker()() as db:
+                    report = await compact_sessions(db, older_than_days=settings.retention_days)
+                log.info(
+                    "retention_compact_done",
+                    sessions=report.sessions,
+                    events_deleted=report.events_deleted,
+                    older_than_days=settings.retention_days,
+                )
+            except Exception:  # noqa: BLE001
+                log.warning("retention_compact_failed", exc_info=True)
+
+        task = asyncio.create_task(_run_compact())
+        _startup_tasks.add(task)
+        task.add_done_callback(_startup_tasks.discard)
+    # Warm CLI pool: start a repeating idle-reaper task and ensure close_all on shutdown.
+    warm_reaper_task: asyncio.Task | None = None
+    if settings.warm_cli:
+        from harness.adapters.warm_pool import get_warm_pool
+
+        async def _warm_reaper_loop() -> None:
+            while True:
+                await asyncio.sleep(60)
+                try:
+                    await get_warm_pool().reap_idle(max_idle_s=300)
+                except Exception:  # noqa: BLE001
+                    log.warning("warm_reap_failed", exc_info=True)
+
+        warm_reaper_task = asyncio.create_task(_warm_reaper_loop())
+        _startup_tasks.add(warm_reaper_task)
+        warm_reaper_task.add_done_callback(_startup_tasks.discard)
+
+    yield
+
+    if warm_reaper_task is not None:
+        warm_reaper_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await warm_reaper_task
+        from harness.adapters.warm_pool import get_warm_pool
+
+        await get_warm_pool().close_all()
+
+    log.info("api_stopping")
+
+
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title="AgentS",
+        version="0.1.0",
+        summary="Unified interface over Claude Code, Google CLI (agy), and local LLMs.",
+        lifespan=lifespan,
+    )
+
+    # Allow CORS from Tauri apps
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["http://localhost:3000", "tauri://localhost", "http://tauri.localhost"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.include_router(api_router)
+    setup_tracing(app)
+
+    gui_dir = _gui_dir()
+    if gui_dir is not None:
+        # Serve the built GUI at /ui (same origin as the API) and send / there.
+        app.mount("/ui", StaticFiles(directory=str(gui_dir), html=True), name="ui")
+
+        @app.get("/")
+        async def root() -> RedirectResponse:
+            return RedirectResponse(url="/ui/")
+    else:
+        @app.get("/")
+        async def root() -> dict:
+            return {"service": "ags", "version": "0.1.0", "docs": "/docs", "gui": "not built"}
+
+    return app
+
+
+app = create_app()

harness/mcp/__init__.py

@@ -0,0 +1,22 @@
+"""MCP (Model Context Protocol) tools integration.
+
+Lets harness agents call external MCP servers. Two paths share one server registry:
+
+* CLI adapters (claude/agy) are their own MCP clients — :mod:`harness.mcp.config_gen`
+  emits the native config they consume.
+* the OpenAI-compatible adapter has no MCP — :class:`harness.mcp.registry.McpManager`
+  is the in-process client that lists tools and dispatches calls.
+"""
+
+from harness.mcp.registry import McpManager, resolve_servers, server_to_dict
+from harness.mcp.tools import McpTool, is_mcp_tool, namespaced_name, parse_namespaced
+
+__all__ = [
+    "McpManager",
+    "McpTool",
+    "is_mcp_tool",
+    "namespaced_name",
+    "parse_namespaced",
+    "resolve_servers",
+    "server_to_dict",
+]

harness/mcp/client.py

@@ -0,0 +1,139 @@
+"""Async MCP client wrapper over the official ``mcp`` Python SDK.
+
+One :class:`McpClient` owns a single live connection to one MCP server (stdio
+subprocess or remote streamable-HTTP). The ``mcp`` SDK is imported lazily inside
+:meth:`connect` so the harness installs and runs without it; a server configured
+when the SDK is absent fails with a clear, actionable error rather than at import.
+
+Secrets are resolved here (via ``secret_ref``) into the child env / Authorization
+header and never persisted. stdio servers are launched in their own process group
+by the SDK's ``stdio_client``; closing the client tears the subprocess down.
+"""
+
+from __future__ import annotations
+
+import os
+from contextlib import AsyncExitStack
+
+from harness.mcp.tools import McpTool
+from harness.observability.logging import get_logger
+from harness.security.secrets import resolve_secret_ref
+
+log = get_logger("mcp-client")
+
+
+class McpUnavailable(RuntimeError):
+    """Raised when an MCP server is configured but cannot be used (SDK missing or
+    connection failed). Callers degrade gracefully — the run continues without the
+    server's tools."""
+
+
+class McpClient:
+    """Live connection to one MCP server. Use as an async context manager or call
+    :meth:`connect` / :meth:`aclose` explicitly."""
+
+    def __init__(self, server: dict) -> None:
+        # ``server`` is a plain dict (see registry.server_to_dict) so this class is
+        # decoupled from the ORM and trivially testable.
+        self.cfg = server
+        self.name: str = server["name"]
+        self._stack: AsyncExitStack | None = None
+        self._session = None  # mcp.ClientSession once connected
+
+    async def __aenter__(self) -> McpClient:
+        await self.connect()
+        return self
+
+    async def __aexit__(self, *exc) -> None:
+        await self.aclose()
+
+    async def connect(self) -> None:
+        try:
+            from mcp import ClientSession
+        except ImportError as e:  # SDK not installed
+            raise McpUnavailable(
+                f"MCP server {self.name!r} configured but the 'mcp' package is not "
+                "installed. Add it to the environment to enable MCP tools."
+            ) from e
+
+        stack = AsyncExitStack()
+        try:
+            read, write = await self._open_transport(stack)
+            session = await stack.enter_async_context(ClientSession(read, write))
+            await session.initialize()
+        except McpUnavailable:
+            await stack.aclose()
+            raise
+        except Exception as e:  # connection / handshake failure
+            await stack.aclose()
+            raise McpUnavailable(f"MCP server {self.name!r} failed to connect: {e}") from e
+        self._stack = stack
+        self._session = session
+
+    async def _open_transport(self, stack: AsyncExitStack):
+        transport = self.cfg.get("transport", "stdio")
+        if transport == "stdio":
+            from mcp import StdioServerParameters
+            from mcp.client.stdio import stdio_client
+
+            env = {**os.environ, **(self.cfg.get("env") or {})}
+            if (token := resolve_secret_ref(self.cfg.get("secret_ref"))):
+                # Convention: expose the resolved secret to a stdio server as MCP_TOKEN
+                # unless the server's own env already names it.
+                env.setdefault("MCP_TOKEN", token)
+            params = StdioServerParameters(
+                command=self.cfg["command"],
+                args=self.cfg.get("args") or [],
+                env=env,
+            )
+            return await stack.enter_async_context(stdio_client(params))
+        if transport == "http":
+            from mcp.client.streamable_http import streamablehttp_client
+
+            headers = dict(self.cfg.get("headers") or {})
+            if (token := resolve_secret_ref(self.cfg.get("secret_ref"))):
+                headers.setdefault("Authorization", f"Bearer {token}")
+            # streamablehttp_client yields (read, write, *_); take the first two.
+            ctx = await stack.enter_async_context(
+                streamablehttp_client(self.cfg["url"], headers=headers)
+            )
+            return ctx[0], ctx[1]
+        raise McpUnavailable(f"MCP server {self.name!r}: unknown transport {transport!r}")
+
+    async def list_tools(self) -> list[McpTool]:
+        if self._session is None:
+            raise McpUnavailable(f"MCP server {self.name!r} not connected")
+        resp = await self._session.list_tools()
+        return [
+            McpTool(
+                server=self.name,
+                name=t.name,
+                description=t.description or "",
+                input_schema=getattr(t, "inputSchema", None),
+            )
+            for t in resp.tools
+        ]
+
+    async def call_tool(self, tool: str, args: dict) -> str:
+        if self._session is None:
+            raise McpUnavailable(f"MCP server {self.name!r} not connected")
+        result = await self._session.call_tool(tool, args or {})
+        return _result_text(result)
+
+    async def aclose(self) -> None:
+        if self._stack is not None:
+            try:
+                await self._stack.aclose()
+            except Exception as e:  # never let cleanup failures escape
+                log.warning("mcp_close_failed", server=self.name, error=str(e))
+        self._stack = None
+        self._session = None
+
+
+def _result_text(result) -> str:
+    """Flatten an MCP ``CallToolResult`` content list into text for the ledger."""
+    parts: list[str] = []
+    for block in getattr(result, "content", None) or []:
+        text = getattr(block, "text", None)
+        parts.append(text if text is not None else str(block))
+    return "\n".join(parts)

harness/mcp/config_gen.py

@@ -0,0 +1,77 @@
+"""Generate native MCP config for the CLI adapters (claude / agy).
+
+These CLIs are their own MCP clients — the harness only has to hand them a config
+file and the right flags. The builders below are pure (dict in, dict out) so they
+are unit-testable without touching disk; :func:`write_json` persists one into a
+per-run directory the adapter passes via ``--mcp-config``.
+
+Secrets ARE resolved into the generated file (the CLI needs the live token), so the
+file is written under a run-scoped dir with 0600 and removed when the run ends.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+from pathlib import Path
+
+from harness.mcp.tools import PREFIX, SEP, namespaced_name
+from harness.security.secrets import resolve_secret_ref
+
+
+def _entry(server: dict) -> dict:
+    """One server's entry in a ``mcpServers`` map (Claude/agy shared shape)."""
+    transport = server.get("transport", "stdio")
+    token = resolve_secret_ref(server.get("secret_ref"))
+    if transport == "http":
+        headers = dict(server.get("headers") or {})
+        if token:
+            headers.setdefault("Authorization", f"Bearer {token}")
+        return {"type": "http", "url": server["url"], "headers": headers}
+    # stdio
+    env = dict(server.get("env") or {})
+    if token:
+        env.setdefault("MCP_TOKEN", token)
+    entry: dict = {"command": server["command"], "args": server.get("args") or []}
+    if env:
+        entry["env"] = env
+    return entry
+
+
+def claude_mcp_config(servers: list[dict]) -> dict:
+    """``.mcp.json`` body for the Claude CLI (``{"mcpServers": {...}}``)."""
+    return {"mcpServers": {s["name"]: _entry(s) for s in servers}}
+
+
+def antigravity_mcp_config(servers: list[dict]) -> dict:
+    """MCP config body for agy. agy's exact schema must be verified against the pinned
+    CLI; it follows the widespread ``{"mcpServers": {...}}`` convention, so we emit that
+    and let the adapter point agy at it via its config mechanism."""
+    return claude_mcp_config(servers)
+
+
+def allowed_tool_patterns(servers: list[dict]) -> list[str]:
+    """``--allowedTools`` entries so the CLI may call the tools without prompting.
+
+    Empty allowlist ⇒ allow the whole server (``mcp__<server>``); otherwise one
+    ``mcp__<server>__<tool>`` per allowed tool."""
+    patterns: list[str] = []
+    for s in servers:
+        allow = s.get("tool_allowlist") or []
+        if not allow:
+            patterns.append(f"{PREFIX}{SEP}{s['name']}")
+        else:
+            patterns.extend(namespaced_name(s["name"], t) for t in allow)
+    return patterns
+
+
+def write_json(obj: dict, directory: str | Path, filename: str = "mcp.json") -> str:
+    """Write ``obj`` as JSON (0600) under ``directory`` and return the path."""
+    d = Path(directory)
+    d.mkdir(parents=True, exist_ok=True)
+    path = d / filename
+    path.write_text(json.dumps(obj, indent=2))
+    with contextlib.suppress(OSError):
+        os.chmod(path, 0o600)
+    return str(path)

harness/mcp/registry.py

@@ -0,0 +1,156 @@
+"""Resolve which MCP servers apply to a run and drive them as a unit.
+
+Two entry points:
+
+* :func:`resolve_servers` — DB-backed: given a run's workspace/provider/mode, return
+  the plain-dict definitions of the MCP servers that should be offered (applying
+  ``enabled``, ``bind``, and read-only gating). The engine attaches these to the
+  ``SessionContext`` so every adapter can act on them (CLI adapters generate native
+  config; the OpenAI adapter spins up an in-process client).
+* :class:`McpManager` — the in-process MCP client used by the OpenAI-compatible
+  adapter: connects the resolved servers, exposes their tools as OpenAI specs, and
+  dispatches namespaced tool calls back to the owning server (redacting results).
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from harness.mcp.client import McpClient, McpUnavailable
+from harness.mcp.tools import McpTool, parse_namespaced, to_openai_specs
+from harness.memory.redact import redact
+from harness.models.mcp_server_config import McpServerConfig
+from harness.observability.logging import get_logger
+
+log = get_logger("mcp-registry")
+
+
+def server_to_dict(row: McpServerConfig) -> dict:
+    """Serialize an ORM row to the transport-agnostic dict the client/config-gen use.
+    The secret is NOT resolved here — only the ``secret_ref`` travels, so secrets stay
+    out of the SessionContext and event ledger."""
+    return {
+        "name": row.name,
+        "transport": row.transport.value,
+        "command": row.command,
+        "args": row.args or [],
+        "env": row.env or {},
+        "url": row.url,
+        "headers": row.headers or {},
+        "secret_ref": row.secret_ref,
+        "tool_allowlist": row.tool_allowlist or [],
+        "read_only": bool(row.read_only),
+    }
+
+
+def _binds(server: dict, *, workspace_slug: str, provider: str) -> bool:
+    bind = server.get("bind") or {}
+    ws = bind.get("workspaces") or []
+    pv = bind.get("providers") or []
+    return (not ws or workspace_slug in ws) and (not pv or provider in pv)
+
+
+def filter_servers(
+    servers: list[dict], *, workspace_slug: str, provider: str, read_only: bool
+) -> list[dict]:
+    """Keep servers bound to this workspace+provider; in a read-only/plan run only
+    servers explicitly marked ``read_only`` are kept (write-capable tools are withheld
+    until the run is in write mode / the approval gate clears them)."""
+    out = []
+    for s in servers:
+        if not _binds(s, workspace_slug=workspace_slug, provider=provider):
+            continue
+        if read_only and not s.get("read_only"):
+            continue
+        out.append(s)
+    return out
+
+
+async def load_enabled_servers(db: AsyncSession) -> list[dict]:
+    """All enabled MCP servers as dicts (with ``bind`` attached). Queried once per
+    session execution — the engine then filters per node in-memory via
+    :func:`filter_servers`, keeping concurrent node fan-out free of DB access."""
+    rows = (
+        await db.execute(select(McpServerConfig).where(McpServerConfig.enabled.is_(True)))
+    ).scalars().all()
+    servers = []
+    for r in rows:
+        s = server_to_dict(r)
+        # bind lives on the row; attach it for filter_servers (kept off the transport
+        # dict so server_to_dict stays purely about *reaching* the server).
+        s["bind"] = r.bind or {}
+        servers.append(s)
+    return servers
+
+
+async def resolve_servers(
+    db: AsyncSession, *, workspace_slug: str, provider: str, read_only: bool
+) -> list[dict]:
+    """DB-backed resolution of the MCP servers offered to one run."""
+    return filter_servers(
+        await load_enabled_servers(db),
+        workspace_slug=workspace_slug,
+        provider=provider,
+        read_only=read_only,
+    )
+
+
+class McpManager:
+    """In-process MCP client manager for a single run (OpenAI adapter path).
+
+    Lifecycle is owned by the caller: ``connect()`` once, use ``specs`` / ``dispatch``
+    during the agentic loop, then ``aclose()``. Connection failures are non-fatal —
+    an unreachable server is logged and simply contributes no tools."""
+
+    def __init__(self, servers: list[dict]) -> None:
+        self._servers = servers
+        self._clients: dict[str, McpClient] = {}
+        self._allowlist: dict[str, list[str]] = {
+            s["name"]: (s.get("tool_allowlist") or []) for s in servers
+        }
+
+    async def connect(self) -> None:
+        for s in self._servers:
+            client = McpClient(s)
+            try:
+                await client.connect()
+            except McpUnavailable as e:
+                log.warning("mcp_server_unavailable", server=s["name"], error=str(e))
+                continue
+            self._clients[s["name"]] = client
+
+    async def specs(self) -> list[dict]:
+        """OpenAI ``tools`` specs across every connected server (allowlist applied)."""
+        tools: list[McpTool] = []
+        for name, client in self._clients.items():
+            try:
+                tools.extend(await client.list_tools())
+            except McpUnavailable as e:
+                log.warning("mcp_list_tools_failed", server=name, error=str(e))
+        return to_openai_specs(tools, self._allowlist)
+
+    async def dispatch(self, name: str, args: dict) -> tuple[str, bool]:
+        """Route a namespaced tool call to its server. Returns ``(output, is_error)``;
+        output is redacted before it can reach the ledger."""
+        parsed = parse_namespaced(name)
+        if parsed is None:
+            return f"error: not an MCP tool: {name!r}", True
+        server, tool = parsed
+        client = self._clients.get(server)
+        if client is None:
+            return f"error: MCP server {server!r} not connected", True
+        if (al := self._allowlist.get(server)) and tool not in al:
+            return f"error: tool {tool!r} not in allowlist for {server!r}", True
+        try:
+            out = await client.call_tool(tool, args)
+        except McpUnavailable as e:
+            return f"error: {e}", True
+        except Exception as e:  # tool execution error from the server
+            return f"error: MCP tool {name!r} failed: {e}", True
+        return redact(out)[0], False
+
+    async def aclose(self) -> None:
+        for client in self._clients.values():
+            await client.aclose()
+        self._clients.clear()