ags-cli 0.1.0__py3-none-any.whl

harness/adapters/probe.py

@@ -0,0 +1,65 @@
+"""Probe a CLI binary's --version and --help once; cache by (path, version)."""
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from pathlib import Path
+
+from harness_sdk.cli_base import resolve_binary
+
+_FLAG_RE = re.compile(r"(--[a-z][a-z0-9-]+)")
+
+
+def _cache_path() -> Path:
+    """Get cache path, respecting HOME env var (for test monkeypatching)."""
+    return Path.home() / ".ags" / "cli_probe.json"
+
+
+async def _capture(argv: list[str]) -> str:
+    # Python 3.12: asyncio.TimeoutError is builtin TimeoutError
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *argv, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.STDOUT,
+        )
+    except OSError:
+        return ""
+    try:
+        out, _ = await asyncio.wait_for(proc.communicate(), timeout=10)
+        return out.decode(errors="replace")
+    except TimeoutError:
+        try:
+            proc.kill()
+        except ProcessLookupError:
+            pass
+        return ""
+
+
+async def probe_cli(binary: str) -> dict:
+    # Resolve via PATH + common install dirs so an installed-but-off-PATH CLI probes OK.
+    path = resolve_binary(binary)
+    if not Path(path).exists():
+        return {"version": None, "flags": set(), "ok": False}
+    version = (await _capture([path, "--version"])).strip().splitlines()[0:1]
+    version = version[0] if version else None
+    cache = {}
+    cache_file = _cache_path()
+    if cache_file.exists():
+        try:
+            cache = json.loads(cache_file.read_text())
+        except json.JSONDecodeError:
+            cache = {}
+    key = f"{path}::{version}"
+    if key in cache:
+        return {"version": version, "flags": set(cache[key]), "ok": True}
+    help_text = await _capture([path, "--help"])
+    flags = set(_FLAG_RE.findall(help_text))
+    cache[key] = sorted(flags)
+    cache_file.parent.mkdir(parents=True, exist_ok=True)
+    cache_file.write_text(json.dumps(cache, indent=1))
+    cache_file.chmod(0o600)
+    return {"version": version, "flags": flags, "ok": True}
+
+
+def supports_flag(probe: dict, flag: str) -> bool:
+    return probe.get("ok", False) and flag in probe.get("flags", set())

harness/adapters/registry.py

@@ -0,0 +1,56 @@
+"""Adapter registry — maps ``AdapterKind`` to concrete classes and builds adapter
+instances from a ``ProviderConfig`` row, resolving ``secret_ref`` at construction.
+
+This is the only place that knows about every concrete adapter; the orchestrator
+asks the registry for an adapter by provider name and depends solely on
+``BaseAdapter``. New adapters register here via ``register``."""
+
+from __future__ import annotations
+
+from harness_sdk.base import AdapterConfig, BaseAdapter
+
+from harness.adapters.antigravity import AntigravityCliAdapter
+from harness.adapters.claude_code import ClaudeCodeAdapter
+from harness.adapters.local_openai import OpenAICompatibleLocalAdapter
+from harness.adapters.mock import MockAdapter
+from harness.models.enums import AdapterKind
+from harness.models.provider_config import ProviderConfig
+from harness.security.secrets import resolve_secret_ref
+
+_REGISTRY: dict[AdapterKind, type[BaseAdapter]] = {
+    AdapterKind.mock: MockAdapter,
+    AdapterKind.openai_local: OpenAICompatibleLocalAdapter,
+    AdapterKind.claude_code: ClaudeCodeAdapter,
+    AdapterKind.antigravity: AntigravityCliAdapter,
+}
+
+
+def register(kind: AdapterKind, cls: type[BaseAdapter]) -> None:
+    """Extension hook for new adapter kinds (Bedrock, Vertex, Azure, custom…)."""
+    _REGISTRY[kind] = cls
+
+
+def adapter_class_for(kind: AdapterKind) -> type[BaseAdapter]:
+    if kind not in _REGISTRY:
+        raise KeyError(f"No adapter registered for kind={kind!r}")
+    return _REGISTRY[kind]
+
+
+def build_adapter(pc: ProviderConfig) -> BaseAdapter:
+    """Instantiate an adapter from a persisted provider config. The secret is
+    resolved into process memory only — never written back to the row."""
+    cfg = AdapterConfig(
+        name=pc.name,
+        kind=pc.kind,
+        base_url=pc.base_url,
+        model=pc.model,
+        api_key=resolve_secret_ref(pc.secret_ref),
+        params=pc.params or {},
+        capabilities=pc.capabilities or {},
+    )
+    return adapter_class_for(pc.kind)(cfg)
+
+
+def build_adapter_from_config(cfg: AdapterConfig) -> BaseAdapter:
+    """Build directly from an in-memory config (used by tests and CLI probes)."""
+    return adapter_class_for(cfg.kind)(cfg)

