wave-agent-sdk 0.0.1

package/src/managers/backgroundBashManager.ts

@@ -0,0 +1,203 @@
+import { spawn } from "child_process";
+import type { BackgroundShell } from "../types.js";
+
+export interface BackgroundBashManagerCallbacks {
+  onShellsChange?: (shells: BackgroundShell[]) => void;
+}
+
+export interface BackgroundBashManagerOptions {
+  callbacks?: BackgroundBashManagerCallbacks;
+  workdir: string;
+}
+
+export class BackgroundBashManager {
+  private shells = new Map<string, BackgroundShell>();
+  private nextId = 1;
+  private callbacks: BackgroundBashManagerCallbacks;
+  private workdir: string;
+
+  constructor(options: BackgroundBashManagerOptions) {
+    this.callbacks = options.callbacks || {};
+    this.workdir = options.workdir;
+  }
+
+  private notifyShellsChange(): void {
+    this.callbacks.onShellsChange?.(Array.from(this.shells.values()));
+  }
+
+  public startShell(command: string, timeout?: number): string {
+    const id = `bash_${this.nextId++}`;
+    const startTime = Date.now();
+
+    const child = spawn(command, {
+      shell: true,
+      stdio: "pipe",
+      cwd: this.workdir,
+      env: {
+        ...process.env,
+      },
+    });
+
+    const shell: BackgroundShell = {
+      id,
+      process: child,
+      command,
+      startTime,
+      status: "running",
+      stdout: "",
+      stderr: "",
+    };
+
+    this.shells.set(id, shell);
+    this.notifyShellsChange();
+
+    // Set up timeout if specified
+    let timeoutHandle: NodeJS.Timeout | undefined;
+    if (timeout && timeout > 0) {
+      timeoutHandle = setTimeout(() => {
+        if (shell.status === "running") {
+          this.killShell(id);
+        }
+      }, timeout);
+    }
+
+    child.stdout?.on("data", (data) => {
+      shell.stdout += data.toString();
+      this.notifyShellsChange();
+    });
+
+    child.stderr?.on("data", (data) => {
+      shell.stderr += data.toString();
+      this.notifyShellsChange();
+    });
+
+    child.on("exit", (code) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      shell.status = "completed";
+      shell.exitCode = code ?? 0;
+      shell.runtime = Date.now() - startTime;
+      this.notifyShellsChange();
+    });
+
+    child.on("error", (error) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      shell.status = "completed";
+      shell.stderr += `\nProcess error: ${error.message}`;
+      shell.exitCode = 1;
+      shell.runtime = Date.now() - startTime;
+      this.notifyShellsChange();
+    });
+
+    return id;
+  }
+
+  public getShell(id: string): BackgroundShell | undefined {
+    return this.shells.get(id);
+  }
+
+  public getAllShells(): BackgroundShell[] {
+    return Array.from(this.shells.values());
+  }
+
+  public getOutput(
+    id: string,
+    filter?: string,
+  ): { stdout: string; stderr: string; status: string } | null {
+    const shell = this.shells.get(id);
+    if (!shell) {
+      return null;
+    }
+
+    let stdout = shell.stdout;
+    let stderr = shell.stderr;
+
+    // Apply regex filter if provided
+    if (filter) {
+      try {
+        const regex = new RegExp(filter);
+        stdout = stdout
+          .split("\n")
+          .filter((line) => regex.test(line))
+          .join("\n");
+        stderr = stderr
+          .split("\n")
+          .filter((line) => regex.test(line))
+          .join("\n");
+      } catch {
+        // logger.warn(`Invalid filter regex: ${filter}`, error);
+      }
+    }
+
+    return {
+      stdout,
+      stderr,
+      status: shell.status,
+    };
+  }
+
+  public killShell(id: string): boolean {
+    const shell = this.shells.get(id);
+    if (!shell || shell.status !== "running") {
+      return false;
+    }
+
+    try {
+      // Try to kill process group first
+      if (shell.process.pid) {
+        process.kill(-shell.process.pid, "SIGTERM");
+
+        // Force kill after timeout
+        setTimeout(() => {
+          if (
+            shell.status === "running" &&
+            shell.process.pid &&
+            !shell.process.killed
+          ) {
+            try {
+              process.kill(-shell.process.pid, "SIGKILL");
+            } catch {
+              // logger.error("Failed to force kill process:", error);
+            }
+          }
+        }, 1000);
+      }
+
+      shell.status = "killed";
+      shell.runtime = Date.now() - shell.startTime;
+      this.notifyShellsChange();
+      return true;
+    } catch {
+      // Fallback to direct process kill
+      try {
+        shell.process.kill("SIGTERM");
+        setTimeout(() => {
+          if (!shell.process.killed) {
+            shell.process.kill("SIGKILL");
+          }
+        }, 1000);
+        shell.status = "killed";
+        shell.runtime = Date.now() - shell.startTime;
+        this.notifyShellsChange();
+        return true;
+      } catch {
+        // logger.error("Failed to kill child process:", directKillError);
+        return false;
+      }
+    }
+  }
+
+  public cleanup(): void {
+    // Kill all running shells
+    for (const [id, shell] of this.shells) {
+      if (shell.status === "running") {
+        this.killShell(id);
+      }
+    }
+    this.shells.clear();
+    this.notifyShellsChange();
+  }
+}

