mcp-ide 0.1.0

package/dist/ink-runner/dist/components/SchemaForm.d.ts

@@ -0,0 +1,7 @@
+import type { FormSchema } from "../types.js";
+interface Props {
+    schema: FormSchema;
+    title?: string;
+}
+export declare function SchemaForm({ schema, title }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ink-runner/dist/components/SchemaForm.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text, useInput, useApp } from "ink";
+import TextInput from "ink-text-input";
+import SelectInput from "ink-select-input";
+import { emitResultWithFile } from "../types.js";
+export function SchemaForm({ schema, title }) {
+    const { exit } = useApp();
+    const [currentIndex, setCurrentIndex] = useState(0);
+    const [answers, setAnswers] = useState({});
+    const [multiSelectState, setMultiSelectState] = useState(new Set());
+    const [multiSelectCursor, setMultiSelectCursor] = useState(0);
+    const [textValue, setTextValue] = useState("");
+    const currentQuestion = schema.questions[currentIndex];
+    const isLastQuestion = currentIndex === schema.questions.length - 1;
+    const isTextInput = !currentQuestion?.options;
+    const isMultiSelect = currentQuestion?.multiSelect;
+    const handleComplete = useCallback((result) => {
+        emitResultWithFile(result); // Writes to file (sync) + stdout
+        exit();
+    }, [exit]);
+    const saveAndAdvance = useCallback((value) => {
+        const key = currentQuestion.header;
+        const newAnswers = { ...answers, [key]: value };
+        setAnswers(newAnswers);
+        if (isLastQuestion) {
+            handleComplete({ action: "accept", answers: newAnswers });
+        }
+        else {
+            setCurrentIndex(currentIndex + 1);
+            setTextValue("");
+            setMultiSelectState(new Set());
+            setMultiSelectCursor(0);
+        }
+    }, [answers, currentIndex, currentQuestion, isLastQuestion, handleComplete]);
+    // Convert options to SelectInput format
+    const selectItems = currentQuestion?.options?.map((opt) => ({
+        label: opt.label + (opt.description ? ` - ${opt.description}` : ""),
+        value: opt.label,
+    })) || [];
+    // Handle keyboard input
+    useInput((input, key) => {
+        if (key.escape) {
+            handleComplete({ action: "cancel" });
+            return;
+        }
+        // Multi-select specific input handling
+        if (isMultiSelect && selectItems.length > 0) {
+            if (key.upArrow) {
+                setMultiSelectCursor(prev => (prev - 1 + selectItems.length) % selectItems.length);
+            }
+            else if (key.downArrow) {
+                setMultiSelectCursor(prev => (prev + 1) % selectItems.length);
+            }
+            else if (input === " ") {
+                // Toggle selection
+                const item = selectItems[multiSelectCursor];
+                setMultiSelectState(prev => {
+                    const newSet = new Set(prev);
+                    if (newSet.has(item.value)) {
+                        newSet.delete(item.value);
+                    }
+                    else {
+                        newSet.add(item.value);
+                    }
+                    return newSet;
+                });
+            }
+            else if (key.return) {
+                saveAndAdvance(Array.from(multiSelectState));
+            }
+        }
+    });
+    // Handle text input submission
+    const handleTextSubmit = useCallback((value) => {
+        if (currentQuestion.validation) {
+            const regex = new RegExp(currentQuestion.validation);
+            if (!regex.test(value)) {
+                // TODO: Show validation error
+                return;
+            }
+        }
+        saveAndAdvance(value);
+    }, [currentQuestion, saveAndAdvance]);
+    // Handle single-select selection
+    const handleSelect = useCallback((item) => {
+        saveAndAdvance(item.value);
+    }, [saveAndAdvance]);
+    if (!currentQuestion) {
+        return _jsx(Text, { color: "red", children: "No questions in schema" });
+    }
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [title && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, color: "cyan", children: title }) })), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { dimColor: true, children: ["Question ", currentIndex + 1, " of ", schema.questions.length] }) }), _jsx(Box, { marginBottom: 1, children: _jsxs(Text, { bold: true, color: "yellow", children: ["[", currentQuestion.header, "]"] }) }), _jsx(Box, { marginBottom: 1, children: _jsx(Text, { children: currentQuestion.question }) }), _jsx(Box, { marginBottom: 1, children: isTextInput ? (_jsxs(Box, { children: [_jsx(Text, { color: "green", children: "> " }), _jsx(TextInput, { value: textValue, onChange: setTextValue, onSubmit: handleTextSubmit, placeholder: currentQuestion.placeholder || "Type your answer...", mask: currentQuestion.inputType === "password" ? "*" : undefined })] })) : isMultiSelect ? (_jsx(Box, { flexDirection: "column", children: selectItems.map((item, idx) => (_jsx(Box, { children: _jsxs(Text, { color: idx === multiSelectCursor ? "cyan" : "white", children: [idx === multiSelectCursor ? "> " : "  ", multiSelectState.has(item.value) ? "[x] " : "[ ] ", item.label] }) }, item.value))) })) : (_jsx(SelectInput, { items: selectItems, onSelect: handleSelect })) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: isTextInput
+                        ? "Press Enter to submit, Escape to cancel"
+                        : isMultiSelect
+                            ? "Use arrows to navigate, Space to toggle, Enter to confirm, Escape to cancel"
+                            : "Use arrows to select, Enter to confirm, Escape to cancel" }) })] }));
+}

