devcopilot 0.2.0__py3-none-any.whl

cli/launchers/codex_model_catalog.py

@@ -0,0 +1,186 @@
+"""Build Codex model catalogs from the FCC model-list route."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from api.gateway_model_ids import (
+    GATEWAY_MODEL_ID_PREFIX,
+    NO_THINKING_GATEWAY_MODEL_ID_PREFIX,
+)
+from config.provider_ids import SUPPORTED_PROVIDER_IDS
+
+SUPPORTED_REASONING_LEVELS = [
+    {"effort": "low", "description": "Fast responses with lighter reasoning"},
+    {
+        "effort": "medium",
+        "description": "Balances speed and reasoning depth for everyday tasks",
+    },
+    {"effort": "high", "description": "Greater reasoning depth for complex problems"},
+    {
+        "effort": "xhigh",
+        "description": "Extra high reasoning depth for complex problems",
+    },
+]
+
+CODEX_BASE_INSTRUCTIONS = (
+    "You are Codex, a coding agent. Help the user understand, modify, test, "
+    "and review code in their workspace. Follow the user's instructions, use "
+    "tools when needed, and communicate concise progress and verification."
+)
+
+
+@dataclass(frozen=True, slots=True)
+class _CatalogCandidate:
+    slug: str
+    provider_model_ref: str
+    display_name: str
+    force_no_thinking: bool
+
+
+def build_codex_model_catalog(models_response: Mapping[str, Any]) -> dict[str, Any]:
+    """Convert FCC `/v1/models` data into Codex `model_catalog_json` payload."""
+
+    candidates = list(_catalog_candidates(models_response))
+    normal_provider_refs = {
+        candidate.provider_model_ref
+        for candidate in candidates
+        if not candidate.force_no_thinking
+    }
+    models: list[dict[str, Any]] = []
+    seen_slugs: set[str] = set()
+
+    for candidate in candidates:
+        if (
+            candidate.force_no_thinking
+            and candidate.provider_model_ref in normal_provider_refs
+        ):
+            continue
+        if candidate.slug in seen_slugs:
+            continue
+        seen_slugs.add(candidate.slug)
+        models.append(_codex_catalog_entry(candidate, priority=len(models)))
+
+    return {"models": models}
+
+
+def write_codex_model_catalog(catalog_path: Path, catalog: Mapping[str, Any]) -> None:
+    """Atomically write a Codex model catalog JSON file."""
+
+    catalog_path.parent.mkdir(parents=True, exist_ok=True)
+    temp_path = catalog_path.with_name(f".{catalog_path.name}.{uuid.uuid4().hex}.tmp")
+    temp_path.write_text(
+        json.dumps(catalog, ensure_ascii=True, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    temp_path.replace(catalog_path)
+
+
+def _catalog_candidates(
+    models_response: Mapping[str, Any],
+) -> list[_CatalogCandidate]:
+    data = models_response.get("data")
+    if not isinstance(data, list):
+        return []
+
+    candidates: list[_CatalogCandidate] = []
+    for item in data:
+        if not isinstance(item, Mapping):
+            continue
+        model_id = _string_value(item.get("id"))
+        if model_id is None:
+            continue
+        candidate = _candidate_from_model_id(
+            model_id,
+            display_name=_string_value(item.get("display_name")) or model_id,
+        )
+        if candidate is not None:
+            candidates.append(candidate)
+    return candidates
+
+
+def _candidate_from_model_id(
+    model_id: str, *, display_name: str
+) -> _CatalogCandidate | None:
+    prefix, separator, remainder = model_id.partition("/")
+    if not separator:
+        return None
+
+    if prefix == GATEWAY_MODEL_ID_PREFIX:
+        if not _is_provider_model_ref(remainder):
+            return None
+        return _CatalogCandidate(
+            slug=remainder,
+            provider_model_ref=remainder,
+            display_name=display_name,
+            force_no_thinking=False,
+        )
+
+    if prefix == NO_THINKING_GATEWAY_MODEL_ID_PREFIX:
+        if not _is_provider_model_ref(remainder):
+            return None
+        return _CatalogCandidate(
+            slug=model_id,
+            provider_model_ref=remainder,
+            display_name=display_name,
+            force_no_thinking=True,
+        )
+
+    if prefix in SUPPORTED_PROVIDER_IDS and remainder:
+        return _CatalogCandidate(
+            slug=model_id,
+            provider_model_ref=model_id,
+            display_name=display_name,
+            force_no_thinking=False,
+        )
+
+    return None
+
+
+def _codex_catalog_entry(
+    candidate: _CatalogCandidate, *, priority: int
+) -> dict[str, Any]:
+    return {
+        "slug": candidate.slug,
+        "display_name": candidate.display_name,
+        "description": "DevCopilot provider model",
+        "default_reasoning_level": "medium",
+        "supported_reasoning_levels": SUPPORTED_REASONING_LEVELS,
+        "shell_type": "shell_command",
+        "visibility": "list",
+        "supported_in_api": True,
+        "priority": priority,
+        "additional_speed_tiers": [],
+        "service_tiers": [],
+        "base_instructions": CODEX_BASE_INSTRUCTIONS,
+        "supports_reasoning_summaries": True,
+        "default_reasoning_summary": "none",
+        "support_verbosity": True,
+        "default_verbosity": "low",
+        "apply_patch_tool_type": "freeform",
+        "web_search_tool_type": "text_and_image",
+        "truncation_policy": {"mode": "tokens", "limit": 10000},
+        "supports_parallel_tool_calls": True,
+        "supports_image_detail_original": True,
+        "context_window": 200000,
+        "max_context_window": 200000,
+        "effective_context_window_percent": 95,
+        "experimental_supported_tools": [],
+        "input_modalities": ["text"],
+        "supports_search_tool": True,
+        "use_responses_lite": False,
+    }
+
+
+def _is_provider_model_ref(value: str) -> bool:
+    provider_id, separator, provider_model = value.partition("/")
+    return bool(separator and provider_model and provider_id in SUPPORTED_PROVIDER_IDS)
+
+
+def _string_value(value: Any) -> str | None:
+    return value if isinstance(value, str) else None

cli/launchers/common.py

@@ -0,0 +1,93 @@
+"""Shared process helpers for installed client CLI launchers."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from collections.abc import Mapping
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+from cli.process_registry import (
+    kill_pid_tree_best_effort,
+    register_pid,
+    unregister_pid,
+)
+
+PROXY_PREFLIGHT_PATH = "/health"
+PROXY_PREFLIGHT_TIMEOUT_SECONDS = 1.5
+
+
+def preflight_proxy(proxy_root_url: str) -> str | None:
+    """Return an error message when the local proxy health check is unreachable."""
+
+    url = f"{proxy_root_url.rstrip('/')}{PROXY_PREFLIGHT_PATH}"
+    request = Request(url, method="GET")
+    try:
+        with urlopen(request, timeout=PROXY_PREFLIGHT_TIMEOUT_SECONDS) as response:
+            status_code = response.getcode()
+    except HTTPError as exc:
+        return f"returned HTTP {exc.code}"
+    except URLError as exc:
+        return str(exc.reason)
+    except OSError as exc:
+        return str(exc)
+
+    if not 200 <= status_code < 300:
+        return f"returned HTTP {status_code}"
+    return None
+
+
+def resolve_client_binary(
+    *,
+    binary_name: str,
+    display_name: str,
+    install_hint: str,
+) -> str:
+    """Resolve an installed client binary or exit with a user-facing hint."""
+
+    client_command = shutil.which(binary_name)
+    if client_command is None:
+        print(
+            f"Could not find {display_name} command: {binary_name}",
+            file=sys.stderr,
+        )
+        print(install_hint, file=sys.stderr)
+        raise SystemExit(127)
+    return client_command
+
+
+def run_client_process(
+    *,
+    command: list[str],
+    env: Mapping[str, str],
+    binary_name: str,
+    display_name: str,
+    install_hint: str,
+) -> None:
+    """Run a client CLI command and mirror its exit code."""
+
+    process: subprocess.Popen[bytes] | None = None
+    try:
+        process = subprocess.Popen(command, env=dict(env))
+        if process.pid:
+            register_pid(process.pid)
+        return_code = process.wait()
+    except FileNotFoundError:
+        print(
+            f"Could not find {display_name} command: {binary_name}",
+            file=sys.stderr,
+        )
+        print(install_hint, file=sys.stderr)
+        raise SystemExit(127) from None
+    except KeyboardInterrupt:
+        if process is not None and process.pid:
+            kill_pid_tree_best_effort(process.pid)
+            process.wait()
+        raise
+    finally:
+        if process is not None and process.pid:
+            unregister_pid(process.pid)
+
+    raise SystemExit(return_code)

