@kenkaiiii/ggcoder 5.67.0 → 5.68.0

package/dist/app-sidecar.js

@@ -68,6 +68,7 @@ import { listSidecarSessions } from "./app-sidecar-sessions.js";
 import { loadTasksSync, saveTasksSync, pruneDoneTasksSync, getNextPendingTask, markTaskInProgress, } from "./core/tasks-store.js";
 import { initLogger, log } from "./core/logger.js";
 import { installTerminationHandlers } from "./core/shutdown.js";
+import { KeepAwake } from "./core/keep-awake.js";
 import { RADIO_STATIONS, getCurrentStation, getRadioVolume, playRadio, setRadioVolume, stopRadio, } from "./core/radio.js";
 import { enrichProcessPath } from "./core/shell-path.js";
 import { downscaleForPreview, shrinkToFit, validateVisionImage } from "./utils/image.js";
@@ -75,13 +76,16 @@ import { startServeMode } from "./modes/serve-mode.js";
 import { installSteroids, probeSteroids } from "./core/steroids.js";
 import { loadTelegramConfig, saveTelegramConfig, verifyBotToken } from "./core/telegram-config.js";
 import { loadServers, addServer, removeServer, getServer, parseMcpAddCommand, MCPClientManager, McpOAuthStore, createElicitationBridge, } from "./core/mcp/index.js";
-import { createAskUserBridge } from "./core/ask-user.js";
+import { askSoftDeadlineMs, createAskUserBridge, deliverLateAnswer, } from "./core/ask-user.js";
 import { createAskUserTool } from "./tools/ask-user.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";
 import { detectNewCommits, repoKey } from "./core/progress/git-xp.js";
 import { rebuildFromSessions } from "./core/progress/rebuild.js";
