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

codex_autorunner/surfaces/web/app.py

@@ -2,6 +2,7 @@ import asyncio
 import logging
 import os
 import shlex
+import sys
 import threading
 from contextlib import ExitStack, asynccontextmanager
 from dataclasses import dataclass
@@ -18,6 +19,7 @@ from starlette.types import ASGIApp
 
 from ...agents.opencode.supervisor import OpenCodeSupervisor
 from ...agents.registry import validate_agent_id
+from ...bootstrap import ensure_hub_car_shim
 from ...core.app_server_threads import (
     AppServerThreadRegistry,
     default_app_server_threads_path,
@@ -34,7 +36,6 @@ from ...core.config import (
     load_repo_config,
     resolve_env_for_root,
 )
-from ...core.engine import Engine, LockError
 from ...core.flows.models import FlowRunStatus
 from ...core.flows.reconciler import reconcile_flow_runs
 from ...core.flows.store import FlowStore
@@ -42,6 +43,7 @@ from ...core.hub import HubSupervisor
 from ...core.logging_utils import safe_log, setup_rotating_logger
 from ...core.optional_dependencies import require_optional_dependencies
 from ...core.request_context import get_request_id
+from ...core.runtime import LockError, RuntimeContext
 from ...core.state import load_state, persist_session_registry
 from ...core.usage import (
     UsageError,
@@ -56,6 +58,7 @@ from ...core.utils import (
     set_repo_root_context,
 )
 from ...housekeeping import run_housekeeping_once
+from ...integrations.agents import build_backend_orchestrator
 from ...integrations.agents.wiring import (
     build_agent_backend_factory,
     build_app_server_supervisor_factory,
@@ -65,7 +68,8 @@ from ...integrations.app_server.env import build_app_server_env
 from ...integrations.app_server.event_buffer import AppServerEventBuffer
 from ...integrations.app_server.supervisor import WorkspaceAppServerSupervisor
 from ...manifest import load_manifest
-from ...tickets.files import safe_relpath
+from ...tickets.files import list_ticket_paths, safe_relpath, ticket_is_done
+from ...tickets.models import Dispatch
 from ...tickets.outbox import parse_dispatch, resolve_outbox_paths
 from ...voice import VoiceConfig, VoiceService
 from .hub_jobs import HubJobManager
@@ -77,6 +81,8 @@ from .middleware import (
     SecurityHeadersMiddleware,
 )
 from .routes import build_repo_router
+from .routes.filebox import build_hub_filebox_routes
+from .routes.pma import build_pma_routes
 from .routes.system import build_system_routes
 from .runner_manager import RunnerManager
 from .schemas import (
@@ -101,7 +107,7 @@ from .terminal_sessions import parse_tui_idle_seconds, prune_terminal_registry
 class AppContext:
     base_path: str
     env: Mapping[str, str]
-    engine: Engine
+    engine: RuntimeContext
     manager: RunnerManager
     app_server_supervisor: Optional[WorkspaceAppServerSupervisor]
     app_server_prune_interval: Optional[float]
@@ -135,6 +141,10 @@ class HubAppContext:
     job_manager: HubJobManager
     app_server_supervisor: Optional[WorkspaceAppServerSupervisor]
     app_server_prune_interval: Optional[float]
+    app_server_threads: AppServerThreadRegistry
+    app_server_events: AppServerEventBuffer
+    opencode_supervisor: Optional[OpenCodeSupervisor]
+    opencode_prune_interval: Optional[float]
     static_dir: Path
     static_assets_context: Optional[object]
     asset_version: str
@@ -309,6 +319,7 @@ def _build_opencode_supervisor(
     env: Mapping[str, str],
     subagent_models: Optional[Mapping[str, str]] = None,
     session_stall_timeout_seconds: Optional[float] = None,
+    max_text_chars: Optional[int] = None,
 ) -> tuple[Optional[OpenCodeSupervisor], Optional[float]]:
     supervisor = build_opencode_supervisor(
         opencode_command=opencode_command,
@@ -319,6 +330,7 @@ def _build_opencode_supervisor(
         max_handles=config.max_handles,
         idle_ttl_seconds=config.idle_ttl_seconds,
         session_stall_timeout_seconds=session_stall_timeout_seconds,
+        max_text_chars=max_text_chars,
         base_env=env,
         subagent_models=subagent_models,
     )
@@ -349,12 +361,11 @@ def _build_app_context(
         if base_path is not None
         else config.server_base_path
     )
-    engine = Engine(
+    backend_orchestrator = build_backend_orchestrator(config.root, config)
+    engine = RuntimeContext(
         config.root,
         config=config,
-        backend_factory=build_agent_backend_factory(config.root, config),
-        app_server_supervisor_factory=build_app_server_supervisor_factory(config),
-        agent_id_validator=validate_agent_id,
+        backend_orchestrator=backend_orchestrator,
     )
     manager = RunnerManager(engine)
     voice_config = VoiceConfig.from_raw(config.voice, env=env)
@@ -484,6 +495,7 @@ def _build_app_context(
         env=env,
         subagent_models=subagent_models,
         session_stall_timeout_seconds=config.opencode.session_stall_timeout_seconds,
+        max_text_chars=config.opencode.max_text_chars,
     )
     voice_service: Optional[VoiceService]
     if voice_missing_reason:
@@ -653,6 +665,7 @@ def _build_hub_context(
         config,
         backend_factory_builder=build_agent_backend_factory,
         app_server_supervisor_factory_builder=build_app_server_supervisor_factory,
+        backend_orchestrator_builder=build_backend_orchestrator,
         agent_id_validator=validate_agent_id,
     )
     logger = setup_rotating_logger(f"hub[{config.root}]", config.server_log)
@@ -669,10 +682,42 @@ def _build_hub_context(
         logging.INFO,
         f"Hub app ready at {config.root}",
     )
+    try:
+        ensure_hub_car_shim(config.root, python_executable=sys.executable)
+    except Exception as exc:
+        safe_log(
+            logger,
+            logging.WARNING,
+            "Failed to ensure hub car shim",
+            exc=exc,
+        )
+    app_server_events = AppServerEventBuffer()
     app_server_supervisor, app_server_prune_interval = _build_app_server_supervisor(
         config.app_server,
         logger=logger,
         event_prefix="hub.app_server",
+        notification_handler=app_server_events.handle_notification,
+    )
+    app_server_threads = AppServerThreadRegistry(
+        default_app_server_threads_path(config.root)
+    )
+    opencode_command = config.agent_serve_command("opencode")
+    try:
+        opencode_binary = config.agent_binary("opencode")
+    except ConfigError:
+        opencode_binary = None
+    agent_config = config.agents.get("opencode")
+    subagent_models = agent_config.subagent_models if agent_config else None
+    opencode_supervisor, opencode_prune_interval = _build_opencode_supervisor(
+        config.app_server,
+        workspace_root=config.root,
+        opencode_binary=opencode_binary,
+        opencode_command=opencode_command,
+        logger=logger,
+        env=resolve_env_for_root(config.root),
+        subagent_models=subagent_models,
+        session_stall_timeout_seconds=config.opencode.session_stall_timeout_seconds,
+        max_text_chars=config.opencode.max_text_chars,
     )
     static_dir, static_context = materialize_static_assets(
         config.static_assets.cache_root,
@@ -699,6 +744,10 @@ def _build_hub_context(
         job_manager=HubJobManager(logger=logger),
         app_server_supervisor=app_server_supervisor,
         app_server_prune_interval=app_server_prune_interval,
+        app_server_threads=app_server_threads,
+        app_server_events=app_server_events,
+        opencode_supervisor=opencode_supervisor,
+        opencode_prune_interval=opencode_prune_interval,
         static_dir=static_dir,
         static_assets_context=static_context,
         asset_version=asset_version(static_dir),
@@ -713,9 +762,14 @@ def _apply_hub_context(app: FastAPI, context: HubAppContext) -> None:
     app.state.job_manager = context.job_manager
     app.state.app_server_supervisor = context.app_server_supervisor
     app.state.app_server_prune_interval = context.app_server_prune_interval
+    app.state.app_server_threads = context.app_server_threads
+    app.state.app_server_events = context.app_server_events
+    app.state.opencode_supervisor = context.opencode_supervisor
+    app.state.opencode_prune_interval = context.opencode_prune_interval
     app.state.static_dir = context.static_dir
     app.state.static_assets_context = context.static_assets_context
     app.state.asset_version = context.asset_version
+    app.state.hub_supervisor = context.supervisor
 
 
 def _app_lifespan(context: AppContext):
@@ -1097,6 +1151,11 @@ def create_hub_app(
     app.state.static_assets_lock = threading.Lock()
     app.state.hub_static_assets = None
     app.mount("/static", static_files, name="static")
+    raw_config = getattr(context.config, "raw", {})
+    pma_config = raw_config.get("pma", {}) if isinstance(raw_config, dict) else {}
+    if isinstance(pma_config, dict) and pma_config.get("enabled"):
+        app.include_router(build_pma_routes())
+    app.include_router(build_hub_filebox_routes())
     mounted_repos: set[str] = set()
     mount_errors: dict[str, str] = {}
     repo_apps: dict[str, ASGIApp] = {}
@@ -1322,6 +1381,53 @@ def create_hub_app(
             repo_dict["mounted"] = False
         return repo_dict
 
+    def _get_ticket_flow_summary(repo_path: Path) -> Optional[dict]:
+        """Get ticket flow summary for a repo (status, done/total, step).
+
+        Returns None if no ticket flow exists or repo is not initialized.
+        """
+        db_path = repo_path / ".codex-autorunner" / "flows.db"
+        if not db_path.exists():
+            return None
+        try:
+            config = load_repo_config(repo_path)
+            with FlowStore(db_path, durable=config.durable_writes) as store:
+                # Get the latest ticket_flow run (any status)
+                runs = store.list_flow_runs(flow_type="ticket_flow")
+                if not runs:
+                    return None
+                latest = runs[0]  # Already sorted by created_at DESC
+
+                # Count tickets
+                ticket_dir = repo_path / ".codex-autorunner" / "tickets"
+                total = 0
+                done = 0
+                for path in list_ticket_paths(ticket_dir):
+                    total += 1
+                    try:
+                        if ticket_is_done(path):
+                            done += 1
+                    except Exception:
+                        continue
+
+                if total == 0:
+                    return None
+
+                # Extract current step from ticket_engine state
+                state = latest.state if isinstance(latest.state, dict) else {}
+                engine = state.get("ticket_engine") if isinstance(state, dict) else {}
+                engine = engine if isinstance(engine, dict) else {}
+                current_step = engine.get("total_turns")
+
+                return {
+                    "status": latest.status.value,
+                    "done_count": done,
+                    "total_count": total,
+                    "current_step": current_step,
+                }
+        except Exception:
+            return None
+
     initial_snapshots = context.supervisor.scan()
     for snap in initial_snapshots:
         if snap.initialized and snap.exists_on_disk:
@@ -1372,6 +1478,24 @@ def create_hub_app(
                         )
 
             asyncio.create_task(_app_server_prune_loop())
+        opencode_supervisor = getattr(app.state, "opencode_supervisor", None)
+        opencode_prune_interval = getattr(app.state, "opencode_prune_interval", None)
+        if opencode_supervisor is not None and opencode_prune_interval:
+
+            async def _opencode_prune_loop():
+                while True:
+                    await asyncio.sleep(opencode_prune_interval)
+                    try:
+                        await opencode_supervisor.prune_idle()
+                    except Exception as exc:
+                        safe_log(
+                            app.state.logger,
+                            logging.WARNING,
+                            "Hub opencode prune task failed",
+                            exc,
+                        )
+
+            asyncio.create_task(_opencode_prune_loop())
         mount_lock = await _get_mount_lock()
         async with mount_lock:
             for prefix in list(mount_order):
@@ -1398,6 +1522,17 @@ def create_hub_app(
                         "Hub app-server shutdown failed",
                         exc,
                     )
+            opencode_supervisor = getattr(app.state, "opencode_supervisor", None)
+            if opencode_supervisor is not None:
+                try:
+                    await opencode_supervisor.close_all()
+                except Exception as exc:
+                    safe_log(
+                        app.state.logger,
+                        logging.WARNING,
+                        "Hub opencode shutdown failed",
+                        exc,
+                    )
             static_context = getattr(app.state, "static_assets_context", None)
             if static_context is not None:
                 static_context.close()
@@ -1501,6 +1636,27 @@ def create_hub_app(
                 history_dir = outbox_paths.dispatch_history_dir
                 if not history_dir.exists() or not history_dir.is_dir():
                     return None
+
+                def _dispatch_dict(dispatch: Dispatch) -> dict:
+                    return {
+                        "mode": dispatch.mode,
+                        "title": dispatch.title,
+                        "body": dispatch.body,
+                        "extra": dispatch.extra,
+                        "is_handoff": dispatch.is_handoff,
+                    }
+
+                def _list_files(dispatch_dir: Path) -> list[str]:
+                    files: list[str] = []
+                    for child in sorted(dispatch_dir.iterdir(), key=lambda p: p.name):
+                        if child.name.startswith("."):
+                            continue
+                        if child.name == "DISPATCH.md":
+                            continue
+                        if child.is_file():
+                            files.append(child.name)
+                    return files
+
                 seq_dirs: list[Path] = []
                 for child in history_dir.iterdir():
                     if not child.is_dir():
@@ -1510,40 +1666,74 @@ def create_hub_app(
                         seq_dirs.append(child)
                 if not seq_dirs:
                     return None
-                latest_dir = sorted(seq_dirs, key=lambda p: p.name)[-1]
-                seq = int(latest_dir.name)
-                dispatch_path = latest_dir / "DISPATCH.md"
-                dispatch, errors = parse_dispatch(dispatch_path)
-                if errors or dispatch is None:
-                    return {
-                        "seq": seq,
-                        "dir": safe_relpath(latest_dir, repo_root),
-                        "dispatch": None,
-                        "errors": errors,
-                        "files": [],
-                    }
-                files: list[str] = []
-                for child in sorted(latest_dir.iterdir(), key=lambda p: p.name):
-                    if child.name.startswith("."):
-                        continue
-                    if child.name == "DISPATCH.md":
+
+                seq_dirs = sorted(seq_dirs, key=lambda p: p.name, reverse=True)
+                handoff_candidate: Optional[dict] = None
+                non_summary_candidate: Optional[dict] = None
+                turn_summary_candidate: Optional[dict] = None
+                error_candidate: Optional[dict] = None
+
+                for seq_dir in seq_dirs:
+                    seq = int(seq_dir.name)
+                    dispatch_path = seq_dir / "DISPATCH.md"
+                    dispatch, errors = parse_dispatch(dispatch_path)
+                    if errors or dispatch is None:
+                        if error_candidate is None:
+                            error_candidate = {
+                                "seq": seq,
+                                "dir": seq_dir,
+                                "errors": errors,
+                            }
                         continue
-                    if child.is_file():
-                        files.append(child.name)
-                dispatch_dict = {
-                    "mode": dispatch.mode,
-                    "title": dispatch.title,
-                    "body": dispatch.body,
-                    "extra": dispatch.extra,
-                    "is_handoff": dispatch.is_handoff,
-                }
-                return {
-                    "seq": seq,
-                    "dir": safe_relpath(latest_dir, repo_root),
-                    "dispatch": dispatch_dict,
+                    candidate = {"seq": seq, "dir": seq_dir, "dispatch": dispatch}
+                    if dispatch.is_handoff and handoff_candidate is None:
+                        handoff_candidate = candidate
+                    if (
+                        dispatch.mode != "turn_summary"
+                        and non_summary_candidate is None
+                    ):
+                        non_summary_candidate = candidate
+                    if (
+                        dispatch.mode == "turn_summary"
+                        and turn_summary_candidate is None
+                    ):
+                        turn_summary_candidate = candidate
+                    if (
+                        handoff_candidate
+                        and non_summary_candidate
+                        and turn_summary_candidate
+                    ):
+                        break
+
+                selected = (
+                    handoff_candidate or non_summary_candidate or turn_summary_candidate
+                )
+                if not selected:
+                    if error_candidate:
+                        return {
+                            "seq": error_candidate["seq"],
+                            "dir": safe_relpath(error_candidate["dir"], repo_root),
+                            "dispatch": None,
+                            "errors": error_candidate["errors"],
+                            "files": [],
+                        }
+                    return None
+
+                selected_dir = selected["dir"]
+                dispatch = selected["dispatch"]
+                result = {
+                    "seq": selected["seq"],
+                    "dir": safe_relpath(selected_dir, repo_root),
+                    "dispatch": _dispatch_dict(dispatch),
                     "errors": [],
-                    "files": files,
+                    "files": _list_files(selected_dir),
                 }
+                if turn_summary_candidate is not None:
+                    result["turn_summary_seq"] = turn_summary_candidate["seq"]
+                    result["turn_summary"] = _dispatch_dict(
+                        turn_summary_candidate["dispatch"]
+                    )
+                return result
             except Exception:
                 return None
 
@@ -1561,11 +1751,11 @@ def create_hub_app(
                 if not db_path.exists():
                     continue
                 try:
-                    store = FlowStore(db_path)
-                    store.initialize()
-                    paused = store.list_flow_runs(
-                        flow_type="ticket_flow", status=FlowRunStatus.PAUSED
-                    )
+                    config = load_repo_config(repo_root)
+                    with FlowStore(db_path, durable=config.durable_writes) as store:
+                        paused = store.list_flow_runs(
+                            flow_type="ticket_flow", status=FlowRunStatus.PAUSED
+                        )
                 except Exception:
                     continue
                 if not paused:
@@ -1603,11 +1793,18 @@ def create_hub_app(
         safe_log(app.state.logger, logging.INFO, "Hub list_repos")
         snapshots = await asyncio.to_thread(context.supervisor.list_repos)
         await _refresh_mounts(snapshots)
+
+        def _enrich_repo(snap):
+            repo_dict = _add_mount_info(snap.to_dict(context.config.root))
+            if snap.initialized and snap.exists_on_disk:
+                repo_dict["ticket_flow"] = _get_ticket_flow_summary(snap.path)
+            else:
+                repo_dict["ticket_flow"] = None
+            return repo_dict
+
         return {
             "last_scan_at": context.supervisor.state.last_scan_at,
-            "repos": [
-                _add_mount_info(repo.to_dict(context.config.root)) for repo in snapshots
-            ],
+            "repos": [_enrich_repo(snap) for snap in snapshots],
         }
 
     @app.get("/hub/version")
@@ -1619,11 +1816,18 @@ def create_hub_app(
         safe_log(app.state.logger, logging.INFO, "Hub scan_repos")
         snapshots = await asyncio.to_thread(context.supervisor.scan)
         await _refresh_mounts(snapshots)
+
+        def _enrich_repo(snap):
+            repo_dict = _add_mount_info(snap.to_dict(context.config.root))
+            if snap.initialized and snap.exists_on_disk:
+                repo_dict["ticket_flow"] = _get_ticket_flow_summary(snap.path)
+            else:
+                repo_dict["ticket_flow"] = None
+            return repo_dict
+
         return {
             "last_scan_at": context.supervisor.state.last_scan_at,
-            "repos": [
-                _add_mount_info(repo.to_dict(context.config.root)) for repo in snapshots
-            ],
+            "repos": [_enrich_repo(snap) for snap in snapshots],
         }
 
     @app.post("/hub/jobs/scan", response_model=HubJobResponse)

codex_autorunner/surfaces/web/routes/__init__.py

@@ -26,6 +26,7 @@ from .app_server import build_app_server_routes
 from .archive import build_archive_routes
 from .base import build_base_routes, build_frontend_routes
 from .file_chat import build_file_chat_routes
+from .filebox import build_filebox_routes
 from .flows import build_flow_routes
 from .messages import build_messages_routes
 from .repos import build_repos_routes
@@ -33,6 +34,7 @@ from .review import build_review_routes
 from .sessions import build_sessions_routes
 from .settings import build_settings_routes
 from .system import build_system_routes
+from .templates import build_templates_routes
 from .terminal_images import build_terminal_image_routes
 from .usage import build_usage_routes
 from .voice import build_voice_routes
@@ -59,6 +61,7 @@ def build_repo_router(static_dir: Path) -> APIRouter:
     router.include_router(build_app_server_routes())
     router.include_router(build_workspace_routes())
     router.include_router(build_flow_routes())
+    router.include_router(build_filebox_routes())
     router.include_router(build_file_chat_routes())
     router.include_router(build_messages_routes())
     router.include_router(build_repos_routes())
@@ -66,6 +69,7 @@ def build_repo_router(static_dir: Path) -> APIRouter:
     router.include_router(build_sessions_routes())
     router.include_router(build_settings_routes())
     router.include_router(build_system_routes())
+    router.include_router(build_templates_routes())
     router.include_router(build_terminal_image_routes())
     router.include_router(build_usage_routes())
     router.include_router(build_voice_routes())

codex_autorunner/surfaces/web/routes/analytics.py

@@ -14,7 +14,7 @@ from typing import Any, Dict, Optional
 
 from fastapi import APIRouter
 
-from ....core.flows.models import FlowRunRecord, FlowRunStatus
+from ....core.flows.models import FlowEventType, FlowRunRecord, FlowRunStatus
 from ....core.flows.store import FlowStore
 from ....core.utils import find_repo_root
 from ....tickets.files import list_ticket_paths, read_ticket, ticket_is_done
@@ -26,18 +26,6 @@ def _flows_db_path(repo_root: Path) -> Path:
     return repo_root / ".codex-autorunner" / "flows.db"
 
 
-def _load_flow_store(repo_root: Path) -> Optional[FlowStore]:
-    db_path = _flows_db_path(repo_root)
-    if not db_path.exists():
-        return None
-    store = FlowStore(db_path)
-    try:
-        store.initialize()
-    except Exception:
-        return None
-    return store
-
-
 def _select_primary_run(records: list[FlowRunRecord]) -> Optional[FlowRunRecord]:
     """Select the primary run for analytics display.
 
@@ -154,19 +142,19 @@ def _aggregate_diff_stats(dispatch_history_dir: Path) -> Dict[str, int]:
 
 
 def _build_summary(repo_root: Path) -> Dict[str, Any]:
+    from ....core.config import load_repo_config
+
     ticket_dir = repo_root / ".codex-autorunner" / "tickets"
-    store = _load_flow_store(repo_root)
+    db_path = _flows_db_path(repo_root)
     records: list[FlowRunRecord] = []
-    if store:
+    if db_path.exists():
         try:
-            records = store.list_flow_runs(flow_type="ticket_flow")
+            with FlowStore(
+                db_path, durable=load_repo_config(repo_root).durable_writes
+            ) as store:
+                records = store.list_flow_runs(flow_type="ticket_flow")
         except Exception:
             records = []
-        finally:
-            try:
-                store.close()
-            except Exception:
-                pass
 
     run_record = _select_primary_run(records)
 
@@ -226,7 +214,26 @@ def _build_summary(repo_root: Path) -> Dict[str, Any]:
         )
         turns["dispatches"] = _count_history_dirs(outbox_paths.dispatch_history_dir)
         turns["replies"] = _count_history_dirs(reply_paths.reply_history_dir)
-        turns["diff_stats"] = _aggregate_diff_stats(outbox_paths.dispatch_history_dir)
+        # Diff stats are now stored in FlowStore as DIFF_UPDATED events.
+        # Fallback to legacy dispatch history parsing if FlowStore query fails.
+        try:
+            with FlowStore(
+                db_path, durable=load_repo_config(repo_root).durable_writes
+            ) as store:
+                events = store.get_events_by_type(
+                    run_record.id, FlowEventType.DIFF_UPDATED
+                )
+            totals = {"insertions": 0, "deletions": 0, "files_changed": 0}
+            for ev in events:
+                data = ev.data or {}
+                totals["insertions"] += int(data.get("insertions") or 0)
+                totals["deletions"] += int(data.get("deletions") or 0)
+                totals["files_changed"] += int(data.get("files_changed") or 0)
+            turns["diff_stats"] = totals
+        except Exception:
+            turns["diff_stats"] = _aggregate_diff_stats(
+                outbox_paths.dispatch_history_dir
+            )
 
         # If current ticket is known, read its frontmatter to pick agent id when available.
         if current_ticket: