centaurus-cli 3.0.0 → 3.1.0

package/dist/tools/command.js

@@ -1,462 +1,469 @@
-import * as shellUtils from '../utils/shell.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import { runWSLCommand, runDockerCommand, runSSHCommand } from '../utils/editor-utils.js';
-// Helper to process shell input with escape sequences and special keys
+import * as shellUtils from "../utils/shell.js";
+import * as fs from "fs";
+import * as path from "path";
+import { runWSLCommand, runDockerCommand, runSSHCommand } from "../utils/editor-utils.js";
 function processShellInput(input) {
-    let processed = input
-        // Handle standard escape sequences
-        .replace(/\\n/g, '\r') // Use \r for Enter/Newline in interactive shell
-        .replace(/\\r/g, '\r')
-        .replace(/\\t/g, '\t')
-        .replace(/\\b/g, '\b')
-        .replace(/\\x1B/g, '\x1B');
-    // Handle special key codes
-    const keyMap = {
-        '[UP]': '\u001b[A',
-        '[DOWN]': '\u001b[B',
-        '[RIGHT]': '\u001b[C',
-        '[LEFT]': '\u001b[D',
-        '[ENTER]': '\r', // Enter key sends CR
-        '[TAB]': '\t',
-        '[ESC]': '\u001b',
-        '[BACKSPACE]': '\b',
-        '[CTRL+C]': '\u0003',
-        '[CTRL+D]': '\u0004',
-        '[CTRL+Z]': '\u001a'
-    };
-    // Replace special keys
-    for (const [key, code] of Object.entries(keyMap)) {
-        processed = processed.split(key).join(code);
-    }
-    return processed;
+  let processed = input.replace(/\\n/g, "\r").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\b/g, "\b").replace(/\\x1B/g, "\x1B");
+  const keyMap = {
+    "[UP]": "\x1B[A",
+    "[DOWN]": "\x1B[B",
+    "[RIGHT]": "\x1B[C",
+    "[LEFT]": "\x1B[D",
+    "[ENTER]": "\r",
+    // Enter key sends CR
+    "[TAB]": "	",
+    "[ESC]": "\x1B",
+    "[BACKSPACE]": "\b",
+    "[CTRL+C]": "",
+    "[CTRL+D]": "",
+    "[CTRL+Z]": ""
+  };
+  for (const [key, code] of Object.entries(keyMap)) {
+    processed = processed.split(key).join(code);
+  }
+  return processed;
+}
+function resolveCommandWorkingDirectory(currentContext, contextCwd, commandCwd) {
+  if (currentContext.type === "local") {
+    return commandCwd ? path.resolve(contextCwd, commandCwd) : contextCwd;
+  }
+  const remoteBase = currentContext.metadata?.workingDirectory || contextCwd || "~";
+  if (!commandCwd) {
+    return remoteBase;
+  }
+  return path.posix.isAbsolute(commandCwd) ? commandCwd : path.posix.join(remoteBase, commandCwd);
 }