+/** App-wide idle-sleep guard: every window's runs share one OS assertion. The
+ *  `keepAwake` setting is applied at daemon start and live via /keep-awake. */
+const keepAwake = new KeepAwake();
 const AUTOMATION_PROVENANCE = {
     source: "runtime",
     kind: "automation",
@@ -568,6 +572,8 @@ async function main() {
     // ~/.gg/debug.log (initLogger truncates on each start).
     const sidecarLog = path.join(paths.agentDir, "gg-app-sidecar.log");
     initLogger(sidecarLog);
+    // Apply the saved keepAwake setting before any run can acquire the guard.
+    keepAwake.setEnabled((await new SettingsManager(paths.settingsFile).load()).keepAwake);
     // The desktop sidecar previously omitted the stream diagnostic hook used by
     // the CLI, leaving device-specific provider stalls impossible to distinguish from
     // event-loop starvation or a broken streaming network path. Keep routine
@@ -906,6 +912,40 @@ async function main() {
             daemonJson(res, 200, { ok: true });
             return;
         }
+        // Keep-awake is app-wide (one OS assertion for every window), so its
+        // setting lives at the daemon level and applies live to in-flight runs.
+        if (method === "GET" && url === "/keep-awake") {
+            daemonJson(res, 200, { enabled: keepAwake.isEnabled });
+            return;
+        }
+        if (method === "POST" && url === "/keep-awake") {
+            void daemonReadBody(req, res).then(async (raw) => {
+                if (raw === null)
+                    return;
+                let enabled;
+                try {
+                    enabled = JSON.parse(raw).enabled;
+                }
+                catch {
+                    enabled = undefined;
+                }
+                if (typeof enabled !== "boolean") {
+                    daemonJson(res, 400, { error: "enabled must be a boolean" });
+                    return;
+                }
+                keepAwake.setEnabled(enabled);
+                try {
+                    const sm = new SettingsManager(paths.settingsFile);
+                    await sm.load();
+                    await sm.set("keepAwake", enabled);
+                }
+                catch (err) {
+                    log("WARN", "app-sidecar", "failed to persist keepAwake", { err: String(err) });
+                }
+                daemonJson(res, 200, { enabled });
+            });
+            return;
+        }
         // Progress is daemon-level so the Home screen can paint before a project
         // session exists; per-session callers still work through the same endpoint.
         if (method === "GET" && url === "/progress") {
@@ -959,6 +999,8 @@ async function main() {
             // Radio playback is app-wide (one stream across all windows), so it stops
             // at the daemon level, not per session.
             stopRadio();
+            // Drop the idle-sleep assertion first: session teardown may hang.
+            keepAwake.dispose();
             // Close the ~/.gg progress fs.watch handle (baseline #8 leak fix).
             progress.dispose();
             await Promise.all([...sessions.values()].map((c) => c.dispose().catch(() => { })));
@@ -1313,9 +1355,33 @@ async function createSession(deps, opts) {
     // MCP bridge above: broadcast over SSE, resolved when the webview POSTs
     // /ask/:id. Registered ONLY here — a TUI/headless/subagent run has nobody to
     // answer, so the tool is absent there rather than hanging on a dead channel.
+    //
+    // Soft deadline ("async ask"): past it the tool returns "no answer yet —
+    // proceed on your best guess" and the question STAYS OPEN. A later answer
+    // rides the ordinary user queue: steering into a live run, or the next turn
+    // when idle. The deadline is short when nobody is watching (autopilot, task
+    // run-all, a scheduled prompt).
+    let scheduledRunActive = false;
     const asks = createAskUserBridge({
         broadcast: (prompt) => broadcast("ask_user", prompt),
-        onTimeout: (prompt) => log("WARN", "app-sidecar", "ask_user timed out", { id: prompt.id }),
+        timeoutMs: () => askSoftDeadlineMs(autopilot || autopilotActive || taskRunAll || scheduledRunActive),
+        onTimeout: (prompt) => {
+            log("WARN", "app-sidecar", "ask_user deadline passed; agent proceeding", { id: prompt.id });
+            broadcast("ask_user_deferred", { id: prompt.id });
+        },
+        onClosed: (ids) => broadcast("ask_user_closed", { ids }),
+        onLateAnswer: (late) => {
+            log("INFO", "app-sidecar", "ask_user late answer queued", { id: late.prompt.id });
+            deliverLateAnswer(late, {
+                queueMessage: (text) => session.queueMessage(text),
+                isBusy: () => running || runClaim.active || autopilotActive,
+                onQueued: () => broadcast("queued", {
+                    count: session.getQueuedCount(),
+                    messages: session.listQueuedMessages(),
+                }),
+                startIdleRun: () => void runStrandedQueue(),
+            });
+        },
     });
     const askUserTool = createAskUserTool(asks.park);
     // The session file path to resume (passed by the daemon's POST /session);
@@ -1860,11 +1926,14 @@ async function createSession(deps, opts) {
         if (!d.silent)
             broadcast("retry", { reason: d.reason, attempt: d.attempt, delayMs: d.delayMs });
     });
+    session.eventBus.on("stream_rule_triggered", (d) => broadcast("stream_rule_triggered", { rules: d.rules, source: d.source, toolName: d.toolName }));
     session.eventBus.on("max_turns", (d) => broadcast("max_turns", d));
     // The agent consumed queued steering at a turn boundary. Re-broadcast as the
     // usual `queued` depth update so the webview drops the pending affordance the
     // moment the message lands in the loop, not at run_end.
     session.eventBus.on("queue_drained", (d) => broadcast("queued", { count: d.count, messages: session.listQueuedMessages() }));
+    // A fresh/loaded session must not receive late answers to the old one's questions.
+    session.eventBus.on("session_start", () => asks.closeDeferred());
     session.eventBus.on("tool_call_start", (d) => {
         toolCallNames.set(d.toolCallId, d.name);
         broadcast("tool_call_start", d);
@@ -1924,6 +1993,26 @@ async function createSession(deps, opts) {
     session.eventBus.on("subagent_state", (d) => broadcast("subagent_state", d));
     session.eventBus.on("compaction_start", (d) => broadcast("compaction_start", d));
     session.eventBus.on("compaction_end", (d) => broadcast("compaction_end", d));
+    // Keep the computer awake while this window's agent works: owned runs and
+    // autopilot cycles (RunLifecycle state), Ken replies, and background
+    // sub-agents that outlive their parent run. Released on settle (completed,
+    // failed or cancelled) and on session dispose.
+    let releaseRunAwake = null;
+    let releaseSubagentAwake = null;
+    const activeSubagents = new Set();
+    session.eventBus.on("subagent_state", (d) => {
+        if (d.state === "starting" || d.state === "running")
+            activeSubagents.add(d.agent_id);
+        else
+            activeSubagents.delete(d.agent_id);
+        if (activeSubagents.size > 0) {
+            releaseSubagentAwake ??= keepAwake.acquire("subagent");
+        }
+        else {
+            releaseSubagentAwake?.();
+            releaseSubagentAwake = null;
+        }
+    });
     let running = false;
     // Closes the window between `/prompt` deciding to start a run and `runAgent`
     // flipping `running` — that stretch awaits, so Node yields inside it. See
@@ -1931,6 +2020,13 @@ async function createSession(deps, opts) {
     const runClaim = new RunClaim();
     const runLifecycle = new RunLifecycle((runState) => {
         running = runState !== "idle";
+        if (running) {
+            releaseRunAwake ??= keepAwake.acquire("run");
+        }
+        else {
+            releaseRunAwake?.();
+            releaseRunAwake = null;
+        }
         if (runState === "cancelling")
             broadcast("run_cancelling", { runState });
     }, 
@@ -3598,6 +3694,8 @@ async function createSession(deps, opts) {
                 // Claim the run NOW, synchronously. Everything below this line may
                 // yield, and `running` does not flip until runAgent begins.
                 claimedStart = runClaim.claim();
+                // A scheduled prompt has nobody watching: short ask deadline.
+                scheduledRunActive = meta?.scheduled === true;
                 json(res, 202, { accepted: true });
                 // Gate inputs captured around the run: whether this turn is a workflow
                 // slash command (attachment prompts skip slash expansion entirely), and
@@ -3696,8 +3794,10 @@ async function createSession(deps, opts) {
                 await runStrandedQueue();
             })
                 .finally(() => {
-                if (claimedStart)
+                if (claimedStart) {
+                    scheduledRunActive = false;
                     runClaim.release();
+                }
             });
             return;
         }
@@ -3733,6 +3833,7 @@ async function createSession(deps, opts) {
                 }
                 json(res, 202, { accepted: true });
                 kenRunning = true;
+                const releaseKenAwake = keepAwake.acquire("ken");
                 broadcast("ken_run_start", { text });
                 try {
                     const ken = await ensureKenSession();
@@ -3749,6 +3850,7 @@ async function createSession(deps, opts) {
                     broadcastError("ken_error", "ken run failed", err);
                 }
                 finally {
+                    releaseKenAwake();
                     kenRunning = false;
                     broadcast("ken_run_end", {});
                     const pending = pendingKenModel;
@@ -4226,6 +4328,18 @@ async function createSession(deps, opts) {
             json(res, 200, payload);
             return;
         }
+        if (method === "POST" && url === "/prewarm") {
+            // Best-effort Anthropic cache prewarm on the composer's first keystroke.
+            // Fire-and-forget: AgentSession.prewarm() applies its own gating (provider,
+            // setting, history size, TTL, in-flight) and swallows request errors.
+            if (!running) {
+                void session.prewarm().catch((err) => {
+                    log("WARN", "app-sidecar", "prewarm failed", { err: String(err) });
+                });
+            }
+            json(res, 202, { accepted: !running });
+            return;
+        }
         if (method === "POST" && url === "/cancel") {
             void (async () => {
                 // Even between task runs, cancellation stops the sweep. Active provider
@@ -5082,6 +5196,10 @@ async function createSession(deps, opts) {
         json(res, 404, { error: "not found" });
     }
     async function dispose() {
+        releaseRunAwake?.();
+        releaseRunAwake = null;
+        releaseSubagentAwake?.();
+        releaseSubagentAwake = null;
         elicitations.cancelAll();
         asks.cancelAll();
         tasksPollStopped = true;