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

codex_autorunner/core/supervisor_utils.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any, Callable, TypeVar
+
+from .logging_utils import log_event
+
+HandleT = TypeVar("HandleT", bound=Any)
+
+
+def evict_lru_handle_locked(
+    handles: dict[str, HandleT],
+    max_handles: int | None,
+    logger: logging.Logger,
+    event_prefix: str,
+    *,
+    last_used_at_getter: Callable[[HandleT], float],
+) -> HandleT | None:
+    if not max_handles or max_handles <= 0:
+        return None
+    if len(handles) < max_handles:
+        return None
+    lru_handle = min(handles.values(), key=last_used_at_getter)
+    log_event(
+        logger,
+        logging.INFO,
+        f"{event_prefix}.handle.evicted",
+        reason="max_handles",
+        workspace_id=lru_handle.workspace_id,
+        workspace_root=str(lru_handle.workspace_root),
+        max_handles=max_handles,
+        handle_count=len(handles),
+        last_used_at=last_used_at_getter(lru_handle),
+    )
+    handles.pop(lru_handle.workspace_id, None)
+    return lru_handle
+
+
+def pop_idle_handles_locked(
+    handles: dict[str, HandleT],
+    idle_ttl_seconds: float | None,
+    logger: logging.Logger,
+    event_prefix: str,
+    *,
+    last_used_at_getter: Callable[[HandleT], float],
+    should_skip_prune: Callable[[HandleT], bool] | None = None,
+) -> list[HandleT]:
+    if not idle_ttl_seconds or idle_ttl_seconds <= 0:
+        return []
+    cutoff = time.monotonic() - idle_ttl_seconds
+    stale: list[HandleT] = []
+    for handle in list(handles.values()):
+        if should_skip_prune and should_skip_prune(handle):
+            log_event(
+                logger,
+                logging.INFO,
+                f"{event_prefix}.handle.prune.skipped",
+                reason="should_skip",
+                workspace_id=handle.workspace_id,
+                workspace_root=str(handle.workspace_root),
+            )
+            continue
+        if last_used_at_getter(handle) and last_used_at_getter(handle) < cutoff:
+            handles.pop(handle.workspace_id, None)
+            stale.append(handle)
+    return stale

codex_autorunner/core/update.py

@@ -378,6 +378,7 @@ def _system_update_worker(
     update_dir: Path,
     logger: logging.Logger,
     update_target: str = "both",
+    skip_checks: bool = False,
 ) -> None:
     status_path = _update_status_path()
     lock_acquired = False
