codex-autorunner 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

codex_autorunner/integrations/agents/wiring.py

@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Optional
+
+from ...core.config import RepoConfig
+from ...core.ports.agent_backend import AgentBackend
+from ...core.state import RunnerState
+from ...core.utils import build_opencode_supervisor
+from ...workspace import canonical_workspace_root, workspace_id_for_path
+from ..app_server.env import build_app_server_env
+from ..app_server.supervisor import WorkspaceAppServerSupervisor
+from .codex_backend import CodexAppServerBackend
+from .opencode_backend import OpenCodeBackend
+
+NotificationHandler = Callable[[dict[str, Any]], Awaitable[None]]
+BackendFactory = Callable[
+    [str, RunnerState, Optional[NotificationHandler]], AgentBackend
+]
+SupervisorFactory = Callable[[str, Optional[NotificationHandler]], Any]
+
+
+def _build_workspace_env(
+    repo_root: Path,
+    config: RepoConfig,
+    *,
+    event_prefix: str,
+    logger: logging.Logger,
+) -> dict[str, str]:
+    workspace_root = canonical_workspace_root(repo_root)
+    workspace_id = workspace_id_for_path(workspace_root)
+    state_dir = config.app_server.state_root / workspace_id
+    state_dir.mkdir(parents=True, exist_ok=True)
+    return build_app_server_env(
+        config.app_server.command,
+        workspace_root,
+        state_dir,
+        logger=logger,
+        event_prefix=event_prefix,
+    )
+
+
+class AgentBackendFactory:
+    def __init__(self, repo_root: Path, config: RepoConfig) -> None:
+        self._repo_root = repo_root
+        self._config = config
+        self._logger = logging.getLogger("codex_autorunner.app_server")
+        self._backend_cache: dict[str, AgentBackend] = {}
+        self._opencode_supervisor: Optional[Any] = None
+
+    def __call__(
+        self,
+        agent_id: str,
+        state: RunnerState,
+        notification_handler: Optional[NotificationHandler],
+    ) -> AgentBackend:
+        if agent_id == "codex":
+            if not self._config.app_server.command:
+                raise ValueError("app_server.command is required for codex backend")
+
+            approval_policy = state.autorunner_approval_policy or "never"
+            sandbox_mode = state.autorunner_sandbox_mode or "dangerFullAccess"
+            if sandbox_mode == "workspaceWrite":
+                sandbox_policy: Any = {
+                    "type": "workspaceWrite",
+                    "writableRoots": [str(self._repo_root)],
+                    "networkAccess": bool(state.autorunner_workspace_write_network),
+                }
+            else:
+                sandbox_policy = sandbox_mode
+
+            model = state.autorunner_model_override or self._config.codex_model
+            reasoning_effort = (
+                state.autorunner_effort_override or self._config.codex_reasoning
+            )
+
+            env = _build_workspace_env(
+                self._repo_root,
+                self._config,
+                event_prefix="autorunner",
+                logger=self._logger,
+            )
+
+            cached = self._backend_cache.get(agent_id)
+            if cached is None:
+                cached = CodexAppServerBackend(
+                    command=self._config.app_server.command,
+                    cwd=self._repo_root,
+                    env=env,
+                    approval_policy=approval_policy,
+                    sandbox_policy=sandbox_policy,
+                    model=model,
+                    reasoning_effort=reasoning_effort,
+                    turn_timeout_seconds=None,
+                    auto_restart=self._config.app_server.auto_restart,
+                    request_timeout=self._config.app_server.request_timeout,
+                    turn_stall_timeout_seconds=self._config.app_server.turn_stall_timeout_seconds,
+                    turn_stall_poll_interval_seconds=self._config.app_server.turn_stall_poll_interval_seconds,
+                    turn_stall_recovery_min_interval_seconds=self._config.app_server.turn_stall_recovery_min_interval_seconds,
+                    max_message_bytes=self._config.app_server.client.max_message_bytes,
+                    oversize_preview_bytes=self._config.app_server.client.oversize_preview_bytes,
+                    max_oversize_drain_bytes=self._config.app_server.client.max_oversize_drain_bytes,
+                    restart_backoff_initial_seconds=self._config.app_server.client.restart_backoff_initial_seconds,
+                    restart_backoff_max_seconds=self._config.app_server.client.restart_backoff_max_seconds,
+                    restart_backoff_jitter_ratio=self._config.app_server.client.restart_backoff_jitter_ratio,
+                    notification_handler=notification_handler,
+                    logger=self._logger,
+                )
+                self._backend_cache[agent_id] = cached
+            else:
+                if isinstance(cached, CodexAppServerBackend):
+                    cached.configure(
+                        approval_policy=approval_policy,
+                        sandbox_policy=sandbox_policy,
+                        model=model,
+                        reasoning_effort=reasoning_effort,
+                        turn_timeout_seconds=None,
+                        notification_handler=notification_handler,
+                    )
+            return cached
+
+        if agent_id == "opencode":
+            agent_cfg = self._config.agents.get("opencode")
+            base_url = agent_cfg.base_url if agent_cfg else None
+            username = os.environ.get("OPENCODE_SERVER_USERNAME")
+            password = os.environ.get("OPENCODE_SERVER_PASSWORD")
+            if password and not username:
+                username = "opencode"
+            auth = (username, password) if username and password else None
+
+            cached = self._backend_cache.get(agent_id)
+            if cached is None:
+                if not base_url:
+                    supervisor = self._ensure_opencode_supervisor()
+                    if supervisor is None:
+                        raise ValueError("opencode backend is not configured")
+                    cached = OpenCodeBackend(
+                        supervisor=supervisor,
+                        workspace_root=self._repo_root,
+                        auth=auth,
+                        timeout=self._config.app_server.request_timeout,
+                        model=state.autorunner_model_override,
+                        reasoning=state.autorunner_effort_override,
+                        approval_policy=state.autorunner_approval_policy,
+                        session_stall_timeout_seconds=self._config.opencode.session_stall_timeout_seconds,
+                        logger=self._logger,
+                    )
+                else:
+                    cached = OpenCodeBackend(
+                        base_url=base_url,
+                        workspace_root=self._repo_root,
+                        auth=auth,
+                        timeout=self._config.app_server.request_timeout,
+                        model=state.autorunner_model_override,
+                        reasoning=state.autorunner_effort_override,
+                        approval_policy=state.autorunner_approval_policy,
+                        session_stall_timeout_seconds=self._config.opencode.session_stall_timeout_seconds,
+                        logger=self._logger,
+                    )
+                self._backend_cache[agent_id] = cached
+            else:
+                if isinstance(cached, OpenCodeBackend):
+                    cached.configure(
+                        model=state.autorunner_model_override,
+                        reasoning=state.autorunner_effort_override,
+                        approval_policy=state.autorunner_approval_policy,
+                    )
+            return cached
+
+        raise ValueError(f"Unsupported agent backend: {agent_id}")
+
+    def _ensure_opencode_supervisor(self) -> Optional[Any]:
+        if self._opencode_supervisor is not None:
+            return self._opencode_supervisor
+        opencode_command = self._config.agent_serve_command("opencode")
+        opencode_binary = None
+        try:
+            opencode_binary = self._config.agent_binary("opencode")
+        except Exception:
+            opencode_binary = None
+        agent_config = self._config.agents.get("opencode")
+        subagent_models = agent_config.subagent_models if agent_config else None
+        supervisor = build_opencode_supervisor(
+            opencode_command=opencode_command,
+            opencode_binary=opencode_binary,
+            workspace_root=self._repo_root,
+            logger=self._logger,
+            request_timeout=self._config.app_server.request_timeout,
+            max_handles=self._config.app_server.max_handles,
+            idle_ttl_seconds=self._config.app_server.idle_ttl_seconds,
+            session_stall_timeout_seconds=self._config.opencode.session_stall_timeout_seconds,
+            max_text_chars=self._config.opencode.max_text_chars,
+            base_env=None,
+            subagent_models=subagent_models,
+        )
+        self._opencode_supervisor = supervisor
+        return supervisor
+
+    async def close_all(self) -> None:
+        backends = list(self._backend_cache.values())
+        self._backend_cache = {}
+        for backend in backends:
+            close = getattr(backend, "close", None)
+            if close is None:
+                continue
+            result = close()
+            if inspect.isawaitable(result):
+                await result
+        if self._opencode_supervisor is not None:
+            try:
+                await self._opencode_supervisor.close_all()
+            except Exception:
+                self._logger.warning(
+                    "Failed closing opencode supervisor", exc_info=True
+                )
+            self._opencode_supervisor = None
+
+
+def build_agent_backend_factory(repo_root: Path, config: RepoConfig) -> BackendFactory:
+    return AgentBackendFactory(repo_root, config)
+
+
+def build_app_server_supervisor_factory(
+    config: RepoConfig,
+    *,
+    logger: Optional[logging.Logger] = None,
+) -> SupervisorFactory:
+    app_logger = logger or logging.getLogger("codex_autorunner.app_server")
+
+    def factory(
+        event_prefix: str, notification_handler: Optional[NotificationHandler]
+    ) -> WorkspaceAppServerSupervisor:
+        if not config.app_server.command:
+            raise ValueError("app_server.command is required for supervisor")
+
+        def _env_builder(
+            workspace_root: Path, _workspace_id: str, state_dir: Path
+        ) -> dict[str, str]:
+            state_dir.mkdir(parents=True, exist_ok=True)
+            return build_app_server_env(
+                config.app_server.command,
+                workspace_root,
+                state_dir,
+                logger=app_logger,
+                event_prefix=event_prefix,
+            )
+
+        return WorkspaceAppServerSupervisor(
+            config.app_server.command,
+            state_root=config.app_server.state_root,
+            env_builder=_env_builder,
+            logger=app_logger,
+            notification_handler=notification_handler,
+            auto_restart=config.app_server.auto_restart,
+            max_handles=config.app_server.max_handles,
+            idle_ttl_seconds=config.app_server.idle_ttl_seconds,
+            request_timeout=config.app_server.request_timeout,
+            turn_stall_timeout_seconds=config.app_server.turn_stall_timeout_seconds,
+            turn_stall_poll_interval_seconds=config.app_server.turn_stall_poll_interval_seconds,
+            turn_stall_recovery_min_interval_seconds=config.app_server.turn_stall_recovery_min_interval_seconds,
+            max_message_bytes=config.app_server.client.max_message_bytes,
+            oversize_preview_bytes=config.app_server.client.oversize_preview_bytes,
+            max_oversize_drain_bytes=config.app_server.client.max_oversize_drain_bytes,
+            restart_backoff_initial_seconds=config.app_server.client.restart_backoff_initial_seconds,
+            restart_backoff_max_seconds=config.app_server.client.restart_backoff_max_seconds,
+            restart_backoff_jitter_ratio=config.app_server.client.restart_backoff_jitter_ratio,
+        )
+
+    return factory
+
+
+__all__ = [
+    "AgentBackendFactory",
+    "build_agent_backend_factory",
+    "build_app_server_supervisor_factory",
+]

