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

codex_autorunner/core/hub.py

@@ -5,7 +5,7 @@ import re
 import shutil
 import time
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import Callable, Dict, List, Optional, Tuple
 
 from ..bootstrap import seed_repo_files
 from ..discovery import DiscoveryRecord, discover_and_init
@@ -16,12 +16,15 @@ from ..manifest import (
     sanitize_repo_id,
     save_manifest,
 )
+from .archive import archive_worktree_snapshot, build_snapshot_id
 from .config import HubConfig, RepoConfig, derive_repo_config, load_hub_config
-from .engine import Engine
+from .engine import AppServerSupervisorFactory, BackendFactory, Engine
 from .git_utils import (
     GitError,
     git_available,
+    git_branch,
     git_default_branch,
+    git_head_sha,
     git_is_clean,
     git_upstream_status,
     run_git,
@@ -33,6 +36,9 @@ from .utils import atomic_write
 
 logger = logging.getLogger("codex_autorunner.hub")
 
+BackendFactoryBuilder = Callable[[Path, RepoConfig], BackendFactory]
+AppServerSupervisorFactoryBuilder = Callable[[RepoConfig], AppServerSupervisorFactory]
+
 
 def _git_failure_detail(proc) -> str:
     return (proc.stderr or proc.stdout or "").strip() or f"exit {proc.returncode}"
@@ -137,7 +143,8 @@ def load_hub_state(state_path: Path, hub_root: Path) -> HubState:
         import json
 
         payload = json.loads(data)
-    except Exception:
+    except Exception as exc:
+        logger.warning("Failed to parse hub state from %s: %s", state_path, exc)
         return HubState(last_scan_at=None, repos=[])
     last_scan_at = payload.get("last_scan_at")
     repos_payload = payload.get("repos") or []
@@ -168,7 +175,13 @@ def load_hub_state(state_path: Path, hub_root: Path) -> HubState:
                 runner_pid=entry.get("runner_pid"),
             )
             repos.append(repo)
-        except Exception:
+        except Exception as exc:
+            repo_id = entry.get("id", "unknown")
+            logger.warning(
+                "Failed to load repo snapshot for id=%s from hub state: %s",
+                repo_id,
+                exc,
+            )
             continue
     return HubState(last_scan_at=last_scan_at, repos=repos)
 
@@ -188,9 +201,30 @@ class RepoRunner:
         *,
         repo_config: RepoConfig,
         spawn_fn: Optional[SpawnRunnerFn] = None,
+        backend_factory_builder: Optional[BackendFactoryBuilder] = None,
+        app_server_supervisor_factory_builder: Optional[
+            AppServerSupervisorFactoryBuilder
+        ] = None,
+        agent_id_validator: Optional[Callable[[str], str]] = None,
     ):
         self.repo_id = repo_id
-        self._engine = Engine(repo_root, config=repo_config)
+        backend_factory = (
+            backend_factory_builder(repo_root, repo_config)
+            if backend_factory_builder is not None
+            else None
+        )
+        app_server_supervisor_factory = (
+            app_server_supervisor_factory_builder(repo_config)
+            if app_server_supervisor_factory_builder is not None
+            else None
+        )
+        self._engine = Engine(
+            repo_root,
+            config=repo_config,
+            backend_factory=backend_factory,
+            app_server_supervisor_factory=app_server_supervisor_factory,
+            agent_id_validator=agent_id_validator,
+        )
         self._controller = ProcessRunnerController(self._engine, spawn_fn=spawn_fn)
 
     @property
@@ -212,21 +246,46 @@ class RepoRunner:
 
 class HubSupervisor:
     def __init__(
-        self, hub_config: HubConfig, *, spawn_fn: Optional[SpawnRunnerFn] = None
+        self,
+        hub_config: HubConfig,
+        *,
+        spawn_fn: Optional[SpawnRunnerFn] = None,
+        backend_factory_builder: Optional[BackendFactoryBuilder] = None,
+        app_server_supervisor_factory_builder: Optional[
+            AppServerSupervisorFactoryBuilder
+        ] = None,
+        agent_id_validator: Optional[Callable[[str], str]] = None,
     ):
         self.hub_config = hub_config
         self.state_path = hub_config.root / ".codex-autorunner" / "hub_state.json"
         self._runners: Dict[str, RepoRunner] = {}
         self._spawn_fn = spawn_fn
+        self._backend_factory_builder = backend_factory_builder
+        self._app_server_supervisor_factory_builder = (
+            app_server_supervisor_factory_builder
+        )
+        self._agent_id_validator = agent_id_validator
         self.state = load_hub_state(self.state_path, self.hub_config.root)
         self._list_cache_at: Optional[float] = None
         self._list_cache: Optional[List[RepoSnapshot]] = None
         self._reconcile_startup()
 
     @classmethod