-export const runCommandTool = {
-    schema: {
-        name: 'execute_command',
-        description: `PROPOSE a command to run on behalf of the user. Operating System: windows. Shell: pwsh.
-**NEVER PROPOSE A cd COMMAND**.
-If you have this tool, note that you DO have the ability to run commands directly on the USER's system.
-Make sure to specify CommandLine exactly as it should be run in the shell.
-Note that the user will have to approve the command before it is executed. The user may reject it if it is not to their liking.
-The actual command will NOT execute until the user approves it. The user may not approve it immediately.
-If the step is WAITING for user approval, it has NOT started running.
-If the step returns a command id, it means that the command was sent to the background. You should use the command_status tool to monitor the output and status of the command.
+const runCommandTool = {
+  schema: {
+    name: "execute_command",
+    description: `PROPOSE a command to run on behalf of the user. Operating System: windows. Shell: pwsh.
+**NEVER PROPOSE A cd COMMAND**.
+If you have this tool, note that you DO have the ability to run commands directly on the USER's system.
+Make sure to specify CommandLine exactly as it should be run in the shell.
+Note that the user will have to approve the command before it is executed. The user may reject it if it is not to their liking.
+The actual command will NOT execute until the user approves it. The user may not approve it immediately.
+If the step is WAITING for user approval, it has NOT started running.
+If the step returns a command id, it means that the command was sent to the background. You should use the command_status tool to monitor the output and status of the command.
 Commands will be run with PAGER=cat. You may want to limit the length of output for commands that usually rely on paging and may contain very long output (e.g. git log, use git log -n <N>).`,
-        parameters: {
-            type: 'object',
-            properties: {
-                reason_text: {
-                    type: 'string',
-                    description: 'REQUIRED: A brief explanation of why you are executing this command and what you expect it to do. This will be shown to the user. Example: "Running npm install to install the project dependencies"',
-                },
-                CommandLine: {
-                    type: 'string',
-                    description: 'The exact command line string to execute.',
-                },
-                Cwd: {
-                    type: 'string',
-                    description: 'The current working directory for the command',
-                },
-                SafeToAutoRun: {
-                    type: 'boolean',
-                    description: 'Set to true if you believe that this command is safe to run WITHOUT user approval. A command is unsafe if it may have some destructive side-effects. Example unsafe side-effects include: deleting files, mutating state, installing system dependencies, making external requests, etc. Set to true only if you are extremely confident it is safe. If you feel the command could be unsafe, never set this to true, EVEN if the USER asks you to. It is imperative that you never auto-run a potentially unsafe command.',
-                },
-                WaitMsBeforeAsync: {
-                    type: 'integer',
-                    description: 'This specifies the number of milliseconds to wait after starting the command before sending it to the background. If you want the command to complete execution synchronously, set this to a large enough value that you expect the command to complete in that time under ordinary circumstances. If you\'re starting an interactive or long-running command, set it to a large enough value that it would cause possible failure cases to execute synchronously (e.g. 500ms). Keep the value as small as possible, with a maximum of 10000ms.',
-                },
-                shell_input: {
-                    type: 'string',
-                    description: '[INTERNAL - DO NOT USE FROM MAIN AGENT] Input to send to a CURRENTLY RUNNING interactive shell. This parameter is used internally by the shell input sub-agent. When starting a command, do NOT set this parameter - just start the command and the user will provide input through the shell UI or agent control mode.',
-                },
-            },
-            required: ['reason_text', 'CommandLine', 'Cwd', 'SafeToAutoRun', 'WaitMsBeforeAsync'],
+    parameters: {
+      type: "object",
+      properties: {
+        reason_text: {
+          type: "string",
+          description: 'REQUIRED: A brief explanation of why you are executing this command and what you expect it to do. This will be shown to the user. Example: "Running npm install to install the project dependencies"'
         },
-    },
-    async execute(args, context) {
-        const { CommandLine, Cwd, shell_input } = args;
-        // Handle shell_input action - send input to a running shell
-        // NOTE: shell_input should only be used by ShellInputAgent, not the main agent
-        if (shell_input) {
-            if (context.cliAdapter) {
-                const interactiveProcess = context.cliAdapter.getCurrentInteractiveProcess();
-                if (!interactiveProcess) {
-                    // Provide a helpful error message guiding the correct approach
-                    throw new Error(`Cannot use shell_input when no interactive shell is running. ` +
-                        `To run an interactive command:\n` +
-                        `1. First, run the command WITHOUT shell_input - just use CommandLine\n` +
-                        `2. The interactive shell will open and you can provide input there\n` +
-                        `3. Agent Control mode (if enabled) will automatically handle input prompts\n\n` +
-                        `Please retry: run the command first, then input will be handled automatically.`);
+        CommandLine: {
+          type: "string",
+          description: "The exact command line string to execute."
+        },
+        Cwd: {
+          type: "string",
+          description: "The current working directory for the command"
+        },
+        SafeToAutoRun: {
+          type: "boolean",
+          description: "Set to true if you believe that this command is safe to run WITHOUT user approval. A command is unsafe if it may have some destructive side-effects. Example unsafe side-effects include: deleting files, mutating state, installing system dependencies, making external requests, etc. Set to true only if you are extremely confident it is safe. If you feel the command could be unsafe, never set this to true, EVEN if the USER asks you to. It is imperative that you never auto-run a potentially unsafe command."
+        },
+        WaitMsBeforeAsync: {
+          type: "integer",
+          description: "This specifies the number of milliseconds to wait after starting the command before sending it to the background. If you want the command to complete execution synchronously, set this to a large enough value that you expect the command to complete in that time under ordinary circumstances. If you're starting an interactive or long-running command, set it to a large enough value that it would cause possible failure cases to execute synchronously (e.g. 500ms). Keep the value as small as possible, with a maximum of 10000ms."
+        },
+        shell_input: {
+          type: "string",
+          description: "[INTERNAL - DO NOT USE FROM MAIN AGENT] Input to send to a CURRENTLY RUNNING interactive shell. This parameter is used internally by the shell input sub-agent. When starting a command, do NOT set this parameter - just start the command and the user will provide input through the shell UI or agent control mode."
+        }
+      },
+      required: ["reason_text", "CommandLine", "Cwd", "SafeToAutoRun", "WaitMsBeforeAsync"]
+    }
+  },
+  async execute(args, context) {
+    const { CommandLine, Cwd, shell_input } = args;
+    if (shell_input) {
+      if (context.cliAdapter) {
+        const interactiveProcess = context.cliAdapter.getCurrentInteractiveProcess();
+        if (!interactiveProcess) {
+          throw new Error(
+            `Cannot use shell_input when no interactive shell is running. To run an interactive command:
+1. First, run the command WITHOUT shell_input - just use CommandLine
+2. The interactive shell will open and you can provide input there
+3. Agent Control mode (if enabled) will automatically handle input prompts
+
+Please retry: run the command first, then input will be handled automatically.`
+          );
+        }
+        const processedInput = processShellInput(shell_input);
+        interactiveProcess.write(processedInput);
+        const readableSent = processedInput.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\x1B/g, "^[").replace(/\u0003/g, "^C");
+        return `Sent input to active shell: ${readableSent}`;
+      } else {
+        throw new Error("CLI adapter not available for shell input.");
+      }
+    }
+    const command = CommandLine;
+    const contextManager = context.contextManager;
+    const currentContext = contextManager.getCurrentContext();
+    const isChainedCommand = /&&|;/.test(command);
+    const cdMatch = !isChainedCommand && command.match(/^cd\s+(.+)$/);
+    if (cdMatch) {
+      if (currentContext.type === "local") {
+        const targetDir = cdMatch[1].trim();
+        const newCwd = path.resolve(Cwd || context.cwd, targetDir);
+        if (!fs.existsSync(newCwd)) {
+          throw new Error(`Directory not found: ${targetDir}
+
+Action: Use 'list_directory' to verify the directory structure.`);
+        }
+        if (!fs.statSync(newCwd).isDirectory()) {
+          throw new Error(`Path is not a directory: ${targetDir}
+
+Action: Verify the path points to a directory, not a file.`);
+        }
+        contextManager.updateWorkingDirectory(newCwd);
+        if (context.cliAdapter) {
+          context.cliAdapter.cwd = newCwd;
+          if (context.cliAdapter.onCwdChange) {
+            context.cliAdapter.onCwdChange(newCwd);
+          }
+        }
+        return `Changed directory to: ${newCwd}`;
+      } else {
+        const targetDir = cdMatch[1].trim();
+        const result = await contextManager.executeCommand(`cd ${targetDir}`);
+        if (result.exitCode === 0) {
+          if (currentContext.handler) {
+            const newCwd = await currentContext.handler.getCurrentWorkingDirectory();
+            if (newCwd) {
+              contextManager.updateWorkingDirectory(newCwd);
+              if (context.cliAdapter) {
+                context.cliAdapter.cwd = newCwd;
+                if (context.cliAdapter.onCwdChange) {
+                  context.cliAdapter.onCwdChange(newCwd);
                 }
-                // Process input to handle escapes and special keys
-                const processedInput = processShellInput(shell_input);
-                // Send the processed input
-                interactiveProcess.write(processedInput);
-                // Return readable confirmation (showing what was actually sent)
-                const readableSent = processedInput
-                    .replace(/\n/g, '\\n')
-                    .replace(/\r/g, '\\r')
-                    .replace(/\x1B/g, '^[')
-                    .replace(/\u0003/g, '^C');
-                return `Sent input to active shell: ${readableSent}`;
-            }
-            else {
-                throw new Error('CLI adapter not available for shell input.');
+              }
             }
+          }
+          return `Changed directory to: ${contextManager.getCurrentContext().metadata.workingDirectory}`;
+        } else {
+          throw new Error(`${result.stderr || "Failed to change directory"}
+
+Action: Verify the directory exists in the remote environment.`);
         }
-        const command = CommandLine; // Map to internal variable
-        const contextManager = context.contextManager;
-        const currentContext = contextManager.getCurrentContext();
-        // Special handling for cd command - change the actual working directory
-        // Only intercept simple cd commands, not chained ones (cd path && cmd, cd path; cmd)
-        // Chained commands will be executed by the shell directly
-        const isChainedCommand = /&&|;/.test(command);
-        const cdMatch = !isChainedCommand && command.match(/^cd\s+(.+)$/);
-        if (cdMatch) {
-            if (currentContext.type === 'local') {
-                const targetDir = cdMatch[1].trim();
-                const newCwd = path.resolve(Cwd || context.cwd, targetDir);
-                if (!fs.existsSync(newCwd)) {
-                    throw new Error(`Directory not found: ${targetDir}\n\nAction: Use 'list_directory' to verify the directory structure.`);
-                }
-                if (!fs.statSync(newCwd).isDirectory()) {
-                    throw new Error(`Path is not a directory: ${targetDir}\n\nAction: Verify the path points to a directory, not a file.`);
-                }
-                contextManager.updateWorkingDirectory(newCwd);
-                // Update CLI adapter CWD and notify UI
-                if (context.cliAdapter) {
-                    context.cliAdapter.cwd = newCwd;
-                    if (context.cliAdapter.onCwdChange) {
-                        context.cliAdapter.onCwdChange(newCwd);
-                    }
-                }
-                return `Changed directory to: ${newCwd}`;
+      }
+    }
+    const longRunningPatterns = [
+      /npm\s+run\s+dev/,
+      /npm\s+run\s+start/,
+      /npm\s+start/,
+      /yarn\s+dev/,
+      /yarn\s+start/,
+      /pnpm\s+dev/,
+      /pnpm\s+start/,
+      /python\s+-m\s+http\.server/,
+      /python3\s+-m\s+http\.server/,
+      /php\s+-S/,
+      /ruby\s+-run\s+-e\s+httpd/,
+      /serve\s+/,
+      /http-server/,
+      /webpack\s+--watch/,
+      /webpack-dev-server/,
+      /vite(?:\s+(?!build)|\s*$)/,
+      /next\s+dev/,
+      /gatsby\s+develop/,
+      /rails\s+server/,
+      /rails\s+s\b/,
+      /django\s+runserver/,
+      /manage\.py\s+runserver/,
+      /flask\s+run/,
+      /nodemon/,
+      /ng\s+serve/,
+      /ember\s+serve/,
+      /hugo\s+server/,
+      /jekyll\s+serve/,
+      /docker\s+run.*-d/,
+      /docker-compose\s+up/,
+      /tail\s+-f/,
+      /watch\s+/,
+      /less\s+/,
+      /more\s+/,
+      /vim\s+/,
+      /vi\s+/,
+      /nano\s+/,
+      /emacs\s+/
+    ];
+    const isLongRunning = longRunningPatterns.some((pattern) => pattern.test(command));
+    if (isLongRunning) {
+      throw new Error(
+        `This command appears to be a long-running process (like a development server or file watcher). Long-running commands cannot be executed through execute_command as they would block execution.
+
+USE THE background_command TOOL INSTEAD:
+- action: "start" to run the command in the background
+- action: "status" to check the output while it runs
+- action: "kill" to terminate when done
+
+Command that needs background execution: ${command}`
+      );
+    }
+    const riskyPatterns = [/rm\s+-rf/, /del\s+\/s/, /format/, /dd\s+if=/];
+    const isRisky = riskyPatterns.some((pattern) => pattern.test(command));
+    const approved = await context.requireApproval(
+      `Execute command: ${command}${currentContext.type !== "local" ? ` (in ${currentContext.type} environment)` : ""}`,
+      isRisky,
+      void 0,
+      "execute_command",
+      { command }
+    );
+    if (typeof approved === "object" && "feedback" in approved) {
+      throw new Error(`USER_FEEDBACK: ${approved.feedback}`);
+    }
+    if (!approved) {
+      throw new Error("Operation cancelled by user.");
+    }
+    const executionCwd = resolveCommandWorkingDirectory(currentContext, context.cwd, Cwd);
+    if (currentContext.type === "local") {
+      return new Promise((resolve, reject) => {
+        let output = "";
+        let exitCode;
+        const interactiveProcess = shellUtils.executeCommandInteractive(
+          command,
+          executionCwd,
+          (data) => {
+            output += data;
+            if (context.onStreamingOutput) {
+              context.onStreamingOutput(data, "stdout");
             }
-            else {
-                // Execute cd in subshell and update working directory
-                const targetDir = cdMatch[1].trim();
-                const result = await contextManager.executeCommand(`cd ${targetDir}`);
-                if (result.exitCode === 0) {
-                    // Get the actual new working directory from the handler
-                    if (currentContext.handler) {
-                        const newCwd = await currentContext.handler.getCurrentWorkingDirectory();
-                        if (newCwd) {
-                            contextManager.updateWorkingDirectory(newCwd);
-                            // Update CLI adapter CWD and notify UI
-                            if (context.cliAdapter) {
-                                context.cliAdapter.cwd = newCwd;
-                                if (context.cliAdapter.onCwdChange) {
-                                    context.cliAdapter.onCwdChange(newCwd);
-                                }
-                            }
-                        }
-                    }
-                    return `Changed directory to: ${contextManager.getCurrentContext().metadata.workingDirectory}`;
-                }
-                else {
-                    throw new Error(`${result.stderr || 'Failed to change directory'}\n\nAction: Verify the directory exists in the remote environment.`);
-                }
+          },
+          (code) => {
+            exitCode = code;
+            if (context.cliAdapter) {
+              context.cliAdapter.setCurrentInteractiveProcess(void 0);
             }
+            if (code === 0) {
+              resolve(output || "Command executed successfully");
+            } else {
+              const errorOutput = output + `
+Exit Code: ${code}`;
+              reject(new Error(`${errorOutput || `Command failed with exit code ${code}`}
+
+Possible reasons:
+1. The command is invalid or not installed.
+2. The arguments are incorrect.
+3. The command requires user input (interactive mode).`));
+            }
+          }
+        );
+        if (context.cliAdapter) {
+          context.cliAdapter.setCurrentInteractiveProcess(interactiveProcess);
         }
-        // Check for long-running commands
-        const longRunningPatterns = [
-            /npm\s+run\s+dev/,
-            /npm\s+run\s+start/,
-            /npm\s+start/,
-            /yarn\s+dev/,
-            /yarn\s+start/,
-            /pnpm\s+dev/,
-            /pnpm\s+start/,
-            /python\s+-m\s+http\.server/,
-            /python3\s+-m\s+http\.server/,
-            /php\s+-S/,
-            /ruby\s+-run\s+-e\s+httpd/,
-            /serve\s+/,
-            /http-server/,
-            /webpack\s+--watch/,
-            /webpack-dev-server/,
-            /vite(?:\s+(?!build)|\s*$)/,
-            /next\s+dev/,
-            /gatsby\s+develop/,
-            /rails\s+server/,
-            /rails\s+s\b/,
-            /django\s+runserver/,
-            /manage\.py\s+runserver/,
-            /flask\s+run/,
-            /nodemon/,
-            /ng\s+serve/,
-            /ember\s+serve/,
-            /hugo\s+server/,
-            /jekyll\s+serve/,
-            /docker\s+run.*-d/,
-            /docker-compose\s+up/,
-            /tail\s+-f/,
-            /watch\s+/,
-            /less\s+/,
-            /more\s+/,
-            /vim\s+/,
-            /vi\s+/,
-            /nano\s+/,
-            /emacs\s+/,
-        ];
-        const isLongRunning = longRunningPatterns.some((pattern) => pattern.test(command));
-        if (isLongRunning) {
-            throw new Error(`This command appears to be a long-running process (like a development server or file watcher). ` +
-                `Long-running commands cannot be executed through execute_command as they would block execution.\n\n` +
-                `USE THE background_command TOOL INSTEAD:\n` +
-                `- action: "start" to run the command in the background\n` +
-                `- action: "status" to check the output while it runs\n` +
-                `- action: "kill" to terminate when done\n\n` +
-                `Command that needs background execution: ${command}`);
-        }
-        // Check for risky commands
-        const riskyPatterns = [/rm\s+-rf/, /del\s+\/s/, /format/, /dd\s+if=/];
-        const isRisky = riskyPatterns.some((pattern) => pattern.test(command));
-        const approved = await context.requireApproval(`Execute command: ${command}${currentContext.type !== 'local' ? ` (in ${currentContext.type} environment)` : ''}`, isRisky, undefined, 'execute_command', { command });
-        // Check for feedback object (user rejected with feedback)
-        if (typeof approved === 'object' && 'feedback' in approved) {
-            throw new Error(`USER_FEEDBACK: ${approved.feedback}`);
+      });
+    } else if (currentContext.type === "wsl") {
+      const remoteCwd = executionCwd;
+      const distribution = currentContext.metadata?.distroName || "Ubuntu";
+      return new Promise((resolve, reject) => {
+        let output = "";
+        const constrainedCols = Math.max(40, (process.stdout.columns || 80) - 4);
+        const constrainedRows = Math.min(process.stdout.rows || 24, 50);
+        const wslPty = runWSLCommand(
+          distribution,
+          command,
+          remoteCwd,
+          (data) => {
+            output += data;
+            if (context.onStreamingOutput) {
+              context.onStreamingOutput(data, "stdout");
+            }
+          },
+          (exitCode) => {
+            if (context.cliAdapter) {
+              context.cliAdapter.setCurrentInteractiveProcess(void 0);
+            }
+            if (exitCode !== 0) {
+              reject(new Error(`${output || `Command failed with exit code ${exitCode}`}
+
+Possible reasons:
+1. The command is invalid or not installed.
+2. The arguments are incorrect.`));
+            } else {
+              resolve(output || "Command executed successfully");
+            }
+          },
+          constrainedCols,
+          constrainedRows
+        );
+        if (context.cliAdapter) {
+          context.cliAdapter.setCurrentInteractiveProcess({
+            process: null,
+            write: (data) => wslPty.write(data),
+            kill: () => wslPty.kill(),
+            signal: (sig) => {
+              if (sig === "SIGINT") {
+                wslPty.write("");
+              }
+            },
+            resize: (cols, rows) => wslPty.resize(cols, rows),
+            isPty: true
+          });
         }
-        // Check for boolean false (user rejected)
-        if (!approved) {
-            throw new Error('Operation cancelled by user.');
+      });
+    } else if (currentContext.type === "docker") {
+      const parentContext = contextManager.getParentContext();
+      const remoteCwd = executionCwd;
+      const containerId = currentContext.metadata?.containerId || "";
+      const constrainedCols = Math.max(40, (process.stdout.columns || 80) - 4);
+      const constrainedRows = Math.min(process.stdout.rows || 24, 50);
+      if (parentContext && parentContext.type === "ssh") {
+        const sshClient = parentContext.handler?.client;
+        if (!sshClient) {
+          throw new Error("SSH client not available for nested Docker session");
         }
-        // Execute command with interactive support (allows user input via stdin)
-        if (currentContext.type === 'local') {
-            // Use interactive process for full stdin/stdout/stderr support
-            return new Promise((resolve, reject) => {
-                let output = '';
-                let exitCode;
-                // Start interactive process
-                const interactiveProcess = shellUtils.executeCommandInteractive(command, 
-                // Resolve Cwd against context.cwd if provided, otherwise use context.cwd
-                // This handles cases where Cwd is "." or relative path
-                Cwd ? path.resolve(context.cwd, Cwd) : context.cwd, (data) => {
-                    // Accumulate output
-                    output += data;
-                    // Stream to UI if callback is available
-                    if (context.onStreamingOutput) {
-                        context.onStreamingOutput(data, 'stdout');
-                    }
-                }, (code) => {
-                    // Process exited
-                    exitCode = code;
-                    // Clear the interactive process reference
-                    if (context.cliAdapter) {
-                        context.cliAdapter.setCurrentInteractiveProcess(undefined);
-                    }
-                    // Resolve or reject based on exit code
-                    if (code === 0) {
-                        resolve(output || 'Command executed successfully');
-                    }
-                    else {
-                        const errorOutput = output + `\nExit Code: ${code}`;
-                        reject(new Error(`${errorOutput || `Command failed with exit code ${code}`}\n\nPossible reasons:\n1. The command is invalid or not installed.\n2. The arguments are incorrect.\n3. The command requires user input (interactive mode).`));
-                    }
-                });
-                // Store the interactive process reference so user can send input
-                if (context.cliAdapter) {
-                    context.cliAdapter.setCurrentInteractiveProcess(interactiveProcess);
+        const escapedCommand = command.replace(/"/g, '\\"');
+        const dockerCommand = `docker exec -w "${remoteCwd}" ${containerId} sh -c "${escapedCommand}"`;
+        return new Promise((resolve, reject) => {
+          let output = "";
+          const sshPty = runSSHCommand(
+            sshClient,
+            dockerCommand,
+            parentContext.metadata.workingDirectory || "~",
+            (data) => {
+              output += data;
+              if (context.onStreamingOutput) {
+                context.onStreamingOutput(data, "stdout");
+              }
+            },
+            (exitCode) => {
+              if (context.cliAdapter) {
+                context.cliAdapter.setCurrentInteractiveProcess(void 0);
+              }
+              if (exitCode !== 0) {
+                reject(new Error(`${output || `Command failed with exit code ${exitCode}`}
+
+Possible reasons:
+1. The command is invalid or not installed in the container.
+2. The arguments are incorrect.
+3. The Docker container may not be running.`));
+              } else {
+                resolve(output || "Command executed successfully");
+              }
+            },
+            constrainedCols,
+            constrainedRows
+          );
+          if (context.cliAdapter) {
+            context.cliAdapter.setCurrentInteractiveProcess({
+              process: null,
+              write: (data) => sshPty.write(data),
+              kill: () => sshPty.kill(),
+              signal: (sig) => {
+                if (sig === "SIGINT") {
+                  sshPty.write("");
                 }
+              },
+              resize: (cols, rows) => sshPty.resize(cols, rows),
+              isPty: true
             });
-        }
-        else if (currentContext.type === 'wsl') {
-            // WSL execution with PTY for proper TTY handling (sudo, etc.)
-            // Resolve Cwd against context known CWD (remote or local tracking)
-            // Note: complex relative paths in WSL might need more handling if they cross mounts,
-            // but usually Cwd is absolute or simple relative.
-            const baseCwd = context.cwd || currentContext.metadata.workingDirectory;
-            const remoteCwd = Cwd ? (path.isAbsolute(Cwd) ? Cwd : path.posix.join(baseCwd, Cwd)) : baseCwd;
-            const distribution = currentContext.metadata?.distroName || 'Ubuntu';
-            return new Promise((resolve, reject) => {
-                let output = '';
-                // Calculate constrained terminal dimensions for proper escape sequence handling
-                // Reduce width to account for UI borders/padding (~4 chars for left+right borders/padding)
-                // Reduce height to account for available display area in InteractiveShell
-                const constrainedCols = Math.max(40, (process.stdout.columns || 80) - 4);
-                const constrainedRows = Math.min(process.stdout.rows || 24, 50);
-                const wslPty = runWSLCommand(distribution, command, remoteCwd, (data) => {
-                    // Stream output to UI
-                    output += data;
-                    if (context.onStreamingOutput) {
-                        context.onStreamingOutput(data, 'stdout');
-                    }
-                }, (exitCode) => {
-                    // Clear the interactive process
-                    if (context.cliAdapter) {
-                        context.cliAdapter.setCurrentInteractiveProcess(undefined);
-                    }
-                    if (exitCode !== 0) {
-                        reject(new Error(`${output || `Command failed with exit code ${exitCode}`}\n\nPossible reasons:\n1. The command is invalid or not installed.\n2. The arguments are incorrect.`));
-                    }
-                    else {
-                        resolve(output || 'Command executed successfully');
-                    }
-                }, constrainedCols, constrainedRows);
-                // Set up interactive process for stdin
-                if (context.cliAdapter) {
-                    context.cliAdapter.setCurrentInteractiveProcess({
-                        process: null,
-                        write: (data) => wslPty.write(data),
-                        kill: () => wslPty.kill(),
-                        signal: (sig) => {
-                            if (sig === 'SIGINT') {
-                                wslPty.write('\x03'); // Ctrl+C
-                            }
-                        },
-                        resize: (cols, rows) => wslPty.resize(cols, rows),
-                        isPty: true
-                    });
+          }
+        });
+      } else {
+        return new Promise((resolve, reject) => {
+          let output = "";
+          const dockerPty = runDockerCommand(
+            containerId,
+            command,
+            remoteCwd,
+            (data) => {
+              output += data;
+              if (context.onStreamingOutput) {
+                context.onStreamingOutput(data, "stdout");
+              }
+            },
+            (exitCode) => {
+              if (context.cliAdapter) {
+                context.cliAdapter.setCurrentInteractiveProcess(void 0);
+              }
+              if (exitCode !== 0) {
+                reject(new Error(`${output || `Command failed with exit code ${exitCode}`}
+
+Possible reasons:
+1. The command is invalid or not installed.
+2. The arguments are incorrect.`));
+              } else {
+                resolve(output || "Command executed successfully");
+              }
+            },
+            constrainedCols,
+            constrainedRows
+          );
+          if (context.cliAdapter) {
+            context.cliAdapter.setCurrentInteractiveProcess({
+              process: null,
+              write: (data) => dockerPty.write(data),
+              kill: () => dockerPty.kill(),
+              signal: (sig) => {
+                if (sig === "SIGINT") {
+                  dockerPty.write("");
                 }
+              },
+              resize: (cols, rows) => dockerPty.resize(cols, rows),
+              isPty: true
             });
-        }
-        else if (currentContext.type === 'docker') {
-            // Docker execution - check if nested inside SSH
-            const parentContext = contextManager.getParentContext();
-            // Resolve Cwd
-            const baseCwd = context.cwd || currentContext.metadata.workingDirectory;
-            const remoteCwd = Cwd ? (path.isAbsolute(Cwd) ? Cwd : path.posix.join(baseCwd, Cwd)) : baseCwd;
-            const containerId = currentContext.metadata?.containerId || '';
-            // Calculate constrained terminal dimensions for proper escape sequence handling
-            const constrainedCols = Math.max(40, (process.stdout.columns || 80) - 4);
-            const constrainedRows = Math.min(process.stdout.rows || 24, 50);
-            if (parentContext && parentContext.type === 'ssh') {
-                // Nested Docker inside SSH: route docker exec command through SSH
-                const sshClient = parentContext.handler?.client;
-                if (!sshClient) {
-                    throw new Error('SSH client not available for nested Docker session');
-                }
-                // Build docker exec command to run via SSH
-                // Escape the command properly for nested shell execution
-                const escapedCommand = command.replace(/"/g, '\\"');
-                const dockerCommand = `docker exec -w "${remoteCwd}" ${containerId} sh -c "${escapedCommand}"`;
-                return new Promise((resolve, reject) => {
-                    let output = '';
-                    const sshPty = runSSHCommand(sshClient, dockerCommand, parentContext.metadata.workingDirectory || '~', (data) => {
-                        // Stream output to UI
-                        output += data;
-                        if (context.onStreamingOutput) {
-                            context.onStreamingOutput(data, 'stdout');
-                        }
-                    }, (exitCode) => {
-                        // Clear the interactive process
-                        if (context.cliAdapter) {
-                            context.cliAdapter.setCurrentInteractiveProcess(undefined);
-                        }
-                        if (exitCode !== 0) {
-                            reject(new Error(`${output || `Command failed with exit code ${exitCode}`}\n\nPossible reasons:\n1. The command is invalid or not installed in the container.\n2. The arguments are incorrect.\n3. The Docker container may not be running.`));
-                        }
-                        else {
-                            resolve(output || 'Command executed successfully');
-                        }
-                    }, constrainedCols, constrainedRows);
-                    // Set up interactive process for stdin
-                    if (context.cliAdapter) {
-                        context.cliAdapter.setCurrentInteractiveProcess({
-                            process: null,
-                            write: (data) => sshPty.write(data),
-                            kill: () => sshPty.kill(),
-                            signal: (sig) => {
-                                if (sig === 'SIGINT') {
-                                    sshPty.write('\x03'); // Ctrl+C
-                                }
-                            },
-                            resize: (cols, rows) => sshPty.resize(cols, rows),
-                            isPty: true
-                        });
-                    }
-                });
+          }
+        });
+      }
+    } else if (currentContext.type === "ssh") {
+      const remoteCwd = executionCwd;
+      const sshClient = currentContext.handler?.client;
+      if (!sshClient) {
+        throw new Error("SSH client not available");
+      }
+      return new Promise((resolve, reject) => {
+        let output = "";
+        const constrainedCols = Math.max(40, (process.stdout.columns || 80) - 4);
+        const constrainedRows = Math.min(process.stdout.rows || 24, 50);
+        const sshPty = runSSHCommand(
+          sshClient,
+          command,
+          remoteCwd,
+          (data) => {
+            output += data;
+            if (context.onStreamingOutput) {
+              context.onStreamingOutput(data, "stdout");
             }
-            else {
-                // Local Docker: use standard runDockerCommand
-                return new Promise((resolve, reject) => {
-                    let output = '';
-                    const dockerPty = runDockerCommand(containerId, command, remoteCwd, (data) => {
-                        // Stream output to UI
-                        output += data;
-                        if (context.onStreamingOutput) {
-                            context.onStreamingOutput(data, 'stdout');
-                        }
-                    }, (exitCode) => {
-                        // Clear the interactive process
-                        if (context.cliAdapter) {
-                            context.cliAdapter.setCurrentInteractiveProcess(undefined);
-                        }
-                        if (exitCode !== 0) {
-                            reject(new Error(`${output || `Command failed with exit code ${exitCode}`}\n\nPossible reasons:\n1. The command is invalid or not installed.\n2. The arguments are incorrect.`));
-                        }
-                        else {
-                            resolve(output || 'Command executed successfully');
-                        }
-                    }, constrainedCols, constrainedRows);
-                    // Set up interactive process for stdin
-                    if (context.cliAdapter) {
-                        context.cliAdapter.setCurrentInteractiveProcess({
-                            process: null,
-                            write: (data) => dockerPty.write(data),
-                            kill: () => dockerPty.kill(),
-                            signal: (sig) => {
-                                if (sig === 'SIGINT') {
-                                    dockerPty.write('\x03'); // Ctrl+C
-                                }
-                            },
-                            resize: (cols, rows) => dockerPty.resize(cols, rows),
-                            isPty: true
-                        });
-                    }
-                });
+          },
+          (exitCode) => {
+            if (context.cliAdapter) {
+              context.cliAdapter.setCurrentInteractiveProcess(void 0);
             }
-        }
-        else if (currentContext.type === 'ssh') {
-            // SSH execution with PTY for proper TTY handling
-            const baseCwd = context.cwd || currentContext.metadata.workingDirectory;
-            const remoteCwd = Cwd ? (path.isAbsolute(Cwd) ? Cwd : path.posix.join(baseCwd, Cwd)) : baseCwd;
-            const sshClient = currentContext.handler?.client;
-            if (!sshClient) {
-                throw new Error('SSH client not available');
+            if (exitCode !== 0) {
+              reject(new Error(`${output || `Command failed with exit code ${exitCode}`}
+
+Possible reasons:
+1. The command is invalid or not installed.
+2. The arguments are incorrect.`));
+            } else {
+              resolve(output || "Command executed successfully");
             }
-            return new Promise((resolve, reject) => {
-                let output = '';
-                // Calculate constrained terminal dimensions for proper escape sequence handling
-                const constrainedCols = Math.max(40, (process.stdout.columns || 80) - 4);
-                const constrainedRows = Math.min(process.stdout.rows || 24, 50);
-                const sshPty = runSSHCommand(sshClient, command, remoteCwd, (data) => {
-                    // Stream output to UI
-                    output += data;
-                    if (context.onStreamingOutput) {
-                        context.onStreamingOutput(data, 'stdout');
-                    }
-                }, (exitCode) => {
-                    // Clear the interactive process
-                    if (context.cliAdapter) {
-                        context.cliAdapter.setCurrentInteractiveProcess(undefined);
-                    }
-                    if (exitCode !== 0) {
-                        reject(new Error(`${output || `Command failed with exit code ${exitCode}`}\n\nPossible reasons:\n1. The command is invalid or not installed.\n2. The arguments are incorrect.`));
-                    }
-                    else {
-                        resolve(output || 'Command executed successfully');
-                    }
-                }, constrainedCols, constrainedRows);
-                // Set up interactive process for stdin
-                if (context.cliAdapter) {
-                    context.cliAdapter.setCurrentInteractiveProcess({
-                        process: null,
-                        write: (data) => sshPty.write(data),
-                        kill: () => sshPty.kill(),
-                        signal: (sig) => {
-                            if (sig === 'SIGINT') {
-                                sshPty.write('\x03'); // Ctrl+C
-                            }
-                        },
-                        resize: (cols, rows) => sshPty.resize(cols, rows),
-                        isPty: true
-                    });
-                }
-            });
+          },
+          constrainedCols,
+          constrainedRows
+        );
+        if (context.cliAdapter) {
+          context.cliAdapter.setCurrentInteractiveProcess({
+            process: null,
+            write: (data) => sshPty.write(data),
+            kill: () => sshPty.kill(),
+            signal: (sig) => {
+              if (sig === "SIGINT") {
+                sshPty.write("");
+              }
+            },
+            resize: (cols, rows) => sshPty.resize(cols, rows),
+            isPty: true
+          });
         }
-    },
+      });
+    }
+  }
+};
+export {
+  runCommandTool
 };
 //# sourceMappingURL=command.js.map