cli/managed/__init__.py

@@ -0,0 +1,6 @@
+"""Managed Claude Code sessions used by messaging."""
+
+from .manager import ManagedClaudeSessionManager
+from .session import ManagedClaudeSession
+
+__all__ = ["ManagedClaudeSession", "ManagedClaudeSessionManager"]

cli/managed/claude.py

@@ -0,0 +1,215 @@
+"""Managed Claude Code task command, environment, and stdout parsing."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass, field
+from typing import Any
+
+from loguru import logger
+
+from cli.claude_env import CLAUDE_CODE_AUTO_COMPACT_WINDOW, claude_auth_token
+
+
+@dataclass(frozen=True, slots=True)
+class ManagedClaudeTaskRequest:
+    """One prompt execution request for a managed Claude Code subprocess."""
+
+    prompt: str
+    session_id: str | None = None
+    fork_session: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class ManagedClaudeInvocation:
+    """Concrete subprocess invocation assembled for a managed Claude task."""
+
+    argv: tuple[str, ...]
+    env: dict[str, str]
+    cwd: str
+    trace_metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class ManagedClaudeConfig:
+    """Configuration for a managed Claude Code subprocess."""
+
+    workspace_path: str
+    api_url: str
+    allowed_dirs: list[str] = field(default_factory=list)
+    plans_directory: str | None = None
+    claude_bin: str = "claude"
+    auth_token: str = ""
+
+
+@dataclass(slots=True)
+class ManagedClaudeParseState:
+    """Mutable stdout parser state for one managed Claude Code task run."""
+
+    log_raw_cli_diagnostics: bool = False
+    session_id_extracted: bool = False
+
+
+def build_managed_claude_invocation(
+    *,
+    config: ManagedClaudeConfig,
+    request: ManagedClaudeTaskRequest,
+    base_env: Mapping[str, str],
+) -> ManagedClaudeInvocation:
+    """Build a Claude Code stream-json subprocess invocation."""
+
+    cmd = build_managed_claude_command(
+        claude_bin=config.claude_bin,
+        prompt=request.prompt,
+        session_id=request.session_id,
+        fork_session=request.fork_session,
+        allowed_dirs=config.allowed_dirs,
+        plans_directory=config.plans_directory,
+    )
+    resume_session_id = (
+        request.session_id
+        if request.session_id and not request.session_id.startswith("pending_")
+        else None
+    )
+    return ManagedClaudeInvocation(
+        argv=tuple(cmd),
+        env=build_managed_claude_env(
+            api_url=config.api_url,
+            auth_token=config.auth_token,
+            base_env=base_env,
+        ),
+        cwd=config.workspace_path,
+        trace_metadata={
+            "client_cli_id": "claude",
+            "resume_session_id": resume_session_id,
+            "fork_session": request.fork_session,
+            "prompt": request.prompt,
+            "cwd": config.workspace_path,
+            "claude_binary": config.claude_bin,
+            "cli_argv": cmd,
+        },
+    )
+
+
+def build_managed_claude_env(
+    *,
+    api_url: str,
+    auth_token: str,
+    base_env: Mapping[str, str],
+) -> dict[str, str]:
+    """Return a Claude Code task environment that targets the local proxy."""
+
+    env = dict(base_env)
+    env["ANTHROPIC_API_URL"] = api_url
+    env["ANTHROPIC_BASE_URL"] = api_url[:-3] if api_url.endswith("/v1") else api_url
+    env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1"
+    env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = CLAUDE_CODE_AUTO_COMPACT_WINDOW
+    env.pop("ANTHROPIC_API_KEY", None)
+    env["ANTHROPIC_AUTH_TOKEN"] = claude_auth_token(auth_token)
+    env["TERM"] = "dumb"
+    env["PYTHONIOENCODING"] = "utf-8"
+    return env
+
+
+def build_managed_claude_command(
+    *,
+    claude_bin: str,
+    prompt: str,
+    session_id: str | None,
+    fork_session: bool,
+    allowed_dirs: list[str],
+    plans_directory: str | None,
+) -> list[str]:
+    """Return the Claude Code stream-json command for a managed task."""
+
+    if session_id and not session_id.startswith("pending_"):
+        cmd = [
+            claude_bin,
+            "--resume",
+            session_id,
+        ]
+        if fork_session:
+            cmd.append("--fork-session")
+        cmd += [
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--dangerously-skip-permissions",
+            "--verbose",
+        ]
+    else:
+        cmd = [
+            claude_bin,
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--dangerously-skip-permissions",
+            "--verbose",
+        ]
+
+    for directory in allowed_dirs:
+        cmd.extend(["--add-dir", directory])
+
+    if plans_directory is not None:
+        cmd.extend(["--settings", json.dumps({"plansDirectory": plans_directory})])
+
+    return cmd
+
+
+def parse_managed_claude_stdout_line(
+    line: str, state: ManagedClaudeParseState
+) -> Iterable[Any]:
+    """Parse one Claude Code stream-json stdout line."""
+
+    try:
+        event = json.loads(line)
+    except json.JSONDecodeError:
+        if state.log_raw_cli_diagnostics:
+            logger.debug("Non-JSON output: {}", line)
+        else:
+            logger.debug("Non-JSON CLI line: char_len={}", len(line))
+        yield {"type": "raw", "content": line}
+        return
+
+    if not state.session_id_extracted:
+        extracted_id = extract_managed_claude_session_id(event)
+        if extracted_id:
+            state.session_id_extracted = True
+            logger.info("Extracted session ID: {}", extracted_id)
+            yield {"type": "session_info", "session_id": extracted_id}
+
+    yield event
+
+
+def extract_managed_claude_session_id(event: Any) -> str | None:
+    """Extract a Claude Code session ID from supported stream-json event shapes."""
+
+    if not isinstance(event, dict):
+        return None
+
+    if session_id := _string_value(event.get("session_id")):
+        return session_id
+    if session_id := _string_value(event.get("sessionId")):
+        return session_id
+
+    for key in ("init", "system", "result", "metadata"):
+        nested = event.get(key)
+        if not isinstance(nested, dict):
+            continue
+        if session_id := _string_value(nested.get("session_id")):
+            return session_id
+        if session_id := _string_value(nested.get("sessionId")):
+            return session_id
+
+    conversation = event.get("conversation")
+    if isinstance(conversation, dict):
+        return _string_value(conversation.get("id"))
+
+    return None
+
+
+def _string_value(value: Any) -> str | None:
+    return value if isinstance(value, str) else None

cli/managed/manager.py

@@ -0,0 +1,157 @@
+"""Managed Claude Code session pool for messaging."""
+
+import asyncio
+import uuid
+
+from loguru import logger
+
+from .session import ManagedClaudeSession
+
+
+class ManagedClaudeSessionManager:
+    """
+    Manages multiple Claude Code sessions for parallel conversation processing.
+
+    Each new conversation gets its own subprocess. Replies to existing
+    conversations reuse the same session instance.
+    """
+
+    def __init__(
+        self,
+        workspace_path: str,
+        api_url: str,
+        allowed_dirs: list[str] | None = None,
+        plans_directory: str | None = None,
+        claude_bin: str = "claude",
+        auth_token: str = "",
+        *,
+        log_raw_cli_diagnostics: bool = False,
+        log_messaging_error_details: bool = False,
+    ):
+        """
+        Initialize the session manager.
+
+        Args:
+            workspace_path: Working directory for CLI processes
+            api_url: API URL for the proxy
+            allowed_dirs: Directories the CLI is allowed to access
+            plans_directory: Directory for Claude Code CLI plan files (passed via --settings)
+        """
+        self.workspace = workspace_path
+        self.api_url = api_url
+        self.allowed_dirs = allowed_dirs or []
+        self.plans_directory = plans_directory
+        self.claude_bin = claude_bin
+        self.auth_token = auth_token
+        self._log_raw_cli_diagnostics = log_raw_cli_diagnostics
+        self._log_messaging_error_details = log_messaging_error_details
+
+        self._sessions: dict[str, ManagedClaudeSession] = {}
+        self._pending_sessions: dict[str, ManagedClaudeSession] = {}
+        self._temp_to_real: dict[str, str] = {}
+        self._real_to_temp: dict[str, str] = {}
+        self._lock = asyncio.Lock()
+
+    async def get_or_create_session(
+        self, session_id: str | None = None
+    ) -> tuple[ManagedClaudeSession, str, bool]:
+        """
+        Get an existing session or create a new one.
+
+        Returns:
+            Tuple of (session instance, session_id, is_new_session)
+        """
+        async with self._lock:
+            if session_id:
+                lookup_id = self._temp_to_real.get(session_id, session_id)
+
+                if lookup_id in self._sessions:
+                    return self._sessions[lookup_id], lookup_id, False
+                if lookup_id in self._pending_sessions:
+                    return self._pending_sessions[lookup_id], lookup_id, False
+
+            temp_id = session_id if session_id else f"pending_{uuid.uuid4().hex[:8]}"
+
+            new_session = ManagedClaudeSession(
+                workspace_path=self.workspace,
+                api_url=self.api_url,
+                allowed_dirs=self.allowed_dirs,
+                plans_directory=self.plans_directory,
+                claude_bin=self.claude_bin,
+                auth_token=self.auth_token,
+                log_raw_cli_diagnostics=self._log_raw_cli_diagnostics,
+            )
+            self._pending_sessions[temp_id] = new_session
+
+            return new_session, temp_id, True
+
+    async def register_real_session_id(
+        self, temp_id: str, real_session_id: str
+    ) -> bool:
+        """Register the real session ID from CLI output."""
+        async with self._lock:
+            if temp_id not in self._pending_sessions:
+                logger.warning(f"Temp session {temp_id} not found")
+                return False
+
+            session = self._pending_sessions.pop(temp_id)
+            self._sessions[real_session_id] = session
+            self._temp_to_real[temp_id] = real_session_id
+            self._real_to_temp[real_session_id] = temp_id
+
+            logger.info(f"Registered session: {temp_id} -> {real_session_id}")
+            return True
+
+    async def remove_session(self, session_id: str) -> bool:
+        """Remove a session from the manager."""
+        async with self._lock:
+            if session_id in self._pending_sessions:
+                session = self._pending_sessions.pop(session_id)
+                await session.stop()
+                return True
+
+            if session_id in self._sessions:
+                session = self._sessions.pop(session_id)
+                await session.stop()
+                temp_id = self._real_to_temp.pop(session_id, None)
+                if temp_id is not None:
+                    self._temp_to_real.pop(temp_id, None)
+                return True
+
+            return False
+
+    async def stop_all(self):
+        """Stop all sessions."""
+        async with self._lock:
+            all_sessions = list(self._sessions.values()) + list(
+                self._pending_sessions.values()
+            )
+            for session in all_sessions:
+                try:
+                    await session.stop()
+                except Exception as e:
+                    if self._log_messaging_error_details:
+                        logger.error(
+                            "Error stopping session: {}: {}",
+                            type(e).__name__,
+                            e,
+                        )
+                    else:
+                        logger.error(
+                            "Error stopping session: exc_type={}",
+                            type(e).__name__,
+                        )
+
+            self._sessions.clear()
+            self._pending_sessions.clear()
+            self._temp_to_real.clear()
+            self._real_to_temp.clear()
+            logger.info("All sessions stopped")
+
+    def get_stats(self) -> dict:
+        """Get session statistics."""
+        return {
+            "active_sessions": len(self._sessions),
+            "pending_sessions": len(self._pending_sessions),
+            "busy_count": sum(1 for s in self._sessions.values() if s.is_busy),
+        }