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

codex_autorunner/surfaces/web/app.py

@@ -1,4 +1,5 @@
 import asyncio
+import json
 import logging
 import os
 import shlex
@@ -6,8 +7,9 @@ import sys
 import threading
 from contextlib import ExitStack, asynccontextmanager
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from pathlib import Path
-from typing import Mapping, Optional
+from typing import Any, Mapping, Optional
 
 from fastapi import FastAPI, HTTPException
 from fastapi.responses import HTMLResponse
@@ -53,6 +55,7 @@ from ...core.usage import (
     parse_iso_datetime,
 )
 from ...core.utils import (
+    atomic_write,
     build_opencode_supervisor,
     reset_repo_root_context,
     set_repo_root_context,
@@ -71,6 +74,7 @@ from ...manifest import load_manifest
 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 ...tickets.replies import resolve_reply_paths
 from ...voice import VoiceConfig, VoiceService
 from .hub_jobs import HubJobManager
 from .middleware import (
@@ -158,6 +162,86 @@ class ServerOverrides:
     auth_token_env: Optional[str] = None
 
 
+_HUB_INBOX_DISMISSALS_FILENAME = "hub_inbox_dismissals.json"
+
+
+def _hub_inbox_dismissals_path(repo_root: Path) -> Path:
+    return repo_root / ".codex-autorunner" / _HUB_INBOX_DISMISSALS_FILENAME
+
+
+def _dismissal_key(run_id: str, seq: int) -> str:
+    return f"{run_id}:{seq}"
+
+
+def _load_hub_inbox_dismissals(repo_root: Path) -> dict[str, dict[str, Any]]:
+    path = _hub_inbox_dismissals_path(repo_root)
+    if not path.exists():
+        return {}
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+    if not isinstance(payload, dict):
+        return {}
+    items = payload.get("items")
+    if not isinstance(items, dict):
+        return {}
+    out: dict[str, dict[str, Any]] = {}
+    for key, value in items.items():
+        if not isinstance(key, str) or not isinstance(value, dict):
+            continue
+        out[key] = dict(value)
+    return out
+
+
+def _save_hub_inbox_dismissals(
+    repo_root: Path, items: dict[str, dict[str, Any]]
+) -> None:
+    path = _hub_inbox_dismissals_path(repo_root)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    payload = {"version": 1, "items": items}
+    atomic_write(path, json.dumps(payload, indent=2, sort_keys=True) + "\n")
+
+
+def _resolve_workspace_and_runs(
+    record_input: dict[str, Any], repo_root: Path
+) -> tuple[Path, Path]:
+    workspace_raw = record_input.get("workspace_root")
+    workspace_root = Path(workspace_raw) if workspace_raw else repo_root
+    if not workspace_root.is_absolute():
+        workspace_root = (repo_root / workspace_root).resolve()
+    else:
+        workspace_root = workspace_root.resolve()
+    runs_raw = record_input.get("runs_dir") or ".codex-autorunner/runs"
+    runs_dir = Path(runs_raw)
+    if not runs_dir.is_absolute():
+        runs_dir = (workspace_root / runs_dir).resolve()
+    return workspace_root, runs_dir
+
+
+def _latest_reply_history_seq(
+    repo_root: Path, run_id: str, record_input: dict[str, Any]
+) -> int:
+    workspace_root, runs_dir = _resolve_workspace_and_runs(record_input, repo_root)
+    reply_paths = resolve_reply_paths(
+        workspace_root=workspace_root, runs_dir=runs_dir, run_id=run_id
+    )
+    history_dir = reply_paths.reply_history_dir
+    if not history_dir.exists() or not history_dir.is_dir():
+        return 0
+    latest = 0
+    try:
+        for child in history_dir.iterdir():
+            if not child.is_dir():
+                continue
+            name = child.name
+            if len(name) == 4 and name.isdigit():
+                latest = max(latest, int(name))
+    except OSError:
+        return latest
+    return latest
+
+
 def _app_server_prune_interval(idle_ttl_seconds: Optional[int]) -> Optional[float]:
     if not idle_ttl_seconds or idle_ttl_seconds <= 0:
         return None
@@ -294,6 +378,7 @@ def _build_app_server_supervisor(
         restart_backoff_initial_seconds=config.client.restart_backoff_initial_seconds,
         restart_backoff_max_seconds=config.client.restart_backoff_max_seconds,
         restart_backoff_jitter_ratio=config.client.restart_backoff_jitter_ratio,
+        output_policy=config.output.policy,
         notification_handler=notification_handler,
         approval_handler=approval_handler,
     )
@@ -1154,7 +1239,14 @@ def create_hub_app(
     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())
+        pma_router = build_pma_routes()
+        app.include_router(pma_router)
+        app.state.pma_lane_worker_start = getattr(
+            pma_router, "_pma_start_lane_worker", None
+        )
+        app.state.pma_lane_worker_stop = getattr(
+            pma_router, "_pma_stop_lane_worker", None
+        )
     app.include_router(build_hub_filebox_routes())
     mounted_repos: set[str] = set()
     mount_errors: dict[str, str] = {}
@@ -1496,6 +1588,19 @@ def create_hub_app(
                         )
 
             asyncio.create_task(_opencode_prune_loop())
+        pma_cfg = getattr(app.state.config, "pma", None)
+        if pma_cfg is not None and pma_cfg.enabled:
+            starter = getattr(app.state, "pma_lane_worker_start", None)
+            if starter is not None:
+                try:
+                    await starter(app, "pma:default")
+                except Exception as exc:
+                    safe_log(
+                        app.state.logger,
+                        logging.WARNING,
+                        "PMA lane worker startup failed",
+                        exc,
+                    )
         mount_lock = await _get_mount_lock()
         async with mount_lock:
             for prefix in list(mount_order):
@@ -1536,6 +1641,17 @@ def create_hub_app(
             static_context = getattr(app.state, "static_assets_context", None)
             if static_context is not None:
                 static_context.close()
+            stopper = getattr(app.state, "pma_lane_worker_stop", None)
+            if stopper is not None:
+                try:
+                    await stopper(app, "pma:default")
+                except Exception as exc:
+                    safe_log(
+                        app.state.logger,
+                        logging.WARNING,
+                        "PMA lane worker shutdown failed",
+                        exc,
+                    )
 
     app.router.lifespan_context = lifespan
 
@@ -1616,6 +1732,18 @@ def create_hub_app(
             **series,
         }
 
+    hub_dismissal_locks: dict[str, asyncio.Lock] = {}
+    hub_dismissal_locks_guard = asyncio.Lock()
+
+    async def _repo_dismissal_lock(repo_root: Path) -> asyncio.Lock:
+        key = str(repo_root.resolve())
+        async with hub_dismissal_locks_guard:
+            lock = hub_dismissal_locks.get(key)
+            if lock is None:
+                lock = asyncio.Lock()
+                hub_dismissal_locks[key] = lock
+            return lock
+
     @app.get("/hub/messages")
     async def hub_messages(limit: int = 100):
         """Return paused ticket_flow dispatches across all repos.
@@ -1746,6 +1874,7 @@ def create_hub_app(
             for snap in snapshots:
                 if not (snap.initialized and snap.exists_on_disk):
                     continue
+                dismissals = _load_hub_inbox_dismissals(snap.path)
                 repo_root = snap.path
                 db_path = repo_root / ".codex-autorunner" / "flows.db"
                 if not db_path.exists():
@@ -1761,11 +1890,24 @@ def create_hub_app(
                 if not paused:
                     continue
                 for record in paused:
-                    latest = _latest_dispatch(
-                        repo_root, str(record.id), dict(record.input_data or {})
-                    )
+                    record_input = dict(record.input_data or {})
+                    latest = _latest_dispatch(repo_root, str(record.id), record_input)
                     if not latest or not latest.get("dispatch"):
                         continue
+                    seq = int(latest.get("seq") or 0)
+                    if seq <= 0:
+                        continue
+                    if _dismissal_key(str(record.id), seq) in dismissals:
+                        continue
+                    # Reconcile stale inbox items: if reply history already
+                    # reached this dispatch seq, treat it as resolved.
+                    if (
+                        _latest_reply_history_seq(
+                            repo_root, str(record.id), record_input
+                        )
+                        >= seq
+                    ):
+                        continue
                     messages.append(
                         {
                             "repo_id": snap.id,
@@ -1788,6 +1930,52 @@ def create_hub_app(
         items = await asyncio.to_thread(_gather)
         return {"items": items}
 
+    @app.post("/hub/messages/dismiss")
+    async def dismiss_hub_message(payload: dict[str, Any]):
+        repo_id = str(payload.get("repo_id") or "").strip()
+        run_id = str(payload.get("run_id") or "").strip()
+        seq_raw = payload.get("seq")
+        reason_raw = payload.get("reason")
+        reason = str(reason_raw).strip() if isinstance(reason_raw, str) else ""
+        if not repo_id:
+            raise HTTPException(status_code=400, detail="Missing repo_id")
+        if not run_id:
+            raise HTTPException(status_code=400, detail="Missing run_id")
+        try:
+            seq = int(seq_raw)
+        except (TypeError, ValueError):
+            raise HTTPException(status_code=400, detail="Invalid seq") from None
+        if seq <= 0:
+            raise HTTPException(status_code=400, detail="Invalid seq")
+
+        snapshots = await asyncio.to_thread(context.supervisor.list_repos)
+        snapshot = next((s for s in snapshots if s.id == repo_id), None)
+        if snapshot is None or not snapshot.exists_on_disk:
+            raise HTTPException(status_code=404, detail="Repo not found")
+
+        repo_lock = await _repo_dismissal_lock(snapshot.path)
+        async with repo_lock:
+            dismissed_at = datetime.now(timezone.utc).isoformat()
+            items = _load_hub_inbox_dismissals(snapshot.path)
+            items[_dismissal_key(run_id, seq)] = {
+                "repo_id": repo_id,
+                "run_id": run_id,
+                "seq": seq,
+                "reason": reason or None,
+                "dismissed_at": dismissed_at,
+            }
+            _save_hub_inbox_dismissals(snapshot.path, items)
+        return {
+            "status": "ok",
+            "dismissed": {
+                "repo_id": repo_id,
+                "run_id": run_id,
+                "seq": seq,
+                "reason": reason or None,
+                "dismissed_at": dismissed_at,
+            },
+        }
+
     @app.get("/hub/repos")
     async def list_repos():
         safe_log(app.state.logger, logging.INFO, "Hub list_repos")

codex_autorunner/surfaces/web/routes/file_chat.py

@@ -51,6 +51,24 @@ class _Target:
     state_key: str
 
 
+@dataclass
+class FileChatRoutesState:
+    active_chats: Dict[str, asyncio.Event]
+    chat_lock: asyncio.Lock
+    turn_lock: asyncio.Lock
+    current_by_target: Dict[str, Dict[str, Any]]
+    current_by_client: Dict[str, Dict[str, Any]]
+    last_by_client: Dict[str, Dict[str, Any]]
+
+    def __init__(self) -> None:
+        self.active_chats = {}
+        self.chat_lock = asyncio.Lock()
+        self.turn_lock = asyncio.Lock()
+        self.current_by_target = {}
+        self.current_by_client = {}
+        self.last_by_client = {}
+
+
 def _state_path(repo_root: Path) -> Path:
     return draft_utils.state_path(repo_root)
 
@@ -205,25 +223,32 @@ def _build_patch(rel_path: str, before: str, after: str) -> str:
 
 def build_file_chat_routes() -> APIRouter:
     router = APIRouter(prefix="/api", tags=["file-chat"])
-    _active_chats: Dict[str, asyncio.Event] = {}
-    _chat_lock = asyncio.Lock()
-    _turn_lock = asyncio.Lock()
-    _current_by_target: Dict[str, Dict[str, Any]] = {}
-    _current_by_client: Dict[str, Dict[str, Any]] = {}
-    _last_by_client: Dict[str, Dict[str, Any]] = {}
-
-    async def _get_or_create_interrupt_event(key: str) -> asyncio.Event:
-        async with _chat_lock:
-            if key not in _active_chats:
-                _active_chats[key] = asyncio.Event()
-            return _active_chats[key]
-
-    async def _clear_interrupt_event(key: str) -> None:
-        async with _chat_lock:
-            _active_chats.pop(key, None)
-
-    async def _begin_turn_state(target: _Target, client_turn_id: Optional[str]) -> None:
-        async with _turn_lock:
+    state = FileChatRoutesState()
+
+    def _get_state(request: Request) -> FileChatRoutesState:
+        if not hasattr(request.app.state, "file_chat_routes_state"):
+            request.app.state.file_chat_routes_state = state
+        return request.app.state.file_chat_routes_state
+
+    async def _get_or_create_interrupt_event(
+        request: Request, key: str
+    ) -> asyncio.Event:
+        s = _get_state(request)
+        async with s.chat_lock:
+            if key not in s.active_chats:
+                s.active_chats[key] = asyncio.Event()
+            return s.active_chats[key]
+
+    async def _clear_interrupt_event(request: Request, key: str) -> None:
+        s = _get_state(request)
+        async with s.chat_lock:
+            s.active_chats.pop(key, None)
+
+    async def _begin_turn_state(
+        request: Request, target: _Target, client_turn_id: Optional[str]
+    ) -> None:
+        s = _get_state(request)
+        async with s.turn_lock:
             state: Dict[str, Any] = {
                 "client_turn_id": client_turn_id or "",
                 "target": target.target,
@@ -232,13 +257,16 @@ def build_file_chat_routes() -> APIRouter:
                 "thread_id": None,
                 "turn_id": None,
             }
-            _current_by_target[target.state_key] = state
+            s.current_by_target[target.state_key] = state
             if client_turn_id:
-                _current_by_client[client_turn_id] = state
-
-    async def _update_turn_state(target: _Target, **updates: Any) -> None:
-        async with _turn_lock:
-            state = _current_by_target.get(target.state_key)
+                s.current_by_client[client_turn_id] = state
+
+    async def _update_turn_state(
+        request: Request, target: _Target, **updates: Any
+    ) -> None:
+        s = _get_state(request)
+        async with s.turn_lock:
+            state = s.current_by_target.get(target.state_key)
             if not state:
                 return
             for key, value in updates.items():
@@ -247,34 +275,45 @@ def build_file_chat_routes() -> APIRouter:
                 state[key] = value
             cid = state.get("client_turn_id") or ""
             if cid:
-                _current_by_client[cid] = state
-
-    async def _finalize_turn_state(target: _Target, result: Dict[str, Any]) -> None:
-        async with _turn_lock:
-            state = _current_by_target.pop(target.state_key, None)
+                s.current_by_client[cid] = state
+
+    async def _finalize_turn_state(
+        request: Request, target: _Target, result: Dict[str, Any]
+    ) -> None:
+        s = _get_state(request)
+        async with s.turn_lock:
+            state = s.current_by_target.pop(target.state_key, None)
             cid = ""
             if state:
                 cid = state.get("client_turn_id", "") or ""
             if cid:
-                _current_by_client.pop(cid, None)
-                _last_by_client[cid] = dict(result or {})
+                s.current_by_client.pop(cid, None)
+                s.last_by_client[cid] = dict(result or {})
 
-    async def _active_for_client(client_turn_id: Optional[str]) -> Dict[str, Any]:
+    async def _active_for_client(
+        request: Request, client_turn_id: Optional[str]
+    ) -> Dict[str, Any]:
         if not client_turn_id:
             return {}
-        async with _turn_lock:
-            return dict(_current_by_client.get(client_turn_id, {}))
+        s = _get_state(request)
+        async with s.turn_lock:
+            return dict(s.current_by_client.get(client_turn_id, {}))
 
-    async def _last_for_client(client_turn_id: Optional[str]) -> Dict[str, Any]:
+    async def _last_for_client(
+        request: Request, client_turn_id: Optional[str]
+    ) -> Dict[str, Any]:
         if not client_turn_id:
             return {}
-        async with _turn_lock:
-            return dict(_last_by_client.get(client_turn_id, {}))
+        s = _get_state(request)
+        async with s.turn_lock:
+            return dict(s.last_by_client.get(client_turn_id, {}))
 
     @router.get("/file-chat/active")
-    async def file_chat_active(client_turn_id: Optional[str] = None) -> Dict[str, Any]:
-        current = await _active_for_client(client_turn_id)
-        last = await _last_for_client(client_turn_id)
+    async def file_chat_active(
+        request: Request, client_turn_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        current = await _active_for_client(request, client_turn_id)
+        last = await _last_for_client(request, client_turn_id)
         return {"active": bool(current), "current": current, "last_result": last}
 
     @router.post("/file-chat")
@@ -300,13 +339,14 @@ def build_file_chat_routes() -> APIRouter:
             target.path.parent.mkdir(parents=True, exist_ok=True)
 
         # Concurrency guard per target
-        async with _chat_lock:
-            existing = _active_chats.get(target.state_key)
+        s = _get_state(request)
+        async with s.chat_lock:
+            existing = s.active_chats.get(target.state_key)
             if existing is not None and not existing.is_set():
                 raise HTTPException(status_code=409, detail="File chat already running")
-            _active_chats[target.state_key] = asyncio.Event()
+            s.active_chats[target.state_key] = asyncio.Event()
 
-        await _begin_turn_state(target, client_turn_id)
+        await _begin_turn_state(request, target, client_turn_id)
 
         if stream:
             return StreamingResponse(
@@ -329,6 +369,7 @@ def build_file_chat_routes() -> APIRouter:
 
             async def _on_meta(agent_id: str, thread_id: str, turn_id: str) -> None:
                 await _update_turn_state(
+                    request,
                     target,
                     agent=agent_id,
                     thread_id=thread_id,
@@ -348,6 +389,7 @@ def build_file_chat_routes() -> APIRouter:
                 )
             except Exception as exc:
                 await _finalize_turn_state(
+                    request,
                     target,
                     {
                         "status": "error",
@@ -358,10 +400,10 @@ def build_file_chat_routes() -> APIRouter:
                 raise
             result = dict(result or {})
             result["client_turn_id"] = client_turn_id or ""
-            await _finalize_turn_state(target, result)
+            await _finalize_turn_state(request, target, result)
             return result
         finally:
-            await _clear_interrupt_event(target.state_key)
+            await _clear_interrupt_event(request, target.state_key)
 
     async def _stream_file_chat(
         request: Request,
@@ -379,6 +421,7 @@ def build_file_chat_routes() -> APIRouter:
 
             async def _on_meta(agent_id: str, thread_id: str, turn_id: str) -> None:
                 await _update_turn_state(
+                    request,
                     target,
                     agent=agent_id,
                     thread_id=thread_id,
@@ -410,7 +453,7 @@ def build_file_chat_routes() -> APIRouter:
                     }
                 result = dict(result or {})
                 result["client_turn_id"] = client_turn_id or ""
-                await _finalize_turn_state(target, result)
+                await _finalize_turn_state(request, target, result)
 
             asyncio.create_task(_finalize())
 
@@ -443,7 +486,7 @@ def build_file_chat_routes() -> APIRouter:
             logger.exception("file chat stream failed")
             yield format_sse("error", {"detail": "File chat failed"})
         finally:
-            await _clear_interrupt_event(target.state_key)
+            await _clear_interrupt_event(request, target.state_key)
 
     async def _execute_file_chat(
         request: Request,
@@ -479,7 +522,9 @@ def build_file_chat_routes() -> APIRouter:
 
         prompt = _build_file_chat_prompt(target=target, message=message, before=before)
 
-        interrupt_event = await _get_or_create_interrupt_event(target.state_key)
+        interrupt_event = await _get_or_create_interrupt_event(
+            request, target.state_key
+        )
         if interrupt_event.is_set():
             return {"status": "interrupted", "detail": "File chat interrupted"}
 
@@ -489,7 +534,7 @@ def build_file_chat_routes() -> APIRouter:
             agent_id = "codex"
 
         thread_key = f"file_chat.{target.state_key}"
-        await _update_turn_state(target, status="running", agent=agent_id)
+        await _update_turn_state(request, target, status="running", agent=agent_id)
 
         if agent_id == "opencode":
             if opencode is None:
@@ -952,8 +997,9 @@ def build_file_chat_routes() -> APIRouter:
         body = await request.json()
         repo_root = _resolve_repo_root(request)
         resolved = _parse_target(repo_root, str(body.get("target") or ""))
-        async with _chat_lock:
-            ev = _active_chats.get(resolved.state_key)
+        s = _get_state(request)
+        async with s.chat_lock:
+            ev = s.active_chats.get(resolved.state_key)
             if ev is None:
                 return {"status": "ok", "detail": "No active chat to interrupt"}
             ev.set()
@@ -977,14 +1023,15 @@ def build_file_chat_routes() -> APIRouter:
         repo_root = _resolve_repo_root(request)
         target = _parse_target(repo_root, f"ticket:{int(index)}")
 
-        async with _chat_lock:
-            existing = _active_chats.get(target.state_key)
+        s = _get_state(request)
+        async with s.chat_lock:
+            existing = s.active_chats.get(target.state_key)
             if existing is not None and not existing.is_set():
                 raise HTTPException(
                     status_code=409, detail="Ticket chat already running"
                 )
-            _active_chats[target.state_key] = asyncio.Event()
-        await _begin_turn_state(target, client_turn_id)
+            s.active_chats[target.state_key] = asyncio.Event()
+        await _begin_turn_state(request, target, client_turn_id)
 
         if stream:
             return StreamingResponse(
@@ -1014,10 +1061,10 @@ def build_file_chat_routes() -> APIRouter:
             )
             result = dict(result or {})
             result["client_turn_id"] = client_turn_id or ""
-            await _finalize_turn_state(target, result)
+            await _finalize_turn_state(request, target, result)
             return result
         finally:
-            await _clear_interrupt_event(target.state_key)
+            await _clear_interrupt_event(request, target.state_key)
 
     @router.get("/tickets/{index}/chat/pending")
     async def pending_ticket_patch(index: int, request: Request):
@@ -1087,8 +1134,9 @@ def build_file_chat_routes() -> APIRouter:
     async def interrupt_ticket_chat(index: int, request: Request):
         repo_root = _resolve_repo_root(request)
         target = _parse_target(repo_root, f"ticket:{int(index)}")
-        async with _chat_lock:
-            ev = _active_chats.get(target.state_key)
+        s = _get_state(request)
+        async with s.chat_lock:
+            ev = s.active_chats.get(target.state_key)
             if ev is None:
                 return {"status": "ok", "detail": "No active chat to interrupt"}
             ev.set()