patchwork-os 0.2.0-alpha.0

package/dist/tools/terminal.js

@@ -0,0 +1,670 @@
+import { INTERPRETER_COMMANDS } from "../config.js";
+import { ExtensionTimeoutError, } from "../extensionClient.js";
+import { error, execSafe, extensionRequired, optionalBool, optionalInt, optionalString, requireString, resolveFilePath, successStructured, } from "./utils.js";
+/**
+ * Flags that allow interpreter commands to execute arbitrary code.
+ * Mirrors DANGEROUS_INTERPRETER_FLAGS in runCommand.ts — applied here to
+ * terminal commands where the shell is involved and quoting cannot be trusted.
+ */
+const TERMINAL_DANGEROUS_INTERPRETER_FLAGS = new Set([
+    "-e",
+    "--eval",
+    "-c",
+    "--print",
+    "-p",
+    "--input-type",
+    "--import",
+    "--loader",
+    "--experimental-loader",
+    "-m",
+    "--inspect", // Node.js debugger — opens a remote debug port
+    "--inspect-brk", // Node.js debugger (break on start)
+    "--inspect-port", // Node.js debugger port override
+]);
+/**
+ * Flags that redirect where commands read config/manifests from.
+ * Mirrors DANGEROUS_PATH_FLAGS in runCommand.ts.
+ */
+const TERMINAL_DANGEROUS_PATH_FLAGS = new Set([
+    "--prefix",
+    "--manifest-path",
+    "--config",
+    "--rcfile",
+    "--require",
+    "-r",
+    "--userconfig",
+    "--globalconfig",
+    "-f",
+    "--makefile",
+]);
+/**
+ * Per-command exemptions from TERMINAL_DANGEROUS_PATH_FLAGS.
+ * Mirrors PATH_FLAG_EXEMPTIONS in runCommand.ts.
+ */
+const TERMINAL_PATH_FLAG_EXEMPTIONS = {
+    psql: new Set(["--config"]),
+    pg_dump: new Set(["--config"]),
+    pg_restore: new Set(["--config"]),
+};
+/** Environment variable names that could enable privilege escalation */
+const DANGEROUS_ENV_VARS = new Set([
+    "PATH",
+    "LD_PRELOAD",
+    "LD_LIBRARY_PATH",
+    "DYLD_INSERT_LIBRARIES",
+    "DYLD_LIBRARY_PATH",
+    "DYLD_FRAMEWORK_PATH",
+    "NODE_OPTIONS",
+    "NODE_PATH",
+    "PYTHONSTARTUP",
+    "PYTHONPATH",
+    "PYTHONHOME",
+    "RUBYOPT",
+    "RUBYLIB",
+    "PERL5OPT",
+    "PERL5LIB",
+    "CLASSPATH",
+    "BASH_ENV",
+    "ENV",
+    "ZDOTDIR",
+    "EDITOR",
+    "VISUAL",
+    "SHELL",
+    "HOME",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "GIT_SSH_COMMAND",
+    "GIT_EXEC_PATH",
+    "NPM_CONFIG_SCRIPT_SHELL",
+    "CARGO_HOME",
+]);
+/**
+ * Validate terminal command tokens for dangerous flags.
+ * Returns an error string if a dangerous flag is found, undefined otherwise.
+ *
+ * Terminal commands run inside a real shell, so flag-level argument injection
+ * (e.g. `git -c core.pager=evil`) cannot be caught by the metacharacter filter.
+ * We apply the same flag blocklists used by runCommand for interpreter and
+ * config-redirect flags.
+ */
+function validateTerminalCommandFlags(command) {
+    const tokens = command.trim().split(/\s+/);
+    const cmd = tokens[0]?.toLowerCase() ?? "";
+    const isInterpreter = INTERPRETER_COMMANDS.has(cmd);
+    for (let i = 1; i < tokens.length; i++) {
+        const tok = tokens[i] ?? "";
+        // Strip value for flags like --config=value → --config
+        const flag = tok.split("=")[0] ?? tok;
+        if (isInterpreter && TERMINAL_DANGEROUS_INTERPRETER_FLAGS.has(flag)) {
+            return `Flag "${flag}" is not allowed for interpreter command "${cmd}" (code execution risk)`;
+        }
+        const exemptions = TERMINAL_PATH_FLAG_EXEMPTIONS[cmd];
+        if (TERMINAL_DANGEROUS_PATH_FLAGS.has(flag) && !exemptions?.has(flag)) {
+            return `Flag "${flag}" is not allowed in terminal commands (config redirect risk)`;
+        }
+    }
+    return undefined;
+}
+/**
+ * Validate a terminal command string against security rules.
+ * Returns an error message if invalid, undefined if the command is safe.
+ */
+function validateCommand(text, commandAllowlist) {
+    // Reject non-ASCII whitespace (U+00A0, etc.) — these bypass quote guard but
+    // pass whitespace-splitting checks, potentially corrupting the argv array.
+    if (/[\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/.test(text)) {
+        return "Command must not contain non-ASCII whitespace characters.";
+    }
+    // Also block Unicode line/paragraph separators (\u2028, \u2029) which act
+    // as line terminators in JavaScript and some shell contexts.
+    if (/[\n\r\u2028\u2029]/.test(text)) {
+        return "Command must not contain newlines. Send one command at a time.";
+    }
+    if (/[;&|`$()<>{}!\\~]/.test(text)) {
+        return ("Command must not contain shell metacharacters (;&|`$()<>{}!\\~). " +
+            "These could chain additional commands beyond the allowlist.");
+    }
+    const firstWord = text.trim().split(/\s+/)[0]?.toLowerCase();
+    if (firstWord && !commandAllowlist.includes(firstWord)) {
+        return (`Command "${firstWord}" is not in the allowlist. ` +
+            `Allowed commands: ${commandAllowlist.join(", ")}. ` +
+            `Use --allow-command ${firstWord} to add it.`);
+    }
+    return validateTerminalCommandFlags(text);
+}
+/** Apply prefix to a terminal name (no-op when prefix is empty).
+ * When prefix is set and name is undefined, generates a unique prefixed default name
+ * so the terminal remains discoverable by listTerminals for this session. */
+function prefixName(name, prefix) {
+    if (!prefix)
+        return name;
+    if (name === undefined) {
+        // Generate a unique default so unnamed terminals are still session-scoped
+        return `${prefix}terminal-${Date.now().toString(36)}`;
+    }
+    return `${prefix}${name}`;
+}
+/** Strip prefix from a terminal name (no-op when prefix is empty). */
+function stripPrefix(name, prefix) {
+    if (!prefix)
+        return name;
+    return name.startsWith(prefix) ? name.slice(prefix.length) : name;
+}
+/** In multi-session mode, index-based terminal lookup is unsafe because the
+ * global index does not correspond to the session-scoped index shown by listTerminals.
+ * Returns an error string when this case is detected, or null if the call is safe. */
+function checkIndexWithPrefix(name, index, prefix) {
+    if (prefix && name === undefined && index !== undefined) {
+        return ("Terminal index-based lookup is not supported when multiple agent sessions are active. " +
+            "Use terminal name instead (from listTerminals). " +
+            "Index 0 in your session refers to a different global index than in VS Code.");
+    }
+    return null;
+}
+export function createGetTerminalOutputTool(extensionClient, terminalPrefix = "") {
+    return {
+        schema: {
+            name: "getTerminalOutput",
+            extensionRequired: true,
+            description: "Get recent output from a VS Code integrated terminal. Identify by name or index (from listTerminals). Returns last N lines. On headless VPS/SSH, use runInTerminal instead.",
+            annotations: { readOnlyHint: true },
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "Terminal name to retrieve output from",
+                    },
+                    index: {
+                        type: "integer",
+                        description: "Terminal index (0-based) from listTerminals",
+                    },
+                    lines: {
+                        type: "integer",
+                        description: "Recent lines to retrieve (default 100, max 5000)",
+                    },
+                },
+                additionalProperties: false,
+            },
+            outputSchema: {
+                type: "object",
+                properties: {
+                    output: { type: "string" },
+                    lines: { type: "array", items: { type: "string" } },
+                },
+            },
+        },
+        handler: async (args, _signal) => {
+            if (!extensionClient.isConnected()) {
+                return extensionRequired("terminal output");
+            }
+            const name = optionalString(args, "name", 256);
+            const index = optionalInt(args, "index", 0, 100);
+            const lines = optionalInt(args, "lines", 1, 5000);
+            if (name === undefined && index === undefined) {
+                return error("At least one of 'name' or 'index' must be provided to identify the terminal");
+            }
+            const indexErr = checkIndexWithPrefix(name, index, terminalPrefix);
+            if (indexErr)
+                return error(indexErr);
+            try {
+                const result = await extensionClient.getTerminalOutput(prefixName(name, terminalPrefix), index, lines);
+                if (result === null) {
+                    return error("Terminal not found");
+                }
+                return successStructured(result);
+            }
+            catch (err) {
+                if (err instanceof ExtensionTimeoutError) {
+                    return error("Extension timed out — terminal features may be unavailable");
+                }
+                throw err;
+            }
+        },
+    };
+}
+export function createCreateTerminalTool(workspace, extensionClient, terminalPrefix = "") {
+    return {
+        schema: {
+            name: "createTerminal",
+            extensionRequired: true,
+            annotations: { destructiveHint: true },
+            description: "Create VS Code integrated terminal. Options: name, cwd, env vars, shell.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "Display name for the terminal",
+                    },
+                    cwd: {
+                        type: "string",
+                        description: "Working dir for terminal (must be within workspace)",
+                    },
+                    env: {
+                        type: "object",
+                        description: "Extra env vars (key-value pairs, max 50 entries)",
+                        additionalProperties: { type: "string" },
+                    },
+                    show: {
+                        type: "boolean",
+                        description: "Show terminal panel after creation (default: true)",
+                    },
+                },
+                additionalProperties: false,
+            },
+            outputSchema: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    index: { type: "integer" },
+                },
+            },
+        },
+        handler: async (args, _signal) => {
+            if (!extensionClient.isConnected()) {
+                return extensionRequired("createTerminal");
+            }
+            const name = optionalString(args, "name", 256);
+            const rawCwd = optionalString(args, "cwd");
+            const resolvedCwd = rawCwd
+                ? resolveFilePath(rawCwd, workspace)
+                : undefined;
+            const rawEnv = args.env;
+            let env;
+            if (rawEnv !== undefined) {
+                if (typeof rawEnv !== "object" ||
+                    rawEnv === null ||
+                    Array.isArray(rawEnv)) {
+                    return error("'env' must be an object with string key-value pairs");
+                }
+                const keys = Object.keys(rawEnv);
+                if (keys.length > 50) {
+                    return error("'env' must have at most 50 entries");
+                }
+                env = {};
+                for (const [k, v] of Object.entries(rawEnv)) {
+                    if (typeof v !== "string") {
+                        return error(`env["${k}"] must be a string`);
+                    }
+                    if (DANGEROUS_ENV_VARS.has(k.toUpperCase())) {
+                        return error(`Environment variable "${k}" is blocked for security — it can redirect command execution`);
+                    }
+                    env[k] = v;
+                }
+            }
+            const show = optionalBool(args, "show") ?? true;
+            try {
+                const result = await extensionClient.createTerminal(prefixName(name, terminalPrefix), resolvedCwd, env, show);
+                if (result === null) {
+                    return error("Failed to create terminal");
+                }
+                // Strip prefix from returned name so the agent sees its logical name
+                const resultWithName = result;
+                const stripped = terminalPrefix && resultWithName.name
+                    ? {
+                        ...result,
+                        name: stripPrefix(resultWithName.name, terminalPrefix),
+                    }
+                    : result;
+                return successStructured(stripped);
+            }
+            catch (err) {
+                if (err instanceof ExtensionTimeoutError) {
+                    return error("Extension timed out — terminal features may be unavailable");
+                }
+                throw err;
+            }
+        },
+    };
+}
+export function createWaitForTerminalOutputTool(extensionClient, terminalPrefix = "") {
+    return {
+        schema: {
+            name: "waitForTerminalOutput",
+            extensionRequired: true,
+            description: "Block until regex matches terminal output. Returns {matched, matchedLine, elapsed} or timedOut.",
+            annotations: { readOnlyHint: true },
+            inputSchema: {
+                type: "object",
+                required: ["pattern"],
+                properties: {
+                    pattern: {
+                        type: "string",
+                        description: "JS regex to match against terminal output lines",
+                    },
+                    name: {
+                        type: "string",
+                        description: "Terminal name (from listTerminals). Uses active if omitted.",
+                    },
+                    index: {
+                        type: "integer",
+                        description: "Terminal index (0-based) from listTerminals. Used if name omitted.",
+                    },
+                    timeout: {
+                        type: "integer",
+                        description: "Seconds to wait (default: 30, max: 300)",
+                    },
+                },
+                additionalProperties: false,
+            },
+            outputSchema: {
+                type: "object",
+                properties: {
+                    matched: { type: "boolean" },
+                    matchedLine: { type: "string" },
+                    elapsed: { type: "integer" },
+                    timedOut: { type: "boolean" },
+                },
+                required: ["matched"],
+            },
+        },
+        // Extension adds a 5 s internal buffer on top of the user timeout — raise
+        // the tool ceiling by 10 s so the extension response always arrives before
+        // the MCP transport cancels the request.
+        timeoutMs: 610_000,
+        handler: async (args, _signal) => {
+            if (!extensionClient.isConnected()) {
+                return extensionRequired("waitForTerminalOutput");
+            }
+            const pattern = requireString(args, "pattern", 1_000);
+            const name = optionalString(args, "name", 256);
+            const index = optionalInt(args, "index", 0, 100);
+            const timeoutSec = optionalInt(args, "timeout", 1, 300) ?? 30;
+            const timeoutMs = timeoutSec * 1_000;
+            const indexErr = checkIndexWithPrefix(name, index, terminalPrefix);
+            if (indexErr)
+                return error(indexErr);
+            // Validate the regex on the bridge side to give a fast, clear error
+            try {
+                new RegExp(pattern);
+            }
+            catch (e) {
+                return error(`Invalid regex pattern: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            // Reject patterns with nested quantifiers — these can cause catastrophic backtracking (ReDoS)
+            // when tested repeatedly against terminal output lines over a long polling window.
+            if (/\([^)]*[+*]\)[+*?]/.test(pattern) ||
+                /\([^)]*\{[^}]+\}\)[+*{?]/.test(pattern) ||
+                /[+*][+*]|\{[^}]+\}[+*]/.test(pattern)) {
+                return error("Pattern contains nested quantifiers (e.g. (a+)+) which can cause catastrophic backtracking. " +
+                    "Simplify the regex — use a literal string match or a non-nested quantifier.");
+            }
+            try {
+                const result = await extensionClient.waitForTerminalOutput(pattern, prefixName(name, terminalPrefix), index, timeoutMs);
+                if (result === null) {
+                    return error("Extension did not respond — ensure the VS Code extension is running");
+                }
+                return successStructured(result);
+            }
+            catch (err) {
+                if (err instanceof ExtensionTimeoutError) {
+                    return error("Extension connection timed out waiting for terminal output");
+                }
+                throw err;
+            }
+        },
+    };
+}
+export function createRunInTerminalTool(workspace, extensionClient, commandAllowlist, terminalPrefix = "") {
+    return {
+        schema: {
+            name: "runInTerminal",
+            annotations: { destructiveHint: true, openWorldHint: true },
+            description: "Execute command and wait for completion. Returns exit code and output. Prefer over runCommand.",
+            inputSchema: {
+                type: "object",
+                required: ["command"],
+                properties: {
+                    command: {
+                        type: "string",
+                        description: "Shell command to run (no metacharacters or newlines)",
+                    },
+                    name: {
+                        type: "string",
+                        description: "Terminal name (from listTerminals). Uses active if omitted.",
+                    },
+                    index: {
+                        type: "integer",
+                        description: "Terminal index (0-based) from listTerminals. Used if name omitted.",
+                    },
+                    timeout: {
+                        type: "integer",
+                        description: "Seconds to wait for completion (default: 30, max: 300)",
+                    },
+                    show: {
+                        type: "boolean",
+                        description: "Focus terminal panel while running (default: true)",
+                    },
+                },
+                additionalProperties: false,
+            },
+            outputSchema: {
+                type: "object",
+                properties: {
+                    exitCode: { type: "integer" },
+                    stdout: { type: "string" },
+                    stderr: { type: "string" },
+                    fallback: { type: "string" },
+                },
+            },
+        },
+        // Extension adds a 5 s internal buffer on top of the user timeout — raise
+        // the tool ceiling by 10 s so the extension response always arrives before
+        // the MCP transport cancels the request.
+        timeoutMs: 610_000,
+        handler: async (args, signal) => {
+            const command = requireString(args, "command", 10_000);
+            const name = optionalString(args, "name", 256);
+            const index = optionalInt(args, "index", 0, 100);
+            const timeoutSec = optionalInt(args, "timeout", 1, 300) ?? 30;
+            const show = optionalBool(args, "show") ?? true;
+            const timeoutMs = timeoutSec * 1_000;
+            const cmdErr = validateCommand(command, commandAllowlist);
+            if (cmdErr)
+                return error(cmdErr);
+            // Attempt VS Code shell integration path when extension is connected
+            if (extensionClient.isConnected()) {
+                const indexErr = checkIndexWithPrefix(name, index, terminalPrefix);
+                if (indexErr)
+                    return error(indexErr);
+                try {
+                    const result = await extensionClient.executeInTerminal(command, prefixName(name, terminalPrefix), index, timeoutMs, show);
+                    if (result !== null) {
+                        return successStructured(result);
+                    }
+                    // null means shell integration unavailable (SSH remote, no PTY hooks)
+                    // — fall through to subprocess fallback below
+                }
+                catch (err) {
+                    if (err instanceof ExtensionTimeoutError) {
+                        // The command was already dispatched to the VS Code terminal but shell
+                        // integration did not return output in time. Do NOT fall through to the
+                        // subprocess fallback — the command may have already started running and
+                        // re-executing it would double-invoke non-idempotent operations.
+                        return error("runInTerminal timed out waiting for shell integration output. " +
+                            "The command may still be running in the VS Code terminal. " +
+                            "Use runCommand for non-interactive commands that need reliable output capture.");
+                    }
+                    throw err;
+                }
+            }
+            // Subprocess fallback: runs the command directly in the workspace using
+            // execSafe (same primitive as runCommand). This path activates when:
+            //   • The extension is not connected
+            //   • Shell integration is unavailable (SSH remote, headless VPS)
+            //   • executeInTerminal timed out waiting for a shell event
+            //
+            // The command has already passed validateCommand so first-token allowlist
+            // and metacharacter checks are satisfied. Split on whitespace for execSafe
+            // which takes argv-style args rather than a raw shell string.
+            // Reject quoted arguments — naive whitespace splitting cannot handle them
+            // correctly and would corrupt the argv array (e.g. "npm run 'my script'"
+            // becomes ["npm", "run", "'my", "script'"]). Use runCommand with an
+            // explicit args array for commands with space-containing arguments.
+            if (/"/.test(command) || /'/.test(command)) {
+                return error("runInTerminal does not support quoted arguments in the fallback (headless) path. " +
+                    "Use runCommand with an explicit args array for arguments containing spaces.");
+            }
+            const tokens = command.trim().split(/\s+/);
+            const cmd = tokens[0] ?? command;
+            const cmdArgs = tokens.slice(1);
+            const fallbackResult = await execSafe(cmd, cmdArgs, {
+                cwd: workspace,
+                timeout: timeoutMs,
+                signal: signal ?? undefined,
+            });
+            return successStructured({ ...fallbackResult, fallback: "subprocess" });
+        },
+    };
+}
+export function createDisposeTerminalTool(extensionClient, terminalPrefix = "") {
+    return {
+        schema: {
+            name: "disposeTerminal",
+            extensionRequired: true,
+            description: "Close a VS Code terminal by name or index.",
+            annotations: { destructiveHint: true },
+            inputSchema: {
+                type: "object",
+                properties: {
+                    name: {
+                        type: "string",
+                        description: "Terminal name to dispose",
+                    },
+                    index: {
+                        type: "integer",
+                        description: "Terminal index (0-based) from listTerminals",
+                    },
+                },
+                additionalProperties: false,
+            },
+            outputSchema: {
+                type: "object",
+                properties: {
+                    disposed: { type: "boolean" },
+                },
+            },
+        },
+        handler: async (args, _signal) => {
+            if (!extensionClient.isConnected()) {
+                return extensionRequired("disposeTerminal");
+            }
+            const name = optionalString(args, "name", 256);
+            const index = optionalInt(args, "index", 0, 100);
+            if (name === undefined && index === undefined) {
+                return error("At least one of 'name' or 'index' must be provided to identify the terminal");
+            }
+            const indexErr = checkIndexWithPrefix(name, index, terminalPrefix);
+            if (indexErr)
+                return error(indexErr);
+            try {
+                const result = await extensionClient.disposeTerminal(prefixName(name, terminalPrefix), index);
+                if (result === null) {
+                    return error("Terminal not found");
+                }
+                return successStructured(result);
+            }
+            catch (err) {
+                if (err instanceof ExtensionTimeoutError) {
+                    return error("Extension timed out — terminal features may be unavailable");
+                }
+                throw err;
+            }
+        },
+    };
+}
+export function createSendTerminalCommandTool(extensionClient, commandAllowlist, terminalPrefix = "") {
+    return {
+        schema: {
+            name: "sendTerminalCommand",
+            extensionRequired: true,
+            annotations: { destructiveHint: true, openWorldHint: true },
+            description: "Send text/command to VS Code terminal. Fire-and-forget; use getTerminalOutput to check results.",
+            inputSchema: {
+                type: "object",
+                required: ["text"],
+                properties: {
+                    text: {
+                        type: "string",
+                        description: "Text or command to send to the terminal",
+                    },
+                    name: {
+                        type: "string",
+                        description: "Terminal name to send to",
+                    },
+                    index: {
+                        type: "integer",
+                        description: "Terminal index (0-based) from listTerminals",
+                    },
+                    addNewline: {
+                        type: "boolean",
+                        description: "Append newline to execute as command (default: true)",
+                    },
+                    isCommand: {
+                        type: "boolean",
+                        description: "False for short stdin responses to prompts (max 512 chars, no shell metacharacters).",
+                    },
+                },
+                additionalProperties: false,
+            },
+            outputSchema: {
+                type: "object",
+                properties: {
+                    sent: { type: "boolean" },
+                },
+            },
+        },
+        handler: async (args, _signal) => {
+            if (!extensionClient.isConnected()) {
+                return extensionRequired("sendTerminalCommand");
+            }
+            const text = requireString(args, "text", 10_000);
+            const name = optionalString(args, "name", 256);
+            const index = optionalInt(args, "index", 0, 100);
+            const addNewline = optionalBool(args, "addNewline") ?? true;
+            const isCommand = optionalBool(args, "isCommand") ?? true;
+            if (name === undefined && index === undefined) {
+                return error("At least one of 'name' or 'index' must be provided to identify the terminal");
+            }
+            const indexErr = checkIndexWithPrefix(name, index, terminalPrefix);
+            if (indexErr)
+                return error(indexErr);
+            if (isCommand) {
+                const cmdErr = validateCommand(text, commandAllowlist);
+                if (cmdErr)
+                    return error(cmdErr);
+            }
+            else {
+                // isCommand:false is for short stdin responses to interactive prompts only.
+                // Enforce a tight length cap and block shell metacharacters to prevent
+                // this path from being used as an allowlist bypass for arbitrary shell commands.
+                if (text.length > 512) {
+                    return error("isCommand:false input must be 512 characters or fewer (stdin prompt responses only)");
+                }
+                if (/[|&;<>`$(){}[\]\n\r]/.test(text)) {
+                    return error("isCommand:false input must not contain shell metacharacters (|, &, ;, <, >, `, $, (, ), {, }, [, ], newlines). Use isCommand:true for shell commands.");
+                }
+                // Reject ASCII control characters (below 0x20, excluding tab)
+                // to prevent terminal injection via Ctrl-C (0x03), Ctrl-D (0x04), etc.
+                if (/[\x00-\x08\x0b-\x1f\x7f]/.test(text)) {
+                    return error("isCommand:false input must not contain ASCII control characters (Ctrl-C, Ctrl-D, ESC, etc.).");
+                }
+            }
+            try {
+                const result = await extensionClient.sendTerminalCommand(text, prefixName(name, terminalPrefix), index, addNewline);
+                if (result === null) {
+                    return error("Failed to send command to terminal");
+                }
+                return successStructured(result);
+            }
+            catch (err) {
+                if (err instanceof ExtensionTimeoutError) {
+                    return error("Extension timed out — terminal features may be unavailable");
+                }
+                throw err;
+            }
+        },
+    };
+}
+//# sourceMappingURL=terminal.js.map