@office-ai/aioncli-core 0.26.0 → 0.30.1

package/dist/src/services/shellExecutionService.js

@@ -9,14 +9,24 @@ import { spawn as cpSpawn } from 'node:child_process';
 import { TextDecoder } from 'node:util';
 import os from 'node:os';
 import { getCachedEncodingForBuffer } from '../utils/systemEncoding.js';
-import { getShellConfiguration } from '../utils/shell-utils.js';
+import { getShellConfiguration, resolveExecutable, } from '../utils/shell-utils.js';
 import { isBinary } from '../utils/textUtils.js';
 import pkg from '@xterm/headless';
 import { serializeTerminalToObject, } from '../utils/terminalSerializer.js';
 import { sanitizeEnvironment, } from './environmentSanitization.js';
+import { killProcessGroup } from '../utils/process-utils.js';
 const { Terminal } = pkg;
-const SIGKILL_TIMEOUT_MS = 200;
 const MAX_CHILD_PROCESS_BUFFER_SIZE = 16 * 1024 * 1024; // 16MB
+/**
+ * An environment variable that is set for shell executions. This can be used
+ * by downstream executables and scripts to identify that they were executed
+ * from within Gemini CLI.
+ */
+export const GEMINI_CLI_IDENTIFICATION_ENV_VAR = 'GEMINI_CLI';
+/**
+ * The value of {@link GEMINI_CLI_IDENTIFICATION_ENV_VAR}
+ */
+export const GEMINI_CLI_IDENTIFICATION_ENV_VAR_VALUE = '1';
 // We want to allow shell outputs that are close to the context window in size.
 // 300,000 lines is roughly equivalent to a large context window, ensuring
 // we capture significant output from long-running commands.
