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

codex_autorunner/surfaces/web/routes/filebox.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import FileResponse
+
+from ....core.filebox import (
+    BOXES,
+    FileBoxEntry,
+    delete_file,
+    ensure_structure,
+    list_filebox,
+    migrate_legacy,
+    resolve_file,
+    save_file,
+)
+from ....core.hub import HubSupervisor
+from ....core.utils import find_repo_root
+
+logger = logging.getLogger(__name__)
+
+
+def _serialize_entry(entry: FileBoxEntry, *, request: Request) -> dict[str, Any]:
+    base = request.scope.get("root_path", "") or ""
+    # Provide a download URL that survives base_path rewrites.
+    download = f"{base}/api/filebox/{entry.box}/{entry.name}"
+    return {
+        "name": entry.name,
+        "box": entry.box,
+        "size": entry.size,
+        "modified_at": entry.modified_at,
+        "source": entry.source,
+        "url": download,
+    }
+
+
+def _serialize_listing(
+    entries: dict[str, list[FileBoxEntry]], *, request: Request
+) -> dict[str, Any]:
+    return {
+        box: [_serialize_entry(e, request=request) for e in files]
+        for box, files in entries.items()
+    }
+
+
+def _resolve_repo_root(request: Request) -> Path:
+    engine = getattr(request.app.state, "engine", None)
+    repo_root = getattr(engine, "repo_root", None)
+    if isinstance(repo_root, Path):
+        return repo_root
+    if isinstance(repo_root, str):
+        try:
+            return Path(repo_root)
+        except Exception:
+            pass
+    return find_repo_root()
+
+
+def build_filebox_routes() -> APIRouter:
+    router = APIRouter(prefix="/api", tags=["filebox"])
+
+    @router.get("/filebox")
+    def list_box(request: Request) -> dict[str, Any]:
+        repo_root = _resolve_repo_root(request)
+        ensure_structure(repo_root)
+        try:
+            migrate_legacy(repo_root)
+        except Exception:
+            logger.debug("FileBox legacy migration skipped", exc_info=True)
+        entries = list_filebox(repo_root)
+        return _serialize_listing(entries, request=request)
+
+    @router.get("/filebox/{box}")
+    def list_single_box(box: str, request: Request) -> dict[str, Any]:
+        if box not in BOXES:
+            raise HTTPException(status_code=400, detail="Invalid box")
+        repo_root = _resolve_repo_root(request)
+        ensure_structure(repo_root)
+        entries = list_filebox(repo_root)
+        return {box: _serialize_listing(entries, request=request).get(box, [])}
+
+    @router.post("/filebox/{box}")
+    async def upload_file(box: str, request: Request) -> dict[str, Any]:
+        if box not in BOXES:
+            raise HTTPException(status_code=400, detail="Invalid box")
+        repo_root = _resolve_repo_root(request)
+        ensure_structure(repo_root)
+
+        form = await request.form()
+        saved = []
+        for filename, file in form.items():
+            try:
+                data = await file.read()
+            except Exception as exc:  # pragma: no cover - defensive
+                logger.warning("Failed to read upload: %s", exc)
+                continue
+            try:
+                path = save_file(repo_root, box, filename, data)
+                saved.append(path.name)
+            except ValueError as exc:
+                raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {"status": "ok", "saved": saved}
+
+    @router.get("/filebox/{box}/{filename}")
+    def download_file(box: str, filename: str, request: Request):
+        if box not in BOXES:
+            raise HTTPException(status_code=400, detail="Invalid box")
+        repo_root = _resolve_repo_root(request)
+        entry = resolve_file(repo_root, box, filename)
+        if entry is None:
+            raise HTTPException(status_code=404, detail="File not found")
+        return FileResponse(entry.path, filename=entry.name)
+
+    @router.delete("/filebox/{box}/{filename}")
+    def delete_file_entry(box: str, filename: str, request: Request) -> dict[str, Any]:
+        if box not in BOXES:
+            raise HTTPException(status_code=400, detail="Invalid box")
+        repo_root = _resolve_repo_root(request)
+        removed = delete_file(repo_root, box, filename)
+        if not removed:
+            raise HTTPException(status_code=404, detail="File not found")
+        return {"status": "ok"}
+
+    return router
+
+
+def _resolve_hub_repo_root(request: Request, repo_id: Optional[str]) -> Path:
+    supervisor: HubSupervisor | None = getattr(
+        request.app.state, "hub_supervisor", None
+    )
+    if supervisor is None:
+        raise HTTPException(status_code=404, detail="Hub supervisor unavailable")
+    snapshots = supervisor.list_repos()
+    candidates = [
+        snap for snap in snapshots if snap.initialized and snap.exists_on_disk
+    ]
+    target = None
+    if repo_id:
+        target = next((snap for snap in candidates if snap.id == repo_id), None)
+        if target is None:
+            raise HTTPException(status_code=404, detail="Repo not found")
+    else:
+        if len(candidates) == 1:
+            target = candidates[0]
+    if target is None:
+        raise HTTPException(status_code=400, detail="repo_id is required")
+    return target.path
+
+
+def _serialize_hub_entry(
+    entry: FileBoxEntry, *, request: Request, repo_id: str
+) -> dict[str, Any]:
+    base = request.scope.get("root_path", "") or ""
+    download = f"{base}/hub/filebox/{repo_id}/{entry.box}/{entry.name}"
+    return {
+        "name": entry.name,
+        "box": entry.box,
+        "size": entry.size,
+        "modified_at": entry.modified_at,
+        "source": entry.source,
+        "url": download,
+        "repo_id": repo_id,
+    }
+
+
+def build_hub_filebox_routes() -> APIRouter:
+    router = APIRouter(prefix="/hub/filebox", tags=["filebox"])
+
+    @router.get("/{repo_id}")
+    def list_repo_filebox(repo_id: str, request: Request) -> dict[str, Any]:
+        repo_root = _resolve_hub_repo_root(request, repo_id)
+        try:
+            migrate_legacy(repo_root)
+        except Exception:
+            logger.debug("Hub FileBox legacy migration skipped", exc_info=True)
+        entries = list_filebox(repo_root)
+        serialized = {
+            box: [
+                _serialize_hub_entry(e, request=request, repo_id=repo_id) for e in files
+            ]
+            for box, files in entries.items()
+        }
+        return serialized
+
+    @router.post("/{repo_id}/{box}")
+    async def hub_upload(repo_id: str, box: str, request: Request) -> dict[str, Any]:
+        if box not in BOXES:
+            raise HTTPException(status_code=400, detail="Invalid box")
+        repo_root = _resolve_hub_repo_root(request, repo_id)
+        ensure_structure(repo_root)
+        form = await request.form()
+        saved = []
+        for filename, file in form.items():
+            data = await file.read()
+            path = save_file(repo_root, box, filename, data)
+            saved.append(path.name)
+        return {"status": "ok", "saved": saved}
+
+    @router.get("/{repo_id}/{box}/{filename}")
+    def hub_download(repo_id: str, box: str, filename: str, request: Request):
+        if box not in BOXES:
+            raise HTTPException(status_code=400, detail="Invalid box")
+        repo_root = _resolve_hub_repo_root(request, repo_id)
+        entry = resolve_file(repo_root, box, filename)
+        if entry is None:
+            raise HTTPException(status_code=404, detail="File not found")
+        return FileResponse(entry.path, filename=entry.name)
+
+    @router.delete("/{repo_id}/{box}/{filename}")
+    def hub_delete(
+        repo_id: str, box: str, filename: str, request: Request
+    ) -> dict[str, Any]:
+        if box not in BOXES:
+            raise HTTPException(status_code=400, detail="Invalid box")
+        repo_root = _resolve_hub_repo_root(request, repo_id)
+        removed = delete_file(repo_root, box, filename)
+        if not removed:
+            raise HTTPException(status_code=404, detail="File not found")
+        return {"status": "ok"}
+
+    return router
+
+
+__all__ = ["build_filebox_routes", "build_hub_filebox_routes"]

