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

codex_autorunner/surfaces/web/routes/workspace.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+import io
+import zipfile
+from dataclasses import asdict
+
+from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile
+from fastapi.responses import FileResponse, PlainTextResponse, StreamingResponse
+
+from ....core import drafts as draft_utils
+from ....tickets.spec_ingest import (
+    SpecIngestTicketsError,
+    ingest_workspace_spec_to_tickets,
+)
+from ....workspace.paths import (
+    PINNED_DOC_FILENAMES,
+    WORKSPACE_DOC_KINDS,
+    list_workspace_files,
+    list_workspace_tree,
+    normalize_workspace_rel_path,
+    read_workspace_doc,
+    read_workspace_file,
+    sanitize_workspace_filename,
+    workspace_dir,
+    workspace_doc_path,
+    write_workspace_doc,
+    write_workspace_file,
+)
+from ..schemas import (
+    SpecIngestTicketsResponse,
+    WorkspaceFileListResponse,
+    WorkspaceResponse,
+    WorkspaceTreeResponse,
+    WorkspaceUploadResponse,
+    WorkspaceWriteRequest,
+)
+
+
+def build_workspace_routes() -> APIRouter:
+    router = APIRouter(prefix="/api", tags=["workspace"])
+
+    @router.get("/workspace", response_model=WorkspaceResponse)
+    def get_workspace(request: Request):
+        repo_root = request.app.state.engine.repo_root
+        return {
+            "active_context": read_workspace_doc(repo_root, "active_context"),
+            "decisions": read_workspace_doc(repo_root, "decisions"),
+            "spec": read_workspace_doc(repo_root, "spec"),
+        }
+
+    @router.get("/workspace/file", response_class=PlainTextResponse)
+    def read_workspace(request: Request, path: str):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            content = read_workspace_file(repo_root, path)
+        except ValueError as exc:  # invalid path
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return PlainTextResponse(content)
+
+    @router.put("/workspace/file", response_class=PlainTextResponse)
+    def write_workspace(request: Request, payload: WorkspaceWriteRequest, path: str):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            # Normalize path the same way workspace helpers do to avoid traversal
+            safe_path, rel_posix = normalize_workspace_rel_path(repo_root, path)
+            content = write_workspace_file(repo_root, path, payload.content)
+            try:
+                rel_repo_path = safe_path.relative_to(repo_root).as_posix()
+                draft_utils.invalidate_drafts_for_path(repo_root, rel_repo_path)
+                state_key = f"workspace_{rel_posix.replace('/', '_')}"
+                draft_utils.remove_draft(repo_root, state_key)
+            except Exception:
+                pass
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return PlainTextResponse(content)
+
+    @router.put("/workspace/{kind}", response_model=WorkspaceResponse)
+    def put_workspace(kind: str, payload: WorkspaceWriteRequest, request: Request):
+        key = (kind or "").strip().lower()
+        if key not in WORKSPACE_DOC_KINDS:
+            raise HTTPException(status_code=400, detail="invalid workspace doc kind")
+        repo_root = request.app.state.engine.repo_root
+        write_workspace_doc(repo_root, key, payload.content)
+        try:
+            rel_path = workspace_doc_path(repo_root, key).relative_to(repo_root)
+            draft_utils.invalidate_drafts_for_path(repo_root, rel_path.as_posix())
+            state_key = f"workspace_{rel_path.name}"
+            draft_utils.remove_draft(repo_root, state_key)
+        except Exception:
+            # best-effort invalidation; avoid blocking writes
+            pass
+        return {
+            "active_context": read_workspace_doc(repo_root, "active_context"),
+            "decisions": read_workspace_doc(repo_root, "decisions"),
+            "spec": read_workspace_doc(repo_root, "spec"),
+        }
+
+    @router.get("/workspace/files", response_model=WorkspaceFileListResponse)
+    def list_files(request: Request):
+        repo_root = request.app.state.engine.repo_root
+        files = [asdict(item) for item in list_workspace_files(repo_root)]
+        return {"files": files}
+
+    @router.get("/workspace/tree", response_model=WorkspaceTreeResponse)
+    def get_workspace_tree(request: Request):
+        repo_root = request.app.state.engine.repo_root
+        tree = [asdict(item) for item in list_workspace_tree(repo_root)]
+        return {"tree": tree}
+
+    @router.post("/workspace/upload", response_model=WorkspaceUploadResponse)
+    async def upload_workspace_files(
+        request: Request,
+        files: list[UploadFile] = File(...),  # noqa: B008
+        subdir: str = Form(""),
+    ):
+        if not files:
+            raise HTTPException(status_code=400, detail="no files provided")
+
+        repo_root = request.app.state.engine.repo_root
+        base = workspace_dir(repo_root)
+        target_dir = base
+        if subdir:
+            try:
+                target_dir, _ = normalize_workspace_rel_path(repo_root, subdir)
+            except ValueError as exc:
+                raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        target_dir.mkdir(parents=True, exist_ok=True)
+
+        uploaded: list[dict[str, str | int]] = []
+        for upload in files:
+            filename = sanitize_workspace_filename(upload.filename or "")
+            try:
+                data = await upload.read()
+            except (
+                Exception
+            ) as exc:  # pragma: no cover - handled by FastAPI for most cases
+                raise HTTPException(
+                    status_code=400, detail="failed to read upload"
+                ) from exc
+
+            dest = target_dir / filename
+            dest.write_bytes(
+                data
+            )  # codeql[py/path-injection] dest sits under normalized workspace dir
+            rel_path = dest.relative_to(base).as_posix()
+            uploaded.append({"filename": filename, "path": rel_path, "size": len(data)})
+
+        return {"status": "ok", "uploaded": uploaded}
+
+    @router.get("/workspace/download")
+    async def download_workspace_file(request: Request, path: str):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            safe_path, _ = normalize_workspace_rel_path(repo_root, path)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        if not safe_path.exists() or safe_path.is_dir():
+            raise HTTPException(status_code=404, detail="file not found")
+
+        return FileResponse(
+            path=safe_path, filename=safe_path.name
+        )  # codeql[py/path-injection] safe_path validated by normalize_workspace_rel_path
+
+    @router.get("/workspace/download-zip")
+    async def download_workspace_zip(request: Request, path: str = ""):
+        repo_root = request.app.state.engine.repo_root
+        base = workspace_dir(repo_root)
+        base.mkdir(parents=True, exist_ok=True)
+
+        target_dir = base
+        zip_name = "workspace.zip"
+        if path:
+            try:
+                target_dir, _ = normalize_workspace_rel_path(repo_root, path)
+            except ValueError as exc:
+                raise HTTPException(status_code=400, detail=str(exc)) from exc
+            if not target_dir.exists() or not target_dir.is_dir():
+                raise HTTPException(status_code=404, detail="folder not found")
+            zip_name = f"{target_dir.name}.zip"
+
+        buffer = io.BytesIO()
+        base_real = base.resolve()
+        with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zf:
+            for file_path in target_dir.rglob("*"):
+                if file_path.is_dir():
+                    continue
+                if file_path.is_symlink():
+                    try:
+                        file_path.resolve().relative_to(base_real)
+                    except Exception:
+                        continue
+                arc_name = file_path.relative_to(target_dir).as_posix()
+                zf.write(
+                    file_path, arc_name
+                )  # codeql[py/path-injection] file_path constrained to workspace dir
+
+        buffer.seek(0)
+        return StreamingResponse(
+            buffer,
+            media_type="application/zip",
+            headers={"Content-Disposition": f'attachment; filename="{zip_name}"'},
+        )
+
+    @router.post("/workspace/folder")
+    async def create_workspace_folder(request: Request, path: str):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            safe_path, rel_posix = normalize_workspace_rel_path(repo_root, path)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        if safe_path.exists():
+            raise HTTPException(status_code=400, detail="path already exists")
+
+        safe_path.mkdir(parents=True, exist_ok=True)
+        return {"status": "created", "path": rel_posix}
+
+    @router.delete("/workspace/folder")
+    async def delete_workspace_folder(request: Request, path: str):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            safe_path, rel_posix = normalize_workspace_rel_path(repo_root, path)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        if not safe_path.exists():
+            raise HTTPException(status_code=404, detail="folder not found")
+        if not safe_path.is_dir():
+            raise HTTPException(status_code=400, detail="not a folder")
+        if any(safe_path.iterdir()):
+            raise HTTPException(status_code=400, detail="folder not empty")
+
+        safe_path.rmdir()
+        return {"status": "deleted", "path": rel_posix}
+
+    @router.delete("/workspace/file")
+    async def delete_workspace_file(request: Request, path: str):
+        repo_root = request.app.state.engine.repo_root
+        base = workspace_dir(repo_root)
+        try:
+            safe_path, rel_posix = normalize_workspace_rel_path(repo_root, path)
+        except ValueError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        if safe_path.parent == base and safe_path.name in PINNED_DOC_FILENAMES:
+            raise HTTPException(status_code=400, detail="cannot delete pinned docs")
+        if not safe_path.exists():
+            raise HTTPException(status_code=404, detail="file not found")
+        if safe_path.is_dir():
+            raise HTTPException(status_code=400, detail="use folder delete endpoint")
+
+        safe_path.unlink()  # codeql[py/path-injection] safe_path validated by normalize_workspace_rel_path
+        return {"status": "deleted", "path": rel_posix}
+
+    @router.post("/workspace/spec/ingest", response_model=SpecIngestTicketsResponse)
+    def ingest_workspace_spec(request: Request):
+        repo_root = request.app.state.engine.repo_root
+        try:
+            result = ingest_workspace_spec_to_tickets(repo_root)
+        except SpecIngestTicketsError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {
+            "status": "ok",
+            "created": result.created,
+            "first_ticket_path": result.first_ticket_path,
+        }
+
+    return router

