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

codex_autorunner/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 ..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

codex_autorunner/server.py

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

codex_autorunner/static/agentControls.js

@@ -1,3 +1,4 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
 import { api, flash } from "./utils.js";
 const STORAGE_KEYS = {
     selected: "car.agent.selected",

codex_autorunner/static/agentEvents.js

@@ -0,0 +1,248 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+/**
+ * Shared parsing helpers for agent (app-server) events.
+ * Used by ticket chat and live agent output to render rich activity.
+ */
+function extractCommand(item, params) {
+    const command = item?.command ?? params?.command;
+    if (Array.isArray(command)) {
+        return command
+            .map((part) => String(part))
+            .join(" ")
+            .trim();
+    }
+    if (typeof command === "string")
+        return command.trim();
+    return "";
+}
+function extractFiles(payload) {
+    const files = [];
+    const addEntry = (entry) => {
+        if (typeof entry === "string" && entry.trim()) {
+            files.push(entry.trim());
+            return;
+        }
+        if (entry && typeof entry === "object") {
+            const entryObj = entry;
+            const path = entryObj.path || entryObj.file || entryObj.name;
+            if (typeof path === "string" && path.trim()) {
+                files.push(path.trim());
+            }
+        }
+    };
+    if (!payload || typeof payload !== "object")
+        return files;
+    for (const key of ["files", "fileChanges", "paths"]) {
+        const value = payload[key];
+        if (Array.isArray(value)) {
+            value.forEach(addEntry);
+        }
+    }
+    for (const key of ["path", "file", "name"]) {
+        addEntry(payload[key]);
+    }
+    return files;
+}
+function extractErrorMessage(params) {
+    if (!params || typeof params !== "object")
+        return "";
+    const err = params.error;
+    if (err && typeof err === "object") {
+        const errObj = err;
+        const message = typeof errObj.message === "string" ? errObj.message : "";
+        const details = typeof errObj.additionalDetails === "string"
+            ? errObj.additionalDetails
+            : typeof errObj.details === "string"
+                ? errObj.details
+                : "";
+        if (message && details && message !== details) {
+            return `${message} (${details})`;
+        }
+        return message || details;
+    }
+    if (typeof err === "string")
+        return err;
+    if (typeof params.message === "string")
+        return params.message;
+    return "";
+}
+function hasMeaningfulText(summary, detail) {
+    return Boolean(summary.trim() || detail.trim());
+}
+function inferSignificance(kind, method) {
+    if (kind === "thinking")
+        return true;
+    if (kind === "error")
+        return true;
+    if (["tool", "command", "file", "output"].includes(kind))
+        return true;
+    if (method.includes("requestApproval"))
+        return true;
+    return false;
+}
+/**
+ * Extract output delta text from an event payload.
+ */
+export function extractOutputDelta(payload) {
+    const message = payload && typeof payload === "object" ? payload.message || payload : payload;
+    if (!message || typeof message !== "object")
+        return "";
+    const method = String(message.method || "").toLowerCase();
+    if (!method.includes("outputdelta"))
+        return "";
+    const params = message.params || {};
+    if (typeof params.delta === "string")
+        return params.delta;
+    if (typeof params.text === "string")
+        return params.text;
+    if (typeof params.output === "string")
+        return params.output;
+    return "";
+}
+/**
+ * Parse an app-server event payload into a normalized AgentEvent plus merge hints.
+ */
+export function parseAppServerEvent(payload) {
+    const message = payload && typeof payload === "object" ? payload.message || payload : payload;
+    if (!message || typeof message !== "object")
+        return null;
+    const messageObj = message;
+    const method = messageObj.method || "app-server";
+    const params = messageObj.params || {};
+    const item = params.item || {};
+    const itemId = params.itemId || item.id || item.itemId || null;
+    const receivedAt = payload && typeof payload === "object"
+        ? payload.received_at || payload.receivedAt || Date.now()
+        : Date.now();
+    // Handle reasoning/thinking deltas - accumulate into existing event
+    if (method === "item/reasoning/summaryTextDelta") {
+        const delta = params.delta || "";
+        if (!delta)
+            return null;
+        const event = {
+            id: payload?.id || `${Date.now()}`,
+            title: "Thinking",
+            summary: delta,
+            detail: "",
+            kind: "thinking",
+            isSignificant: true,
+            time: receivedAt,
+            itemId,
+            method,
+        };
+        return { event, mergeStrategy: "append" };
+    }
+    // Handle reasoning part added (paragraph break)
+    if (method === "item/reasoning/summaryPartAdded") {
+        const event = {
+            id: payload?.id || `${Date.now()}`,
+            title: "Thinking",
+            summary: "",
+            detail: "",
+            kind: "thinking",
+            isSignificant: true,
+            time: receivedAt,
+            itemId,
+            method,
+        };
+        return { event, mergeStrategy: "newline" };
+    }
+    let title = method;
+    let summary = "";
+    let detail = "";
+    let kind = "event";
+    // Handle generic status updates
+    if (method === "status" || params.status) {
+        title = "Status";
+        summary = params.status || "Processing";
+        kind = "status";
+    }
+    else if (method === "item/completed") {
+        const itemType = item.type;
+        if (itemType === "commandExecution") {
+            title = "Command";
+            summary = extractCommand(item, params);
+            kind = "command";
+            if (item.exitCode !== undefined && item.exitCode !== null) {
+                detail = `exit ${item.exitCode}`;
+            }
+        }
+        else if (itemType === "fileChange") {
+            title = "File change";
+            const files = extractFiles(item);
+            summary = files.join(", ") || "Updated files";
+            kind = "file";
+        }
+        else if (itemType === "tool") {
+            title = "Tool";
+            summary =
+                item.name ||
+                    item.tool ||
+                    item.id ||
+                    "Tool call";
+            kind = "tool";
+        }
+        else if (itemType === "agentMessage") {
+            title = "Agent";
+            summary = item.text || "Agent message";
+            kind = "output";
+        }
+        else {
+            title = itemType ? `Item ${itemType}` : "Item completed";
+            summary = item.text || item.message || "";
+        }
+    }
+    else if (method === "item/commandExecution/requestApproval") {
+        title = "Command approval";
+        summary = extractCommand(item, params) || "Approval requested";
+        kind = "command";
+    }
+    else if (method === "item/fileChange/requestApproval") {
+        title = "File approval";
+        const files = extractFiles(params);
+        summary = files.join(", ") || "Approval requested";
+        kind = "file";
+    }
+    else if (method === "turn/completed") {
+        title = "Turn completed";
+        summary = params.status || "completed";
+        kind = "status";
+    }
+    else if (method === "error") {
+        title = "Error";
+        summary = extractErrorMessage(params) || "App-server error";
+        kind = "error";
+    }
+    else if (method.includes("outputDelta")) {
+        title = "Output";
+        summary = params.delta || params.text || "";
+        kind = "output";
+    }
+    else if (params.delta) {
+        title = "Delta";
+        summary = params.delta;
+    }
+    const summaryText = typeof summary === "string" ? summary : String(summary ?? "");
+    const detailText = typeof detail === "string" ? detail : String(detail ?? "");
+    const meaningful = hasMeaningfulText(summaryText, detailText);
+    const isStarted = method.includes("item/started");
+    if (!meaningful && isStarted) {
+        return null;
+    }
+    if (!meaningful) {
+        return null;
+    }
+    const isSignificant = inferSignificance(kind, method);
+    const event = {
+        id: payload?.id || `${Date.now()}`,
+        title,
+        summary: summaryText,
+        detail: detailText,
+        kind,
+        isSignificant,
+        time: receivedAt,
+        itemId,
+        method,
+    };
+    return { event };
+}

codex_autorunner/static/app.js

@@ -1,19 +1,20 @@
+// 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 { initDashboard } from "./dashboard.js";
-import { initDocs } from "./docs.js";
-import { initLogs } from "./logs.js";
 import { initTerminal } from "./terminal.js";
-import { initRuns } from "./runs.js";
-import { loadState } from "./state.js";
-import { initGitHub } from "./github.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 { flash } from "./utils.js";
 import { initLiveUpdates } from "./liveUpdates.js";
-function initRepoShell() {
+import { initHealthGate } from "./health.js";
+import { initWorkspace } from "./workspace.js";
+import { initDashboard } from "./dashboard.js";
+async function initRepoShell() {
+    await initHealthGate();
     if (REPO_ID) {
         const navBar = document.querySelector(".nav-bar");
         if (navBar) {
@@ -32,23 +33,27 @@ function initRepoShell() {
             brand.insertAdjacentElement("afterend", repoName);
         }
     }
-    registerTab("dashboard", "Dashboard");
-    registerTab("docs", "Docs");
-    registerTab("runs", "Runs");
-    registerTab("logs", "Logs");
+    const defaultTab = REPO_ID ? "tickets" : "analytics";
+    registerTab("tickets", "Tickets");
+    registerTab("inbox", "Inbox");
+    registerTab("analytics", "Analytics");
+    registerTab("workspace", "Workspace");
     registerTab("terminal", "Terminal");
     const initializedTabs = new Set();
     const lazyInit = (tabId) => {
         if (initializedTabs.has(tabId))
             return;
-        if (tabId === "docs") {
-            initDocs();
+        if (tabId === "workspace") {
+            initWorkspace();
+        }
+        else if (tabId === "inbox" || tabId === "messages") {
+            initMessages();
         }
-        else if (tabId === "logs") {
-            initLogs();
+        else if (tabId === "analytics") {
+            initDashboard();
         }
-        else if (tabId === "runs") {
-            initRuns();
+        else if (tabId === "tickets") {
+            initTicketFlow();
         }
         initializedTabs.add(tabId);
     };
@@ -58,7 +63,7 @@ function initRepoShell() {
         }
         lazyInit(tabId);
     });
-    initTabs();
+    initTabs(defaultTab);
     const activePanel = document.querySelector(".panel.active");
     if (activePanel?.id) {
         lazyInit(activePanel.id);
@@ -67,12 +72,10 @@ function initRepoShell() {
     terminalPanel?.addEventListener("pointerdown", () => {
         lazyInit("terminal");
     }, { once: true });
-    initDashboard();
+    initMessageBell();
     initLiveUpdates();
     initRepoSettingsPanel();
-    initGitHub();
     initMobileCompact();
-    loadState();
     const repoShell = document.getElementById("repo-shell");
     if (repoShell?.hasAttribute("inert")) {
         const openModals = document.querySelectorAll(".modal-overlay:not([hidden])");
@@ -97,6 +100,6 @@ function bootstrap() {
         repoShell.classList.remove("hidden");
     if (hubShell)
         hubShell.classList.add("hidden");
-    initRepoShell();
+    void initRepoShell();
 }
 bootstrap();