@dreb/coding-agent 2.46.0 → 2.48.0

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

@@ -855,77 +855,105 @@ export async function navigateTreeForRpc(session, targetId, options) {
         ...(result.editorText !== undefined ? { editorText: result.editorText } : {}),
     };
 }
-/**
- * Run in RPC mode.
- * Listens for JSON commands on stdin, outputs events and responses on stdout.
- */
-export async function runRpcMode(session, modelFallbackMessage) {
-    takeOverStdout();
-    const output = (obj) => {
-        writeRawStdout(serializeJsonLine(obj));
-    };
-    const success = (id, command, data) => {
-        if (data === undefined) {
-            return { id, type: "response", command, success: true };
-        }
-        return { id, type: "response", command, success: true, data };
-    };
-    const error = (id, command, message) => {
-        return { id, type: "response", command, success: false, error: message };
-    };
-    if (session.sessionFile && session.messages.length > 0) {
-        const rehydratedCount = rehydrateBackgroundAgentsFromDisk(session.sessionFile);
-        if (rehydratedCount > 0) {
-            console.error(`[rpc] Rehydrated ${rehydratedCount} background subagent${rehydratedCount === 1 ? "" : "s"} from disk`);
-        }
-    }
-    // Pending extension UI requests waiting for response
-    const pendingExtensionRequests = new Map();
-    // Shutdown request flag
-    let shutdownRequested = false;
-    let dailyCostTracker;
-    let dailyCostTrackerPrimed = false;
+export function createRpcExtensionUIContext(output, pendingExtensionRequests, onAskStop = () => { }) {
     /** Helper for dialog methods with signal/timeout support */
-    function createDialogPromise(opts, defaultValue, request, parseResponse) {
+    function createDialogPromise(opts, defaultValue, request, parseResponse, onTimeout) {
         if (opts?.signal?.aborted)
             return Promise.resolve(defaultValue);
         const id = crypto.randomUUID();
         return new Promise((resolve, reject) => {
             let timeoutId;
+            let settled = false;
             const cleanup = () => {
+                if (settled)
+                    return false;
+                settled = true;
                 if (timeoutId)
                     clearTimeout(timeoutId);
                 opts?.signal?.removeEventListener("abort", onAbort);
                 pendingExtensionRequests.delete(id);
+                output({ type: "extension_ui_response_handled", id });
+                return true;
             };
             const onAbort = () => {
-                cleanup();
+                if (!cleanup())
+                    return;
                 resolve(defaultValue);
             };
             opts?.signal?.addEventListener("abort", onAbort, { once: true });
             if (opts?.timeout) {
                 timeoutId = setTimeout(() => {
-                    cleanup();
+                    if (!cleanup())
+                        return;
+                    onTimeout?.();
                     resolve(defaultValue);
                 }, opts.timeout);
             }
+            const rpcRequest = {
+                type: "extension_ui_request",
+                id,
+                ...request,
+            };
             pendingExtensionRequests.set(id, {
+                request: rpcRequest,
                 resolve: (response) => {
-                    cleanup();
-                    resolve(parseResponse(response));
+                    if (!cleanup())
+                        return;
+                    try {
+                        resolve(parseResponse(response));
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                },
+                reject: (error) => {
+                    if (!cleanup())
+                        return;
+                    reject(error);
                 },
-                reject,
             });
-            output({ type: "extension_ui_request", id, ...request });
+            output(rpcRequest);
         });
     }
     /**
      * Create an extension UI context that uses the RPC protocol.
      */
-    const createExtensionUIContext = () => ({
+    return {
         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, {
+            method: "ask",
+            title: request.title ?? "Question",
+            question: request.question,
+            options: request.options,
+            allowFreeText: request.allowFreeText,
+            multiSelect: request.multiSelect,
+            multiline: request.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.
+            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;
+            }
+            return { selected, customText };
+        }, onAskStop),
         notify(message, type) {
             // Fire and forget - no response needed
             output({
@@ -1004,26 +1032,11 @@ export async function runRpcMode(session, modelFallbackMessage) {
             // Host should track editor state locally if needed
             return "";
         },
-        async editor(title, prefill) {
-            const id = crypto.randomUUID();
-            return new Promise((resolve, reject) => {
-                pendingExtensionRequests.set(id, {
-                    resolve: (response) => {
-                        if ("cancelled" in response && response.cancelled) {
-                            resolve(undefined);
-                        }
-                        else if ("value" in response) {
-                            resolve(response.value);
-                        }
-                        else {
-                            resolve(undefined);
-                        }
-                    },
-                    reject,
-                });
-                output({ type: "extension_ui_request", id, method: "editor", title, prefill });
-            });
-        },
+        editor: (title, prefill) => createDialogPromise(undefined, undefined, { method: "editor", title, prefill }, (response) => "cancelled" in response && response.cancelled
+            ? undefined
+            : "value" in response
+                ? response.value
+                : undefined),
         setEditorComponent() {
             // Custom editor components not supported in RPC mode
         },
@@ -1047,7 +1060,45 @@ export async function runRpcMode(session, modelFallbackMessage) {
         setToolsExpanded(_expanded) {
             // Tool expansion not supported in RPC mode - no TUI
         },
-    });
+    };
+}
+/** Cancel every pending dialog during RPC host teardown. */
+export function cancelPendingRpcExtensionRequests(pendingExtensionRequests) {
+    for (const [id, pending] of [...pendingExtensionRequests]) {
+        pending.resolve({ type: "extension_ui_response", id, cancelled: true });
+    }
+}
+export async function runRpcMode(session, modelFallbackMessage) {
+    takeOverStdout();
+    const output = (obj) => {
+        writeRawStdout(serializeJsonLine(obj));
+    };
+    const success = (id, command, data) => {
+        if (data === undefined) {
+            return { id, type: "response", command, success: true };
+        }
+        return { id, type: "response", command, success: true, data };
+    };
+    const error = (id, command, message) => {
+        return { id, type: "response", command, success: false, error: message };
+    };
+    if (session.sessionFile && session.messages.length > 0) {
+        const rehydratedCount = rehydrateBackgroundAgentsFromDisk(session.sessionFile);
+        if (rehydratedCount > 0) {
+            console.error(`[rpc] Rehydrated ${rehydratedCount} background subagent${rehydratedCount === 1 ? "" : "s"} from disk`);
+        }
+    }
+    // Pending extension UI requests waiting for response. Keep the emitted
+    // payload alongside its callbacks so recovery snapshots can reconstruct the
+    // answer UI after a Dashboard reload or replay gap.
+    const pendingExtensionRequests = new Map();
+    // Shutdown request flag
+    let shutdownRequested = false;
+    let dailyCostTracker;
+    let dailyCostTrackerPrimed = false;
+    // Extension UI context uses the RPC protocol; built by a module-scope
+    // factory so the dialog round trip is unit-testable (see createRpcExtensionUIContext).
+    const createExtensionUIContext = () => createRpcExtensionUIContext(output, pendingExtensionRequests, () => void session.abort());
     // Set up extensions with RPC-based UI context
     await session.bindExtensions({
         uiContext: createExtensionUIContext(),
@@ -1186,6 +1237,7 @@ export async function runRpcMode(session, modelFallbackMessage) {
                     state: getStateForRpc(session, modelFallbackMessage),
                     messages: getDashboardMessagesForRpc(session),
                     backgroundAgents: getBackgroundAgents().map(toRpcBackgroundAgentInfo),
+                    pendingExtensionUiRequests: [...pendingExtensionRequests.values()].map(({ request }) => request),
                 };
                 return success(id, "get_dashboard_snapshot", data);
             }
@@ -1515,6 +1567,7 @@ export async function runRpcMode(session, modelFallbackMessage) {
      */
     let detachInput = () => { };
     async function shutdown() {
+        cancelPendingRpcExtensionRequests(pendingExtensionRequests);
         const currentRunner = session.extensionRunner;
         if (currentRunner?.hasHandlers("session_shutdown")) {
             await currentRunner.emit({ type: "session_shutdown" });