harness/adapters/warm_pool.py

@@ -0,0 +1,255 @@
+"""Warm persistent claude process pool (experimental, HARNESS_WARM_CLI=1).
+
+Verified CLI contract (claude 2.1.190, tested empirically):
+  - ``claude --print --verbose --input-format stream-json --output-format stream-json
+      [--model m]`` reads NDJSON user messages from stdin, keeps ONE conversation
+      across multiple messages in ONE process, and stays alive until stdin EOF.
+    ``--verbose`` is REQUIRED for the event stream to be emitted.
+  - Turn protocol:
+      Write: {"type":"user","message":{"role":"user","content":[{"type":"text","text":<msg>}]}}\\n
+      to stdin.  The turn's events stream out on stdout.  A turn ENDS with a
+      {"type":"result", ...} line — exactly one result per turn.
+  - The stream also emits {"type":"system","subtype":"init","session_id":...} at startup
+      plus other system/thinking events (harmlessly ignored by the existing
+      ClaudeCodeAdapter.parse_chunk).
+  - Two turns sent to a single process produce exactly two result lines, each with
+      per-turn content and shared conversation context.
+
+Architecture:
+  A dict keyed by caller-supplied ``key`` (the adapter uses ``session_id:mode`` so a
+  plan→write permission switch spawns a separate proc) holds live ``WarmProc``
+  entries.  Each entry carries an ``asyncio.Lock`` that serializes turns so two
+  concurrent callers can't interleave their stdin writes / stdout reads.
+  Processes are spawned with ``start_new_session=True`` (same isolation as the
+  one-shot adapter path in cli_base.py) so they can be killed via the process group
+  (mirroring cli_base.py's killpg pattern).  Each entry may carry an ``on_close``
+  callback (per-proc cleanup, e.g. remove the session's resolved-secret MCP temp
+  dir), invoked once and exception-suppressed on any kill/reap/close path.
+
+  Respawn resumes on disk: a warm proc holds ONE conversation; when it dies (idle
+  reap, crash, ``kill``) the on-disk conversation persists. A freshly respawned proc
+  passes ``--resume <native_session_id>`` (built by ``build_warm_argv``) to resume
+  it — no engine-side transcript replay needed (verified empirically).
+
+  A module-level singleton ``_POOL`` is created lazily and exposed via
+  ``get_warm_pool()``.  The harness ``lifespan`` in ``main.py`` starts a repeating
+  60-second reaper task and calls ``close_all()`` on shutdown.
+
+Usage is gated behind ``settings.warm_cli`` (env ``HARNESS_WARM_CLI``). A warm-turn
+death before any event reaches the bus falls back to the one-shot spawn path; a
+death mid-stream is fail-closed by the adapter (see ClaudeCodeAdapter.stream_events).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import json
+import os
+import signal
+import time
+from collections.abc import AsyncIterator, Callable
+from dataclasses import dataclass, field
+
+from harness.observability.logging import get_logger
+
+log = get_logger("warm-pool")
+
+
+@dataclass
+class WarmProc:
+    """A live warm claude process kept between turns."""
+
+    proc: asyncio.subprocess.Process
+    key: str
+    last_used: float = field(default_factory=time.monotonic)
+    # Per-proc lock: ensures turns don't interleave on the same process.
+    lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+    # Optional per-proc teardown callback (e.g. remove this session's MCP temp dir).
+    # Invoked exactly once when the proc leaves the pool (kill/reap/close), all
+    # exceptions suppressed.
+    on_close: Callable[[], None] | None = None
+
+
+class WarmCliPool:
+    """Pool of long-lived ``claude`` (or stub) processes, keyed by session key.
+
+    Thread-safety model: all public methods are async and intended to be called
+    from one asyncio event loop.  Concurrent turns on the same proc are serialized
+    by the per-proc ``asyncio.Lock``.
+    """
+
+    def __init__(self) -> None:
+        self._procs: dict[str, WarmProc] = {}
+
+    # ── public API ────────────────────────────────────────────────────────────
+
+    async def acquire(
+        self, key: str, argv: list[str], env: dict,
+        *, on_close: Callable[[], None] | None = None,
+    ) -> WarmProc:
+        """Return (or spawn) the warm process for ``key``.
+
+        If an existing process is alive, it is returned immediately.
+        If it has exited (or never existed), a new one is spawned.
+
+        ``on_close`` is an optional per-proc teardown callback invoked (once,
+        exception-suppressed) when the proc leaves the pool via kill/reap/close.
+        """
+        existing = self._procs.get(key)
+        if existing is not None and existing.proc.returncode is None:
+            return existing
+        # Spawn a fresh process.
+        merged_env = {**os.environ, **env}
+        proc = await asyncio.create_subprocess_exec(
+            *argv,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=merged_env,
+            start_new_session=True,  # own process group for clean kill
+        )
+        wp = WarmProc(proc=proc, key=key, on_close=on_close)
+        self._procs[key] = wp
+        log.debug("warm_pool_spawned", key=key, pid=proc.pid)
+        return wp
+
+    async def kill(self, key: str) -> None:
+        """Kill and remove the warm process for ``key`` (no-op if absent).
+
+        Used to fail-close a broken warm turn (so the next turn respawns and
+        ``--resume``s the on-disk conversation) and to service ``cancel_run``.
+        """
+        wp = self._procs.pop(key, None)
+        if wp is None:
+            return
+        await _kill_proc(wp.proc, key)
+        _run_on_close(wp)
+
+    async def send_turn(self, proc: WarmProc, message: str) -> AsyncIterator[str]:
+        """Write one user NDJSON line to ``proc.proc.stdin`` and yield stdout lines
+        until (and including) the ``{"type":"result"}`` line for this turn.
+
+        Serialized per-proc via ``proc.lock`` so concurrent callers queue up.
+        A per-line idle timeout is applied when ``stall_timeout_s > 0`` (0 → no
+        timeout), reusing the harness-wide setting.
+        """
+        from harness.settings import get_settings
+
+        stall_s = get_settings().stall_timeout_s or None  # None = no timeout
+
+        async with proc.lock:
+            proc.last_used = time.monotonic()
+            # Write the user turn to stdin.
+            if proc.proc.stdin is None or proc.proc.returncode is not None:
+                raise RuntimeError("warm proc stdin is closed or process has exited")
+            line_bytes = (message.rstrip("\n") + "\n").encode()
+            proc.proc.stdin.write(line_bytes)
+            await proc.proc.stdin.drain()
+
+            # Read stdout lines until a result line.
+            assert proc.proc.stdout is not None
+            async for line in _read_until_result(proc.proc.stdout, stall_s):
+                proc.last_used = time.monotonic()
+                yield line
+
+    async def reap_idle(self, max_idle_s: float = 300) -> None:
+        """Kill and remove processes that have been idle for more than ``max_idle_s``."""
+        now = time.monotonic()
+        stale = [
+            key for key, wp in self._procs.items()
+            if (now - wp.last_used) >= max_idle_s or wp.proc.returncode is not None
+        ]
+        for key in stale:
+            wp = self._procs.pop(key, None)
+            if wp is not None:
+                await _kill_proc(wp.proc, key)
+                _run_on_close(wp)
+
+    async def close_all(self) -> None:
+        """Close stdin on all procs (signals EOF exit), then kill after grace."""
+        keys = list(self._procs.keys())
+        for key in keys:
+            wp = self._procs.pop(key, None)
+            if wp is None:
+                continue
+            # Close stdin → the stub/claude reads EOF and exits cleanly.
+            if wp.proc.stdin is not None:
+                with contextlib.suppress(Exception):
+                    wp.proc.stdin.close()
+            await _kill_proc(wp.proc, key, grace_s=5.0)
+            _run_on_close(wp)
+
+
+# ── module-level singleton ────────────────────────────────────────────────────
+
+_POOL: WarmCliPool | None = None
+
+
+def get_warm_pool() -> WarmCliPool:
+    """Return the module-level WarmCliPool singleton (created lazily)."""
+    global _POOL
+    if _POOL is None:
+        _POOL = WarmCliPool()
+    return _POOL
+
+
+# ── internal helpers ──────────────────────────────────────────────────────────
+
+def _run_on_close(wp: WarmProc) -> None:
+    """Invoke a WarmProc's teardown callback once, suppressing any error."""
+    if wp.on_close is not None:
+        with contextlib.suppress(Exception):
+            wp.on_close()
+        wp.on_close = None  # ensure it runs at most once
+
+
+async def _read_until_result(
+    stdout: asyncio.StreamReader, stall_s: float | None
+) -> AsyncIterator[str]:
+    """Yield decoded stdout lines until (and including) a ``type=result`` line."""
+    while True:
+        if stall_s is not None:
+            try:
+                raw = await asyncio.wait_for(stdout.readline(), timeout=stall_s)
+            except asyncio.TimeoutError:
+                raise TimeoutError(
+                    f"warm pool: no output for {stall_s}s (stalled)"
+                )
+        else:
+            raw = await stdout.readline()
+
+        if not raw:  # EOF before result — process died
+            raise RuntimeError("warm pool: process stdout closed before result line")
+
+        line = raw.decode(errors="replace").rstrip("\r\n")
+        if not line:
+            continue  # skip blank lines
+
+        yield line
+
+        # Stop after the result line.
+        try:
+            obj = json.loads(line)
+            if obj.get("type") == "result":
+                break
+        except json.JSONDecodeError:
+            pass  # non-JSON noise; keep reading
+
+
+async def _kill_proc(
+    proc: asyncio.subprocess.Process, key: str, grace_s: float = 2.0
+) -> None:
+    """SIGTERM the process group, wait grace_s, then SIGKILL if still alive."""
+    if proc.returncode is not None:
+        return
+    log.debug("warm_pool_reaping", key=key, pid=proc.pid)
+    with contextlib.suppress(ProcessLookupError, OSError):
+        os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
+    with contextlib.suppress(Exception):
+        await asyncio.wait_for(proc.wait(), timeout=grace_s)
+    if proc.returncode is None:
+        with contextlib.suppress(ProcessLookupError, OSError):
+            os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+        with contextlib.suppress(Exception):
+            await proc.wait()