-    def from_path(cls, path: Path) -> "HubSupervisor":
+    def from_path(
+        cls,
+        path: Path,
+        *,
+        backend_factory_builder: Optional[BackendFactoryBuilder] = None,
+        app_server_supervisor_factory_builder: Optional[
+            AppServerSupervisorFactoryBuilder
+        ] = None,
+    ) -> "HubSupervisor":
         config = load_hub_config(path)
-        return cls(config)
+        return cls(
+            config,
+            backend_factory_builder=backend_factory_builder,
+            app_server_supervisor_factory_builder=app_server_supervisor_factory_builder,
+        )
 
     def scan(self) -> List[RepoSnapshot]:
         self._invalidate_list_cache()
@@ -261,8 +320,24 @@ class HubSupervisor:
                 repo_config = derive_repo_config(
                     self.hub_config, record.absolute_path, load_env=False
                 )
+                backend_factory = (
+                    self._backend_factory_builder(record.absolute_path, repo_config)
+                    if self._backend_factory_builder is not None
+                    else None
+                )
+                app_server_supervisor_factory = (
+                    self._app_server_supervisor_factory_builder(repo_config)
+                    if self._app_server_supervisor_factory_builder is not None
+                    else None
+                )
                 controller = ProcessRunnerController(
-                    Engine(record.absolute_path, config=repo_config)
+                    Engine(
+                        record.absolute_path,
+                        config=repo_config,
+                        backend_factory=backend_factory,
+                        app_server_supervisor_factory=app_server_supervisor_factory,
+                        agent_id_validator=self._agent_id_validator,
+                    )
                 )
                 controller.reconcile()
             except Exception as exc:
@@ -586,6 +661,9 @@ class HubSupervisor:
         worktree_repo_id: str,
         delete_branch: bool = False,
         delete_remote: bool = False,
+        archive: bool = True,
+        force_archive: bool = False,
+        archive_note: Optional[str] = None,
     ) -> None:
         self._invalidate_list_cache()
         manifest = load_manifest(self.hub_config.manifest_path, self.hub_config.root)
@@ -606,6 +684,44 @@ class HubSupervisor:
         if runner:
             runner.stop()
 
