centaurus-cli 3.1.2 → 3.1.4

package/dist/tools/command.js

@@ -2,6 +2,63 @@ 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";
+import { BackgroundTaskManager } from "../services/background-task-manager.js";
+import { quickLog } from "../utils/conversation-logger.js";
+function extractCdTargetsFromCommand(command) {
+  const targets = [];
+  const segments = command.split(/\s*(?:&&|\|\||;)\s*/);
+  for (const segment of segments) {
+    const trimmed = segment.trim();
+    if (!trimmed) continue;
+    let match = null;
+    match = trimmed.match(/^cd\s+\/d\s+(.+)$/i);
+    if (!match) {
+      match = trimmed.match(/^cd\s+(.+)$/i);
+    }
+    if (!match) {
+      match = trimmed.match(/^pushd\s+(.+)$/i);
+    }
+    if (!match) {
+      match = trimmed.match(/^Set-Location\s+(.+)$/i);
+    }
+    if (!match) {
+      match = trimmed.match(/^sl\s+(.+)$/i);
+    }
+    if (!match) {
+      match = trimmed.match(/^chdir\s+(.+)$/i);
+    }
+    if (match) {
+      let target = match[1].trim();
+      target = target.replace(/^["']|["']$/g, "");
+      if (target.length > 1) {
+        target = target.replace(/[\/\\]+$/, "");
+      }
+      targets.push(target);
+    }
+  }
+  return targets;
+}
+function resolvePostCommandCwd(currentCwd, command, isWindows = false) {
+  const targets = extractCdTargetsFromCommand(command);
+  if (targets.length === 0) return null;
+  let cwd = currentCwd;
+  for (const target of targets) {
+    let expanded = target;
+    if (expanded === "~" || expanded.startsWith("~/") || expanded.startsWith("~\\")) {
+      const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+      expanded = homeDir + expanded.substring(1);
+    }
+    if (expanded === "-") continue;
+    cwd = path.resolve(cwd, expanded);
+  }
+  try {
+    if (fs.existsSync(cwd) && fs.statSync(cwd).isDirectory()) {
+      return cwd;
+    }
+  } catch {
+  }
+  return null;
+}
 function processShellInput(input) {
   let processed = input.replace(/\\n/g, "\r").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\b/g, "\b").replace(/\\x1B/g, "\x1B");
   const keyMap = {
@@ -33,6 +90,25 @@ function resolveCommandWorkingDirectory(currentContext, contextCwd, commandCwd)
   }
   return path.posix.isAbsolute(commandCwd) ? commandCwd : path.posix.join(remoteBase, commandCwd);
 }
+const TIMEOUT_TRANSFER_PREFIX = "__TIMEOUT_TRANSFER__";
+function buildTransferMessage(taskId, command, cwd, timeoutSeconds, outputSoFar, remoteContext) {
+  const outputPreview = outputSoFar.length > 500 ? outputSoFar.slice(-500) : outputSoFar;
+  const location = remoteContext ? ` (on ${remoteContext})` : "";
+  return `Command exceeded timeout of ${timeoutSeconds}s and has been transferred to background${location}.
+
+**Background Task ID:** ${taskId}
+**Command:** ${command}
+**Working Directory:** ${cwd}
+**Status:** Still running in background
+
+**Output so far (last 500 chars):**
+\`\`\`
+${outputPreview || "(no output yet)"}
+\`\`\`
+
+Use \`background_command\` with action="status" and task_id="${taskId}" to check progress.
+Use \`background_command\` with action="kill" and task_id="${taskId}" to terminate it.`;
+}
 const runCommandTool = {
   schema: {
     name: "execute_command",
@@ -71,13 +147,48 @@ Commands will be run with PAGER=cat. You may want to limit the length of output
         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."
+        },
+        timeout_seconds: {
+          type: "integer",
+          description: "Optional timeout in seconds. If the command takes longer than this, it will be automatically transferred to a background shell and you will receive the background task ID to monitor it. Use this for commands that might take a while (e.g., builds, installs, tests) where you want to continue working if they run long. If not set, the command runs until completion with no timeout."
         }
       },
       required: ["reason_text", "CommandLine", "Cwd", "SafeToAutoRun", "WaitMsBeforeAsync"]
     }
   },
   async execute(args, context) {
-    const { CommandLine, Cwd, shell_input } = args;
+    const { CommandLine, Cwd, shell_input, timeout_seconds } = args;
+    const timeoutMs = timeout_seconds && timeout_seconds > 0 ? timeout_seconds * 1e3 : 0;
+    if (!shell_input && context.cliAdapter && context.cliAdapter.isCustomTunnelActive()) {
+      const interactiveProcess = context.cliAdapter.getCurrentInteractiveProcess();
+      if (interactiveProcess && CommandLine) {
+        const inputWithEnter = CommandLine.endsWith("\n") || CommandLine.endsWith("\r") ? CommandLine : CommandLine + "\r";
+        const processedInput = processShellInput(inputWithEnter);
+        interactiveProcess.write(processedInput);
+        const tunnelBuf = () => context.cliAdapter.tunnelOutputBuffer || "";
+        const beforeLen = tunnelBuf().length;
+        let lastLen = beforeLen;
+        let stableTime = 0;
+        const waitStart = Date.now();
+        while (Date.now() - waitStart < 5e3) {
+          await new Promise((r) => setTimeout(r, 300));
+          const curLen = tunnelBuf().length;
+          if (curLen > lastLen) {
+            lastLen = curLen;
+            stableTime = 0;
+          } else {
+            stableTime += 300;
+            if (stableTime >= 800) break;
+          }
+        }
+        const captured = tunnelBuf().substring(beforeLen);
+        const { processTerminalOutput } = await import("../utils/terminal-output.js");
+        return processTerminalOutput(captured).trim() || "(command sent, no output captured)";
+      }
+      if (!interactiveProcess) {
+        context.cliAdapter.customTunnelCommand = null;
+      }
+    }
     if (shell_input) {
       if (context.cliAdapter) {
         const interactiveProcess = context.cliAdapter.getCurrentInteractiveProcess();
@@ -223,69 +334,124 @@ Command that needs background execution: ${command}`
       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");
-            }
-          },
-          (code) => {
-            exitCode = code;
-            if (context.cliAdapter) {
-              context.cliAdapter.setCurrentInteractiveProcess(void 0);
+        let transferred = false;
+        let timeoutTimer = null;
+        let onDataCallback = (data) => {
+          output += data;
+          if (context.onStreamingOutput) {
+            context.onStreamingOutput(data, "stdout");
+          }
+        };
+        let onExitCallback = (code) => {
+          exitCode = code;
+          if (timeoutTimer) {
+            clearTimeout(timeoutTimer);
+            timeoutTimer = null;
+          }
+          if (transferred) return;
+          if (context.cliAdapter) {
+            context.cliAdapter.setCurrentInteractiveProcess(void 0);
+          }
+          if (code === 0) {
+            const newCwd = resolvePostCommandCwd(executionCwd, command);
+            if (newCwd && newCwd !== executionCwd && context.cliAdapter) {
+              context.cliAdapter.cwd = newCwd;
+              contextManager.updateWorkingDirectory(newCwd);
+              if (context.cliAdapter.onCwdChange) {
+                context.cliAdapter.onCwdChange(newCwd);
+              }
             }
-            if (code === 0) {
-              resolve(output || "Command executed successfully");
-            } else {
-              const errorOutput = output + `
+            resolve(output || "Command executed successfully");
+          } else {
+            const errorOutput = output + `
 Exit Code: ${code}`;
-              reject(new Error(`${errorOutput || `Command failed with 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).`));
-            }
           }
+        };
+        const interactiveProcess = shellUtils.executeCommandInteractive(
+          command,
+          executionCwd,
+          (data) => onDataCallback(data),
+          (code) => onExitCallback(code)
         );
         if (context.cliAdapter) {
           context.cliAdapter.setCurrentInteractiveProcess(interactiveProcess);
         }
+        if (timeoutMs > 0) {
+          timeoutTimer = setTimeout(() => {
+            if (transferred || exitCode !== void 0) return;
+            transferred = true;
+            args.timeoutTransferred = true;
+            quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [execute_command] Timeout (${timeout_seconds}s) exceeded for: ${command}. Transferring to background.
+`);
+            const adopted = BackgroundTaskManager.adoptRunningProcess(
+              command,
+              executionCwd,
+              output
+            );
+            const remotePty = {
+              write: (data) => interactiveProcess.write(data),
+              kill: () => interactiveProcess.kill(),
+              resize: (cols, rows) => {
+                if (interactiveProcess.resize) interactiveProcess.resize(cols, rows);
+              },
+              isRunning: () => interactiveProcess.ptyProcess?.isRunning?.() ?? false
+            };
+            adopted.setRemotePty(remotePty);
+            onDataCallback = adopted.onData;
+            onExitCallback = adopted.onExit;
+            if (context.cliAdapter) {
+              context.cliAdapter.setCurrentInteractiveProcess(void 0);
+            }
+            resolve(buildTransferMessage(adopted.id, command, executionCwd, timeout_seconds, output));
+          }, timeoutMs);
+        }
       });
     } else if (currentContext.type === "wsl") {
       const remoteCwd = executionCwd;
       const distribution = currentContext.metadata?.distroName || "Ubuntu";
       return new Promise((resolve, reject) => {
         let output = "";
+        let transferred = false;
+        let timeoutTimer = null;
         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}`}
+        let onDataCallback = (data) => {
+          output += data;
+          if (context.onStreamingOutput) {
+            context.onStreamingOutput(data, "stdout");
+          }
+        };
+        let onExitCallback = (exitCode) => {
+          if (timeoutTimer) {
+            clearTimeout(timeoutTimer);
+            timeoutTimer = null;
+          }
+          if (transferred) return;
+          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");
-            }
-          },
+          } else {
+            resolve(output || "Command executed successfully");
+          }
+        };
+        const wslPty = runWSLCommand(
+          distribution,
+          command,
+          remoteCwd,
+          (data) => onDataCallback(data),
+          (exitCode) => onExitCallback(exitCode),
           constrainedCols,
           constrainedRows
         );
@@ -303,6 +469,24 @@ Possible reasons:
             isPty: true
           });
         }
+        if (timeoutMs > 0) {
+          timeoutTimer = setTimeout(() => {
+            if (transferred) return;
+            transferred = true;
+            args.timeoutTransferred = true;
+            const adopted = BackgroundTaskManager.adoptRunningProcess(command, remoteCwd, output, `wsl:${distribution}`);
+            adopted.setRemotePty({
+              write: (data) => wslPty.write(data),
+              kill: () => wslPty.kill(),
+              resize: (cols, rows) => wslPty.resize(cols, rows),
+              isRunning: () => wslPty.isRunning()
+            });
+            onDataCallback = adopted.onData;
+            onExitCallback = adopted.onExit;
+            if (context.cliAdapter) context.cliAdapter.setCurrentInteractiveProcess(void 0);
+            resolve(buildTransferMessage(adopted.id, command, remoteCwd, timeout_seconds, output, `wsl:${distribution}`));
+          }, timeoutMs);
+        }
       });
     } else if (currentContext.type === "docker") {
       const parentContext = contextManager.getParentContext();
@@ -317,33 +501,41 @@ Possible reasons:
         }
         const escapedCommand = command.replace(/"/g, '\\"');
         const dockerCommand = `docker exec -w "${remoteCwd}" ${containerId} sh -c "${escapedCommand}"`;
+        const remoteLabel = `docker:${containerId.substring(0, 12)} via ssh`;
         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}`}
+          let transferred = false;
+          let timeoutTimer = null;
+          let onDataCallback = (data) => {
+            output += data;
+            if (context.onStreamingOutput) {
+              context.onStreamingOutput(data, "stdout");
+            }
+          };
+          let onExitCallback = (exitCode) => {
+            if (timeoutTimer) {
+              clearTimeout(timeoutTimer);
+              timeoutTimer = null;
+            }
+            if (transferred) return;
+            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");
-              }
-            },
+            } else {
+              resolve(output || "Command executed successfully");
+            }
+          };
+          const sshPty = runSSHCommand(
+            sshClient,
+            dockerCommand,
+            parentContext.metadata.workingDirectory || "~",
+            (data) => onDataCallback(data),
+            (exitCode) => onExitCallback(exitCode),
             constrainedCols,
             constrainedRows
           );