harness/api/router.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from harness.api.v1 import (
+    adapters,
+    approvals,
+    artifacts,
+    attachments,
+    doctor,
+    health,
+    mcp,
+    memory,
+    policies,
+    project,
+    runs,
+    sessions,
+    stream,
+    tasks,
+    usage,
+)
+
+api_router = APIRouter(prefix="/api/v1")
+api_router.include_router(tasks.router)
+api_router.include_router(runs.router)
+api_router.include_router(doctor.router)
+api_router.include_router(sessions.router)
+api_router.include_router(memory.router)
+api_router.include_router(adapters.router)
+api_router.include_router(mcp.router)
+api_router.include_router(policies.router)
+api_router.include_router(stream.router)
+api_router.include_router(health.router)
+api_router.include_router(project.router)
+api_router.include_router(artifacts.router)
+api_router.include_router(attachments.router)
+api_router.include_router(approvals.router)
+api_router.include_router(usage.router)

harness/api/v1/adapters.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from harness.deps import CurrentPrincipal, DbSession
+from harness.schemas.adapter import AdapterOut, AdapterTestResult
+from harness.services.adapters_health import (
+    create_provider,
+    delete_provider,
+    list_models,
+    list_provider_configs,
+    managed_provider_names,
+    set_model,
+    test_adapter,
+)
+
+router = APIRouter(prefix="/adapters", tags=["adapters"])
+
+
+class SetModelRequest(BaseModel):
+    model: str
+
+
+class CreateProviderRequest(BaseModel):
+    name: str
+    base_url: str
+    model: str | None = None
+    api_key: str | None = None
+    tool_calling: bool = False
+    params: dict = {}
+
+
+@router.get("", response_model=list[AdapterOut])
+async def index(db: DbSession, _: CurrentPrincipal) -> list[AdapterOut]:
+    managed = managed_provider_names()
+    return [
+        AdapterOut(
+            id=pc.id, name=pc.name, kind=pc.kind, model=pc.model,
+            base_url=pc.base_url, enabled=pc.enabled, capabilities=pc.capabilities or {},
+            managed=pc.name in managed,
+        )
+        for pc in await list_provider_configs(db)
+    ]
+
+
+@router.post("", status_code=201)
+async def create(req: CreateProviderRequest, db: DbSession, principal: CurrentPrincipal) -> dict:
+    """Add an OpenAI-compatible provider (durable: overlay file + 0600 file secret)."""
+    try:
+        return await create_provider(
+            db, name=req.name, base_url=req.base_url, model=req.model,
+            api_key=req.api_key, tool_calling=req.tool_calling, params=req.params,
+            actor=principal.subject,
+        )
+    except ValueError as exc:
+        raise HTTPException(422, str(exc)) from exc
+
+@router.put("/{name}")
+async def update(name: str, req: CreateProviderRequest, db: DbSession, principal: CurrentPrincipal) -> dict:
+    """Update an existing OpenAI-compatible provider."""
+    try:
+        return await create_provider(
+            db, name=name, base_url=req.base_url, model=req.model,
+            api_key=req.api_key, tool_calling=req.tool_calling, params=req.params,
+            actor=principal.subject, update=True,
+        )
+    except ValueError as exc:
+        raise HTTPException(422, str(exc)) from exc
+
+
+@router.delete("/{name}")
+async def remove(name: str, db: DbSession, principal: CurrentPrincipal) -> dict:
+    try:
+        return await delete_provider(db, name, actor=principal.subject)
+    except ValueError as exc:
+        raise HTTPException(404, str(exc)) from exc
+
+
+@router.post("/{name}/test", response_model=AdapterTestResult)
+async def test(name: str, db: DbSession, _: CurrentPrincipal) -> AdapterTestResult:
+    try:
+        return await test_adapter(db, name)
+    except ValueError as exc:
+        raise HTTPException(404, str(exc)) from exc
+
+
+@router.get("/{name}/models")
+async def models(name: str, db: DbSession, _: CurrentPrincipal) -> dict:
+    try:
+        return await list_models(db, name)
+    except ValueError as exc:
+        raise HTTPException(404, str(exc)) from exc
+
+
+@router.post("/{name}/model")
+async def select_model(
+    name: str, req: SetModelRequest, db: DbSession, principal: CurrentPrincipal
+) -> dict:
+    try:
+        return await set_model(db, name, req.model, actor=principal.subject)
+    except ValueError as exc:
+        # 404 for unknown provider, 422 for an invalid model choice.
+        code = 404 if "not found" in str(exc) else 422
+        raise HTTPException(code, str(exc)) from exc