+        if archive:
+            branch_name = entry.branch or git_branch(worktree_path) or "unknown"
+            head_sha = git_head_sha(worktree_path) or "unknown"
+            snapshot_id = build_snapshot_id(branch_name, head_sha)
+            logger.info(
+                "Hub archive worktree start id=%s snapshot_id=%s",
+                worktree_repo_id,
+                snapshot_id,
+            )
+            try:
+                result = archive_worktree_snapshot(
+                    base_repo_root=base_path,
+                    base_repo_id=base.id,
+                    worktree_repo_root=worktree_path,
+                    worktree_repo_id=worktree_repo_id,
+                    branch=branch_name,
+                    worktree_of=entry.worktree_of,
+                    note=archive_note,
+                    snapshot_id=snapshot_id,
+                    head_sha=head_sha,
+                    source_path=entry.path,
+                )
+            except Exception as exc:
+                logger.exception(
+                    "Hub archive worktree failed id=%s snapshot_id=%s",
+                    worktree_repo_id,
+                    snapshot_id,
+                )
+                if not force_archive:
+                    raise ValueError(f"Worktree archive failed: {exc}") from exc
+            else:
+                logger.info(
+                    "Hub archive worktree complete id=%s snapshot_id=%s status=%s",
+                    worktree_repo_id,
+                    result.snapshot_id,
+                    result.status,
+                )
+
         # Remove worktree from base repo.
         try:
             proc = run_git(
@@ -759,10 +875,10 @@ class HubSupervisor:
         if not repo:
             raise ValueError(f"Repo {repo_id} not found in manifest")
         repo_root = (self.hub_config.root / repo.path).resolve()
-        state_path = repo_root / ".codex-autorunner" / "state.sqlite3"
-        if not allow_uninitialized and not state_path.exists():
+        tickets_dir = repo_root / ".codex-autorunner" / "tickets"
+        if not allow_uninitialized and not tickets_dir.exists():
             raise ValueError(f"Repo {repo_id} is not initialized")
-        if not state_path.exists():
+        if not tickets_dir.exists():
             return None
         repo_config = derive_repo_config(self.hub_config, repo_root, load_env=False)
         runner = RepoRunner(
@@ -770,6 +886,11 @@ class HubSupervisor:
             repo_root,
             repo_config=repo_config,
             spawn_fn=self._spawn_fn,
+            backend_factory_builder=self._backend_factory_builder,
+            app_server_supervisor_factory_builder=(
+                self._app_server_supervisor_factory_builder
+            ),
+            agent_id_validator=self._agent_id_validator,
         )
         self._runners[repo_id] = runner
         return runner
@@ -781,7 +902,7 @@ class HubSupervisor:
         records: List[DiscoveryRecord] = []
         for entry in manifest.repos:
             repo_path = (self.hub_config.root / entry.path).resolve()
-            initialized = (repo_path / ".codex-autorunner" / "state.sqlite3").exists()
+            initialized = (repo_path / ".codex-autorunner" / "tickets").exists()
             records.append(
                 DiscoveryRecord(
                     repo=entry,
@@ -821,9 +942,8 @@ class HubSupervisor:
         lock_status = read_lock_status(lock_path)
 
         runner_state: Optional[RunnerState] = None
-        state_path = repo_path / ".codex-autorunner" / "state.sqlite3"
-        if record.initialized and state_path.exists():
-            runner_state = load_state(state_path)
+        if record.initialized:
+            runner_state = load_state(repo_path / ".codex-autorunner" / "state.sqlite3")
 
         is_clean: Optional[bool] = None
         if record.exists_on_disk and git_available(repo_path):

codex_autorunner/core/locks.py

@@ -1,5 +1,6 @@
 import errno
 import json
+import logging
 import os
 import socket
 import subprocess
@@ -27,6 +28,7 @@ class LockAssessment:
 
 
 DEFAULT_RUNNER_CMD_HINTS = ("codex_autorunner.cli", "codex-autorunner", "car ")
+logger = logging.getLogger(__name__)
 
 
 def process_alive(pid: int) -> bool:
@@ -48,6 +50,7 @@ def process_is_zombie(pid: int) -> bool:
             check=False,
         )
     except Exception:
+        logger.debug("Failed to check process status for pid %s", pid, exc_info=True)
         return False
     if result.returncode != 0:
         return False
@@ -65,6 +68,7 @@ def process_command(pid: int) -> Optional[str]:
             check=False,
         )
     except Exception:
+        logger.debug("Failed to inspect process command for pid %s", pid, exc_info=True)
         return None
     if result.returncode != 0:
         return None

codex_autorunner/core/notifications.py

@@ -23,6 +23,18 @@ class NotificationManager:
         self._warned_missing: set[str] = set()
         self._enabled_mode = self._parse_enabled(self._cfg.get("enabled"))
         self._events = self._normalize_events(self._cfg.get("events"))
+        timeout_raw = self._cfg.get("timeout_seconds", DEFAULT_TIMEOUT_SECONDS)
+        try:
+            timeout_seconds = (
+                float(timeout_raw)
+                if timeout_raw is not None
+                else DEFAULT_TIMEOUT_SECONDS
+            )
+        except (TypeError, ValueError):
+            timeout_seconds = DEFAULT_TIMEOUT_SECONDS
+        if timeout_seconds <= 0:
+            timeout_seconds = DEFAULT_TIMEOUT_SECONDS
+        self._timeout_seconds = timeout_seconds
         self._warn_unknown_events(self._events)
         discord_cfg = self._cfg.get("discord")
         self._discord: Dict[str, Any] = (
@@ -202,7 +214,7 @@ class NotificationManager:
         if not targets:
             return
         try:
-            with httpx.Client(timeout=DEFAULT_TIMEOUT_SECONDS) as client:
+            with httpx.Client(timeout=self._timeout_seconds) as client:
                 self._send_sync(client, targets, message)
         except Exception as exc:
             self._log_warning("Notification delivery failed", exc)
@@ -216,7 +228,7 @@ class NotificationManager:
         if not targets:
             return
         try:
-            async with httpx.AsyncClient(timeout=DEFAULT_TIMEOUT_SECONDS) as client:
+            async with httpx.AsyncClient(timeout=self._timeout_seconds) as client:
                 await self._send_async(client, targets, message)
         except Exception as exc:
             self._log_warning("Notification delivery failed", exc)

codex_autorunner/core/ports/__init__.py

@@ -0,0 +1,28 @@
+from .agent_backend import AgentBackend, AgentEvent, AgentEventType, now_iso
+from .run_event import (
+    ApprovalRequested,
+    Completed,
+    Failed,
+    OutputDelta,
+    RunEvent,
+    RunNotice,
+    Started,
+    TokenUsage,
+    ToolCall,
+)
+
+__all__ = [
+    "AgentBackend",
+    "AgentEvent",
+    "AgentEventType",
+    "now_iso",
+    "RunEvent",
+    "Started",
+    "OutputDelta",
+    "ToolCall",
+    "ApprovalRequested",
+    "TokenUsage",
+    "RunNotice",
+    "Completed",
+    "Failed",
+]

codex_autorunner/core/ports/agent_backend.py

@@ -0,0 +1,150 @@
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, AsyncGenerator, Dict, Optional
+
+_logger = logging.getLogger(__name__)
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+class AgentEventType(str, Enum):
+    STREAM_DELTA = "stream_delta"
+    TOOL_CALL = "tool_call"
+    TOOL_RESULT = "tool_result"
+    MESSAGE_COMPLETE = "message_complete"
+    ERROR = "error"
+    APPROVAL_REQUESTED = "approval_requested"
+    APPROVAL_GRANTED = "approval_granted"
+    APPROVAL_DENIED = "approval_denied"
+    SESSION_STARTED = "session_started"
+    SESSION_ENDED = "session_ended"
+    SESION_STARTED = "session_started"  # legacy typo kept for backward tests
+
+
+@dataclass
+class AgentEvent:
+    type: str
+    timestamp: str
+    data: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def event_type(self) -> AgentEventType:
+        try:
+            return AgentEventType(self.type)
+        except ValueError:
+            return AgentEventType.ERROR
+
+    @classmethod
+    def stream_delta(cls, content: str, delta_type: str = "text") -> "AgentEvent":
+        return cls(
+            type=AgentEventType.STREAM_DELTA.value,
+            timestamp=now_iso(),
+            data={"content": content, "delta_type": delta_type},
+        )
+
+    @classmethod
+    def tool_call(cls, tool_name: str, tool_input: Dict[str, Any]) -> "AgentEvent":
+        return cls(
+            type=AgentEventType.TOOL_CALL.value,
+            timestamp=now_iso(),
+            data={"tool_name": tool_name, "tool_input": tool_input},
+        )
+
+    @classmethod
+    def tool_result(
+        cls, tool_name: str, result: Any, error: Optional[str] = None
+    ) -> "AgentEvent":
+        return cls(
+            type=AgentEventType.TOOL_RESULT.value,
+            timestamp=now_iso(),
+            data={"tool_name": tool_name, "result": result, "error": error},
+        )
+
+    @classmethod
+    def message_complete(cls, final_message: str) -> "AgentEvent":
+        return cls(
+            type=AgentEventType.MESSAGE_COMPLETE.value,
+            timestamp=now_iso(),
+            data={"final_message": final_message},
+        )
+
+    @classmethod
+    def error(cls, error_message: str) -> "AgentEvent":
+        return cls(
+            type=AgentEventType.ERROR.value,
+            timestamp=now_iso(),
+            data={"error": error_message},
+        )
+
+    @classmethod
+    def approval_requested(
+        cls, request_id: str, description: str, context: Optional[Dict[str, Any]] = None
+    ) -> "AgentEvent":
+        return cls(
+            type=AgentEventType.APPROVAL_REQUESTED.value,
+            timestamp=now_iso(),
+            data={
+                "request_id": request_id,
+                "description": description,
+                "context": context or {},
+            },
+        )
+
+    @classmethod
+    def approval_granted(cls, request_id: str) -> "AgentEvent":
+        return cls(
+            type=AgentEventType.APPROVAL_GRANTED.value,
+            timestamp=now_iso(),
+            data={"request_id": request_id},
+        )
+
+    @classmethod
+    def approval_denied(
+        cls, request_id: str, reason: Optional[str] = None
+    ) -> "AgentEvent":
+        return cls(
+            type=AgentEventType.APPROVAL_DENIED.value,
+            timestamp=now_iso(),
+            data={"request_id": request_id, "reason": reason},
+        )
+
+
+class AgentBackend:
+    async def start_session(self, target: dict, context: dict) -> str:
+        raise NotImplementedError
+
+    def run_turn(
+        self, session_id: str, message: str
+    ) -> AsyncGenerator[AgentEvent, None]:
+        raise NotImplementedError
+
+    def stream_events(self, session_id: str) -> AsyncGenerator[AgentEvent, None]:
+        raise NotImplementedError
+
+    def run_turn_events(
+        self, session_id: str, message: str
+    ) -> AsyncGenerator[Any, None]:
+        raise NotImplementedError
+
+    async def interrupt(self, session_id: str) -> None:
+        raise NotImplementedError
+
+    async def final_messages(self, session_id: str) -> list[str]:
+        raise NotImplementedError
+
+    async def request_approval(
+        self, description: str, context: Optional[Dict[str, Any]] = None
+    ) -> bool:
+        raise NotImplementedError
+
+
+__all__ = [
+    "AgentBackend",
+    "AgentEvent",
+    "AgentEventType",
+    "now_iso",
+]

codex_autorunner/core/ports/backend_orchestrator.py

@@ -0,0 +1,41 @@
+"""Protocol for backend orchestrators used by the Engine."""
+
+from __future__ import annotations
+
+from typing import Any, AsyncGenerator, Optional, Protocol
+
+from .run_event import RunEvent
+
+
+class BackendOrchestrator(Protocol):
+    def run_turn(
+        self,
+        *,
+        agent_id: str,
+        state: Any,
+        prompt: str,
+        model: Optional[str],
+        reasoning: Optional[str],
+        session_key: str,
+    ) -> AsyncGenerator[RunEvent, None]: ...
+
+    async def interrupt(self, agent_id: str, state: Any) -> None: ...
+
+    def get_thread_id(self, session_key: str) -> Optional[str]: ...
+
+    def set_thread_id(self, session_key: str, thread_id: str) -> None: ...
+
+    def build_app_server_supervisor(
+        self,
+        *,
+        event_prefix: str,
+        notification_handler: Optional[Any] = None,
+    ) -> Optional[Any]: ...
+
+    def ensure_opencode_supervisor(self) -> Optional[Any]: ...
+
+    def get_last_turn_id(self) -> Optional[str]: ...
+
+    def get_last_thread_info(self) -> Optional[dict[str, Any]]: ...
+
+    def get_last_token_total(self) -> Optional[dict[str, Any]]: ...

codex_autorunner/core/ports/run_event.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Optional, Union
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+@dataclass(frozen=True)
+class Started:
+    timestamp: str
+    session_id: str
+    thread_id: Optional[str] = None
+    turn_id: Optional[str] = None
+
+
+@dataclass(frozen=True)
+class OutputDelta:
+    timestamp: str
+    content: str
+    delta_type: str = "text"
+
+
+@dataclass(frozen=True)
+class ToolCall:
+    timestamp: str
+    tool_name: str
+    tool_input: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class ApprovalRequested:
+    timestamp: str
+    request_id: str
+    description: str
+    context: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class TokenUsage:
+    timestamp: str
+    usage: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class RunNotice:
+    timestamp: str
+    kind: str
+    message: str = ""
+    data: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class Completed:
+    timestamp: str
+    final_message: str = ""
+
+
+@dataclass(frozen=True)
+class Failed:
+    timestamp: str
+    error_message: str
+
+
+RunEvent = Union[
+    Started,
+    OutputDelta,
+    ToolCall,
+    ApprovalRequested,
+    TokenUsage,
+    RunNotice,
+    Completed,
+    Failed,
+]
+
+
+__all__ = [
+    "RunEvent",
+    "Started",
+    "OutputDelta",
+    "ToolCall",
+    "ApprovalRequested",
+    "TokenUsage",
+    "RunNotice",
+    "Completed",
+    "Failed",
+    "now_iso",
+]

codex_autorunner/core/prompt.py

@@ -15,12 +15,20 @@ def _display_path(root: Path, path: Path) -> str:
 
 
 def build_doc_paths(config: Config) -> Mapping[str, str]:
+    def _safe_path(*keys: str) -> str:
+        for key in keys:
+            try:
+                return _display_path(config.root, config.doc_path(key))
+            except KeyError:
+                continue
+        return ""
+
     return {
-        "todo": _display_path(config.root, config.doc_path("todo")),
-        "progress": _display_path(config.root, config.doc_path("progress")),
-        "opinions": _display_path(config.root, config.doc_path("opinions")),
-        "spec": _display_path(config.root, config.doc_path("spec")),
-        "summary": _display_path(config.root, config.doc_path("summary")),
+        "todo": _safe_path("todo", "active_context"),
+        "progress": _safe_path("progress", "decisions"),
+        "opinions": _safe_path("opinions"),
+        "spec": _safe_path("spec"),
+        "summary": _safe_path("summary"),
     }
 
 
@@ -64,8 +72,8 @@ def build_final_summary_prompt(
 
     doc_paths = build_doc_paths(config)
     doc_contents = {
-        "todo": docs.read_doc("todo"),
-        "progress": docs.read_doc("progress"),
+        "todo": docs.read_doc("todo") or docs.read_doc("active_context"),
+        "progress": docs.read_doc("progress") or docs.read_doc("decisions"),
         "opinions": docs.read_doc("opinions"),
         "spec": docs.read_doc("spec"),
         "summary": docs.read_doc("summary"),