codex-autorunner 0.1.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

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/app_server/supervisor.py

@@ -2,12 +2,14 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import os
 import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Callable, Dict, Optional, Sequence
 
 from ...core.logging_utils import log_event
+from ...core.supervisor_utils import evict_lru_handle_locked, pop_idle_handles_locked
 from ...workspace import canonical_workspace_root, workspace_id_for_path
 from .client import ApprovalHandler, CodexAppServerClient, NotificationHandler
 
@@ -34,8 +36,17 @@ class WorkspaceAppServerSupervisor:
         approval_handler: Optional[ApprovalHandler] = None,
         notification_handler: Optional[NotificationHandler] = None,
         logger: Optional[logging.Logger] = None,
-        auto_restart: bool = True,
+        auto_restart: Optional[bool] = None,
         request_timeout: Optional[float] = None,
+        turn_stall_timeout_seconds: Optional[float] = None,
+        turn_stall_poll_interval_seconds: Optional[float] = None,
+        turn_stall_recovery_min_interval_seconds: Optional[float] = None,
+        max_message_bytes: Optional[int] = None,
+        oversize_preview_bytes: Optional[int] = None,
+        max_oversize_drain_bytes: Optional[int] = None,
+        restart_backoff_initial_seconds: Optional[float] = None,
+        restart_backoff_max_seconds: Optional[float] = None,
+        restart_backoff_jitter_ratio: Optional[float] = None,
         default_approval_decision: str = "cancel",
         max_handles: Optional[int] = None,
         idle_ttl_seconds: Optional[float] = None,
@@ -46,8 +57,27 @@ class WorkspaceAppServerSupervisor:
         self._approval_handler = approval_handler
         self._notification_handler = notification_handler
         self._logger = logger or logging.getLogger(__name__)
-        self._auto_restart = auto_restart
+        disable_restart_env = os.environ.get(
+            "CODEX_DISABLE_APP_SERVER_AUTORESTART_FOR_TESTS"
+        )
+        if disable_restart_env:
+            self._auto_restart = False
+        elif auto_restart is None:
+            self._auto_restart = True
+        else:
+            self._auto_restart = auto_restart
         self._request_timeout = request_timeout
+        self._turn_stall_timeout_seconds = turn_stall_timeout_seconds
+        self._turn_stall_poll_interval_seconds = turn_stall_poll_interval_seconds
+        self._turn_stall_recovery_min_interval_seconds = (
+            turn_stall_recovery_min_interval_seconds
+        )
+        self._max_message_bytes = max_message_bytes
+        self._oversize_preview_bytes = oversize_preview_bytes
+        self._max_oversize_drain_bytes = max_oversize_drain_bytes
+        self._restart_backoff_initial_seconds = restart_backoff_initial_seconds
+        self._restart_backoff_max_seconds = restart_backoff_max_seconds
+        self._restart_backoff_jitter_ratio = restart_backoff_jitter_ratio
         self._default_approval_decision = default_approval_decision
         self._max_handles = max_handles
         self._idle_ttl_seconds = idle_ttl_seconds
@@ -78,7 +108,8 @@ class WorkspaceAppServerSupervisor:
                     last_used_at=handle.last_used_at,
                 )
                 await handle.client.close()
-            except Exception:
+            except Exception as exc:
+                self._logger.debug("Failed to close handle: %s", exc)
                 continue
 
     async def prune_idle(self) -> int:
@@ -100,7 +131,8 @@ class WorkspaceAppServerSupervisor:
                 )
                 await handle.client.close()
                 closed += 1
-            except Exception:
+            except Exception as exc:
+                self._logger.debug("Failed to prune handle: %s", exc)
                 continue
         return closed
 
@@ -129,6 +161,15 @@ class WorkspaceAppServerSupervisor:
                 default_approval_decision=self._default_approval_decision,
                 auto_restart=self._auto_restart,
                 request_timeout=self._request_timeout,
+                turn_stall_timeout_seconds=self._turn_stall_timeout_seconds,
+                turn_stall_poll_interval_seconds=self._turn_stall_poll_interval_seconds,
+                turn_stall_recovery_min_interval_seconds=self._turn_stall_recovery_min_interval_seconds,
+                max_message_bytes=self._max_message_bytes,
+                oversize_preview_bytes=self._oversize_preview_bytes,
+                max_oversize_drain_bytes=self._max_oversize_drain_bytes,
+                restart_backoff_initial_seconds=self._restart_backoff_initial_seconds,
+                restart_backoff_max_seconds=self._restart_backoff_max_seconds,
+                restart_backoff_jitter_ratio=self._restart_backoff_jitter_ratio,
                 notification_handler=self._notification_handler,
                 logger=self._logger,
             )
@@ -157,7 +198,8 @@ class WorkspaceAppServerSupervisor:
                     last_used_at=handle.last_used_at,
                 )
                 await handle.client.close()
-            except Exception:
+            except Exception as exc:
+                self._logger.debug("Failed to close handle: %s", exc)
                 continue
         return handle
 
@@ -173,35 +215,19 @@ class WorkspaceAppServerSupervisor:
             return self._pop_idle_handles_locked()
 
     def _pop_idle_handles_locked(self) -> list[AppServerHandle]:
-        if not self._idle_ttl_seconds or self._idle_ttl_seconds <= 0:
-            return []
-        cutoff = time.monotonic() - self._idle_ttl_seconds
-        stale: list[AppServerHandle] = []
-        for handle in list(self._handles.values()):
-            if handle.last_used_at and handle.last_used_at < cutoff:
-                self._handles.pop(handle.workspace_id, None)
-                stale.append(handle)
-        return stale
+        return pop_idle_handles_locked(
+            self._handles,
+            self._idle_ttl_seconds,
+            self._logger,
+            "app_server",
+            last_used_at_getter=lambda h: h.last_used_at,
+        )
 
     def _evict_lru_handle_locked(self) -> Optional[AppServerHandle]:
-        if not self._max_handles or self._max_handles <= 0:
-            return None
-        if len(self._handles) < self._max_handles:
-            return None
-        lru_handle = min(
-            self._handles.values(),
-            key=lambda handle: handle.last_used_at or 0.0,
-        )
-        log_event(
+        return evict_lru_handle_locked(
+            self._handles,
+            self._max_handles,
             self._logger,
-            logging.INFO,
-            "app_server.handle.evicted",
-            reason="max_handles",
-            workspace_id=lru_handle.workspace_id,
-            workspace_root=str(lru_handle.workspace_root),
-            max_handles=self._max_handles,
-            handle_count=len(self._handles),
-            last_used_at=lru_handle.last_used_at,
+            "app_server",
+            last_used_at_getter=lambda h: h.last_used_at or 0.0,
         )
-        self._handles.pop(lru_handle.workspace_id, None)
-        return lru_handle