feat(bash): Add Bash timeout control feature and related adjustments

Author: qorzj

src/common/bash-timeout.ts

@@ -0,0 +1,12 @@
+export const DEFAULT_BASH_TIMEOUT_MS = 10 * 60 * 1000;
+export const MIN_BASH_TIMEOUT_MS = 60 * 1000;
+export const BASH_TIMEOUT_INCREMENT_MS = 5 * 60 * 1000;
+export const BASH_TIMEOUT_DECREMENT_MS = 60 * 1000;
+
+export function clampBashTimeoutMs(timeoutMs: number, minTimeoutMs: number = MIN_BASH_TIMEOUT_MS): number {
+  if (!Number.isFinite(timeoutMs)) {
+    return DEFAULT_BASH_TIMEOUT_MS;
+  }
+  const minimum = Number.isFinite(minTimeoutMs) ? Math.max(1, Math.round(minTimeoutMs)) : MIN_BASH_TIMEOUT_MS;
+  return Math.max(minimum, Math.round(timeoutMs));
+}

src/session.ts

@@ -17,7 +17,12 @@ import {
   getTools,
   type ToolDefinition,
 } from "./prompt";
-import { ToolExecutor, type CreateOpenAIClient } from "./tools/executor";
+import {
+  ToolExecutor,
+  type CreateOpenAIClient,
+  type ProcessTimeoutControl,
+  type ProcessTimeoutInfo,
+} from "./tools/executor";
 import { McpManager } from "./mcp/mcp-manager";
 import type { McpServerConfig } from "./settings";
 import { logApiError } from "./common/error-logger";
@@ -134,6 +139,21 @@ export type ModelUsage = {
   total_reqs?: number;
 };
 
