@dreb/coding-agent 2.51.0 → 2.53.0

package/dist/modes/rpc/rpc-mode.js

@@ -16,12 +16,15 @@ import { isValidThinkingLevel, VALID_THINKING_LEVELS } from "../../cli/args.js";
 import { VERSION } from "../../config.js";
 import { canonicalizeTrustedRoots, matchContextTrust, validateTrustedContextFolder, validateTrustedContextFolders, } from "../../core/context-trust.js";
 import { DailyCostTracker } from "../../core/daily-cost-tracker.js";
+import { acquireDreamLock, buildDreamPrompt, cleanupDreamTmpDirs, parseDreamCommand, performDreamBackup, pruneOldBackups, resolveDreamContext, validateArchivePath, validateMemoryLinks, } from "../../core/dream.js";
 import { getGitBranch } from "../../core/git-branch.js";
 import { parseModelPattern } from "../../core/model-resolver.js";
 import { takeOverStdout, writeRawStdout } from "../../core/output-guard.js";
 import { SessionManager } from "../../core/session-manager.js";
+import { BUILTIN_SLASH_COMMANDS, parseBuiltinSlashCommand } from "../../core/slash-commands.js";
 import { TabTitleGenerator } from "../../core/tab-title.js";
 import { validateThinkingLevelForModel } from "../../core/thinking.js";
+import { resolveToCwd } from "../../core/tools/path-utils.js";
 import { discoverAgentTypes, getBackgroundAgents, rehydrateBackgroundAgentsFromDisk, } from "../../core/tools/subagent.js";
 import { theme } from "../interactive/theme/theme.js";
 import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
@@ -71,6 +74,111 @@ export function getResourcesForRpc(session) {
             session.resourceLoader.getAppendSystemPrompt().length > 0,
     };
 }
+export function getCommandsForRpc(session) {
+    const commands = new Map();
+    for (const command of session.extensionRunner?.getRegisteredCommands() ?? []) {
+        commands.set(command.invocationName, {
+            name: command.invocationName,
+            description: command.description,
+            source: "extension",
+            sourceInfo: command.sourceInfo,
+        });
+    }
+    for (const template of session.promptTemplates) {
+        if (!commands.has(template.name)) {
+            commands.set(template.name, {
+                name: template.name,
+                description: template.description,
+                source: "prompt",
+                sourceInfo: template.sourceInfo,
+            });
+        }
+    }
+    for (const skill of session.getFilteredSkills()) {
+        const name = `skill:${skill.name}`;
+        if (!commands.has(name)) {
+            commands.set(name, { name, description: skill.description, source: "skill", sourceInfo: skill.sourceInfo });
+        }
+    }
+    // Built-ins deliberately win collisions, matching interactive autocomplete and
+    // ensuring a colliding resource can never make built-in text reach the model.
+    for (const command of BUILTIN_SLASH_COMMANDS) {
+        commands.set(command.name, {
+            name: command.name,
+            description: command.description,
+            source: "builtin",
+            dashboard: command.dashboard !== false,
+        });
+    }
+    return [...commands.values()];
+}
+export function getBuiltinPromptRejection(message) {
+    const parsed = parseBuiltinSlashCommand(message);
+    return parsed
+        ? `Built-in slash command /${parsed.command.name} must be handled by the RPC client; it was not sent to the model.`
+        : undefined;
+}
+async function runDreamForRpc(session, args = "") {
+    const command = parseDreamCommand(`/dream${args ? ` ${args}` : ""}`);
+    if (command.type === "showBackup") {
+        return { message: `Dream backup path: ${session.settingsManager.getDreamArchivePath()}` };
+    }
+    if (command.type === "setBackup") {
+        const absolutePath = resolveToCwd(command.path, session.sessionManager.getCwd());
+        const context = await resolveDreamContext(session.settingsManager);
+        validateArchivePath(absolutePath, [
+            context.globalMemoryDir,
+            ...context.projectMemoryDirs,
+            ...context.claudeMemoryDirs,
+        ]);
+        if (session.settingsManager.hasGlobalSettingsLoadError()) {
+            throw new Error("Cannot write dream backup path: the global settings file failed to load");
+        }
+        session.settingsManager.drainErrors();
+        session.settingsManager.setDreamArchivePath(absolutePath);
+        try {
+            await session.settingsManager.flush();
+        }
+        catch (error) {
+            session.settingsManager.reload();
+            throw error;
+        }
+        const writeErrors = session.settingsManager.drainErrors();
+        if (writeErrors.length > 0) {
+            session.settingsManager.reload();
+            throw new Error(`Failed to persist dream backup path: ${writeErrors.map((entry) => `${entry.scope}: ${entry.error.message}`).join("; ")}`);
+        }
+        return { message: `Dream backup path set to: ${absolutePath}` };
+    }
+    let releaseLock;
+    let context;
+    try {
+        releaseLock = await acquireDreamLock();
+        context = await resolveDreamContext(session.settingsManager);
+        validateArchivePath(context.archivePath, [
+            context.globalMemoryDir,
+            ...context.projectMemoryDirs,
+            ...context.claudeMemoryDirs,
+        ]);
+        const backup = await performDreamBackup(context);
+        if (!backup.verified) {
+            throw new Error(`Backup verification failed; check ${backup.backupPath}`);
+        }
+        await session.prompt(buildDreamPrompt(context, backup), { source: "rpc" });
+        const links = validateMemoryLinks([context.globalMemoryDir, ...context.projectMemoryDirs]);
+        await pruneOldBackups(context.archivePath);
+        return {
+            message: links.valid
+                ? `Dream completed. Backup: ${backup.backupPath}`
+                : `Dream completed with ${links.brokenLinks.length} broken memory link(s). Backup: ${backup.backupPath}`,
+        };
+    }
+    finally {
+        releaseLock?.();
+        if (context)
+            cleanupDreamTmpDirs([context.globalMemoryDir, ...context.projectMemoryDirs]);
+    }
+}
 export function getPendingMessagesForRpc(session) {
     return {
         steering: [...session.getSteeringMessages()],
@@ -915,6 +1023,74 @@ export function createRpcExtensionUIContext(output, pendingExtensionRequests, on
             output(rpcRequest);
         });
     }