@@ -73,6 +83,10 @@ const getFullBufferText = (terminal) => {
  */
 export class ShellExecutionService {
     static activePtys = new Map();
+    static activeChildProcesses = new Map();
+    static exitedPtyInfo = new Map();
+    static activeResolvers = new Map();
+    static activeListeners = new Map();
     /**
      * Executes a shell command using `node-pty`, capturing all output and lifecycle events.
      *
@@ -88,7 +102,7 @@ export class ShellExecutionService {
             const ptyInfo = await getPty();
             if (ptyInfo) {
                 try {
-                    return this.executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo);
+                    return await this.executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo);
                 }
                 catch (_e) {
                     // Fallback to child_process
@@ -119,6 +133,12 @@ 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) {
         try {
             const isWindows = os.platform() === 'win32';
@@ -133,20 +153,29 @@ export class ShellExecutionService {
                 detached: !isWindows,
                 env: {
                     ...sanitizeEnvironment(process.env, sanitizationConfig),
-                    GEMINI_CLI: '1',
+                    [GEMINI_CLI_IDENTIFICATION_ENV_VAR]: GEMINI_CLI_IDENTIFICATION_ENV_VAR_VALUE,
                     TERM: 'xterm-256color',
                     PAGER: 'cat',
                     GIT_PAGER: 'cat',
                 },
             });
+            const state = {
+                output: '',
+                truncated: false,
+                outputChunks: [],
+            };
+            if (child.pid) {
+                this.activeChildProcesses.set(child.pid, {
+                    process: child,
+                    state,
+                });
+            }
             const result = new Promise((resolve) => {
+                if (child.pid) {
+                    this.activeResolvers.set(child.pid, resolve);
+                }
                 let stdoutDecoder = null;
                 let stderrDecoder = null;
-                let stdout = '';
-                let stderr = '';
-                let stdoutTruncated = false;
-                let stderrTruncated = false;
-                const outputChunks = [];
                 let error = null;
                 let exited = false;
                 let isStreamingRawContent = true;
@@ -166,12 +195,16 @@ export class ShellExecutionService {
                             stderrDecoder = new TextDecoder('utf-8');
                         }
                     }
-                    outputChunks.push(data);
+                    state.outputChunks.push(data);
                     if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
-                        const sniffBuffer = Buffer.concat(outputChunks.slice(0, 20));
+                        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);
                         }
                     }
                     // Emit process event to indicate the process is actively running
@@ -179,7 +212,7 @@ export class ShellExecutionService {
                     if (isStreamingRawContent) {
                         const now = Date.now();
                         if (now - lastProcessEventTime >= PROCESS_EVENT_INTERVAL_MS) {
-                            const totalBytes = outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                            const totalBytes = state.outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
                             onOutputEvent({ type: 'process', bytesReceived: totalBytes });
                             lastProcessEventTime = now;
                         }
@@ -187,48 +220,62 @@ export class ShellExecutionService {
                     if (isStreamingRawContent) {
                         const decoder = stream === 'stdout' ? stdoutDecoder : stderrDecoder;
                         const decodedChunk = decoder.decode(data, { stream: true });
-                        if (stream === 'stdout') {
-                            const { newBuffer, truncated } = this.appendAndTruncate(stdout, decodedChunk, MAX_CHILD_PROCESS_BUFFER_SIZE);
-                            stdout = newBuffer;
-                            if (truncated) {
-                                stdoutTruncated = true;
-                            }
+                        const { newBuffer, truncated } = this.appendAndTruncate(state.output, decodedChunk, MAX_CHILD_PROCESS_BUFFER_SIZE);
+                        state.output = newBuffer;
+                        if (truncated) {
+                            state.truncated = true;
                         }
-                        else {
-                            const { newBuffer, truncated } = this.appendAndTruncate(stderr, decodedChunk, MAX_CHILD_PROCESS_BUFFER_SIZE);
-                            stderr = newBuffer;
-                            if (truncated) {
-                                stderrTruncated = true;
-                            }
+                        if (decodedChunk) {
+                            const event = {
+                                type: 'data',
+                                chunk: decodedChunk,
+                            };
+                            onOutputEvent(event);
+                            if (child.pid)
+                                ShellExecutionService.emitEvent(child.pid, event);
                         }
                     }
+                    else {
+                        const totalBytes = state.outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                        const event = {
+                            type: 'binary_progress',
+                            bytesReceived: totalBytes,
+                        };
+                        onOutputEvent(event);
+                        if (child.pid)
+                            ShellExecutionService.emitEvent(child.pid, event);
+                    }
                 };
                 const handleExit = (code, signal) => {
                     const { finalBuffer } = cleanup();
-                    // Ensure we don't add an extra newline if stdout already ends with one.
-                    const separator = stdout.endsWith('\n') ? '' : '\n';
-                    let combinedOutput = stdout + (stderr ? (stdout ? separator : '') + stderr : '');
-                    if (stdoutTruncated || stderrTruncated) {
+                    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();
-                    if (isStreamingRawContent) {
-                        if (finalStrippedOutput) {
-                            onOutputEvent({ type: 'data', chunk: finalStrippedOutput });
-                        }
-                    }
-                    else {
-                        onOutputEvent({ type: 'binary_detected' });
+                    const exitCode = code;
+                    const exitSignal = signal ? os.constants.signals[signal] : null;
+                    if (child.pid) {
+                        const event = {
+                            type: 'exit',
+                            exitCode,
+                            signal: exitSignal,
+                        };
+                        onOutputEvent(event);
+                        ShellExecutionService.emitEvent(child.pid, event);
+                        this.activeChildProcesses.delete(child.pid);
+                        this.activeResolvers.delete(child.pid);
+                        this.activeListeners.delete(child.pid);
                     }
                     resolve({
                         rawOutput: finalBuffer,
                         output: finalStrippedOutput,
-                        exitCode: code,
-                        signal: signal ? os.constants.signals[signal] : null,
+                        exitCode,
+                        signal: exitSignal,
                         error,
                         aborted: abortSignal.aborted,
-                        pid: undefined,
+                        pid: child.pid,
                         executionMethod: 'child_process',
                     });
                 };
@@ -240,29 +287,15 @@ export class ShellExecutionService {
                 });
                 const abortHandler = async () => {
                     if (child.pid && !exited) {
-                        if (isWindows) {
-                            cpSpawn('taskkill', ['/pid', child.pid.toString(), '/f', '/t']);
-                        }
-                        else {
-                            try {
-                                process.kill(-child.pid, 'SIGTERM');
-                                await new Promise((res) => setTimeout(res, SIGKILL_TIMEOUT_MS));
-                                if (!exited) {
-                                    process.kill(-child.pid, 'SIGKILL');
-                                }
-                            }
-                            catch (_e) {
-                                if (!exited)
-                                    child.kill('SIGKILL');
-                            }
-                        }
+                        await killProcessGroup({
+                            pid: child.pid,
+                            escalate: true,
+                            isExited: () => exited,
+                        });
                     }
                 };
                 abortSignal.addEventListener('abort', abortHandler, { once: true });
                 child.on('exit', (code, signal) => {
-                    if (child.pid) {
-                        this.activePtys.delete(child.pid);
-                    }
                     handleExit(code, signal);
                 });
                 function cleanup() {
@@ -271,22 +304,43 @@ export class ShellExecutionService {
                     if (stdoutDecoder) {
                         const remaining = stdoutDecoder.decode();
                         if (remaining) {
-                            stdout += 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);
+                            }
                         }
                     }
                     if (stderrDecoder) {
                         const remaining = stderrDecoder.decode();
                         if (remaining) {
-                            stderr += remaining;
+                            state.output += remaining;
+                            if (isStreamingRawContent && remaining) {
+                                const event = {
+                                    type: 'data',
+                                    chunk: remaining,
+                                };
+                                onOutputEvent(event);
+                                if (child.pid)
+                                    ShellExecutionService.emitEvent(child.pid, event);
+                            }
                         }
                     }
-                    const finalBuffer = Buffer.concat(outputChunks);
-                    return { stdout, stderr, finalBuffer };
+                    const finalBuffer = Buffer.concat(state.outputChunks);
+                    return { finalBuffer };
                 }
             });
-            return { pid: undefined, result };
+            return { pid: child.pid, result };
         }
         catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             const error = e;
             return {
                 pid: undefined,
@@ -303,7 +357,7 @@ export class ShellExecutionService {
             };
         }
     }
-    static executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo) {
+    static async executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, shellExecutionConfig, ptyInfo) {
         if (!ptyInfo) {
             // This should not happen, but as a safeguard...
             throw new Error('PTY implementation not found');
@@ -312,11 +366,15 @@ export class ShellExecutionService {
             const cols = shellExecutionConfig.terminalWidth ?? 80;
             const rows = shellExecutionConfig.terminalHeight ?? 30;
             const { executable, argsPrefix, shell } = getShellConfiguration();
+            const resolvedExecutable = await resolveExecutable(executable);
+            if (!resolvedExecutable) {
+                throw new Error(`Shell executable "${executable}" not found in PATH or at absolute location. Please ensure the shell is installed and available in your environment.`);
+            }
             const guardedCommand = ensurePromptvarsDisabled(commandToExecute, shell);
             const args = [...argsPrefix, guardedCommand];
             const ptyProcess = ptyInfo.module.spawn(executable, args, {
                 cwd,
-                name: 'xterm',
+                name: 'xterm-256color',
                 cols,
                 rows,
                 env: {
@@ -329,6 +387,7 @@ export class ShellExecutionService {
                 handleFlowControl: true,
             });
             const result = new Promise((resolve) => {
+                this.activeResolvers.set(ptyProcess.pid, resolve);
                 const headlessTerminal = new Terminal({
                     allowProposedApi: true,
                     cols,
@@ -336,7 +395,11 @@ export class ShellExecutionService {
                     scrollback: shellExecutionConfig.scrollback ?? SCROLLBACK_LIMIT,
                 });
                 headlessTerminal.scrollToTop();
-                this.activePtys.set(ptyProcess.pid, { ptyProcess, headlessTerminal });
+                this.activePtys.set(ptyProcess.pid, {
+                    ptyProcess,
+                    headlessTerminal,
+                    maxSerializedLines: shellExecutionConfig.maxSerializedLines,
+                });
                 let processingChain = Promise.resolve();
                 let decoder = null;
                 let output = null;
@@ -364,12 +427,15 @@ export class ShellExecutionService {
                         }
                     }
                     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);
+                        newOutput = serializeTerminalToObject(headlessTerminal, startLine, endLine);
                     }
                     else {
-                        newOutput = (serializeTerminalToObject(headlessTerminal) || []).map((line) => line.map((token) => {
+                        newOutput = (serializeTerminalToObject(headlessTerminal, startLine, endLine) ||
+                            []).map((line) => line.map((token) => {
                             token.fg = '';
                             token.bg = '';
                             return token;
@@ -386,20 +452,23 @@ export class ShellExecutionService {
                             break;
                         }
                     }
-                    if (buffer.cursorY > lastNonEmptyLine) {
-                        lastNonEmptyLine = buffer.cursorY;
+                    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;
-                    // Using stringify for a quick deep comparison.
-                    if (JSON.stringify(output) !== JSON.stringify(finalOutput)) {
+                    if (output !== finalOutput) {
                         output = finalOutput;
-                        onOutputEvent({
+                        const event = {
                             type: 'data',
                             chunk: finalOutput,
-                        });
+                        };
+                        onOutputEvent(event);
+                        ShellExecutionService.emitEvent(ptyProcess.pid, event);
                     }
                 };
                 const render = (finalRender = false) => {
@@ -440,7 +509,9 @@ export class ShellExecutionService {
                             sniffedBytes = sniffBuffer.length;
                             if (isBinary(sniffBuffer)) {
                                 isStreamingRawContent = false;
-                                onOutputEvent({ type: 'binary_detected' });
+                                const event = { type: 'binary_detected' };
+                                onOutputEvent(event);
+                                ShellExecutionService.emitEvent(ptyProcess.pid, event);
                             }
                         }
                         if (isStreamingRawContent) {
@@ -458,10 +529,12 @@ export class ShellExecutionService {
                         }
                         else {
                             const totalBytes = outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
-                            onOutputEvent({
+                            const event = {
                                 type: 'binary_progress',
                                 bytesReceived: totalBytes,
-                            });
+                            };
+                            onOutputEvent(event);
+                            ShellExecutionService.emitEvent(ptyProcess.pid, event);
                             resolve();
                         }
                     }));
@@ -474,8 +547,31 @@ export class ShellExecutionService {
                     exited = true;
                     abortSignal.removeEventListener('abort', abortHandler);
                     this.activePtys.delete(ptyProcess.pid);
+                    // 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();
+                        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,
@@ -509,27 +605,12 @@ export class ShellExecutionService {
                 });
                 const abortHandler = async () => {
                     if (ptyProcess.pid && !exited) {
-                        if (os.platform() === 'win32') {
-                            ptyProcess.kill();
-                        }
-                        else {
-                            try {
-                                // Kill the entire process group
-                                process.kill(-ptyProcess.pid, 'SIGTERM');
-                                await new Promise((res) => setTimeout(res, SIGKILL_TIMEOUT_MS));
-                                if (!exited) {
-                                    process.kill(-ptyProcess.pid, 'SIGKILL');
-                                }
-                            }
-                            catch (_e) {
-                                // Fallback to killing just the process if the group kill fails
-                                ptyProcess.kill('SIGTERM');
-                                await new Promise((res) => setTimeout(res, SIGKILL_TIMEOUT_MS));
-                                if (!exited) {
-                                    ptyProcess.kill('SIGKILL');
-                                }
-                            }
-                        }
+                        await killProcessGroup({
+                            pid: ptyProcess.pid,
+                            escalate: true,
+                            isExited: () => exited,
+                            pty: ptyProcess,
+                        });
                     }
                 };
                 abortSignal.addEventListener('abort', abortHandler, { once: true });
@@ -537,6 +618,7 @@ export class ShellExecutionService {
             return { pid: ptyProcess.pid, result };
         }
         catch (e) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
             const error = e;
             if (error.message.includes('posix_spawnp failed')) {
                 onOutputEvent({
@@ -569,6 +651,13 @@ 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;
         }
@@ -578,6 +667,14 @@ export class ShellExecutionService {
         }
     }
     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.
@@ -587,6 +684,139 @@ export class ShellExecutionService {
             return false;
         }
     }
+    /**
+     * Registers a callback to be invoked when the process with the given PID exits.
+     * This attaches directly to the PTY's exit event.
+     *
+     * @param pid The process ID to watch.
+     * @param callback The function to call on exit.
+     * @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 () => { };
+        }
+    }
+    /**
+     * Kills a process by its PID.
+     *
+     * @param pid The process ID to kill.
+     */
+    static kill(pid) {
+        const activePty = this.activePtys.get(pid);
+        const activeChild = this.activeChildProcesses.get(pid);
+        if (activeChild) {
+            killProcessGroup({ pid }).catch(() => { });
+            this.activeChildProcesses.delete(pid);
+        }
+        else if (activePty) {
+            killProcessGroup({ pid, pty: activePty.ptyProcess }).catch(() => { });
+            this.activePtys.delete(pid);
+        }
+        this.activeResolvers.delete(pid);
+        this.activeListeners.delete(pid);
+    }
+    /**
+     * Moves a running shell command to the background.
+     * This resolves the execution promise but keeps the PTY active.
+     *
+     * @param pid The process ID of the target PTY.
+     */
+    static background(pid) {
+        const resolve = this.activeResolvers.get(pid);
+        if (resolve) {
+            let output = '';
+            const rawOutput = Buffer.from('');
+            const activePty = this.activePtys.get(pid);
+            const activeChild = this.activeChildProcesses.get(pid);
+            if (activePty) {
+                output = getFullBufferText(activePty.headlessTerminal);
+                resolve({
+                    rawOutput,
+                    output,
+                    exitCode: null,
+                    signal: null,
+                    error: null,
+                    aborted: false,
+                    pid,
+                    executionMethod: 'node-pty',
+                    backgrounded: true,
+                });
+            }
+            else if (activeChild) {
+                output = activeChild.state.output;
+                resolve({
+                    rawOutput,
+                    output,
+                    exitCode: null,
+                    signal: null,
+                    error: null,
+                    aborted: false,
+                    pid,
+                    executionMethod: 'child_process',
+                    backgrounded: true,
+                });
+            }
+            this.activeResolvers.delete(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);
+            }
+        };
+    }
     /**
      * Resizes the pseudo-terminal (PTY) of a running process.
      *
@@ -607,6 +837,7 @@ export class ShellExecutionService {
             catch (e) {
                 // Ignore errors if the pty has already exited, which can happen
                 // due to a race condition between the exit event and this call.
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
                 const err = e;
                 const isEsrch = err.code === 'ESRCH';
                 const isWindowsPtyError = err.message?.includes('Cannot resize a pty that has already exited');
@@ -620,6 +851,17 @@ export class ShellExecutionService {
                 }
             }
         }
+        // Force emit the new state after resize
+        if (activePty) {
+            const endLine = activePty.headlessTerminal.buffer.active.length;
+            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));
+            }
+        }
     }
     /**
      * Scrolls the pseudo-terminal (PTY) of a running process.