@prestyj/cli 5.28.0 → 5.29.0

package/dist/app-sidecar.js

@@ -39,11 +39,12 @@ import { isWorkflowCommandText, countAssistantMessages, shouldStartAutopilotCycl
 import { driveAutopilotCycle, frameAutopilotInjection } from "./core/autopilot-cycle.js";
 import { describeRunVerification, describeTurnVerification } from "./core/run-status.js";
 import { validateNolanModelPref, effectiveNolanModel, } from "./core/nolan-model.js";
-import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeNolanTurnsForHistory, getHistoryMessageVisibility, replayMessagesInOrder, restoreUserRow, restoreAssistantTexts, resolveRestoredCommand, autopilotMarkerCopySeed, } from "./core/session-history.js";
+import { normalizeAutopilotMarkersForHistory, normalizeAppMarkersForHistory, normalizeNolanTurnsForHistory, getHistoryMessageVisibility, replayMessagesInOrder, restoreUserRow, restoreAssistantTexts, resolveRestoredCommand, autopilotMarkerCopySeed, extractToolImagePaths, } from "./core/session-history.js";
 import { sessionToMarkdown, defaultExportFilename, } from "./core/session-export.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { advancesPhase, explainPullFailure, isGgufShard, isValidHfRepoId, parseOllamaPullLine, pickGgufQuant, SHARDED_MESSAGE, toHfSearchRow, } from "./hf-pull.js";
 import { cleanupToolOutputs } from "./tools/overflow.js";
+import { spawnedTasks } from "./tools/subagent-shared.js";
 import { readCappedBody } from "./utils/http-body.js";
 import { fetchSubscriptionUsage, SubscriptionUsageError, XIAOMI_CREDITS_KEY, dualAuthProvider, oauthStorageKey, discoverLocalModels, findProbedModel, formatLocalModelId, parseLocalModelId, probeEndpoint, toModelInfo as localModelInfo, } from "@prestyj/core";
 import { LocalEndpointError, addCustomEndpoint, listAllEndpoints, removeCustomEndpoint, syncEndpointCredentials, } from "./core/local-endpoint-store.js";
@@ -70,20 +71,25 @@ import { listSidecarSessions } from "./app-sidecar-sessions.js";
 import { loadTasksSync, saveTasksSync, pruneDoneTasksSync, getNextPendingTask, markTaskInProgress, } from "./core/task-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";
+import { downscaleForPreview, IMAGE_MEDIA_TYPES, shrinkToFit, validateVisionImage, } from "./utils/image.js";
+import { readFileBounded } from "./tools/operations.js";
 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",
@@ -570,6 +576,8 @@ async function main() {
     // ~/.ezcoder/debug.log (initLogger truncates on each start).
     const sidecarLog = path.join(paths.agentDir, "ezcoder-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
@@ -908,6 +916,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") {
@@ -955,9 +997,16 @@ async function main() {
     const shutdown = installTerminationHandlers({
         scope: "app-sidecar",
         teardown: async () => {
+            // Before any await: background commands live outside the daemon's process
+            // group, and the app force-kills that group after 3 s. If a slow session
+            // teardown is still pending then, these would never be stopped.
+            for (const c of sessions.values())
+                c.stopBackgroundProcesses();
             clearInterval(parentWatch);
             // Radio playback is app-wide (one stream across all windows).
             stopRadio();
+            // Drop the idle-sleep assertion first: session teardown may hang.
+            keepAwake.dispose();
             // Close the ~/.ezcoder progress fs.watch handle.
             progress.dispose();
             await Promise.all([...sessions.values()].map((c) => c.dispose().catch(() => { })));
@@ -1312,9 +1361,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);
@@ -1867,11 +1940,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);
@@ -1931,12 +2007,38 @@ async function createSession(deps, opts) {
     session.eventBus.on("hook", (d) => broadcast("hook", d));
     session.eventBus.on("diagnostics", (d) => broadcast("diagnostics", d));
     // Fires BEFORE the candidate final answer streams. The webview holds assistant
-    // text back while armed, so an Ideal review supersedes a draft that was never
+    // text back while armed, so an injected follow-up supersedes a draft that was never
     // painted instead of deleting one the user already started reading.
     session.eventBus.on("hook_armed", (d) => broadcast("hook_armed", d));
     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));
+    // Cold-prompt-cache notice: push the fresh TTL anchor + context size whenever
+    // a run or compaction settles. Expiry itself is time-based, so the webview
+    // also re-reads `cacheExpiry` from /state when the user returns or types.
+    for (const ev of ["agent_done", "compaction_end", "model_change"]) {
+        session.eventBus.on(ev, () => broadcast("cache_expiry", session.getCacheExpiryStatus()));
+    }
+    // Keep the computer awake while this window's agent works: owned runs and
+    // autopilot cycles (RunLifecycle state), Nolan 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
@@ -1944,6 +2046,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 });
     }, 
