mcp-ide 0.1.0

package/dist/index.js

@@ -0,0 +1,1124 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import * as path from "path";
+import { loadConfig, configExists } from "./config.js";
+import { ProcessManager } from "./process-manager.js";
+import { TmuxManager, EmbeddedTmuxManager, isTmuxAvailable, listIdeSessions, isInsideTmux } from "./tmux-manager.js";
+import { InteractionManager } from "./interaction-manager.js";
+// Parse CLI arguments
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let config;
+    let sessionName;
+    // Check for subcommand
+    const firstArg = args[0];
+    if (!firstArg || firstArg.startsWith("-")) {
+        // No subcommand, default to server mode
+        // Parse remaining flags
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg === "--help" || arg === "-h") {
+                return { command: "help" };
+            }
+            else if (arg === "--config" || arg === "-c") {
+                config = args[++i];
+                if (!config) {
+                    console.error("Error: --config requires a path argument");
+                    process.exit(1);
+                }
+            }
+        }
+        return { command: "server", config };
+    }
+    // Handle subcommands
+    switch (firstArg) {
+        case "sessions":
+            return { command: "sessions" };
+        case "attach":
+            sessionName = args[1];
+            return { command: "attach", sessionName };
+        case "help":
+        case "--help":
+        case "-h":
+            return { command: "help" };
+        default:
+            // Unknown arg, might be a flag for server mode
+            if (firstArg.startsWith("-")) {
+                for (let i = 0; i < args.length; i++) {
+                    const arg = args[i];
+                    if (arg === "--help" || arg === "-h") {
+                        return { command: "help" };
+                    }
+                    else if (arg === "--config" || arg === "-c") {
+                        config = args[++i];
+                    }
+                }
+                return { command: "server", config };
+            }
+            console.error(`Unknown command: ${firstArg}`);
+            console.error("Run 'mcp-ide help' for usage");
+            process.exit(1);
+    }
+}
+function showHelp() {
+    console.log(`
+mcp-ide - MCP server for managing development processes
+
+Usage:
+  mcp-ide [options]           Start MCP server (default)
+  mcp-ide sessions            List active IDE tmux sessions
+  mcp-ide attach [name]       Attach to a tmux session
+
+Options:
+  -h, --help              Show this help message
+  -c, --config <path>     Path to mide.yaml config file
+
+Configuration:
+  Create an mide.yaml file in your project root to define processes.
+  Or specify a custom path with --config.
+
+tmux Integration:
+  Processes run in tmux panes for live output viewing.
+  Use 'mcp-ide attach' to see process output in your terminal.
+
+Example mide.yaml:
+  processes:
+    api:
+      command: npm run dev
+      port: 3000
+    frontend:
+      command: npm run dev
+      cwd: ./frontend
+      port: 5173
+`);
+}
+/**
+ * List all active IDE sessions
+ */
+async function commandSessions() {
+    const sessions = await listIdeSessions();
+    if (sessions.length === 0) {
+        console.log("No active IDE sessions found.");
+        console.log("\nStart a session by running 'mcp-ide' in a project directory with mide.yaml");
+        return;
+    }
+    console.log("IDE SESSIONS");
+    console.log("============");
+    console.log("");
+    for (const session of sessions) {
+        const age = formatAge(session.created);
+        console.log(`  ${session.name.padEnd(30)} ${session.windows} window(s)   ${age}`);
+    }
+    console.log("");
+    console.log("Use: mcp-ide attach <name>");
+}
+/**
+ * Attach to a tmux session
+ */
+async function commandAttach(sessionName) {
+    const sessions = await listIdeSessions();
+    if (sessions.length === 0) {
+        console.error("No active IDE sessions found.");
+        process.exit(1);
+    }
+    let targetSession;
+    if (sessionName) {
+        // Find exact or prefix match
+        const match = sessions.find((s) => s.name === sessionName || s.name.startsWith(sessionName));
+        if (!match) {
+            console.error(`Session "${sessionName}" not found.`);
+            console.error("\nAvailable sessions:");
+            sessions.forEach((s) => console.error(`  ${s.name}`));
+            process.exit(1);
+        }
+        targetSession = match.name;
+    }
+    else {
+        // Auto-detect: try to find session for current directory
+        const projectName = path.basename(process.cwd());
+        const expectedName = `mide-${projectName.toLowerCase().replace(/[^a-z0-9_-]/g, "-")}`;
+        const match = sessions.find((s) => s.name === expectedName || s.name.startsWith(expectedName));
+        if (match) {
+            targetSession = match.name;
+        }
+        else if (sessions.length === 1) {
+            // Only one session, use it
+            targetSession = sessions[0].name;
+        }
+        else {
+            console.error("Multiple sessions available. Please specify which one:");
+            sessions.forEach((s) => console.error(`  mcp-ide attach ${s.name}`));
+            process.exit(1);
+        }
+    }
+    console.log(`Attaching to ${targetSession}...`);
+    // Create a temporary TmuxManager just to attach
+    const tmux = new TmuxManager(targetSession.replace(/^mide-/, ""));
+    tmux.sessionName = targetSession;
+    tmux.attach();
+}
+function formatAge(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}
+// Process tool schemas
+const StartProcessSchema = z.object({
+    name: z.string().describe("Process name from mide.yaml"),
+    args: z.string().optional().describe("Additional arguments to pass to the command"),
+    force: z.boolean().optional().describe("Kill any process using the port before starting"),
+});
+const StopProcessSchema = z.object({
+    name: z.string().describe("Process name to stop"),
+});
+const RestartProcessSchema = z.object({
+    name: z.string().describe("Process name to restart"),
+});
+const GetStatusSchema = z.object({
+    name: z.string().describe("Process name"),
+});
+const GetLogsSchema = z.object({
+    name: z.string().describe("Process name"),
+    stream: z.enum(["stdout", "stderr", "combined"]).optional().describe("Log stream (default: combined)"),
+    tail: z.number().optional().describe("Number of lines to return (default: 100)"),
+});
+const GetUrlSchema = z.object({
+    name: z.string().describe("Process name"),
+});
+// Dynamic terminal schemas
+const CreatePaneSchema = z.object({
+    name: z.string().describe("Unique name for the pane"),
+    command: z.string().describe("Command to run in the pane"),
+    group: z.string().optional().describe("Group to place the pane in (default: 'dynamic')"),
+    mode: z.enum(["embedded", "standalone"]).optional().describe("Tmux mode: embedded (current session) or standalone (separate IDE session)"),
+});
+const RemovePaneSchema = z.object({
+    name: z.string().describe("Name of the pane to remove"),
+});
+// Test blocking tool schema (for validating progress heartbeats)
+const TestBlockingSchema = z.object({
+    duration_seconds: z.number().describe("How long to block in seconds"),
+    heartbeat_interval_ms: z.number().optional().describe("Progress heartbeat interval in ms (default: 25000)"),
+});
+// Interaction tool schemas
+const FormQuestionSchema = z.object({
+    question: z.string().describe("The question to ask"),
+    header: z.string().describe("Short label for the question (max 12 chars)"),
+    options: z.array(z.object({
+        label: z.string().describe("Option label"),
+        description: z.string().optional().describe("Option description"),
+    })).optional().describe("Options for selection (if not provided, renders text input)"),
+    multiSelect: z.boolean().optional().describe("Allow multiple selections"),
+    inputType: z.enum(["text", "textarea", "password"]).optional().describe("Input type for text questions"),
+    placeholder: z.string().optional().describe("Placeholder text for input"),
+    validation: z.string().optional().describe("Regex pattern for validation"),
+});
+const FormSchemaSchema = z.object({
+    questions: z.array(FormQuestionSchema).min(1).describe("Questions to ask"),
+});
+const ShowInteractionSchema = z.object({
+    schema: FormSchemaSchema.optional().describe("Form schema (AskUserQuestion-compatible)"),
+    ink_file: z.string().optional().describe("Path to custom Ink component file (.tsx/.jsx)"),
+    title: z.string().optional().describe("Form title"),
+    group: z.string().optional().describe("tmux layout group"),
+    timeout_ms: z.number().optional().describe("Auto-cancel after N ms"),
+    block: z.boolean().optional().describe("Block until done (default: true)"),
+});
+const GetInteractionResultSchema = z.object({
+    interaction_id: z.string().describe("Interaction ID from non-blocking show_interaction"),
+    block: z.boolean().optional().describe("Wait for result (default: false)"),
+});
+const CancelInteractionSchema = z.object({
+    interaction_id: z.string().describe("Interaction ID to cancel"),
+});
+const SetStatusSchema = z.object({
+    status: z.enum(["pending", "running", "completed", "failed"]),
+    message: z.string().optional(),
+});
+// Process tools
+const PROCESS_TOOLS = [
+    {
+        name: "list_processes",
+        description: "List all processes defined in mide.yaml with their status",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+    {
+        name: "start_process",
+        description: "Start a process defined in mide.yaml",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Process name from mide.yaml" },
+                args: { type: "string", description: "Additional arguments to pass to the command" },
+                force: { type: "boolean", description: "Kill any process using the port before starting" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "stop_process",
+        description: "Stop a running process",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Process name to stop" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "restart_process",
+        description: "Restart a process",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Process name to restart" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "get_status",
+        description: "Get detailed status of a process",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Process name" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "get_logs",
+        description: "Get log output from a process",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Process name" },
+                stream: { type: "string", enum: ["stdout", "stderr", "combined"], description: "Log stream (default: combined)" },
+                tail: { type: "number", description: "Number of lines to return (default: 100)" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "get_url",
+        description: "Get the URL for a process (if it has a port)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Process name" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "create_pane",
+        description: "Create a terminal/process pane running a command. Use for dev servers, build commands, or any shell process. In embedded mode (default when inside tmux), creates pane in current session. In standalone mode, creates in separate IDE session.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Unique name for the pane" },
+                command: { type: "string", description: "Command to run (e.g., 'npm run dev', 'python server.py')" },
+                group: { type: "string", description: "Group to place the pane in (default: 'dynamic', standalone mode only)" },
+                mode: { type: "string", enum: ["embedded", "standalone"], description: "Tmux mode: embedded (current session) or standalone (separate IDE session)" },
+            },
+            required: ["name", "command"],
+        },
+    },
+    {
+        name: "remove_pane",
+        description: "Remove a terminal/process pane by name",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the pane to remove" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "set_status",
+        description: "Update the IDE terminal window title to show current status",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["pending", "running", "completed", "failed"],
+                    description: "Current status indicator (⏳ pending, 🔄 running, ✅ completed, ❌ failed)",
+                },
+                message: {
+                    type: "string",
+                    description: "Custom message (e.g., 'Building project...', '3 tests failed')",
+                },
+            },
+            required: ["status"],
+        },
+    },
+    {
+        name: "test_blocking",
+        description: "Test tool that blocks for a specified duration while sending progress heartbeats. Used to validate timeout handling.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                duration_seconds: { type: "number", description: "How long to block in seconds" },
+                heartbeat_interval_ms: { type: "number", description: "Progress heartbeat interval in ms (default: 25000)" },
+            },
+            required: ["duration_seconds"],
+        },
+    },
+    {
+        name: "show_interaction",
+        description: "Show an interactive form or custom Ink component in a tmux pane and collect user input. By default blocks until user completes the form.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                schema: {
+                    type: "object",
+                    description: "Form schema with questions (AskUserQuestion-compatible)",
+                    properties: {
+                        questions: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    question: { type: "string", description: "The question to ask" },
+                                    header: { type: "string", description: "Short label (max 12 chars)" },
+                                    options: { type: "array", description: "Selection options (omit for text input)" },
+                                    multiSelect: { type: "boolean", description: "Allow multiple selections" },
+                                    inputType: { type: "string", enum: ["text", "textarea", "password"] },
+                                    placeholder: { type: "string" },
+                                    validation: { type: "string", description: "Regex pattern" },
+                                },
+                                required: ["question", "header"],
+                            },
+                        },
+                    },
+                    required: ["questions"],
+                },
+                ink_file: { type: "string", description: "Path to custom Ink component file (.tsx/.jsx) - saves tokens!" },
+                title: { type: "string", description: "Form title" },
+                group: { type: "string", description: "tmux layout group" },
+                timeout_ms: { type: "number", description: "Auto-cancel timeout in ms" },
+                block: { type: "boolean", description: "Block until done (default: true)" },
+            },
+        },
+    },
+    {
+        name: "get_interaction_result",
+        description: "Get the result of a non-blocking interaction",
+        inputSchema: {
+            type: "object",
+            properties: {
+                interaction_id: { type: "string", description: "Interaction ID from show_interaction" },
+                block: { type: "boolean", description: "Wait for result (default: false)" },
+            },
+            required: ["interaction_id"],
+        },
+    },
+    {
+        name: "cancel_interaction",
+        description: "Cancel an active interaction",
+        inputSchema: {
+            type: "object",
+            properties: {
+                interaction_id: { type: "string", description: "Interaction ID to cancel" },
+            },
+            required: ["interaction_id"],
+        },
+    },
+];
+function formatToolError(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        isError: true,
+    };
+}
+async function main() {
+    const parsedArgs = parseArgs();
+    // Handle non-server commands
+    switch (parsedArgs.command) {
+        case "help":
+            showHelp();
+            process.exit(0);
+            break;
+        case "sessions":
+            await commandSessions();
+            process.exit(0);
+            break;
+        case "attach":
+            await commandAttach(parsedArgs.sessionName);
+            // attach() doesn't return - it replaces the process
+            break;
+        case "server":
+            // Continue to MCP server mode below
+            break;
+    }
+    // Server mode: Start MCP server
+    const workspaceDir = process.cwd();
+    // Check if tmux is available (required)
+    if (!(await isTmuxAvailable())) {
+        console.error("[mide] Error: tmux is required but not found.");
+        console.error("[mide] Install tmux: brew install tmux (macOS) or apt install tmux (Linux)");
+        process.exit(1);
+    }
+    // Check if config exists (either specified or in cwd)
+    const hasConfig = parsedArgs.config || configExists();
+    if (!hasConfig) {
+        console.error("[mide] No mide.yaml found in current directory");
+        console.error("[mide] Running in minimal mode - no process management available");
+    }
+    // Load config if it exists
+    let config;
+    let configDir = workspaceDir;
+    let processManager;
+    let tmuxManager;
+    let embeddedTmuxManager;
+    let interactionManager;
+    // Initialize embedded tmux manager if running inside tmux
+    if (isInsideTmux()) {
+        try {
+            embeddedTmuxManager = await EmbeddedTmuxManager.create();
+            console.error(`[mide] Running in embedded mode (session: ${embeddedTmuxManager.getSessionName()})`);
+            // Initialize interaction manager for embedded mode (works without mide.yaml)
+            // Uses ~/.mide/interactive/ for global components
+            interactionManager = new InteractionManager({
+                tmuxManager: embeddedTmuxManager,
+                cwd: workspaceDir,
+            });
+        }
+        catch (err) {
+            console.error(`[mide] Failed to create embedded tmux manager: ${err}`);
+        }
+    }
+    if (hasConfig) {
+        const loaded = await loadConfig(parsedArgs.config);
+        config = loaded.config;
+        configDir = loaded.configDir;
+        // Create tmux session with project name
+        const projectName = path.basename(configDir);
+        // Top-level layout takes precedence over settings.layout
+        const layout = config.layout ?? config.settings?.layout;
+        tmuxManager = new TmuxManager(projectName, {
+            sessionPrefix: config.settings?.tmuxSessionPrefix,
+            layout,
+        });
+        await tmuxManager.createSession();
+        console.error(`[mide] Created tmux session: ${tmuxManager.sessionName}`);
+        // Initialize process manager with tmux
+        processManager = new ProcessManager(configDir, {
+            settings: config.settings,
+            tmuxManager,
+        });
+        await processManager.startAll(config);
+        // Initialize interaction manager for interactive forms
+        // Let InteractionManager find ink-runner relative to its own location
+        interactionManager = new InteractionManager({
+            tmuxManager,
+            cwd: configDir, // Project root for resolving .mide/interactive paths
+        });
+        // Auto-attach terminal if configured and there are processes to show
+        const hasProcesses = Object.keys(config.processes || {}).length > 0;
+        if (config.settings?.autoAttachTerminal && hasProcesses) {
+            await tmuxManager.openTerminal(config.settings?.terminalApp, configDir);
+        }
+        else if (hasProcesses) {
+            console.error(`[mide] Attach with: tmux attach -t ${tmuxManager.sessionName}`);
+        }
+    }
+    // Tool handler
+    async function handleToolCall(name, args) {
+        switch (name) {
+            case "list_processes": {
+                if (!processManager) {
+                    return formatToolError("No mide.yaml found - process management not available");
+                }
+                const processes = processManager.listProcesses();
+                if (processes.length === 0) {
+                    return {
+                        content: [{ type: "text", text: "No processes defined in mide.yaml" }],
+                    };
+                }
+                const formatted = processes.map((p) => {
+                    const parts = [`${p.name}: ${p.status}`];
+                    if (p.port)
+                        parts.push(`port=${p.port}`);
+                    if (p.healthy !== undefined)
+                        parts.push(`healthy=${p.healthy}`);
+                    if (p.error)
+                        parts.push(`error=${p.error}`);
+                    return parts.join(" | ");
+                });
+                return {
+                    content: [{ type: "text", text: formatted.join("\n") }],
+                };
+            }
+            case "start_process": {
+                if (!processManager) {
+                    return formatToolError("No mide.yaml found - process management not available");
+                }
+                const parsed = StartProcessSchema.parse(args);
+                await processManager.startProcess(parsed.name, {
+                    args: parsed.args,
+                    force: parsed.force,
+                });
+                return {
+                    content: [{ type: "text", text: `Process "${parsed.name}" started` }],
+                };
+            }
+            case "stop_process": {
+                if (!processManager) {
+                    return formatToolError("No mide.yaml found - process management not available");
+                }
+                const parsed = StopProcessSchema.parse(args);
+                await processManager.stopProcess(parsed.name);
+                return {
+                    content: [{ type: "text", text: `Process "${parsed.name}" stopped` }],
+                };
+            }
+            case "restart_process": {
+                if (!processManager) {
+                    return formatToolError("No mide.yaml found - process management not available");
+                }
+                const parsed = RestartProcessSchema.parse(args);
+                await processManager.restartProcess(parsed.name);
+                return {
+                    content: [{ type: "text", text: `Process "${parsed.name}" restarted` }],
+                };
+            }
+            case "get_status": {
+                if (!processManager) {
+                    return formatToolError("No mide.yaml found - process management not available");
+                }
+                const parsed = GetStatusSchema.parse(args);
+                const process = processManager.getProcess(parsed.name);
+                if (!process) {
+                    return formatToolError(`Process "${parsed.name}" not found`);
+                }
+                const state = process.getState();
+                const lines = [
+                    `Name: ${state.name}`,
+                    `Status: ${state.status}`,
+                ];
+                if (state.pid)
+                    lines.push(`PID: ${state.pid}`);
+                if (state.port)
+                    lines.push(`Port: ${state.port}`);
+                if (state.url)
+                    lines.push(`URL: ${state.url}`);
+                if (state.healthy !== undefined)
+                    lines.push(`Healthy: ${state.healthy}`);
+                if (state.restartCount > 0)
+                    lines.push(`Restart Count: ${state.restartCount}`);
+                if (state.error)
+                    lines.push(`Error: ${state.error}`);
+                return {
+                    content: [{ type: "text", text: lines.join("\n") }],
+                };
+            }
+            case "get_logs": {
+                if (!processManager) {
+                    return formatToolError("No mide.yaml found - process management not available");
+                }
+                const parsed = GetLogsSchema.parse(args);
+                const proc = processManager.getProcess(parsed.name);
+                if (!proc) {
+                    return formatToolError(`Process "${parsed.name}" not found`);
+                }
+                // Get logs from tmux pane
+                const tail = parsed.tail ?? 100;
+                const content = await proc.getLogsAsync(tail);
+                return {
+                    content: [{ type: "text", text: content || "(no logs yet)" }],
+                };
+            }
+            case "get_url": {
+                if (!processManager) {
+                    return formatToolError("No mide.yaml found - process management not available");
+                }
+                const parsed = GetUrlSchema.parse(args);
+                const url = processManager.getUrl(parsed.name);
+                if (!url) {
+                    return {
+                        content: [{ type: "text", text: `Process "${parsed.name}" has no URL (no port configured or detected)` }],
+                    };
+                }
+                return {
+                    content: [{ type: "text", text: url }],
+                };
+            }
+            case "create_pane": {
+                const parsed = CreatePaneSchema.parse(args);
+                // Determine effective mode: tool param > config > auto-detect
+                const effectiveMode = parsed.mode
+                    ?? config?.settings?.tmuxMode
+                    ?? (isInsideTmux() ? "embedded" : "standalone");
+                // Embedded mode: create pane in user's current tmux session
+                if (effectiveMode === "embedded" && embeddedTmuxManager) {
+                    const paneId = await embeddedTmuxManager.createPane(parsed.name, parsed.command, configDir);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `Created embedded terminal "${parsed.name}"\n` +
+                                    `Command: ${parsed.command}\n` +
+                                    `Pane ID: ${paneId}\n` +
+                                    `Session: ${embeddedTmuxManager.getSessionName()}`
+                            }],
+                    };
+                }
+                // Standalone mode: use separate MIDE session (requires config)
+                if (!processManager || !tmuxManager) {
+                    if (effectiveMode === "embedded" && !embeddedTmuxManager) {
+                        return formatToolError("Embedded mode requires running inside tmux");
+                    }
+                    return formatToolError("Standalone mode requires mide.yaml");
+                }
+                const terminal = await processManager.createDynamicTerminal(parsed.name, parsed.command, parsed.group);
+                // Auto-open terminal if not already attached (skip if inside tmux - user can switch manually)
+                if (config?.settings?.autoAttachTerminal !== false && !isInsideTmux()) {
+                    await tmuxManager.openTerminal(config?.settings?.terminalApp, configDir);
+                }
+                const groups = processManager.getAvailableGroups();
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Created pane "${terminal.name}" in group "${terminal.group}"\n` +
+                                `Command: ${terminal.command}\n` +
+                                `Pane ID: ${terminal.paneId}\n` +
+                                (groups.length > 1 ? `Available groups: ${groups.join(", ")}` : "")
+                        }],
+                };
+            }
+            case "remove_pane": {
+                const parsed = RemovePaneSchema.parse(args);
+                // Try embedded manager first
+                if (embeddedTmuxManager?.hasPane(parsed.name)) {
+                    await embeddedTmuxManager.killPane(parsed.name);
+                    return {
+                        content: [{ type: "text", text: `Removed embedded terminal "${parsed.name}"` }],
+                    };
+                }
+                // Fall back to standalone mode
+                if (!processManager) {
+                    return formatToolError("Terminal not found");
+                }
+                await processManager.removeDynamicTerminal(parsed.name);
+                return {
+                    content: [{ type: "text", text: `Removed pane "${parsed.name}"` }],
+                };
+            }
+            case "set_status": {
+                const parsed = SetStatusSchema.parse(args);
+                // Use embedded manager if available, otherwise standalone
+                if (embeddedTmuxManager) {
+                    await embeddedTmuxManager.setStatus(parsed.status, parsed.message);
+                }
+                else if (tmuxManager) {
+                    await tmuxManager.setStatus(parsed.status, parsed.message);
+                }
+                else {
+                    return formatToolError("No tmux session active");
+                }
+                return {
+                    content: [{ type: "text", text: `Status: ${parsed.status}${parsed.message ? ` - ${parsed.message}` : ""}` }],
+                };
+            }
+            // test_blocking is handled separately in the request handler (needs server access)
+            default:
+                return formatToolError(`Unknown tool: ${name}`);
+        }
+    }
+    // Create MCP server
+    const server = new Server({
+        name: "mcp-ide",
+        version: "0.4.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Handle tool listing
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        let tools = [];
+        // Process tools (always available if config exists)
+        if (processManager) {
+            tools = [...tools, ...PROCESS_TOOLS];
+        }
+        else if (embeddedTmuxManager) {
+            // Embedded mode: offer terminal tools without full config
+            tools.push({
+                name: "create_pane",
+                description: "Create a terminal/process pane in the current tmux session. Use for dev servers, build commands, or any shell process.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Unique name for the pane" },
+                        command: { type: "string", description: "Command to run (e.g., 'npm run dev', 'python server.py')" },
+                    },
+                    required: ["name", "command"],
+                },
+            }, {
+                name: "remove_pane",
+                description: "Remove a terminal/process pane by name",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Name of the pane to remove" },
+                    },
+                    required: ["name"],
+                },
+            }, {
+                name: "set_status",
+                description: "Update the terminal window title to show current status",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        status: {
+                            type: "string",
+                            enum: ["pending", "running", "completed", "failed"],
+                            description: "Current status indicator",
+                        },
+                        message: { type: "string", description: "Custom message" },
+                    },
+                    required: ["status"],
+                },
+            }, {
+                name: "test_blocking",
+                description: "Test tool that blocks for a specified duration while sending progress heartbeats.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        duration_seconds: { type: "number", description: "How long to block in seconds" },
+                        heartbeat_interval_ms: { type: "number", description: "Progress heartbeat interval in ms (default: 25000)" },
+                    },
+                    required: ["duration_seconds"],
+                },
+            }, 
+            // Interaction tools (ink-runner based)
+            {
+                name: "show_interaction",
+                description: "Show an interactive form or custom Ink component in a tmux pane and collect user input. By default blocks until user completes the form.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        schema: {
+                            type: "object",
+                            description: "Form schema with questions (AskUserQuestion-compatible)",
+                            properties: {
+                                questions: {
+                                    type: "array",
+                                    items: {
+                                        type: "object",
+                                        properties: {
+                                            question: { type: "string", description: "The question to ask" },
+                                            header: { type: "string", description: "Short label (max 12 chars)" },
+                                            options: { type: "array", description: "Selection options (omit for text input)" },
+                                            multiSelect: { type: "boolean", description: "Allow multiple selections" },
+                                            inputType: { type: "string", enum: ["text", "textarea", "password"] },
+                                            placeholder: { type: "string" },
+                                            validation: { type: "string", description: "Regex pattern" },
+                                        },
+                                        required: ["question", "header"],
+                                    },
+                                },
+                            },
+                            required: ["questions"],
+                        },
+                        ink_file: { type: "string", description: "Path to custom Ink component file (.tsx/.jsx) - resolves from ~/.mide/interactive/ or .mide/interactive/" },
+                        title: { type: "string", description: "Form title" },
+                        timeout_ms: { type: "number", description: "Auto-cancel timeout in ms" },
+                        block: { type: "boolean", description: "Block until done (default: true)" },
+                    },
+                },
+            }, {
+                name: "get_interaction_result",
+                description: "Get the result of a non-blocking interaction",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        interaction_id: { type: "string", description: "Interaction ID from show_interaction" },
+                        block: { type: "boolean", description: "Wait for result (default: false)" },
+                    },
+                    required: ["interaction_id"],
+                },
+            }, {
+                name: "cancel_interaction",
+                description: "Cancel an active interaction",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        interaction_id: { type: "string", description: "Interaction ID to cancel" },
+                    },
+                    required: ["interaction_id"],
+                },
+            });
+        }
+        else {
+            // Minimal mode: just test_blocking
+            tools.push({
+                name: "test_blocking",
+                description: "Test tool that blocks for a specified duration while sending progress heartbeats. Used to validate timeout handling.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        duration_seconds: { type: "number", description: "How long to block in seconds" },
+                        heartbeat_interval_ms: { type: "number", description: "Progress heartbeat interval in ms (default: 25000)" },
+                    },
+                    required: ["duration_seconds"],
+                },
+            });
+        }
+        return { tools };
+    });
+    // Handle tool calls
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            // Handle test_blocking specially (needs server access for progress notifications)
+            if (name === "test_blocking") {
+                const parsed = TestBlockingSchema.parse(args);
+                const durationMs = parsed.duration_seconds * 1000;
+                const heartbeatIntervalMs = parsed.heartbeat_interval_ms ?? 25000;
+                const progressToken = request.params._meta?.progressToken;
+                console.error(`[mide] test_blocking: duration=${durationMs}ms, heartbeat=${heartbeatIntervalMs}ms, progressToken=${progressToken}`);
+                const startTime = Date.now();
+                let heartbeatCount = 0;
+                while (Date.now() - startTime < durationMs) {
+                    // Wait for heartbeat interval or remaining time, whichever is shorter
+                    const remaining = durationMs - (Date.now() - startTime);
+                    const waitTime = Math.min(heartbeatIntervalMs, remaining);
+                    if (waitTime > 0) {
+                        await new Promise(resolve => setTimeout(resolve, waitTime));
+                    }
+                    // Send progress notification if we have a token and still have time left
+                    if (progressToken && Date.now() - startTime < durationMs) {
+                        heartbeatCount++;
+                        const elapsed = Date.now() - startTime;
+                        const progress = Math.min(elapsed / durationMs, 0.99);
+                        console.error(`[mide] Sending progress heartbeat #${heartbeatCount}: ${(progress * 100).toFixed(1)}%`);
+                        try {
+                            await server.notification({
+                                method: "notifications/progress",
+                                params: {
+                                    progressToken,
+                                    progress,
+                                    total: 1,
+                                    message: `Blocking... ${Math.round(elapsed / 1000)}s / ${parsed.duration_seconds}s`
+                                }
+                            });
+                        }
+                        catch (err) {
+                            console.error(`[mide] Failed to send progress notification:`, err);
+                        }
+                    }
+                }
+                const actualDuration = Date.now() - startTime;
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Blocked for ${actualDuration}ms (requested ${durationMs}ms)\nSent ${heartbeatCount} progress heartbeats\nProgress token was: ${progressToken ? "provided" : "NOT provided"}`
+                        }],
+                };
+            }
+            // Handle show_interaction (needs server access for progress notifications)
+            if (name === "show_interaction") {
+                if (!interactionManager) {
+                    return formatToolError("Interaction tools not available - tmux required");
+                }
+                const parsed = ShowInteractionSchema.parse(args);
+                if (!parsed.schema && !parsed.ink_file) {
+                    return formatToolError("Either schema or ink_file is required");
+                }
+                const interactionId = await interactionManager.create({
+                    schema: parsed.schema,
+                    inkFile: parsed.ink_file,
+                    title: parsed.title,
+                    group: parsed.group,
+                    timeoutMs: parsed.timeout_ms,
+                });
+                // Auto-open terminal if not already attached (skip if inside tmux - user can switch manually)
+                if (tmuxManager && config?.settings?.autoAttachTerminal !== false && !isInsideTmux()) {
+                    await tmuxManager.openTerminal(config?.settings?.terminalApp, configDir);
+                }
+                // Non-blocking mode
+                if (parsed.block === false) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({ interaction_id: interactionId, status: "pending" })
+                            }],
+                    };
+                }
+                // Blocking mode with progress heartbeats
+                const progressToken = request.params._meta?.progressToken;
+                const heartbeatIntervalMs = 25000;
+                const startTime = Date.now();
+                let heartbeatCount = 0;
+                console.error(`[mide] show_interaction blocking: id=${interactionId}, progressToken=${progressToken}`);
+                while (true) {
+                    // Wait for result with short timeout
+                    const result = await interactionManager.waitForResult(interactionId, heartbeatIntervalMs);
+                    if (result) {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: JSON.stringify(result)
+                                }],
+                        };
+                    }
+                    // Check if interaction was cancelled/timed out
+                    const state = interactionManager.getState(interactionId);
+                    if (state && state.status !== "pending") {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: JSON.stringify(state.result || { action: state.status })
+                                }],
+                        };
+                    }
+                    // Check tool-level timeout if specified
+                    if (parsed.timeout_ms) {
+                        const elapsed = Date.now() - startTime;
+                        if (elapsed >= parsed.timeout_ms) {
+                            await interactionManager.cancel(interactionId);
+                            return {
+                                content: [{
+                                        type: "text",
+                                        text: JSON.stringify({ action: "timeout" })
+                                    }],
+                            };
+                        }
+                    }
+                    // Send progress heartbeat to keep connection alive
+                    if (progressToken) {
+                        heartbeatCount++;
+                        console.error(`[mide] Sending progress heartbeat #${heartbeatCount} for ${interactionId}`);
+                        try {
+                            await server.notification({
+                                method: "notifications/progress",
+                                params: {
+                                    progressToken,
+                                    progress: 0,
+                                    message: "Waiting for user input..."
+                                }
+                            });
+                        }
+                        catch (err) {
+                            console.error(`[mide] Failed to send progress notification:`, err);
+                        }
+                    }
+                }
+            }
+            // Handle get_interaction_result
+            if (name === "get_interaction_result") {
+                if (!interactionManager) {
+                    return formatToolError("Interaction tools not available - tmux required");
+                }
+                const parsed = GetInteractionResultSchema.parse(args);
+                const state = interactionManager.getState(parsed.interaction_id);
+                if (!state) {
+                    return formatToolError(`Interaction "${parsed.interaction_id}" not found`);
+                }
+                // If blocking requested and still pending, wait
+                if (parsed.block && state.status === "pending") {
+                    const result = await interactionManager.waitForResult(parsed.interaction_id, 30000);
+                    if (result) {
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: JSON.stringify({ status: "completed", result })
+                                }],
+                        };
+                    }
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                status: state.status,
+                                result: state.result
+                            })
+                        }],
+                };
+            }
+            // Handle cancel_interaction
+            if (name === "cancel_interaction") {
+                if (!interactionManager) {
+                    return formatToolError("Interaction tools not available - tmux required");
+                }
+                const parsed = CancelInteractionSchema.parse(args);
+                const success = await interactionManager.cancel(parsed.interaction_id);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success })
+                        }],
+                };
+            }
+            return await handleToolCall(name, args);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[mide] Tool call failed: ${name}:`, msg);
+            return formatToolError(msg);
+        }
+    });
+    // Handle shutdown
+    let isShuttingDown = false;
+    async function shutdown() {
+        if (isShuttingDown)
+            return;
+        isShuttingDown = true;
+        console.error("[mide] Shutting down...");
+        try {
+            // Stop all pending interactions first
+            if (interactionManager) {
+                await interactionManager.stopAll();
+            }
+            // Stop embedded panes
+            if (embeddedTmuxManager) {
+                await embeddedTmuxManager.stopAll();
+            }
+            // Then stop all processes and destroy tmux session
+            if (processManager) {
+                await processManager.stopAll();
+            }
+        }
+        catch (err) {
+            console.error("[mide] Error during shutdown:", err);
+        }
+        // Give a moment for cleanup to complete
+        setTimeout(() => process.exit(0), 100);
+    }
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    // Connect transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[mide] MCP server running");
+    if (processManager && tmuxManager) {
+        console.error(`[mide] Managing ${processManager.listProcesses().length} processes in tmux session: ${tmuxManager.sessionName}`);
+    }
+}
+main().catch((err) => {
+    // Stringify error to avoid Node inspect issues with some error types
+    const errorMsg = err instanceof Error ? err.stack || err.message : String(err);
+    console.error("Fatal error:", errorMsg);
+    process.exit(1);
+});