codex-autorunner 1.2.0__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/archive.py

@@ -17,6 +17,8 @@ from ..schemas import (
     ArchiveSnapshotsResponse,
     ArchiveSnapshotSummary,
     ArchiveTreeResponse,
+    LocalRunArchivesResponse,
+    LocalRunArchiveSummary,
 )
 
 logger = logging.getLogger("codex_autorunner.routes.archive")
@@ -28,6 +30,10 @@ def _archive_worktrees_root(repo_root: Path) -> Path:
     return repo_root / ".codex-autorunner" / "archive" / "worktrees"
 
 
+def _local_flows_root(repo_root: Path) -> Path:
+    return repo_root / ".codex-autorunner" / "flows"
+
+
 def _normalize_component(value: str, label: str) -> str:
     cleaned = (value or "").strip()
     if not cleaned:
@@ -68,6 +74,18 @@ def _normalize_archive_rel_path(base: Path, rel_path: str) -> tuple[Path, str]:
     return candidate, rel_posix
 
 
+_LOCAL_ARCHIVE_DIRS = {"archived_tickets", "archived_runs"}
+
+
+def _normalize_local_archive_rel_path(base: Path, rel_path: str) -> tuple[Path, str]:
+    target, rel_posix = _normalize_archive_rel_path(base, rel_path)
+    if rel_posix:
+        head = rel_posix.split("/", 1)[0]
+        if head not in _LOCAL_ARCHIVE_DIRS:
+            raise ValueError("invalid archive path")
+    return target, rel_posix
+
+
 def _resolve_snapshot_root(
     repo_root: Path,
     snapshot_id: str,
@@ -108,6 +126,15 @@ def _resolve_snapshot_root(
     return resolved_root, worktree_id
 
 
+def _resolve_local_run_root(repo_root: Path, run_id: str) -> Path:
+    run_id = _normalize_component(run_id, "run_id")
+    flows_root = _local_flows_root(repo_root)
+    run_root = flows_root / run_id
+    if not run_root.exists() or not run_root.is_dir():
+        raise FileNotFoundError("run archive not found")
+    return run_root
+
+
 def _safe_mtime(path: Path) -> Optional[float]:
     try:
         return path.stat().st_mtime
@@ -194,6 +221,42 @@ def _iter_snapshots(repo_root: Path) -> list[ArchiveSnapshotSummary]:
     return snapshots
 
 
+def _format_mtime(ts: Optional[float]) -> Optional[str]:
+    if ts is None:
+        return None
+    return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat()
+
+
+def _iter_local_run_archives(repo_root: Path) -> list[LocalRunArchiveSummary]:
+    flows_root = _local_flows_root(repo_root)
+    if not flows_root.exists() or not flows_root.is_dir():
+        return []
+    entries: list[tuple[float, LocalRunArchiveSummary]] = []
+    for run_dir in sorted(flows_root.iterdir(), key=lambda p: p.name):
+        if not run_dir.is_dir():
+            continue
+        tickets_dir = run_dir / "archived_tickets"
+        runs_dir = run_dir / "archived_runs"
+        has_tickets = tickets_dir.exists() and tickets_dir.is_dir()
+        has_runs = runs_dir.exists() and runs_dir.is_dir()
+        if not has_tickets and not has_runs:
+            continue
+        mtime_candidates = [
+            _safe_mtime(tickets_dir) if has_tickets else None,
+            _safe_mtime(runs_dir) if has_runs else None,
+        ]
+        mtime = max([ts for ts in mtime_candidates if ts is not None], default=0.0)
+        summary = LocalRunArchiveSummary(
+            run_id=run_dir.name,
+            archived_at=_format_mtime(mtime) if mtime else None,
+            has_tickets=has_tickets,
+            has_runs=has_runs,
+        )
+        entries.append((mtime, summary))
+    entries.sort(key=lambda item: (item[0], item[1].run_id), reverse=True)
+    return [entry[1] for entry in entries]
+
+
 def _list_tree(snapshot_root: Path, rel_path: str) -> ArchiveTreeResponse:
     target, rel_posix = _normalize_archive_rel_path(snapshot_root, rel_path)
     if (
@@ -207,6 +270,69 @@ def _list_tree(snapshot_root: Path, rel_path: str) -> ArchiveTreeResponse:
 
     root_real = snapshot_root.resolve(strict=False)
     nodes: list[dict[str, Any]] = []
+    for child in sorted(
+        target.iterdir(), key=lambda p: p.name
+    ):  # codeql[py/path-injection] target validated by normalize helper
+        try:
+            resolved = child.resolve(strict=False)
+            resolved.relative_to(root_real)
+        except Exception:
+            continue
+
+        if child.is_dir():
+            node_type = "folder"
+            size_bytes = None
+        else:
+            node_type = "file"
+            try:
+                size_bytes = child.stat().st_size
+            except OSError:
+                size_bytes = None
+
+        try:
+            node_path = resolved.relative_to(root_real).as_posix()
+        except ValueError:
+            continue
+
+        nodes.append(
+            {
+                "path": node_path,
+                "name": child.name,
+                "type": node_type,
+                "size_bytes": size_bytes,
+                "mtime": _safe_mtime(child),
+            }
+        )
+
+    return ArchiveTreeResponse(path=rel_posix, nodes=nodes)
+
+
+def _list_local_tree(run_root: Path, rel_path: str) -> ArchiveTreeResponse:
+    target, rel_posix = _normalize_local_archive_rel_path(run_root, rel_path)
+    if not rel_posix:
+        nodes: list[dict[str, Any]] = []
+        for name in sorted(_LOCAL_ARCHIVE_DIRS):
+            candidate = run_root / name
+            if not candidate.exists() or not candidate.is_dir():
+                continue
+            nodes.append(
+                {
+                    "path": name,
+                    "name": name,
+                    "type": "folder",
+                    "size_bytes": None,
+                    "mtime": _safe_mtime(candidate),
+                }
+            )
+        return ArchiveTreeResponse(path="", nodes=nodes)
+
+    if not target.exists():
+        raise FileNotFoundError("path not found")
+    if not target.is_dir():
+        raise ValueError("path is not a directory")
+
+    root_real = run_root.resolve(strict=False)
+    nodes: list[dict[str, Any]] = []
     for child in sorted(target.iterdir(), key=lambda p: p.name):
         try:
             resolved = child.resolve(strict=False)
@@ -251,6 +377,12 @@ def build_archive_routes() -> APIRouter:
         snapshots = _iter_snapshots(repo_root)
         return {"snapshots": snapshots}
 
+    @router.get("/local-runs", response_model=LocalRunArchivesResponse)
+    def list_local_runs(request: Request):
+        repo_root = request.app.state.engine.repo_root
+        archives = _iter_local_run_archives(repo_root)
+        return {"archives": archives}
+
     @router.get(
         "/snapshots/{snapshot_id}", response_model=ArchiveSnapshotDetailResponse
     )
@@ -294,6 +426,22 @@ def build_archive_routes() -> APIRouter:
             raise HTTPException(status_code=409, detail=str(exc)) from exc
         return response
 
+    @router.get("/local/tree", response_model=ArchiveTreeResponse)
+    def list_local_tree(
+        request: Request,
+        run_id: str,
+        path: str = "",
+    ):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            run_root = _resolve_local_run_root(repo_root, run_id)
+            response = _list_local_tree(run_root, path)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+        return response
+
     @router.get("/file", response_class=PlainTextResponse)
     def read_file(
         request: Request,
@@ -317,6 +465,32 @@ def build_archive_routes() -> APIRouter:
         if not target.exists() or target.is_dir():
             raise HTTPException(status_code=404, detail="file not found")
 
+        try:
+            content = target.read_text(
+                encoding="utf-8", errors="replace"
+            )  # codeql[py/path-injection] target validated by normalize helper
+        except OSError as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+        return PlainTextResponse(content)
+
+    @router.get("/local/file", response_class=PlainTextResponse)
+    def read_local_file(
+        request: Request,
+        run_id: str,
+        path: str,
+    ):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            run_root = _resolve_local_run_root(repo_root, run_id)
+            target, rel_posix = _normalize_local_archive_rel_path(run_root, path)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+        if not rel_posix or not target.exists() or target.is_dir():
+            raise HTTPException(status_code=404, detail="file not found")
+
         try:
             content = target.read_text(encoding="utf-8", errors="replace")
         except OSError as exc:
@@ -351,6 +525,29 @@ def build_archive_routes() -> APIRouter:
             filename=target.name,
         )
 
+    @router.get("/local/download")
+    def download_local_file(
+        request: Request,
+        run_id: str,
+        path: str,
+    ):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            run_root = _resolve_local_run_root(repo_root, run_id)
+            target, rel_posix = _normalize_local_archive_rel_path(run_root, path)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+        if not rel_posix or not target.exists() or target.is_dir():
+            raise HTTPException(status_code=404, detail="file not found")
+
+        return FileResponse(
+            path=target,  # codeql[py/path-injection] target validated by normalize helper
+            filename=target.name,
+        )
+
     return router