@kenkaiiii/ggcoder 5.27.0 → 5.29.0

package/dist/app-sidecar.js

@@ -65,7 +65,7 @@ import { enrichProcessPath } from "./core/shell-path.js";
 import { downscaleForPreview, shrinkToFit, validateVisionImage } from "./utils/image.js";
 import { startServeMode } from "./modes/serve-mode.js";
 import { loadTelegramConfig, saveTelegramConfig, verifyBotToken } from "./core/telegram-config.js";
-import { loadServers, addServer, removeServer, getServer, parseMcpAddCommand, MCPClientManager, McpOAuthStore, } from "./core/mcp/index.js";
+import { loadServers, addServer, removeServer, getServer, parseMcpAddCommand, MCPClientManager, McpOAuthStore, createElicitationBridge, } from "./core/mcp/index.js";
 import { buildSnapshot, levelForXp, rankForLevel } from "./core/progress/ranks.js";
 import { loadProgress, peekProgress, updateProgress } from "./core/progress/store.js";
 import { awardPrompt, awardCommits } from "./core/progress/engine.js";
@@ -575,6 +575,20 @@ async function main() {
     // request to its window's session via the `x-gg-session` header (and the
     // `?session=` query for the SSE /events stream).
     const sessions = new Map();
+    /**
+     * Fan one frame out to every window.
+     *
+     * For state that is genuinely global rather than per-session — `~/.gg/auth.json`
+     * is shared by all windows, so connecting a provider in one must refresh the
+     * model picker in all of them. Mirrors the memory/jiwa/progress fan-outs.
+     */
+    const broadcastAll = (type, data) => {
+        for (const ctx of sessions.values())
+            ctx.broadcast(type, data);
+    };
+    // Providers currently mid-OAuth in some window. Daemon-level so two windows
+    // cannot race two browser flows for the same provider into one auth file.
+    const oauthInFlightProviders = new Set();
     const memoryStore = new MemoryStore({
         onChange: ({ memories }) => {
             for (const ctx of sessions.values()) {
@@ -770,7 +784,15 @@ async function main() {
                 const sessionPath = typeof body.sessionPath === "string" && body.sessionPath ? body.sessionPath : undefined;
                 const id = randomUUID();
                 try {
-                    const ctx = await createSession({ auth, paths, progress, memoryStore, jiwaStore }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
+                    const ctx = await createSession({
+                        auth,
+                        paths,
+                        progress,
+                        memoryStore,
+                        jiwaStore,
+                        broadcastAll,
+                        oauthInFlightProviders,
+                    }, { id, mode, chatAgent, cwd: sessionCwd, sessionPath });
                     sessions.set(id, ctx);
                     log("INFO", "app-sidecar", "session created", {
                         id,
@@ -1046,7 +1068,7 @@ async function createProgressManager(agentDir, broadcastAll) {
  * logger, PATH, shared auth file, and radio live at the daemon level.
  */
 async function createSession(deps, opts) {
-    const { auth, progress, memoryStore, jiwaStore } = deps;
+    const { auth, progress, memoryStore, jiwaStore, broadcastAll, oauthInFlightProviders } = deps;
     const paths = deps.paths;
     const mode = opts.mode;
     let chatAgent = opts.chatAgent;
@@ -1182,6 +1204,17 @@ async function createSession(deps, opts) {
         })
             .catch(() => { });
     }
+    // ── MCP elicitation bridge ─────────────────────────────────
+    // An MCP server can ask for user input in the middle of a tool call. The
+    // bridge parks the promise; we broadcast the prompt over SSE and resolve it
+    // when the webview POSTs /mcp/elicit/:id.
+    const elicitations = createElicitationBridge({
+        broadcast: (prompt) => broadcast("mcp_elicit", prompt),
+        onTimeout: (prompt) => log("WARN", "app-sidecar", "MCP elicitation timed out", {
+            id: prompt.id,
+            server: prompt.server,
+        }),
+    });
     // The session file path to resume (passed by the daemon's POST /session);
     // empty/unset starts a fresh session.
     const resumeSessionPath = opts.sessionPath;
@@ -1195,6 +1228,7 @@ async function createSession(deps, opts) {
         signal: abort.signal,
         // Keep MCP startup off the readiness path in both modes.
         backgroundMcpConnect: true,
+        onMcpElicit: elicitations.onElicit,
         // Keep restore-time auto-compaction off the readiness path too: its summary
         // LLM call (30s timeout) used to freeze waitForReady — and with it the whole
         // window (project picker, session list) — whenever a resumed session was
@@ -1566,6 +1600,21 @@ async function createSession(deps, opts) {
         running = runState !== "idle";
         if (runState === "cancelling")
             broadcast("run_cancelling", { runState });
+    }, 
+    // Durable run journal. Fire-and-forget on purpose: an unwritten journal
+    // entry is a missed crash hint, while a journal write that throws inside
+    // begin()/settle() would break run ownership itself.
+    {
+        started: (generation) => void session.persistRunStarted(generation).catch((err) => {
+            log("WARN", "app-sidecar", "failed to journal run start", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }),
+        finished: (generation, outcome) => void session.persistRunFinished(generation, outcome).catch((err) => {
+            log("WARN", "app-sidecar", "failed to journal run finish", {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }),
     });
     const cancelledRunEndGenerations = new Set();
     let pendingCancelDrain = null;
@@ -1791,6 +1840,10 @@ async function createSession(deps, opts) {
     function abortOwnedWork() {
         cancelGeneration++;
         abort.abort();
+        // An MCP tool call parked on user input is not cancelled by the signal —
+        // the promise lives in the bridge. Release it, or the aborted turn's tool
+        // call never returns.
+        elicitations.cancelAll();
         // Stop a run-all sweep and every async child through AgentSession's signal.
         taskRunAll = false;
         autopilotCancelled = true;
@@ -1802,9 +1855,9 @@ async function createSession(deps, opts) {
         kenAutoAbort = new AbortController();
         kenAutoSession?.setSignal(kenAutoAbort.signal);
     }
-    function finishOwnedGeneration(generation, emitCancelledFallback) {
+    function finishOwnedGeneration(generation, emitCancelledFallback, outcome = "completed") {
         const cancelled = runLifecycle.isCancellationRequested(generation);
-        const settlement = runLifecycle.settle(generation);
+        const settlement = runLifecycle.settle(generation, outcome);
         if (!settlement.settled)
             return cancelled;
         // A replacement signal is safe only after the provider-backed owner settled.
@@ -1882,8 +1935,9 @@ async function createSession(deps, opts) {
                     });
                 }
             }
-            if (ownsGeneration)
-                finishOwnedGeneration(generation, false);
+            if (ownsGeneration) {
+                finishOwnedGeneration(generation, false, runSucceeded ? "completed" : "failed");
+            }
             // 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)) {
@@ -2762,6 +2816,21 @@ async function createSession(deps, opts) {
                                 },
                             });
                         }
+                        else if (marker.kind === "interrupted_run") {
+                            // Rendered as an error row: the run's tools already changed the
+                            // repo, so the user needs to see it and decide what to do. We
+                            // never replay it — that would duplicate those changes.
+                            history.push({
+                                role: "assistant",
+                                text: "",
+                                error: {
+                                    scope: "interrupted_run",
+                                    headline: "A run was interrupted",
+                                    message: "GG Coder stopped mid-run, so this turn is incomplete. Any files its tools already changed are still on disk.",
+                                    guidance: "Review the working tree, then re-send the request if you still want it.",
+                                },
+                            });
+                        }
                     }
                 };
                 let nonSystemCount = 0;
@@ -2842,7 +2911,14 @@ async function createSession(deps, opts) {
                         // Autopilot injected this turn — live showed only the Ken-tinted
                         // marker for it, never a user bubble. Emitting one here would print
                         // the injected instruction a second time, unstyled.
-                        if (!restored.autopilotInjected && (text.trim() || restored.images.length > 0)) {
+                        //
+                        // Pushed background-status updates are skipped for the same reason:
+                        // the live run rendered no bubble for them, so showing them here
+                        // would fill a reopened session with machine-facing status lines
+                        // the user never saw while working.
+                        if (!restored.autopilotInjected &&
+                            !restored.notification &&
+                            (text.trim() || restored.images.length > 0)) {
                             history.push({
                                 role: "user",
                                 text: command ?? text,
@@ -3799,7 +3875,17 @@ async function createSession(deps, opts) {
                     ...(baseUrl ? { baseUrl } : {}),
                 };
                 await auth.setCredentials(storageKey, creds);
-                broadcast("auth_done", { provider });
+                // auth.json is shared by every window, so this is a global change:
+                // close their login modals and refresh their provider lists too.
+                broadcastAll("auth_done", { provider });
+                // `auth_done` means "a login succeeded" (modals close on it).
+                // `auth_change` means "auth.json changed" — which a DISCONNECT also is,
+                // so connection state has one signal that covers both directions.
+                broadcastAll("auth_change", { provider });
+                // A newly connected provider unlocks its models. `/models` filters on
+                // who is logged in, so every window's picker is now stale — without
+                // this the new models don't appear until the session is reopened.
+                broadcastAll("models_change", {});
                 json(res, 200, { ok: true });
             });
             return;
@@ -3825,7 +3911,18 @@ async function createSession(deps, opts) {
                     json(res, 409, { error: "a login is already in progress" });
                     return;
                 }
+                // A login writes the shared ~/.gg/auth.json, so two windows racing the
+                // same provider means two browser tabs and two token exchanges whose
+                // writes clobber each other. The per-session flag above cannot see
+                // that — guard the provider daemon-wide as well.
+                if (oauthInFlightProviders.has(provider)) {
+                    json(res, 409, {
+                        error: `a ${meta.label} login is already in progress in another window`,
+                    });
+                    return;
+                }
                 oauthInFlight = true;
+                oauthInFlightProviders.add(provider);
                 json(res, 202, { accepted: true });
                 void (async () => {
                     const cb = authCallbacks();
@@ -3846,10 +3943,19 @@ async function createSession(deps, opts) {
                             throw new Error(`OAuth not implemented for ${provider}`);
                         }
                         await auth.setCredentials(storageKey, creds);
-                        broadcast("auth_done", { provider });
+                        // Terminal outcome of a GLOBAL change: every window's login modal
+                        // should close and its provider list refresh, not just the one
+                        // that started the flow.
+                        broadcastAll("auth_done", { provider });
+                        broadcastAll("auth_change", { provider });
+                        // The OAuth provider's models just became selectable everywhere.
+                        broadcastAll("models_change", {});
                     }
                     catch (err) {
                         captureSidecarError(err, "app-sidecar.auth.oauth", { provider });
+                        // Deliberately session-scoped: this is the outcome of ONE window's
+                        // attempt. Another window that never pressed Connect has nothing to
+                        // show an error about, and its modal correctly still offers login.
                         broadcast("auth_error", {
                             provider,
                             message: err instanceof Error ? err.message : String(err),
@@ -3857,6 +3963,7 @@ async function createSession(deps, opts) {
                     }
                     finally {
                         oauthInFlight = false;
+                        oauthInFlightProviders.delete(provider);
                         pendingCode = null;
                     }
                 })();
@@ -3885,6 +3992,39 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        if (method === "POST" && url.startsWith("/mcp/elicit/")) {
+            const id = decodeURIComponent(url.slice("/mcp/elicit/".length));
+            void readBody(req, res).then((raw) => {
+                if (raw === null)
+                    return;
+                let result;
+                try {
+                    const parsed = JSON.parse(raw);
+                    if (parsed.action !== "accept" &&
+                        parsed.action !== "decline" &&
+                        parsed.action !== "cancel") {
+                        json(res, 400, { error: "action must be accept, decline, or cancel" });
+                        return;
+                    }
+                    result =
+                        parsed.action === "accept"
+                            ? { action: "accept", content: parsed.content ?? {} }
+                            : { action: parsed.action };
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                // Unknown id means it already timed out or was cancelled by an abort —
+                // the tool call has moved on, so the answer has nowhere to go.
+                if (!elicitations.settle(id, result)) {
+                    json(res, 409, { error: "no elicitation is awaiting a response" });
+                    return;
+                }
+                json(res, 200, { ok: true });
+            });
+            return;
+        }
         if (method === "POST" && url === "/auth/logout") {
             void readBody(req, res).then(async (raw) => {
                 if (raw === null)
@@ -4270,6 +4410,7 @@ async function createSession(deps, opts) {
         json(res, 404, { error: "not found" });
     }
     async function dispose() {
+        elicitations.cancelAll();
         tasksPollStopped = true;
         if (tasksPoll)
             clearTimeout(tasksPoll);