+export type SessionProcessEntry = {
+  startTime: string;
+  command: string;
+  timeoutMs?: number;
+  deadlineAt?: string;
+  timedOut?: boolean;
+};
+
+export type BashTimeoutAdjustment = {
+  processId: string;
+  timeoutMs: number;
+  deadlineAt: string;
+  timedOut: boolean;
+};
+
 export type SessionEntry = {
   id: string;
   summary: string | null;
@@ -148,7 +168,7 @@ export type SessionEntry = {
   activeTokens: number;
   createTime: string;
   updateTime: string;
-  processes: Map<string, { startTime: string; command: string }> | null; // {pid: {startTime, command}}
+  processes: Map<string, SessionProcessEntry> | null; // {pid: process info}
 };
 
 export type SessionsIndex = {
@@ -234,6 +254,7 @@ export class SessionManager {
   private activeSessionId: string | null = null;
   private activePromptController: AbortController | null = null;
   private readonly sessionControllers = new Map<string, AbortController>();
+  private readonly processTimeoutControls = new Map<string, ProcessTimeoutControl>();
   private readonly toolExecutor: ToolExecutor;
   private readonly mcpManager = new McpManager();
   private mcpToolDefinitions: ToolDefinition[] = [];
@@ -1360,6 +1381,7 @@ ${skillMd}
     const killedPids: number[] = [];
     const failedPids: number[] = [];
     for (const pid of processIds) {
+      this.processTimeoutControls.delete(this.getProcessControlKey(sessionId, pid));
       if (killProcessTree(pid, "SIGKILL")) {
         killedPids.push(pid);
         continue;
@@ -1397,6 +1419,37 @@ ${skillMd}
     return !this.sessionControllers.has(sessionId);
   }
 
+  adjustActiveBashTimeout(deltaMs: number): BashTimeoutAdjustment | null {
+    const sessionId = this.activeSessionId;
+    if (!sessionId || !Number.isFinite(deltaMs)) {
+      return null;
+    }
+    const session = this.getSession(sessionId);
+    if (!session?.processes) {
+      return null;
+    }
+
+    let selectedPid: string | null = null;
+    for (const pid of session.processes.keys()) {
+      if (this.processTimeoutControls.has(this.getProcessControlKey(sessionId, pid))) {
+        selectedPid = pid;
+      }
+    }
+    if (!selectedPid) {
+      return null;
+    }
+
+    const control = this.processTimeoutControls.get(this.getProcessControlKey(sessionId, selectedPid));
+    if (!control) {
+      return null;
+    }
+
+    const current = control.getInfo();
+    const next = control.setTimeoutMs(current.timeoutMs + deltaMs);
+    this.updateSessionProcessTimeout(sessionId, selectedPid, next);
+    return this.buildBashTimeoutAdjustment(selectedPid, next);
+  }
+
   listSessions(): SessionEntry[] {
     const index = this.loadSessionsIndex();
     return index.entries;
@@ -1741,6 +1794,7 @@ ${skillMd}
       onProcessStart: (pid, command) => this.addSessionProcess(sessionId, pid, command),
       onProcessExit: (pid) => this.removeSessionProcess(sessionId, pid),
       onProcessStdout: (pid, chunk) => this.onProcessStdout?.(Number(pid), chunk),
+      onProcessTimeoutControl: (pid, control) => this.setSessionProcessTimeoutControl(sessionId, pid, control),
       shouldStop: () => this.isInterrupted(sessionId),
     });
     if (this.isInterrupted(sessionId)) {
@@ -2137,6 +2191,7 @@ ${skillMd}
 
   private removeSessionProcess(sessionId: string, processId: string | number): void {
     const now = new Date().toISOString();
+    this.processTimeoutControls.delete(this.getProcessControlKey(sessionId, processId));
     this.updateSessionEntry(sessionId, (entry) => {
       const processes = new Map(entry.processes ?? []);
       processes.delete(String(processId));
@@ -2148,7 +2203,58 @@ ${skillMd}
     });
   }
 
-  private getProcessIds(processes: Map<string, { startTime: string; command: string }> | null): number[] {
+  private setSessionProcessTimeoutControl(
+    sessionId: string,
+    processId: string | number,
+    control: ProcessTimeoutControl | null
+  ): void {
+    const key = this.getProcessControlKey(sessionId, processId);
+    if (!control) {
+      this.processTimeoutControls.delete(key);
+      return;
+    }
+
+    this.processTimeoutControls.set(key, control);
+    this.updateSessionProcessTimeout(sessionId, processId, control.getInfo());
+  }
+
+  private updateSessionProcessTimeout(sessionId: string, processId: string | number, info: ProcessTimeoutInfo): void {
+    const now = new Date().toISOString();
+    this.updateSessionEntry(sessionId, (entry) => {
+      const processes = new Map(entry.processes ?? []);
+      const pid = String(processId);
+      const processInfo = processes.get(pid);
+      if (!processInfo) {
+        return entry;
+      }
+      processes.set(pid, {
+        ...processInfo,
+        timeoutMs: info.timeoutMs,
+        deadlineAt: new Date(info.deadlineAtMs).toISOString(),
+        timedOut: info.timedOut,
+      });
+      return {
+        ...entry,
+        processes,
+        updateTime: now,
+      };
+    });
+  }
+
+  private buildBashTimeoutAdjustment(processId: string, info: ProcessTimeoutInfo): BashTimeoutAdjustment {
+    return {
+      processId,
+      timeoutMs: info.timeoutMs,
+      deadlineAt: new Date(info.deadlineAtMs).toISOString(),
+      timedOut: info.timedOut,
+    };
+  }
+
+  private getProcessControlKey(sessionId: string, processId: string | number): string {
+    return `${sessionId}:${String(processId)}`;
+  }
+
+  private getProcessIds(processes: Map<string, SessionProcessEntry> | null): number[] {
     if (!processes) {
       return [];
     }
@@ -2232,11 +2338,11 @@ ${skillMd}
     return usagePerModel;
   }
 
-  private deserializeProcesses(value: unknown): Map<string, { startTime: string; command: string }> | null {
+  private deserializeProcesses(value: unknown): Map<string, SessionProcessEntry> | null {
     if (!value || typeof value !== "object") {
       return null;
     }
-    const processes = new Map<string, { startTime: string; command: string }>();
+    const processes = new Map<string, SessionProcessEntry>();
     for (const [pid, entry] of Object.entries(value as Record<string, unknown>)) {
       if (!pid) {
         continue;
@@ -2245,22 +2351,34 @@ ${skillMd}
         // Backward compatibility for old format where just stored start time
         processes.set(pid, { startTime: entry, command: "Running process..." });
       } else if (typeof entry === "object" && entry !== null) {
-        const obj = entry as { startTime?: unknown; command?: unknown };
+        const obj = entry as {
+          startTime?: unknown;
+          command?: unknown;
+          timeoutMs?: unknown;
+          deadlineAt?: unknown;
+          timedOut?: unknown;
+        };
         const startTime = typeof obj.startTime === "string" ? obj.startTime : new Date().toISOString();
         const command = typeof obj.command === "string" ? obj.command : "Running process...";
-        processes.set(pid, { startTime, command });
+        processes.set(pid, {
+          startTime,
+          command,
+          timeoutMs: typeof obj.timeoutMs === "number" ? obj.timeoutMs : undefined,
+          deadlineAt: typeof obj.deadlineAt === "string" ? obj.deadlineAt : undefined,
+          timedOut: typeof obj.timedOut === "boolean" ? obj.timedOut : undefined,
+        });
       }
     }
     return processes.size > 0 ? processes : null;
   }
 
   private serializeProcesses(
-    processes: Map<string, { startTime: string; command: string }> | null
-  ): Record<string, { startTime: string; command: string }> | null {
+    processes: Map<string, SessionProcessEntry> | null
+  ): Record<string, SessionProcessEntry> | null {
     if (!processes || processes.size === 0) {
       return null;
     }
-    const serialized: Record<string, { startTime: string; command: string }> = {};
+    const serialized: Record<string, SessionProcessEntry> = {};
     for (const [pid, entry] of processes.entries()) {
       serialized[pid] = entry;
     }

src/tests/session.test.ts

@@ -1641,6 +1641,40 @@ test("SessionManager treats OpenAI APIUserAbortError as interrupted", async () =
   assert.equal(session?.failReason, "interrupted");
 });
 
+test("SessionManager adjusts the active Bash timeout control and session metadata", async () => {
+  const workspace = createTempDir("deepcode-bash-timeout-session-");
+  const manager = createSessionManager(workspace, "");
+  const sessionId = await manager.createSession({ text: "hello" });
+
+  (manager as any).addSessionProcess(sessionId, 123, "sleep 10");
+
+  let timeoutInfo = {
+    timeoutMs: 10 * 60 * 1000,
+    startedAtMs: 1000,
+    deadlineAtMs: 1000 + 10 * 60 * 1000,
+    timedOut: false,
+  };
+  (manager as any).setSessionProcessTimeoutControl(sessionId, 123, {
+    getInfo: () => timeoutInfo,
+    setTimeoutMs: (timeoutMs: number) => {
+      timeoutInfo = {
+        ...timeoutInfo,
+        timeoutMs,
+        deadlineAtMs: timeoutInfo.startedAtMs + timeoutMs,
+      };
+      return timeoutInfo;
+    },
+  });
+
+  const adjustment = manager.adjustActiveBashTimeout(5 * 60 * 1000);
+  const processInfo = manager.getSession(sessionId)?.processes?.get("123");
+
+  assert.equal(adjustment?.processId, "123");
+  assert.equal(adjustment?.timeoutMs, 15 * 60 * 1000);
+  assert.equal(processInfo?.timeoutMs, 15 * 60 * 1000);
+  assert.equal(processInfo?.deadlineAt, new Date(timeoutInfo.deadlineAtMs).toISOString());
+});
+
 function createSessionManager(projectRoot: string, machineId: string): SessionManager {
   return new SessionManager({
     projectRoot,

src/tests/tool-handlers.test.ts

@@ -4,7 +4,7 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import { setTimeout as delay } from "node:timers/promises";
-import type { ToolExecutionContext } from "../tools/executor";
+import type { ProcessTimeoutControl, ToolExecutionContext } from "../tools/executor";
 import { handleBashTool } from "../tools/bash-handler";
 import { handleEditTool } from "../tools/edit-handler";
 import { handleReadTool } from "../tools/read-handler";
@@ -52,6 +52,58 @@ test("Bash streams stdout and stderr before command completion", async () => {
   assert.match(streamedOutput, /err/);
 });
 
+test("Bash terminates commands that exceed the configured timeout", async () => {
+  const workspace = createTempWorkspace();
+  const exitedPids: Array<string | number> = [];
+
+  const result = await handleBashTool(
+    {
+      command: "printf 'start\\n'; sleep 5; printf 'done\\n'",
+    },
+    createContext("bash-timeout", workspace, {
+      bashTimeoutMs: 100,
+      bashMinTimeoutMs: 1,
+      onProcessExit: (pid) => {
+        exitedPids.push(pid);
+      },
+    })
+  );
+
+  assert.equal(result.ok, false);
+  assert.equal(result.error, "Command timed out.");
+  assert.equal(result.metadata?.timedOut, true);
+  assert.equal(result.metadata?.timeoutMs, 100);
+  assert.doesNotMatch(result.output ?? "", /done/);
+  assert.equal(exitedPids.length, 1);
+});
+
+test("Bash timeout control can extend the active command deadline", async () => {
+  const workspace = createTempWorkspace();
+  let timeoutControl: ProcessTimeoutControl | null = null;
+
+  const result = await handleBashTool(
+    {
+      command: "sleep 0.2; printf 'done\\n'",
+    },
+    createContext("bash-timeout-extend", workspace, {
+      bashTimeoutMs: 100,
+      bashMinTimeoutMs: 1,
+      onProcessTimeoutControl: (_pid, control) => {
+        if (control) {
+          timeoutControl = control;
+          control.setTimeoutMs(1000);
+        }
+      },
+    })
+  );
+
+  assert.ok(timeoutControl);
+  assert.equal(result.ok, true);
+  assert.match(result.output ?? "", /done/);
+  assert.equal(result.metadata?.timedOut, false);
+  assert.equal(result.metadata?.timeoutMs, 1000);
+});
+
 test("UpdatePlan accepts a markdown task list string", async () => {
   const workspace = createTempWorkspace();
   const plan = ["## Task List", "", "- [>] Inspect current behavior", "- [ ] Implement UpdatePlan"].join("\n");