@@ -353,42 +545,66 @@ Possible reasons:
               write: (data) => sshPty.write(data),
               kill: () => sshPty.kill(),
               signal: (sig) => {
-                if (sig === "SIGINT") {
-                  sshPty.write("");
-                }
+                if (sig === "SIGINT") sshPty.write("");
               },
               resize: (cols, rows) => sshPty.resize(cols, rows),
               isPty: true
             });
           }
+          if (timeoutMs > 0) {
+            timeoutTimer = setTimeout(() => {
+              if (transferred) return;
+              transferred = true;
+              args.timeoutTransferred = true;
+              const adopted = BackgroundTaskManager.adoptRunningProcess(command, remoteCwd, output, remoteLabel);
+              adopted.setRemotePty({
+                write: (data) => sshPty.write(data),
+                kill: () => sshPty.kill(),
+                resize: (cols, rows) => sshPty.resize(cols, rows),
+                isRunning: () => sshPty.isRunning()
+              });
+              onDataCallback = adopted.onData;
+              onExitCallback = adopted.onExit;
+              if (context.cliAdapter) context.cliAdapter.setCurrentInteractiveProcess(void 0);
+              resolve(buildTransferMessage(adopted.id, command, remoteCwd, timeout_seconds, output, remoteLabel));
+            }, timeoutMs);
+          }
         });
       } else {
+        const dockerLabel = `docker:${containerId.substring(0, 12)}`;
         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}`}
+          let transferred = false;
+          let timeoutTimer = null;
+          let onDataCallback = (data) => {
+            output += data;
+            if (context.onStreamingOutput) {
+              context.onStreamingOutput(data, "stdout");
+            }
+          };
+          let onExitCallback = (exitCode) => {
+            if (timeoutTimer) {
+              clearTimeout(timeoutTimer);
+              timeoutTimer = null;
+            }
+            if (transferred) return;
+            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");
-              }
-            },
+            } else {
+              resolve(output || "Command executed successfully");
+            }
+          };
+          const dockerPty = runDockerCommand(
+            containerId,
+            command,
+            remoteCwd,
+            (data) => onDataCallback(data),
+            (exitCode) => onExitCallback(exitCode),
             constrainedCols,
             constrainedRows
           );
@@ -398,14 +614,30 @@ Possible reasons:
               write: (data) => dockerPty.write(data),
               kill: () => dockerPty.kill(),
               signal: (sig) => {
-                if (sig === "SIGINT") {
-                  dockerPty.write("");
-                }
+                if (sig === "SIGINT") dockerPty.write("");
               },
               resize: (cols, rows) => dockerPty.resize(cols, rows),
               isPty: true
             });
           }
+          if (timeoutMs > 0) {
+            timeoutTimer = setTimeout(() => {
+              if (transferred) return;
+              transferred = true;
+              args.timeoutTransferred = true;
+              const adopted = BackgroundTaskManager.adoptRunningProcess(command, remoteCwd, output, dockerLabel);
+              adopted.setRemotePty({
+                write: (data) => dockerPty.write(data),
+                kill: () => dockerPty.kill(),
+                resize: (cols, rows) => dockerPty.resize(cols, rows),
+                isRunning: () => dockerPty.isRunning()
+              });
+              onDataCallback = adopted.onData;
+              onExitCallback = adopted.onExit;
+              if (context.cliAdapter) context.cliAdapter.setCurrentInteractiveProcess(void 0);
+              resolve(buildTransferMessage(adopted.id, command, remoteCwd, timeout_seconds, output, dockerLabel));
+            }, timeoutMs);
+          }
         });
       }
     } else if (currentContext.type === "ssh") {
@@ -414,34 +646,42 @@ Possible reasons:
       if (!sshClient) {
         throw new Error("SSH client not available");
       }
+      const sshLabel = `${currentContext.metadata?.username || "user"}@${currentContext.metadata?.hostname || "remote"}`;
       return new Promise((resolve, reject) => {
         let output = "";
+        let transferred = false;
+        let timeoutTimer = null;
         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");
-            }
-          },
-          (exitCode) => {
-            if (context.cliAdapter) {
-              context.cliAdapter.setCurrentInteractiveProcess(void 0);
-            }
-            if (exitCode !== 0) {
-              reject(new Error(`${output || `Command failed with exit code ${exitCode}`}
+        let onDataCallback = (data) => {
+          output += data;
+          if (context.onStreamingOutput) {
+            context.onStreamingOutput(data, "stdout");
+          }
+        };
+        let onExitCallback = (exitCode) => {
+          if (timeoutTimer) {
+            clearTimeout(timeoutTimer);
+            timeoutTimer = null;
+          }
+          if (transferred) return;
+          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");
-            }
-          },
+          } else {
+            resolve(output || "Command executed successfully");
+          }
+        };
+        const sshPty = runSSHCommand(
+          sshClient,
+          command,
+          remoteCwd,
+          (data) => onDataCallback(data),
+          (exitCode) => onExitCallback(exitCode),
           constrainedCols,
           constrainedRows
         );
