@google/gemini-cli-core 0.1.22 → 0.2.0-preview.0

package/dist/src/services/fileSystemService.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Interface for file system operations that may be delegated to different implementations
+ */
+export interface FileSystemService {
+    /**
+     * Read text content from a file
+     *
+     * @param filePath - The path to the file to read
+     * @returns The file content as a string
+     */
+    readTextFile(filePath: string): Promise<string>;
+    /**
+     * Write text content to a file
+     *
+     * @param filePath - The path to the file to write
+     * @param content - The content to write
+     */
+    writeTextFile(filePath: string, content: string): Promise<void>;
+}
+/**
+ * Standard file system implementation
+ */
+export declare class StandardFileSystemService implements FileSystemService {
+    readTextFile(filePath: string): Promise<string>;
+    writeTextFile(filePath: string, content: string): Promise<void>;
+}

package/dist/src/services/fileSystemService.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'fs/promises';
+/**
+ * Standard file system implementation
+ */
+export class StandardFileSystemService {
+    async readTextFile(filePath) {
+        return fs.readFile(filePath, 'utf-8');
+    }
+    async writeTextFile(filePath, content) {
+        await fs.writeFile(filePath, content, 'utf-8');
+    }
+}
+//# sourceMappingURL=fileSystemService.js.map

package/dist/src/services/fileSystemService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystemService.js","sourceRoot":"","sources":["../../../src/services/fileSystemService.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,aAAa,CAAC;AAuB7B;;GAEG;AACH,MAAM,OAAO,yBAAyB;IACpC,KAAK,CAAC,YAAY,CAAC,QAAgB;QACjC,OAAO,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,aAAa,CAAC,QAAgB,EAAE,OAAe;QACnD,MAAM,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;CACF"}

package/dist/src/services/fileSystemService.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/services/fileSystemService.test.js

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import fs from 'fs/promises';
+import { StandardFileSystemService } from './fileSystemService.js';
+vi.mock('fs/promises');
+describe('StandardFileSystemService', () => {
+    let fileSystem;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        fileSystem = new StandardFileSystemService();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('readTextFile', () => {
+        it('should read file content using fs', async () => {
+            const testContent = 'Hello, World!';
+            vi.mocked(fs.readFile).mockResolvedValue(testContent);
+            const result = await fileSystem.readTextFile('/test/file.txt');
+            expect(fs.readFile).toHaveBeenCalledWith('/test/file.txt', 'utf-8');
+            expect(result).toBe(testContent);
+        });
+        it('should propagate fs.readFile errors', async () => {
+            const error = new Error('ENOENT: File not found');
+            vi.mocked(fs.readFile).mockRejectedValue(error);
+            await expect(fileSystem.readTextFile('/test/file.txt')).rejects.toThrow('ENOENT: File not found');
+        });
+    });
+    describe('writeTextFile', () => {
+        it('should write file content using fs', async () => {
+            vi.mocked(fs.writeFile).mockResolvedValue();
+            await fileSystem.writeTextFile('/test/file.txt', 'Hello, World!');
+            expect(fs.writeFile).toHaveBeenCalledWith('/test/file.txt', 'Hello, World!', 'utf-8');
+        });
+    });
+});
+//# sourceMappingURL=fileSystemService.test.js.map

package/dist/src/services/fileSystemService.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileSystemService.test.js","sourceRoot":"","sources":["../../../src/services/fileSystemService.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AACzE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC7B,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAEnE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;AAEvB,QAAQ,CAAC,2BAA2B,EAAE,GAAG,EAAE;IACzC,IAAI,UAAqC,CAAC;IAE1C,UAAU,CAAC,GAAG,EAAE;QACd,EAAE,CAAC,aAAa,EAAE,CAAC;QACnB,UAAU,GAAG,IAAI,yBAAyB,EAAE,CAAC;IAC/C,CAAC,CAAC,CAAC;IAEH,SAAS,CAAC,GAAG,EAAE;QACb,EAAE,CAAC,eAAe,EAAE,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,cAAc,EAAE,GAAG,EAAE;QAC5B,EAAE,CAAC,mCAAmC,EAAE,KAAK,IAAI,EAAE;YACjD,MAAM,WAAW,GAAG,eAAe,CAAC;YACpC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;YAEtD,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC;YAE/D,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,oBAAoB,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;YACpE,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACnC,CAAC,CAAC,CAAC;QAEH,EAAE,CAAC,qCAAqC,EAAE,KAAK,IAAI,EAAE;YACnD,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;YAClD,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAEhD,MAAM,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CACrE,wBAAwB,CACzB,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,QAAQ,CAAC,eAAe,EAAE,GAAG,EAAE;QAC7B,EAAE,CAAC,oCAAoC,EAAE,KAAK,IAAI,EAAE;YAClD,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,iBAAiB,EAAE,CAAC;YAE5C,MAAM,UAAU,CAAC,aAAa,CAAC,gBAAgB,EAAE,eAAe,CAAC,CAAC;YAElE,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,oBAAoB,CACvC,gBAAgB,EAChB,eAAe,EACf,OAAO,CACR,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/src/services/shellExecutionService.d.ts

