@mako10k/shell-server 0.2.4 → 0.3.0

package/dist/core/process-manager.js

@@ -22,8 +22,68 @@ export class ProcessManager {
     fileStorageSubscriber;
     realtimeStreamSubscriber;
     enableStreaming = false; // Feature Flag
-    constructor(maxConcurrentProcesses = 50, outputDir = '/tmp/mcp-shell-outputs', fileManager) {
-        this.maxConcurrentProcesses = maxConcurrentProcesses;
+    buildConcurrencyStopCandidates(limit = 5) {
+        const now = Date.now();
+        return Array.from(this.executions.values())
+            .filter((exec) => exec.status === 'running')
+            .sort((a, b) => {
+            const aStart = a.started_at ? new Date(a.started_at).getTime() : Number.MAX_SAFE_INTEGER;
+            const bStart = b.started_at ? new Date(b.started_at).getTime() : Number.MAX_SAFE_INTEGER;
+            return aStart - bStart;
+        })
+            .slice(0, limit)
+            .map((exec) => {
+            const startedAtMs = exec.started_at ? new Date(exec.started_at).getTime() : undefined;
+            const runtimeSeconds = startedAtMs && Number.isFinite(startedAtMs)
+                ? Math.max(0, Math.floor((now - startedAtMs) / 1000))
+                : undefined;
+            return {
+                execution_id: exec.execution_id,
+                ...(exec.process_id !== undefined ? { process_id: exec.process_id } : {}),
+                command: exec.command.length > 120 ? `${exec.command.slice(0, 117)}...` : exec.command,
+                ...(runtimeSeconds !== undefined ? { runtime_seconds: runtimeSeconds } : {}),
+                status: exec.status,
+                suggested_action: {
+                    tool: 'process_kill',
+                    parameters: {
+                        ...(exec.process_id !== undefined ? { process_id: exec.process_id } : {}),
+                        signal: 'TERM',
+                        force: false,
+                    },
+                },
+            };
+        });
+    }
+    getRunningExecutionCount() {
+        return Array.from(this.executions.values()).filter((exec) => exec.status === 'running').length;
+    }
+    async waitForExecutionSlot(maxWaitMs, pollIntervalMs = 100) {
+        if (this.getRunningExecutionCount() < this.maxConcurrentProcesses) {
+            return true;
+        }
+        if (maxWaitMs <= 0) {
+            return false;
+        }
+        const deadline = Date.now() + maxWaitMs;
+        while (Date.now() < deadline) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, Math.min(pollIntervalMs, Math.max(1, deadline - Date.now())));
+            });
+            if (this.getRunningExecutionCount() < this.maxConcurrentProcesses) {
+                return true;
+            }
+        }
+        return this.getRunningExecutionCount() < this.maxConcurrentProcesses;
+    }
+    constructor(maxConcurrentProcesses = 8, outputDir = '/tmp/mcp-shell-outputs', fileManager) {
+        const envMaxConcurrentRaw = process.env['SHELL_SERVER_MAX_CONCURRENT_PROCESSES'];
+        const envMaxConcurrentParsed = envMaxConcurrentRaw
+            ? Number.parseInt(envMaxConcurrentRaw, 10)
+            : NaN;
+        const resolvedMaxConcurrent = Number.isFinite(envMaxConcurrentParsed) && envMaxConcurrentParsed > 0
+            ? envMaxConcurrentParsed
+            : maxConcurrentProcesses;
+        this.maxConcurrentProcesses = resolvedMaxConcurrent;
         this.outputDir = outputDir;
         this.fileManager = fileManager;
         this.defaultWorkingDirectory = process.env['SHELL_SERVER_DEFAULT_WORKDIR'] || process.cwd();
@@ -111,41 +171,70 @@ export class ProcessManager {
         await ensureDirectory(this.outputDir);
     }
     async executeCommand(options) {
-        // Check concurrent execution limit
-        const runningProcesses = Array.from(this.executions.values()).filter((exec) => exec.status === 'running').length;
+        let effectiveOptions = { ...options };
+        // For adaptive mode, when all slots are occupied, wait for a free slot
+        // using the same foreground wait budget requested by the caller.
+        const runningProcesses = this.getRunningExecutionCount();
         if (runningProcesses >= this.maxConcurrentProcesses) {
-            throw new ResourceLimitError('concurrent processes', this.maxConcurrentProcesses);
+            const queueWaitBudgetSeconds = effectiveOptions.executionMode === 'adaptive'
+                ? (effectiveOptions.foregroundTimeoutSeconds ?? 10)
+                : 0;
+            const queueWaitBudgetMs = Math.max(0, Math.floor(queueWaitBudgetSeconds * 1000));
+            const waitStartedAt = Date.now();
+            const acquired = await this.waitForExecutionSlot(queueWaitBudgetMs);
+            const waitedMs = Date.now() - waitStartedAt;
+            if (!acquired) {
+                const currentRunning = this.getRunningExecutionCount();
+                const stopCandidates = this.buildConcurrencyStopCandidates();
+                throw new ResourceLimitError('concurrent processes', this.maxConcurrentProcesses, undefined, {
+                    code: 'CONCURRENCY_LIMIT_EXCEEDED',
+                    reason: `Concurrent execution limit reached (${currentRunning}/${this.maxConcurrentProcesses}) and no slot became available within ${Math.floor(waitedMs / 1000)}s queue wait budget.`,
+                    running_count: currentRunning,
+                    limit: this.maxConcurrentProcesses,
+                    queue_wait_budget_seconds: queueWaitBudgetSeconds,
+                    waited_seconds: Math.floor(waitedMs / 1000),
+                    stop_candidates: stopCandidates,
+                    next_steps: [
+                        'Call process_list with status_filter="running" to inspect active executions.',
+                        'Stop one or more long-running commands via process_kill, then retry shell_execute.',
+                    ],
+                });
+            }
+            if (effectiveOptions.executionMode === 'adaptive') {
+                const originalForegroundWaitSeconds = effectiveOptions.foregroundTimeoutSeconds ?? 10;
+                const remainingForegroundWaitSeconds = Math.max(1, Math.floor((originalForegroundWaitSeconds * 1000 - waitedMs) / 1000));
+                effectiveOptions = {
+                    ...effectiveOptions,
+                    foregroundTimeoutSeconds: remainingForegroundWaitSeconds,
+                };
+            }
         }
         // Prepare input data when input_output_id is specified
-        let resolvedInputData = options.inputData;
+        let resolvedInputData = effectiveOptions.inputData;
         let inputStream = undefined;
-        if (options.inputOutputId) {
+        if (effectiveOptions.inputOutputId) {
             if (!this.fileManager) {
                 throw new ExecutionError('FileManager is not available for input_output_id processing', {
-                    inputOutputId: options.inputOutputId,
+                    inputOutputId: effectiveOptions.inputOutputId,
                 });
             }
-            // Identify execution ID from output_id
-            const sourceExecutionId = this.findExecutionIdByOutputId(options.inputOutputId);
+            const sourceExecutionId = this.findExecutionIdByOutputId(effectiveOptions.inputOutputId);
             if (sourceExecutionId && this.realtimeStreamSubscriber) {
-                // For active processes: use StreamingPipelineReader
                 const streamState = this.realtimeStreamSubscriber.getStreamState(sourceExecutionId);
                 if (streamState && streamState.isActive) {
                     console.error(`ProcessManager: Using streaming pipeline for active process ${sourceExecutionId}`);
-                    inputStream = new StreamingPipelineReader(this.fileManager, this.realtimeStreamSubscriber, options.inputOutputId, sourceExecutionId);
+                    inputStream = new StreamingPipelineReader(this.fileManager, this.realtimeStreamSubscriber, effectiveOptions.inputOutputId, sourceExecutionId);
                 }
             }
-            // If not active (or on failure), fall back to traditional file read
             if (!inputStream) {
                 try {
-                    console.error(`ProcessManager: Using traditional file read for ${options.inputOutputId}`);
-                    const result = await this.fileManager.readFile(options.inputOutputId, 0, 100 * 1024 * 1024, // read up to 100MB
-                    'utf-8');
+                    console.error(`ProcessManager: Using traditional file read for ${effectiveOptions.inputOutputId}`);
+                    const result = await this.fileManager.readFile(effectiveOptions.inputOutputId, 0, 100 * 1024 * 1024, 'utf-8');
                     resolvedInputData = result.content;
                 }
                 catch (error) {
-                    throw new ExecutionError(`Failed to read input from output_id: ${options.inputOutputId}`, {
-                        inputOutputId: options.inputOutputId,
+                    throw new ExecutionError(`Failed to read input from output_id: ${effectiveOptions.inputOutputId}`, {
+                        inputOutputId: effectiveOptions.inputOutputId,
                         originalError: String(error),
                     });
                 }
@@ -153,11 +242,10 @@ export class ProcessManager {
         }
         const executionId = generateId();
         const startTime = getCurrentTimestamp();
-        // Initialize execution info
-        const resolvedWorkingDirectory = this.resolveWorkingDirectory(options.workingDirectory);
+        const resolvedWorkingDirectory = this.resolveWorkingDirectory(effectiveOptions.workingDirectory);
         const executionInfo = {
             execution_id: executionId,
-            command: options.command,
+            command: effectiveOptions.command,
             status: 'running',
             working_directory: resolvedWorkingDirectory,
             default_working_directory: this.defaultWorkingDirectory,
@@ -165,30 +253,27 @@ export class ProcessManager {
             created_at: startTime,
             started_at: startTime,
         };
-        if (options.environmentVariables) {
-            executionInfo.environment_variables = options.environmentVariables;
+        if (effectiveOptions.environmentVariables) {
+            executionInfo.environment_variables = effectiveOptions.environmentVariables;
         }
         this.executions.set(executionId, executionInfo);
-        // If new terminal creation is requested
-        if (options.createTerminal && this.terminalManager) {
+        if (effectiveOptions.createTerminal && this.terminalManager) {
             try {
                 const terminalOptions = {
                     sessionName: `exec-${executionId}`,
-                    shellType: options.terminalShell || 'bash',
-                    dimensions: options.terminalDimensions || { width: 80, height: 24 },
+                    shellType: effectiveOptions.terminalShell || 'bash',
+                    dimensions: effectiveOptions.terminalDimensions || { width: 80, height: 24 },
                     autoSaveHistory: true,
                 };
-                if (options.workingDirectory) {
-                    terminalOptions.workingDirectory = options.workingDirectory;
+                if (effectiveOptions.workingDirectory) {
+                    terminalOptions.workingDirectory = effectiveOptions.workingDirectory;
                 }
-                if (options.environmentVariables) {
-                    terminalOptions.environmentVariables = options.environmentVariables;
+                if (effectiveOptions.environmentVariables) {
+                    terminalOptions.environmentVariables = effectiveOptions.environmentVariables;
                 }
                 const terminalInfo = await this.terminalManager.createTerminal(terminalOptions);
                 executionInfo.terminal_id = terminalInfo.terminal_id;
-                // Send command to terminal
-                this.terminalManager.sendInput(terminalInfo.terminal_id, options.command, true);
-                // Update execution info
+                this.terminalManager.sendInput(terminalInfo.terminal_id, effectiveOptions.command, true);
                 executionInfo.status = 'completed';
                 executionInfo.completed_at = getCurrentTimestamp();
                 this.executions.set(executionId, executionInfo);
@@ -204,17 +289,15 @@ export class ProcessManager {
             }
         }
         try {
-            // Prepare execution options
-            const { inputOutputId: _inputOutputId, ...baseOptions } = options;
+            const { inputOutputId: _inputOutputId, ...baseOptions } = effectiveOptions;
             const updatedOptions = {
                 ...baseOptions,
                 ...(resolvedInputData !== undefined && { inputData: resolvedInputData }),
             };
-            // Special handling when StreamingPipelineReader exists
             if (inputStream) {
                 return await this.executeCommandWithInputStream(executionId, updatedOptions, inputStream);
             }
-            switch (options.executionMode) {
+            switch (effectiveOptions.executionMode) {
                 case 'foreground':
                     return await this.executeForegroundCommand(executionId, updatedOptions);
                 case 'adaptive':
@@ -224,11 +307,10 @@ export class ProcessManager {
                 case 'detached':
                     return await this.executeDetachedCommand(executionId, updatedOptions);
                 default:
-                    throw new ExecutionError('Unsupported execution mode', { mode: options.executionMode });
+                    throw new ExecutionError('Unsupported execution mode', { mode: effectiveOptions.executionMode });
             }
         }
         catch (error) {
-            // Update execution info on error
             const updatedInfo = this.executions.get(executionId);
             if (updatedInfo) {
                 updatedInfo.status = 'failed';
@@ -347,17 +429,21 @@ export class ProcessManager {
                 reject(new ExecutionError(`Process error: ${error.message}`, { originalError: String(error) }));
             });
             // Timeout handling
-            const timeout = setTimeout(() => {
-                console.error(`Process timeout for ${executionId}`);
-                child.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!child.killed) {
-                        child.kill('SIGKILL');
-                    }
-                }, 5000);
-            }, options.timeoutSeconds * 1000);
+            const timeout = options.timeoutSeconds !== undefined
+                ? setTimeout(() => {
+                    console.error(`Process timeout for ${executionId}`);
+                    child.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!child.killed) {
+                            child.kill('SIGKILL');
+                        }
+                    }, 5000);
+                }, options.timeoutSeconds * 1000)
+                : undefined;
             child.on('close', () => {
-                clearTimeout(timeout);
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
             });
         });
     }
@@ -379,46 +465,48 @@ export class ProcessManager {
                 this.processes.set(childProcess.pid, childProcess);
             }
             // Set timeout
-            const timeout = setTimeout(async () => {
-                childProcess.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!childProcess.killed) {
-                        childProcess.kill('SIGKILL');
-                    }
-                }, 5000);
-                const executionTime = Date.now() - startTime;
-                const executionInfo = this.executions.get(executionId);
-                if (executionInfo) {
-                    executionInfo.status = 'timeout';
-                    executionInfo.stdout = sanitizeString(stdout);
-                    executionInfo.stderr = sanitizeString(stderr);
-                    executionInfo.completed_at = getCurrentTimestamp();
-                    executionInfo.execution_time_ms = executionTime;
-                    if (childProcess.pid !== undefined) {
-                        executionInfo.process_id = childProcess.pid;
-                    }
-                    // Save output to FileManager (regardless of size)
-                    let outputFileId;
-                    try {
-                        outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
-                        executionInfo.output_id = outputFileId;
-                    }
-                    catch (error) {
-                        // Record file-save failures as critical errors and include them in execution info
-                        console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
-                        executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
-                    }
-                    // Set detailed output status
-                    this.setOutputStatus(executionInfo, outputTruncated, 'timeout', outputFileId);
-                    this.executions.set(executionId, executionInfo);
-                    // Return partial result when return_partial_on_timeout is true
-                    if (options.returnPartialOnTimeout) {
-                        resolve(executionInfo);
-                        return;
+            const timeout = options.timeoutSeconds !== undefined
+                ? setTimeout(async () => {
+                    childProcess.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!childProcess.killed) {
+                            childProcess.kill('SIGKILL');
+                        }
+                    }, 5000);
+                    const executionTime = Date.now() - startTime;
+                    const executionInfo = this.executions.get(executionId);
+                    if (executionInfo) {
+                        executionInfo.status = 'timeout';
+                        executionInfo.stdout = sanitizeString(stdout);
+                        executionInfo.stderr = sanitizeString(stderr);
+                        executionInfo.completed_at = getCurrentTimestamp();
+                        executionInfo.execution_time_ms = executionTime;
+                        if (childProcess.pid !== undefined) {
+                            executionInfo.process_id = childProcess.pid;
+                        }
+                        // Save output to FileManager (regardless of size)
+                        let outputFileId;
+                        try {
+                            outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
+                            executionInfo.output_id = outputFileId;
+                        }
+                        catch (error) {
+                            // Record file-save failures as critical errors and include them in execution info
+                            console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
+                            executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
+                        }
+                        // Set detailed output status
+                        this.setOutputStatus(executionInfo, outputTruncated, 'timeout', outputFileId);
+                        this.executions.set(executionId, executionInfo);
+                        // Return partial result when return_partial_on_timeout is true
+                        if (options.returnPartialOnTimeout) {
+                            resolve(executionInfo);
+                            return;
+                        }
                     }
-                }
-                reject(new TimeoutError(options.timeoutSeconds));
-            }, options.timeoutSeconds * 1000);
+                    reject(new TimeoutError(options.timeoutSeconds ?? 0));
+                }, options.timeoutSeconds * 1000)
+                : undefined;
             // Send stdin
             if (options.inputData) {
                 childProcess.stdin?.write(options.inputData);
@@ -453,7 +541,9 @@ export class ProcessManager {
             }
             // Handle process close
             childProcess.on('close', async (code) => {
-                clearTimeout(timeout);
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
                 if (childProcess.pid) {
                     this.processes.delete(childProcess.pid);
                 }
@@ -542,39 +632,41 @@ export class ProcessManager {
                 }
             }, foregroundTimeout * 1000);
             // Set final timeout
-            const finalTimeoutHandle = setTimeout(async () => {
-                childProcess.kill('SIGTERM');
-                setTimeout(() => {
-                    if (!childProcess.killed) {
-                        childProcess.kill('SIGKILL');
-                    }
-                }, 5000);
-                const executionInfo = this.executions.get(executionId);
-                if (executionInfo) {
-                    executionInfo.status = 'timeout';
-                    executionInfo.stdout = sanitizeString(stdout);
-                    executionInfo.stderr = sanitizeString(stderr);
-                    executionInfo.output_truncated = outputTruncated;
-                    executionInfo.completed_at = getCurrentTimestamp();
-                    executionInfo.execution_time_ms = Date.now() - startTime;
-                    // Save output to FileManager
-                    try {
-                        const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
-                        executionInfo.output_id = outputFileId;
-                    }
-                    catch (error) {
-                        // Record file-save failures as critical errors and include them in execution info
-                        console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
-                        executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
-                    }
-                    this.executions.set(executionId, executionInfo);
-                    if (returnPartialOnTimeout) {
-                        resolve(executionInfo);
-                        return;
+            const finalTimeoutHandle = options.timeoutSeconds !== undefined
+                ? setTimeout(async () => {
+                    childProcess.kill('SIGTERM');
+                    setTimeout(() => {
+                        if (!childProcess.killed) {
+                            childProcess.kill('SIGKILL');
+                        }
+                    }, 5000);
+                    const executionInfo = this.executions.get(executionId);
+                    if (executionInfo) {
+                        executionInfo.status = 'timeout';
+                        executionInfo.stdout = sanitizeString(stdout);
+                        executionInfo.stderr = sanitizeString(stderr);
+                        executionInfo.output_truncated = outputTruncated;
+                        executionInfo.completed_at = getCurrentTimestamp();
+                        executionInfo.execution_time_ms = Date.now() - startTime;
+                        // Save output to FileManager
+                        try {
+                            const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
+                            executionInfo.output_id = outputFileId;
+                        }
+                        catch (error) {
+                            // Record file-save failures as critical errors and include them in execution info
+                            console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
+                            executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
+                        }
+                        this.executions.set(executionId, executionInfo);
+                        if (returnPartialOnTimeout) {
+                            resolve(executionInfo);
+                            return;
+                        }
                     }
-                }
-                reject(new TimeoutError(options.timeoutSeconds));
-            }, options.timeoutSeconds * 1000);
+                    reject(new TimeoutError(options.timeoutSeconds ?? 0));
+                }, options.timeoutSeconds * 1000)
+                : undefined;
             // Function to transition to background mode
             const transitionToBackground = async () => {
                 clearTimeout(foregroundTimeoutHandle);
@@ -608,9 +700,14 @@ export class ProcessManager {
                     this.setOutputStatus(executionInfo, outputTruncated, 'background_transition', outputFileId);
                     this.executions.set(executionId, executionInfo);
                     // Configure continued background handling (adaptive mode only)
+                    const remainingTimeoutSeconds = options.timeoutSeconds !== undefined
+                        ? Math.max(1, options.timeoutSeconds - Math.floor((Date.now() - startTime) / 1000))
+                        : undefined;
                     this.handleAdaptiveBackgroundTransition(executionId, childProcess, {
                         ...options,
-                        timeoutSeconds: Math.max(1, options.timeoutSeconds - Math.floor((Date.now() - startTime) / 1000)),
+                        ...(remainingTimeoutSeconds !== undefined
+                            ? { timeoutSeconds: remainingTimeoutSeconds }
+                            : {}),
                     });
                     resolve(executionInfo);
                 }
@@ -660,7 +757,9 @@ export class ProcessManager {
             // Handle process close
             childProcess.on('close', async (code) => {
                 clearTimeout(foregroundTimeoutHandle);
-                clearTimeout(finalTimeoutHandle);
+                if (finalTimeoutHandle) {
+                    clearTimeout(finalTimeoutHandle);
+                }
                 if (childProcess.pid) {
                     this.processes.delete(childProcess.pid);
                 }
@@ -697,7 +796,9 @@ export class ProcessManager {
             // Error handling
             childProcess.on('error', (error) => {
                 clearTimeout(foregroundTimeoutHandle);
-                clearTimeout(finalTimeoutHandle);
+                if (finalTimeoutHandle) {
+                    clearTimeout(finalTimeoutHandle);
+                }
                 if (childProcess.pid) {
                     this.processes.delete(childProcess.pid);
                 }
@@ -747,52 +848,54 @@ export class ProcessManager {
         let stdout = '';
         let stderr = '';
         // Set timeout (for background processes)
-        const timeout = setTimeout(async () => {
-            childProcess.kill('SIGTERM');
-            setTimeout(() => {
-                if (!childProcess.killed) {
-                    childProcess.kill('SIGKILL');
-                }
-            }, 5000);
-            const executionInfo = this.executions.get(executionId);
-            if (executionInfo) {
-                executionInfo.status = 'timeout';
-                executionInfo.stdout = stdout;
-                executionInfo.stderr = stderr;
-                executionInfo.output_truncated = true;
-                executionInfo.completed_at = getCurrentTimestamp();
-                executionInfo.execution_time_ms = Date.now() - startTime;
-                // Save output to FileManager
-                try {
-                    const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
-                    executionInfo.output_id = outputFileId;
-                }
-                catch (error) {
-                    // Record file-save failures as critical errors and include them in execution info
-                    console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
-                    executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
-                }
-                this.executions.set(executionId, executionInfo);
-                // Invoke timeout callback for background process
-                if (this.backgroundProcessCallbacks.onTimeout) {
-                    setImmediate(async () => {
-                        try {
-                            const callback = this.backgroundProcessCallbacks.onTimeout;
-                            if (callback) {
-                                const result = callback(executionId, executionInfo);
-                                if (result instanceof Promise) {
-                                    await result;
+        const timeout = options.timeoutSeconds !== undefined
+            ? setTimeout(async () => {
+                childProcess.kill('SIGTERM');
+                setTimeout(() => {
+                    if (!childProcess.killed) {
+                        childProcess.kill('SIGKILL');
+                    }
+                }, 5000);
+                const executionInfo = this.executions.get(executionId);
+                if (executionInfo) {
+                    executionInfo.status = 'timeout';
+                    executionInfo.stdout = stdout;
+                    executionInfo.stderr = stderr;
+                    executionInfo.output_truncated = true;
+                    executionInfo.completed_at = getCurrentTimestamp();
+                    executionInfo.execution_time_ms = Date.now() - startTime;
+                    // Save output to FileManager
+                    try {
+                        const outputFileId = await this.saveOutputToFile(executionId, stdout, stderr);
+                        executionInfo.output_id = outputFileId;
+                    }
+                    catch (error) {
+                        // Record file-save failures as critical errors and include them in execution info
+                        console.error(`[CRITICAL] Failed to save output file for execution ${executionId}:`, error);
+                        executionInfo.message = `Output file save failed: ${error instanceof Error ? error.message : String(error)}`;
+                    }
+                    this.executions.set(executionId, executionInfo);
+                    // Invoke timeout callback for background process
+                    if (this.backgroundProcessCallbacks.onTimeout) {
+                        setImmediate(async () => {
+                            try {
+                                const callback = this.backgroundProcessCallbacks.onTimeout;
+                                if (callback) {
+                                    const result = callback(executionId, executionInfo);
+                                    if (result instanceof Promise) {
+                                        await result;
+                                    }
                                 }
                             }
-                        }
-                        catch (callbackError) {
-                            // Record callback errors in internal logs only
-                            // console.error('Background process timeout callback error:', callbackError);
-                        }
-                    });
+                            catch (callbackError) {
+                                // Record callback errors in internal logs only
+                                // console.error('Background process timeout callback error:', callbackError);
+                            }
+                        });
+                    }
                 }
-            }
-        }, options.timeoutSeconds * 1000);
+            }, options.timeoutSeconds * 1000)
+            : undefined;
         // Collect output
         childProcess.stdout?.on('data', (data) => {
             stdout += data.toString();
@@ -804,7 +907,9 @@ export class ProcessManager {
         }
         // Handle process close
         childProcess.on('close', async (code) => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             if (childProcess.pid) {
                 this.processes.delete(childProcess.pid);
             }
@@ -846,7 +951,9 @@ export class ProcessManager {
             }
         });
         childProcess.on('error', (error) => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             if (childProcess.pid) {
                 this.processes.delete(childProcess.pid);
             }
@@ -880,24 +987,28 @@ export class ProcessManager {
     // Handle processes transitioned to background in adaptive mode
     handleAdaptiveBackgroundTransition(executionId, childProcess, options) {
         // Set timeout (final timeout)
-        const timeout = setTimeout(async () => {
-            childProcess.kill('SIGTERM');
-            setTimeout(() => {
-                if (!childProcess.killed) {
-                    childProcess.kill('SIGKILL');
+        const timeout = options.timeoutSeconds !== undefined
+            ? setTimeout(async () => {
+                childProcess.kill('SIGTERM');
+                setTimeout(() => {
+                    if (!childProcess.killed) {
+                        childProcess.kill('SIGKILL');
+                    }
+                }, 5000);
+                const executionInfo = this.executions.get(executionId);
+                if (executionInfo) {
+                    executionInfo.status = 'timeout';
+                    executionInfo.completed_at = getCurrentTimestamp();
+                    // Keep existing output (already captured in adaptive mode)
+                    this.executions.set(executionId, executionInfo);
                 }
-            }, 5000);
-            const executionInfo = this.executions.get(executionId);
-            if (executionInfo) {
-                executionInfo.status = 'timeout';
-                executionInfo.completed_at = getCurrentTimestamp();
-                // Keep existing output (already captured in adaptive mode)
-                this.executions.set(executionId, executionInfo);
-            }
-        }, options.timeoutSeconds * 1000);
+            }, options.timeoutSeconds * 1000)
+            : undefined;
         // Handle process close
         childProcess.on('close', async (code) => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             if (childProcess.pid) {
                 this.processes.delete(childProcess.pid);
             }
@@ -933,7 +1044,9 @@ export class ProcessManager {
             }
         });
         childProcess.on('error', (error) => {
-            clearTimeout(timeout);
+            if (timeout) {
+                clearTimeout(timeout);
+            }
             if (childProcess.pid) {
                 this.processes.delete(childProcess.pid);
             }