@hansjm10/volt-coding-agent 0.0.0-bootstrap.0 → 0.1.0

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

@@ -0,0 +1,1089 @@
+/**
+ * RPC mode: Headless operation with JSON stdin/stdout protocol.
+ *
+ * Used for embedding the agent in other applications.
+ * Receives commands as JSON on stdin, outputs events and responses as JSON on stdout.
+ *
+ * Protocol:
+ * - Commands: JSON objects with `type` field, optional `id` for correlation
+ * - Responses: JSON objects with `type: "response"`, `command`, `success`, and optional `data`/`error`
+ * - Events: AgentSessionEvent objects streamed as they occur
+ * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
+ */
+import * as crypto from "node:crypto";
+import { extractVisibleTextContent } from "../../core/messages.js";
+import { startModelCatalogWatcher } from "../../core/model-catalog-watcher.js";
+import { flushRawStdout, restoreStdout, takeOverStdout, waitForRawStdoutBackpressure, writeRawStdout, } from "../../core/output-guard.js";
+import { REMOTE_REVIEW_TOOL_NAMES, runReviewWorkflow, } from "../../core/review.js";
+import { getAvailableThemesWithPaths, getThemeByName, setRegisteredThemes, setTheme, setThemeInstance, Theme, theme, } from "../../core/theme/runtime.js";
+import { killTrackedDetachedChildren } from "../../utils/shell.js";
+import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
+import { createRpcErrorResponse, getRpcErrorResponseTarget, HOST_ACTION_REQUESTS_CAPABILITY, handleRpcCommand, } from "./rpc-command-dispatcher.js";
+import { validateRpcCommandPayload } from "./rpc-command-validation.js";
+function parseHostActionResponseDecision(value) {
+    return value === "approved" || value === "denied" || value === "dismissed" ? value : undefined;
+}
+const MAX_PENDING_RPC_INPUT_TASKS = 64;
+function createStdioRpcTransport() {
+    return {
+        write(value) {
+            writeRawStdout(serializeJsonLine(value));
+        },
+        onLine(handler) {
+            return attachJsonlLineReader(process.stdin, handler);
+        },
+        onClose(handler) {
+            const onEnd = () => {
+                handler();
+            };
+            const onError = (error) => {
+                handler(error);
+            };
+            process.stdin.on("end", onEnd);
+            process.stdin.on("error", onError);
+            return () => {
+                process.stdin.off("end", onEnd);
+                process.stdin.off("error", onError);
+            };
+        },
+        waitForBackpressure: waitForRawStdoutBackpressure,
+        flush: flushRawStdout,
+        close() {
+            process.stdin.pause();
+        },
+    };
+}
+class RpcHostActionBridge {
+    interaction = {
+        requestAction: (request, options) => this.requestAction(request, options),
+        updateAction: (update) => this.updateAction(update),
+    };
+    activeAttachment;
+    nextAttachmentId = 0;
+    pendingRequests = new Map();
+    attach(attachment) {
+        const activeAttachment = { ...attachment, id: ++this.nextAttachmentId };
+        this.activeAttachment = activeAttachment;
+        return () => {
+            if (this.activeAttachment?.id === activeAttachment.id) {
+                this.activeAttachment = undefined;
+            }
+        };
+    }
+    getPendingRequests() {
+        return Array.from(this.pendingRequests.values()).map((entry) => entry.request);
+    }
+    cancelAll(message = "RPC mode is shutting down") {
+        const requests = Array.from(this.pendingRequests.values());
+        for (const request of requests) {
+            this.settle(request, { decision: "dismissed", message });
+        }
+    }
+    resolveResponse(response) {
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+            this.settle(pending, { decision: response.decision, message: response.message });
+        }
+    }
+    requestAction(request, requestOptions) {
+        const activeAttachment = this.activeAttachment;
+        if (activeAttachment?.isShuttingDown()) {
+            return Promise.resolve({ decision: "dismissed" });
+        }
+        if (!activeAttachment?.canSend()) {
+            return Promise.resolve({ decision: "unavailable" });
+        }
+        if (requestOptions?.signal?.aborted) {
+            return Promise.resolve({ decision: "dismissed" });
+        }
+        return new Promise((resolve) => {
+            const existing = this.pendingRequests.get(request.id);
+            if (existing) {
+                this.settle(existing, { decision: "dismissed", message: "Host action replaced" });
+            }
+            const rpcRequest = { type: "host_action_request", ...request };
+            let entry;
+            const onAbort = () => {
+                this.settle(entry, { decision: "dismissed", message: "Host action cancelled" });
+            };
+            entry = {
+                request: rpcRequest,
+                resolve,
+                settled: false,
+                signal: requestOptions?.signal,
+                onAbort,
+            };
+            requestOptions?.signal?.addEventListener("abort", onAbort, { once: true });
+            if (request.timeoutMs !== undefined) {
+                entry.timeoutId = setTimeout(() => {
+                    this.settle(entry, { decision: "dismissed", message: "Host action timed out" });
+                }, request.timeoutMs);
+                entry.timeoutId.unref?.();
+            }
+            this.pendingRequests.set(request.id, entry);
+            activeAttachment.output(rpcRequest);
+        });
+    }
+    updateAction(update) {
+        const activeAttachment = this.activeAttachment;
+        if (activeAttachment?.canSend()) {
+            activeAttachment.output({ type: "host_action_update", ...update });
+        }
+    }
+    settle(entry, decision) {
+        if (entry.settled) {
+            return;
+        }
+        entry.settled = true;
+        if (entry.timeoutId) {
+            clearTimeout(entry.timeoutId);
+        }
+        entry.signal?.removeEventListener("abort", entry.onAbort);
+        this.pendingRequests.delete(entry.request.id);
+        entry.resolve(decision);
+    }
+}
+const rpcHostActionBridges = new WeakMap();
+function getRpcHostActionBridge(runtimeHost) {
+    let bridge = rpcHostActionBridges.get(runtimeHost);
+    if (!bridge) {
+        bridge = new RpcHostActionBridge();
+        rpcHostActionBridges.set(runtimeHost, bridge);
+    }
+    return bridge;
+}
+function createRpcSessionEventPayload(event) {
+    if (!isRecord(event) || event.type !== "message_update") {
+        return event;
+    }
+    const assistantMessageEvent = event.assistantMessageEvent;
+    const message = event.message;
+    if (!isRecord(assistantMessageEvent) || assistantMessageEvent.type !== "text_end" || !isRecord(message)) {
+        return event;
+    }
+    if (message.role !== "assistant") {
+        return event;
+    }
+    return {
+        ...event,
+        assistantMessageEvent: {
+            ...assistantMessageEvent,
+            message: extractVisibleTextContent(message.content),
+        },
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toRpcSubagentDefinition(definition) {
+    return {
+        name: definition.name,
+        description: definition.description,
+        source: definition.source,
+        sourceInfo: {
+            source: definition.sourceInfo.source,
+            scope: definition.sourceInfo.scope,
+            origin: definition.sourceInfo.origin,
+        },
+        ...(definition.tools ? { tools: definition.tools } : {}),
+        ...(definition.excludedTools ? { excludedTools: definition.excludedTools } : {}),
+        ...(definition.allowedSubagents ? { allowedSubagents: definition.allowedSubagents } : {}),
+        ...(definition.maxSubagentDepth !== undefined ? { maxSubagentDepth: definition.maxSubagentDepth } : {}),
+        ...(definition.maxChildAgents !== undefined ? { maxChildAgents: definition.maxChildAgents } : {}),
+        ...(definition.model ? { model: definition.model } : {}),
+        ...(definition.thinking ? { thinking: definition.thinking } : {}),
+    };
+}
+class RpcSubagentLifecycle {
+    getSession;
+    output;
+    active = new Map();
+    constructor(options) {
+        this.getSession = options.getSession;
+        this.output = options.output;
+    }
+    list() {
+        return {
+            subagents: this.getSession().resourceLoader.getSubagents().definitions.map(toRpcSubagentDefinition),
+        };
+    }
+    async start(agent, prompt) {
+        const session = this.getSession();
+        const manager = session.getSubagentToolManager();
+        if (!manager) {
+            throw new Error("Subagent manager is not available");
+        }
+        const handle = await manager.startByName(agent, { allowedTools: session.getActiveToolNames() });
+        let entry;
+        const unsubscribe = handle.onEvent((event) => {
+            if (entry?.disposed) {
+                return;
+            }
+            this.output({ type: "subagent_event", subagentId: handle.id, event: createRpcSessionEventPayload(event) });
+        });
+        entry = { handle, unsubscribe, disposed: false };
+        this.active.set(handle.id, entry);
+        void handle.waitForEnd().then((result) => {
+            if (!entry?.disposed) {
+                this.output({ type: "subagent_end", subagentId: handle.id, result });
+            }
+        }, () => undefined);
+        try {
+            await handle.prompt(prompt);
+        }
+        catch (error) {
+            await this.disposeEntry(handle.id, entry).catch(() => undefined);
+            throw error;
+        }
+        return { subagentId: handle.id, sessionId: handle.sessionId };
+    }
+    async abort(subagentId) {
+        const entry = this.getEntry(subagentId);
+        try {
+            await entry.handle.abort();
+        }
+        finally {
+            await this.disposeEntry(subagentId, entry);
+        }
+    }
+    async getState(subagentId) {
+        return this.getEntry(subagentId).handle.getState();
+    }
+    async getTranscript(options) {
+        return this.getEntry(options.subagentId).handle.getTranscript({
+            limit: options.limit,
+            beforeEntryId: options.beforeEntryId,
+        });
+    }
+    async dispose(subagentId) {
+        await this.disposeEntry(subagentId, this.getEntry(subagentId));
+    }
+    async disposeAll() {
+        const entries = Array.from(this.active.entries());
+        await Promise.all(entries.map(([subagentId, entry]) => this.disposeEntry(subagentId, entry).catch(() => undefined)));
+    }
+    getEntry(subagentId) {
+        const entry = this.active.get(subagentId);
+        if (!entry || entry.disposed) {
+            throw new Error(`Subagent ${subagentId} is not active`);
+        }
+        return entry;
+    }
+    async disposeEntry(subagentId, entry) {
+        if (entry.disposed) {
+            return;
+        }
+        entry.disposed = true;
+        this.active.delete(subagentId);
+        entry.unsubscribe();
+        await entry.handle.dispose();
+    }
+}
+/**
+ * Run in RPC mode.
+ * Listens for JSON commands from the transport, outputs events and responses to it.
+ */
+export async function runRpcMode(runtimeHost, options = {}) {
+    if (!options.transport) {
+        takeOverStdout();
+    }
+    const shouldExitProcess = options.exitProcess ?? !options.transport;
+    const shouldDisposeRuntimeOnClose = options.disposeRuntimeOnClose ?? true;
+    const allowUiActionInvocation = options.allowUiActionInvocation ?? true;
+    const requireRemoteSafeUiActions = options.requireRemoteSafeUiActions ?? false;
+    const shouldRestoreStdout = !options.transport && !shouldExitProcess;
+    const transport = options.transport ?? createStdioRpcTransport();
+    const startupAwareTransport = transport;
+    startupAwareTransport.setRpcModeStartupComplete?.(false);
+    // Shutdown request flag
+    let shutdownRequested = false;
+    let shuttingDown = false;
+    const signalCleanupHandlers = [];
+    const pendingWrites = new Set();
+    let hasPendingWriteError = false;
+    let pendingWriteError;
+    let transportFailureShutdownScheduled = false;
+    const toError = (value) => (value instanceof Error ? value : new Error(String(value)));
+    const recordPendingWriteError = (error) => {
+        const writeError = toError(error);
+        if (!hasPendingWriteError) {
+            hasPendingWriteError = true;
+            pendingWriteError = writeError;
+        }
+        return writeError;
+    };
+    const requestTransportFailureShutdown = (error) => {
+        const writeError = recordPendingWriteError(error);
+        if (shuttingDown || transportFailureShutdownScheduled) {
+            return;
+        }
+        transportFailureShutdownScheduled = true;
+        // Defer so in-flight backpressure waits can report the same failure first.
+        setImmediate(() => {
+            transportFailureShutdownScheduled = false;
+            if (shuttingDown) {
+                return;
+            }
+            void shutdown(1, undefined, { error: writeError }).catch(() => { });
+        });
+    };
+    const trackTransportWrite = (result) => {
+        if (!result) {
+            return;
+        }
+        const tracked = Promise.resolve(result)
+            .catch((error) => {
+            requestTransportFailureShutdown(error);
+        })
+            .finally(() => {
+            pendingWrites.delete(tracked);
+        });
+        pendingWrites.add(tracked);
+    };
+    const waitForTransportBackpressure = async () => {
+        while (pendingWrites.size > 0) {
+            await Promise.all(pendingWrites);
+        }
+        if (hasPendingWriteError) {
+            const error = pendingWriteError;
+            hasPendingWriteError = false;
+            pendingWriteError = undefined;
+            throw toError(error);
+        }
+        await transport.waitForBackpressure?.();
+    };
+    let session = runtimeHost.session;
+    let lastNotifiedSession;
+    let unsubscribe;
+    let unsubscribeBackpressure;
+    let stopModelCatalogWatcher = () => { };
+    const output = (obj) => {
+        if (shuttingDown || hasPendingWriteError) {
+            return;
+        }
+        try {
+            trackTransportWrite(transport.write(obj));
+        }
+        catch (writeError) {
+            requestTransportFailureShutdown(writeError);
+        }
+    };
+    const rpcSubagents = new RpcSubagentLifecycle({ getSession: () => session, output });
+    // Pending extension UI requests waiting for response
+    const pendingExtensionRequests = new Map();
+    const cancelPendingExtensionRequests = () => {
+        const requests = Array.from(pendingExtensionRequests.values());
+        pendingExtensionRequests.clear();
+        for (const request of requests) {
+            request.cancel();
+        }
+    };
+    let clientCapabilities = new Set();
+    const hostActionBridge = getRpcHostActionBridge(runtimeHost);
+    const detachHostActionBridge = hostActionBridge.attach({
+        canSend: () => !shuttingDown && clientCapabilities.has(HOST_ACTION_REQUESTS_CAPABILITY),
+        isShuttingDown: () => shuttingDown,
+        output: (message) => output(message),
+    });
+    const cancelPendingHostActionRequests = (message = "RPC mode is shutting down") => {
+        hostActionBridge.cancelAll(message);
+    };
+    const setSessionHostInteraction = (targetSession) => {
+        const sessionWithHostInteraction = targetSession;
+        sessionWithHostInteraction.setHostInteraction?.(hostActionBridge.interaction);
+    };
+    /** Helper for dialog methods with signal/timeout support */
+    function createDialogPromise(opts, defaultValue, request, parseResponse) {
+        if (opts?.signal?.aborted || shuttingDown)
+            return Promise.resolve(defaultValue);
+        const id = crypto.randomUUID();
+        return new Promise((resolve) => {
+            let timeoutId;
+            const cleanup = () => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                opts?.signal?.removeEventListener("abort", onAbort);
+                pendingExtensionRequests.delete(id);
+            };
+            const onAbort = () => {
+                cleanup();
+                resolve(defaultValue);
+            };
+            opts?.signal?.addEventListener("abort", onAbort, { once: true });
+            if (opts?.timeout) {
+                timeoutId = setTimeout(() => {
+                    cleanup();
+                    resolve(defaultValue);
+                }, opts.timeout);
+            }
+            pendingExtensionRequests.set(id, {
+                resolve: (response) => {
+                    cleanup();
+                    resolve(parseResponse(response));
+                },
+                cancel: () => {
+                    cleanup();
+                    resolve(defaultValue);
+                },
+            });
+            output({ type: "extension_ui_request", id, ...request });
+        });
+    }
+    /**
+     * Create an extension UI context that uses the RPC protocol.
+     */
+    const createExtensionUIContext = () => ({
+        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),
+        notify(message, type) {
+            // Fire and forget - no response needed
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "notify",
+                message,
+                notifyType: type,
+            });
+        },
+        onTerminalInput() {
+            // Raw terminal input not supported in RPC mode
+            return () => { };
+        },
+        setStatus(key, text) {
+            // Fire and forget - no response needed
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "setStatus",
+                statusKey: key,
+                statusText: text,
+            });
+        },
+        setWorkingMessage(_message) {
+            // Working message not supported in RPC mode - requires TUI loader access
+        },
+        setWorkingVisible(_visible) {
+            // Working visibility not supported in RPC mode - requires TUI loader access
+        },
+        setWorkingIndicator(_options) {
+            // Working indicator customization not supported in RPC mode - requires TUI loader access
+        },
+        setHiddenThinkingLabel(_label) {
+            // Hidden thinking label not supported in RPC mode - requires TUI message rendering access
+        },
+        setWidget(key, content, options) {
+            // Only support string arrays in RPC mode - factory functions are ignored
+            if (content === undefined || Array.isArray(content)) {
+                output({
+                    type: "extension_ui_request",
+                    id: crypto.randomUUID(),
+                    method: "setWidget",
+                    widgetKey: key,
+                    widgetLines: content,
+                    widgetPlacement: options?.placement,
+                });
+            }
+            // Component factories are not supported in RPC mode - would need TUI access
+        },
+        setFooter(_factory) {
+            // Custom footer not supported in RPC mode - requires TUI access
+        },
+        setHeader(_factory) {
+            // Custom header not supported in RPC mode - requires TUI access
+        },
+        setTitle(title) {
+            // Fire and forget - host can implement terminal title control
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "setTitle",
+                title,
+            });
+        },
+        async custom() {
+            // Custom UI not supported in RPC mode
+            return undefined;
+        },
+        pasteToEditor(text) {
+            // Paste handling not supported in RPC mode - falls back to setEditorText
+            this.setEditorText(text);
+        },
+        setEditorText(text) {
+            // Fire and forget - host can implement editor control
+            output({
+                type: "extension_ui_request",
+                id: crypto.randomUUID(),
+                method: "set_editor_text",
+                text,
+            });
+        },
+        getEditorText() {
+            // Synchronous method can't wait for RPC response
+            // Host should track editor state locally if needed
+            return "";
+        },
+        async editor(title, prefill) {
+            if (shuttingDown) {
+                return undefined;
+            }
+            const id = crypto.randomUUID();
+            return new Promise((resolve) => {
+                const cleanup = () => {
+                    pendingExtensionRequests.delete(id);
+                };
+                pendingExtensionRequests.set(id, {
+                    resolve: (response) => {
+                        cleanup();
+                        if ("cancelled" in response && response.cancelled) {
+                            resolve(undefined);
+                        }
+                        else if ("value" in response) {
+                            resolve(response.value);
+                        }
+                        else {
+                            resolve(undefined);
+                        }
+                    },
+                    cancel: () => {
+                        cleanup();
+                        resolve(undefined);
+                    },
+                });
+                output({ type: "extension_ui_request", id, method: "editor", title, prefill });
+            });
+        },
+        addAutocompleteProvider() {
+            // Autocomplete provider composition is not supported in RPC mode
+        },
+        setEditorComponent() {
+            // Custom editor components not supported in RPC mode
+        },
+        getEditorComponent() {
+            // Custom editor components not supported in RPC mode
+            return undefined;
+        },
+        get theme() {
+            return theme;
+        },
+        getAllThemes() {
+            return getAvailableThemesWithPaths();
+        },
+        getTheme(name) {
+            return getThemeByName(name);
+        },
+        setTheme(themeOrName) {
+            // Applies to this process's theme instance and persists the choice; a
+            // daemon host observes the change and broadcasts a theme_snapshot. No
+            // hot-reload watcher in rpc mode (that is the rendering TUI's job).
+            if (themeOrName instanceof Theme) {
+                setThemeInstance(themeOrName);
+                return { success: true };
+            }
+            const result = setTheme(themeOrName, false);
+            if (result.success && session.settingsManager.getTheme() !== themeOrName) {
+                session.settingsManager.setTheme(themeOrName);
+            }
+            return result;
+        },
+        getToolsExpanded() {
+            // Tool expansion not supported in RPC mode - no TUI
+            return false;
+        },
+        setToolsExpanded(_expanded) {
+            // Tool expansion not supported in RPC mode - no TUI
+        },
+    });
+    // When a phone relays through a running TUI the SAME runtimeHost is shared and
+    // survives this mode (shouldDisposeRuntimeOnClose === false). Capture the TUI's
+    // own rebind handler so it can be restored on exit; otherwise the TUI's session
+    // changes would keep running this RPC-mode handler after the phone disconnects.
+    const previousRebindSession = runtimeHost.getRebindSession?.();
+    runtimeHost.setRebindSession(async () => {
+        await rebindSession();
+    });
+    const restoreRebindSession = () => {
+        if (!shouldDisposeRuntimeOnClose) {
+            runtimeHost.setRebindSession(previousRebindSession);
+        }
+    };
+    const notifySessionChanged = async () => {
+        // Fire on a new session OBJECT, not just a new sessionId. A same-file
+        // drain/reacquire reload produces a fresh AgentSession with the identical
+        // sessionId; consumers (notably the iroh transcript-entry / live-activity
+        // subscriptions) must rekey to the new object or they stay bound to the
+        // disposed one and silently stop delivering. Same-id consumers no-op safely.
+        if (options.onSessionChanged && session !== lastNotifiedSession) {
+            lastNotifiedSession = session;
+            await options.onSessionChanged({ sessionFile: session.sessionFile, sessionId: session.sessionId });
+        }
+    };
+    const rebindSession = async () => {
+        await rpcSubagents.disposeAll();
+        session = runtimeHost.session;
+        if (shuttingDown) {
+            await notifySessionChanged();
+            return;
+        }
+        setSessionHostInteraction(session);
+        // Extension-provided themes resolve by name in rpc mode too (getAllThemes /
+        // getTheme / setTheme), mirroring the TUI's registration at bind time.
+        const resourceThemes = session.resourceLoader?.getThemes?.().themes;
+        if (resourceThemes) {
+            setRegisteredThemes(resourceThemes);
+        }
+        await session.bindExtensions({
+            uiContext: createExtensionUIContext(),
+            mode: "rpc",
+            commandContextActions: {
+                waitForIdle: () => session.waitForIdle(),
+                newSession: async (options) => runtimeHost.newSession(options),
+                fork: async (entryId, forkOptions) => {
+                    const result = await runtimeHost.fork(entryId, forkOptions);
+                    return { cancelled: result.cancelled };
+                },
+                navigateTree: async (targetId, options) => {
+                    const result = await session.navigateTree(targetId, {
+                        summarize: options?.summarize,
+                        customInstructions: options?.customInstructions,
+                        replaceInstructions: options?.replaceInstructions,
+                        label: options?.label,
+                    });
+                    return { cancelled: result.cancelled };
+                },
+                switchSession: async (sessionPath, options) => {
+                    return runtimeHost.switchSession(sessionPath, options);
+                },
+                reload: async () => {
+                    await session.reload();
+                },
+            },
+            shutdownHandler: () => {
+                shutdownRequested = true;
+            },
+            onError: (err) => {
+                output({ type: "extension_error", extensionPath: err.extensionPath, event: err.event, error: err.error });
+            },
+        });
+        if (shuttingDown)
+            return;
+        await notifySessionChanged();
+        unsubscribe?.();
+        unsubscribeBackpressure?.();
+        unsubscribe = session.subscribe((event) => {
+            output(createRpcSessionEventPayload(event));
+        });
+        unsubscribeBackpressure = session.agent.subscribe(async () => {
+            try {
+                await waitForTransportBackpressure();
+            }
+            catch (transportError) {
+                requestTransportFailureShutdown(transportError);
+            }
+        });
+    };
+    const handleReviewWorkflowEvent = (event) => {
+        try {
+            const result = options.onWorkflowEvent?.(event);
+            if (result) {
+                void Promise.resolve(result).catch(() => { });
+            }
+        }
+        catch (error) {
+            void error;
+        }
+        output(event);
+    };
+    const createHostActionContext = () => ({
+        session,
+        abortRun: () => session.abort(),
+        compactContext: (customInstructions) => session.compact(customInstructions),
+        newSession: (newSessionOptions) => runtimeHost.newSession(newSessionOptions),
+        afterSessionSwitch: rebindSession,
+        renameSession: (name) => {
+            session.setSessionName(name);
+        },
+        setThinkingLevel: (level, options) => {
+            session.setThinkingLevel(level, options);
+        },
+        setFastModeRestoreThinkingLevel: (level) => {
+            session.setFastModeRestoreThinkingLevel(level);
+        },
+        runReviewAction: (target, reviewOptions) => runReviewWorkflow({
+            target,
+            cwd: runtimeHost.cwd,
+            agentDir: runtimeHost.services.agentDir,
+            session,
+            newSession: async (newSessionOptions) => {
+                const result = await runtimeHost.newSession(newSessionOptions);
+                if (!result.cancelled) {
+                    await rebindSession();
+                }
+                return result;
+            },
+            authStorage: session.modelRegistry.authStorage,
+            settingsManager: session.settingsManager,
+            tools: REMOTE_REVIEW_TOOL_NAMES,
+            requireProjectTrust: reviewOptions.remote,
+            requireConfirmation: reviewOptions.requireConfirmation,
+            confirm: ({ title, message }) => createExtensionUIContext().confirm(title, message),
+            onEvent: handleReviewWorkflowEvent,
+        }),
+    });
+    const createRpcCommandContext = () => ({
+        session,
+        runtimeHost,
+        options: {
+            allowUiActionInvocation,
+            requireRemoteSafeUiActions,
+            registerPushTarget: options.registerPushTarget,
+        },
+        output,
+        rebindSession,
+        createHostActionContext,
+        setClientCapabilities(features) {
+            clientCapabilities = new Set(features.filter((feature) => typeof feature === "string"));
+            options.onClientCapabilitiesChanged?.(Array.from(clientCapabilities));
+        },
+        getPendingHostActionRequests: () => hostActionBridge.getPendingRequests(),
+        cancelPendingHostActionRequests,
+        subagents: rpcSubagents,
+    });
+    let detachInput = () => { };
+    let detachClose = () => { };
+    let resolveModeClosed;
+    let rejectModeClosed;
+    const modeClosed = new Promise((resolve, reject) => {
+        resolveModeClosed = resolve;
+        rejectModeClosed = reject;
+    });
+    let shutdownPromise;
+    const registerSignalHandlers = () => {
+        const signals = ["SIGTERM"];
+        if (process.platform !== "win32") {
+            signals.push("SIGHUP");
+        }
+        for (const signal of signals) {
+            const handler = () => {
+                killTrackedDetachedChildren();
+                void shutdown(signal === "SIGHUP" ? 129 : 143, signal);
+            };
+            process.on(signal, handler);
+            signalCleanupHandlers.push(() => process.off(signal, handler));
+        }
+    };
+    const cleanupStartupFailure = async () => {
+        shuttingDown = true;
+        try {
+            restoreRebindSession();
+            stopModelCatalogWatcher();
+            cancelPendingExtensionRequests();
+            detachHostActionBridge();
+            await rpcSubagents.disposeAll();
+            if (shouldDisposeRuntimeOnClose) {
+                cancelPendingHostActionRequests();
+            }
+            for (const cleanup of signalCleanupHandlers) {
+                cleanup();
+            }
+            unsubscribe?.();
+            unsubscribeBackpressure?.();
+            if (shouldDisposeRuntimeOnClose) {
+                await runtimeHost.dispose();
+            }
+            detachInput();
+            detachClose();
+        }
+        finally {
+            try {
+                await transport.close();
+            }
+            finally {
+                if (shouldRestoreStdout) {
+                    restoreStdout();
+                }
+            }
+        }
+    };
+    let startupComplete = false;
+    let startupAbortError;
+    const queuedStartupCommandLines = [];
+    /**
+     * Check if shutdown was requested and perform shutdown if so.
+     * Called after handling each command when waiting for the next command.
+     */
+    function shutdown(exitCode = 0, signal, failure) {
+        if (!startupComplete) {
+            void modeClosed.catch(() => { });
+            if (!startupAbortError) {
+                if (failure) {
+                    startupAbortError = toError(failure.error);
+                }
+                else if (signal) {
+                    startupAbortError = new Error(`RPC mode shut down during startup by ${signal}`);
+                }
+                else {
+                    startupAbortError = new Error("RPC mode shut down during startup");
+                }
+            }
+        }
+        stopModelCatalogWatcher();
+        cancelPendingExtensionRequests();
+        detachHostActionBridge();
+        if (shouldDisposeRuntimeOnClose) {
+            cancelPendingHostActionRequests();
+        }
+        if (shuttingDown) {
+            if (shouldExitProcess) {
+                process.exit(exitCode);
+            }
+            return shutdownPromise ?? modeClosed;
+        }
+        shuttingDown = true;
+        shutdownPromise = (async () => {
+            try {
+                let hasShutdownError = failure !== undefined;
+                let shutdownError = failure?.error;
+                try {
+                    restoreRebindSession();
+                    for (const cleanup of signalCleanupHandlers) {
+                        cleanup();
+                    }
+                    unsubscribe?.();
+                    unsubscribeBackpressure?.();
+                    await rpcSubagents.disposeAll();
+                    if (shouldDisposeRuntimeOnClose) {
+                        await runtimeHost.dispose();
+                    }
+                    detachInput();
+                    detachClose();
+                    if (signal !== "SIGTERM" && !hasShutdownError) {
+                        await waitForTransportBackpressure();
+                        await transport.flush?.();
+                    }
+                }
+                catch (error) {
+                    if (!hasShutdownError) {
+                        hasShutdownError = true;
+                        shutdownError = error;
+                    }
+                }
+                finally {
+                    try {
+                        await transport.close();
+                    }
+                    catch (closeError) {
+                        if (!hasShutdownError) {
+                            hasShutdownError = true;
+                            shutdownError = closeError;
+                        }
+                    }
+                    if (shouldRestoreStdout) {
+                        restoreStdout();
+                    }
+                }
+                if (hasShutdownError) {
+                    throw shutdownError;
+                }
+                if (shouldExitProcess) {
+                    process.exit(exitCode);
+                }
+                resolveModeClosed?.();
+            }
+            catch (shutdownError) {
+                rejectModeClosed?.(shutdownError);
+                throw shutdownError;
+            }
+        })();
+        return shutdownPromise;
+    }
+    async function checkShutdownRequested() {
+        if (!shutdownRequested)
+            return;
+        await shutdown();
+    }
+    let commandQueue = Promise.resolve();
+    let pendingInputTaskCount = 0;
+    const handleControlMessage = (parsed) => {
+        // Handle extension UI and host action responses during startup as well as normal operation.
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || !("type" in parsed)) {
+            return false;
+        }
+        if (parsed.type === "extension_ui_response") {
+            const response = parsed;
+            const pending = pendingExtensionRequests.get(response.id);
+            if (pending) {
+                pendingExtensionRequests.delete(response.id);
+                pending.resolve(response);
+            }
+            return true;
+        }
+        if (parsed.type === "host_action_response") {
+            const response = parsed;
+            const decision = parseHostActionResponseDecision(response.decision);
+            if (decision) {
+                hostActionBridge.resolveResponse({ ...response, decision });
+            }
+            return true;
+        }
+        return false;
+    };
+    const handleQueuedParsedInput = async (parsed) => {
+        if (shuttingDown) {
+            return;
+        }
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            const target = getRpcErrorResponseTarget(parsed);
+            output(createRpcErrorResponse(target.id, target.command, `Unknown command: ${target.command}`));
+            await waitForTransportBackpressure();
+            return;
+        }
+        const validationError = validateRpcCommandPayload(parsed);
+        if (validationError) {
+            const target = getRpcErrorResponseTarget(parsed);
+            output(createRpcErrorResponse(target.id, target.command, validationError));
+            await waitForTransportBackpressure();
+            await checkShutdownRequested();
+            return;
+        }
+        const command = parsed;
+        let response;
+        try {
+            response = await handleRpcCommand(command, createRpcCommandContext());
+        }
+        catch (commandError) {
+            const target = getRpcErrorResponseTarget(command);
+            output(createRpcErrorResponse(target.id, target.command, toError(commandError).message));
+            await waitForTransportBackpressure();
+            await checkShutdownRequested();
+            return;
+        }
+        if (response && !shuttingDown) {
+            output(response);
+            await waitForTransportBackpressure();
+        }
+        await checkShutdownRequested();
+    };
+    const enqueueInputTask = (task) => {
+        if (pendingInputTaskCount >= MAX_PENDING_RPC_INPUT_TASKS) {
+            return false;
+        }
+        pendingInputTaskCount++;
+        const runTask = async () => {
+            try {
+                await task();
+            }
+            catch (inputError) {
+                await shutdown(1, undefined, { error: toError(inputError) }).catch(() => { });
+            }
+            finally {
+                pendingInputTaskCount--;
+            }
+        };
+        commandQueue = commandQueue.then(runTask, runTask);
+        void commandQueue.catch(() => { });
+        return true;
+    };
+    const rejectInputTaskOverflow = () => {
+        return shutdown(1, undefined, {
+            error: new Error(`RPC input queue exceeds ${MAX_PENDING_RPC_INPUT_TASKS} tasks`),
+        }).catch(() => { });
+    };
+    const processInputLine = (line) => {
+        if (shuttingDown) {
+            return Promise.resolve();
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch (parseError) {
+            const enqueued = enqueueInputTask(async () => {
+                if (shuttingDown) {
+                    return;
+                }
+                output(createRpcErrorResponse(undefined, "parse", `Failed to parse command: ${parseError instanceof Error ? parseError.message : String(parseError)}`));
+                await waitForTransportBackpressure();
+            });
+            return enqueued ? Promise.resolve() : rejectInputTaskOverflow();
+        }
+        if (handleControlMessage(parsed)) {
+            return Promise.resolve();
+        }
+        if (!startupComplete) {
+            if (queuedStartupCommandLines.length >= MAX_PENDING_RPC_INPUT_TASKS) {
+                return rejectInputTaskOverflow();
+            }
+            queuedStartupCommandLines.push(line);
+            return Promise.resolve();
+        }
+        return enqueueInputTask(() => handleQueuedParsedInput(parsed)) ? Promise.resolve() : rejectInputTaskOverflow();
+    };
+    detachInput = transport.onLine(processInputLine);
+    detachClose =
+        transport.onClose?.((transportError) => {
+            if (transportError) {
+                void shutdown(1, undefined, { error: transportError }).catch(() => { });
+                return;
+            }
+            if (!startupComplete) {
+                void shutdown(0, undefined, { error: new Error("RPC transport closed during startup") }).catch(() => { });
+                return;
+            }
+            void shutdown().catch(() => { });
+        }) ?? (() => { });
+    try {
+        await rebindSession();
+    }
+    catch (startupError) {
+        if (shuttingDown) {
+            try {
+                await shutdownPromise;
+            }
+            catch { }
+            throw startupAbortError ?? startupError;
+        }
+        try {
+            await cleanupStartupFailure();
+        }
+        catch { }
+        throw startupError;
+    }
+    if (shuttingDown) {
+        try {
+            await shutdownPromise;
+        }
+        catch { }
+        throw startupAbortError ?? new Error("RPC mode shut down during startup");
+    }
+    startupComplete = true;
+    startupAwareTransport.setRpcModeStartupComplete?.(true);
+    // Notify connected clients when logins or API keys saved by other volt
+    // processes change the selectable model catalog on disk.
+    stopModelCatalogWatcher = startModelCatalogWatcher({
+        agentDir: runtimeHost.services?.agentDir,
+        getModelRegistry: () => session.modelRegistry,
+        onCatalogChanged: () => output({ type: "models_changed" }),
+    });
+    for (const line of queuedStartupCommandLines.splice(0)) {
+        // These lines were admitted into the bounded pre-startup queue before an
+        // async-aware transport could apply steady-state per-line backpressure.
+        // Preserve detached review workflows by scheduling them onto commandQueue
+        // without holding RPC-mode startup open until a long-running action ends.
+        void processInputLine(line);
+    }
+    if (shouldExitProcess) {
+        registerSignalHandlers();
+    }
+    try {
+        options.onReady?.();
+    }
+    catch (readyError) {
+        void modeClosed.catch(() => { });
+        await shutdown(1, undefined, { error: readyError });
+        throw readyError;
+    }
+    // Keep RPC mode active until shutdown completes.
+    return modeClosed;
+}
+//# sourceMappingURL=rpc-mode.js.map