@kenkaiiii/ggcoder 5.16.0 → 5.17.0

package/dist/app-sidecar.js

@@ -18,10 +18,11 @@ import os from "node:os";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { parseArgs } from "node:util";
-import { formatError } from "@kenkaiiii/gg-ai";
+import { environmentSecrets, formatError, redactValue, } from "@kenkaiiii/gg-ai";
 import { runJsonMode } from "./modes/json-mode.js";
 import { runSubagentWorkerMode } from "./modes/subagent-worker-mode.js";
 import { AgentSession } from "./core/agent-session.js";
+import { RunLifecycle } from "./core/run-lifecycle.js";
 import { CHAT_AGENT_IDS, chatAgentSessionsDir, createChatAgent, parseChatAgentId, sessionsDirForChatAgent, switchChatAgent, } from "./chat-agents/index.js";
 import { buildJiwaTools, JiwaStore } from "./chat-agents/jiwa.js";
 import { buildMemoryTools, MemoryStore } from "./chat-agents/memory.js";
@@ -929,7 +930,8 @@ async function createSession(deps, opts) {
     const clients = new Set();
     let clientSeq = 0;
     function broadcast(type, data) {
-        const frame = `data: ${JSON.stringify({ type, data })}\n\n`;
+        const safePayload = redactValue({ type, data }, { secrets: environmentSecrets(process.env) });
+        const frame = `data: ${JSON.stringify(safePayload)}\n\n`;
         for (const c of clients)
             c.res.write(frame);
     }
@@ -1123,6 +1125,13 @@ async function createSession(deps, opts) {
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
     let running = false;
+    const runLifecycle = new RunLifecycle((runState) => {
+        running = runState !== "idle";
+        if (runState === "cancelling")
+            broadcast("run_cancelling", { runState });
+    });
+    const cancelledRunEndGenerations = new Set();
+    let pendingCancelDrain = null;
     let titleGenerated = false;
     // Bumped by /cancel — a run whose cancel generation changed mid-flight was
     // canceled and earns no XP.
@@ -1145,6 +1154,7 @@ async function createSession(deps, opts) {
     let autopilotCancelled = false;
     // Hard cap on review→prompt→review rounds per user turn (loop safety).
     const MAX_AUTOPILOT_ROUNDS = 3;
+    const CANCEL_TIMEOUT_MS = 5_000;
     // Prompt bodies Autopilot Ken injected into the BUILD session this
     // conversation. Passed into every Ken digest so injected prompts render as
     // "Ken autopilot (injected)" instead of `**User:**` — otherwise multi-round
@@ -1351,29 +1361,63 @@ async function createSession(deps, opts) {
             });
         }
     }
