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

codex_autorunner/routes/analytics.py

@@ -1,239 +1,3 @@
-"""Analytics summary routes.
+"""Backward-compatible analytics routes."""
 
-This module aggregates run/ticket/message metadata for the analytics dashboard
-without relying on legacy autorunner endpoints. It intentionally reads from the
-filesystem-backed ticket_flow store and ticket files to keep the UI consistent
-with the rest of the app.
-"""
-
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-from fastapi import APIRouter
-
-from ..core.flows.models import 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
-from ..tickets.outbox import resolve_outbox_paths
-from ..tickets.replies import resolve_reply_paths
-
-
-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.
-
-    Only considers the newest run (records[0]). If it's active or paused, return it.
-    If the newest run is terminal (completed/stopped/failed), return None to show idle.
-    This matches the backend's _active_or_paused_run() logic and prevents showing
-    stale data from old paused runs when newer runs have completed.
-    """
-    if not records:
-        return None
-    newest = records[0]
-    if (
-        FlowRunStatus(newest.status).is_active()
-        or FlowRunStatus(newest.status).is_paused()
-    ):
-        return newest
-    return None
-
-
-def _parse_timestamp(value: Optional[str]) -> Optional[datetime]:
-    if not value:
-        return None
-    try:
-        if value.endswith("Z"):
-            return datetime.fromisoformat(value.replace("Z", "+00:00"))
-        return datetime.fromisoformat(value)
-    except ValueError:
-        return None
-
-
-def _duration_seconds(
-    started_at: Optional[str], finished_at: Optional[str], status: str
-) -> Optional[float]:
-    start_dt = _parse_timestamp(started_at)
-    if not start_dt:
-        return None
-    end_dt = _parse_timestamp(finished_at)
-    if not end_dt and status in {
-        FlowRunStatus.RUNNING.value,
-        FlowRunStatus.PAUSED.value,
-        FlowRunStatus.PENDING.value,
-    }:
-        end_dt = datetime.now(timezone.utc)
-    if not end_dt:
-        return None
-    return (end_dt - start_dt).total_seconds()
-
-
-def _ticket_counts(ticket_dir: Path) -> dict[str, int]:
-    total = 0
-    done = 0
-    for path in list_ticket_paths(ticket_dir):
-        total += 1
-        try:
-            if ticket_is_done(path):
-                done += 1
-        except Exception:
-            # Treat unreadable/invalid tickets as not-done but still count them.
-            continue
-    todo = max(total - done, 0)
-    return {"todo": todo, "done": done, "total": total}
-
-
-def _count_history_dirs(history_dir: Path) -> int:
-    if not history_dir.exists() or not history_dir.is_dir():
-        return 0
-    count = 0
-    try:
-        for child in history_dir.iterdir():
-            try:
-                if child.is_dir() and len(child.name) == 4 and child.name.isdigit():
-                    count += 1
-            except OSError:
-                continue
-    except OSError:
-        return count
-    return count
-
-
-def _build_summary(repo_root: Path) -> Dict[str, Any]:
-    ticket_dir = repo_root / ".codex-autorunner" / "tickets"
-    store = _load_flow_store(repo_root)
-    records: list[FlowRunRecord] = []
-    if store:
-        try:
-            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)
-
-    default_run = {
-        "id": None,
-        "short_id": None,
-        "status": "idle",
-        "started_at": None,
-        "finished_at": None,
-        "duration_seconds": None,
-        "current_step": None,
-        "created_at": None,
-    }
-
-    run_data: Dict[str, Any] = default_run
-    turns: Dict[str, Optional[int]] = {
-        "total": None,
-        "current_ticket": None,
-        "dispatches": 0,
-        "replies": 0,
-    }
-    current_ticket: Optional[str] = None
-    agent_id: Optional[str] = None
-
-    if run_record:
-        run_data = {
-            "id": run_record.id,
-            "short_id": run_record.id.split("-")[0] if run_record.id else None,
-            "status": run_record.status.value,
-            "started_at": run_record.started_at,
-            "finished_at": run_record.finished_at,
-            "duration_seconds": _duration_seconds(
-                run_record.started_at, run_record.finished_at, run_record.status.value
-            ),
-            "current_step": run_record.current_step,
-            "created_at": run_record.created_at,
-        }
-
-        state = run_record.state if isinstance(run_record.state, dict) else {}
-        ticket_state = state.get("ticket_engine") if isinstance(state, dict) else {}
-        if isinstance(ticket_state, dict):
-            turns["total"] = ticket_state.get("total_turns")  # type: ignore[index]
-            turns["current_ticket"] = ticket_state.get("ticket_turns")  # type: ignore[index]
-            current_ticket = ticket_state.get("current_ticket")  # type: ignore[assignment]
-            agent_id = ticket_state.get("last_agent_id")  # type: ignore[assignment]
-
-        workspace_value = run_record.input_data.get("workspace_root")
-        workspace_root = Path(workspace_value) if workspace_value else repo_root
-        runs_dir = Path(
-            run_record.input_data.get("runs_dir") or ".codex-autorunner/runs"
-        )
-        outbox_paths = resolve_outbox_paths(
-            workspace_root=workspace_root, runs_dir=runs_dir, run_id=run_record.id
-        )
-        reply_paths = resolve_reply_paths(
-            workspace_root=workspace_root, runs_dir=runs_dir, run_id=run_record.id
-        )
-        turns["dispatches"] = _count_history_dirs(outbox_paths.dispatch_history_dir)
-        turns["replies"] = _count_history_dirs(reply_paths.reply_history_dir)
-
-        # If current ticket is known, read its frontmatter to pick agent id when available.
-        if current_ticket:
-            current_path = (workspace_root / current_ticket).resolve()
-            try:
-                doc, _errors = read_ticket(current_path)
-                if doc and doc.frontmatter and getattr(doc.frontmatter, "agent", None):
-                    agent_id = doc.frontmatter.agent
-            except Exception:
-                pass
-
-    ticket_counts = _ticket_counts(ticket_dir)
-
-    return {
-        "run": run_data,
-        "tickets": {
-            "todo_count": ticket_counts["todo"],
-            "done_count": ticket_counts["done"],
-            "total_count": ticket_counts["total"],
-            "current_ticket": current_ticket,
-        },
-        "turns": {
-            "total": turns.get("total"),
-            "current_ticket": turns.get("current_ticket"),
-            "dispatches": turns.get("dispatches"),
-            "replies": turns.get("replies"),
-        },
-        "agent": {
-            "id": agent_id,
-            "model": None,
-        },
-    }
-
-
-def build_analytics_routes() -> APIRouter:
-    router = APIRouter(prefix="/api/analytics", tags=["analytics"])
-
-    @router.get("/summary")
-    def get_analytics_summary():
-        repo_root = find_repo_root()
-        data = _build_summary(repo_root)
-        return data
-
-    return router
-
-
-__all__ = ["build_analytics_routes"]
+from ..surfaces.web.routes.analytics import *  # noqa: F401,F403

codex_autorunner/routes/app_server.py

@@ -1,132 +1,3 @@
-"""
-App-server support routes (thread registry).
-"""
+"""Backward-compatible app-server routes."""
 
-from pathlib import Path
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import FileResponse, StreamingResponse
-
-from ..core.app_server_threads import normalize_feature_key
-from ..core.utils import is_within
-from ..integrations.app_server.client import CodexAppServerError
-from ..web.schemas import (
-    AppServerThreadArchiveRequest,
-    AppServerThreadArchiveResponse,
-    AppServerThreadResetAllResponse,
-    AppServerThreadResetRequest,
-    AppServerThreadResetResponse,
-    AppServerThreadsResponse,
-)
-from .shared import SSE_HEADERS
-
-
-def build_app_server_routes() -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/api/app-server/turns/{turn_id}/events")
-    async def stream_app_server_turn_events(
-        turn_id: str, request: Request, thread_id: str
-    ):
-        events = getattr(request.app.state, "app_server_events", None)
-        if events is None:
-            raise HTTPException(status_code=404, detail="App-server events unavailable")
-        if not thread_id:
-            raise HTTPException(status_code=400, detail="thread_id is required")
-        return StreamingResponse(
-            events.stream(thread_id, turn_id),
-            media_type="text/event-stream",
-            headers=SSE_HEADERS,
-        )
-
-    @router.get("/api/app-server/threads", response_model=AppServerThreadsResponse)
-    def app_server_threads(request: Request):
-        registry = request.app.state.app_server_threads
-        return registry.feature_map()
-
-    @router.get("/api/app-server/models")
-    async def app_server_models(request: Request):
-        engine = request.app.state.engine
-        supervisor = request.app.state.app_server_supervisor
-        try:
-            client = await supervisor.get_client(engine.repo_root)
-            return await client.model_list()
-        except CodexAppServerError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
-
-    @router.post(
-        "/api/app-server/threads/reset", response_model=AppServerThreadResetResponse
-    )
-    def reset_app_server_thread(request: Request, payload: AppServerThreadResetRequest):
-        registry = request.app.state.app_server_threads
-        try:
-            key = normalize_feature_key(payload.key)
-        except ValueError as exc:
-            raise HTTPException(status_code=400, detail=str(exc)) from exc
-        cleared = registry.reset_thread(key)
-        return {"status": "ok", "key": key, "cleared": cleared}
-
-    @router.post(
-        "/api/app-server/threads/archive",
-        response_model=AppServerThreadArchiveResponse,
-    )
-    async def archive_app_server_thread(
-        request: Request, payload: AppServerThreadArchiveRequest
-    ):
-        thread_id = payload.thread_id.strip()
-        if not thread_id:
-            raise HTTPException(status_code=400, detail="thread_id is required")
-        engine = request.app.state.engine
-        supervisor = request.app.state.app_server_supervisor
-        try:
-            client = await supervisor.get_client(engine.repo_root)
-            await client.thread_archive(thread_id)
-        except CodexAppServerError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
-        return {"status": "ok", "thread_id": thread_id, "archived": True}
-
-    @router.post(
-        "/api/app-server/threads/reset-all",
-        response_model=AppServerThreadResetAllResponse,
-    )
-    def reset_app_server_threads(request: Request):
-        registry = request.app.state.app_server_threads
-        registry.reset_all()
-        return {"status": "ok", "cleared": True}
-
-    @router.get("/api/app-server/threads/backup")
-    def download_app_server_threads_backup(request: Request):
-        registry = request.app.state.app_server_threads
-        notice = registry.corruption_notice() or {}
-        backup_path = notice.get("backup_path")
-        if not isinstance(backup_path, str) or not backup_path:
-            raise HTTPException(status_code=404, detail="No backup available")
-        path = Path(backup_path)
-        engine = request.app.state.engine
-        if not is_within(engine.repo_root, path):
-            raise HTTPException(status_code=400, detail="Invalid backup path")
-        if not path.exists():
-            raise HTTPException(status_code=404, detail="Backup not found")
-        return FileResponse(path, filename=path.name)
-
-    @router.get("/api/app-server/account")
-    async def app_server_account(request: Request):
-        engine = request.app.state.engine
-        supervisor = request.app.state.app_server_supervisor
-        try:
-            client = await supervisor.get_client(engine.repo_root)
-            return await client.account_read()
-        except CodexAppServerError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
-
-    @router.get("/api/app-server/rate-limits")
-    async def app_server_rate_limits(request: Request):
-        engine = request.app.state.engine
-        supervisor = request.app.state.app_server_supervisor
-        try:
-            client = await supervisor.get_client(engine.repo_root)
-            return await client.rate_limits_read()
-        except CodexAppServerError as exc:
-            raise HTTPException(status_code=502, detail=str(exc)) from exc
-
-    return router
+from ..surfaces.web.routes.app_server import *  # noqa: F401,F403