package/dist/ink-runner/dist/file-runner.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Sandbox configuration for running custom Ink components
+ */
+export interface SandboxOptions {
+    /** Enable sandboxing via Node.js experimental permissions (default: true) */
+    enabled?: boolean;
+    /** Additional paths to allow reading (default: none) */
+    allowFsRead?: string[];
+    /** Additional paths to allow writing (default: none) */
+    allowFsWrite?: string[];
+}
+/**
+ * Options for running a custom Ink component from a file
+ */
+export interface RunFromFileOptions {
+    /** Path to the component file */
+    filePath: string;
+    /** Optional title to display */
+    title?: string;
+    /** Sandbox configuration */
+    sandbox?: SandboxOptions;
+    /** Interaction ID for file-based result communication */
+    interactionId?: string;
+}
+/**
+ * Bundles and executes a custom Ink component from a file.
+ *
+ * Strategy: Create a single bundled file that includes:
+ * 1. The onComplete callback setup
+ * 2. The user's component (with ink/react bundled in)
+ * 3. The render call
+ *
+ * Security: By default, runs with Node.js experimental permissions to restrict:
+ * - File system access (only temp dir and bundle)
+ * - No network access
+ * - No child process spawning
+ * - No worker threads
+ */
+export declare function runFromFile(filePathOrOptions: string | RunFromFileOptions, title?: string): Promise<void>;

package/dist/ink-runner/dist/file-runner.js

