@openeryc/pi-coding-agent 0.75.11 → 0.75.13

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

@@ -1,609 +0,0 @@
-/**
- * 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 { takeOverStdout, writeRawStdout } from "../../core/output-guard.js";
-import { killTrackedDetachedChildren } from "../../utils/shell.js";
-import { theme } from "../interactive/theme/theme.js";
-import { attachJsonlLineReader, serializeJsonLine } from "./jsonl.js";
-/**
- * Run in RPC mode.
- * Listens for JSON commands on stdin, outputs events and responses on stdout.
- */
-export async function runRpcMode(runtimeHost) {
-    takeOverStdout();
-    let session = runtimeHost.session;
-    let unsubscribe;
-    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 };
-    };
-    // Pending extension UI requests waiting for response
-    const pendingExtensionRequests = new Map();
-    // Shutdown request flag
-    let shutdownRequested = false;
-    let shuttingDown = false;
-    const signalCleanupHandlers = [];
-    /** Helper for dialog methods with signal/timeout support */
-    function createDialogPromise(opts, defaultValue, request, parseResponse) {
-        if (opts?.signal?.aborted)
-            return Promise.resolve(defaultValue);
-        const id = crypto.randomUUID();
-        return new Promise((resolve, reject) => {
-            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));
-                },
-                reject,
-            });
-            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) {
-            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 });
-            });
-        },
-        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 [];
-        },
-        getTheme(_name) {
-            return undefined;
-        },
-        setTheme(_theme) {
-            // Theme switching not supported in RPC mode
-            return { success: false, error: "Theme switching not supported in RPC mode" };
-        },
-        getToolsExpanded() {
-            // Tool expansion not supported in RPC mode - no TUI
-            return false;
-        },
-        setToolsExpanded(_expanded) {
-            // Tool expansion not supported in RPC mode - no TUI
-        },
-    });
-    runtimeHost.setRebindSession(async () => {
-        await rebindSession();
-    });
-    const rebindSession = async () => {
-        session = runtimeHost.session;
-        await session.bindExtensions({
-            uiContext: createExtensionUIContext(),
-            commandContextActions: {
-                waitForIdle: () => session.agent.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 });
-            },
-        });
-        unsubscribe?.();
-        unsubscribe = session.subscribe((event) => {
-            output(event);
-        });
-    };
-    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);
-            };
-            process.on(signal, handler);
-            signalCleanupHandlers.push(() => process.off(signal, handler));
-        }
-    };
-    await rebindSession();
-    registerSignalHandlers();
-    // Handle a single command
-    const handleCommand = async (command) => {
-        const id = command.id;
-        switch (command.type) {
-            // =================================================================
-            // Prompting
-            // =================================================================
-            case "prompt": {
-                // Start prompt handling immediately, but emit the authoritative response only after
-                // prompt preflight succeeds. Queued and immediately handled prompts also count as success.
-                let preflightSucceeded = false;
-                void session
-                    .prompt(command.message, {
-                    images: command.images,
-                    streamingBehavior: command.streamingBehavior,
-                    source: "rpc",
-                    preflightResult: (didSucceed) => {
-                        if (didSucceed) {
-                            preflightSucceeded = true;
-                            output(success(id, "prompt"));
-                        }
-                    },
-                })
-                    .catch((e) => {
-                    if (!preflightSucceeded) {
-                        output(error(id, "prompt", e.message));
-                    }
-                });
-                return undefined;
-            }
-            case "steer": {
-                await session.steer(command.message, command.images);
-                return success(id, "steer");
-            }
-            case "follow_up": {
-                await session.followUp(command.message, command.images);
-                return success(id, "follow_up");
-            }
-            case "abort": {
-                await session.abort();
-                return success(id, "abort");
-            }
-            case "new_session": {
-                const options = command.parentSession ? { parentSession: command.parentSession } : undefined;
-                const result = await runtimeHost.newSession(options);
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
-                return success(id, "new_session", result);
-            }
-            // =================================================================
-            // State
-            // =================================================================
-            case "get_state": {
-                const state = {
-                    model: session.model,
-                    thinkingLevel: session.thinkingLevel,
-                    isStreaming: session.isStreaming,
-                    isCompacting: session.isCompacting,
-                    steeringMode: session.steeringMode,
-                    followUpMode: session.followUpMode,
-                    sessionFile: session.sessionFile,
-                    sessionId: session.sessionId,
-                    sessionName: session.sessionName,
-                    autoCompactionEnabled: session.autoCompactionEnabled,
-                    messageCount: session.messages.length,
-                    pendingMessageCount: session.pendingMessageCount,
-                };
-                return success(id, "get_state", state);
-            }
-            // =================================================================
-            // Model
-            // =================================================================
-            case "set_model": {
-                const models = await session.modelRegistry.getAvailable();
-                const model = models.find((m) => m.provider === command.provider && m.id === command.modelId);
-                if (!model) {
-                    return error(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
-                }
-                await session.setModel(model);
-                return success(id, "set_model", model);
-            }
-            case "cycle_model": {
-                const result = await session.cycleModel();
-                if (!result) {
-                    return success(id, "cycle_model", null);
-                }
-                return success(id, "cycle_model", result);
-            }
-            case "get_available_models": {
-                const models = await session.modelRegistry.getAvailable();
-                return success(id, "get_available_models", { models });
-            }
-            // =================================================================
-            // Thinking
-            // =================================================================
-            case "set_thinking_level": {
-                session.setThinkingLevel(command.level);
-                return success(id, "set_thinking_level");
-            }
-            case "cycle_thinking_level": {
-                const level = session.cycleThinkingLevel();
-                if (!level) {
-                    return success(id, "cycle_thinking_level", null);
-                }
-                return success(id, "cycle_thinking_level", { level });
-            }
-            // =================================================================
-            // Queue Modes
-            // =================================================================
-            case "set_steering_mode": {
-                session.setSteeringMode(command.mode);
-                return success(id, "set_steering_mode");
-            }
-            case "set_follow_up_mode": {
-                session.setFollowUpMode(command.mode);
-                return success(id, "set_follow_up_mode");
-            }
-            // =================================================================
-            // Compaction
-            // =================================================================
-            case "compact": {
-                const result = await session.compact(command.customInstructions);
-                return success(id, "compact", result);
-            }
-            case "set_auto_compaction": {
-                session.setAutoCompactionEnabled(command.enabled);
-                return success(id, "set_auto_compaction");
-            }
-            // =================================================================
-            // Retry
-            // =================================================================
-            case "set_auto_retry": {
-                session.setAutoRetryEnabled(command.enabled);
-                return success(id, "set_auto_retry");
-            }
-            case "abort_retry": {
-                session.abortRetry();
-                return success(id, "abort_retry");
-            }
-            // =================================================================
-            // Bash
-            // =================================================================
-            case "bash": {
-                const result = await session.executeBash(command.command);
-                return success(id, "bash", result);
-            }
-            case "abort_bash": {
-                session.abortBash();
-                return success(id, "abort_bash");
-            }
-            // =================================================================
-            // Session
-            // =================================================================
-            case "get_session_stats": {
-                const stats = session.getSessionStats();
-                return success(id, "get_session_stats", stats);
-            }
-            case "export_html": {
-                const path = await session.exportToHtml(command.outputPath);
-                return success(id, "export_html", { path });
-            }
-            case "switch_session": {
-                const result = await runtimeHost.switchSession(command.sessionPath);
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
-                return success(id, "switch_session", result);
-            }
-            case "fork": {
-                const result = await runtimeHost.fork(command.entryId);
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
-                return success(id, "fork", { text: result.selectedText, cancelled: result.cancelled });
-            }
-            case "clone": {
-                const leafId = session.sessionManager.getLeafId();
-                if (!leafId) {
-                    return error(id, "clone", "Cannot clone session: no current entry selected");
-                }
-                const result = await runtimeHost.fork(leafId, { position: "at" });
-                if (!result.cancelled) {
-                    await rebindSession();
-                }
-                return success(id, "clone", { cancelled: result.cancelled });
-            }
-            case "get_fork_messages": {
-                const messages = session.getUserMessagesForForking();
-                return success(id, "get_fork_messages", { messages });
-            }
-            case "get_last_assistant_text": {
-                const text = session.getLastAssistantText();
-                return success(id, "get_last_assistant_text", { text });
-            }
-            case "set_session_name": {
-                const name = command.name.trim();
-                if (!name) {
-                    return error(id, "set_session_name", "Session name cannot be empty");
-                }
-                session.setSessionName(name);
-                return success(id, "set_session_name");
-            }
-            case "set_session_goal": {
-                const goal = command.goal.trim();
-                if (!goal) {
-                    return error(id, "set_session_goal", "Session goal cannot be empty");
-                }
-                session.setSessionGoal(goal);
-                return success(id, "set_session_goal");
-            }
-            // =================================================================
-            // Messages
-            // =================================================================
-            case "get_messages": {
-                return success(id, "get_messages", { messages: session.messages });
-            }
-            // =================================================================
-            // Commands (available for invocation via prompt)
-            // =================================================================
-            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.resourceLoader.getSkills().skills) {
-                    commands.push({
-                        name: `skill:${skill.name}`,
-                        description: skill.description,
-                        source: "skill",
-                        sourceInfo: skill.sourceInfo,
-                    });
-                }
-                return success(id, "get_commands", { commands });
-            }
-            default: {
-                const unknownCommand = command;
-                return error(undefined, unknownCommand.type, `Unknown command: ${unknownCommand.type}`);
-            }
-        }
-    };
-    /**
-     * Check if shutdown was requested and perform shutdown if so.
-     * Called after handling each command when waiting for the next command.
-     */
-    let detachInput = () => { };
-    async function shutdown(exitCode = 0) {
-        if (shuttingDown) {
-            process.exit(exitCode);
-        }
-        shuttingDown = true;
-        for (const cleanup of signalCleanupHandlers) {
-            cleanup();
-        }
-        unsubscribe?.();
-        await runtimeHost.dispose();
-        detachInput();
-        process.stdin.pause();
-        process.exit(exitCode);
-    }
-    async function checkShutdownRequested() {
-        if (!shutdownRequested)
-            return;
-        await shutdown();
-    }
-    const handleInputLine = async (line) => {
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch (parseError) {
-            output(error(undefined, "parse", `Failed to parse command: ${parseError instanceof Error ? parseError.message : String(parseError)}`));
-            return;
-        }
-        // Handle extension UI responses
-        if (typeof parsed === "object" &&
-            parsed !== null &&
-            "type" in parsed &&
-            parsed.type === "extension_ui_response") {
-            const response = parsed;
-            const pending = pendingExtensionRequests.get(response.id);
-            if (pending) {
-                pendingExtensionRequests.delete(response.id);
-                pending.resolve(response);
-            }
-            return;
-        }
-        const command = parsed;
-        try {
-            const response = await handleCommand(command);
-            if (response) {
-                output(response);
-            }
-            await checkShutdownRequested();
-        }
-        catch (commandError) {
-            output(error(command.id, command.type, commandError instanceof Error ? commandError.message : String(commandError)));
-        }
-    };
-    const onInputEnd = () => {
-        void shutdown();
-    };
-    process.stdin.on("end", onInputEnd);
-    detachInput = (() => {
-        const detachJsonl = attachJsonlLineReader(process.stdin, (line) => {
-            void handleInputLine(line);
-        });
-        return () => {
-            detachJsonl();
-            process.stdin.off("end", onInputEnd);
-        };
-    })();
-    // Keep process alive forever
-    return new Promise(() => { });
-}
-//# sourceMappingURL=rpc-mode.js.map