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

codex_autorunner/static/templateReposSettings.js

@@ -0,0 +1,225 @@
+// GENERATED FILE - do not edit directly. Source: static_src/
+import { api, confirmModal, flash } from "./utils.js";
+import { checkTemplatesEnabled } from "./ticketTemplates.js";
+function els() {
+    return {
+        list: document.getElementById("template-repos-list"),
+        addBtn: document.getElementById("template-repos-add"),
+        form: document.getElementById("template-repo-form"),
+        idInput: document.getElementById("repo-id"),
+        urlInput: document.getElementById("repo-url"),
+        refInput: document.getElementById("repo-ref"),
+        trustedInput: document.getElementById("repo-trusted"),
+        saveBtn: document.getElementById("repo-save"),
+        cancelBtn: document.getElementById("repo-cancel"),
+    };
+}
+const state = {
+    mode: "create",
+    editId: null,
+    enabled: false,
+    repos: [],
+    busy: false,
+};
+function setBusy(busy) {
+    state.busy = busy;
+    const { saveBtn, addBtn } = els();
+    if (saveBtn)
+        saveBtn.disabled = busy;
+    if (addBtn)
+        addBtn.disabled = busy;
+}
+function showForm(show) {
+    const { form } = els();
+    if (!form)
+        return;
+    if (show)
+        form.classList.remove("hidden");
+    else
+        form.classList.add("hidden");
+}
+function resetForm() {
+    const { idInput, urlInput, refInput, trustedInput } = els();
+    if (idInput)
+        idInput.value = "";
+    if (urlInput)
+        urlInput.value = "";
+    if (refInput)
+        refInput.value = "main";
+    if (trustedInput)
+        trustedInput.checked = false;
+    state.mode = "create";
+    state.editId = null;
+    if (idInput)
+        idInput.disabled = false;
+}
+function openCreateForm() {
+    resetForm();
+    showForm(true);
+    const { idInput } = els();
+    idInput?.focus();
+}
+function openEditForm(repo) {
+    const { idInput, urlInput, refInput, trustedInput } = els();
+    state.mode = "edit";
+    state.editId = repo.id;
+    if (idInput) {
+        idInput.value = repo.id;
+        idInput.disabled = true;
+    }
+    if (urlInput)
+        urlInput.value = repo.url;
+    if (refInput)
+        refInput.value = repo.default_ref || "main";
+    if (trustedInput)
+        trustedInput.checked = Boolean(repo.trusted);
+    showForm(true);
+    urlInput?.focus();
+}
+function normalizeRequired(value, label) {
+    const v = (value || "").trim();
+    if (!v) {
+        flash(`${label} is required`, "error");
+        return null;
+    }
+    return v;
+}
+function renderRepos() {
+    const { list } = els();
+    if (!list)
+        return;
+    list.innerHTML = "";
+    if (!state.enabled) {
+        const hint = document.createElement("div");
+        hint.className = "muted small";
+        hint.textContent = "Templates are disabled (templates.enabled=false).";
+        list.appendChild(hint);
+    }
+    if (!state.repos.length) {
+        const empty = document.createElement("div");
+        empty.className = "muted small";
+        empty.textContent = "No template repos configured.";
+        list.appendChild(empty);
+        return;
+    }
+    for (const repo of state.repos) {
+        const row = document.createElement("div");
+        row.className = "template-repo-item";
+        row.innerHTML = `
+      <div class="template-repo-meta">
+        <span class="template-repo-id">${repo.id}</span>
+        <span class="template-repo-url">${repo.url}</span>
+        <span class="muted small">ref: ${repo.default_ref}${repo.trusted ? " · trusted" : ""}</span>
+      </div>
+      <div class="template-repo-actions">
+        <button class="ghost sm" data-action="edit" data-id="${repo.id}">Edit</button>
+        <button class="danger sm" data-action="delete" data-id="${repo.id}">Delete</button>
+      </div>
+    `;
+        list.appendChild(row);
+    }
+    list.querySelectorAll("button[data-action]").forEach((btn) => {
+        btn.addEventListener("click", async () => {
+            const action = btn.dataset.action;
+            const id = btn.dataset.id;
+            if (!action || !id)
+                return;
+            const repo = state.repos.find((r) => r.id === id);
+            if (!repo)
+                return;
+            if (action === "edit") {
+                openEditForm(repo);
+                return;
+            }
+            if (action === "delete") {
+                await deleteRepo(id);
+            }
+        });
+    });
+}
+export async function loadTemplateRepos() {
+    const { list } = els();
+    if (!list)
+        return;
+    try {
+        const data = (await api("/api/templates/repos"));
+        state.enabled = Boolean(data.enabled);
+        state.repos = Array.isArray(data.repos) ? data.repos : [];
+        renderRepos();
+    }
+    catch (err) {
+        state.enabled = false;
+        state.repos = [];
+        renderRepos();
+        flash(err.message || "Failed to load template repos", "error");
+    }
+}
+async function saveRepo() {
+    const { idInput, urlInput, refInput, trustedInput } = els();
+    if (!idInput || !urlInput || !refInput || !trustedInput)
+        return;
+    const id = normalizeRequired(idInput.value, "ID");
+    const url = normalizeRequired(urlInput.value, "Git URL");
+    const ref = normalizeRequired(refInput.value, "Default ref");
+    if (!id || !url || !ref)
+        return;
+    setBusy(true);
+    try {
+        if (state.mode === "create") {
+            await api("/api/templates/repos", {
+                method: "POST",
+                body: { id, url, trusted: Boolean(trustedInput.checked), default_ref: ref },
+            });
+            flash("Template repo added", "success");
+        }
+        else if (state.mode === "edit" && state.editId) {
+            await api(`/api/templates/repos/${encodeURIComponent(state.editId)}`, {
+                method: "PUT",
+                body: { url, trusted: Boolean(trustedInput.checked), default_ref: ref },
+            });
+            flash("Template repo updated", "success");
+        }
+        await loadTemplateRepos();
+        await checkTemplatesEnabled();
+        showForm(false);
+        resetForm();
+    }
+    catch (err) {
+        flash(err.message || "Failed to save template repo", "error");
+    }
+    finally {
+        setBusy(false);
+    }
+}
+async function deleteRepo(id) {
+    const confirmed = await confirmModal(`Delete template repo "${id}"?`, {
+        confirmText: "Delete",
+        danger: true,
+    });
+    if (!confirmed)
+        return;
+    setBusy(true);
+    try {
+        await api(`/api/templates/repos/${encodeURIComponent(id)}`, { method: "DELETE" });
+        flash("Template repo deleted", "success");
+        await loadTemplateRepos();
+        await checkTemplatesEnabled();
+    }
+    catch (err) {
+        flash(err.message || "Failed to delete template repo", "error");
+    }
+    finally {
+        setBusy(false);
+    }
+}
+export function initTemplateReposSettings() {
+    const { list, addBtn, saveBtn, cancelBtn } = els();
+    if (!list || !addBtn || !saveBtn || !cancelBtn)
+        return;
+    addBtn.addEventListener("click", () => openCreateForm());
+    saveBtn.addEventListener("click", () => void saveRepo());
+    cancelBtn.addEventListener("click", () => {
+        showForm(false);
+        resetForm();
+    });
+}