@@ -0,0 +1,276 @@
+import * as esbuild from "esbuild";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { spawn } from "child_process";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { emitResult, getInteractionId, RESULT_FILE_DIR } from "./types.js";
+// ESM compatibility for __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Create require function for resolving module paths from ink-runner's location
+const require = createRequire(import.meta.url);
+// Get ink-runner's node_modules path for explicit resolution
+// When running from plugin: dist/ink-runner/dist/file-runner.js -> dist/ink-runner/node_modules
+// When running from dev: packages/ink-runner/dist/file-runner.js -> packages/ink-runner/node_modules
+const inkRunnerNodeModules = path.resolve(__dirname, "..", "node_modules");
+/**
+ * Bundles and executes a custom Ink component from a file.
+ *
+ * Strategy: Create a single bundled file that includes:
+ * 1. The onComplete callback setup
+ * 2. The user's component (with ink/react bundled in)
+ * 3. The render call
+ *
+ * Security: By default, runs with Node.js experimental permissions to restrict:
+ * - File system access (only temp dir and bundle)
+ * - No network access
+ * - No child process spawning
+ * - No worker threads
+ */
+export async function runFromFile(filePathOrOptions, title) {
+    // Handle both old and new API
+    const options = typeof filePathOrOptions === "string"
+        ? { filePath: filePathOrOptions, title }
+        : filePathOrOptions;
+    const filePath = options.filePath;
+    const displayTitle = options.title;
+    const sandbox = options.sandbox ?? { enabled: true };
+    const interactionId = options.interactionId ?? getInteractionId();
+    // Validate file exists
+    const absFilePath = path.resolve(filePath);
+    if (!fs.existsSync(absFilePath)) {
+        console.error(`Error: File not found: ${absFilePath}`);
+        emitResult({ action: "cancel" });
+        process.exit(1);
+    }
+    const ext = path.extname(absFilePath);
+    if (![".tsx", ".jsx", ".ts", ".js"].includes(ext)) {
+        console.error(`Error: Unsupported file extension: ${ext}`);
+        console.error("Supported extensions: .tsx, .jsx, .ts, .js");
+        emitResult({ action: "cancel" });
+        process.exit(1);
+    }
+    // Create temp files
+    const tempDir = os.tmpdir();
+    const bundleId = Date.now();
+    const entryPath = path.join(tempDir, `ink-runner-entry-${bundleId}.tsx`);
+    const bundledPath = path.join(tempDir, `ink-runner-bundle-${bundleId}.mjs`);
+    try {
+        // Create entry file that wraps the user's component
+        const interactionIdJson = interactionId ? JSON.stringify(interactionId) : "null";
+        const entryScript = `
+import { render } from 'ink';
+import React from 'react';
+import { writeFileSync } from 'fs';
+import Component from ${JSON.stringify(absFilePath)};
+
+// Interaction ID for file-based result communication
+const __interactionId = ${interactionIdJson};
+const __resultFilePath = __interactionId ? '${RESULT_FILE_DIR}/mcp-interaction-' + __interactionId + '.result' : null;
+
+// Set up the onComplete callback
+let __resultEmitted = false;
+globalThis.onComplete = function(result) {
+  if (__resultEmitted) return;
+  __resultEmitted = true;
+  const fullResult = { action: 'accept', result };
+  // Write to file first (synchronous, reliable)
+  if (__resultFilePath) {
+    writeFileSync(__resultFilePath, JSON.stringify(fullResult), 'utf-8');
+  }
+  // Also emit to stdout for backward compatibility
+  console.log('__MCP_RESULT__:' + JSON.stringify(fullResult));
+  setTimeout(() => process.exit(0), 100);
+};
+
+// Validate default export
+if (!Component) {
+  console.error('Error: Component must have a default export');
+  console.log('__MCP_RESULT__:' + JSON.stringify({ action: 'cancel' }));
+  process.exit(1);
+}
+
+// Render the component
+render(React.createElement(Component));
+`;
+        fs.writeFileSync(entryPath, entryScript);
+        // Node.js built-in modules - use node: prefix for ESM
+        const nodeBuiltins = [
+            "assert", "buffer", "child_process", "cluster", "console", "constants",
+            "crypto", "dgram", "dns", "domain", "events", "fs", "http", "https",
+            "module", "net", "os", "path", "perf_hooks", "process", "punycode",
+            "querystring", "readline", "repl", "stream", "string_decoder", "sys",
+            "timers", "tls", "tty", "url", "util", "v8", "vm", "worker_threads", "zlib"
+        ];
+        // Create external list with node: prefix for proper ESM resolution
+        const externals = [
+            ...nodeBuiltins,
+            ...nodeBuiltins.map((m) => `node:${m}`),
+        ];
+        // Banner to provide require() for CJS packages bundled into ESM
+        const banner = `
+import { createRequire as __createRequire } from 'module';
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const require = __createRequire(import.meta.url);
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_fn(__filename);
+`;
+        // Bundle everything together, resolving ink/react from ink-runner's node_modules
+        const result = await esbuild.build({
+            entryPoints: [entryPath],
+            bundle: true,
+            platform: "node",
+            format: "esm",
+            outfile: bundledPath,
+            jsx: "automatic",
+            jsxImportSource: "react",
+            banner: { js: banner },
+            // External node built-ins
+            external: externals,
+            // Suppress warnings
+            logLevel: "error",
+            plugins: [
+                // Resolve ink, react, and react/jsx-runtime from ink-runner's node_modules
+                {
+                    name: "resolve-ink-runner-deps",
+                    setup(build) {
+                        // Resolve bare specifiers for ink and react
+                        build.onResolve({ filter: /^(ink|react|react\/jsx-runtime)$/ }, (args) => {
+                            try {
+                                // Explicitly resolve from ink-runner's node_modules, not from CWD
+                                // This is critical when running as a Claude Code plugin
+                                const modulePath = path.join(inkRunnerNodeModules, args.path);
+                                // For react/jsx-runtime, we need to resolve the actual file
+                                if (args.path === "react/jsx-runtime") {
+                                    const jsxRuntimePath = path.join(inkRunnerNodeModules, "react", "jsx-runtime.js");
+                                    if (fs.existsSync(jsxRuntimePath)) {
+                                        return { path: jsxRuntimePath };
+                                    }
+                                }
+                                // For ink and react, resolve using require.resolve with explicit paths
+                                const pkgJsonPath = path.join(modulePath, "package.json");
+                                if (fs.existsSync(pkgJsonPath)) {
+                                    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+                                    // Use the main/module/exports field to find the entry point
+                                    const entryPoint = pkgJson.module || pkgJson.main || "index.js";
+                                    const resolvedPath = path.join(modulePath, entryPoint);
+                                    if (fs.existsSync(resolvedPath)) {
+                                        return { path: resolvedPath };
+                                    }
+                                }
+                                // Fallback to require.resolve
+                                const resolved = require.resolve(args.path);
+                                return { path: resolved };
+                            }
+                            catch {
+                                return null; // Let esbuild handle it
+                            }
+                        });
+                    },
+                },
+                // Stub out react-devtools-core (optional peer dep)
+                {
+                    name: "stub-react-devtools",
+                    setup(build) {
+                        build.onResolve({ filter: /^react-devtools-core$/ }, () => ({
+                            path: "react-devtools-core",
+                            namespace: "stub",
+                        }));
+                        build.onLoad({ filter: /.*/, namespace: "stub" }, () => ({
+                            contents: "export default {}; export const connectToDevTools = () => {};",
+                        }));
+                    },
+                },
+            ],
+        });
+        if (result.errors.length > 0) {
+            console.error("Bundle errors:");
+            for (const err of result.errors) {
+                console.error(`  ${err.text}`);
+            }
+            emitResult({ action: "cancel" });
+            process.exit(1);
+        }
+        // Show title if provided
+        if (displayTitle) {
+            console.log(`\x1b[36m${displayTitle}\x1b[0m\n`);
+        }
+        // Build node arguments with optional sandbox permissions
+        const nodeArgs = [];
+        if (sandbox.enabled !== false) {
+            // Enable permission model for sandboxing
+            // Node 20-22: --experimental-permission, Node 23+: --permission
+            const nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+            const permissionFlag = nodeVersion >= 23 ? "--permission" : "--experimental-permission";
+            nodeArgs.push(permissionFlag);
+            // Sandbox strategy: Block dangerous capabilities while allowing filesystem
+            // The main threats from untrusted Ink components are:
+            // 1. Network access (data exfiltration) - BLOCKED
+            // 2. Child process spawning (arbitrary code) - BLOCKED
+            // 3. Worker threads (circumvent restrictions) - BLOCKED
+            //
+            // Filesystem: Use wildcard for read (Node module resolution is complex)
+            // but restrict writes to temp directories only
+            // Allow reading all files - Node's module resolution needs broad access
+            // The code is bundled so it won't load external modules anyway
+            nodeArgs.push("--allow-fs-read=*");
+            // Allow writing only to temp directories
+            // Node 25+ requires separate flags for each path instead of comma-separated
+            const allowedWritePaths = [
+                tempDir,
+                "/tmp",
+                "/var/folders",
+                "/private/var/folders",
+                "/private/tmp",
+                ...(sandbox.allowFsWrite ?? []),
+            ];
+            for (const writePath of allowedWritePaths) {
+                nodeArgs.push(`--allow-fs-write=${writePath}`);
+            }
+            // Dangerous capabilities are blocked by not including their flags:
+            // - --allow-child-process (not included = blocked)
+            // - --allow-worker (not included = blocked)
+            // - --allow-addon (not included = blocked)
+            // Network is implicitly denied in permission mode
+        }
+        nodeArgs.push(bundledPath);
+        // Run the bundled file
+        const child = spawn("node", nodeArgs, {
+            stdio: "inherit",
+        });
+        // Wait for child to exit
+        await new Promise((resolve, reject) => {
+            child.on("exit", (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Process exited with code ${code}`));
+                }
+            });
+            child.on("error", reject);
+        });
+    }
+    catch (err) {
+        console.error("Error bundling/running file:");
+        console.error(err instanceof Error ? err.message : String(err));
+        emitResult({ action: "cancel" });
+        process.exit(1);
+    }
+    finally {
+        // Clean up temp files
+        for (const f of [entryPath, bundledPath]) {
+            try {
+                if (fs.existsSync(f)) {
+                    fs.unlinkSync(f);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}

package/dist/ink-runner/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/ink-runner/dist/index.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { SchemaForm } from "./components/SchemaForm.js";
+import { emitResult, emitResultWithFile, setInteractionId } from "./types.js";
+import { runFromFile } from "./file-runner.js";
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            result.help = true;
+        }
+        else if (arg === "--schema" || arg === "-s") {
+            result.schema = args[++i];
+        }
+        else if (arg === "--file" || arg === "-f") {
+            result.file = args[++i];
+        }
+        else if (arg === "--title" || arg === "-t") {
+            result.title = args[++i];
+        }
+        else if (arg === "--no-sandbox") {
+            result.noSandbox = true;
+        }
+        else if (arg === "--interaction-id" || arg === "-i") {
+            result.interactionId = args[++i];
+        }
+    }
+    return result;
+}
+function showHelp() {
+    console.log(`
+ink-runner - Interactive form runner for mcp-ide
+
+Usage:
+  ink-runner --schema '<json>' [--title 'Form Title']
+  ink-runner --file /path/to/component.tsx [--title 'Title']
+  ink-runner -s '<json>' [-t 'Form Title']
+
+Options:
+  -s, --schema <json>   JSON schema defining the form
+  -f, --file <path>     Path to custom Ink component (.tsx/.jsx/.ts/.js)
+  -t, --title <text>    Optional form/component title
+  -h, --help            Show this help message
+
+Either --schema or --file is required.
+
+Schema Format (for --schema mode):
+  {
+    "questions": [
+      {
+        "question": "What is your name?",
+        "header": "Name",
+        "inputType": "text",          // optional: text, textarea, password
+        "placeholder": "Enter name",  // optional
+        "validation": "^[a-zA-Z]+$"   // optional: regex pattern
+      },
+      {
+        "question": "Select your role",
+        "header": "Role",
+        "options": [
+          { "label": "Developer", "description": "Write code" },
+          { "label": "Designer", "description": "Create designs" }
+        ],
+        "multiSelect": false  // optional: true for checkbox-style
+      }
+    ]
+  }
+
+Custom Component Format (for --file mode):
+  - Must have a default export (React component)
+  - Use global 'onComplete(result)' to return data
+  - Example:
+    import { Box, Text, useInput, useApp } from 'ink';
+    function MyComponent() {
+      const { exit } = useApp();
+      useInput((input, key) => {
+        if (key.return) {
+          onComplete({ selected: 'value' });
+          exit();
+        }
+      });
+      return <Text>Press Enter</Text>;
+    }
+    export default MyComponent;
+
+Output:
+  On completion, prints: __MCP_RESULT__:{"action":"accept","answers/result":{...}}
+  Actions: accept, decline, cancel
+
+Controls:
+  - Text input: Type and press Enter
+  - Single select: Arrow keys + Enter
+  - Multi select: Arrow keys + Space to toggle + Enter
+  - Cancel: Escape key
+`);
+}
+async function main() {
+    const args = parseArgs();
+    // Set interaction ID for file-based result communication
+    if (args.interactionId) {
+        setInteractionId(args.interactionId);
+    }
+    if (args.help) {
+        showHelp();
+        process.exit(0);
+    }
+    // Handle SIGINT/SIGTERM
+    process.on("SIGINT", () => {
+        emitResultWithFile({ action: "cancel" });
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        emitResultWithFile({ action: "cancel" });
+        process.exit(0);
+    });
+    // Mode 2: Custom component from file
+    if (args.file) {
+        await runFromFile({
+            filePath: args.file,
+            title: args.title,
+            sandbox: { enabled: !args.noSandbox },
+        });
+        return;
+    }
+    // Mode 1: Schema-based form
+    if (!args.schema) {
+        console.error("Error: Either --schema or --file is required");
+        console.error("Run 'ink-runner --help' for usage");
+        emitResult({ action: "cancel" });
+        process.exit(1);
+    }
+    let schema;
+    try {
+        schema = JSON.parse(args.schema);
+    }
+    catch (err) {
+        console.error("Error: Invalid JSON schema");
+        console.error(err instanceof Error ? err.message : String(err));
+        emitResult({ action: "cancel" });
+        process.exit(1);
+    }
+    if (!schema.questions || !Array.isArray(schema.questions) || schema.questions.length === 0) {
+        console.error("Error: Schema must have at least one question");
+        emitResult({ action: "cancel" });
+        process.exit(1);
+    }
+    const { waitUntilExit } = render(_jsx(SchemaForm, { schema: schema, title: args.title }));
+    await waitUntilExit();
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    emitResult({ action: "cancel" });
+    process.exit(1);
+});

package/dist/ink-runner/dist/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Schema types matching Claude Code's AskUserQuestion format
+ */
+export interface FormOption {
+    label: string;
+    description?: string;
+}
+export interface FormQuestion {
+    question: string;
+    header: string;
+    options?: FormOption[];
+    multiSelect?: boolean;
+    inputType?: "text" | "textarea" | "password";
+    placeholder?: string;
+    validation?: string;
+}
+export interface FormSchema {
+    questions: FormQuestion[];
+}
+export type FormAction = "accept" | "decline" | "cancel";
+export interface FormResult {
+    action: FormAction;
+    answers?: Record<string, string | string[]>;
+}
+/**
+ * Output protocol: Print this to stdout when form completes
+ * The IDE captures this from the tmux pane
+ */
+export declare const RESULT_PREFIX = "__MCP_RESULT__:";
+export declare function emitResult(result: FormResult): void;
+/**
+ * File-based result communication (more reliable than stdout)
+ * Result files are stored in /tmp with pattern: mcp-interaction-{id}.result
+ */
+export declare const RESULT_FILE_DIR = "/tmp";
+export declare function getResultFilePath(interactionId: string): string;
+/**
+ * Write result to file synchronously - guarantees write completes before process exit
+ */
+export declare function writeResultFile(interactionId: string, result: FormResult): void;
+export declare function setInteractionId(id: string): void;
+export declare function getInteractionId(): string | undefined;
+/**
+ * Emit result via both file (reliable) and stdout (fallback/debugging)
+ */
+export declare function emitResultWithFile(result: FormResult): void;

package/dist/ink-runner/dist/types.js

@@ -0,0 +1,45 @@
+import { writeFileSync } from "fs";
+/**
+ * Output protocol: Print this to stdout when form completes
+ * The IDE captures this from the tmux pane
+ */
+export const RESULT_PREFIX = "__MCP_RESULT__:";
+export function emitResult(result) {
+    console.log(`${RESULT_PREFIX}${JSON.stringify(result)}`);
+}
+/**
+ * File-based result communication (more reliable than stdout)
+ * Result files are stored in /tmp with pattern: mcp-interaction-{id}.result
+ */
+export const RESULT_FILE_DIR = "/tmp";
+export function getResultFilePath(interactionId) {
+    return `${RESULT_FILE_DIR}/mcp-interaction-${interactionId}.result`;
+}
+/**
+ * Write result to file synchronously - guarantees write completes before process exit
+ */
+export function writeResultFile(interactionId, result) {
+    const filePath = getResultFilePath(interactionId);
+    writeFileSync(filePath, JSON.stringify(result), "utf-8");
+}
+/**
+ * Global interaction ID - set from command line args
+ */
+let _interactionId;
+export function setInteractionId(id) {
+    _interactionId = id;
+}
+export function getInteractionId() {
+    return _interactionId;
+}
+/**
+ * Emit result via both file (reliable) and stdout (fallback/debugging)
+ */
+export function emitResultWithFile(result) {
+    // Write to file first (synchronous, guaranteed)
+    if (_interactionId) {
+        writeResultFile(_interactionId, result);
+    }
+    // Also emit to stdout for backward compatibility and debugging
+    emitResult(result);
+}