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

codex_autorunner/routes/github.py

@@ -1,327 +0,0 @@
-"""
-GitHub integration routes.
-"""
-
-import asyncio
-import time
-from pathlib import Path
-from typing import Any, Dict, Optional, Tuple
-
-from fastapi import APIRouter, HTTPException, Query, Request
-from fastapi.responses import FileResponse, StreamingResponse
-
-from ..integrations.github.pr_flow import PrFlowError, PrFlowManager
-from ..integrations.github.service import GitHubError, GitHubService
-from ..web.schemas import (
-    GithubContextRequest,
-    GithubIssueRequest,
-    GithubPrFlowActionRequest,
-    GithubPrFlowStartRequest,
-    GithubPrSyncRequest,
-)
-from .shared import SSE_HEADERS, jsonl_event_stream
-
-_GITHUB_CACHE: Dict[Tuple[str, str], Dict[str, Any]] = {}
-_GITHUB_CACHE_LOCK = asyncio.Lock()
-_GITHUB_STATUS_TTL_SECONDS = 20.0
-_GITHUB_PR_TTL_SECONDS = 60.0
-
-
-async def _get_cached_status_payload(
-    request: Request,
-    *,
-    kind: str,
-    ttl_seconds: float,
-) -> dict:
-    repo_root = request.app.state.engine.repo_root.resolve()
-    key = (str(repo_root), kind)
-    now = time.monotonic()
-    task: Optional[asyncio.Task] = None
-
-    async with _GITHUB_CACHE_LOCK:
-        entry = _GITHUB_CACHE.get(key) or {}
-        value = entry.get("value")
-        expires_at = float(entry.get("expires_at", 0) or 0)
-        task = entry.get("task")
-
-        if value is not None and expires_at > now:
-            return value
-        if task is None:
-            task = asyncio.create_task(
-                asyncio.to_thread(_github(request).status_payload)
-            )
-            _GITHUB_CACHE[key] = {
-                "value": value,
-                "expires_at": expires_at,
-                "task": task,
-            }
-
-    if task is None:
-        task = asyncio.create_task(asyncio.to_thread(_github(request).status_payload))
-        async with _GITHUB_CACHE_LOCK:
-            _GITHUB_CACHE[key] = {"task": task}
-
-    try:
-        value = await task
-    except Exception:
-        async with _GITHUB_CACHE_LOCK:
-            current = _GITHUB_CACHE.get(key) or {}
-            if current.get("task") is task:
-                _GITHUB_CACHE.pop(key, None)
-        raise
-
-    async with _GITHUB_CACHE_LOCK:
-        _GITHUB_CACHE[key] = {
-            "value": value,
-            "expires_at": now + ttl_seconds,
-        }
-    return value
-
-
-def _github(request) -> GitHubService:
-    """Get a GitHubService instance from the request."""
-    engine = request.app.state.engine
-    return GitHubService(engine.repo_root, raw_config=engine.config.raw)
-
-
-def _pr_flow(request: Request) -> PrFlowManager:
-    manager = getattr(request.app.state, "pr_flow_manager", None)
-    if manager is None:
-        engine = request.app.state.engine
-        manager = PrFlowManager(
-            engine.repo_root,
-            app_server_supervisor=getattr(
-                request.app.state, "app_server_supervisor", None
-            ),
-            opencode_supervisor=getattr(request.app.state, "opencode_supervisor", None),
-            logger=getattr(request.app.state, "logger", None),
-        )
-        request.app.state.pr_flow_manager = manager
-    return manager
-
-
-def build_github_routes() -> APIRouter:
-    """Build routes for GitHub integration."""
-    router = APIRouter()
-
-    @router.get("/api/github/status")
-    async def github_status(request: Request):
-        try:
-            return await _get_cached_status_payload(
-                request,
-                kind="status",
-                ttl_seconds=_GITHUB_STATUS_TTL_SECONDS,
-            )
-        except GitHubError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.get("/api/github/pr")
-    async def github_pr(request: Request):
-        try:
-            status = await _get_cached_status_payload(
-                request,
-                kind="pr",
-                ttl_seconds=_GITHUB_PR_TTL_SECONDS,
-            )
-            return {
-                "status": "ok",
-                "git": status.get("git"),
-                "pr": status.get("pr"),
-                "links": status.get("pr_links"),
-                "link": status.get("link") or {},
-            }
-        except GitHubError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.post("/api/github/link-issue")
-    async def github_link_issue(request: Request, payload: GithubIssueRequest):
-        issue = payload.issue
-        try:
-            state = await asyncio.to_thread(_github(request).link_issue, str(issue))
-            return {"status": "ok", "link": state}
-        except GitHubError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.post("/api/github/spec/from-issue")
-    async def github_spec_from_issue(request: Request, payload: GithubIssueRequest):
-        issue = payload.issue
-
-        doc_chat = request.app.state.doc_chat
-        repo_blocked = doc_chat.repo_blocked_reason()
-        if repo_blocked:
-            raise HTTPException(status_code=409, detail=repo_blocked)
-        if doc_chat.doc_busy():
-            raise HTTPException(
-                status_code=409, detail="Doc chat already running for spec"
-            )
-
-        svc = _github(request)
-        try:
-            prompt, link_state = await asyncio.to_thread(
-                svc.build_spec_prompt_from_issue, str(issue)
-            )
-            doc_req = doc_chat.parse_request(
-                {"message": prompt, "stream": False}, kind="spec"
-            )
-            async with doc_chat.doc_lock():
-                result = await doc_chat.execute(doc_req)
-            if result.get("status") != "ok":
-                detail = result.get("detail") or "SPEC generation failed"
-                raise HTTPException(status_code=500, detail=detail)
-            result["github"] = {"issue": link_state.get("issue")}
-            return result
-        except GitHubError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except HTTPException:
-            raise
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.post("/api/github/pr/sync")
-    async def github_pr_sync(request: Request, payload: GithubPrSyncRequest):
-        if payload.mode is not None:
-            raise HTTPException(
-                status_code=400,
-                detail="Hub-only install: create a hub worktree repo instead of passing mode.",
-            )
-        draft = payload.draft
-        title = payload.title
-        body = payload.body
-        try:
-            return await asyncio.to_thread(
-                _github(request).sync_pr,
-                draft=draft,
-                title=str(title) if title else None,
-                body=str(body) if body else None,
-            )
-        except GitHubError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.post("/api/github/context")
-    async def github_context(request: Request, payload: GithubContextRequest):
-        url = payload.url
-        try:
-            result = await asyncio.to_thread(
-                _github(request).build_context_file_from_url, str(url)
-            )
-            if not result:
-                return {"status": "ok", "injected": False}
-            return {"status": "ok", "injected": True, **result}
-        except GitHubError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.get("/api/github/pr_flow/status")
-    async def github_pr_flow_status(request: Request):
-        try:
-            return {"status": "ok", "flow": _pr_flow(request).status()}
-        except PrFlowError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.post("/api/github/pr_flow/start")
-    async def github_pr_flow_start(request: Request, payload: GithubPrFlowStartRequest):
-        try:
-            state = await asyncio.to_thread(
-                _pr_flow(request).start, payload=payload.model_dump()
-            )
-            return {"status": "ok", "flow": state}
-        except PrFlowError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.post("/api/github/pr_flow/stop")
-    async def github_pr_flow_stop(
-        request: Request, _payload: GithubPrFlowActionRequest
-    ):
-        try:
-            state = await asyncio.to_thread(_pr_flow(request).stop)
-            return {"status": "ok", "flow": state}
-        except PrFlowError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.post("/api/github/pr_flow/resume")
-    async def github_pr_flow_resume(
-        request: Request, _payload: GithubPrFlowActionRequest
-    ):
-        try:
-            state = await asyncio.to_thread(_pr_flow(request).resume)
-            return {"status": "ok", "flow": state}
-        except PrFlowError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.post("/api/github/pr_flow/collect")
-    async def github_pr_flow_collect(
-        request: Request, _payload: GithubPrFlowActionRequest
-    ):
-        try:
-            state = await asyncio.to_thread(_pr_flow(request).collect_reviews)
-            return {"status": "ok", "flow": state}
-        except PrFlowError as exc:
-            raise HTTPException(status_code=exc.status_code, detail=str(exc)) from exc
-        except Exception as exc:
-            raise HTTPException(status_code=500, detail=str(exc)) from exc
-
-    @router.get("/api/github/pr_flow/events")
-    async def github_pr_flow_events(request: Request):
-        shutdown_event = getattr(request.app.state, "shutdown_event", None)
-        events_path = _pr_flow(request).events_path()
-        return StreamingResponse(
-            jsonl_event_stream(
-                events_path, event_name="pr-flow", shutdown_event=shutdown_event
-            ),
-            headers=SSE_HEADERS,
-            media_type="text/event-stream",
-        )
-
-    @router.get("/api/github/pr_flow/artifact")
-    async def github_pr_flow_artifact(
-        request: Request,
-        kind: str = Query(..., description="review_bundle|workflow_log|final_report"),
-    ):
-        flow = _pr_flow(request).status()
-        mapping = {
-            "review_bundle": flow.get("review_bundle_path"),
-            "workflow_log": flow.get("workflow_log_path"),
-            "final_report": flow.get("final_report_path"),
-        }
-        raw_path = mapping.get(kind)
-        if not raw_path:
-            raise HTTPException(status_code=404, detail="Artifact not found")
-        target = Path(raw_path).expanduser().resolve()
-        allowed_roots = [request.app.state.engine.repo_root.resolve()]
-        worktree_path = flow.get("worktree_path")
-        if isinstance(worktree_path, str) and worktree_path:
-            allowed_roots.append(Path(worktree_path).expanduser().resolve())
-        allowed = False
-        for root in allowed_roots:
-            try:
-                target.relative_to(root)
-                if ".codex-autorunner" in target.parts:
-                    allowed = True
-                    break
-            except ValueError:
-                continue
-        if not allowed or not target.exists():
-            raise HTTPException(status_code=404, detail="Artifact not found")
-        media_type = "text/plain"
-        if target.suffix == ".md":
-            media_type = "text/markdown"
-        return FileResponse(target, media_type=media_type, filename=target.name)
-
-    return router

