fix_smartCommand

Author: build_agent

app/backend/src/agent/commandLog.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import { killBackgroundProcess } from "../tools/smartCommand.js";
 
 /**
  * Tracks every shell command the agent runs through the `run_command` tool so
@@ -17,6 +18,8 @@ export interface AgentCommandRun {
   stdout: string;
   stderr: string;
   truncated: boolean;
+  /** PID of the child process, set for background (long-running) commands. */
+  pid?: number;
 }
 
 export type AgentCommandSummary = Omit<AgentCommandRun, "stdout" | "stderr"> & {
@@ -27,14 +30,16 @@ export type AgentCommandSummary = Omit<AgentCommandRun, "stdout" | "stderr"> & {
 /** Lightweight token for an in-progress agent command. */
 export interface PendingCommandHandle {
   readonly id: string;
+  /** Register the OS PID once the child spawns so dismiss can kill it. */
+  setPid(pid: number): void;
   appendChunk(stream: "stdout" | "stderr", text: string): void;
   complete(result: Omit<AgentCommandRun, "id">): AgentCommandRun;
 }
 
 const MAX_RUNS = 100;
 const ring: AgentCommandRun[] = [];
 /** In-progress runs — kept until complete() is called so reconnecting clients can replay them. */
-const pending = new Map<string, { id: string; cmd: string; cwd: string; startedAt: number; output: string }>();
+const pending = new Map<string, { id: string; cmd: string; cwd: string; startedAt: number; output: string; pid?: number }>();
 const bus = new EventEmitter();
 bus.setMaxListeners(50);
 
@@ -65,6 +70,10 @@ export function startAgentCommand(cmd: string, cwd: string): PendingCommandHandl
 
   const handle: PendingCommandHandle = {
     id,
+    setPid(pid: number) {
+      const p = pending.get(id);
+      if (p) p.pid = pid;
+    },
     appendChunk(stream, text) {
       const p = pending.get(id);
       if (p) p.output += text;
@@ -112,15 +121,33 @@ export function getAgentCommand(id: string): AgentCommandRun | undefined {
 }
 
 export function clearAgentCommands(): number {
+  // Kill any background PIDs still tracked on the ring before clearing.
+  for (const r of ring) {
+    if (r.pid != null) killBackgroundProcess(r.pid);
+  }
+  // Also kill in-progress commands (pending map may have pids for queued long-runners).
+  for (const p of pending.values()) {
+    if (p.pid != null) killBackgroundProcess(p.pid);
+  }
   const n = ring.length;
   ring.length = 0;
   bus.emit("clear");
   return n;
 }
 
 export function deleteAgentCommand(id: string): boolean {
+  // Also try pending (user dismissed while the command was still running).
+  const p = pending.get(id);
+  if (p) {
+    if (p.pid != null) killBackgroundProcess(p.pid);
+    pending.delete(id);
+    bus.emit("delete", id);
+    return true;
+  }
   const i = ring.findIndex((r) => r.id === id);
   if (i < 0) return false;
+  const entry = ring[i];
+  if (entry.pid != null) killBackgroundProcess(entry.pid);
   ring.splice(i, 1);
   bus.emit("delete", id);
   return true;

app/backend/src/agent/executor.ts

@@ -275,6 +275,7 @@ export async function executeTool(
         try {
           r = await runSmartCommand(cmd, {
             cwd: getWorkspace(),
+            onChildSpawn: (pid) => cmdHandle.setPid(pid),
             onStreamChunk: (stream, text) => {
               if (stream === "out") qOut += text;
               else qErr += text;
@@ -298,6 +299,7 @@ export async function executeTool(
           stdout: r.stdout,
           stderr: r.stderr,
           truncated: r.truncated,
+          pid: r.pid,
         });
 
         // Build output summary based on result mode

app/backend/src/tools/smartCommand.ts

@@ -152,6 +152,13 @@ export interface SmartCommandOptions {
    * Used to forward `command_chunk` to the UI without blocking the agent on a poll loop.
    */
   onStreamChunk?: (stream: "out" | "err", text: string) => void | Promise<void>;
+  /**
+   * Called immediately after the child process spawns with its PID.
+   * Lets callers register the pid for cleanup before the command resolves
+   * (important for long-running "background" commands where the promise may
+   * resolve early and the caller needs to be able to kill the process later).
+   */
+  onChildSpawn?: (pid: number) => void;
 }
 
 // Keep track of background processes so we can clean them up
@@ -226,6 +233,7 @@ export async function runSmartCommand(
   if (!trimmed) throw new Error("Empty command");
 
   const streamCb = opts.onStreamChunk;
+  const spawnCb = opts.onChildSpawn;
   const cwd = opts.cwd ?? getWorkspace();
   const maxBytes = opts.maxBytes ?? 256 * 1024;
   const isLongRunning = opts.forceLongRunning || isLongRunningCommand(trimmed);
@@ -263,6 +271,12 @@ export async function runSmartCommand(
       ...(killAsGroup ? { detached: true } : {}),
     });
 
+    // Notify caller of the PID as soon as the child is alive so they can
+    // register it for potential early-kill (e.g. user dismisses the run).
+    if (child.pid !== undefined && spawnCb) {
+      try { spawnCb(child.pid); } catch { /* caller must not throw */ }
+    }
+
     let outBuf = "";
     let errBuf = "";
     let truncated = false;