machinaos 0.0.76 → 0.0.78

package/server/services/cli_agent/config.py

@@ -0,0 +1,112 @@
+"""Provider configuration loader for the AI CLI framework.
+
+Loads `server/config/ai_cli_providers.json` and exposes
+`get_provider_config(name)` returning a typed `CliProviderConfig`. The
+JSON file is the single source of truth for binary names, npm packages,
+default flags, IDE lockfile paths, and per-provider feature flags.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+from core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+# ---------------------------------------------------------------------------
+# Provider config dataclass
+# ---------------------------------------------------------------------------
+
+@dataclass
+class CliProviderConfig:
+    """Per-provider config from `ai_cli_providers.json`."""
+    name: str
+    package_name: str
+    binary_name: str
+    login_argv: Tuple[str, ...]
+    auth_status_argv: Optional[Tuple[str, ...]]
+    ide_lock_env_var: Optional[str]
+    ide_lockfile_dir: Optional[Path]
+    defaults: Dict[str, Any] = field(default_factory=dict)
+    supports: frozenset = field(default_factory=frozenset)
+
+
+# ---------------------------------------------------------------------------
+# Load config once at import time
+# ---------------------------------------------------------------------------
+
+def _config_path() -> Path:
+    return Path(__file__).parent.parent.parent / "config" / "ai_cli_providers.json"
+
+
+def _load_raw() -> Dict[str, Any]:
+    path = _config_path()
+    try:
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+    except FileNotFoundError:
+        logger.warning(f"ai_cli_providers.json not found at {path}")
+        return {}
+    except Exception as e:
+        logger.warning(f"Failed to load ai_cli_providers.json: {e}")
+        return {}
+
+
+def _expand_lockfile_dir(raw: Optional[str]) -> Optional[Path]:
+    """Expand ~ and the literal `<tmpdir>` placeholder in lockfile paths."""
+    if not raw:
+        return None
+    if raw.startswith("<tmpdir>"):
+        return Path(tempfile.gettempdir()) / raw[len("<tmpdir>") :].lstrip("/").lstrip("\\")
+    return Path(os.path.expanduser(raw))
+
+
+def _build_configs() -> Dict[str, CliProviderConfig]:
+    raw = _load_raw()
+    configs: Dict[str, CliProviderConfig] = {}
+    for name, prov in raw.items():
+        # Pull known fields out; everything else lives in `defaults` so
+        # provider impls can read e.g. `default_model`, `default_max_turns`.
+        defaults = {
+            k: v for k, v in prov.items()
+            if k.startswith("default_")
+        }
+        configs[name] = CliProviderConfig(
+            name=name,
+            package_name=prov.get("package_name", ""),
+            binary_name=prov.get("binary_name", name),
+            login_argv=tuple(prov.get("login_argv", [])),
+            auth_status_argv=(
+                tuple(prov["auth_status_argv"])
+                if prov.get("auth_status_argv") else None
+            ),
+            ide_lock_env_var=prov.get("ide_lock_env_var"),
+            ide_lockfile_dir=_expand_lockfile_dir(prov.get("ide_lockfile_dir")),
+            defaults=defaults,
+            supports=frozenset(prov.get("supports", [])),
+        )
+    return configs
+
+
+PROVIDER_CONFIGS: Dict[str, CliProviderConfig] = _build_configs()
+
+
+def get_provider_config(name: str) -> Optional[CliProviderConfig]:
+    return PROVIDER_CONFIGS.get(name)
+
+
+def list_provider_names() -> List[str]:
+    return list(PROVIDER_CONFIGS.keys())
+
+
+def reload_configs() -> None:
+    """Reload `ai_cli_providers.json` (useful for tests)."""
+    global PROVIDER_CONFIGS
+    PROVIDER_CONFIGS = _build_configs()

package/server/services/cli_agent/factory.py

@@ -0,0 +1,48 @@
+"""Factory for `AICliProvider` instances.
+
+Mirrors `services/llm/factory.py`: lazy imports keep optional providers
+from being loaded until first use. v1 ships Claude + Codex; calling
+`create_cli_provider("gemini")` raises `NotImplementedError` (v2).
+"""
+
+from __future__ import annotations
+
+from core.logging import get_logger
+
+from services.cli_agent.protocol import AICliProvider
+
+logger = get_logger(__name__)
+
+
+SUPPORTED_PROVIDERS = frozenset({"claude", "codex"})  # v2 adds "gemini"
+ALL_PROVIDERS = frozenset({"claude", "codex", "gemini"})  # union of v1+v2 names
+
+
+def create_cli_provider(name: str) -> AICliProvider:
+    """Build a CLI provider by name.
+
+    Raises:
+        NotImplementedError: for `gemini` until the v2 implementation lands.
+        ValueError: for unknown names.
+    """
+    if name == "claude":
+        from services.cli_agent.providers.anthropic_claude import AnthropicClaudeProvider
+        return AnthropicClaudeProvider()
+
+    if name == "codex":
+        from services.cli_agent.providers.openai_codex import OpenAICodexProvider
+        return OpenAICodexProvider()
+
+    if name == "gemini":
+        # v2 stub — surface a clean error so factory consumers can detect
+        # the deferred state and offer the user an actionable hint.
+        raise NotImplementedError(
+            "gemini provider deferred to v2. Use 'claude' or 'codex' in v1."
+        )
+
+    raise ValueError(f"Unknown CLI provider: {name!r}. Known: {sorted(ALL_PROVIDERS)}")
+
+
+def is_supported(name: str) -> bool:
+    """True if the provider is fully implemented in this version."""
+    return name in SUPPORTED_PROVIDERS

package/server/services/cli_agent/lockfile.py

@@ -0,0 +1,141 @@
+"""VSCode-style IDE lockfile writer + remover + stale-PID sweep.
+
+Each spawned CLI session writes a discovery lockfile that the CLI reads
+to auto-connect to MachinaOs's MCP server. We mirror the format the
+official VSCode Claude Code extension writes
+(``~/.claude/ide/<pid>.lock`` containing
+``{port, url, authToken, workspaceFolders, ideName, transport, pid}``)
+and the path convention Gemini's VSCode companion uses
+(``<tmpdir>/gemini/ide/gemini-ide-server-<pid>-<port>.json``).
+
+The startup sweep (mirroring VSCode's own behaviour) removes lockfiles
+whose PIDs are no longer alive — see ``main.py`` lifespan.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def _lockfile_path(
+    *, ide_lockfile_dir: Path, pid: int, port: int, ide_name: str,
+) -> Path:
+    if ide_name == "gemini":
+        return ide_lockfile_dir / f"gemini-ide-server-{pid}-{port}.json"
+    return ide_lockfile_dir / f"{pid}.lock"
+
+
+# Keep `lockfile_path` as a public alias for tests that exercise the
+# path-shape contract.
+lockfile_path = _lockfile_path
+
+
+def write_ide_lockfile(
+    *,
+    ide_lockfile_dir: Path,
+    pid: int,
+    port: int,
+    token: str,
+    workspace_dir: Path,
+    ide_name: str,
+    url: Optional[str] = None,
+    transport: str = "http",
+) -> Path:
+    """Write a VSCode-style IDE lockfile (mode 0600 on POSIX)."""
+    ide_lockfile_dir.mkdir(parents=True, exist_ok=True)
+    path = _lockfile_path(
+        ide_lockfile_dir=ide_lockfile_dir, pid=pid, port=port, ide_name=ide_name,
+    )
+
+    # FastMCP's ``streamable_http_app()`` registers the JSON-RPC route at
+    # ``/mcp`` of the sub-app; ``main.py`` mounts the sub-app at
+    # ``/mcp/ide``. The absolute endpoint the claude CLI POSTs to via
+    # ``--ide`` lockfile discovery is therefore ``/mcp/ide/mcp``. Older
+    # builds advertised ``/mcp/ide`` here and the CLI silently 404'd
+    # before reaching the bearer-token middleware — see ``[CC-Agent MCP
+    # auth]`` log lines.
+    payload = {
+        "port": port,
+        "url": url or f"http://127.0.0.1:{port}/mcp/ide/mcp",
+        "authToken": token,
+        "workspaceFolders": [str(workspace_dir)],
+        "ideName": ide_name,
+        "transport": transport,
+        "pid": pid,
+    }
+
+    tmp = path.with_suffix(path.suffix + ".tmp")
+    tmp.write_text(json.dumps(payload), encoding="utf-8")
+    if sys.platform != "win32":
+        try:
+            os.chmod(tmp, 0o600)
+        except OSError:
+            pass
+    tmp.replace(path)
+    return path
+
+
+def remove_ide_lockfile(path: Optional[Path]) -> None:
+    """Best-effort lockfile removal. Never raises."""
+    if not path:
+        return
+    try:
+        if path.exists():
+            path.unlink()
+    except OSError as exc:
+        logger.debug("Failed to remove lockfile %s: %s", path, exc)
+
+
+def sweep_stale_lockfiles(ide_lockfile_dir: Optional[Path]) -> int:
+    """Remove lockfiles whose PIDs are no longer alive.
+
+    Mirrors VSCode's startup behaviour. Safe on missing dirs. Never raises.
+    """
+    if not ide_lockfile_dir or not ide_lockfile_dir.exists():
+        return 0
+
+    try:
+        import psutil
+    except ImportError:
+        return 0
+
+    removed = 0
+    for entry in ide_lockfile_dir.iterdir():
+        if not entry.is_file():
+            continue
+        try:
+            data = json.loads(entry.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        pid = data.get("pid")
+        if not isinstance(pid, int):
+            continue
+        try:
+            alive = psutil.pid_exists(pid)
+        except Exception:
+            alive = True
+        if alive:
+            continue
+        try:
+            entry.unlink()
+            removed += 1
+        except OSError as exc:
+            logger.debug("Failed to remove stale lockfile %s: %s", entry, exc)
+
+    if removed:
+        logger.info("Swept %d stale CLI lockfile(s) from %s", removed, ide_lockfile_dir)
+    return removed
+
+
+def list_active_lockfiles(ide_lockfile_dir: Optional[Path]) -> List[Path]:
+    """Diagnostic helper: list lockfiles in the discovery dir."""
+    if not ide_lockfile_dir or not ide_lockfile_dir.exists():
+        return []
+    return [p for p in ide_lockfile_dir.iterdir() if p.is_file()]