codex_autorunner/static/ticketChatActions.js

@@ -2,16 +2,20 @@
 /**
  * Ticket Chat Actions - handles sending messages, applying/discarding patches
  */
-import { api, flash, splitMarkdownFrontmatter } from "./utils.js";
+import { api, confirmModal, flash, splitMarkdownFrontmatter } from "./utils.js";
 import { performTicketChatRequest } from "./ticketChatStream.js";
-import { renderTicketMessages } from "./ticketChatEvents.js";
+import { renderTicketMessages, renderTicketEvents } from "./ticketChatEvents.js";
 import { publish } from "./bus.js";
 import { createDocChat } from "./docChatCore.js";
 import { saveTicketChatHistory } from "./ticketChatStorage.js";
 import { renderDiff } from "./diffRenderer.js";
+import { newClientTurnId, streamTurnEvents } from "./fileChat.js";
+import { loadPendingTurn, savePendingTurn, clearPendingTurn } from "./turnResume.js";
+import { resumeFileChatTurn } from "./turnEvents.js";
 // Limits for events display
 export const TICKET_CHAT_EVENT_LIMIT = 8;
 export const TICKET_CHAT_EVENT_MAX = 50;
+const pendingKeyForTicket = (index) => index != null ? `car.ticketChat.pending.${index}` : "car.ticketChat.pending";
 export const ticketChat = createDocChat({
     idPrefix: "ticket-chat",
     storage: { keyPrefix: "car-ticket-chat-", maxMessages: 50, version: 1 },
@@ -39,7 +43,9 @@ export const ticketChat = createDocChat({
 export const ticketChatState = Object.assign(ticketChat.state, {
     ticketIndex: null,
     draft: null,
+    contextUsagePercent: null,
 });
+let currentTurnEventsController = null;
 export function getTicketChatElements() {
     const base = ticketChat.elements;
     return {
@@ -75,13 +81,14 @@ export function resetTicketChatState() {
     ticketChatState.streamText = "";
     ticketChatState.statusText = "";
     ticketChatState.controller = null;
+    ticketChatState.contextUsagePercent = null;
     // Note: events are cleared at the start of each new request, not here
     // Messages persist across requests within the same ticket
 }
 export async function startNewTicketChatThread() {
     if (ticketChatState.ticketIndex == null)
         return;
-    const confirmed = window.confirm("Start a new conversation thread for this ticket?");
+    const confirmed = await confirmModal("Start a new conversation thread for this ticket?");
     if (!confirmed)
         return;
     try {
@@ -111,6 +118,97 @@ export async function startNewTicketChatThread() {
 export function clearTicketEvents() {
     ticketChat.clearEvents();
 }
+function clearTurnEventsStream() {
+    if (currentTurnEventsController) {
+        try {
+            currentTurnEventsController.abort();
+        }
+        catch {
+            // ignore
+        }
+        currentTurnEventsController = null;
+    }
+}
+function clearPendingTurnState(pendingKey) {
+    clearTurnEventsStream();
+    clearPendingTurn(pendingKey);
+}
+function handleTicketTurnMeta(update) {
+    const threadId = typeof update.thread_id === "string" ? update.thread_id : "";
+    const turnId = typeof update.turn_id === "string" ? update.turn_id : "";
+    const agent = typeof update.agent === "string" ? update.agent : "codex";
+    if (!threadId || !turnId)
+        return;
+    clearTurnEventsStream();
+    currentTurnEventsController = streamTurnEvents({ agent, threadId, turnId }, {
+        onEvent: (event) => {
+            ticketChat.applyAppEvent(event);
+            ticketChat.renderEvents();
+            ticketChat.render();
+        },
+    });
+}
+export function applyTicketChatResult(payload) {
+    if (!payload || typeof payload !== "object")
+        return;
+    const result = payload;
+    handleTicketTurnMeta(result);
+    if (result.status === "interrupted") {
+        ticketChatState.status = "interrupted";
+        ticketChatState.error = "";
+        addAssistantMessage("Request interrupted", true);
+        renderTicketChat();
+        renderTicketMessages();
+        return;
+    }
+    if (result.status === "error" || result.error) {
+        ticketChatState.status = "error";
+        ticketChatState.error =
+            result.detail || result.error || "Chat failed";
+        addAssistantMessage(`Error: ${ticketChatState.error}`, true);
+        renderTicketChat();
+        renderTicketMessages();
+        return;
+    }
+    // Success
+    ticketChatState.status = "done";
+    if (result.message) {
+        ticketChatState.streamText = result.message;
+    }
+    if (result.agent_message || result.agentMessage) {
+        ticketChatState.statusText =
+            result.agent_message || result.agentMessage || "";
+    }
+    // Check for draft/patch in response
+    const hasDraft = result.has_draft ?? result.hasDraft;
+    if (hasDraft === false) {
+        ticketChatState.draft = null;
+    }
+    else if (hasDraft === true || result.draft || result.patch || result.content) {
+        ticketChatState.draft = {
+            content: result.content || "",
+            patch: result.patch || "",
+            agentMessage: result.agent_message || result.agentMessage || "",
+            createdAt: result.created_at || result.createdAt || "",
+            baseHash: result.base_hash || result.baseHash || "",
+        };
+    }
+    // Add assistant message from response
+    const responseText = ticketChatState.streamText ||
+        ticketChatState.statusText ||
+        (ticketChatState.draft ? "Changes ready to apply" : "Done");
+    if (responseText && ticketChatState.messages.length > 0) {
+        // Only add if we have messages (i.e., a user message was sent)
+        const lastMessage = ticketChatState.messages[ticketChatState.messages.length - 1];
+        // Avoid duplicate assistant messages
+        if (lastMessage.role === "user") {
+            addAssistantMessage(responseText, true);
+        }
+    }
+    renderTicketChat();
+    renderTicketMessages();
+    renderTicketEvents();
+}
 /**
  * Add a user message to the chat history.
  */
@@ -129,6 +227,7 @@ export function setTicketIndex(index) {
     ticketChatState.ticketIndex = index;
     ticketChatState.draft = null;
     resetTicketChatState();
+    clearTurnEventsStream();
     // Clear chat history when switching tickets
     if (changed) {
         ticketChat.setTarget(index != null ? String(index) : null);
@@ -183,7 +282,16 @@ export async function sendTicketChat() {
     resetTicketChatState();
     ticketChatState.status = "running";
     ticketChatState.statusText = "queued";
+    clearTurnEventsStream();
     ticketChatState.controller = new AbortController();
+    const pendingKey = pendingKeyForTicket(ticketChatState.ticketIndex);
+    const clientTurnId = newClientTurnId("ticket");
+    savePendingTurn(pendingKey, {
+        clientTurnId,
+        message,
+        startedAtMs: Date.now(),
+        target: ticketChatState.ticketIndex != null ? `ticket:${ticketChatState.ticketIndex}` : "ticket",
+    });
     renderTicketChat();
     if (els.input) {
         els.input.value = "";
@@ -196,12 +304,14 @@ export async function sendTicketChat() {
             agent,
             model,
             reasoning,
+            clientTurnId,
         });
         // Try to load any pending draft
         await loadTicketPending(ticketChatState.ticketIndex, true);
         if (ticketChatState.status === "running") {
             ticketChatState.status = "done";
         }
+        clearPendingTurnState(pendingKey);
     }
     catch (err) {
         const error = err;
@@ -213,6 +323,7 @@ export async function sendTicketChat() {
             ticketChatState.status = "error";
             ticketChatState.error = error.message || "Ticket chat failed";
         }
+        clearPendingTurnState(pendingKey);
     }
     finally {
         ticketChatState.controller = null;
@@ -226,6 +337,7 @@ export async function cancelTicketChat() {
     if (ticketChatState.controller) {
         ticketChatState.controller.abort();
     }
+    clearTurnEventsStream();
     // Send interrupt to server
     if (ticketChatState.ticketIndex != null) {
         try {
@@ -242,6 +354,56 @@ export async function cancelTicketChat() {
     ticketChatState.statusText = "";
     ticketChatState.controller = null;
     renderTicketChat();
+    if (ticketChatState.ticketIndex != null) {
+        clearPendingTurnState(pendingKeyForTicket(ticketChatState.ticketIndex));
+    }
+}
+export async function resumeTicketPendingTurn(index) {
+    if (index == null)
+        return;
+    const pendingKey = pendingKeyForTicket(index);
+    const pending = loadPendingTurn(pendingKey);
+    if (!pending || pending.target !== `ticket:${index}`)
+        return;
+    const chatState = ticketChatState;
+    chatState.status = "running";
+    chatState.statusText = "Recovering previous turn…";
+    ticketChat.render();
+    ticketChat.renderMessages();
+    try {
+        const outcome = await resumeFileChatTurn(pending.clientTurnId, {
+            onEvent: (event) => {
+                ticketChat.applyAppEvent(event);
+                ticketChat.renderEvents();
+                ticketChat.render();
+            },
+            onResult: (result) => {
+                applyTicketChatResult(result);
+                const status = result.status;
+                if (status === "ok" || status === "error" || status === "interrupted") {
+                    clearPendingTurnState(pendingKey);
+                }
+            },
+            onError: (msg) => {
+                chatState.statusText = msg;
+                renderTicketChat();
+            },
+        });
+        currentTurnEventsController = outcome.controller;
+        if (outcome.lastResult && outcome.lastResult.status) {
+            applyTicketChatResult(outcome.lastResult);
+            clearPendingTurnState(pendingKey);
+            return;
+        }
+        if (!outcome.controller) {
+            window.setTimeout(() => void resumeTicketPendingTurn(index), 1000);
+        }
+    }
+    catch (err) {
+        const msg = err.message || "Failed to resume turn";
+        chatState.statusText = msg;
+        renderTicketChat();
+    }
 }
 export async function applyTicketPatch() {
     if (ticketChatState.ticketIndex == null) {

codex_autorunner/static/ticketChatStream.js

@@ -3,21 +3,14 @@
  * Ticket Chat Stream - handles SSE streaming for ticket chat
  */
 import { resolvePath, getAuthToken } from "./utils.js";
-import { ticketChatState, renderTicketChat, clearTicketEvents, addUserMessage, addAssistantMessage, } from "./ticketChatActions.js";
+import { ticketChatState, renderTicketChat, clearTicketEvents, addUserMessage, addAssistantMessage, applyTicketChatResult, } from "./ticketChatActions.js";
 import { applyTicketEvent, renderTicketEvents, renderTicketMessages } from "./ticketChatEvents.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 performTicketChatRequest(ticketIndex, message, signal, options = {}) {
     // Clear events from previous request and add user message to history
     clearTicketEvents();
     addUserMessage(message);
+    ticketChatState.contextUsagePercent = null;
     // Render both chat (for container visibility) and messages
     renderTicketChat();
     renderTicketMessages();
@@ -39,6 +32,8 @@ export async function performTicketChatRequest(ticketIndex, message, signal, opt
         payload.model = options.model;
     if (options.reasoning)
         payload.reasoning = options.reasoning;
+    if (options.clientTurnId)
+        payload.client_turn_id = options.clientTurnId;
     const res = await fetch(endpoint, {
         method: "POST",
         headers,
@@ -59,7 +54,7 @@ export async function performTicketChatRequest(ticketIndex, message, signal, opt
     }
     const contentType = res.headers.get("content-type") || "";
     if (contentType.includes("text/event-stream")) {
-        await readTicketChatStream(res);
+        await readEventStream(res, (event, data) => handleTicketStreamEvent(event, data));
     }
     else {
         // Non-streaming response
@@ -69,54 +64,6 @@ export async function performTicketChatRequest(ticketIndex, message, signal, opt
         applyTicketChatResult(responsePayload);
     }
 }
-async function readTicketChatStream(res) {
-    if (!res.body)
-        throw new Error("Streaming not supported in this browser");
-    const reader = res.body.getReader();
-    let buffer = "";
-    let escapedNewlines = false;
-    for (;;) {
-        const { value, done } = await reader.read();
-        if (done)
-            break;
-        const decoded = decoder.decode(value, { stream: true });
-        // Handle escaped newlines
-        if (!escapedNewlines) {
-            const combined = buffer + decoded;
-            if (!combined.includes("\n") && combined.includes("\\n")) {
-                escapedNewlines = true;
-                buffer = buffer.replace(/\\n(?=event:|data:|\\n)/g, "\n");
-            }
-        }
-        buffer += escapedNewlines
-            ? decoded.replace(/\\n(?=event:|data:|\\n)/g, "\n")
-            : decoded;
-        // Split on double newlines (SSE message delimiter)
-        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());
-                }
-                else if (line.trim()) {
-                    dataLines.push(line);
-                }
-            });
-            if (dataLines.length === 0)
-                continue;
-            const data = dataLines.join("\n");
-            handleTicketStreamEvent(event, data);
-        }
-    }
-}
 function handleTicketStreamEvent(event, rawData) {
     const parsed = parseMaybeJson(rawData);
     switch (event) {
@@ -154,6 +101,17 @@ function handleTicketStreamEvent(event, rawData) {
             renderTicketEvents();
             break;
         }
+        case "token_usage": {
+            // Token usage events - context window usage
+            if (typeof parsed === "object" && parsed !== null) {
+                const percentRemaining = extractContextRemainingPercent(parsed);
+                if (percentRemaining !== null) {
+                    ticketChatState.contextUsagePercent = percentRemaining;
+                    renderTicketChat();
+                }
+            }
+            break;
+        }
         case "error": {
             const message = typeof parsed === "object" && parsed !== null
                 ? parsed.detail ||
@@ -202,63 +160,3 @@ function handleTicketStreamEvent(event, rawData) {
             break;
     }
 }
-function applyTicketChatResult(payload) {
-    if (!payload || typeof payload !== "object")
-        return;
-    const result = payload;
-    if (result.status === "interrupted") {
-        ticketChatState.status = "interrupted";
-        ticketChatState.error = "";
-        addAssistantMessage("Request interrupted", true);
-        renderTicketChat();
-        renderTicketMessages();
-        return;
-    }
-    if (result.status === "error" || result.error) {
-        ticketChatState.status = "error";
-        ticketChatState.error =
-            result.detail || result.error || "Chat failed";
-        addAssistantMessage(`Error: ${ticketChatState.error}`, true);
-        renderTicketChat();
-        renderTicketMessages();
-        return;
-    }
-    // Success
-    ticketChatState.status = "done";
-    if (result.message) {
-        ticketChatState.streamText = result.message;
-    }
-    if (result.agent_message || result.agentMessage) {
-        ticketChatState.statusText =
-            result.agent_message || result.agentMessage || "";
-    }
-    // Check for draft/patch in response
-    const hasDraft = result.has_draft ?? result.hasDraft;
-    if (hasDraft === false) {
-        ticketChatState.draft = null;
-    }
-    else if (hasDraft === true || result.draft || result.patch || result.content) {
-        ticketChatState.draft = {
-            content: result.content || "",
-            patch: result.patch || "",
-            agentMessage: result.agent_message || result.agentMessage || "",
-            createdAt: result.created_at || result.createdAt || "",
-            baseHash: result.base_hash || result.baseHash || "",
-        };
-    }
-    // Add assistant message from response
-    const responseText = ticketChatState.streamText ||
-        ticketChatState.statusText ||
-        (ticketChatState.draft ? "Changes ready to apply" : "Done");
-    if (responseText && ticketChatState.messages.length > 0) {
-        // Only add if we have messages (i.e., a user message was sent)
-        const lastMessage = ticketChatState.messages[ticketChatState.messages.length - 1];
-        // Avoid duplicate assistant messages
-        if (lastMessage.role === "user") {
-            addAssistantMessage(responseText, true);
-        }
-    }
-    renderTicketChat();
-    renderTicketMessages();
-    renderTicketEvents();
-}