codex_autorunner/integrations/app_server/client.py

@@ -23,10 +23,15 @@ from typing import (
     no_type_check,
 )
 
+from ...core.app_server_utils import (
+    _extract_thread_id,
+    _extract_thread_id_for_turn,
+    _extract_turn_id,
+)
 from ...core.circuit_breaker import CircuitBreaker
 from ...core.exceptions import (
+    AppServerError,
     CircuitOpenError,
-    CodexError,
     PermanentError,
     TransientError,
 )
@@ -62,7 +67,7 @@ _INVALID_JSON_PREVIEW_BYTES = 200
 _CLIENT_INSTANCES: weakref.WeakSet = weakref.WeakSet()
 
 
-class CodexAppServerError(CodexError):
+class CodexAppServerError(AppServerError):
     """Base error for app-server client failures."""
 
 
@@ -1579,54 +1584,12 @@ def _preview_excerpt(text: str, limit: int = 256) -> str:
     return f"{normalized[:limit].rstrip()}..."
 
 
-def _extract_turn_id(payload: Any) -> Optional[str]:
-    if not isinstance(payload, dict):
-        return None
-    for key in ("turnId", "turn_id", "id"):
-        value = payload.get(key)
-        if isinstance(value, str):
-            return value
-    turn = payload.get("turn")
-    if isinstance(turn, dict):
-        for key in ("id", "turnId", "turn_id"):
-            value = turn.get(key)
-            if isinstance(value, str):
-                return value
-    return None
-
-
 def _turn_key(thread_id: Optional[str], turn_id: Optional[str]) -> Optional[TurnKey]:
     if not thread_id or not turn_id:
         return None
     return (thread_id, turn_id)
 
 
