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

codex_autorunner/static/chatUploads.js

@@ -0,0 +1,137 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+import { api, flash, resolvePath } from "./utils.js";
+const IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "heic", "heif"];
+const IMAGE_MIME_EXT = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/heic": "heic",
+    "image/heif": "heif",
+};
+function escapeMarkdownLinkText(text) {
+    return text.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+function toAbsoluteUrl(path) {
+    const resolved = resolvePath(path);
+    try {
+        return new URL(resolved, window.location.origin).toString();
+    }
+    catch {
+        return resolved;
+    }
+}
+function isImageFile(file) {
+    if (file.type && file.type.startsWith("image/"))
+        return true;
+    const lower = (file.name || "").toLowerCase();
+    return IMAGE_EXTENSIONS.some((ext) => lower.endsWith(`.${ext}`));
+}
+function normalizeFilename(file, index, used) {
+    let name = (file.name || "").trim();
+    if (!name) {
+        const ext = IMAGE_MIME_EXT[file.type] || "png";
+        name = `pasted-image-${Date.now()}-${index + 1}.${ext}`;
+    }
+    let candidate = name;
+    let suffix = 1;
+    while (used.has(candidate)) {
+        const dot = name.lastIndexOf(".");
+        if (dot > 0) {
+            const base = name.slice(0, dot);
+            const ext = name.slice(dot + 1);
+            candidate = `${base}-${suffix}.${ext}`;
+        }
+        else {
+            candidate = `${name}-${suffix}`;
+        }
+        suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function extractImageFilesFromClipboard(event) {
+    const items = event.clipboardData?.items;
+    if (!items || !items.length)
+        return [];
+    const files = [];
+    for (const item of Array.from(items)) {
+        if (item.kind !== "file")
+            continue;
+        if (item.type && !item.type.startsWith("image/"))
+            continue;
+        const file = item.getAsFile();
+        if (file && isImageFile(file))
+            files.push(file);
+    }
+    return files;
+}
+async function uploadImages(basePath, box, files, pathPrefix) {
+    const used = new Set();
+    const form = new FormData();
+    const entries = [];
+    const prefix = basePath.replace(/\/$/, "");
+    const normalizedPathPrefix = pathPrefix ? pathPrefix.replace(/\/$/, "") : "";
+    files.forEach((file, index) => {
+        const name = normalizeFilename(file, index, used);
+        form.append(name, file, name);
+        const path = normalizedPathPrefix ? `${normalizedPathPrefix}/${box}/${name}` : undefined;
+        const relativeUrl = `${prefix}/${box}/${encodeURIComponent(name)}`;
+        entries.push({ name, url: toAbsoluteUrl(relativeUrl), path });
+    });
+    await api(`${prefix}/${box}`, { method: "POST", body: form });
+    return entries;
+}
+function insertTextAtCursor(textarea, text, options = {}) {
+    const value = textarea.value || "";
+    const start = Number.isInteger(textarea.selectionStart) ? textarea.selectionStart : value.length;
+    const end = Number.isInteger(textarea.selectionEnd) ? textarea.selectionEnd : value.length;
+    const prefix = value.slice(0, start);
+    const suffix = value.slice(end);
+    const separator = options.separator || "newline";
+    let insert = text;
+    if (separator === "newline") {
+        insert = `${prefix && !prefix.endsWith("\n") ? "\n" : ""}${insert}`;
+    }
+    else if (separator === "space") {
+        insert = `${prefix && !/\s$/.test(prefix) ? " " : ""}${insert}`;
+    }
+    textarea.value = `${prefix}${insert}${suffix}`;
+    const cursor = prefix.length + insert.length;
+    textarea.setSelectionRange(cursor, cursor);
+    textarea.dispatchEvent(new Event("input", { bubbles: true }));
+}
+export function initChatPasteUpload(options) {
+    const { textarea } = options;
+    if (!textarea)
+        return;
+    textarea.addEventListener("paste", async (event) => {
+        const files = extractImageFilesFromClipboard(event);
+        if (!files.length)
+            return;
+        event.preventDefault();
+        const box = options.box || "inbox";
+        const insertStyle = options.insertStyle || "markdown";
+        try {
+            const entries = await uploadImages(options.basePath, box, files, options.pathPrefix);
+            const lines = entries.flatMap((entry) => {
+                const label = escapeMarkdownLinkText(entry.name);
+                const linkLine = `[${label}](${entry.url})`;
+                if (insertStyle === "markdown")
+                    return [linkLine];
+                const pathLine = entry.path || entry.name;
+                if (insertStyle === "path")
+                    return [pathLine];
+                return entry.path ? [linkLine, entry.path] : [linkLine];
+            });
+            if (lines.length) {
+                insertTextAtCursor(textarea, lines.join("\n"), { separator: "newline" });
+            }
+            options.onUploaded?.(entries.map((entry) => ({ name: entry.name, url: entry.url })));
+        }
+        catch (err) {
+            const message = err.message || "Image upload failed";
+            flash(message, "error");
+        }
+    });
+}

codex_autorunner/static/constants.js

@@ -37,7 +37,7 @@ export const CONSTANTS = {
     },
     PROMPTS: {
         VOICE_TRANSCRIPT_DISCLAIMER: "Note: transcribed from user voice. If confusing or possibly inaccurate and you cannot infer the intention please clarify before proceeding.",
-        CAR_CONTEXT_HINT: "Context: read .codex-autorunner/ABOUT_CAR.md for repo-specific rules.",
+        CAR_CONTEXT_HINT: "Context: This repo is managed by Codex Autorunner (CAR). Read `.codex-autorunner/ABOUT_CAR.md` (tickets, workspace docs, helper commands) before making workflow assumptions.",
     },
     KEYWORDS: {
         CAR_CONTEXT: [

codex_autorunner/static/docChatCore.js

@@ -2,6 +2,7 @@
 import { parseAppServerEvent } from "./agentEvents.js";
 import { summarizeEvents, renderCompactSummary, COMPACT_MAX_ACTIONS, COMPACT_MAX_TEXT_LENGTH } from "./eventSummarizer.js";
 import { saveChatHistory, loadChatHistory } from "./docChatStorage.js";
+import { renderMarkdown } from "./messages.js";
 function getElements(prefix) {
     return {
         input: document.getElementById(`${prefix}-input`),
@@ -33,13 +34,14 @@ function addEvent(state, entry, limits) {
         });
     }
 }
-function buildMessage(role, content, isFinal) {
+function buildMessage(role, content, isFinal, meta) {
     return {
         id: `${role}-${Date.now()}`,
         role,
         content,
         time: new Date().toISOString(),
         isFinal,
+        meta,
     };
 }
 export function createDocChat(config) {
@@ -52,11 +54,31 @@ export function createDocChat(config) {
         controller: null,
         draft: null,
         events: [],
+        totalEvents: 0,
         messages: [],
         eventItemIndex: {},
         eventsExpanded: false,
+        contextUsagePercent: null,
     };
     const elements = getElements(config.idPrefix);
+    function decorateFileLinks(root) {
+        const links = Array.from(root.querySelectorAll("a"));
+        for (const link of links) {
+            const href = link.getAttribute("href") || "";
+            if (!href)
+                continue;
+            // Only decorate PMA file links.
+            if (!href.includes("/hub/pma/files/"))
+                continue;
+            link.classList.add("pma-file-link");
+            link.setAttribute("download", "");
+            // Ensure downloads happen in-place (no new tab).
+            link.removeAttribute("target");
+            link.setAttribute("rel", "noopener");
+            if (!link.title)
+                link.title = "Download file";
+        }
+    }
     function saveHistory() {
         if (!config.storage || !state.target)
             return;
@@ -79,17 +101,21 @@ export function createDocChat(config) {
         state.messages.push(buildMessage("user", content, true));
         saveHistory();
     }
-    function addAssistantMessage(content, isFinal = true) {
+    function addAssistantMessage(content, isFinal = true, meta) {
         if (!content)
             return;
         const last = state.messages[state.messages.length - 1];
-        if (last && last.role === "assistant" && last.content === content)
+        if (last && last.role === "assistant" && last.content === content) {
+            if (meta)
+                last.meta = meta;
             return;
-        state.messages.push(buildMessage("assistant", content, isFinal));
+        }
+        state.messages.push(buildMessage("assistant", content, isFinal, meta));
         saveHistory();
     }
     function clearEvents() {
         state.events = [];
+        state.totalEvents = 0;
         state.eventItemIndex = {};
     }
     function applyAppEvent(payload) {
@@ -111,6 +137,7 @@ export function createDocChat(config) {
             return;
         }
         addEvent(state, { ...event }, config.limits);
+        state.totalEvents += 1;
         if (itemId)
             state.eventItemIndex[itemId] = state.events.length - 1;
     }
@@ -118,18 +145,33 @@ export function createDocChat(config) {
         const { eventsMain, eventsList, eventsCount, eventsToggle } = elements;
         if (!eventsMain || !eventsList || !eventsCount)
             return;
+        // If inlineEvents is enabled, we don't render to the separate events container
+        if (config.inlineEvents) {
+            // Still need to calculate showEvents to hide the container properly
+            // but return early before modifying innerHTML
+            if (eventsMain)
+                eventsMain.classList.add("hidden");
+            return;
+        }
         const hasEvents = state.events.length > 0;
         const isRunning = state.status === "running";
-        const showEvents = hasEvents || isRunning;
+        const showEvents = config.eventsOnlyWhileRunning ? isRunning : (hasEvents || isRunning);
         const compactMode = !!config.compactMode;
         const expanded = !!state.eventsExpanded;
         if (config.styling.eventsHiddenClass) {
             eventsMain.classList.toggle(config.styling.eventsHiddenClass, !showEvents);
         }
         else {
-            eventsMain.classList.toggle("hidden", !showEvents);
+            // In inline mode, never show the main event container since we render inline
+            if (config.inlineEvents) {
+                eventsMain.classList.add("hidden");
+            }
+            else {
+                eventsMain.classList.toggle("hidden", !showEvents);
+            }
         }
-        eventsCount.textContent = String(state.events.length);
+        const eventCount = state.totalEvents || state.events.length;
+        eventsCount.textContent = String(eventCount);
         if (!showEvents) {
             eventsList.innerHTML = "";
             return;
@@ -202,6 +244,7 @@ export function createDocChat(config) {
         const summary = summarizeEvents(state.events, {
             maxActions: config.compactOptions?.maxActions ?? COMPACT_MAX_ACTIONS,
             maxTextLength: config.compactOptions?.maxTextLength ?? COMPACT_MAX_TEXT_LENGTH,
+            contextUsagePercent: state.contextUsagePercent ?? undefined,
         });
         const text = state.events.length ? renderCompactSummary(summary) : "";
         const wrapper = document.createElement("pre");
@@ -240,17 +283,45 @@ export function createDocChat(config) {
             }
             wrapper.appendChild(roleLabel);
             const content = document.createElement("div");
-            content.className = config.styling.messageContentClass;
-            content.textContent = msg.content;
+            content.className = `${config.styling.messageContentClass} messages-markdown`;
+            // Use markdown rendering for assistant messages.
+            // For user messages, keep plain text unless the message includes PMA file links
+            // (used for "uploaded file" pills).
+            const shouldRenderMarkdown = msg.role === "assistant" ||
+                msg.content.includes("/hub/pma/files/") ||
+                msg.content.includes("/api/filebox/") ||
+                msg.content.includes("/hub/filebox/");
+            if (shouldRenderMarkdown) {
+                content.innerHTML = renderMarkdown(msg.content);
+                decorateFileLinks(content);
+            }
+            else {
+                content.textContent = msg.content;
+            }
             wrapper.appendChild(content);
             const meta = document.createElement("div");
             meta.className = config.styling.messageMetaClass;
             const time = msg.time ? new Date(msg.time) : new Date();
-            meta.textContent = time.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+            let metaText = time.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+            if (msg.meta) {
+                const parts = [];
+                if (msg.meta.steps)
+                    parts.push(`${msg.meta.steps} steps`);
+                if (msg.meta.duration)
+                    parts.push(`${msg.meta.duration.toFixed(1)}s`);
+                if (state.contextUsagePercent !== null && msg.isFinal) {
+                    parts.push(`ctx left ${state.contextUsagePercent}%`);
+                }
+                if (parts.length)
+                    metaText += ` · ${parts.join(" · ")}`;
+            }
+            meta.textContent = metaText;
             wrapper.appendChild(meta);
             messagesEl.appendChild(wrapper);
         });
-        if (hasStream) {
+        // While running, show an inline "Thinking" bubble at the bottom where the
+        // final assistant message will appear (even if we don't have streamed text yet).
+        if (hasStream || state.status === "running") {
             const streaming = document.createElement("div");
             streaming.className = [
                 config.styling.messagesClass,
@@ -265,12 +336,100 @@ export function createDocChat(config) {
             roleLabel.textContent = "Thinking";
             streaming.appendChild(roleLabel);
             const content = document.createElement("div");
-            content.className = config.styling.messageContentClass;
-            content.textContent = state.streamText;
+            content.className = `${config.styling.messageContentClass} messages-markdown`;
+            // If we have streamed text, show it. Otherwise show a compact "working" summary
+            // based on the most recent event/tool-call.
+            if (state.streamText) {
+                content.innerHTML = renderMarkdown(state.streamText);
+                decorateFileLinks(content);
+            }
+            else {
+                const stepCount = state.totalEvents || state.events.length;
+                const statusText = (state.statusText || "").trim();
+                const isNoiseEvent = (evt) => {
+                    const title = (evt.title || "").toLowerCase();
+                    const method = (evt.method || "").toLowerCase();
+                    // Hide token/partial deltas; they are too granular for the UI.
+                    if (title === "delta")
+                        return true;
+                    if (method.includes("delta"))
+                        return true;
+                    return false;
+                };
+                const meaningfulEvents = state.events.filter((evt) => !isNoiseEvent(evt));
+                const lastMeaningful = meaningfulEvents[meaningfulEvents.length - 1];
+                const headline = lastMeaningful
+                    ? (lastMeaningful.title || lastMeaningful.summary || statusText || "Working...")
+                    : (statusText || "Thinking...");
+                // Build DOM so we can attach a "Show details" toggle inside the Thinking bubble.
+                content.innerHTML = "";
+                const header = document.createElement("div");
+                header.className = "chat-thinking-inline";
+                const spinner = document.createElement("span");
+                spinner.className = "chat-thinking-spinner";
+                header.appendChild(spinner);
+                const headlineSpan = document.createElement("span");
+                headlineSpan.textContent = String(headline);
+                header.appendChild(headlineSpan);
+                if (stepCount > 0) {
+                    const steps = document.createElement("span");
+                    steps.className = "chat-thinking-steps";
+                    steps.textContent = `(${stepCount} steps)`;
+                    header.appendChild(steps);
+                    if (state.contextUsagePercent !== null) {
+                        const context = document.createElement("span");
+                        context.className = "chat-thinking-steps";
+                        context.textContent = ` · ctx left ${state.contextUsagePercent}%`;
+                        header.appendChild(context);
+                    }
+                    // Only show the toggle if we have more than a couple steps.
+                    if (meaningfulEvents.length > 2) {
+                        const toggle = document.createElement("button");
+                        toggle.type = "button";
+                        toggle.className = "ghost sm chat-thinking-details-btn";
+                        toggle.textContent = state.eventsExpanded ? "Hide details" : "Show details";
+                        toggle.addEventListener("click", (e) => {
+                            e.preventDefault();
+                            state.eventsExpanded = !state.eventsExpanded;
+                            renderMessages();
+                        });
+                        header.appendChild(toggle);
+                    }
+                }
+                content.appendChild(header);
+                const maxRecent = state.eventsExpanded
+                    ? Math.min(meaningfulEvents.length, config.limits.eventVisible || 20)
+                    : 3;
+                const recentEvents = meaningfulEvents.slice(-maxRecent);
+                if (recentEvents.length) {
+                    const list = document.createElement("ul");
+                    list.className = "chat-thinking-steps-list";
+                    for (const evt of recentEvents) {
+                        const li = document.createElement("li");
+                        const title = document.createElement("span");
+                        title.className = "chat-thinking-step-title";
+                        title.textContent = (evt.title || evt.kind || evt.method || "step").trim();
+                        li.appendChild(title);
+                        const summaryText = (evt.summary || "").trim();
+                        if (summaryText) {
+                            const summary = document.createElement("span");
+                            summary.className = "chat-thinking-step-summary";
+                            summary.textContent = ` — ${summaryText}`;
+                            li.appendChild(summary);
+                        }
+                        list.appendChild(li);
+                    }
+                    content.appendChild(list);
+                }
+            }
             streaming.appendChild(content);
             messagesEl.appendChild(streaming);
         }
         messagesEl.scrollTop = messagesEl.scrollHeight;
+        // Also scroll the parent container if it exists
+        if (elements.streamEl) {
+            elements.streamEl.scrollTop = elements.streamEl.scrollHeight;
+        }
     }
     function render() {
         const { statusEl, errorEl, cancelBtn, newThreadBtn, streamEl, } = elements;
@@ -292,12 +451,25 @@ export function createDocChat(config) {
             newThreadBtn.classList.toggle("hidden", !hasHistory || state.status === "running");
         }
         if (streamEl) {
+            // In inline mode, we always want to show the stream element if there's any activity
+            // or history, because the "Thinking" state is rendered as a message in the history list
+            // (technically in the messagesEl container), but we need the parent container visible.
             const hasContent = state.events.length > 0 ||
                 state.messages.length > 0 ||
                 !!state.streamText ||
                 state.status === "running";
             streamEl.classList.toggle("hidden", !hasContent);
+            // Auto-scroll to bottom when new content appears
+            streamEl.scrollTop = streamEl.scrollHeight;
         }
+        // Important: renderMessages handles the "Thinking" bubble creation
+        // when state.status === 'running' or we have a streamText.
+        // However, if we only have events but no streamText yet, we need to ensure
+        // renderMessages is called with a "virtual" stream state to trigger the bubble.
+        // We do this by checking if we are running.
+        // We need to pass a flag or rely on state.status in renderMessages?
+        // Actually renderMessages uses state.streamText. 
+        // Let's force a "pending" indicator in renderMessages if running but no text.
         renderEvents();
         renderMessages();
     }

codex_autorunner/static/fileChat.js

@@ -1,16 +1,8 @@
 // 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;
-    }
-}
+import { extractContextRemainingPercent, readEventStream, parseMaybeJson } from "./streamUtils.js";
 export async function sendFileChat(target, message, controller, handlers = {}, options = {}) {
-    const endpoint = resolvePath("/api/file-chat");
+    const endpoint = resolvePath(options.basePath || "/api/file-chat");
     const headers = {
         "Content-Type": "application/json",
     };
@@ -22,6 +14,8 @@ export async function sendFileChat(target, message, controller, handlers = {}, o
         message,
         stream: true,
     };
+    if (options.clientTurnId)
+        payload.client_turn_id = options.clientTurnId;
     if (options.agent)
         payload.agent = options.agent;
     if (options.model)
@@ -58,36 +52,7 @@ export async function sendFileChat(target, message, controller, handlers = {}, o
     }
 }
 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);
-        }
-    }
+    await readEventStream(res, (event, raw) => handleStreamEvent(event, raw, handlers));
 }
 function handleStreamEvent(event, rawData, handlers) {
     const parsed = parseMaybeJson(rawData);
@@ -104,6 +69,16 @@ function handleStreamEvent(event, rawData, handlers) {
             handlers.onToken?.(token);
             break;
         }
+        case "token_usage": {
+            if (typeof parsed === "object" && parsed !== null) {
+                const usage = parsed;
+                const percent = extractContextRemainingPercent(usage);
+                if (percent !== null) {
+                    handlers.onTokenUsage?.(percent, usage);
+                }
+            }
+            break;
+        }
         case "update": {
             handlers.onUpdate?.(parsed);
             break;
@@ -180,3 +155,56 @@ export async function discardDraft(target) {
 export async function interruptFileChat(target) {
     await api("/api/file-chat/interrupt", { method: "POST", body: { target } });
 }
+export function newClientTurnId(prefix = "filechat") {
+    try {
+        if (typeof crypto !== "undefined" && "randomUUID" in crypto && typeof crypto.randomUUID === "function") {
+            return crypto.randomUUID();
+        }
+    }
+    catch {
+        // ignore
+    }
+    return `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+export async function fetchActiveFileChat(clientTurnId, basePath = "/api/file-chat/active") {
+    const suffix = clientTurnId ? `?client_turn_id=${encodeURIComponent(clientTurnId)}` : "";
+    const path = `${basePath}${suffix}`;
+    try {
+        const res = (await api(path));
+        return res || {};
+    }
+    catch {
+        return {};
+    }
+}
+export function streamTurnEvents(meta, handlers = {}) {
+    if (!meta.threadId || !meta.turnId)
+        return null;
+    const ctrl = new AbortController();
+    const token = getAuthToken();
+    const headers = {};
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    const url = resolvePath(`${meta.basePath || "/api/file-chat/turns"}/${encodeURIComponent(meta.turnId)}/events?thread_id=${encodeURIComponent(meta.threadId)}&agent=${encodeURIComponent(meta.agent || "codex")}`);
+    void (async () => {
+        try {
+            const res = await fetch(url, { method: "GET", headers, signal: ctrl.signal });
+            if (!res.ok) {
+                handlers.onError?.("Failed to stream events");
+                return;
+            }
+            const contentType = res.headers.get("content-type") || "";
+            if (!contentType.includes("text/event-stream"))
+                return;
+            await readEventStream(res, (event, raw) => {
+                if (event === "app-server" || event === "event") {
+                    handlers.onEvent?.(parseMaybeJson(raw));
+                }
+            });
+        }
+        catch (err) {
+            handlers.onError?.(err.message || "Event stream failed");
+        }
+    })();
+    return ctrl;
+}