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

codex_autorunner/static/eventSummarizer.js

@@ -0,0 +1,166 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+export const COMPACT_MAX_ACTIONS = 10;
+export const COMPACT_MAX_TEXT_LENGTH = 80;
+const STATUS_ICONS = {
+    done: "✓",
+    fail: "✗",
+    warn: "⚠",
+    running: "▸",
+    update: "↻",
+    thinking: "🧠",
+};
+function normalizeText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function truncateText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, maxLength).trim()}…`;
+}
+function formatElapsed(seconds) {
+    const total = Math.max(Math.floor(seconds), 0);
+    if (total < 60)
+        return `${total}s`;
+    const minutes = Math.floor(total / 60);
+    const secs = total % 60;
+    if (minutes < 60)
+        return `${minutes}m ${secs}s`;
+    const hours = Math.floor(minutes / 60);
+    const remaining = minutes % 60;
+    return `${hours}h ${remaining}m`;
+}
+function deriveHeaderLabel(events) {
+    const lastError = [...events].reverse().find((evt) => evt.kind === "error");
+    if (lastError)
+        return "error";
+    const lastStatus = [...events].reverse().find((evt) => evt.kind === "status" && evt.summary);
+    if (lastStatus?.summary)
+        return lastStatus.summary;
+    return "working";
+}
+function eventToAction(event, maxTextLength) {
+    if (event.isSignificant === false && event.kind !== "thinking") {
+        return null;
+    }
+    const rawText = normalizeText(event.summary || event.detail || "");
+    if (!rawText)
+        return null;
+    let label = event.kind;
+    let status = "update";
+    if (event.kind === "command") {
+        label = "command";
+        status = event.method.includes("requestApproval") ? "warn" : "done";
+    }
+    else if (event.kind === "tool") {
+        label = "tool";
+        status = "done";
+    }
+    else if (event.kind === "file") {
+        label = "files";
+        status = event.method.includes("requestApproval") ? "warn" : "done";
+    }
+    else if (event.kind === "output") {
+        label = "output";
+        status = "update";
+    }
+    else if (event.kind === "thinking") {
+        label = "thinking";
+        status = "update";
+    }
+    else if (event.kind === "error") {
+        label = "error";
+        status = "fail";
+    }
+    else if (event.kind === "status") {
+        label = "status";
+        status = "running";
+    }
+    else {
+        label = "event";
+        status = "update";
+    }
+    const text = truncateText(rawText, maxTextLength);
+    const icon = label === "thinking" ? STATUS_ICONS.thinking : STATUS_ICONS[status] || STATUS_ICONS.running;
+    return { icon, label, text, status };
+}
+export function summarizeEvents(events, options = {}) {
+    const maxActions = options.maxActions ?? COMPACT_MAX_ACTIONS;
+    const maxTextLength = options.maxTextLength ?? COMPACT_MAX_TEXT_LENGTH;
+    const actions = [];
+    let lastOutputIndex = null;
+    let lastThinkingIndex = null;
+    events.forEach((event) => {
+        const action = eventToAction(event, maxTextLength);
+        if (!action)
+            return;
+        if (action.label === "output") {
+            if (lastOutputIndex != null) {
+                actions[lastOutputIndex] = action;
+            }
+            else {
+                actions.push(action);
+                lastOutputIndex = actions.length - 1;
+            }
+            return;
+        }
+        if (action.label === "thinking") {
+            if (lastThinkingIndex != null) {
+                actions[lastThinkingIndex] = action;
+            }
+            else {
+                actions.push(action);
+                lastThinkingIndex = actions.length - 1;
+            }
+            return;
+        }
+        actions.push(action);
+        lastOutputIndex = null;
+    });
+    let thinkingAction = null;
+    if (lastThinkingIndex != null && actions[lastThinkingIndex]) {
+        thinkingAction = actions[lastThinkingIndex];
+    }
+    let trimmedActions = actions.slice(-maxActions);
+    if (thinkingAction) {
+        trimmedActions = trimmedActions.filter((action) => action !== thinkingAction);
+        trimmedActions.push(thinkingAction);
+        if (maxActions > 0 && trimmedActions.length > maxActions) {
+            trimmedActions = trimmedActions.slice(-maxActions);
+        }
+    }
+    const step = actions.length;
+    const headerParts = [deriveHeaderLabel(events)];
+    const now = options.now ?? Date.now();
+    const startTime = options.startTime ?? (events.length ? Math.min(...events.map((evt) => evt.time || now)) : null);
+    if (startTime != null) {
+        const elapsed = (now - startTime) / 1000;
+        headerParts.push(formatElapsed(elapsed));
+    }
+    if (step) {
+        headerParts.push(`step ${step}`);
+    }
+    if (options.contextUsagePercent != null) {
+        headerParts.push(`ctx ${options.contextUsagePercent}%`);
+    }
+    return {
+        header: headerParts.join(" · "),
+        actions: trimmedActions,
+        thinkingText: thinkingAction?.text,
+    };
+}
+export function renderCompactSummary(summary) {
+    const lines = [];
+    if (summary.header) {
+        lines.push(summary.header);
+    }
+    summary.actions.forEach((action) => {
+        if (!action.text)
+            return;
+        if (action.label === "thinking") {
+            lines.push(`${STATUS_ICONS.thinking} ${action.text}`);
+            return;
+        }
+        lines.push(`${action.icon} ${action.label}: ${action.text}`);
+    });
+    return lines.join("\n");
+}

codex_autorunner/static/fileChat.js

@@ -0,0 +1,182 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+import { resolvePath, getAuthToken, api } from "./utils.js";
+const decoder = new TextDecoder();
+function parseMaybeJson(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+}
+export async function sendFileChat(target, message, controller, handlers = {}, options = {}) {
+    const endpoint = resolvePath("/api/file-chat");
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    const token = getAuthToken();
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const payload = {
+        target,
+        message,
+        stream: true,
+    };
+    if (options.agent)
+        payload.agent = options.agent;
+    if (options.model)
+        payload.model = options.model;
+    if (options.reasoning)
+        payload.reasoning = options.reasoning;
+    const res = await fetch(endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        let detail = text;
+        try {
+            const parsed = JSON.parse(text);
+            detail =
+                parsed.detail || parsed.error || parsed.message || text;
+        }
+        catch {
+            // ignore
+        }
+        throw new Error(detail || `Request failed (${res.status})`);
+    }
+    const contentType = res.headers.get("content-type") || "";
+    if (contentType.includes("text/event-stream")) {
+        await readFileChatStream(res, handlers);
+    }
+    else {
+        const responsePayload = contentType.includes("application/json") ? await res.json() : await res.text();
+        handlers.onUpdate?.(responsePayload);
+        handlers.onDone?.();
+    }
+}
+async function readFileChatStream(res, handlers) {
+    if (!res.body)
+        throw new Error("Streaming not supported in this browser");
+    const reader = res.body.getReader();
+    let buffer = "";
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const chunks = buffer.split("\n\n");
+        buffer = chunks.pop() || "";
+        for (const chunk of chunks) {
+            if (!chunk.trim())
+                continue;
+            let event = "message";
+            const dataLines = [];
+            chunk.split("\n").forEach((line) => {
+                if (line.startsWith("event:")) {
+                    event = line.slice(6).trim();
+                }
+                else if (line.startsWith("data:")) {
+                    dataLines.push(line.slice(5).trimStart());
+                }
+            });
+            if (!dataLines.length)
+                continue;
+            const rawData = dataLines.join("\n");
+            handleStreamEvent(event, rawData, handlers);
+        }
+    }
+}
+function handleStreamEvent(event, rawData, handlers) {
+    const parsed = parseMaybeJson(rawData);
+    switch (event) {
+        case "status": {
+            const status = typeof parsed === "string" ? parsed : parsed.status || "";
+            handlers.onStatus?.(status);
+            break;
+        }
+        case "token": {
+            const token = typeof parsed === "string"
+                ? parsed
+                : parsed.token || parsed.text || rawData || "";
+            handlers.onToken?.(token);
+            break;
+        }
+        case "update": {
+            handlers.onUpdate?.(parsed);
+            break;
+        }
+        case "event":
+        case "app-server": {
+            handlers.onEvent?.(parsed);
+            break;
+        }
+        case "error": {
+            const msg = typeof parsed === "object" && parsed !== null
+                ? (parsed.detail || parsed.error || rawData || "File chat failed")
+                : rawData || "File chat failed";
+            handlers.onError?.(msg);
+            break;
+        }
+        case "interrupted": {
+            const msg = typeof parsed === "object" && parsed !== null
+                ? (parsed.detail || rawData || "File chat interrupted")
+                : rawData || "File chat interrupted";
+            handlers.onInterrupted?.(msg);
+            break;
+        }
+        case "done":
+        case "finish": {
+            handlers.onDone?.();
+            break;
+        }
+        default:
+            // treat unknown as event for visibility
+            handlers.onEvent?.(parsed);
+            break;
+    }
+}
+export async function fetchPendingDraft(target) {
+    try {
+        const res = (await api(`/api/file-chat/pending?target=${encodeURIComponent(target)}`));
+        if (!res || typeof res !== "object")
+            return null;
+        return {
+            target: res.target || target,
+            content: res.content || "",
+            patch: res.patch || "",
+            agent_message: res.agent_message || undefined,
+            created_at: res.created_at || undefined,
+            base_hash: res.base_hash || undefined,
+            current_hash: res.current_hash || undefined,
+            is_stale: Boolean(res.is_stale),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function applyDraft(target, options = {}) {
+    const res = (await api("/api/file-chat/apply", {
+        method: "POST",
+        body: { target, force: Boolean(options.force) },
+    }));
+    return {
+        content: res.content || "",
+        agent_message: res.agent_message || undefined,
+    };
+}
+export async function discardDraft(target) {
+    const res = (await api("/api/file-chat/discard", {
+        method: "POST",
+        body: { target },
+    }));
+    return {
+        content: res.content || "",
+    };
+}
+export async function interruptFileChat(target) {
+    await api("/api/file-chat/interrupt", { method: "POST", body: { target } });
+}

codex_autorunner/static/health.js

@@ -0,0 +1,155 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+import { publish } from "./bus.js";
+import { setAutoRefreshEnabled } from "./autoRefresh.js";
+import { getAuthToken, resolvePath } from "./utils.js";
+let initialized = false;
+let healthState = "unknown";
+let lastDetail = null;
+let retryTimer = null;
+function bannerEls() {
+    return {
+        banner: document.getElementById("repo-health-banner"),
+        title: document.getElementById("repo-health-title"),
+        detail: document.getElementById("repo-health-detail"),
+        retry: document.getElementById("repo-health-retry"),
+    };
+}
+function renderBanner(status, detail) {
+    const { banner, title, detail: detailEl, retry } = bannerEls();
+    if (!banner || !title)
+        return;
+    if (status === "ok") {
+        banner.classList.add("hidden");
+        banner.classList.remove("error", "warn");
+        if (retry)
+            retry.disabled = false;
+        return;
+    }
+    const isOffline = status === "offline";
+    banner.classList.remove("hidden");
+    banner.classList.toggle("error", isOffline);
+    banner.classList.toggle("warn", !isOffline);
+    title.textContent = isOffline
+        ? "Repo server offline or unreachable"
+        : "Repo server uninitialized";
+    if (detailEl) {
+        detailEl.textContent =
+            detail ||
+                (isOffline
+                    ? "Check that the repo server is running."
+                    : "Create .codex-autorunner/tickets/ to initialize this repo.");
+    }
+    if (retry)
+        retry.disabled = false;
+}
+function setHealth(status, detail) {
+    const changed = status !== healthState || detail !== lastDetail;
+    healthState = status;
+    lastDetail = detail || null;
+    renderBanner(status, detail);
+    setAutoRefreshEnabled(status !== "offline");
+    if (changed) {
+        publish("repo:health", { status, detail });
+    }
+}
+async function tryFetch(path) {
+    const target = resolvePath(path);
+    const headers = {};
+    const token = getAuthToken();
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const res = await fetch(target, { headers });
+    const text = await res.text();
+    let payload = null;
+    try {
+        payload = JSON.parse(text);
+    }
+    catch (_err) {
+        payload = null;
+    }
+    return { ok: res.ok, status: res.status, payload, text };
+}
+function deriveHealthFromPayload(payload) {
+    if (!payload || typeof payload !== "object") {
+        return { status: "offline", detail: "Empty health response" };
+    }
+    const p = payload;
+    const payloadStatus = String(p.status || "ok").toLowerCase();
+    if (payloadStatus !== "ok" && payloadStatus !== "degraded") {
+        return { status: "offline", detail: String(p.detail || payloadStatus) };
+    }
+    // Ticket-first: the only initialization requirement is `.codex-autorunner/tickets/`.
+    const tickets = p.tickets;
+    const ticketsStatus = String(tickets?.status || "").toLowerCase();
+    if (ticketsStatus && ticketsStatus !== "ok") {
+        return {
+            status: "degraded",
+            detail: "Tickets directory missing; create .codex-autorunner/tickets/.",
+        };
+    }
+    // Flows DB is lazily created. Only treat truly unavailable storage as degraded.
+    const flows = p.flows;
+    const flowsStatus = String(flows?.status || "").toLowerCase();
+    if (flowsStatus && flowsStatus !== "ok" && flowsStatus !== "missing") {
+        return { status: "degraded", detail: `Flows unavailable: ${flowsStatus}` };
+    }
+    return { status: "ok" };
+}
+async function probeHealth() {
+    const paths = ["/api/repo/health", "/health"];
+    let lastError = null;
+    for (const path of paths) {
+        try {
+            const res = await tryFetch(path);
+            if (res.ok) {
+                return deriveHealthFromPayload(res.payload);
+            }
+            lastError = `${path} → ${res.status}`;
+            if (res.status === 404) {
+                continue;
+            }
+            break;
+        }
+        catch (err) {
+            lastError = err.message || String(err);
+        }
+    }
+    return { status: "offline", detail: lastError };
+}
+function scheduleNext(delayMs) {
+    if (retryTimer) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+    }
+    retryTimer = setTimeout(() => {
+        void refreshRepoHealth();
+    }, delayMs);
+}
+export async function refreshRepoHealth() {
+    const result = await probeHealth();
+    setHealth(result.status, result.detail);
+    const nextDelay = result.status === "ok" ? 20000 : Math.min(60000, result.status === "degraded" ? 20000 : 10000);
+    scheduleNext(nextDelay);
+}
+export async function initHealthGate() {
+    if (initialized)
+        return;
+    initialized = true;
+    const { retry } = bannerEls();
+    if (retry) {
+        retry.addEventListener("click", () => {
+            if (retryTimer) {
+                clearTimeout(retryTimer);
+                retryTimer = null;
+            }
+            void refreshRepoHealth();
+        });
+    }
+    await refreshRepoHealth();
+}
+export function isRepoHealthy() {
+    return healthState === "ok" || healthState === "degraded";
+}
+export function currentHealthDetail() {
+    return lastDetail;
+}