codex_autorunner/surfaces/web/routes/flows.py

@@ -14,12 +14,11 @@ from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import FileResponse, StreamingResponse
 from pydantic import BaseModel, Field
 
-from ....agents.registry import validate_agent_id
 from ....core.config import load_repo_config
-from ....core.engine import Engine
 from ....core.flows import (
     FlowController,
     FlowDefinition,
+    FlowEventType,
     FlowRunRecord,
     FlowRunStatus,
     FlowStore,
@@ -36,12 +35,9 @@ from ....core.flows.ux_helpers import (
     seed_issue_from_text,
 )
 from ....core.flows.worker_process import FlowWorkerHealth, check_worker_health
+from ....core.runtime import RuntimeContext
 from ....core.utils import atomic_write, find_repo_root
 from ....flows.ticket_flow import build_ticket_flow_definition
-from ....integrations.agents.wiring import (
-    build_agent_backend_factory,
-    build_app_server_supervisor_factory,
-)
 from ....integrations.github.service import GitHubError, GitHubService
 from ....tickets import AgentPool
 from ....tickets.files import (
@@ -51,7 +47,7 @@ from ....tickets.files import (
     safe_relpath,
 )
 from ....tickets.frontmatter import parse_markdown_frontmatter
-from ....tickets.lint import lint_ticket_frontmatter
+from ....tickets.lint import lint_ticket_directory, lint_ticket_frontmatter
 from ....tickets.outbox import parse_dispatch, resolve_outbox_paths
 from ..schemas import (
     TicketCreateRequest,
@@ -82,6 +78,14 @@ def _ticket_dir(repo_root: Path) -> Path:
     return repo_root / ".codex-autorunner" / "tickets"
 
 
+def _find_ticket_path_by_index(ticket_dir: Path, index: int) -> Optional[Path]:
+    for path in list_ticket_paths(ticket_dir):
+        idx = parse_ticket_index(path.name)
+        if idx == index:
+            return path
+    return None
+
+
 def _require_flow_store(repo_root: Path) -> Optional[FlowStore]:
     db_path, _ = _flow_paths(repo_root)
     store = FlowStore(db_path)
@@ -126,12 +130,9 @@ def _build_flow_definition(repo_root: Path, flow_type: str) -> FlowDefinition:
 
     if flow_type == "ticket_flow":
         config = load_repo_config(repo_root)
-        engine = Engine(
-            repo_root,
+        engine = RuntimeContext(
+            repo_root=repo_root,
             config=config,
-            backend_factory=build_agent_backend_factory(repo_root, config),
-            app_server_supervisor_factory=build_app_server_supervisor_factory(config),
-            agent_id_validator=validate_agent_id,
         )
         agent_pool = AgentPool(engine.config)
         definition = build_ticket_flow_definition(agent_pool=agent_pool)
@@ -200,6 +201,27 @@ def _normalize_run_id(run_id: Union[str, uuid.UUID]) -> str:
         raise HTTPException(status_code=400, detail="Invalid run_id") from None
 
 
+def _validate_tickets(ticket_dir: Path) -> list[str]:
+    """Validate all tickets in the directory and return a list of error messages."""
+    errors: list[str] = []
+
+    if not ticket_dir.exists():
+        return errors
+
+    # Check for directory-level errors (duplicate indices)
+    dir_errors = lint_ticket_directory(ticket_dir)
+    errors.extend(dir_errors)
+
+    # Check each ticket file for frontmatter errors
+    ticket_paths = list_ticket_paths(ticket_dir)
+    for path in ticket_paths:
+        _, ticket_errors = read_ticket(path)
+        for err in ticket_errors:
+            errors.append(f"{path.relative_to(path.parent.parent)}: {err}")
+
+    return errors
+
+
 def _cleanup_worker_handle(run_id: str) -> None:
     handle = _active_workers.pop(run_id, None)
     if not handle:
@@ -276,6 +298,7 @@ class FlowStatusResponse(BaseModel):
     error_message: Optional[str]
     state: Dict = Field(default_factory=dict)
     reason_summary: Optional[str] = None
+    ticket_progress: Optional[Dict[str, int]] = None
     last_event_seq: Optional[int] = None
     last_event_at: Optional[str] = None
     worker_health: Optional[FlowWorkerHealthResponse] = None
@@ -337,6 +360,7 @@ def _build_flow_status_response(
         last_event_at=snapshot["last_event_at"],
         worker_health=snapshot["worker_health"],
     )
+    resp.ticket_progress = snapshot.get("ticket_progress")
     if snapshot.get("state") is not None:
         resp.state = snapshot["state"]
     return resp
@@ -416,6 +440,39 @@ def build_flow_routes() -> APIRouter:
             workspace_root=workspace_root, runs_dir=runs_dir, run_id=record.id
         )
 
+    def _get_diff_stats_by_dispatch_seq(
+        repo_root: Path, *, run_id: str
+    ) -> dict[int, dict[str, int]]:
+        """Return mapping of dispatch_seq -> diff stats for the run."""
+        store = _require_flow_store(repo_root)
+        if store is None:
+            return {}
+        try:
+            events = store.get_events_by_type(run_id, FlowEventType.DIFF_UPDATED)
+        except Exception:
+            events = []
+        finally:
+            try:
+                store.close()
+            except Exception:
+                pass
+
+        by_seq: dict[int, dict[str, int]] = {}
+        for ev in events:
+            data = ev.data or {}
+            try:
+                seq_val = int(data.get("dispatch_seq") or 0)
+            except Exception:
+                continue
+            if seq_val <= 0:
+                continue
+            by_seq[seq_val] = {
+                "insertions": int(data.get("insertions") or 0),
+                "deletions": int(data.get("deletions") or 0),
+                "files_changed": int(data.get("files_changed") or 0),
+            }
+        return by_seq
+
     @router.get("")
     async def list_flow_definitions():
         repo_root = find_repo_root()
@@ -461,7 +518,11 @@ def build_flow_routes() -> APIRouter:
         return _definition_info(definition)
 
     async def _start_flow(
-        flow_type: str, request: FlowStartRequest, *, force_new: bool = False
+        flow_type: str,
+        request: FlowStartRequest,
+        *,
+        force_new: bool = False,
+        validate_tickets: bool = True,
     ) -> FlowStatusResponse:
         if flow_type not in _supported_flow_types:
             raise HTTPException(
@@ -471,6 +532,27 @@ def build_flow_routes() -> APIRouter:
         repo_root = find_repo_root()
         controller = _get_flow_controller(repo_root, flow_type)
 
+        if flow_type == "ticket_flow" and validate_tickets:
+            ticket_dir = repo_root / ".codex-autorunner" / "tickets"
+            if force_new and not list_ticket_paths(ticket_dir):
+                raise HTTPException(
+                    status_code=400,
+                    detail=(
+                        "No tickets found under .codex-autorunner/tickets. "
+                        "Use /api/flows/ticket_flow/bootstrap to seed tickets."
+                    ),
+                )
+
+            lint_errors = _validate_tickets(ticket_dir)
+            if lint_errors:
+                raise HTTPException(
+                    status_code=400,
+                    detail={
+                        "message": "Ticket validation failed",
+                        "errors": lint_errors,
+                    },
+                )
+
         # Reuse an active/paused run unless force_new is requested.
         if not force_new:
             runs = _safe_list_flow_runs(
@@ -592,6 +674,16 @@ def build_flow_routes() -> APIRouter:
             )
             active = _active_or_paused_run(records)
             if active:
+                # Validate tickets before reusing active run
+                lint_errors = _validate_tickets(ticket_dir)
+                if lint_errors:
+                    raise HTTPException(
+                        status_code=400,
+                        detail={
+                            "message": "Ticket validation failed",
+                            "errors": lint_errors,
+                        },
+                    )
                 _reap_dead_worker(active.id)
                 _start_flow_worker(repo_root, active.id)
                 store = _require_flow_store(repo_root)
@@ -636,12 +728,51 @@ You are the first ticket in a new ticket_flow run.
             input_data=flow_request.input_data,
             metadata=meta | {"seeded_ticket": seeded},
         )
-        return await _start_flow("ticket_flow", payload, force_new=force_new)
+        validate_tickets = not tickets_exist or force_new
+        return await _start_flow(
+            "ticket_flow",
+            payload,
+            force_new=force_new,
+            validate_tickets=validate_tickets,
+        )
 
     @router.get("/ticket_flow/tickets")
     async def list_ticket_files():
         repo_root = find_repo_root()
         ticket_dir = repo_root / ".codex-autorunner" / "tickets"
+        # Compute cumulative diff stats per ticket for the active/paused run.
+        runs = _safe_list_flow_runs(
+            repo_root, flow_type="ticket_flow", recover_stuck=True
+        )
+        active_run = _active_or_paused_run(runs)
+        diff_by_ticket: dict[str, dict[str, int]] = {}
+        if active_run:
+            store = _require_flow_store(repo_root)
+            if store is not None:
+                try:
+                    events = store.get_events_by_type(
+                        active_run.id, FlowEventType.DIFF_UPDATED
+                    )
+                except Exception:
+                    events = []
+                finally:
+                    try:
+                        store.close()
+                    except Exception:
+                        pass
+                for ev in events:
+                    data = ev.data or {}
+                    ticket_id = data.get("ticket_id")
+                    if not isinstance(ticket_id, str) or not ticket_id.strip():
+                        continue
+                    stats = diff_by_ticket.setdefault(
+                        ticket_id,
+                        {"insertions": 0, "deletions": 0, "files_changed": 0},
+                    )
+                    stats["insertions"] += int(data.get("insertions") or 0)
+                    stats["deletions"] += int(data.get("deletions") or 0)
+                    stats["files_changed"] += int(data.get("files_changed") or 0)
+
         tickets = []
         for path in list_ticket_paths(ticket_dir):
             doc, errors = read_ticket(path)
@@ -662,6 +793,7 @@ You are the first ticket in a new ticket_flow run.
                     "frontmatter": asdict(doc.frontmatter) if doc else None,
                     "body": doc.body if doc else parsed_body,
                     "errors": errors,
+                    "diff_stats": diff_by_ticket.get(rel_path),
                 }
             )
         return {
@@ -669,6 +801,39 @@ You are the first ticket in a new ticket_flow run.
             "tickets": tickets,
         }
 
+    @router.get("/ticket_flow/tickets/{index}", response_model=TicketResponse)
+    async def get_ticket(index: int):
+        """Fetch a single ticket by index; return raw body even if frontmatter is invalid."""
+        repo_root = find_repo_root()
+        ticket_dir = repo_root / ".codex-autorunner" / "tickets"
+        ticket_path = _find_ticket_path_by_index(ticket_dir, index)
+
+        if not ticket_path:
+            raise HTTPException(status_code=404, detail=f"Ticket {index:03d} not found")
+
+        doc, errors = read_ticket(ticket_path)
+        if doc and not errors:
+            return TicketResponse(
+                path=safe_relpath(ticket_path, repo_root),
+                index=doc.index,
+                frontmatter=asdict(doc.frontmatter),
+                body=doc.body,
+            )
+
+        # Mirror list endpoint: surface raw body for repair when frontmatter is broken.
+        try:
+            raw_body = ticket_path.read_text(encoding="utf-8")
+            parsed_frontmatter, parsed_body = parse_markdown_frontmatter(raw_body)
+        except Exception:
+            parsed_frontmatter, parsed_body = {}, None
+
+        return TicketResponse(
+            path=safe_relpath(ticket_path, repo_root),
+            index=parse_ticket_index(ticket_path.name),
+            frontmatter=parsed_frontmatter or {},
+            body=parsed_body,
+        )
+
     @router.post("/ticket_flow/tickets", response_model=TicketResponse)
     async def create_ticket(request: TicketCreateRequest):
         """Create a new ticket with auto-generated index."""
@@ -688,13 +853,18 @@ You are the first ticket in a new ticket_flow run.
         while next_index in existing_indices:
             next_index += 1
 
-        # Build frontmatter
-        title_line = f"title: {request.title}\n" if request.title else ""
-        goal_line = f"goal: {request.goal}\n" if request.goal else ""
+        # Build frontmatter (quote scalars to avoid YAML parse issues with colons, etc.)
+        def _quote(val: Optional[str]) -> str:
+            return (
+                json.dumps(val) if val is not None else ""
+            )  # JSON string is valid YAML scalar
+
+        title_line = f"title: {_quote(request.title)}\n" if request.title else ""
+        goal_line = f"goal: {_quote(request.goal)}\n" if request.goal else ""
 
         content = (
             "---\n"
-            f"agent: {request.agent}\n"
+            f"agent: {_quote(request.agent)}\n"
             "done: false\n"
             f"{title_line}"
             f"{goal_line}"
@@ -724,12 +894,10 @@ You are the first ticket in a new ticket_flow run.
         """Update an existing ticket by index."""
         repo_root = find_repo_root()
         ticket_dir = repo_root / ".codex-autorunner" / "tickets"
-        ticket_path = ticket_dir / f"TICKET-{index:03d}.md"
+        ticket_path = _find_ticket_path_by_index(ticket_dir, index)
 
-        if not ticket_path.exists():
-            raise HTTPException(
-                status_code=404, detail=f"Ticket TICKET-{index:03d}.md not found"
-            )
+        if not ticket_path:
+            raise HTTPException(status_code=404, detail=f"Ticket {index:03d} not found")
 
         # Validate frontmatter before saving
         data, body = parse_markdown_frontmatter(request.content)
@@ -761,12 +929,10 @@ You are the first ticket in a new ticket_flow run.
         """Delete a ticket by index."""
         repo_root = find_repo_root()
         ticket_dir = repo_root / ".codex-autorunner" / "tickets"
-        ticket_path = ticket_dir / f"TICKET-{index:03d}.md"
+        ticket_path = _find_ticket_path_by_index(ticket_dir, index)
 
-        if not ticket_path.exists():
-            raise HTTPException(
-                status_code=404, detail=f"Ticket TICKET-{index:03d}.md not found"
-            )
+        if not ticket_path:
+            raise HTTPException(status_code=404, detail=f"Ticket {index:03d} not found")
 
         rel_path = safe_relpath(ticket_path, repo_root)
         ticket_path.unlink()
@@ -801,6 +967,19 @@ You are the first ticket in a new ticket_flow run.
         record = _get_flow_record(repo_root, run_id)
         controller = _get_flow_controller(repo_root, record.flow_type)
 
+        # Validate tickets before resuming ticket_flow
+        if record.flow_type == "ticket_flow":
+            ticket_dir = repo_root / ".codex-autorunner" / "tickets"
+            lint_errors = _validate_tickets(ticket_dir)
+            if lint_errors:
+                raise HTTPException(
+                    status_code=400,
+                    detail={
+                        "message": "Ticket validation failed",
+                        "errors": lint_errors,
+                    },
+                )
+
         updated = await controller.resume_flow(run_id)
         _reap_dead_worker(run_id)
         _start_flow_worker(repo_root, run_id)
@@ -935,7 +1114,7 @@ You are the first ticket in a new ticket_flow run.
                     run_id, after_seq=resume_after
                 ):
                     data = event.model_dump(mode="json")
-                    yield f"id: {event.seq}\n" f"data: {json.dumps(data)}\n\n"
+                    yield f"id: {event.seq}\ndata: {json.dumps(data)}\n\n"
             except Exception as e:
                 _logger.exception("Error streaming events for run %s: %s", run_id, e)
                 raise
@@ -961,6 +1140,10 @@ You are the first ticket in a new ticket_flow run.
         record = _get_flow_record(repo_root, normalized)
         paths = _resolve_outbox_for_record(record, repo_root)
 
+        # Pull diff stats from FlowStore keyed by dispatch sequence number so we
+        # can enrich dispatch history entries without relying on DISPATCH.md metadata.
+        diff_by_seq = _get_diff_stats_by_dispatch_seq(repo_root, run_id=normalized)
+
         history_entries = []
         history_dir = paths.dispatch_history_dir
         if history_dir.exists() and history_dir.is_dir():
@@ -978,6 +1161,13 @@ You are the first ticket in a new ticket_flow run.
                 dispatch_dict = asdict(dispatch) if dispatch else None
                 if dispatch_dict and dispatch:
                     dispatch_dict["is_handoff"] = dispatch.is_handoff
+                    # Add structured diff stats (per turn summary), matched by seq.
+                    try:
+                        entry_seq_int = int(entry.name)
+                    except Exception:
+                        entry_seq_int = 0
+                    if entry_seq_int and entry_seq_int in diff_by_seq:
+                        dispatch_dict["diff_stats"] = diff_by_seq[entry_seq_int]
                 attachments = []
                 for child in sorted(entry.rglob("*")):
                     if child.name == "DISPATCH.md":