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

codex_autorunner/routes/workspace.py

@@ -1,271 +1,3 @@
-from __future__ import annotations
+"""Backward-compatible workspace routes."""
 
-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 ..web.schemas import (
-    SpecIngestTicketsResponse,
-    WorkspaceFileListResponse,
-    WorkspaceResponse,
-    WorkspaceTreeResponse,
-    WorkspaceUploadResponse,
-    WorkspaceWriteRequest,
-)
-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,
-)
-
-
-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
+from ..surfaces.web.routes.workspace import *  # noqa: F401,F403

codex_autorunner/server.py

@@ -1,8 +1,8 @@
 from importlib import resources
 
 from .core.engine import Engine, LockError, clear_stale_lock, doctor
-from .web.app import create_app, create_hub_app, create_repo_app
-from .web.middleware import BasePathRouterMiddleware
+from .surfaces.web.app import create_app, create_hub_app, create_repo_app
+from .surfaces.web.middleware import BasePathRouterMiddleware
 
 __all__ = [
     "Engine",

codex_autorunner/static/agentControls.js

@@ -1,5 +1,6 @@
 // GENERATED FILE - do not edit directly. Source: static_src/
 import { api, flash } from "./utils.js";
+import { createSmartRefresh } from "./smartRefresh.js";
 const STORAGE_KEYS = {
     selected: "car.agent.selected",
     model: (agent) => `car.agent.${agent}.model`,
@@ -15,6 +16,22 @@ let agentList = [...FALLBACK_AGENTS];
 let defaultAgent = "codex";
 const modelCatalogs = new Map();
 const modelCatalogPromises = new Map();
+const agentControlsRefresh = createSmartRefresh({
+    getSignature: (payload) => {
+        const agentsSig = payload.agents
+            .map((agent) => `${agent.id}:${agent.name || ""}:${agent.version || ""}:${agent.protocol_version || ""}`)
+            .join("|");
+        const catalogSig = payload.catalog
+            ? `${payload.catalog.default_model || ""}:${payload.catalog.models
+                .map((model) => `${model.id}:${model.display_name || ""}:${model.supports_reasoning ? "1" : "0"}:${model.reasoning_options.join(",")}`)
+                .join("|")}`
+            : "none";
+        return `${agentsSig}::${payload.defaultAgent}::${catalogSig}`;
+    },
+    render: (payload) => {
+        renderAgentControls(payload);
+    },
+});
 function safeGetStorage(key) {
     try {
         return localStorage.getItem(key);
@@ -242,7 +259,7 @@ function resolveSelectedReasoning(agent, model) {
     }
     return model.reasoning_options[0] || "";
 }
-async function refreshControls() {
+async function loadAgentControlsPayload() {
     try {
         await loadAgents();
     }
@@ -251,11 +268,6 @@ async function refreshControls() {
         ensureFallbackAgents();
     }
     const selectedAgent = getSelectedAgent();
-    // Always update agent options first (uses in-memory agentList)
-    controls.forEach((control) => {
-        ensureAgentOptions(control.agentSelect);
-    });
-    // Then try to load model catalog
     let catalog = modelCatalogs.get(selectedAgent);
     if (!catalog) {
         try {
@@ -266,6 +278,20 @@ async function refreshControls() {
             catalog = null;
         }
     }
+    return {
+        agents: [...agentList],
+        defaultAgent,
+        selectedAgent,
+        catalog: catalog || null,
+    };
+}
+function renderAgentControls(payload) {
+    const selectedAgent = payload.selectedAgent;
+    // Always update agent options first (uses in-memory agentList)
+    controls.forEach((control) => {
+        ensureAgentOptions(control.agentSelect);
+    });
+    const catalog = payload.catalog;
     // Update model and reasoning options
     controls.forEach((control) => {
         ensureModelOptions(control.modelSelect, catalog);
@@ -288,6 +314,9 @@ async function refreshControls() {
         }
     });
 }
+export async function refreshAgentControls(request = {}) {
+    await agentControlsRefresh.refresh(loadAgentControlsPayload, request);
+}
 async function handleAgentChange(nextAgent) {
     const previous = getSelectedAgent();
     setSelectedAgent(nextAgent);
@@ -298,17 +327,17 @@ async function handleAgentChange(nextAgent) {
         setSelectedAgent(previous);
         flash(`Failed to load ${getLabelText(nextAgent)} models; staying on ${getLabelText(previous)}.`, "error");
     }
-    await refreshControls();
+    await refreshAgentControls({ force: true, reason: "manual" });
 }
 async function handleModelChange(nextModel) {
     const agent = getSelectedAgent();
     setSelectedModel(agent, nextModel);
-    await refreshControls();
+    await refreshAgentControls({ force: true, reason: "manual" });
 }
 async function handleReasoningChange(nextReasoning) {
     const agent = getSelectedAgent();
     setSelectedReasoning(agent, nextReasoning);
-    await refreshControls();
+    await refreshAgentControls({ force: true, reason: "manual" });
 }
 /**
  * @param {AgentControlConfig} [config]
@@ -343,10 +372,10 @@ export function initAgentControls(config = {}) {
         });
     }
     // Async refresh to load from API (will update if API returns different data)
-    refreshControls().catch((err) => {
+    refreshAgentControls({ force: true, reason: "initial" }).catch((err) => {
         console.warn("Failed to refresh agent controls", err);
     });
 }
 export async function ensureAgentCatalog() {
-    await refreshControls();
+    await refreshAgentControls({ force: true, reason: "manual" });
 }

codex_autorunner/static/app.js

@@ -1,18 +1,19 @@
 // GENERATED FILE - do not edit directly. Source: static_src/
 import { REPO_ID, HUB_BASE } from "./env.js";
 import { initHub } from "./hub.js";
-import { initTabs, registerTab } from "./tabs.js";
+import { initTabs, registerTab, registerHamburgerAction } from "./tabs.js";
 import { initTerminal } from "./terminal.js";
 import { initTicketFlow } from "./tickets.js";
 import { initMessages, initMessageBell } from "./messages.js";
 import { initMobileCompact } from "./mobileCompact.js";
 import { subscribe } from "./bus.js";
-import { initRepoSettingsPanel } from "./settings.js";
+import { initRepoSettingsPanel, openRepoSettings } from "./settings.js";
 import { flash } from "./utils.js";
 import { initLiveUpdates } from "./liveUpdates.js";
 import { initHealthGate } from "./health.js";
 import { initWorkspace } from "./workspace.js";
 import { initDashboard } from "./dashboard.js";
+import { initArchive } from "./archive.js";
 async function initRepoShell() {
     await initHealthGate();
     if (REPO_ID) {
@@ -36,9 +37,13 @@ async function initRepoShell() {
     const defaultTab = REPO_ID ? "tickets" : "analytics";
     registerTab("tickets", "Tickets");
     registerTab("inbox", "Inbox");
-    registerTab("analytics", "Analytics");
     registerTab("workspace", "Workspace");
     registerTab("terminal", "Terminal");
+    // Menu tabs (shown in hamburger menu)
+    registerTab("analytics", "Analytics", { menuTab: true, icon: "📊" });
+    registerTab("archive", "Archive", { menuTab: true, icon: "📦" });
+    // Settings action in hamburger menu
+    registerHamburgerAction("settings", "Settings", "⚙", () => openRepoSettings());
     const initializedTabs = new Set();
     const lazyInit = (tabId) => {
         if (initializedTabs.has(tabId))
@@ -52,6 +57,9 @@ async function initRepoShell() {
         else if (tabId === "analytics") {
             initDashboard();
         }
+        else if (tabId === "archive") {
+            initArchive();
+        }
         else if (tabId === "tickets") {
             initTicketFlow();
         }