@@ -457,10 +458,14 @@ def _system_update_worker(
             _run_cmd(["git", "fetch", "origin", repo_ref], cwd=update_dir)
             _run_cmd(["git", "reset", "--hard", "FETCH_HEAD"], cwd=update_dir)
 
-        if os.environ.get("CODEX_AUTORUNNER_SKIP_UPDATE_CHECKS") == "1":
-            logger.info(
-                "Skipping update checks (CODEX_AUTORUNNER_SKIP_UPDATE_CHECKS=1)."
-            )
+        skip_checks_env = os.environ.get("CODEX_AUTORUNNER_SKIP_UPDATE_CHECKS") == "1"
+        if skip_checks_env or skip_checks:
+            if skip_checks_env:
+                logger.info(
+                    "Skipping update checks (CODEX_AUTORUNNER_SKIP_UPDATE_CHECKS=1)."
+                )
+            else:
+                logger.info("Skipping update checks (update.skip_checks=true).")
         else:
             logger.info("Running checks...")
             try:
@@ -526,6 +531,7 @@ def _spawn_update_process(
     update_dir: Path,
     logger: logging.Logger,
     update_target: str = "both",
+    skip_checks: bool = False,
     notify_chat_id: Optional[int] = None,
     notify_thread_id: Optional[int] = None,
     notify_reply_to: Optional[int] = None,
@@ -565,14 +571,17 @@ def _spawn_update_process(
         "--log-path",
         str(log_path),
     ]
+    if skip_checks:
+        cmd.append("--skip-checks")
     try:
-        subprocess.Popen(
-            cmd,
-            cwd=str(update_dir.parent),
-            start_new_session=True,
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
+        with log_path.open("a", encoding="utf-8") as log_file:
+            subprocess.Popen(
+                cmd,
+                cwd=str(update_dir.parent),
+                start_new_session=True,
+                stdout=log_file,
+                stderr=log_file,
+            )
     except Exception:
         logger.exception("Failed to spawn update worker")
         _write_update_status(

codex_autorunner/core/update_runner.py

@@ -23,6 +23,7 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--update-dir", required=True)
     parser.add_argument("--log-path", required=True)
     parser.add_argument("--target", default="both")
+    parser.add_argument("--skip-checks", action="store_true")
     args = parser.parse_args(argv)
 
     update_dir = Path(args.update_dir).expanduser()
@@ -36,6 +37,7 @@ def main(argv: list[str] | None = None) -> int:
         update_dir=update_dir,
         logger=logger,
         update_target=args.target,
+        skip_checks=bool(args.skip_checks),
     )
     return 0
 

codex_autorunner/core/utils.py

@@ -1,3 +1,4 @@
+import contextvars
 import json
 import logging
 import os
@@ -23,8 +24,32 @@ class RepoNotFoundError(Exception):
     pass
 
 
-def find_repo_root(start: Path) -> Path:
-    current = start.resolve()
+_repo_root_ctx: contextvars.ContextVar[Optional[Path]] = contextvars.ContextVar(
+    "codex_autorunner_repo_root", default=None
+)
+
+
+def set_repo_root_context(
+    repo_root: Optional[Path],
+) -> contextvars.Token[Optional[Path]]:
+    """Set the current repo root for the active context."""
+    return _repo_root_ctx.set(repo_root.resolve() if repo_root else None)
+
+
+def reset_repo_root_context(token: contextvars.Token[Optional[Path]]) -> None:
+    _repo_root_ctx.reset(token)
+
+
+def get_repo_root_context() -> Optional[Path]:
+    return _repo_root_ctx.get()
+
+
+def find_repo_root(start: Optional[Path] = None) -> Path:
+    ctx_root = get_repo_root_context()
+    if ctx_root is not None and (ctx_root / ".git").exists():
+        return ctx_root
+
+    current = (start or Path.cwd()).resolve()
     for parent in [current] + list(current.parents):
         if (parent / ".git").exists():
             return parent
@@ -190,6 +215,7 @@ def build_opencode_supervisor(
     request_timeout: Optional[float] = None,
     max_handles: Optional[int] = None,
     idle_ttl_seconds: Optional[float] = None,
+    session_stall_timeout_seconds: Optional[float] = None,
     base_env: Optional[MutableMapping[str, str]] = None,
     subagent_models: Optional[Mapping[str, str]] = None,
 ) -> Optional["OpenCodeSupervisor"]:
@@ -244,6 +270,7 @@ def build_opencode_supervisor(
         request_timeout=request_timeout,
         max_handles=max_handles,
         idle_ttl_seconds=idle_ttl_seconds,
+        session_stall_timeout_seconds=session_stall_timeout_seconds,
         username=username if password else None,
         password=password if password else None,
         base_env=base_env,

codex_autorunner/discovery.py

@@ -57,7 +57,7 @@ def discover_and_init(hub_config: HubConfig) -> Tuple[Manifest, List[DiscoveryRe
 
     def _record_repo(repo_entry: ManifestRepo, *, added: bool) -> None:
         repo_path = (hub_config.root / repo_entry.path).resolve()
-        initialized = (repo_path / ".codex-autorunner" / "state.sqlite3").exists()
+        initialized = (repo_path / ".codex-autorunner" / "tickets").exists()
         init_error: Optional[str] = None
         if hub_config.auto_init_missing and repo_path.exists() and not initialized:
             try:
@@ -176,9 +176,7 @@ def discover_and_init(hub_config: HubConfig) -> Tuple[Manifest, List[DiscoveryRe
                 absolute_path=repo_path,
                 added_to_manifest=False,
                 exists_on_disk=repo_path.exists(),
-                initialized=(
-                    repo_path / ".codex-autorunner" / "state.sqlite3"
-                ).exists(),
+                initialized=(repo_path / ".codex-autorunner" / "tickets").exists(),
                 init_error=None,
             )
         )

codex_autorunner/flows/ticket_flow/__init__.py

@@ -0,0 +1,3 @@
+from .definition import build_ticket_flow_definition
+
+__all__ = ["build_ticket_flow_definition"]

codex_autorunner/flows/ticket_flow/definition.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from ...core.flows.definition import EmitEventFn, FlowDefinition, StepOutcome
+from ...core.flows.models import FlowEventType, FlowRunRecord
+from ...core.utils import find_repo_root
+from ...tickets import AgentPool, TicketRunConfig, TicketRunner
+
+
+def build_ticket_flow_definition(*, agent_pool: AgentPool) -> FlowDefinition:
+    """Build the single-step ticket runner flow.
+
+    The flow is intentionally simple: each step executes at most one agent turn
+    against the current ticket, and re-schedules itself until paused or complete.
+    """
+
+    async def _ticket_turn_step(
+        record: FlowRunRecord,
+        input_data: Dict[str, Any],
+        emit_event: Optional[EmitEventFn],
+    ) -> StepOutcome:
+        # Namespace all state under `ticket_engine` to avoid collisions with other flows.
+        engine_state = (
+            record.state.get("ticket_engine")
+            if isinstance(record.state, dict)
+            else None
+        )
+        engine_state = dict(engine_state) if isinstance(engine_state, dict) else {}
+
+        repo_root = find_repo_root()
+        workspace_root = Path(input_data.get("workspace_root") or repo_root)
+        ticket_dir = Path(input_data.get("ticket_dir") or ".codex-autorunner/tickets")
+        runs_dir = Path(input_data.get("runs_dir") or ".codex-autorunner/runs")
+        max_total_turns = int(input_data.get("max_total_turns") or 25)
+        max_lint_retries = int(input_data.get("max_lint_retries") or 3)
+        max_commit_retries = int(input_data.get("max_commit_retries") or 2)
+        auto_commit = bool(
+            input_data.get("auto_commit") if "auto_commit" in input_data else True
+        )
+
+        runner = TicketRunner(
+            workspace_root=workspace_root,
+            run_id=str(record.id),
+            config=TicketRunConfig(
+                ticket_dir=ticket_dir,
+                runs_dir=runs_dir,
+                max_total_turns=max_total_turns,
+                max_lint_retries=max_lint_retries,
+                max_commit_retries=max_commit_retries,
+                auto_commit=auto_commit,
+            ),
+            agent_pool=agent_pool,
+        )
+
+        if emit_event is not None:
+            emit_event(FlowEventType.STEP_PROGRESS, {"message": "Running ticket turn"})
+        result = await runner.step(engine_state, emit_event=emit_event)
+        out_state = dict(record.state or {})
+        out_state["ticket_engine"] = result.state
+
+        if result.status == "completed":
+            return StepOutcome.complete(output=out_state)
+        if result.status == "paused":
+            return StepOutcome.pause(output=out_state)
+        if result.status == "failed":
+            return StepOutcome.fail(
+                error=result.reason or "Ticket engine failed", output=out_state
+            )
+        return StepOutcome.continue_to(next_steps={"ticket_turn"}, output=out_state)
+
+    return FlowDefinition(
+        flow_type="ticket_flow",
+        name="Ticket Flow",
+        description="Ticket-based agent workflow runner",
+        initial_step="ticket_turn",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "workspace_root": {"type": "string"},
+                "ticket_dir": {"type": "string"},
+                "runs_dir": {"type": "string"},
+                "max_total_turns": {"type": "integer"},
+                "max_lint_retries": {"type": "integer"},
+                "max_commit_retries": {"type": "integer"},
+                "auto_commit": {"type": "boolean"},
+            },
+        },
+        steps={"ticket_turn": _ticket_turn_step},
+    )

codex_autorunner/integrations/agents/__init__.py

@@ -0,0 +1,27 @@
+from .agent_backend import AgentBackend, AgentEvent, AgentEventType
+from .codex_backend import CodexAppServerBackend
+from .opencode_backend import OpenCodeBackend
+from .run_event import (
+    ApprovalRequested,
+    Completed,
+    Failed,
+    OutputDelta,
+    RunEvent,
+    Started,
+    ToolCall,
+)
+
+__all__ = [
+    "AgentBackend",
+    "AgentEvent",
+    "AgentEventType",
+    "CodexAppServerBackend",
+    "OpenCodeBackend",
+    "RunEvent",
+    "Started",
+    "OutputDelta",
+    "ToolCall",
+    "ApprovalRequested",
+    "Completed",
+    "Failed",
+]

codex_autorunner/integrations/agents/agent_backend.py

@@ -0,0 +1,142 @@
+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
+
+    async def run_turn(
+        self, session_id: str, message: str
+    ) -> AsyncGenerator[AgentEvent, None]:
+        raise NotImplementedError
+
+    async def stream_events(self, session_id: str) -> AsyncGenerator[AgentEvent, None]:
+        raise NotImplementedError
+
+    async 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