@@ -1970,10 +2079,8 @@ async function createSession(deps, opts) {
     // Autopilot (auto-review) toggle for THIS window's project. Loaded from
     // ezcoder-app.json on boot; flipped via POST /autopilot. When on, POST /prompt runs
     // runAutopilotCycle after the user's turn settles — Nolan auto-reviews the work
-    // and drives the review→prompt→review loop. Nolan is the sole verification
-    // owner in this mode, so suppress the build session's redundant Ideal hook.
+    // and drives the review→prompt→review loop.
     let autopilot = mode === "code" && (await loadAutopilot(cwd));
-    session.setIdealReviewSuppressed(autopilot);
     // True while an autopilot review is in flight (used to defer nolanAuto model
     // switches, like nolanRunning does for chat Nolan, and to drive the spinner).
     let autopilotReviewing = false;
@@ -2173,9 +2280,6 @@ async function createSession(deps, opts) {
             // (often >5 min) regardless of the user's global speedProfile pick.
             forceLongCacheRetention: true,
         });
-        // Nolan is already the independent autopilot reviewer; recursively running
-        // his own Ideal self-review adds latency and can corrupt the verdict shape.
-        nolanAgent.setIdealReviewSuppressed(true);
         await nolanAgent.initialize();
         // Keep review text/tools silent; report usage only for whole-task accounting.
         nolanAgent.eventBus.on("turn_end", (d) => {
@@ -2444,7 +2548,6 @@ async function createSession(deps, opts) {
         const generation = runLifecycle.begin(abortOwnedWork).generation;
         pendingCancelDrain = null;
         autopilotActive = true;
-        session.setIdealReviewSuppressed(true);
         // Generation captured by the last plan review; acceptPlan re-checks it so
         // a user Accept/Reject landing mid-review always wins.
         let planGenAtReview = -1;
@@ -2562,7 +2665,6 @@ async function createSession(deps, opts) {
         }
         finally {
             autopilotActive = false;
-            session.setIdealReviewSuppressed(autopilot);
             finishOwnedGeneration(generation, true, session.getVerificationProblem() ? "unverified" : "completed");
             queueMicrotask(() => void runStrandedQueue());
         }
@@ -2861,6 +2963,7 @@ async function createSession(deps, opts) {
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                 supportsVideo: getModel(st.model)?.supportsVideo ?? false,
                 autopilot,
+                cacheExpiry: session.getCacheExpiryStatus(),
                 ...nolanStatePayload(),
                 ...footerExtras(),
             });
@@ -3340,7 +3443,16 @@ async function createSession(deps, opts) {
                 // Pre-index tool results by toolCallId so we can pair tool calls with
                 // their results (for sub-agent status + image extraction).
                 const toolResultMap = new Map();
+                // Tool name per call, so restore only trusts generate_image's own text
+                // when it reads extra images from disk (an MCP server could fake it).
+                const toolNameById = new Map();
                 for (const msg of messages) {
+                    if (msg.role === "assistant" && typeof msg.content !== "string") {
+                        for (const c of msg.content) {
+                            if (c.type === "tool_call")
+                                toolNameById.set(c.id, c.name);
+                        }
+                    }
                     if (msg.role !== "tool")
                         continue;
                     for (const tr of msg.content) {
@@ -3500,31 +3612,43 @@ async function createSession(deps, opts) {
                             const imageBlocks = tr.content.filter((c) => c.type === "image");
                             if (imageBlocks.length === 0)
                                 continue;
-                            // Extract the path from the text block (e.g. "Generated image → /path").
+                            // Extract the path from the text block so the restored image
+                            // stays clickable (read / screenshot / generate_image formats).
                             const textBlock = tr.content.find((c) => c.type === "text" && "text" in c && typeof c.text === "string");
                             const textContent = textBlock && textBlock.type === "text" ? textBlock.text : "";
-                            const pathMatch = textContent.match(/→\s*(\S+)/);
-                            const imgPath = pathMatch?.[1];
-                            // Downscale each image for the webview preview.
+                            const imgPaths = extractToolImagePaths(textContent);
+                            // Downscale each image for the webview preview. Paths pair with
+                            // image blocks in order (a tool saves one file per image).
                             const toolImages = [];
+                            let blockIndex = 0;
                             for (const block of imageBlocks) {
                                 if (block.type !== "image")
                                     continue;
-                                try {
-                                    const rawBuf = Buffer.from(block.data, "base64");
-                                    const previewBuf = await downscaleForPreview(rawBuf);
-                                    toolImages.push({
-                                        src: `data:${block.mediaType};base64,${previewBuf.toString("base64")}`,
-                                        path: imgPath,
-                                    });
-                                }
-                                catch {
-                                    // Downscale failed — use the raw data.
-                                    toolImages.push({
-                                        src: `data:${block.mediaType};base64,${block.data}`,
-                                        path: imgPath,
-                                    });
-                                }
+                                const imgPath = imgPaths[blockIndex++];
+                                const previewBuf = await downscaleForPreview(Buffer.from(block.data, "base64"));
+                                toolImages.push({
+                                    src: `data:${block.mediaType};base64,${previewBuf.toString("base64")}`,
+                                    path: imgPath,
+                                });
+                            }
+                            // generate_image persists only its first image's pixels; the
+                            // rest exist only on disk, so preview them from their files.
+                            // Skip silently if a file was moved or deleted since.
+                            const extraPaths = toolNameById.get(tr.toolCallId) === "generate_image"
+                                ? imgPaths.slice(blockIndex)
+                                : [];
+                            for (const extraPath of extraPaths) {
+                                const mediaType = IMAGE_MEDIA_TYPES[path.extname(extraPath).toLowerCase()];
+                                if (!mediaType)
+                                    continue;
+                                const raw = await readFileBounded(extraPath).catch(() => null);
+                                if (!raw)
+                                    continue;
+                                const previewBuf = await downscaleForPreview(raw);
+                                toolImages.push({
+                                    src: `data:${mediaType};base64,${previewBuf.toString("base64")}`,
+                                    path: extraPath,
+                                });
                             }
                             if (toolImages.length > 0) {
                                 history.push({
@@ -3609,18 +3733,25 @@ async function createSession(deps, opts) {
                     if (msg.role === "assistant" && typeof msg.content !== "string") {
                         const subagentCalls = msg.content.filter((c) => c.type === "tool_call" && (c.name === "subagent" || c.name === "spawn_agent"));
                         if (subagentCalls.length > 0) {
-                            const agents = subagentCalls.map((c) => {
+                            const agents = subagentCalls.flatMap((c) => {
                                 const result = toolResultMap.get(c.id);
-                                return {
-                                    agentName: c.name === "spawn_agent" && typeof c.args?.task_name === "string"
-                                        ? c.args.task_name
-                                        : typeof c.args?.agent === "string"
-                                            ? c.args.agent
-                                            : undefined,
-                                    // Async workers are intentionally non-resumable; restored rows are historical.
-                                    status: result?.isError ? "error" : "done",
-                                    toolUseCount: 0,
-                                };
+                                // Async workers are intentionally non-resumable; restored rows are historical.
+                                const status = result?.isError ? "error" : "done";
+                                if (c.name === "spawn_agent") {
+                                    // One row per child: a batch call starts several.
+                                    return spawnedTasks(c.args).map((spawn) => ({
+                                        agentName: spawn.task_name ?? spawn.agent,
+                                        status,
+                                        toolUseCount: 0,
+                                    }));
+                                }
+                                return [
+                                    {
+                                        agentName: typeof c.args?.agent === "string" ? c.args.agent : undefined,
+                                        status,
+                                        toolUseCount: 0,
+                                    },
+                                ];
                             });
                             history.push({
                                 role: "assistant",
@@ -3754,6 +3885,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
@@ -3852,8 +3985,10 @@ async function createSession(deps, opts) {
                 await runStrandedQueue();
             })
                 .finally(() => {
-                if (claimedStart)
+                if (claimedStart) {
+                    scheduledRunActive = false;
                     runClaim.release();
+                }
             });
             return;
         }
@@ -3889,6 +4024,7 @@ async function createSession(deps, opts) {
                 }
                 json(res, 202, { accepted: true });
                 nolanRunning = true;
+                const releaseNolanAwake = keepAwake.acquire("nolan");
                 broadcast("nolan_run_start", { text });
                 try {
                     const nolanAgent = await ensureNolanSession();
@@ -3905,6 +4041,7 @@ async function createSession(deps, opts) {
                     broadcastError("nolan_error", "nolan run failed", err);
                 }
                 finally {
+                    releaseNolanAwake();
                     nolanRunning = false;
                     broadcast("nolan_run_end", {});
                     const pending = pendingNolanModel;
@@ -3943,9 +4080,6 @@ async function createSession(deps, opts) {
                     return;
                 }
                 autopilot = enabled;
-                // A toggle-off during an active cycle takes effect after Nolan finishes;
-                // until then, injected build runs must not re-enable Ideal self-review.
-                session.setIdealReviewSuppressed(enabled || autopilotActive);
                 await saveAutopilot(cwd, enabled);
                 log("INFO", "app-sidecar", "autopilot toggled", { enabled: String(enabled) });
                 broadcast("autopilot", { autopilot: enabled });
@@ -4471,6 +4605,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
@@ -5327,6 +5473,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;
@@ -5350,6 +5500,11 @@ async function createSession(deps, opts) {
         await nolanAutoSession?.dispose().catch(() => { });
         await session.dispose().catch(() => { });
     }
+    function stopBackgroundProcesses() {
+        session.stopBackgroundProcesses();
+        nolanSession?.stopBackgroundProcesses();
+        nolanAutoSession?.stopBackgroundProcesses();
+    }
     return {
         id: opts.id,
         mode,
@@ -5363,6 +5518,7 @@ async function createSession(deps, opts) {
         broadcast,
         handle,
         dispose,
+        stopBackgroundProcesses,
     };
 }
 main().catch(async (err) => {