@@ -7,22 +7,20 @@
 export interface ShellExecutionResult {
     /** The raw, unprocessed output buffer. */
     rawOutput: Buffer;
-    /** The combined, decoded stdout and stderr as a string. */
+    /** The combined, decoded output as a string. */
     output: string;
-    /** The decoded stdout as a string. */
-    stdout: string;
-    /** The decoded stderr as a string. */
-    stderr: string;
     /** The process exit code, or null if terminated by a signal. */
     exitCode: number | null;
     /** The signal that terminated the process, if any. */
-    signal: NodeJS.Signals | null;
+    signal: number | null;
     /** An error object if the process failed to spawn. */
     error: Error | null;
     /** A boolean indicating if the command was aborted by the user. */
     aborted: boolean;
     /** The process ID of the spawned shell. */
     pid: number | undefined;
+    /** The method used to execute the shell command. */
+    executionMethod: 'lydell-node-pty' | 'node-pty' | 'child_process' | 'none';
 }
 /** A handle for an ongoing shell execution. */
 export interface ShellExecutionHandle {
@@ -37,8 +35,6 @@ export interface ShellExecutionHandle {
 export type ShellOutputEvent = {
     /** The event contains a chunk of output data. */
     type: 'data';
-    /** The stream from which the data originated. */
-    stream: 'stdout' | 'stderr';
     /** The decoded string chunk. */
     chunk: string;
 } | {
@@ -57,7 +53,7 @@ export type ShellOutputEvent = {
  */
 export declare class ShellExecutionService {
     /**
-     * Executes a shell command using `spawn`, capturing all output and lifecycle events.
+     * Executes a shell command using `node-pty`, capturing all output and lifecycle events.
      *
      * @param commandToExecute The exact command string to run.
      * @param cwd The working directory to execute the command in.
@@ -66,5 +62,7 @@ export declare class ShellExecutionService {
      * @returns An object containing the process ID (pid) and a promise that
      *          resolves with the complete execution result.
      */
-    static execute(commandToExecute: string, cwd: string, onOutputEvent: (event: ShellOutputEvent) => void, abortSignal: AbortSignal): ShellExecutionHandle;
+    static execute(commandToExecute: string, cwd: string, onOutputEvent: (event: ShellOutputEvent) => void, abortSignal: AbortSignal, shouldUseNodePty: boolean, terminalColumns?: number, terminalRows?: number): Promise<ShellExecutionHandle>;
+    private static childProcessFallback;
+    private static executeWithPty;
 }

package/dist/src/services/shellExecutionService.js

@@ -3,13 +3,26 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { spawn } from 'child_process';
+import { getPty } from '../utils/getPty.js';
+import { spawn as cpSpawn } from 'child_process';
 import { TextDecoder } from 'util';
 import os from 'os';
-import stripAnsi from 'strip-ansi';
 import { getCachedEncodingForBuffer } from '../utils/systemEncoding.js';
 import { isBinary } from '../utils/textUtils.js';
+import pkg from '@xterm/headless';
+import stripAnsi from 'strip-ansi';
+const { Terminal } = pkg;
 const SIGKILL_TIMEOUT_MS = 200;
+// @ts-expect-error getFullText is not a public API.
+const getFullText = (terminal) => {
+    const buffer = terminal.buffer.active;
+    const lines = [];
+    for (let i = 0; i < buffer.length; i++) {
+        const line = buffer.getLine(i);
+        lines.push(line ? line.translateToString(true) : '');
+    }
+    return lines.join('\n').trim();
+};
 /**
  * A centralized service for executing shell commands with robust process
  * management, cross-platform compatibility, and streaming output capabilities.
@@ -17,7 +30,7 @@ const SIGKILL_TIMEOUT_MS = 200;
  */
 export class ShellExecutionService {
     /**
-     * Executes a shell command using `spawn`, capturing all output and lifecycle events.
+     * Executes a shell command using `node-pty`, capturing all output and lifecycle events.
      *
      * @param commandToExecute The exact command string to run.
      * @param cwd The working directory to execute the command in.
@@ -26,150 +39,293 @@ export class ShellExecutionService {
      * @returns An object containing the process ID (pid) and a promise that
      *          resolves with the complete execution result.
      */
-    static execute(commandToExecute, cwd, onOutputEvent, abortSignal) {
-        const isWindows = os.platform() === 'win32';
-        const child = spawn(commandToExecute, [], {
-            cwd,
-            stdio: ['ignore', 'pipe', 'pipe'],
-            // Use bash unless in Windows (since it doesn't support bash).
-            // For windows, just use the default.
-            shell: isWindows ? true : 'bash',
-            // Use process groups on non-Windows for robust killing.
-            // Windows process termination is handled by `taskkill /t`.
-            detached: !isWindows,
-            env: {
-                ...process.env,
-                GEMINI_CLI: '1',
-            },
-        });
-        const result = new Promise((resolve) => {
-            // Use decoders to handle multi-byte characters safely (for streaming output).
-            let stdoutDecoder = null;
-            let stderrDecoder = null;
-            let stdout = '';
-            let stderr = '';
-            const outputChunks = [];
-            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);
+    static async execute(commandToExecute, cwd, onOutputEvent, abortSignal, shouldUseNodePty, terminalColumns, terminalRows) {
+        if (shouldUseNodePty) {
+            const ptyInfo = await getPty();
+            if (ptyInfo) {
+                try {
+                    return this.executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, terminalColumns, terminalRows, ptyInfo);
+                }
+                catch (_e) {
+                    // Fallback to child_process
+                }
+            }
+        }
+        return this.childProcessFallback(commandToExecute, cwd, onOutputEvent, abortSignal);
+    }
+    static childProcessFallback(commandToExecute, cwd, onOutputEvent, abortSignal) {
+        try {
+            const isWindows = os.platform() === 'win32';
+            const child = cpSpawn(commandToExecute, [], {
+                cwd,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                shell: isWindows ? true : 'bash',
+                detached: !isWindows,
+                env: {
+                    ...process.env,
+                    GEMINI_CLI: '1',
+                    TERM: 'xterm-256color',
+                    PAGER: 'cat',
+                },
+            });
+            const result = new Promise((resolve) => {
+                let stdoutDecoder = null;
+                let stderrDecoder = null;
+                let stdout = '';
+                let stderr = '';
+                const outputChunks = [];
+                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);
+                        }
+                        catch {
+                            stdoutDecoder = new TextDecoder('utf-8');
+                            stderrDecoder = new TextDecoder('utf-8');
+                        }
                     }
-                    catch {
-                        // If the encoding is not supported, fall back to utf-8.
-                        // This can happen on some platforms for certain encodings like 'utf-32le'.
-                        stdoutDecoder = new TextDecoder('utf-8');
-                        stderrDecoder = 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;
+                            onOutputEvent({ type: 'binary_detected' });
+                        }
                     }
-                }
-                outputChunks.push(data);
-                // Binary detection logic. This only runs until we've made a determination.
-                if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
-                    const sniffBuffer = Buffer.concat(outputChunks.slice(0, 20));
-                    sniffedBytes = sniffBuffer.length;
-                    if (isBinary(sniffBuffer)) {
-                        // Change state to stop streaming raw content.
-                        isStreamingRawContent = false;
-                        onOutputEvent({ type: 'binary_detected' });
+                    const decoder = stream === 'stdout' ? stdoutDecoder : stderrDecoder;
+                    const decodedChunk = decoder.decode(data, { stream: true });
+                    const strippedChunk = stripAnsi(decodedChunk);
+                    if (stream === 'stdout') {
+                        stdout += strippedChunk;
                     }
+                    else {
+                        stderr += strippedChunk;
+                    }
+                    if (isStreamingRawContent) {
+                        onOutputEvent({ type: 'data', chunk: strippedChunk });
+                    }
+                    else {
+                        const totalBytes = outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                        onOutputEvent({
+                            type: 'binary_progress',
+                            bytesReceived: totalBytes,
+                        });
+                    }
+                };
+                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';
+                    const combinedOutput = stdout + (stderr ? (stdout ? separator : '') + stderr : '');
+                    resolve({
+                        rawOutput: finalBuffer,
+                        output: combinedOutput.trim(),
+                        exitCode: code,
+                        signal: signal ? os.constants.signals[signal] : null,
+                        error,
+                        aborted: abortSignal.aborted,
+                        pid: child.pid,
+                        executionMethod: 'child_process',
+                    });
+                };
+                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) {
+                        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');
+                            }
+                        }
+                    }
+                };
+                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) {
+                            stdout += stripAnsi(remaining);
+                        }
+                    }
+                    if (stderrDecoder) {
+                        const remaining = stderrDecoder.decode();
+                        if (remaining) {
+                            stderr += stripAnsi(remaining);
+                        }
+                    }
+                    const finalBuffer = Buffer.concat(outputChunks);
+                    return { stdout, stderr, finalBuffer };
                 }