-def _extract_thread_id_for_turn(payload: Any) -> Optional[str]:
-    if not isinstance(payload, dict):
-        return None
-    for candidate in (payload, payload.get("turn"), payload.get("item")):
-        thread_id = _extract_thread_id_from_container(candidate)
-        if thread_id:
-            return thread_id
-    return None
-
-
-def _extract_thread_id_from_container(payload: Any) -> Optional[str]:
-    if not isinstance(payload, dict):
-        return None
-    for key in ("threadId", "thread_id"):
-        value = payload.get(key)
-        if isinstance(value, str):
-            return value
-    thread = payload.get("thread")
-    if isinstance(thread, dict):
-        for key in ("id", "threadId", "thread_id"):
-            value = thread.get(key)
-            if isinstance(value, str):
-                return value
-    return None
-
-
 def _extract_review_text(item: Any) -> Optional[str]:
     if not isinstance(item, dict):
         return None
@@ -1671,22 +1634,6 @@ def _extract_error_message(payload: Any) -> Optional[str]:
     return message
 
 
-def _extract_thread_id(payload: Any) -> Optional[str]:
-    if not isinstance(payload, dict):
-        return None
-    for key in ("threadId", "thread_id", "id"):
-        value = payload.get(key)
-        if isinstance(value, str):
-            return value
-    thread = payload.get("thread")
-    if isinstance(thread, dict):
-        for key in ("id", "threadId", "thread_id"):
-            value = thread.get(key)
-            if isinstance(value, str):
-                return value
-    return None
-
-
 _SANDBOX_POLICY_CANONICAL = {
     "dangerfullaccess": "dangerFullAccess",
     "readonly": "readOnly",

codex_autorunner/integrations/app_server/env.py

@@ -1,110 +1,5 @@
 from __future__ import annotations
 
-import logging
-import os
-from pathlib import Path
-from typing import Mapping, Optional, Sequence
+from ...core.app_server_utils import build_app_server_env
 
-from ...core.logging_utils import log_event
-from ...core.utils import resolve_executable, subprocess_env
-
-
-def app_server_env(
-    command: Sequence[str],
-    cwd: Path,
-    *,
-    base_env: Optional[Mapping[str, str]] = None,
-) -> dict[str, str]:
-    extra_paths: list[str] = []
-    if command:
-        binary = command[0]
-        resolved = resolve_executable(binary, env=base_env)
-        candidate: Optional[Path] = Path(resolved) if resolved else None
-        if candidate is None:
-            candidate = Path(binary).expanduser()
-            if not candidate.is_absolute():
-                candidate = (cwd / candidate).resolve()
-        if candidate.exists():
-            extra_paths.append(str(candidate.parent))
-    return subprocess_env(extra_paths=extra_paths, base_env=base_env)
-
-
-def seed_codex_home(
-    codex_home: Path,
-    *,
-    logger: Optional[logging.Logger] = None,
-    event_prefix: str = "app_server",
-) -> None:
-    logger = logger or logging.getLogger(__name__)
-    auth_path = codex_home / "auth.json"
-    source_root = Path(os.environ.get("CODEX_HOME", "~/.codex")).expanduser()
-    if source_root.resolve() == codex_home.resolve():
-        return
-    source_auth = source_root / "auth.json"
-    if auth_path.exists():
-        if auth_path.is_symlink() and auth_path.resolve() == source_auth.resolve():
-            return
-        log_event(
-            logger,
-            logging.INFO,
-            f"{event_prefix}.codex_home.seed.skipped",
-            reason="auth_exists",
-            source=str(source_root),
-            target=str(codex_home),
-        )
-        return
-    if not source_root.exists():
-        log_event(
-            logger,
-            logging.WARNING,
-            f"{event_prefix}.codex_home.seed.skipped",
-            reason="source_missing",
-            source=str(source_root),
-            target=str(codex_home),
-        )
-        return
-    if not source_auth.exists():
-        log_event(
-            logger,
-            logging.WARNING,
-            f"{event_prefix}.codex_home.seed.skipped",
-            reason="auth_missing",
-            source=str(source_root),
-            target=str(codex_home),
-        )
-        return
-    try:
-        auth_path.symlink_to(source_auth)
-        log_event(
-            logger,
-            logging.INFO,
-            f"{event_prefix}.codex_home.seeded",
-            source=str(source_root),
-            target=str(codex_home),
-        )
-    except OSError as exc:
-        log_event(
-            logger,
-            logging.WARNING,
-            f"{event_prefix}.codex_home.seed.failed",
-            exc=exc,
-            source=str(source_root),
-            target=str(codex_home),
-        )
-
-
-def build_app_server_env(
-    command: Sequence[str],
-    workspace_root: Path,
-    state_dir: Path,
-    *,
-    logger: Optional[logging.Logger] = None,
-    event_prefix: str = "app_server",
-    base_env: Optional[Mapping[str, str]] = None,
-) -> dict[str, str]:
-    env = app_server_env(command, workspace_root, base_env=base_env)
-    codex_home = state_dir / "codex_home"
-    codex_home.mkdir(parents=True, exist_ok=True)
-    seed_codex_home(codex_home, logger=logger, event_prefix=event_prefix)
-    env["CODEX_HOME"] = str(codex_home)
-    return env
+__all__ = ["build_app_server_env"]

codex_autorunner/{core/app_server_events.py → integrations/app_server/event_buffer.py}

@@ -1,17 +1,19 @@
 import asyncio
 import json
+import logging
 import threading
 import time
 from dataclasses import dataclass, field
 from typing import Any, AsyncIterator, Dict, Optional
 
-from ..integrations.app_server.client import (
-    _extract_thread_id,
-    _extract_thread_id_for_turn,
-    _extract_turn_id,
+from ...core.app_server_ids import (
+    extract_thread_id,
+    extract_thread_id_for_turn,
+    extract_turn_id,
 )
 
 TurnKey = tuple[str, str]
+LOGGER = logging.getLogger("codex_autorunner.app_server")
 
 
 def format_sse(event: str, data: object) -> str:
@@ -143,11 +145,11 @@ class AppServerEventBuffer:
     ) -> tuple[Optional[str], Optional[str]]:
         params_raw = message.get("params")
         params: Dict[str, Any] = params_raw if isinstance(params_raw, dict) else {}
-        turn_id = _extract_turn_id(params) or _extract_turn_id(message)
+        turn_id = extract_turn_id(params) or extract_turn_id(message)
         thread_id = (
-            _extract_thread_id_for_turn(params)
-            or _extract_thread_id(params)
-            or _extract_thread_id(message)
+            extract_thread_id_for_turn(params)
+            or extract_thread_id(params)
+            or extract_thread_id(message)
         )
         if not thread_id and turn_id:
             thread_id = self._turn_index.get(turn_id)
@@ -184,9 +186,14 @@ class AppServerEventBuffer:
         try:
             lines = formatter.format_event(message)
         except Exception:
+            LOGGER.warning("Failed to format app server event log line.", exc_info=True)
             return
         for line in lines:
             try:
                 emit(line)
             except Exception:
+                LOGGER.warning(
+                    "Failed to emit app server event log line.",
+                    exc_info=True,
+                )
                 continue

codex_autorunner/integrations/telegram/adapter.py

@@ -259,6 +259,17 @@ class PageCallback:
     page: int
 
 
+@dataclass(frozen=True)
+class FlowCallback:
+    action: str
+    run_id: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class FlowRunCallback:
+    run_id: str
+
+
 def parse_command(
     text: Optional[str],
     *,
@@ -741,6 +752,27 @@ def encode_compact_callback(action: str) -> str:
     return data
 
 
+def encode_flow_callback(action: str, run_id: Optional[str] = None) -> str:
+    action = str(action or "").strip()
+    if not action:
+        raise ValueError("flow action required")
+    if run_id:
+        data = f"flow:{action}:{run_id}"
+    else:
+        data = f"flow:{action}"
+    _validate_callback_data(data)
+    return data
+
+
+def encode_flow_run_callback(run_id: str) -> str:
+    run_id = str(run_id or "").strip()
+    if not run_id:
+        raise ValueError("flow run id required")
+    data = f"flow_run:{run_id}"
+    _validate_callback_data(data)
+    return data
+
+
 def parse_callback_data(
     data: Optional[str],
 ) -> Optional[
@@ -760,6 +792,8 @@ def parse_callback_data(
         ReviewCommitCallback,
         CancelCallback,
         CompactCallback,
+        FlowCallback,
+        FlowRunCallback,
         PageCallback,
     ]
 ]:
@@ -857,6 +891,19 @@ def parse_callback_data(
         if not page.isdigit():
             return None
         return PageCallback(kind=kind, page=int(page))
+    if data.startswith("flow:"):
+        _, _, rest = data.partition(":")
+        action, sep, run_id = rest.partition(":")
+        if not action:
+            return None
+        if sep and not run_id:
+            return None
+        return FlowCallback(action=action, run_id=run_id or None)
+    if data.startswith("flow_run:"):
+        _, _, run_id = data.partition(":")
+        if not run_id:
+            return None
+        return FlowRunCallback(run_id=run_id)
     return None
 
 
@@ -1062,6 +1109,24 @@ def build_bind_keyboard(
     return build_inline_keyboard(rows)
 
 
+def build_flow_runs_keyboard(
+    options: Sequence[tuple[str, str]],
+    *,
+    page_button: Optional[tuple[str, str]] = None,
+    include_cancel: bool = False,
+) -> dict[str, Any]:
+    rows = [
+        [InlineButton(label, encode_flow_run_callback(run_id))]
+        for run_id, label in options
+    ]
+    if page_button:
+        label, callback_data = page_button
+        rows.append([InlineButton(label, callback_data)])
+    if include_cancel:
+        rows.append([InlineButton("Cancel", encode_cancel_callback("flow-runs"))])
+    return build_inline_keyboard(rows)
+
+
 def _validate_callback_data(data: str) -> None:
     if len(data.encode("utf-8")) > TELEGRAM_CALLBACK_DATA_LIMIT:
         raise ValueError("callback_data exceeds Telegram limit")