starmux 0.12.0 → 0.13.0

package/dist/vendor/desktop-commander/dist/tools/improved-process-tools.js

@@ -0,0 +1,726 @@
+import { terminalManager, MAX_BUFFERED_OUTPUT_CHARS, getProcessWaitLimit } from '../terminal-manager.js';
+import { commandManager } from '../command-manager.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
+import { capture } from "../utils/capture.js";
+import { analyzeProcessState, cleanProcessOutput, formatProcessStateMessage } from '../utils/process-detection.js';
+import { configManager } from '../config-manager.js';
+import { getDefaultShell } from '../utils/shell.js';
+import { terminateProcessTree } from '../utils/process-tree.js';
+import { MAX_PROCESS_WAIT_MS } from '../config.js';
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+// Get the directory where the MCP is installed (for ES module imports)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const mcpRoot = path.resolve(__dirname, '..', '..');
+// Track virtual Node sessions (PIDs that are actually Node fallback sessions)
+const virtualNodeSessions = new Map();
+let virtualPidCounter = -1000; // Use negative PIDs for virtual sessions
+/** How long a node:local script's output pipes may stay open after its timeout ended its tree */
+const PIPES_CLOSE_WAIT_MS = 1000;
+/** The answer when some processes of a session could not be ended */
+function terminationFailedResult(pid) {
+    return {
+        content: [{ type: "text", text: `Error: Could not terminate every process of session ${pid}; some may still be running` }],
+        isError: true,
+    };
+}
+/**
+ * Execute Node.js code via temp file (fallback when Python unavailable)
+ * Creates temp .mjs file in MCP directory for ES module import access
+ */
+async function executeNodeCode(code, timeout_ms = 30000, sessionPid) {
+    const tempFile = path.join(mcpRoot, `.mcp-exec-${Date.now()}-${Math.random().toString(36).slice(2)}.mjs`);
+    try {
+        await fs.writeFile(tempFile, code, 'utf8');
+        const result = await new Promise((resolve) => {
+            const proc = spawn(process.execPath, [tempFile], {
+                cwd: mcpRoot,
+                windowsHide: true // Prevent visible console windows on Windows
+            });
+            let stdout = '';
+            let stderr = '';
+            // Not spawn's own timeout option: that kills only the script, leaving the
+            // processes it started running and holding its output pipes open, so
+            // 'close' never came and the call never returned.
+            const timer = setTimeout(async () => {
+                if (await terminateProcessTree(proc)) {
+                    // The tree ended, but a process that left it before the walk (one
+                    // started by a child that has exited) may still hold the output
+                    // pipes: 'close' answers if it comes within PIPES_CLOSE_WAIT_MS
+                    await new Promise((wait) => setTimeout(wait, PIPES_CLOSE_WAIT_MS).unref());
+                }
+                // Some of the tree survived, or a process outside it holds the output
+                // pipes, so 'close' may never come: answer now and stop reading them
+                proc.stdout.destroy();
+                proc.stderr.destroy();
+                resolve({ stdout, stderr, exitCode: 1, treeSurvived: true });
+            }, timeout_ms);
+            proc.stdout.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            proc.on('close', (exitCode) => {
+                clearTimeout(timer);
+                resolve({ stdout, stderr, exitCode: exitCode ?? 1 });
+            });
+            proc.on('error', (err) => {
+                clearTimeout(timer);
+                resolve({ stdout, stderr: stderr + '\n' + err.message, exitCode: 1 });
+            });
+        });
+        // Clean up temp file
+        await fs.unlink(tempFile).catch(() => { });
+        if (result.treeSurvived) {
+            return terminationFailedResult(sessionPid);
+        }
+        if (result.exitCode !== 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Execution failed (exit code ${result.exitCode}):\n${result.stderr}\n${result.stdout}`
+                    }],
+                isError: true
+            };
+        }
+        // Each call runs a fresh script and the session waits for the next one; the output isn't cut
+        const outputLines = result.stdout.trim().length > 0 ? result.stdout.replace(/\r?\n$/, '').split('\n').length : 0;
+        return {
+            content: [{
+                    type: "text",
+                    text: result.stdout || '(no output)'
+                }],
+            structuredContent: {
+                pid: sessionPid,
+                status: 'waiting_for_input',
+                truncated: false,
+                shownLines: outputLines,
+                totalLines: outputLines,
+            },
+        };
+    }
+    catch (error) {
+        // Clean up temp file on error
+        await fs.unlink(tempFile).catch(() => { });
+        return {
+            content: [{
+                    type: "text",
+                    text: `Failed to execute Node.js code: ${error instanceof Error ? error.message : String(error)}`
+                }],
+            isError: true
+        };
+    }
+}
+/**
+ * Start a new process (renamed from execute_command)
+ * Includes early detection of process waiting for input
+ * maxWaitMs: ceiling for this call's wait. The tools always use MAX_PROCESS_WAIT_MS;
+ * only in-process callers (tests) pass a smaller one. Not part of the tool schema.
+ */
+export async function startProcess(args, maxWaitMs = MAX_PROCESS_WAIT_MS) {
+    const parsed = StartProcessArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_start_process_failed');
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for start_process: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        // Each command's first word as typed, so telemetry replaces a path whole
+        // (the base name alone would send the last part of it)
+        const commands = commandManager.extractCommands(parsed.data.command, true).join(', ');
+        capture('server_start_process', {
+            command: commandManager.getBaseCommand(parsed.data.command),
+            commands: commands
+        });
+    }
+    catch (error) {
+        capture('server_start_process', {
+            command: commandManager.getBaseCommand(parsed.data.command)
+        });
+    }
+    const isAllowed = await commandManager.validateCommand(parsed.data.command);
+    if (!isAllowed) {
+        return {
+            content: [{ type: "text", text: `Error: Command not allowed: ${parsed.data.command}` }],
+            isError: true,
+            structuredContent: { blocked: true, command: parsed.data.command },
+        };
+    }
+    const commandToRun = parsed.data.command;
+    // Handle node:local - runs Node.js code directly on MCP server
+    if (commandToRun.trim() === 'node:local') {
+        const virtualPid = virtualPidCounter--;
+        virtualNodeSessions.set(virtualPid, { timeout_ms: parsed.data.timeout_ms || 30000 });
+        return {
+            content: [{
+                    type: "text",
+                    text: `Node.js session started with PID ${virtualPid} (MCP server execution)
+
+   IMPORTANT: Each interact_with_process call runs as a FRESH script.
+   State is NOT preserved between calls. Include ALL code in ONE call:
+   - imports, file reading, processing, and output together.
+
+   Available libraries:
+   - ExcelJS for Excel files: import ExcelJS from 'exceljs'
+   - All Node.js built-ins: fs, path, http, crypto, etc.
+
+🔄 Ready for code - send complete self-contained script via interact_with_process.`
+                }],
+            structuredContent: { pid: virtualPid, status: 'waiting_for_input' },
+        };
+    }
+    let shellUsed = parsed.data.shell;
+    if (!shellUsed) {
+        const config = await configManager.getConfig();
+        shellUsed = config.defaultShell || getDefaultShell();
+    }
+    const result = await terminalManager.executeCommand(commandToRun, parsed.data.timeout_ms, shellUsed, parsed.data.verbose_timing || false, maxWaitMs);
+    if (result.pid === -1) {
+        return {
+            content: [{ type: "text", text: result.output }],
+            isError: true,
+        };
+    }
+    // Whether the process is waiting for input, as detected when the wait ended
+    const { processState } = result;
+    let statusMessage = '';
+    if (processState.isWaitingForInput) {
+        statusMessage = `\n🔄 ${formatProcessStateMessage(processState, result.pid)}`;
+    }
+    else if (processState.isFinished) {
+        statusMessage = `\n✅ ${formatProcessStateMessage(processState, result.pid)}`;
+    }
+    else if (result.isBlocked) {
+        statusMessage = '\n⏳ Process is running. Use read_process_output to get more output.';
+    }
+    // Add timing information if requested
+    let timingMessage = '';
+    if (result.timingInfo) {
+        timingMessage = formatTimingInfo(result.timingInfo);
+    }
+    return {
+        content: [{
+                type: "text",
+                text: `Process started with PID ${result.pid} (shell: ${shellUsed})\nInitial output:\n${result.output}${statusMessage}${timingMessage}`
+            }],
+        structuredContent: {
+            pid: result.pid,
+            shell: shellUsed,
+            status: getProcessStatus(processState),
+            ...getWaitCapFields(result.waitCappedAtMs),
+        },
+    };
+}
+/**
+ * Machine-readable process state for structuredContent, mirroring the
+ * status line shown in the text response.
+ */
+function getProcessStatus(state, timedOut = false) {
+    if (state.isWaitingForInput)
+        return 'waiting_for_input';
+    if (state.isFinished)
+        return 'finished';
+    return timedOut ? 'timeout' : 'running';
+}
+/**
+ * structuredContent fields telling the caller whether the wait ceiling
+ * (not timeout_ms) ended the wait. When it did, status is 'running'
+ * and the caller continues with read_process_output.
+ */
+function getWaitCapFields(waitCappedAtMs) {
+    return waitCappedAtMs !== undefined
+        ? { waitCapped: true, waitLimitMs: waitCappedAtMs }
+        : { waitCapped: false };
+}
+function formatTimingInfo(timing) {
+    let msg = '\n\n📊 Timing Information:\n';
+    msg += `  Exit Reason: ${timing.exitReason}\n`;
+    msg += `  Total Duration: ${timing.totalDurationMs}ms\n`;
+    if (timing.timeToFirstOutputMs !== undefined) {
+        msg += `  Time to First Output: ${timing.timeToFirstOutputMs}ms\n`;
+    }
+    if (timing.firstOutputTime && timing.lastOutputTime) {
+        msg += `  Output Window: ${timing.lastOutputTime - timing.firstOutputTime}ms\n`;
+    }
+    if (timing.outputEvents && timing.outputEvents.length > 0) {
+        msg += `\n  Output Events (${timing.outputEvents.length} total):\n`;
+        timing.outputEvents.forEach((event, idx) => {
+            msg += `    [${idx + 1}] +${event.deltaMs}ms | ${event.source} | ${event.length}b`;
+            if (event.matchedPattern) {
+                msg += ` | 🎯 ${event.matchedPattern}`;
+            }
+            msg += `\n       "${event.snippet}"\n`;
+        });
+    }
+    return msg;
+}
+/**
+ * Read output from a running process with file-like pagination
+ * Supports offset/length parameters for controlled reading
+ * maxWaitMs: ceiling for this call's wait. The tools always use MAX_PROCESS_WAIT_MS;
+ * only in-process callers (tests) pass a smaller one. Not part of the tool schema.
+ */
+export async function readProcessOutput(args, maxWaitMs = MAX_PROCESS_WAIT_MS) {
+    const parsed = ReadProcessOutputArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for read_process_output: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    // Get default line limit from config
+    const config = await configManager.getConfig();
+    const defaultLength = config.fileReadLineLimit ?? 1000;
+    const { pid, timeout_ms = 5000, offset = 0, // 0 = from last read, positive = absolute, negative = tail
+    length = defaultLength, // Default from config, same as file reading
+    verbose_timing = false } = parsed.data;
+    // Timing telemetry
+    const startTime = Date.now();
+    const { waitMs } = getProcessWaitLimit(timeout_ms, maxWaitMs);
+    // For active sessions with no new output yet, optionally wait for output
+    const session = terminalManager.getSession(pid);
+    if (session && offset === 0) {
+        // Wait for new output to arrive (only for "new output" reads, not absolute/tail)
+        const waitForOutput = () => {
+            return new Promise((resolve) => {
+                // Check if there's already new output
+                if (terminalManager.hasUnreadOutput(pid)) {
+                    resolve();
+                    return;
+                }
+                let resolved = false;
+                let interval = null;
+                let timeout = null;
+                const cleanup = () => {
+                    if (interval)
+                        clearInterval(interval);
+                    if (timeout)
+                        clearTimeout(timeout);
+                };
+                const resolveOnce = () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    cleanup();
+                    resolve();
+                };
+                // Poll for new output, or for the exit (the session is then no
+                // longer active): a process that exited writes nothing more itself
+                interval = setInterval(() => {
+                    if (terminalManager.hasUnreadOutput(pid) || !terminalManager.getSession(pid)) {
+                        resolveOnce();
+                    }
+                }, 50);
+                // Timeout
+                timeout = setTimeout(() => {
+                    resolveOnce();
+                }, waitMs);
+            });
+        };
+        await waitForOutput();
+    }
+    // Read output with pagination
+    const result = terminalManager.readOutputPaginated(pid, offset, length);
+    if (!result) {
+        return {
+            content: [{ type: "text", text: `No session found for PID ${pid}` }],
+            isError: true,
+        };
+    }
+    // Join lines back into string
+    const output = result.lines.join('\n');
+    // Generate status message similar to file reading
+    let statusMessage = '';
+    if (offset < 0) {
+        // Tail read - match file reading format for consistency
+        statusMessage = `[Reading last ${result.readCount} lines (total: ${result.totalLines} lines)]`;
+    }
+    else if (offset === 0) {
+        // "New output" read
+        if (result.remaining > 0) {
+            statusMessage = `[Reading ${result.readCount} new lines from line ${result.readFrom} (total: ${result.totalLines} lines, ${result.remaining} remaining)]`;
+        }
+        else {
+            statusMessage = `[Reading ${result.readCount} new lines (total: ${result.totalLines} lines)]`;
+        }
+    }
+    else {
+        // Absolute position read
+        statusMessage = `[Reading ${result.readCount} lines from line ${result.readFrom} (total: ${result.totalLines} lines, ${result.remaining} remaining)]`;
+    }
+    // Surface buffer-cap eviction so the model knows the retained output is not
+    // the full output and that line numbers shifted (matches the truncation
+    // markers used by other tools).
+    if (result.evictedLines && result.evictedLines > 0) {
+        const capMB = Math.round(MAX_BUFFERED_OUTPUT_CHARS / 1024 / 1024);
+        statusMessage += `\n[WARNING: output exceeded the ${capMB}MB buffer cap; the ${result.evictedLines} earliest lines were evicted and cannot be read. Line numbers and totals refer to the retained buffer only]`;
+    }
+    // Add process state info
+    let processStateMessage = '';
+    if (result.isComplete) {
+        const runtimeStr = result.runtimeMs !== undefined
+            ? ` (runtime: ${(result.runtimeMs / 1000).toFixed(2)}s)`
+            : '';
+        // A process ended by a signal has no exit code: name the signal instead of "exit code null"
+        const ending = result.exitCode === null && result.signal ? `signal ${result.signal}` : `exit code ${result.exitCode}`;
+        processStateMessage = `\n✅ Process completed with ${ending}${runtimeStr}`;
+    }
+    else if (session) {
+        // Analyze state for running processes
+        const processState = terminalManager.getProcessState(pid);
+        if (processState?.isWaitingForInput) {
+            processStateMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
+        }
+    }
+    // Add timing information if requested
+    let timingMessage = '';
+    if (verbose_timing) {
+        const endTime = Date.now();
+        timingMessage = `\n\n📊 Timing: ${endTime - startTime}ms`;
+    }
+    const responseText = output || '(No output in requested range)';
+    return {
+        content: [{
+                type: "text",
+                text: `${statusMessage}\n\n${responseText}${processStateMessage}${timingMessage}`
+            }],
+    };
+}
+/**
+ * Interact with a running process (renamed from send_input)
+ * Automatically detects when process is ready and returns output
+ * maxWaitMs: ceiling for this call's wait. The tools always use MAX_PROCESS_WAIT_MS;
+ * only in-process callers (tests) pass a smaller one. Not part of the tool schema.
+ */
+export async function interactWithProcess(args, maxWaitMs = MAX_PROCESS_WAIT_MS) {
+    const parsed = InteractWithProcessArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_interact_with_process_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for interact_with_process: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    const { pid, input, timeout_ms = 8000, wait_for_prompt = true, verbose_timing = false } = parsed.data;
+    // Get config for output line limit
+    const config = await configManager.getConfig();
+    const maxOutputLines = config.fileReadLineLimit ?? 1000;
+    const waitLimit = getProcessWaitLimit(timeout_ms, maxWaitMs);
+    // Check if this is a virtual Node session (node:local)
+    if (virtualNodeSessions.has(pid)) {
+        const session = virtualNodeSessions.get(pid);
+        capture('server_interact_with_process_node_fallback', {
+            pid: pid,
+            inputLength: input.length
+        });
+        // Execute code via temp file approach
+        // Respect per-call timeout if provided, otherwise use session default
+        // (parsed.data's: timeout_ms above already holds the 8000ms default for processes),
+        // within the process wait ceiling: the call answers only once the script ends
+        const effectiveTimeout = Math.min(parsed.data.timeout_ms ?? session.timeout_ms, waitLimit.capMs);
+        return executeNodeCode(input, effectiveTimeout, pid);
+    }
+    // Timing telemetry
+    const startTime = Date.now();
+    let firstOutputTime;
+    let lastOutputTime;
+    const outputEvents = [];
+    let exitReason = 'timeout';
+    try {
+        capture('server_interact_with_process', {
+            pid: pid,
+            inputLength: input.length
+        });
+        // Capture output snapshot BEFORE sending input
+        // This handles REPLs where output is appended to the prompt line
+        const outputSnapshot = terminalManager.captureOutputSnapshot(pid);
+        // Only a process that reads its input at a prompt prints prompts in its output
+        const readAtPrompt = terminalManager.getProcessState(pid)?.isWaitingForInput ?? false;
+        // No snapshot means no active session, which can't take input either
+        const success = outputSnapshot !== null && terminalManager.sendInputToProcess(pid, input);
+        if (!success) {
+            return {
+                content: [{ type: "text", text: `Error: Failed to send input to process ${pid}. The process may have exited or doesn't accept input.` }],
+                isError: true,
+            };
+        }
+        // If not waiting for response, return immediately
+        if (!wait_for_prompt) {
+            exitReason = 'no_wait';
+            let timingMessage = '';
+            if (verbose_timing) {
+                const endTime = Date.now();
+                const timingInfo = {
+                    startTime,
+                    endTime,
+                    totalDurationMs: endTime - startTime,
+                    exitReason,
+                    firstOutputTime,
+                    lastOutputTime,
+                    timeToFirstOutputMs: undefined,
+                    outputEvents: undefined
+                };
+                timingMessage = formatTimingInfo(timingInfo);
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Input sent to process ${pid}. Use read_process_output to get the response.${timingMessage}`
+                    }],
+                // Not waited for: no output was read
+                structuredContent: { pid, status: 'running', truncated: false, shownLines: 0, totalLines: 0 },
+            };
+        }
+        // Smart waiting with immediate and periodic detection
+        let output = "";
+        let processState;
+        let earlyExit = false;
+        let waitCapped = false;
+        const waitForResponse = () => {
+            return new Promise((resolve) => {
+                let resolved = false;
+                const pollIntervalMs = 50; // Poll every 50ms for faster response
+                // A deadline, not a poll count, so a busy event loop can't stretch the wait past the ceiling
+                const deadline = Date.now() + waitLimit.waitMs;
+                let interval = null;
+                // Advances every poll, so each poll reads only the output that arrived since the
+                // previous one (snapshot-based, which handles REPL prompt line appending)
+                let readPosition = outputSnapshot;
+                let resolveOnce = () => {
+                    if (resolved)
+                        return;
+                    resolved = true;
+                    if (interval)
+                        clearInterval(interval);
+                    resolve();
+                };
+                // Fast-polling check - check every 50ms for quick responses
+                interval = setInterval(() => {
+                    if (resolved)
+                        return;
+                    const read = terminalManager.readOutputSince(pid, readPosition);
+                    if (read)
+                        readPosition = read.next;
+                    const newOutput = read?.output ?? '';
+                    if (newOutput.length > 0) {
+                        const now = Date.now();
+                        if (!firstOutputTime)
+                            firstOutputTime = now;
+                        lastOutputTime = now;
+                        if (verbose_timing) {
+                            outputEvents.push({
+                                timestamp: now,
+                                deltaMs: now - startTime,
+                                source: 'periodic_poll',
+                                length: newOutput.length,
+                                snippet: newOutput.slice(0, 50).replace(/\n/g, '\\n')
+                            });
+                        }
+                        // Full output since the snapshot, bounded like the session buffer it came from
+                        output += newOutput;
+                        if (output.length > MAX_BUFFERED_OUTPUT_CHARS) {
+                            output = output.slice(-MAX_BUFFERED_OUTPUT_CHARS);
+                        }
+                        // Analyze current state from the end of the output since the snapshot
+                        processState = terminalManager.getProcessState(pid, outputSnapshot) ?? analyzeProcessState(output, pid);
+                        // Exit early if we detect the process is waiting for input
+                        if (processState.isWaitingForInput) {
+                            earlyExit = true;
+                            exitReason = 'early_exit_periodic_check';
+                            if (verbose_timing && outputEvents.length > 0) {
+                                outputEvents[outputEvents.length - 1].matchedPattern = 'periodic_check';
+                            }
+                            resolveOnce();
+                            return;
+                        }
+                    }
+                    // Also exit once the process has exited, whether or not it wrote
+                    // anything since the previous poll: no answer can come any more
+                    const state = terminalManager.getProcessState(pid, outputSnapshot);
+                    if (state?.isFinished) {
+                        processState = state;
+                        exitReason = 'process_finished';
+                        resolveOnce();
+                        return;
+                    }
+                    if (Date.now() >= deadline) {
+                        exitReason = 'timeout';
+                        waitCapped = waitLimit.capped;
+                        resolveOnce();
+                    }
+                }, pollIntervalMs);
+            });
+        };
+        await waitForResponse();
+        // Clean and format output
+        let cleanOutput = cleanProcessOutput(output, input, readAtPrompt);
+        const timeoutReached = !earlyExit && !processState?.isFinished && !processState?.isWaitingForInput;
+        // Apply output line limit to prevent context overflow
+        let truncationMessage = '';
+        const outputLines = cleanOutput.split('\n');
+        const totalLines = cleanOutput.trim().length > 0 ? outputLines.length : 0;
+        const shownLines = Math.min(totalLines, maxOutputLines);
+        if (outputLines.length > maxOutputLines) {
+            const truncatedLines = outputLines.slice(0, maxOutputLines);
+            cleanOutput = truncatedLines.join('\n');
+            const remainingLines = outputLines.length - maxOutputLines;
+            truncationMessage = `\n\n⚠️ Output truncated: showing ${maxOutputLines} of ${outputLines.length} lines (${remainingLines} hidden). Use read_process_output with offset/length for full output.`;
+        }
+        // Determine final state
+        if (!processState) {
+            processState = terminalManager.getProcessState(pid, outputSnapshot) ?? analyzeProcessState(output, pid);
+        }
+        let statusMessage = '';
+        if (processState.isWaitingForInput) {
+            statusMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
+        }
+        else if (processState.isFinished) {
+            statusMessage = `\n✅ ${formatProcessStateMessage(processState, pid)}`;
+        }
+        else if (timeoutReached) {
+            statusMessage = '\n⏱️ Response may be incomplete (timeout reached)';
+        }
+        // Add timing information if requested
+        let timingMessage = '';
+        if (verbose_timing) {
+            const endTime = Date.now();
+            const timingInfo = {
+                startTime,
+                endTime,
+                totalDurationMs: endTime - startTime,
+                exitReason,
+                firstOutputTime,
+                lastOutputTime,
+                timeToFirstOutputMs: firstOutputTime ? firstOutputTime - startTime : undefined,
+                outputEvents: outputEvents.length > 0 ? outputEvents : undefined
+            };
+            timingMessage = formatTimingInfo(timingInfo);
+        }
+        // A capped wait didn't reach the caller's timeout_ms: the process is still
+        // running and the caller continues with read_process_output
+        const structuredContent = {
+            pid,
+            status: getProcessStatus(processState, timeoutReached && !waitCapped),
+            truncated: totalLines > shownLines,
+            shownLines,
+            totalLines,
+            ...getWaitCapFields(timeoutReached && waitCapped ? waitLimit.capMs : undefined),
+        };
+        if (cleanOutput.trim().length === 0 && !timeoutReached) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `✅ Input executed in process ${pid}.\n📭 (No output produced)${statusMessage}${timingMessage}`
+                    }],
+                structuredContent,
+            };
+        }
+        // Format response with better structure and consistent emojis
+        let responseText = `✅ Input executed in process ${pid}`;
+        if (cleanOutput && cleanOutput.trim().length > 0) {
+            responseText += `:\n\n📤 Output:\n${cleanOutput}`;
+        }
+        else {
+            responseText += `.\n📭 (No output produced)`;
+        }
+        if (statusMessage) {
+            responseText += `\n\n${statusMessage}`;
+        }
+        if (truncationMessage) {
+            responseText += truncationMessage;
+        }
+        if (timingMessage) {
+            responseText += timingMessage;
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: responseText
+                }],
+            structuredContent,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_interact_with_process_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error interacting with process: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Force terminate a process
+ */
+export async function forceTerminate(args) {
+    const parsed = ForceTerminateArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for force_terminate: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    const pid = parsed.data.pid;
+    // Handle virtual Node.js sessions (node:local)
+    if (virtualNodeSessions.has(pid)) {
+        virtualNodeSessions.delete(pid);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Cleared virtual Node.js session ${pid}`
+                }],
+        };
+    }
+    // Returns once the session's processes are gone, so a success means they no longer run
+    const outcome = await terminalManager.forceTerminate(pid);
+    if (outcome === 'failed') {
+        return terminationFailedResult(pid);
+    }
+    return {
+        content: [{
+                type: "text",
+                text: outcome === 'terminated'
+                    ? `Successfully initiated termination of session ${pid}`
+                    : `No active session found for PID ${pid}`
+            }],
+    };
+}
+/**
+ * List active sessions
+ */
+export async function listSessions() {
+    const sessions = terminalManager.listActiveSessions();
+    // Include virtual Node.js sessions
+    const virtualSessions = Array.from(virtualNodeSessions.entries()).map(([pid, session]) => ({
+        pid,
+        type: 'node:local',
+        timeout_ms: session.timeout_ms
+    }));
+    const realSessionsText = sessions.map(s => `PID: ${s.pid}, Blocked: ${s.isBlocked}, Runtime: ${Math.round(s.runtime / 1000)}s`);
+    const virtualSessionsText = virtualSessions.map(s => `PID: ${s.pid} (node:local), Timeout: ${s.timeout_ms}ms`);
+    const allSessions = [...realSessionsText, ...virtualSessionsText];
+    return {
+        content: [{
+                type: "text",
+                text: allSessions.length === 0
+                    ? 'No active sessions'
+                    : allSessions.join('\n')
+            }],
+        structuredContent: {
+            sessions: [
+                ...sessions.map(s => ({ pid: s.pid, type: 'process', isBlocked: s.isBlocked, runtimeMs: s.runtime })),
+                ...virtualSessions.map(s => ({ pid: s.pid, type: s.type, timeoutMs: s.timeout_ms })),
+            ],
+        },
+    };
+}