codex_autorunner/surfaces/web/runner_manager.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from ...core.engine import Engine
+from ...core.runner_controller import ProcessRunnerController
+
+
+class RunnerManager:
+    def __init__(self, engine: Engine):
+        self._controller = ProcessRunnerController(engine)
+
+    @property
+    def running(self) -> bool:
+        return self._controller.running
+
+    def start(self, once: bool = False) -> None:
+        self._controller.start(once=once)
+
+    def resume(self, once: bool = False) -> None:
+        self._controller.resume(once=once)
+
+    def stop(self) -> None:
+        self._controller.stop()
+
+    def kill(self) -> None:
+        self._controller.kill()

codex_autorunner/surfaces/web/schemas.py

@@ -0,0 +1,417 @@
+"""
+Pydantic request/response schemas for web and API routes.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field
+
+
+class Payload(BaseModel):
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+
+class ResponseModel(BaseModel):
+    model_config = ConfigDict(extra="ignore")
+
+
+class WorkspaceWriteRequest(Payload):
+    content: str = ""
+
+
+class WorkspaceResponse(ResponseModel):
+    active_context: str
+    decisions: str
+    spec: str
+
+
+class WorkspaceFileItem(ResponseModel):
+    name: str
+    path: str
+    is_pinned: bool = False
+    modified_at: Optional[str] = None
+
+
+class WorkspaceFileListResponse(ResponseModel):
+    files: List[WorkspaceFileItem]
+
+
+class WorkspaceNode(ResponseModel):
+    name: str
+    path: str
+    type: Literal["file", "folder"]
+    is_pinned: bool = False
+    modified_at: Optional[str] = None
+    size: Optional[int] = None
+    children: Optional[List["WorkspaceNode"]] = None
+
+
+WorkspaceNode.model_rebuild()
+
+
+class WorkspaceTreeResponse(ResponseModel):
+    tree: List[WorkspaceNode]
+
+
+class WorkspaceUploadedItem(ResponseModel):
+    filename: str
+    path: str
+    size: int
+
+
+class WorkspaceUploadResponse(ResponseModel):
+    status: str
+    uploaded: List[WorkspaceUploadedItem]
+
+
+class ArchiveSnapshotSummary(ResponseModel):
+    snapshot_id: str
+    worktree_repo_id: str
+    created_at: Optional[str] = None
+    status: Optional[str] = None
+    branch: Optional[str] = None
+    head_sha: Optional[str] = None
+    note: Optional[str] = None
+    summary: Optional[Dict[str, Any]] = None
+
+
+class ArchiveSnapshotsResponse(ResponseModel):
+    snapshots: List[ArchiveSnapshotSummary]
+
+
+class ArchiveSnapshotDetailResponse(ResponseModel):
+    snapshot: ArchiveSnapshotSummary
+    meta: Optional[Dict[str, Any]] = None
+
+
+class ArchiveTreeNode(ResponseModel):
+    path: str
+    name: str
+    type: Literal["file", "folder"]
+    size_bytes: Optional[int] = None
+    mtime: Optional[float] = None
+
+
+class ArchiveTreeResponse(ResponseModel):
+    path: str
+    nodes: List[ArchiveTreeNode]
+
+
+class SpecIngestTicketsResponse(ResponseModel):
+    status: str
+    created: int
+    first_ticket_path: Optional[str] = None
+
+
+class RunControlRequest(Payload):
+    once: bool = False
+    agent: Optional[str] = None
+    model: Optional[str] = None
+    reasoning: Optional[str] = None
+
+
+class HubCreateRepoRequest(Payload):
+    git_url: Optional[str] = Field(
+        default=None, validation_alias=AliasChoices("git_url", "gitUrl")
+    )
+    repo_id: Optional[str] = Field(
+        default=None, validation_alias=AliasChoices("repo_id", "id")
+    )
+    path: Optional[str] = None
+    git_init: bool = True
+    force: bool = False
+
+
+class HubRemoveRepoRequest(Payload):
+    force: bool = False
+    delete_dir: bool = True
+    delete_worktrees: bool = False
+
+
+class HubCreateWorktreeRequest(Payload):
+    base_repo_id: str = Field(
+        validation_alias=AliasChoices("base_repo_id", "baseRepoId")
+    )
+    branch: str
+    force: bool = False
+    start_point: Optional[str] = Field(
+        default=None,
+        validation_alias=AliasChoices(
+            "start_point", "startPoint", "base_ref", "baseRef"
+        ),
+    )
+
+
+class HubCleanupWorktreeRequest(Payload):
+    worktree_repo_id: str = Field(
+        validation_alias=AliasChoices("worktree_repo_id", "worktreeRepoId")
+    )
+    delete_branch: bool = False
+    delete_remote: bool = False
+    archive: bool = True
+    force_archive: bool = Field(
+        default=False, validation_alias=AliasChoices("force_archive", "forceArchive")
+    )
+    archive_note: Optional[str] = Field(
+        default=None, validation_alias=AliasChoices("archive_note", "archiveNote")
+    )
+
+
+class AppServerThreadResetRequest(Payload):
+    key: str = Field(
+        validation_alias=AliasChoices("key", "feature", "feature_key", "featureKey")
+    )
+
+
+class AppServerThreadArchiveRequest(Payload):
+    thread_id: str = Field(validation_alias=AliasChoices("thread_id", "threadId", "id"))
+
+
+class SessionSettingsRequest(Payload):
+    autorunner_model_override: Optional[str] = None
+    autorunner_effort_override: Optional[str] = None
+    autorunner_approval_policy: Optional[str] = None
+    autorunner_sandbox_mode: Optional[str] = None
+    autorunner_workspace_write_network: Optional[bool] = None
+    runner_stop_after_runs: Optional[int] = None
+
+
+class GithubIssueRequest(Payload):
+    issue: str
+
+
+class GithubContextRequest(Payload):
+    url: str
+
+
+class GithubPrSyncRequest(Payload):
+    draft: bool = True
+    title: Optional[str] = None
+    body: Optional[str] = None
+    mode: Optional[str] = None
+
+
+class SessionStopRequest(Payload):
+    session_id: Optional[str] = None
+    repo_path: Optional[str] = None
+
+
+class SystemUpdateRequest(Payload):
+    target: Optional[str] = None
+
+
+class HubJobResponse(ResponseModel):
+    job_id: str
+    kind: str
+    status: str
+    created_at: str
+    started_at: Optional[str]
+    finished_at: Optional[str]
+    result: Optional[Dict[str, Any]]
+    error: Optional[str]
+
+
+class StateResponse(ResponseModel):
+    last_run_id: Optional[int]
+    status: str
+    last_exit_code: Optional[int]
+    last_run_started_at: Optional[str]
+    last_run_finished_at: Optional[str]
+    outstanding_count: int
+    done_count: int
+    running: bool
+    runner_pid: Optional[int]
+    lock_present: bool
+    lock_pid: Optional[int]
+    lock_freeable: bool
+    lock_freeable_reason: Optional[str]
+    terminal_idle_timeout_seconds: Optional[int]
+    codex_model: str
+
+
+class SessionSettingsResponse(ResponseModel):
+    autorunner_model_override: Optional[str]
+    autorunner_effort_override: Optional[str]
+    autorunner_approval_policy: Optional[str]
+    autorunner_sandbox_mode: Optional[str]
+    autorunner_workspace_write_network: Optional[bool]
+    runner_stop_after_runs: Optional[int]
+
+
+class VersionResponse(ResponseModel):
+    asset_version: Optional[str]
+
+
+class RunControlResponse(ResponseModel):
+    running: bool
+    once: bool
+
+
+class RunStatusResponse(ResponseModel):
+    running: bool
+
+
+class RunResetResponse(ResponseModel):
+    status: str
+    message: str
+
+
+class SessionItemResponse(ResponseModel):
+    session_id: str
+    repo_path: Optional[str]
+    abs_repo_path: Optional[str] = None
+    created_at: Optional[str]
+    last_seen_at: Optional[str]
+    status: Optional[str]
+    alive: bool
+
+
+class SessionsResponse(ResponseModel):
+    sessions: List[SessionItemResponse]
+    repo_to_session: Dict[str, str]
+    abs_repo_to_session: Optional[Dict[str, str]] = None
+
+
+class SessionStopResponse(ResponseModel):
+    status: str
+    session_id: str
+
+
+class AppServerThreadsResponse(ResponseModel):
+    file_chat: Optional[str] = None
+    file_chat_opencode: Optional[str] = None
+    autorunner: Optional[str] = None
+    autorunner_opencode: Optional[str] = None
+    corruption: Optional[Dict[str, Any]] = None
+
+
+class AppServerThreadResetResponse(ResponseModel):
+    status: str
+    key: str
+    cleared: bool
+
+
+class AppServerThreadArchiveResponse(ResponseModel):
+    status: str
+    thread_id: str
+    archived: bool
+
+
+class AppServerThreadResetAllResponse(ResponseModel):
+    status: str
+    cleared: bool
+
+
+class TokenTotalsResponse(ResponseModel):
+    input_tokens: int
+    cached_input_tokens: int
+    output_tokens: int
+    reasoning_output_tokens: int
+    total_tokens: int
+
+
+class RepoUsageResponse(ResponseModel):
+    mode: str
+    repo: str
+    codex_home: str
+    since: Optional[str]
+    until: Optional[str]
+    status: str
+    events: int
+    totals: TokenTotalsResponse
+    latest_rate_limits: Optional[Dict[str, Any]]
+
+
+class UsageSeriesEntryResponse(ResponseModel):
+    key: str
+    model: Optional[str]
+    token_type: Optional[str]
+    total: int
+    values: List[int]
+
+
+class UsageSeriesResponse(ResponseModel):
+    mode: str
+    repo: str
+    codex_home: str
+    since: Optional[str]
+    until: Optional[str]
+    status: str
+    bucket: str
+    segment: str
+    buckets: List[str]
+    series: List[UsageSeriesEntryResponse]
+
+
+class SystemHealthResponse(ResponseModel):
+    status: str
+    mode: str
+    base_path: str
+    asset_version: Optional[str] = None
+
+
+class SystemUpdateResponse(ResponseModel):
+    status: str
+    message: str
+    target: str
+
+
+class SystemUpdateStatusResponse(ResponseModel):
+    status: str
+    message: str
+
+
+class SystemUpdateCheckResponse(ResponseModel):
+    status: str
+    update_available: bool
+    message: str
+    local_commit: Optional[str] = None
+    remote_commit: Optional[str] = None
+
+
+class ReviewStartRequest(Payload):
+    agent: Optional[str] = None
+    model: Optional[str] = None
+    reasoning: Optional[str] = None
+    max_wallclock_seconds: Optional[int] = Field(
+        default=None,
+        validation_alias=AliasChoices("max_wallclock_seconds", "maxWallclockSeconds"),
+    )
+
+
+class ReviewStatusResponse(ResponseModel):
+    review: Dict[str, Any]
+
+
+class ReviewControlResponse(ResponseModel):
+    status: str
+    detail: Optional[str] = None
+
+
+# Ticket CRUD schemas
+
+
+class TicketCreateRequest(Payload):
+    agent: str = "codex"
+    title: Optional[str] = None
+    goal: Optional[str] = None
+    body: str = ""
+
+
+class TicketUpdateRequest(Payload):
+    content: str  # Full markdown with frontmatter
+
+
+class TicketResponse(ResponseModel):
+    path: str
+    index: int
+    frontmatter: Dict[str, Any]
+    body: str
+
+
+class TicketDeleteResponse(ResponseModel):
+    status: str
+    index: int
+    path: str