codex-autorunner 1.1.0__py3-none-any.whl → 1.2.1__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/terminalManager.js

@@ -49,6 +49,17 @@ const CAR_CONTEXT_HINT = wrapInjectedContext(CONSTANTS.PROMPTS.CAR_CONTEXT_HINT)
 const VOICE_TRANSCRIPT_DISCLAIMER_TEXT = 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.";
 const INJECTED_CONTEXT_TAG_RE = /<injected context>/i;
+const CAR_CONTEXT_COMMAND_RE = [
+    /^\/\S/,
+    /^\.\/\S/,
+    /^git(\s|$)/,
+    /^cd(\s|$)/,
+    /^ls(\s|$)/,
+    /^make(\s|$)/,
+    /^pnpm(\s|$)/,
+    /^npm(\s|$)/,
+    /^python3?(\s|$)/,
+];
 function wrapInjectedContext(text) {
     return `<injected context>\n${text}\n</injected context>`;
 }
@@ -57,6 +68,13 @@ function wrapInjectedContextIfNeeded(text) {
         return text;
     return INJECTED_CONTEXT_TAG_RE.test(text) ? text : wrapInjectedContext(text);
 }
+function looksLikeCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    const lowered = trimmed.toLowerCase();
+    return CAR_CONTEXT_COMMAND_RE.some((pattern) => pattern.test(lowered));
+}
 const LEGACY_SESSION_STORAGE_KEY = "codex_terminal_session_id";
 const SESSION_STORAGE_PREFIX = "codex_terminal_session_id:";
 const SESSION_STORAGE_TS_PREFIX = "codex_terminal_session_ts:";
@@ -620,12 +638,13 @@ export class TerminalManager {
                     return null;
                 if (manager._hasTextInputHookFired(CAR_CONTEXT_HOOK_ID))
                     return null;
-                const lowered = text.toLowerCase();
-                const hit = CONSTANTS.KEYWORDS.CAR_CONTEXT.some((kw) => lowered.includes(kw));
-                if (!hit)
+                if (looksLikeCommand(text))
                     return null;
+                const lowered = text.toLowerCase();
                 if (lowered.includes("about_car.md"))
                     return null;
+                if (lowered.includes(".codex-autorunner"))
+                    return null;
                 if (text.includes(CONSTANTS.PROMPTS.CAR_CONTEXT_HINT) ||
                     text.includes(CAR_CONTEXT_HINT)) {
                     return null;

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) {