-                const decodedChunk = stream === 'stdout'
-                    ? stdoutDecoder.decode(data, { stream: true })
-                    : stderrDecoder.decode(data, { stream: true });
-                const strippedChunk = stripAnsi(decodedChunk);
-                if (stream === 'stdout') {
-                    stdout += strippedChunk;
-                }
-                else {
-                    stderr += strippedChunk;
-                }
-                if (isStreamingRawContent) {
-                    onOutputEvent({ type: 'data', stream, chunk: strippedChunk });
-                }
-                else {
-                    const totalBytes = outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
-                    onOutputEvent({ type: 'binary_progress', bytesReceived: totalBytes });
-                }
-            };
-            child.stdout.on('data', (data) => handleOutput(data, 'stdout'));
-            child.stderr.on('data', (data) => handleOutput(data, 'stderr'));
-            child.on('error', (err) => {
-                const { stdout, stderr, finalBuffer } = cleanup();
-                error = err;
-                resolve({
+            });
+            return { pid: child.pid, result };
+        }
+        catch (e) {
+            const error = e;
+            return {
+                pid: undefined,
+                result: Promise.resolve({
                     error,
-                    stdout,
-                    stderr,
-                    rawOutput: finalBuffer,
-                    output: stdout + (stderr ? `\n${stderr}` : ''),
+                    rawOutput: Buffer.from(''),
+                    output: '',
                     exitCode: 1,
                     signal: null,
                     aborted: false,
-                    pid: child.pid,
-                });
+                    pid: undefined,
+                    executionMethod: 'none',
+                }),
+            };
+        }
+    }
+    static executeWithPty(commandToExecute, cwd, onOutputEvent, abortSignal, terminalColumns, terminalRows, ptyInfo) {
+        try {
+            const cols = terminalColumns ?? 80;
+            const rows = terminalRows ?? 30;
+            const isWindows = os.platform() === 'win32';
+            const shell = isWindows ? 'cmd.exe' : 'bash';
+            const args = isWindows
+                ? ['/c', commandToExecute]
+                : ['-c', commandToExecute];
+            const ptyProcess = ptyInfo?.module.spawn(shell, args, {
+                cwd,
+                name: 'xterm-color',
+                cols,
+                rows,
+                env: {
+                    ...process.env,
+                    GEMINI_CLI: '1',
+                    TERM: 'xterm-256color',
+                    PAGER: 'cat',
+                },
+                handleFlowControl: true,
             });
-            const abortHandler = async () => {
-                if (child.pid && !exited) {
-                    if (isWindows) {
-                        spawn('taskkill', ['/pid', child.pid.toString(), '/f', '/t']);
-                    }
-                    else {
-                        try {
-                            // Kill the entire process group (negative PID).
-                            // SIGTERM first, then SIGKILL if it doesn't die.
-                            process.kill(-child.pid, 'SIGTERM');
-                            await new Promise((res) => setTimeout(res, SIGKILL_TIMEOUT_MS));
-                            if (!exited) {
-                                process.kill(-child.pid, 'SIGKILL');
+            const result = new Promise((resolve) => {
+                const headlessTerminal = new Terminal({
+                    allowProposedApi: true,
+                    cols,
+                    rows,
+                });
+                let processingChain = Promise.resolve();
+                let decoder = null;
+                let output = '';
+                const outputChunks = [];
+                const error = null;
+                let exited = false;
+                let isStreamingRawContent = true;
+                const MAX_SNIFF_SIZE = 4096;
+                let sniffedBytes = 0;
+                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');
                             }
                         }
-                        catch (_e) {
-                            // Fall back to killing just the main process if group kill fails.
-                            if (!exited)
-                                child.kill('SIGKILL');
+                        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;
+                                onOutputEvent({ type: 'binary_detected' });
+                            }
                         }
-                    }
-                }
-            };
-            abortSignal.addEventListener('abort', abortHandler, { once: true });
-            child.on('exit', (code, signal) => {
-                const { stdout, stderr, finalBuffer } = cleanup();
-                resolve({
-                    rawOutput: finalBuffer,
-                    output: stdout + (stderr ? `\n${stderr}` : ''),
-                    stdout,
-                    stderr,
-                    exitCode: code,
-                    signal,
-                    error,
-                    aborted: abortSignal.aborted,
-                    pid: child.pid,
+                        if (isStreamingRawContent) {
+                            const decodedChunk = decoder.decode(data, { stream: true });
+                            headlessTerminal.write(decodedChunk, () => {
+                                const newStrippedOutput = getFullText(headlessTerminal);
+                                output = newStrippedOutput;
+                                onOutputEvent({ type: 'data', chunk: newStrippedOutput });
+                                resolve();
+                            });
+                        }
+                        else {
+                            const totalBytes = outputChunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                            onOutputEvent({
+                                type: 'binary_progress',
+                                bytesReceived: totalBytes,
+                            });
+                            resolve();
+                        }
+                    }));
+                };
+                ptyProcess.onData((data) => {
+                    const bufferData = Buffer.from(data, 'utf-8');
+                    handleOutput(bufferData);
+                });
+                ptyProcess.onExit(({ exitCode, signal }) => {
+                    exited = true;
+                    abortSignal.removeEventListener('abort', abortHandler);
+                    processingChain.then(() => {
+                        const finalBuffer = Buffer.concat(outputChunks);
+                        resolve({
+                            rawOutput: finalBuffer,
+                            output,
+                            exitCode,
+                            signal: signal ?? null,
+                            error,
+                            aborted: abortSignal.aborted,
+                            pid: ptyProcess.pid,
+                            executionMethod: ptyInfo?.name ?? 'node-pty',
+                        });
+                    });
                 });
+                const abortHandler = async () => {
+                    if (ptyProcess.pid && !exited) {
+                        ptyProcess.kill('SIGHUP');
+                    }
+                };
+                abortSignal.addEventListener('abort', abortHandler, { once: true });
             });
-            /**
-             * Cleans up a process (and it's accompanying state) that is exiting or
-             * erroring and returns output formatted output buffers and strings
-             */
-            function cleanup() {
-                exited = true;
-                abortSignal.removeEventListener('abort', abortHandler);
-                if (stdoutDecoder) {
-                    stdout += stripAnsi(stdoutDecoder.decode());
-                }
-                if (stderrDecoder) {
-                    stderr += stripAnsi(stderrDecoder.decode());
-                }
-                const finalBuffer = Buffer.concat(outputChunks);
-                return { stdout, stderr, finalBuffer };
-            }
-        });
-        return { pid: child.pid, result };
+            return { pid: ptyProcess.pid, result };
+        }
+        catch (e) {
+            const error = e;
+            return {
+                pid: undefined,
+                result: Promise.resolve({
+                    error,
+                    rawOutput: Buffer.from(''),
+                    output: '',
+                    exitCode: 1,
+                    signal: null,
+                    aborted: false,
+                    pid: undefined,
+                    executionMethod: 'none',
+                }),
+            };
+        }
     }
 }
 //# sourceMappingURL=shellExecutionService.js.map