package/src/managers/bashManager.ts

@@ -0,0 +1,97 @@
+import { spawn, type ChildProcess } from "child_process";
+import { addBashCommandToHistory } from "../utils/bashHistory.js";
+import type { MessageManager } from "./messageManager.js";
+
+export interface BashManagerOptions {
+  messageManager: MessageManager;
+  workdir: string;
+}
+
+export interface CommandExecutionResult {
+  exitCode: number;
+  output: string;
+}
+
+export class BashManager {
+  private workdir: string;
+  private messageManager: MessageManager;
+  public isCommandRunning = false;
+  private currentProcess: ChildProcess | null = null;
+
+  constructor(options: BashManagerOptions) {
+    this.workdir = options.workdir;
+    this.messageManager = options.messageManager;
+  }
+
+  private setCommandRunning(isRunning: boolean): void {
+    this.isCommandRunning = isRunning;
+  }
+
+  public async executeCommand(command: string): Promise<number> {
+    if (this.isCommandRunning) {
+      throw new Error("Command already running");
+    }
+
+    this.setCommandRunning(true);
+
+    // Add command output placeholder
+    this.messageManager.addCommandOutputMessage(command);
+
+    return new Promise<number>((resolve) => {
+      const child = spawn(command, {
+        shell: true,
+        stdio: "pipe",
+        cwd: this.workdir,
+        env: {
+          ...process.env,
+        },
+      });
+
+      this.currentProcess = child;
+      let outputBuffer = "";
+
+      const updateOutput = (newData: string) => {
+        outputBuffer += newData;
+        this.messageManager.updateCommandOutputMessage(command, outputBuffer);
+      };
+
+      child.stdout?.on("data", (data) => {
+        updateOutput(data.toString());
+      });
+
+      child.stderr?.on("data", (data) => {
+        updateOutput(data.toString());
+      });
+
+      child.on("exit", (code, signal) => {
+        const exitCode = code === null && signal ? 130 : (code ?? 0);
+
+        // Add command to bash history
+        addBashCommandToHistory(command, this.workdir);
+
+        this.messageManager.completeCommandMessage(command, exitCode);
+
+        this.setCommandRunning(false);
+        this.currentProcess = null;
+        resolve(exitCode);
+      });
+
+      child.on("error", (error) => {
+        updateOutput(`\nError: ${error.message}\n`);
+        this.messageManager.completeCommandMessage(command, 1);
+
+        this.setCommandRunning(false);
+        this.currentProcess = null;
+        resolve(1);
+      });
+    });
+  }
+
+  public abortCommand(): void {
+    if (this.currentProcess && this.isCommandRunning) {
+      this.currentProcess.kill("SIGKILL");
+      this.currentProcess = null;
+      this.isCommandRunning = false;
+    }
+  }
+}