@@ -451,19 +691,37 @@ Possible reasons:
             write: (data) => sshPty.write(data),
             kill: () => sshPty.kill(),
             signal: (sig) => {
-              if (sig === "SIGINT") {
-                sshPty.write("");
-              }
+              if (sig === "SIGINT") sshPty.write("");
             },
             resize: (cols, rows) => sshPty.resize(cols, rows),
             isPty: true
           });
         }
+        if (timeoutMs > 0) {
+          timeoutTimer = setTimeout(() => {
+            if (transferred) return;
+            transferred = true;
+            args.timeoutTransferred = true;
+            const adopted = BackgroundTaskManager.adoptRunningProcess(command, remoteCwd, output, sshLabel);
+            adopted.setRemotePty({
+              write: (data) => sshPty.write(data),
+              kill: () => sshPty.kill(),
+              resize: (cols, rows) => sshPty.resize(cols, rows),
+              isRunning: () => sshPty.isRunning()
+            });
+            onDataCallback = adopted.onData;
+            onExitCallback = adopted.onExit;
+            if (context.cliAdapter) context.cliAdapter.setCurrentInteractiveProcess(void 0);
+            resolve(buildTransferMessage(adopted.id, command, remoteCwd, timeout_seconds, output, sshLabel));
+          }, timeoutMs);
+        }
       });
     }
   }
 };
 export {
+  extractCdTargetsFromCommand,
+  resolvePostCommandCwd,
   runCommandTool
 };
 //# sourceMappingURL=command.js.map