codex_autorunner/routes/runs.py

@@ -1,250 +0,0 @@
-"""
-Run telemetry routes.
-"""
-
-import time
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Optional
-
-from fastapi import APIRouter, HTTPException, Request
-from fastapi.responses import FileResponse, StreamingResponse
-
-from ..core.utils import is_within
-from .shared import SSE_HEADERS, jsonl_event_stream
-
-
-def _parse_iso(ts: Optional[str]) -> Optional[datetime]:
-    if not isinstance(ts, str):
-        return None
-    try:
-        return datetime.strptime(ts, "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=timezone.utc)
-    except ValueError:
-        return None
-
-
-def _token_total(entry: dict[str, Any]) -> Optional[float]:
-    token_usage = entry.get("token_usage")
-    if not isinstance(token_usage, dict):
-        return None
-    delta = token_usage.get("delta")
-    if isinstance(delta, dict):
-        for key in ("total_tokens", "totalTokens", "total"):
-            value = delta.get(key)
-            if isinstance(value, (int, float)):
-                return float(value)
-    return None
-
-
-def _extract_total_from_dict(token_dict: Optional[dict[str, Any]]) -> Optional[float]:
-    if token_dict is None:
-        return None
-    if not isinstance(token_dict, dict):
-        return None
-    for key in ("total_tokens", "totalTokens", "total"):
-        value = token_dict.get(key)
-        if isinstance(value, (int, float)):
-            return float(value)
-    return None
-
-
-def _completed_todo_count(entry: dict[str, Any]) -> int:
-    todo = entry.get("todo")
-    if not isinstance(todo, dict):
-        return 0
-    counts = todo.get("counts")
-    if isinstance(counts, dict):
-        value = counts.get("completed")
-        if isinstance(value, int):
-            return value
-    completed = todo.get("completed")
-    return len(completed) if isinstance(completed, list) else 0
-
-
-def build_runs_routes() -> APIRouter:
-    router = APIRouter()
-
-    @router.get("/api/runs")
-    def list_runs(request: Request, limit: int = 200):
-        engine = request.app.state.engine
-        engine.reconcile_run_index()
-        index = engine._load_run_index()
-        entries: list[dict[str, Any]] = []
-        for key, entry in index.items():
-            try:
-                run_id = int(key)
-            except (TypeError, ValueError):
-                continue
-            if not isinstance(entry, dict):
-                continue
-            started = _parse_iso(entry.get("started_at"))
-            finished = _parse_iso(entry.get("finished_at"))
-            duration = None
-            if started and finished:
-                duration = (finished - started).total_seconds()
-            enriched = dict(entry)
-            enriched["run_id"] = run_id
-            enriched["duration_seconds"] = duration
-            enriched["token_total"] = _token_total(entry)
-            enriched["completed_todo_count"] = _completed_todo_count(entry)
-            entries.append(enriched)
-        entries.sort(key=lambda item: item.get("run_id", 0), reverse=True)
-        capped = entries[: max(1, min(int(limit), 1000))]
-        return {"runs": capped}
-
-    @router.get("/api/runs/{run_id}/plan")
-    def fetch_run_plan(request: Request, run_id: int):
-        engine = request.app.state.engine
-        entry = engine._load_run_index().get(str(run_id))
-        if not isinstance(entry, dict):
-            raise HTTPException(status_code=404, detail="Run not found")
-        artifacts = entry.get("artifacts")
-        if not isinstance(artifacts, dict):
-            raise HTTPException(status_code=404, detail="Plan not found")
-        plan_path = artifacts.get("plan_path")
-        if not isinstance(plan_path, str) or not plan_path:
-            raise HTTPException(status_code=404, detail="Plan not found")
-        path = Path(plan_path)
-        if not is_within(engine.repo_root, path):
-            raise HTTPException(status_code=400, detail="Invalid plan path")
-        if not path.exists():
-            raise HTTPException(status_code=404, detail="Plan not found")
-        return FileResponse(path, media_type="application/json")
-
-    @router.get("/api/runs/{run_id}/diff")
-    def fetch_run_diff(request: Request, run_id: int):
-        engine = request.app.state.engine
-        entry = engine._load_run_index().get(str(run_id))
-        if not isinstance(entry, dict):
-            raise HTTPException(status_code=404, detail="Run not found")
-        artifacts = entry.get("artifacts")
-        if not isinstance(artifacts, dict):
-            raise HTTPException(status_code=404, detail="Diff not found")
-        diff_path = artifacts.get("diff_path")
-        if not isinstance(diff_path, str) or not diff_path:
-            raise HTTPException(status_code=404, detail="Diff not found")
-        path = Path(diff_path)
-        if not is_within(engine.repo_root, path):
-            raise HTTPException(status_code=400, detail="Invalid diff path")
-        if not path.exists():
-            raise HTTPException(status_code=404, detail="Diff not found")
-        return FileResponse(path, media_type="text/plain")
-
-    @router.get("/api/runs/{run_id}/output")
-    def fetch_run_output(request: Request, run_id: int):
-        engine = request.app.state.engine
-        entry = engine._load_run_index().get(str(run_id))
-        if not isinstance(entry, dict):
-            raise HTTPException(status_code=404, detail="Run not found")
-        artifacts = entry.get("artifacts")
-        if not isinstance(artifacts, dict):
-            raise HTTPException(status_code=404, detail="Output not found")
-        output_path = artifacts.get("output_path")
-        if not isinstance(output_path, str) or not output_path:
-            raise HTTPException(status_code=404, detail="Output not found")
-        path = Path(output_path)
-        if not is_within(engine.repo_root, path):
-            raise HTTPException(status_code=400, detail="Invalid output path")
-        if not path.exists():
-            raise HTTPException(status_code=404, detail="Output not found")
-        return FileResponse(path, media_type="text/plain")
-
-    @router.get("/api/runs/{run_id}/telemetry")
-    def fetch_run_telemetry(request: Request, run_id: int):
-        engine = request.app.state.engine
-        telemetry = engine._snapshot_run_telemetry(run_id)
-        if telemetry is None:
-            entry = engine._load_run_index().get(str(run_id))
-            if not isinstance(entry, dict):
-                raise HTTPException(status_code=404, detail="Run not found")
-            token_usage = entry.get("token_usage")
-            if isinstance(token_usage, dict):
-                delta = token_usage.get("delta")
-                thread_total = token_usage.get("thread_total_after")
-            else:
-                delta = None
-                thread_total = None
-            return {
-                "run_id": run_id,
-                "status": "completed",
-                "thread_id": None,
-                "turn_id": None,
-                "token_delta": delta,
-                "token_total": thread_total,
-                "total_tokens": _extract_total_from_dict(delta),
-                "updated_at": None,
-            }
-        token_total = telemetry.token_total
-        total_tokens = _extract_total_from_dict(token_total)
-        return {
-            "run_id": run_id,
-            "status": "active",
-            "thread_id": telemetry.thread_id,
-            "turn_id": telemetry.turn_id,
-            "token_delta": None,
-            "token_total": token_total,
-            "total_tokens": total_tokens,
-            "updated_at": time.time(),
-        }
-
-    @router.get("/api/runs/{run_id}/events/stream")
-    async def stream_run_events(request: Request, run_id: int):
-        engine = request.app.state.engine
-        entry = engine._load_run_index().get(str(run_id))
-        if not isinstance(entry, dict):
-            raise HTTPException(status_code=404, detail="Run not found")
-        events_path = engine._events_log_path(run_id)
-        shutdown_event = getattr(request.app.state, "shutdown_event", None)
-        return StreamingResponse(
-            jsonl_event_stream(
-                events_path,
-                event_name="event",
-                shutdown_event=shutdown_event,
-            ),
-            media_type="text/event-stream",
-            headers=SSE_HEADERS,
-        )
-
-    @router.get("/api/runs/{run_id}/final_review")
-    def fetch_final_review(request: Request, run_id: int):
-        engine = request.app.state.engine
-        entry = engine._load_run_index().get(str(run_id))
-        if not isinstance(entry, dict):
-            raise HTTPException(status_code=404, detail="Run not found")
-        artifacts = entry.get("artifacts")
-        if not isinstance(artifacts, dict):
-            raise HTTPException(status_code=404, detail="Review not found")
-        report_path = artifacts.get("final_review_report_path")
-        if not isinstance(report_path, str) or not report_path:
-            raise HTTPException(status_code=404, detail="Review not found")
-        path = Path(report_path)
-        if not is_within(engine.repo_root, path):
-            raise HTTPException(status_code=400, detail="Invalid review path")
-        if not path.exists():
-            raise HTTPException(status_code=404, detail="Review not found")
-        media_type = "text/markdown" if path.suffix == ".md" else "text/plain"
-        return FileResponse(path, media_type=media_type)
-
-    @router.get("/api/runs/{run_id}/final_review_scratchpad")
-    def fetch_final_review_scratchpad(request: Request, run_id: int):
-        engine = request.app.state.engine
-        entry = engine._load_run_index().get(str(run_id))
-        if not isinstance(entry, dict):
-            raise HTTPException(status_code=404, detail="Run not found")
-        artifacts = entry.get("artifacts")
-        if not isinstance(artifacts, dict):
-            raise HTTPException(status_code=404, detail="Review scratchpad not found")
-        bundle_path = artifacts.get("final_review_scratchpad_bundle_path")
-        if not isinstance(bundle_path, str) or not bundle_path:
-            raise HTTPException(status_code=404, detail="Review scratchpad not found")
-        path = Path(bundle_path)
-        if not is_within(engine.repo_root, path):
-            raise HTTPException(status_code=400, detail="Invalid scratchpad path")
-        if not path.exists():
-            raise HTTPException(status_code=404, detail="Review scratchpad not found")
-        media_type = (
-            "application/zip" if path.suffix == ".zip" else "application/octet-stream"
-        )
-        return FileResponse(path, media_type=media_type)
-
-    return router