-    // Core run lifecycle shared by /prompt and the task runner: flips `running`,
-    // brackets the run with run_start/run_end, refreshes the footer extras, and
-    // generates the session title once. `label` is the text shown live with the
-    // run_start frame.
+    function abortOwnedWork() {
+        cancelGeneration++;
+        abort.abort();
+        // Stop a run-all sweep and every async child through AgentSession's signal.
+        taskRunAll = false;
+        autopilotCancelled = true;
+        kenAutoAbort.abort();
+    }
+    function installFreshRunControllers() {
+        abort = new AbortController();
+        session.setSignal(abort.signal);
+        kenAutoAbort = new AbortController();
+        kenAutoSession?.setSignal(kenAutoAbort.signal);
+    }
+    function finishOwnedGeneration(generation, emitCancelledFallback) {
+        const cancelled = runLifecycle.isCancellationRequested(generation);
+        const settlement = runLifecycle.settle(generation);
+        if (!settlement.settled)
+            return cancelled;
+        // A replacement signal is safe only after the provider-backed owner settled.
+        installFreshRunControllers();
+        if (cancelled && emitCancelledFallback && !cancelledRunEndGenerations.has(generation)) {
+            cancelledRunEndGenerations.add(generation);
+            broadcast("run_end", { cancelled: true, runState: runLifecycle.state });
+        }
+        return cancelled;
+    }
+    // Core provider-run bracket. Standalone runs own a lifecycle generation;
+    // injected autopilot runs share the cycle's outer generation.
     async function runAgent(label, run) {
-        running = true;
+        const ownsGeneration = !runLifecycle.running;
+        const generation = ownsGeneration
+            ? runLifecycle.begin(abortOwnedWork).generation
+            : runLifecycle.generation;
+        if (ownsGeneration)
+            pendingCancelDrain = null;
         // Progress (Ranks): completed, non-canceled runs with ≥1 assistant turn earn
         // XP — prompt + any commits authored during the run window.
         const runStartedAt = Date.now();
         const cancelGenAtStart = cancelGeneration;
         const assistantsBeforeRun = countAssistantMessages(session.getMessages());
         let runSucceeded = false;
-        broadcast("run_start", { text: label });
+        broadcast("run_start", { text: label, runState: runLifecycle.state });
         try {
-            await run();
+            if (!runLifecycle.isCancellationRequested(generation))
+                await run();
             runSucceeded = true;
         }
         catch (err) {
-            broadcastError("error", "run failed", err);
+            if (!runLifecycle.isCancellationRequested(generation)) {
+                broadcastError("error", "run failed", err);
+            }
         }
         finally {
-            running = false;
+            const cancelled = runLifecycle.isCancellationRequested(generation);
             if (runSucceeded &&
+                !cancelled &&
                 cancelGeneration === cancelGenAtStart &&
                 countAssistantMessages(session.getMessages()) > assistantsBeforeRun) {
                 // Fire-and-forget — XP must never delay or break run teardown.
@@ -1383,21 +1427,24 @@ async function createSession(deps, opts) {
             // background tasks — refresh the footer extras once it settles.
             gitBranch = await getGitBranch(cwd).catch(() => gitBranch);
             gitIsRepo = await isGitRepo(cwd).catch(() => gitIsRepo);
-            broadcast("run_end", {});
+            if (ownsGeneration)
+                finishOwnedGeneration(generation, false);
+            // A cancelled injected run is still owned by the surrounding autopilot
+            // cycle; its outer finalizer emits the one terminal cancelled run_end.
+            if (!(cancelled && !ownsGeneration)) {
+                if (cancelled)
+                    cancelledRunEndGenerations.add(generation);
+                broadcast("run_end", {
+                    ...(cancelled ? { cancelled: true } : {}),
+                    runState: runLifecycle.state,
+                });
+            }
             // Autopilot's review loop is driven explicitly from POST /prompt (see
-            // runAutopilotCycle), NOT from this shared finally — that keeps the
-            // injected GG Coder runs this cycle triggers from recursively re-entering
-            // the loop through the same bracket.
-            // The agent may have marked project tasks done during the run — prune the
-            // completed ones so they drop out of the Tasks modal automatically (users
-            // never have to delete finished tasks by hand).
+            // runAutopilotCycle), NOT from this shared finally — that keeps injected
+            // runs from recursively entering the same review loop.
             broadcast("tasks_list", { tasks: pruneDoneTasksSync(cwd) });
-            // Queue drains into the run as steering, so it's empty by run_end —
-            // sync the webview indicator.
             broadcast("queued", { count: session.getQueuedCount() });
             broadcast("extras", footerExtras());
-            // Generate a session title once, after the first run, for the title bar
-            // (best-effort, async — don't block the response).
             if (!titleGenerated) {
                 titleGenerated = true;
                 void session.generateTitle().then((title) => {
@@ -1430,7 +1477,8 @@ async function createSession(deps, opts) {
             return parseAutopilotVerdict(lastAssistantText(ken.getMessages()));
         }
         catch (err) {
-            broadcastError("autopilot_error", "autopilot review failed", err);
+            if (!autopilotCancelled)
+                broadcastError("autopilot_error", "autopilot review failed", err);
             return null;
         }
         finally {
@@ -1505,6 +1553,8 @@ async function createSession(deps, opts) {
     async function runAutopilotCycle(originalRequest) {
         if (!autopilot || autopilotCancelled)
             return;
+        const generation = runLifecycle.begin(abortOwnedWork).generation;
+        pendingCancelDrain = null;
         autopilotActive = true;
         // Generation captured by the last plan review; acceptPlan re-checks it so
         // a user Accept/Reject landing mid-review always wins.
@@ -1619,6 +1669,8 @@ async function createSession(deps, opts) {
         }
         finally {
             autopilotActive = false;
+            finishOwnedGeneration(generation, true);
+            queueMicrotask(() => void runStrandedQueue());
         }
     }
     // ── Stranded-queue drain ───────────────────────────────
@@ -1795,7 +1847,7 @@ async function createSession(deps, opts) {
         });
     }
     function json(res, status, body) {
-        const payload = JSON.stringify(body);
+        const payload = JSON.stringify(redactValue(body, { secrets: environmentSecrets(process.env) }));
         res.writeHead(status, {
             "content-type": "application/json",
             "access-control-allow-origin": "*",
@@ -1811,6 +1863,7 @@ async function createSession(deps, opts) {
                 mode,
                 chatAgent,
                 running,
+                runState: runLifecycle.state,
                 ready: true,
                 thinkingLevel: session.getThinkingLevel() ?? null,
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
@@ -1883,6 +1936,7 @@ async function createSession(deps, opts) {
                     mode,
                     chatAgent,
                     running,
+                    runState: runLifecycle.state,
                     thinkingLevel: session.getThinkingLevel() ?? null,
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                     supportsVideo: getModel(st.model)?.supportsVideo ?? false,
@@ -2378,6 +2432,13 @@ async function createSession(deps, opts) {
                     json(res, 400, { error: "empty prompt" });
                     return;
                 }
+                if (runLifecycle.running && runLifecycle.isCancellationRequested(runLifecycle.generation)) {
+                    json(res, 409, {
+                        error: runLifecycle.state === "cancelling" ? "run_cancelling" : "cancel_failed",
+                        runState: runLifecycle.state,
+                    });
+                    return;
+                }
                 if (running || autopilotActive) {
                     // Queue prompts as mid-run steering (mirrors the CLI). Also queue while
                     // an autopilot cycle is active but between injected runs (build idle,
@@ -2866,26 +2927,50 @@ async function createSession(deps, opts) {
             return;
         }
         if (method === "POST" && url === "/cancel") {
-            cancelGeneration++;
-            abort.abort();
-            abort = new AbortController();
-            session.setSignal(abort.signal);
-            running = false;
-            // Stop a run-all sweep so the next pending task isn't auto-started.
-            taskRunAll = false;
-            // Stop any in-flight autopilot cycle: flag it so the loop bails between
-            // steps, and abort a review that's mid-prompt on the kenAuto session.
-            autopilotCancelled = true;
-            kenAutoAbort.abort();
-            kenAutoAbort = new AbortController();
-            kenAutoSession?.setSignal(kenAutoAbort.signal);
-            autopilotReviewing = false;
-            // Drop any queued steering and return it so the webview can restore it to
-            // the composer.
-            const drained = session.drainQueue();
-            broadcast("run_end", { cancelled: true });
-            broadcast("queued", { count: 0 });
-            json(res, 200, { cancelled: true, drained });
+            void (async () => {
+                // Even between task runs, cancellation stops the sweep. Active provider
+                // ownership invokes the full abort hook exactly once through lifecycle.
+                taskRunAll = false;
+                autopilotCancelled = true;
+                if (!runLifecycle.running) {
+                    kenAutoAbort.abort();
+                    kenAutoAbort = new AbortController();
+                    kenAutoSession?.setSignal(kenAutoAbort.signal);
+                }
+                const generation = runLifecycle.generation;
+                if (!pendingCancelDrain || pendingCancelDrain.generation !== generation) {
+                    pendingCancelDrain = { generation, text: session.drainQueue() };
+                    broadcast("queued", { count: 0 });
+                }
+                const result = await runLifecycle.cancel(CANCEL_TIMEOUT_MS);
+                const drained = pendingCancelDrain.text;
+                if (result.status === "failed") {
+                    broadcast("cancel_failed", {
+                        error: "cancel_failed",
+                        reason: result.reason,
+                        runState: runLifecycle.state,
+                    });
+                    json(res, 504, {
+                        error: "cancel_failed",
+                        reason: result.reason,
+                        runState: runLifecycle.state,
+                        drained,
+                    });
+                    return;
+                }
+                json(res, 200, {
+                    cancelled: result.status === "cancelled",
+                    runState: runLifecycle.state,
+                    drained,
+                });
+            })().catch((error) => {
+                broadcast("cancel_failed", { error: "cancel_failed", runState: runLifecycle.state });
+                json(res, 500, {
+                    error: "cancel_failed",
+                    message: error instanceof Error ? error.message : String(error),
+                    runState: runLifecycle.state,
+                });
+            });
             return;
         }
         if (method === "POST" && url === "/new-session") {