+    // Serialize `ask` requests so at most one ask wizard is ever pending, mirroring
+    // the TUI's single-dialog queue (`enqueueExtensionDialog`). Tool execution runs
+    // in parallel, so a turn can issue several `ask_user` calls at once; without
+    // this the Dashboard (which renders a single pending ask) would leave the extra
+    // wizards invisible and their promises hanging until the turn aborts. The first
+    // ask runs synchronously (preserving immediate request emission); later ones
+    // wait in a FIFO. A call whose signal aborts while still queued settles with the
+    // aborted value and never emits a request.
+    let askInFlight = false;
+    const askWaiters = [];
+    const runNextAsk = () => {
+        if (askInFlight)
+            return;
+        const next = askWaiters.shift();
+        if (!next)
+            return;
+        askInFlight = true;
+        next();
+    };
+    function serializeAsk(opts, abortedValue, run) {
+        const signal = opts?.signal;
+        if (signal?.aborted)
+            return Promise.resolve(abortedValue);
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(value);
+            };
+            // A started run's outcome propagates verbatim (a host/protocol failure
+            // must still reject so the ask_user tool reports it distinctly).
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(error);
+            };
+            // While still queued, a signal abort removes this task and settles it
+            // without ever emitting. Once started, createDialogPromise owns abort.
+            const onAbort = () => {
+                const index = askWaiters.indexOf(startTask);
+                if (index === -1)
+                    return;
+                askWaiters.splice(index, 1);
+                finish(abortedValue);
+            };
+            const startTask = () => {
+                signal?.removeEventListener("abort", onAbort);
+                if (signal?.aborted) {
+                    finish(abortedValue);
+                    askInFlight = false;
+                    runNextAsk();
+                    return;
+                }
+                run()
+                    .then(finish, fail)
+                    .finally(() => {
+                    askInFlight = false;
+                    runNextAsk();
+                });
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            askWaiters.push(startTask);
+            runNextAsk();
+        });
+    }
     /**
      * Create an extension UI context that uses the RPC protocol.
      */
