@google/gemini-cli-core 0.34.0-preview.3 → 0.35.0-nightly.20260314.3038fdce2

package/dist/src/services/shellExecutionService.js

@@ -18,7 +18,9 @@ import { debugLogger } from '../utils/debugLogger.js';
 import { Storage } from '../config/storage.js';
 import { serializeTerminalToObject, } from '../utils/terminalSerializer.js';
 import { sanitizeEnvironment, } from './environmentSanitization.js';
+import { NoopSandboxManager } from './sandboxManager.js';
 import { killProcessGroup } from '../utils/process-utils.js';
+import { ExecutionLifecycleService, } from './executionLifecycleService.js';
 const { Terminal } = pkg;
 const MAX_CHILD_PROCESS_BUFFER_SIZE = 16 * 1024 * 1024; // 16MB
 /**
@@ -135,7 +137,6 @@ export class ShellExecutionService {
     static activeChildProcesses = new Map();
     static backgroundLogPids = new Set();
     static backgroundLogStreams = new Map();
-    static exitedPtyInfo = new Map();
     static getLogDir() {
         return path.join(Storage.getGlobalTempDir(), 'background-processes');
     }
@@ -161,8 +162,6 @@ export class ShellExecutionService {
         }
         this.backgroundLogPids.delete(pid);
     }
-    static activeResolvers = new Map();
-    static activeListeners = new Map();
     /**
      * Executes a shell command using `node-pty`, capturing all output and lifecycle events.
      *
@@ -174,11 +173,19 @@ export class ShellExecutionService {
      *          resolves with the complete execution result.
      */
     static async execute(commandToExecute, cwd, onOutputEvent, abortSignal, shouldUseNodePty, shellExecutionConfig) {
+        const sandboxManager = new NoopSandboxManager();
+        const { env: sanitizedEnv } = await sandboxManager.prepareCommand({
+            command: commandToExecute,
+            args: [],
+            env: process.env,
+            cwd,
+            config: shellExecutionConfig,
+        });
         if (shouldUseNodePty) {
             const ptyInfo = await getPty();
             if (ptyInfo) {
                 try {
-                    return await this.executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo);
+                    return await this.executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo, sanitizedEnv);
                 }
                 catch (_e) {
                     // Fallback to child_process
@@ -209,12 +216,6 @@ export class ShellExecutionService {
         const truncatedBuffer = currentBuffer.substring(charsToTrim);
         return { newBuffer: truncatedBuffer + chunk, truncated: true };
     }
-    static emitEvent(pid, event) {
-        const listeners = this.activeListeners.get(pid);
-        if (listeners) {
-            listeners.forEach((listener) => listener(event));
-        }
-    }
     static childProcessFallback(commandToExecute, cwd, onOutputEvent, abortSignal, sanitizationConfig, isInteractive) {
         try {
             const isWindows = os.platform() === 'win32';
@@ -276,169 +277,202 @@ export class ShellExecutionService {
                     state,
                 });
             }
-            const result = new Promise((resolve) => {
-                if (child.pid) {
-                    this.activeResolvers.set(child.pid, resolve);
-                }
-                let stdoutDecoder = null;
-                let stderrDecoder = null;
-                let error = null;
-                let exited = false;
-                let isStreamingRawContent = true;
-                const MAX_SNIFF_SIZE = 4096;
-                let sniffedBytes = 0;
-                const handleOutput = (data, stream) => {
-                    if (!stdoutDecoder || !stderrDecoder) {
-                        const encoding = getCachedEncodingForBuffer(data);
+            const lifecycleHandle = child.pid
+                ? ExecutionLifecycleService.attachExecution(child.pid, {
+                    executionMethod: 'child_process',
+                    getBackgroundOutput: () => state.output,
+                    getSubscriptionSnapshot: () => state.output || undefined,
+                    writeInput: (input) => {
+                        const stdin = child.stdin;
+                        if (stdin) {
+                            stdin.write(input);
+                        }
+                    },
+                    kill: () => {
+                        if (child.pid) {
+                            killProcessGroup({ pid: child.pid }).catch(() => { });
+                            this.activeChildProcesses.delete(child.pid);
+                        }
+                    },
+                    isActive: () => {
+                        if (!child.pid) {
+                            return false;
+                        }
                         try {
-                            stdoutDecoder = new TextDecoder(encoding);
-                            stderrDecoder = new TextDecoder(encoding);
+                            return process.kill(child.pid, 0);
                         }
                         catch {
-                            stdoutDecoder = new TextDecoder('utf-8');
-                            stderrDecoder = new TextDecoder('utf-8');
+                            return false;
                         }
+                    },
+                })
+                : undefined;
+            let resolveWithoutPid;
+            const result = lifecycleHandle?.result ??
+                new Promise((resolve) => {
+                    resolveWithoutPid = resolve;
+                });
+            let stdoutDecoder = null;
+            let stderrDecoder = null;
+            let error = null;
+            let exited = false;
+            let isStreamingRawContent = true;
+            const MAX_SNIFF_SIZE = 4096;
+            let sniffedBytes = 0;
+            const handleOutput = (data, stream) => {
+                if (!stdoutDecoder || !stderrDecoder) {
+                    const encoding = getCachedEncodingForBuffer(data);
+                    try {
+                        stdoutDecoder = new TextDecoder(encoding);
+                        stderrDecoder = new TextDecoder(encoding);
                     }
-                    state.outputChunks.push(data);
-                    if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
-                        const sniffBuffer = Buffer.concat(state.outputChunks.slice(0, 20));
-                        sniffedBytes = sniffBuffer.length;
-                        if (isBinary(sniffBuffer)) {
-                            isStreamingRawContent = false;
-                            const event = { type: 'binary_detected' };
-                            onOutputEvent(event);
-                            if (child.pid)
-                                ShellExecutionService.emitEvent(child.pid, event);
-                        }
+                    catch {
+                        stdoutDecoder = new TextDecoder('utf-8');
+                        stderrDecoder = new TextDecoder('utf-8');
                     }
-                    if (isStreamingRawContent) {
-                        const decoder = stream === 'stdout' ? stdoutDecoder : stderrDecoder;
-                        const decodedChunk = decoder.decode(data, { stream: true });
-                        const { newBuffer, truncated } = this.appendAndTruncate(state.output, decodedChunk, MAX_CHILD_PROCESS_BUFFER_SIZE);
-                        state.output = newBuffer;
-                        if (truncated) {
-                            state.truncated = true;
-                        }
-                        if (decodedChunk) {
-                            const event = {
-                                type: 'data',
-                                chunk: decodedChunk,
-                            };
-                            onOutputEvent(event);
-                            if (child.pid) {
-                                ShellExecutionService.emitEvent(child.pid, event);
-                                if (ShellExecutionService.backgroundLogPids.has(child.pid)) {
-                                    ShellExecutionService.syncBackgroundLog(child.pid, decodedChunk);
-                                }
-                            }
+                }
+                state.outputChunks.push(data);
+                if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
+                    const sniffBuffer = Buffer.concat(state.outputChunks.slice(0, 20));
+                    sniffedBytes = sniffBuffer.length;
+                    if (isBinary(sniffBuffer)) {
+                        isStreamingRawContent = false;
+                        const event = { type: 'binary_detected' };
+                        onOutputEvent(event);
+                        if (child.pid) {
+                            ExecutionLifecycleService.emitEvent(child.pid, event);
                         }
                     }
-                    else {
-                        const totalBytes = state.outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                }
+                if (isStreamingRawContent) {
+                    const decoder = stream === 'stdout' ? stdoutDecoder : stderrDecoder;
+                    const decodedChunk = decoder.decode(data, { stream: true });
+                    const { newBuffer, truncated } = this.appendAndTruncate(state.output, decodedChunk, MAX_CHILD_PROCESS_BUFFER_SIZE);
+                    state.output = newBuffer;
+                    if (truncated) {
+                        state.truncated = true;
+                    }
+                    if (decodedChunk) {
                         const event = {
-                            type: 'binary_progress',
-                            bytesReceived: totalBytes,
+                            type: 'data',
+                            chunk: decodedChunk,
                         };
                         onOutputEvent(event);
-                        if (child.pid)
-                            ShellExecutionService.emitEvent(child.pid, event);
-                    }
-                };
-                const handleExit = (code, signal) => {
-                    const { finalBuffer } = cleanup();
-                    let combinedOutput = state.output;
-                    if (state.truncated) {
-                        const truncationMessage = `\n[GEMINI_CLI_WARNING: Output truncated. The buffer is limited to ${MAX_CHILD_PROCESS_BUFFER_SIZE / (1024 * 1024)}MB.]`;
-                        combinedOutput += truncationMessage;
+                        if (child.pid) {
+                            ExecutionLifecycleService.emitEvent(child.pid, event);
+                            if (ShellExecutionService.backgroundLogPids.has(child.pid)) {
+                                ShellExecutionService.syncBackgroundLog(child.pid, decodedChunk);
+                            }
+                        }
                     }
-                    const finalStrippedOutput = stripAnsi(combinedOutput).trim();
-                    const exitCode = code;
-                    const exitSignal = signal ? os.constants.signals[signal] : null;
+                }
+                else {
+                    const totalBytes = state.outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                    const event = {
+                        type: 'binary_progress',
+                        bytesReceived: totalBytes,
+                    };
+                    onOutputEvent(event);
                     if (child.pid) {
-                        const pid = child.pid;
-                        const event = {
-                            type: 'exit',
-                            exitCode,
-                            signal: exitSignal,
-                        };
-                        onOutputEvent(event);
-                        ShellExecutionService.emitEvent(pid, event);
-                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                        ShellExecutionService.cleanupLogStream(pid).then(() => {
-                            this.activeChildProcesses.delete(pid);
-                            this.activeResolvers.delete(pid);
-                            this.activeListeners.delete(pid);
-                        });
+                        ExecutionLifecycleService.emitEvent(child.pid, event);
                     }
-                    resolve({
-                        rawOutput: finalBuffer,
-                        output: finalStrippedOutput,
+                }
+            };
+            const handleExit = (code, signal) => {
+                const { finalBuffer } = cleanup();
+                let combinedOutput = state.output;
+                if (state.truncated) {
+                    const truncationMessage = `\n[GEMINI_CLI_WARNING: Output truncated. The buffer is limited to ${MAX_CHILD_PROCESS_BUFFER_SIZE / (1024 * 1024)}MB.]`;
+                    combinedOutput += truncationMessage;
+                }
+                const finalStrippedOutput = stripAnsi(combinedOutput).trim();
+                const exitCode = code;
+                const exitSignal = signal ? os.constants.signals[signal] : null;
+                const resultPayload = {
+                    rawOutput: finalBuffer,
+                    output: finalStrippedOutput,
+                    exitCode,
+                    signal: exitSignal,
+                    error,
+                    aborted: abortSignal.aborted,
+                    pid: child.pid,
+                    executionMethod: 'child_process',
+                };
+                if (child.pid) {
+                    const pid = child.pid;
+                    const event = {
+                        type: 'exit',
                         exitCode,
                         signal: exitSignal,
-                        error,
-                        aborted: abortSignal.aborted,
+                    };
+                    onOutputEvent(event);
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    ShellExecutionService.cleanupLogStream(pid).then(() => {
+                        ShellExecutionService.activeChildProcesses.delete(pid);
+                    });
+                    ExecutionLifecycleService.completeWithResult(pid, resultPayload);
+                }
+                else {
+                    resolveWithoutPid?.(resultPayload);
+                }
+            };
+            child.stdout.on('data', (data) => handleOutput(data, 'stdout'));
+            child.stderr.on('data', (data) => handleOutput(data, 'stderr'));
+            child.on('error', (err) => {
+                error = err;
+                handleExit(1, null);
+            });
+            const abortHandler = async () => {
+                if (child.pid && !exited) {
+                    await killProcessGroup({
                         pid: child.pid,
-                        executionMethod: 'child_process',
+                        escalate: true,
+                        isExited: () => exited,
                     });
-                };
-                child.stdout.on('data', (data) => handleOutput(data, 'stdout'));
-                child.stderr.on('data', (data) => handleOutput(data, 'stderr'));
-                child.on('error', (err) => {
-                    error = err;
-                    handleExit(1, null);
-                });
-                const abortHandler = async () => {
-                    if (child.pid && !exited) {
-                        await killProcessGroup({
-                            pid: child.pid,
-                            escalate: true,
-                            isExited: () => exited,
-                        });
-                    }
-                };
-                abortSignal.addEventListener('abort', abortHandler, { once: true });
-                child.on('exit', (code, signal) => {
-                    handleExit(code, signal);
-                });
-                function cleanup() {
-                    exited = true;
-                    abortSignal.removeEventListener('abort', abortHandler);
-                    if (stdoutDecoder) {
-                        const remaining = stdoutDecoder.decode();
-                        if (remaining) {
-                            state.output += remaining;
-                            // If there's remaining output, we should technically emit it too,
-                            // but it's rare to have partial utf8 chars at the very end of stream.
-                            if (isStreamingRawContent && remaining) {
-                                const event = {
-                                    type: 'data',
-                                    chunk: remaining,
-                                };
-                                onOutputEvent(event);
-                                if (child.pid)
-                                    ShellExecutionService.emitEvent(child.pid, event);
+                }
+            };
+            abortSignal.addEventListener('abort', abortHandler, { once: true });
+            child.on('exit', (code, signal) => {
+                handleExit(code, signal);
+            });
+            function cleanup() {
+                exited = true;
+                abortSignal.removeEventListener('abort', abortHandler);
+                if (stdoutDecoder) {
+                    const remaining = stdoutDecoder.decode();
+                    if (remaining) {
+                        state.output += remaining;
+                        if (isStreamingRawContent) {
+                            const event = {
+                                type: 'data',
+                                chunk: remaining,
+                            };
+                            onOutputEvent(event);
+                            if (child.pid) {
+                                ExecutionLifecycleService.emitEvent(child.pid, event);
                             }
                         }
                     }
-                    if (stderrDecoder) {
-                        const remaining = stderrDecoder.decode();
-                        if (remaining) {
-                            state.output += remaining;
-                            if (isStreamingRawContent && remaining) {
-                                const event = {
-                                    type: 'data',
-                                    chunk: remaining,
-                                };
-                                onOutputEvent(event);
-                                if (child.pid)
-                                    ShellExecutionService.emitEvent(child.pid, event);
+                }
+                if (stderrDecoder) {
+                    const remaining = stderrDecoder.decode();
+                    if (remaining) {
+                        state.output += remaining;
+                        if (isStreamingRawContent) {
+                            const event = {
+                                type: 'data',
+                                chunk: remaining,
+                            };
+                            onOutputEvent(event);
+                            if (child.pid) {
+                                ExecutionLifecycleService.emitEvent(child.pid, event);
                             }
                         }
                     }
-                    const finalBuffer = Buffer.concat(state.outputChunks);
-                    return { finalBuffer };
                 }
-            });
+                const finalBuffer = Buffer.concat(state.outputChunks);
+                return { finalBuffer };
+            }
             return { pid: child.pid, result };
         }
         catch (e) {
@@ -459,7 +493,7 @@ export class ShellExecutionService {
             };
         }
     }
-    static async executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo) {
+    static async executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo, sanitizedEnv) {
         if (!ptyInfo) {
             // This should not happen, but as a safeguard...
             throw new Error('PTY implementation not found');
@@ -482,7 +516,7 @@ export class ShellExecutionService {
                 cols,
                 rows,
                 env: {
-                    ...sanitizeEnvironment(process.env, shellExecutionConfig.sanitizationConfig),
+                    ...sanitizedEnv,
                     GEMINI_CLI: '1',
                     TERM: 'xterm-256color',
                     PAGER: shellExecutionConfig.pager ?? 'cat',
@@ -492,246 +526,271 @@ export class ShellExecutionService {
             });
             // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             spawnedPty = ptyProcess;
-            const result = new Promise((resolve) => {
-                this.activeResolvers.set(ptyProcess.pid, resolve);
-                const headlessTerminal = new Terminal({
-                    allowProposedApi: true,
-                    cols,
-                    rows,
-                    scrollback: shellExecutionConfig.scrollback ?? SCROLLBACK_LIMIT,
-                });
-                headlessTerminal.scrollToTop();
-                this.activePtys.set(ptyProcess.pid, {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    ptyProcess,
-                    headlessTerminal,
-                    maxSerializedLines: shellExecutionConfig.maxSerializedLines,
-                });
-                let processingChain = Promise.resolve();
-                let decoder = null;
-                let output = null;
-                const outputChunks = [];
-                const error = null;
-                let exited = false;
-                let isStreamingRawContent = true;
-                const MAX_SNIFF_SIZE = 4096;
-                let sniffedBytes = 0;
-                let isWriting = false;
-                let hasStartedOutput = false;
-                let renderTimeout = null;
-                const renderFn = () => {
-                    renderTimeout = null;
-                    if (!isStreamingRawContent) {
+            const ptyPid = Number(ptyProcess.pid);
+            const headlessTerminal = new Terminal({
+                allowProposedApi: true,
+                cols,
+                rows,
+                scrollback: shellExecutionConfig.scrollback ?? SCROLLBACK_LIMIT,
+            });
+            headlessTerminal.scrollToTop();
+            this.activePtys.set(ptyPid, {
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                ptyProcess,
+                headlessTerminal,
+                maxSerializedLines: shellExecutionConfig.maxSerializedLines,
+            });
+            const result = ExecutionLifecycleService.attachExecution(ptyPid, {
+                executionMethod: ptyInfo?.name ?? 'node-pty',
+                writeInput: (input) => {
+                    if (!ExecutionLifecycleService.isActive(ptyPid)) {
                         return;
                     }
-                    if (!shellExecutionConfig.disableDynamicLineTrimming) {
-                        if (!hasStartedOutput) {
-                            const bufferText = getFullBufferText(headlessTerminal);
-                            if (bufferText.trim().length === 0) {
-                                return;
-                            }
-                            hasStartedOutput = true;
-                        }
-                    }
-                    const buffer = headlessTerminal.buffer.active;
-                    const endLine = buffer.length;
-                    const startLine = Math.max(0, endLine - (shellExecutionConfig.maxSerializedLines ?? 2000));
-                    let newOutput;
-                    if (shellExecutionConfig.showColor) {
-                        newOutput = serializeTerminalToObject(headlessTerminal, startLine, endLine);
-                    }
-                    else {
-                        newOutput = (serializeTerminalToObject(headlessTerminal, startLine, endLine) ||
-                            []).map((line) => line.map((token) => {
-                            token.fg = '';
-                            token.bg = '';
-                            return token;
-                        }));
+                    ptyProcess.write(input);
+                },
+                kill: () => {
+                    killProcessGroup({
+                        pid: ptyPid,
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        pty: ptyProcess,
+                    }).catch(() => { });
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                        ptyProcess.destroy?.();
                     }
-                    let lastNonEmptyLine = -1;
-                    for (let i = newOutput.length - 1; i >= 0; i--) {
-                        const line = newOutput[i];
-                        if (line
-                            .map((segment) => segment.text)
-                            .join('')
-                            .trim().length > 0) {
-                            lastNonEmptyLine = i;
-                            break;
-                        }
+                    catch {
+                        // Ignore errors during cleanup
                     }
-                    const absoluteCursorY = buffer.baseY + buffer.cursorY;
-                    const cursorRelativeIndex = absoluteCursorY - startLine;
-                    if (cursorRelativeIndex > lastNonEmptyLine) {
-                        lastNonEmptyLine = cursorRelativeIndex;
+                    this.activePtys.delete(ptyPid);
+                },
+                isActive: () => {
+                    try {
+                        return process.kill(ptyPid, 0);
                     }
-                    const trimmedOutput = newOutput.slice(0, lastNonEmptyLine + 1);
-                    const finalOutput = shellExecutionConfig.disableDynamicLineTrimming
-                        ? newOutput
-                        : trimmedOutput;
-                    if (output !== finalOutput) {
-                        output = finalOutput;
-                        const event = {
-                            type: 'data',
-                            chunk: finalOutput,
-                        };
-                        onOutputEvent(event);
-                        ShellExecutionService.emitEvent(ptyProcess.pid, event);
+                    catch {
+                        return false;
                     }
-                };
-                const render = (finalRender = false) => {
-                    if (finalRender) {
-                        if (renderTimeout) {
-                            clearTimeout(renderTimeout);
+                },
+                getBackgroundOutput: () => getFullBufferText(headlessTerminal),
+                getSubscriptionSnapshot: () => {
+                    const endLine = headlessTerminal.buffer.active.length;
+                    const startLine = Math.max(0, endLine - (shellExecutionConfig.maxSerializedLines ?? 2000));
+                    const bufferData = serializeTerminalToObject(headlessTerminal, startLine, endLine);
+                    return bufferData.length > 0 ? bufferData : undefined;
+                },
+            }).result;
+            let processingChain = Promise.resolve();
+            let decoder = null;
+            let output = null;
+            const outputChunks = [];
+            const error = null;
+            let exited = false;
+            let isStreamingRawContent = true;
+            const MAX_SNIFF_SIZE = 4096;
+            let sniffedBytes = 0;
+            let isWriting = false;
+            let hasStartedOutput = false;
+            let renderTimeout = null;
+            const renderFn = () => {
+                renderTimeout = null;
+                if (!isStreamingRawContent) {
+                    return;
+                }
+                if (!shellExecutionConfig.disableDynamicLineTrimming) {
+                    if (!hasStartedOutput) {
+                        const bufferText = getFullBufferText(headlessTerminal);
+                        if (bufferText.trim().length === 0) {
+                            return;
                         }
-                        renderFn();
-                        return;
+                        hasStartedOutput = true;
                     }
-                    if (renderTimeout) {
-                        return;
+                }
+                const buffer = headlessTerminal.buffer.active;
+                const endLine = buffer.length;
+                const startLine = Math.max(0, endLine - (shellExecutionConfig.maxSerializedLines ?? 2000));
+                let newOutput;
+                if (shellExecutionConfig.showColor) {
+                    newOutput = serializeTerminalToObject(headlessTerminal, startLine, endLine);
+                }
+                else {
+                    newOutput = (serializeTerminalToObject(headlessTerminal, startLine, endLine) ||
+                        []).map((line) => line.map((token) => {
+                        token.fg = '';
+                        token.bg = '';
+                        return token;
+                    }));
+                }
+                let lastNonEmptyLine = -1;
+                for (let i = newOutput.length - 1; i >= 0; i--) {
+                    const line = newOutput[i];
+                    if (line
+                        .map((segment) => segment.text)
+                        .join('')
+                        .trim().length > 0) {
+                        lastNonEmptyLine = i;
+                        break;
                     }
-                    renderTimeout = setTimeout(() => {
-                        renderFn();
-                        renderTimeout = null;
-                    }, 68);
-                };
-                headlessTerminal.onScroll(() => {
-                    if (!isWriting) {
-                        render();
+                }
+                const absoluteCursorY = buffer.baseY + buffer.cursorY;
+                const cursorRelativeIndex = absoluteCursorY - startLine;
+                if (cursorRelativeIndex > lastNonEmptyLine) {
+                    lastNonEmptyLine = cursorRelativeIndex;
+                }
+                const trimmedOutput = newOutput.slice(0, lastNonEmptyLine + 1);
+                const finalOutput = shellExecutionConfig.disableDynamicLineTrimming
+                    ? newOutput
+                    : trimmedOutput;
+                if (output !== finalOutput) {
+                    output = finalOutput;
+                    const event = {
+                        type: 'data',
+                        chunk: finalOutput,
+                    };
+                    onOutputEvent(event);
+                    ExecutionLifecycleService.emitEvent(ptyPid, event);
+                }
+            };
+            const render = (finalRender = false) => {
+                if (finalRender) {
+                    if (renderTimeout) {
+                        clearTimeout(renderTimeout);
                     }
-                });
-                const handleOutput = (data) => {
-                    processingChain = processingChain.then(() => new Promise((resolve) => {
-                        if (!decoder) {
-                            const encoding = getCachedEncodingForBuffer(data);
-                            try {
-                                decoder = new TextDecoder(encoding);
-                            }
-                            catch {
-                                decoder = new TextDecoder('utf-8');
-                            }
-                        }
-                        outputChunks.push(data);
-                        if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
-                            const sniffBuffer = Buffer.concat(outputChunks.slice(0, 20));
-                            sniffedBytes = sniffBuffer.length;
-                            if (isBinary(sniffBuffer)) {
-                                isStreamingRawContent = false;
-                                const event = { type: 'binary_detected' };
-                                onOutputEvent(event);
-                                ShellExecutionService.emitEvent(ptyProcess.pid, event);
-                            }
+                    renderFn();
+                    return;
+                }
+                if (renderTimeout) {
+                    return;
+                }
+                renderTimeout = setTimeout(() => {
+                    renderFn();
+                    renderTimeout = null;
+                }, 68);
+            };
+            headlessTerminal.onScroll(() => {
+                if (!isWriting) {
+                    render();
+                }
+            });
+            const handleOutput = (data) => {
+                processingChain = processingChain.then(() => new Promise((resolveChunk) => {
+                    if (!decoder) {
+                        const encoding = getCachedEncodingForBuffer(data);
+                        try {
+                            decoder = new TextDecoder(encoding);
                         }
-                        if (isStreamingRawContent) {
-                            const decodedChunk = decoder.decode(data, { stream: true });
-                            if (decodedChunk.length === 0) {
-                                resolve();
-                                return;
-                            }
-                            if (ShellExecutionService.backgroundLogPids.has(ptyProcess.pid)) {
-                                ShellExecutionService.syncBackgroundLog(ptyProcess.pid, decodedChunk);
-                            }
-                            isWriting = true;
-                            headlessTerminal.write(decodedChunk, () => {
-                                render();
-                                isWriting = false;
-                                resolve();
-                            });
+                        catch {
+                            decoder = new TextDecoder('utf-8');
                         }
-                        else {
-                            const totalBytes = outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
-                            const event = {
-                                type: 'binary_progress',
-                                bytesReceived: totalBytes,
-                            };
+                    }
+                    outputChunks.push(data);
+                    if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
+                        const sniffBuffer = Buffer.concat(outputChunks.slice(0, 20));
+                        sniffedBytes = sniffBuffer.length;
+                        if (isBinary(sniffBuffer)) {
+                            isStreamingRawContent = false;
+                            const event = { type: 'binary_detected' };
                             onOutputEvent(event);
-                            ShellExecutionService.emitEvent(ptyProcess.pid, event);
-                            resolve();
+                            ExecutionLifecycleService.emitEvent(ptyPid, event);
                         }
-                    }));
-                };
-                ptyProcess.onData((data) => {
-                    const bufferData = Buffer.from(data, 'utf-8');
-                    handleOutput(bufferData);
-                });
-                ptyProcess.onExit(({ exitCode, signal }) => {
-                    exited = true;
-                    abortSignal.removeEventListener('abort', abortHandler);
-                    // Attempt to destroy the PTY to ensure FD is closed
-                    try {
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-                        ptyProcess.destroy?.();
                     }
-                    catch {
-                        // Ignore errors during cleanup
-                    }
-                    const finalize = () => {
-                        render(true);
-                        // Store exit info for late subscribers (e.g. backgrounding race condition)
-                        this.exitedPtyInfo.set(ptyProcess.pid, { exitCode, signal });
-                        setTimeout(() => {
-                            this.exitedPtyInfo.delete(ptyProcess.pid);
-                        }, 5 * 60 * 1000).unref();
-                        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                        ShellExecutionService.cleanupLogStream(ptyProcess.pid).then(() => {
-                            this.activePtys.delete(ptyProcess.pid);
-                            this.activeResolvers.delete(ptyProcess.pid);
-                            const event = {
-                                type: 'exit',
-                                exitCode,
-                                signal: signal ?? null,
-                            };
-                            onOutputEvent(event);
-                            ShellExecutionService.emitEvent(ptyProcess.pid, event);
-                            this.activeListeners.delete(ptyProcess.pid);
-                            const finalBuffer = Buffer.concat(outputChunks);
-                            resolve({
-                                rawOutput: finalBuffer,
-                                output: getFullBufferText(headlessTerminal),
-                                exitCode,
-                                signal: signal ?? null,
-                                error,
-                                aborted: abortSignal.aborted,
-                                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                                pid: ptyProcess.pid,
-                                executionMethod: ptyInfo?.name ?? 'node-pty',
-                            });
+                    if (isStreamingRawContent) {
+                        const decodedChunk = decoder.decode(data, { stream: true });
+                        if (decodedChunk.length === 0) {
+                            resolveChunk();
+                            return;
+                        }
+                        if (ShellExecutionService.backgroundLogPids.has(ptyPid)) {
+                            ShellExecutionService.syncBackgroundLog(ptyPid, decodedChunk);
+                        }
+                        isWriting = true;
+                        headlessTerminal.write(decodedChunk, () => {
+                            render();
+                            isWriting = false;
+                            resolveChunk();
                         });
+                    }
+                    else {
+                        const totalBytes = outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                        const event = {
+                            type: 'binary_progress',
+                            bytesReceived: totalBytes,
+                        };
+                        onOutputEvent(event);
+                        ExecutionLifecycleService.emitEvent(ptyPid, event);
+                        resolveChunk();
+                    }
+                }));
+            };
+            ptyProcess.onData((data) => {
+                const bufferData = Buffer.from(data, 'utf-8');
+                handleOutput(bufferData);
+            });
+            ptyProcess.onExit(({ exitCode, signal }) => {
+                exited = true;
+                abortSignal.removeEventListener('abort', abortHandler);
+                // Attempt to destroy the PTY to ensure FD is closed
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+                    ptyProcess.destroy?.();
+                }
+                catch {
+                    // Ignore errors during cleanup
+                }
+                const finalize = () => {
+                    render(true);
+                    const event = {
+                        type: 'exit',
+                        exitCode,
+                        signal: signal ?? null,
                     };
+                    onOutputEvent(event);
+                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                    ShellExecutionService.cleanupLogStream(ptyPid).then(() => {
+                        ShellExecutionService.activePtys.delete(ptyPid);
+                    });
+                    ExecutionLifecycleService.completeWithResult(ptyPid, {
+                        rawOutput: Buffer.concat(outputChunks),
+                        output: getFullBufferText(headlessTerminal),
+                        exitCode,
+                        signal: signal ?? null,
+                        error,
+                        aborted: abortSignal.aborted,
+                        pid: ptyPid,
+                        executionMethod: ptyInfo?.name ?? 'node-pty',
+                    });
+                };
+                if (abortSignal.aborted) {
+                    finalize();
+                    return;
+                }
+                const processingComplete = processingChain.then(() => 'processed');
+                const abortFired = new Promise((res) => {
                     if (abortSignal.aborted) {
-                        finalize();
+                        res('aborted');
                         return;
                     }
-                    const processingComplete = processingChain.then(() => 'processed');
-                    const abortFired = new Promise((res) => {
-                        if (abortSignal.aborted) {
-                            res('aborted');
-                            return;
-                        }
-                        abortSignal.addEventListener('abort', () => res('aborted'), {
-                            once: true,
-                        });
-                    });
-                    // eslint-disable-next-line @typescript-eslint/no-floating-promises
-                    Promise.race([processingComplete, abortFired]).then(() => {
-                        finalize();
+                    abortSignal.addEventListener('abort', () => res('aborted'), {
+                        once: true,
                     });
                 });
-                const abortHandler = async () => {
-                    if (ptyProcess.pid && !exited) {
-                        await killProcessGroup({
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                            pid: ptyProcess.pid,
-                            escalate: true,
-                            isExited: () => exited,
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                            pty: ptyProcess,
-                        });
-                    }
-                };
-                abortSignal.addEventListener('abort', abortHandler, { once: true });
+                // eslint-disable-next-line @typescript-eslint/no-floating-promises
+                Promise.race([processingComplete, abortFired]).then(() => {
+                    finalize();
+                });
             });
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            return { pid: ptyProcess.pid, result };
+            const abortHandler = async () => {
+                if (ptyProcess.pid && !exited) {
+                    await killProcessGroup({
+                        pid: ptyPid,
+                        escalate: true,
+                        isExited: () => exited,
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                        pty: ptyProcess,
+                    });
+                }
+            };
+            abortSignal.addEventListener('abort', abortHandler, { once: true });
+            return { pid: ptyPid, result };
         }
         catch (e) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
@@ -775,38 +834,10 @@ export class ShellExecutionService {
      * @param input The string to write to the terminal.
      */
     static writeToPty(pid, input) {
-        if (this.activeChildProcesses.has(pid)) {
-            const activeChild = this.activeChildProcesses.get(pid);
-            if (activeChild) {
-                activeChild.process.stdin?.write(input);
-            }
-            return;
-        }
-        if (!this.isPtyActive(pid)) {
-            return;
-        }
-        const activePty = this.activePtys.get(pid);
-        if (activePty) {
-            activePty.ptyProcess.write(input);
-        }
+        ExecutionLifecycleService.writeInput(pid, input);
     }
     static isPtyActive(pid) {
-        if (this.activeChildProcesses.has(pid)) {
-            try {
-                return process.kill(pid, 0);
-            }
-            catch {
-                return false;
-            }
-        }
-        try {
-            // process.kill with signal 0 is a way to check for the existence of a process.
-            // It doesn't actually send a signal.
-            return process.kill(pid, 0);
-        }
-        catch (_) {
-            return false;
-        }
+        return ExecutionLifecycleService.isActive(pid);
     }
     /**
      * Registers a callback to be invoked when the process with the given PID exits.
@@ -817,36 +848,7 @@ export class ShellExecutionService {
      * @returns An unsubscribe function.
      */
     static onExit(pid, callback) {
-        const activePty = this.activePtys.get(pid);
-        if (activePty) {
-            const disposable = activePty.ptyProcess.onExit(({ exitCode, signal }) => {
-                callback(exitCode, signal);
-                disposable.dispose();
-            });
-            return () => disposable.dispose();
-        }
-        else if (this.activeChildProcesses.has(pid)) {
-            const activeChild = this.activeChildProcesses.get(pid);
-            const listener = (code, signal) => {
-                let signalNumber;
-                if (signal) {
-                    signalNumber = os.constants.signals[signal];
-                }
-                callback(code ?? 0, signalNumber);
-            };
-            activeChild?.process.on('exit', listener);
-            return () => {
-                activeChild?.process.removeListener('exit', listener);
-            };
-        }
-        else {
-            // Check if it already exited recently
-            const exitedInfo = this.exitedPtyInfo.get(pid);
-            if (exitedInfo) {
-                callback(exitedInfo.exitCode, exitedInfo.signal);
-            }
-            return () => { };
-        }
+        return ExecutionLifecycleService.onExit(pid, callback);
     }
     /**
      * Kills a process by its PID.
@@ -854,25 +856,10 @@ export class ShellExecutionService {
      * @param pid The process ID to kill.
      */
     static async kill(pid) {
-        const activePty = this.activePtys.get(pid);
-        const activeChild = this.activeChildProcesses.get(pid);
         await this.cleanupLogStream(pid);
-        if (activeChild) {
-            killProcessGroup({ pid }).catch(() => { });
-            this.activeChildProcesses.delete(pid);
-        }
-        else if (activePty) {
-            killProcessGroup({ pid, pty: activePty.ptyProcess }).catch(() => { });
-            try {
-                activePty.ptyProcess.destroy?.();
-            }
-            catch {
-                // Ignore errors during cleanup
-            }
-            this.activePtys.delete(pid);
-        }
-        this.activeResolvers.delete(pid);
-        this.activeListeners.delete(pid);
+        this.activePtys.delete(pid);
+        this.activeChildProcesses.delete(pid);
+        ExecutionLifecycleService.kill(pid);
     }
     /**
      * Moves a running shell command to the background.
@@ -881,17 +868,9 @@ export class ShellExecutionService {
      * @param pid The process ID of the target PTY.
      */
     static background(pid) {
-        const resolve = this.activeResolvers.get(pid);
-        if (!resolve)
-            return;
         const activePty = this.activePtys.get(pid);
         const activeChild = this.activeChildProcesses.get(pid);
-        if (!activePty && !activeChild)
-            return;
-        const output = activePty
-            ? getFullBufferText(activePty.headlessTerminal)
-            : (activeChild?.state.output ?? '');
-        const executionMethod = activePty ? 'node-pty' : 'child_process';
+        // Set up background logging
         const logPath = this.getLogFilePath(pid);
         const logDir = this.getLogDir();
         try {
@@ -905,6 +884,7 @@ export class ShellExecutionService {
                 writeBufferToLogStream(activePty.headlessTerminal, stream, 0);
             }
             else if (activeChild) {
+                const output = activeChild.state.output;
                 if (output) {
                     stream.write(stripAnsi(output) + '\n');
                 }
@@ -914,48 +894,10 @@ export class ShellExecutionService {
             debugLogger.warn('Failed to setup background logging:', e);
         }
         this.backgroundLogPids.add(pid);
-        resolve({
-            rawOutput: Buffer.from(''),
-            output,
-            exitCode: null,
-            signal: null,
-            error: null,
-            aborted: false,
-            pid,
-            executionMethod,
-            backgrounded: true,
-        });
-        this.activeResolvers.delete(pid);
+        ExecutionLifecycleService.background(pid);
     }
     static subscribe(pid, listener) {
-        if (!this.activeListeners.has(pid)) {
-            this.activeListeners.set(pid, new Set());
-        }
-        this.activeListeners.get(pid)?.add(listener);
-        // Send current buffer content immediately
-        const activePty = this.activePtys.get(pid);
-        const activeChild = this.activeChildProcesses.get(pid);
-        if (activePty) {
-            // Use serializeTerminalToObject to preserve colors and structure
-            const endLine = activePty.headlessTerminal.buffer.active.length;
-            const startLine = Math.max(0, endLine - (activePty.maxSerializedLines ?? 2000));
-            const bufferData = serializeTerminalToObject(activePty.headlessTerminal, startLine, endLine);
-            if (bufferData && bufferData.length > 0) {
-                listener({ type: 'data', chunk: bufferData });
-            }
-        }
-        else if (activeChild) {
-            const output = activeChild.state.output;
-            if (output) {
-                listener({ type: 'data', chunk: output });
-            }
-        }
-        return () => {
-            this.activeListeners.get(pid)?.delete(listener);
-            if (this.activeListeners.get(pid)?.size === 0) {
-                this.activeListeners.delete(pid);
-            }
-        };
+        return ExecutionLifecycleService.subscribe(pid, listener);
     }
     /**
      * Resizes the pseudo-terminal (PTY) of a running process.
@@ -997,10 +939,7 @@ export class ShellExecutionService {
             const startLine = Math.max(0, endLine - (activePty.maxSerializedLines ?? 2000));
             const bufferData = serializeTerminalToObject(activePty.headlessTerminal, startLine, endLine);
             const event = { type: 'data', chunk: bufferData };
-            const listeners = ShellExecutionService.activeListeners.get(pid);
-            if (listeners) {
-                listeners.forEach((listener) => listener(event));
-            }
+            ExecutionLifecycleService.emitEvent(pid, event);
         }
     }
     /**