@@ -922,38 +1098,50 @@ export function createRpcExtensionUIContext(output, pendingExtensionRequests, on
         select: (title, options, opts) => createDialogPromise(opts, undefined, { method: "select", title, options, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined),
         confirm: (title, message, opts) => createDialogPromise(opts, false, { method: "confirm", title, message, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? false : "confirmed" in r ? r.confirmed : false),
         input: (title, placeholder, opts) => createDialogPromise(opts, undefined, { method: "input", title, placeholder, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined),
-        ask: (request, opts) => createDialogPromise(opts, undefined, {
+        ask: (request, opts) => serializeAsk(opts, undefined, () => createDialogPromise(opts, undefined, {
             method: "ask",
             title: request.title ?? "Question",
-            question: request.question,
-            options: request.options,
-            allowFreeText: request.allowFreeText,
-            multiSelect: request.multiSelect,
-            multiline: request.multiline,
+            questions: request.questions.map((q) => ({
+                question: q.question,
+                title: q.title,
+                options: q.options,
+                allowFreeText: q.allowFreeText,
+                multiSelect: q.multiSelect,
+                multiline: q.multiline,
+            })),
             timeout: opts?.timeout,
             // Preserve the authoritative deadline across Dashboard reload,
             // resync, and drill-in hydration instead of restarting the full
-            // duration whenever the question component remounts.
+            // duration whenever the wizard remounts.
             expiresAt: opts?.timeout ? Date.now() + opts.timeout : undefined,
         }, (response) => {
             if ("cancelled" in response && response.cancelled) {
                 onAskStop();
                 return undefined;
             }
-            const selected = response.selected;
-            const customText = response.customText;
-            if (!Array.isArray(selected) || !selected.every((value) => typeof value === "string")) {
-                throw new Error("Invalid RPC ask response: selected must be an array of strings");
-            }
-            if (customText !== undefined && typeof customText !== "string") {
-                throw new Error("Invalid RPC ask response: customText must be a string");
-            }
-            if (selected.length === 0 && !customText?.trim()) {
-                onAskStop();
-                return undefined;
+            const rawAnswers = response.answers;
+            if (!Array.isArray(rawAnswers)) {
+                throw new Error("Invalid RPC ask response: answers must be an array");
             }
-            return { selected, customText };
-        }, onAskStop),
+            const answers = rawAnswers.map((entry) => {
+                const selected = entry?.selected;
+                const customText = entry?.customText;
+                const skipped = entry?.skipped;
+                if (!Array.isArray(selected) || !selected.every((value) => typeof value === "string")) {
+                    throw new Error("Invalid RPC ask response: each answer's selected must be an array of strings");
+                }
+                if (customText !== undefined && typeof customText !== "string") {
+                    throw new Error("Invalid RPC ask response: customText must be a string");
+                }
+                const answered = selected.length > 0 || !!customText?.trim();
+                return {
+                    selected,
+                    customText: customText || undefined,
+                    skipped: skipped === true || !answered,
+                };
+            });
+            return { answers };
+        }, onAskStop)),
         notify(message, type) {
             // Fire and forget - no response needed
             output({
@@ -1193,6 +1381,9 @@ export async function runRpcMode(session, modelFallbackMessage) {
             // Prompting
             // =================================================================
             case "prompt": {
+                const rejection = getBuiltinPromptRejection(command.message);
+                if (rejection)
+                    return error(id, "prompt", rejection);
                 // Don't await - events will stream
                 // Extension commands are executed immediately, file prompt templates are expanded
                 // If streaming and streamingBehavior specified, queues via steer/followUp
@@ -1206,10 +1397,16 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 return success(id, "prompt");
             }
             case "steer": {
+                const rejection = getBuiltinPromptRejection(command.message);
+                if (rejection)
+                    return error(id, "steer", rejection);
                 await session.steer(command.message, command.images);
                 return success(id, "steer");
             }
             case "follow_up": {
+                const rejection = getBuiltinPromptRejection(command.message);
+                if (rejection)
+                    return error(id, "follow_up", rejection);
                 await session.followUp(command.message, command.images);
                 return success(id, "follow_up");
             }
@@ -1224,6 +1421,13 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 const cancelled = !(await session.newSession(options));
                 return success(id, "new_session", { cancelled });
             }
+            case "reload": {
+                await session.reload();
+                return success(id, "reload");
+            }
+            case "dream": {
+                return success(id, "dream", await runDreamForRpc(session, command.args));
+            }
             // =================================================================
             // State
             // =================================================================
@@ -1399,6 +1603,10 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 const path = await session.exportToHtml(command.outputPath);
                 return success(id, "export_html", { path });
             }
+            case "import_jsonl": {
+                const cancelled = !(await session.importFromJsonl(command.inputPath));
+                return success(id, "import_jsonl", { cancelled });
+            }
             case "switch_session": {
                 const cancelled = !(await session.switchSession(command.sessionPath));
                 return success(id, "switch_session", { cancelled });
@@ -1454,7 +1662,7 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 return success(id, "get_messages", { messages: session.messages });
             }
             // =================================================================
-            // Commands (available for invocation via prompt)
+            // Command discovery (resource commands plus client-handled built-ins)
             // =================================================================
             // =================================================================
             // Session Listing
@@ -1528,32 +1736,7 @@ export async function runRpcMode(session, modelFallbackMessage) {
                 return success(id, "get_version", { version: VERSION });
             }
             case "get_commands": {
-                const commands = [];
-                for (const command of session.extensionRunner?.getRegisteredCommands() ?? []) {
-                    commands.push({
-                        name: command.invocationName,
-                        description: command.description,
-                        source: "extension",
-                        sourceInfo: command.sourceInfo,
-                    });
-                }
-                for (const template of session.promptTemplates) {
-                    commands.push({
-                        name: template.name,
-                        description: template.description,
-                        source: "prompt",
-                        sourceInfo: template.sourceInfo,
-                    });
-                }
-                for (const skill of session.getFilteredSkills()) {
-                    commands.push({
-                        name: `skill:${skill.name}`,
-                        description: skill.description,
-                        source: "skill",
-                        sourceInfo: skill.sourceInfo,
-                    });
-                }
-                return success(id, "get_commands", { commands });
+                return success(id, "get_commands", { commands: getCommandsForRpc(session) });
             }
             default: {
                 const unknownCommand = command;