summaryrefslogtreecommitdiff
path: root/packages/core/src
diff options
context:
space:
mode:
Diffstat (limited to 'packages/core/src')
-rw-r--r--packages/core/src/config/config.ts7
-rw-r--r--packages/core/src/services/shellExecutionService.test.ts452
-rw-r--r--packages/core/src/services/shellExecutionService.ts495
-rw-r--r--packages/core/src/tools/shell.test.ts32
-rw-r--r--packages/core/src/tools/shell.ts28
-rw-r--r--packages/core/src/utils/getPty.ts34
6 files changed, 826 insertions, 222 deletions
diff --git a/packages/core/src/config/config.ts b/packages/core/src/config/config.ts
index 5ab39e83..8c95a99d 100644
--- a/packages/core/src/config/config.ts
+++ b/packages/core/src/config/config.ts
@@ -202,6 +202,7 @@ export interface ConfigParameters {
chatCompression?: ChatCompressionSettings;
interactive?: boolean;
trustedFolder?: boolean;
+ shouldUseNodePtyShell?: boolean;
}
export class Config {
@@ -267,6 +268,7 @@ export class Config {
private readonly chatCompression: ChatCompressionSettings | undefined;
private readonly interactive: boolean;
private readonly trustedFolder: boolean | undefined;
+ private readonly shouldUseNodePtyShell: boolean;
private initialized: boolean = false;
constructor(params: ConfigParameters) {
@@ -334,6 +336,7 @@ export class Config {
this.chatCompression = params.chatCompression;
this.interactive = params.interactive ?? false;
this.trustedFolder = params.trustedFolder;
+ this.shouldUseNodePtyShell = params.shouldUseNodePtyShell ?? false;
if (params.contextFileName) {
setGeminiMdFilename(params.contextFileName);
@@ -728,6 +731,10 @@ export class Config {
return this.interactive;
}
+ getShouldUseNodePtyShell(): boolean {
+ return this.shouldUseNodePtyShell;
+ }
+
async getGitService(): Promise<GitService> {
if (!this.gitService) {
this.gitService = new GitService(this.targetDir);
diff --git a/packages/core/src/services/shellExecutionService.test.ts b/packages/core/src/services/shellExecutionService.test.ts
index 47df12e8..604350aa 100644
--- a/packages/core/src/services/shellExecutionService.test.ts
+++ b/packages/core/src/services/shellExecutionService.test.ts
@@ -5,21 +5,6 @@
*/
import { vi, describe, it, expect, beforeEach, type Mock } from 'vitest';
-const mockSpawn = vi.hoisted(() => vi.fn());
-vi.mock('child_process', () => ({
- spawn: mockSpawn,
-}));
-
-const mockGetShellConfiguration = vi.hoisted(() => vi.fn());
-let mockIsWindows = false;
-
-vi.mock('../utils/shell-utils.js', () => ({
- getShellConfiguration: mockGetShellConfiguration,
- get isWindows() {
- return mockIsWindows;
- },
-}));
-
import EventEmitter from 'events';
import { Readable } from 'stream';
import { type ChildProcess } from 'child_process';
@@ -28,17 +13,43 @@ import {
ShellOutputEvent,
} from './shellExecutionService.js';
+// Hoisted Mocks
+const mockPtySpawn = vi.hoisted(() => vi.fn());
+const mockCpSpawn = vi.hoisted(() => vi.fn());
const mockIsBinary = vi.hoisted(() => vi.fn());
+const mockPlatform = vi.hoisted(() => vi.fn());
+const mockGetPty = vi.hoisted(() => vi.fn());
+
+// Top-level Mocks
+vi.mock('@lydell/node-pty', () => ({
+ spawn: mockPtySpawn,
+}));
+vi.mock('child_process', () => ({
+ spawn: mockCpSpawn,
+}));
vi.mock('../utils/textUtils.js', () => ({
isBinary: mockIsBinary,
}));
-
-const mockPlatform = vi.hoisted(() => vi.fn());
vi.mock('os', () => ({
default: {
platform: mockPlatform,
+ constants: {
+ signals: {
+ SIGTERM: 15,
+ SIGKILL: 9,
+ },
+ },
},
platform: mockPlatform,
+ constants: {
+ signals: {
+ SIGTERM: 15,
+ SIGKILL: 9,
+ },
+ },
+}));
+vi.mock('../utils/getPty.js', () => ({
+ getPty: mockGetPty,
}));
const mockProcessKill = vi
@@ -46,19 +57,271 @@ const mockProcessKill = vi
.mockImplementation(() => true);
describe('ShellExecutionService', () => {
- let mockChildProcess: EventEmitter & Partial<ChildProcess>;
+ let mockPtyProcess: EventEmitter & {
+ pid: number;
+ kill: Mock;
+ onData: Mock;
+ onExit: Mock;
+ };
let onOutputEventMock: Mock<(event: ShellOutputEvent) => void>;
beforeEach(() => {
vi.clearAllMocks();
mockIsBinary.mockReturnValue(false);
+ mockPlatform.mockReturnValue('linux');
+ mockGetPty.mockResolvedValue({
+ module: { spawn: mockPtySpawn },
+ name: 'mock-pty',
+ });
+
+ onOutputEventMock = vi.fn();
+
+ mockPtyProcess = new EventEmitter() as EventEmitter & {
+ pid: number;
+ kill: Mock;
+ onData: Mock;
+ onExit: Mock;
+ };
+ mockPtyProcess.pid = 12345;
+ mockPtyProcess.kill = vi.fn();
+ mockPtyProcess.onData = vi.fn();
+ mockPtyProcess.onExit = vi.fn();
+
+ mockPtySpawn.mockReturnValue(mockPtyProcess);
+ });
+
+ // Helper function to run a standard execution simulation
+ const simulateExecution = async (
+ command: string,
+ simulation: (
+ ptyProcess: typeof mockPtyProcess,
+ ac: AbortController,
+ ) => void,
+ ) => {
+ const abortController = new AbortController();
+ const handle = await ShellExecutionService.execute(
+ command,
+ '/test/dir',
+ onOutputEventMock,
+ abortController.signal,
+ true,
+ );
+
+ await new Promise((resolve) => setImmediate(resolve));
+ simulation(mockPtyProcess, abortController);
+ const result = await handle.result;
+ return { result, handle, abortController };
+ };
+
+ describe('Successful Execution', () => {
+ it('should execute a command and capture output', async () => {
+ const { result, handle } = await simulateExecution('ls -l', (pty) => {
+ pty.onData.mock.calls[0][0]('file1.txt\n');
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+ });
+
+ expect(mockPtySpawn).toHaveBeenCalledWith(
+ 'bash',
+ ['-c', 'ls -l'],
+ expect.any(Object),
+ );
+ expect(result.exitCode).toBe(0);
+ expect(result.signal).toBeNull();
+ expect(result.error).toBeNull();
+ expect(result.aborted).toBe(false);
+ expect(result.output).toBe('file1.txt');
+ expect(handle.pid).toBe(12345);
+
+ expect(onOutputEventMock).toHaveBeenCalledWith({
+ type: 'data',
+ chunk: 'file1.txt',
+ });
+ });
+
+ it('should strip ANSI codes from output', async () => {
+ const { result } = await simulateExecution('ls --color=auto', (pty) => {
+ pty.onData.mock.calls[0][0]('a\u001b[31mred\u001b[0mword');
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+ });
+
+ expect(result.output).toBe('aredword');
+ expect(onOutputEventMock).toHaveBeenCalledWith({
+ type: 'data',
+ chunk: 'aredword',
+ });
+ });
+
+ it('should correctly decode multi-byte characters split across chunks', async () => {
+ const { result } = await simulateExecution('echo "你好"', (pty) => {
+ const multiByteChar = '你好';
+ pty.onData.mock.calls[0][0](multiByteChar.slice(0, 1));
+ pty.onData.mock.calls[0][0](multiByteChar.slice(1));
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+ });
+ expect(result.output).toBe('你好');
+ });
+
+ it('should handle commands with no output', async () => {
+ const { result } = await simulateExecution('touch file', (pty) => {
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+ });
+
+ expect(result.output).toBe('');
+ expect(onOutputEventMock).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('Failed Execution', () => {
+ it('should capture a non-zero exit code', async () => {
+ const { result } = await simulateExecution('a-bad-command', (pty) => {
+ pty.onData.mock.calls[0][0]('command not found');
+ pty.onExit.mock.calls[0][0]({ exitCode: 127, signal: null });
+ });
+
+ expect(result.exitCode).toBe(127);
+ expect(result.output).toBe('command not found');
+ expect(result.error).toBeNull();
+ });
+
+ it('should capture a termination signal', async () => {
+ const { result } = await simulateExecution('long-process', (pty) => {
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: 15 });
+ });
+
+ expect(result.exitCode).toBe(0);
+ expect(result.signal).toBe(15);
+ });
+
+ it('should handle a synchronous spawn error', async () => {
+ mockGetPty.mockImplementation(() => null);
+
+ mockCpSpawn.mockImplementation(() => {
+ throw new Error('Simulated PTY spawn error');
+ });
+
+ const handle = await ShellExecutionService.execute(
+ 'any-command',
+ '/test/dir',
+ onOutputEventMock,
+ new AbortController().signal,
+ true,
+ );
+ const result = await handle.result;
+
+ expect(result.error).toBeInstanceOf(Error);
+ expect(result.error?.message).toContain('Simulated PTY spawn error');
+ expect(result.exitCode).toBe(1);
+ expect(result.output).toBe('');
+ expect(handle.pid).toBeUndefined();
+ });
+ });
+
+ describe('Aborting Commands', () => {
+ it('should abort a running process and set the aborted flag', async () => {
+ const { result } = await simulateExecution(
+ 'sleep 10',
+ (pty, abortController) => {
+ abortController.abort();
+ pty.onExit.mock.calls[0][0]({ exitCode: 1, signal: null });
+ },
+ );
+
+ expect(result.aborted).toBe(true);
+ expect(mockPtyProcess.kill).toHaveBeenCalled();
+ });
+ });
+
+ describe('Binary Output', () => {
+ it('should detect binary output and switch to progress events', async () => {
+ mockIsBinary.mockReturnValueOnce(true);
+ const binaryChunk1 = Buffer.from([0x89, 0x50, 0x4e, 0x47]);
+ const binaryChunk2 = Buffer.from([0x0d, 0x0a, 0x1a, 0x0a]);
+
+ const { result } = await simulateExecution('cat image.png', (pty) => {
+ pty.onData.mock.calls[0][0](binaryChunk1);
+ pty.onData.mock.calls[0][0](binaryChunk2);
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+ });
- mockGetShellConfiguration.mockReturnValue({
- executable: 'bash',
- argsPrefix: ['-c'],
+ expect(result.rawOutput).toEqual(
+ Buffer.concat([binaryChunk1, binaryChunk2]),
+ );
+ expect(onOutputEventMock).toHaveBeenCalledTimes(3);
+ expect(onOutputEventMock.mock.calls[0][0]).toEqual({
+ type: 'binary_detected',
+ });
+ expect(onOutputEventMock.mock.calls[1][0]).toEqual({
+ type: 'binary_progress',
+ bytesReceived: 4,
+ });
+ expect(onOutputEventMock.mock.calls[2][0]).toEqual({
+ type: 'binary_progress',
+ bytesReceived: 8,
+ });
});
- mockIsWindows = false;
+
+ it('should not emit data events after binary is detected', async () => {
+ mockIsBinary.mockImplementation((buffer) => buffer.includes(0x00));
+
+ await simulateExecution('cat mixed_file', (pty) => {
+ pty.onData.mock.calls[0][0](Buffer.from('some text'));
+ pty.onData.mock.calls[0][0](Buffer.from([0x00, 0x01, 0x02]));
+ pty.onData.mock.calls[0][0](Buffer.from('more text'));
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+ });
+
+ const eventTypes = onOutputEventMock.mock.calls.map(
+ (call: [ShellOutputEvent]) => call[0].type,
+ );
+ expect(eventTypes).toEqual([
+ 'data',
+ 'binary_detected',
+ 'binary_progress',
+ 'binary_progress',
+ ]);
+ });
+ });
+
+ describe('Platform-Specific Behavior', () => {
+ it('should use cmd.exe on Windows', async () => {
+ mockPlatform.mockReturnValue('win32');
+ await simulateExecution('dir "foo bar"', (pty) =>
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null }),
+ );
+
+ expect(mockPtySpawn).toHaveBeenCalledWith(
+ 'cmd.exe',
+ ['/c', 'dir "foo bar"'],
+ expect.any(Object),
+ );
+ });
+
+ it('should use bash on Linux', async () => {
+ mockPlatform.mockReturnValue('linux');
+ await simulateExecution('ls "foo bar"', (pty) =>
+ pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null }),
+ );
+
+ expect(mockPtySpawn).toHaveBeenCalledWith(
+ 'bash',
+ ['-c', 'ls "foo bar"'],
+ expect.any(Object),
+ );
+ });
+ });
+});
+
+describe('ShellExecutionService child_process fallback', () => {
+ let mockChildProcess: EventEmitter & Partial<ChildProcess>;
+ let onOutputEventMock: Mock<(event: ShellOutputEvent) => void>;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+
+ mockIsBinary.mockReturnValue(false);
+ mockPlatform.mockReturnValue('linux');
+ mockGetPty.mockResolvedValue(null);
onOutputEventMock = vi.fn();
@@ -73,7 +336,7 @@ describe('ShellExecutionService', () => {
configurable: true,
});
- mockSpawn.mockReturnValue(mockChildProcess);
+ mockCpSpawn.mockReturnValue(mockChildProcess);
});
// Helper function to run a standard execution simulation
@@ -82,11 +345,12 @@ describe('ShellExecutionService', () => {
simulation: (cp: typeof mockChildProcess, ac: AbortController) => void,
) => {
const abortController = new AbortController();
- const handle = ShellExecutionService.execute(
+ const handle = await ShellExecutionService.execute(
command,
'/test/dir',
onOutputEventMock,
abortController.signal,
+ true,
);
await new Promise((resolve) => setImmediate(resolve));
@@ -103,7 +367,7 @@ describe('ShellExecutionService', () => {
cp.emit('exit', 0, null);
});
- expect(mockSpawn).toHaveBeenCalledWith(
+ expect(mockCpSpawn).toHaveBeenCalledWith(
'ls -l',
[],
expect.objectContaining({ shell: 'bash' }),
@@ -112,19 +376,15 @@ describe('ShellExecutionService', () => {
expect(result.signal).toBeNull();
expect(result.error).toBeNull();
expect(result.aborted).toBe(false);
- expect(result.stdout).toBe('file1.txt\n');
- expect(result.stderr).toBe('a warning');
- expect(result.output).toBe('file1.txt\n\na warning');
+ expect(result.output).toBe('file1.txt\na warning');
expect(handle.pid).toBe(12345);
expect(onOutputEventMock).toHaveBeenCalledWith({
type: 'data',
- stream: 'stdout',
chunk: 'file1.txt\n',
});
expect(onOutputEventMock).toHaveBeenCalledWith({
type: 'data',
- stream: 'stderr',
chunk: 'a warning',
});
});
@@ -135,10 +395,9 @@ describe('ShellExecutionService', () => {
cp.emit('exit', 0, null);
});
- expect(result.stdout).toBe('aredword');
+ expect(result.output).toBe('aredword');
expect(onOutputEventMock).toHaveBeenCalledWith({
type: 'data',
- stream: 'stdout',
chunk: 'aredword',
});
});
@@ -150,7 +409,7 @@ describe('ShellExecutionService', () => {
cp.stdout?.emit('data', multiByteChar.slice(2));
cp.emit('exit', 0, null);
});
- expect(result.stdout).toBe('你好');
+ expect(result.output).toBe('你好');
});
it('should handle commands with no output', async () => {
@@ -158,8 +417,6 @@ describe('ShellExecutionService', () => {
cp.emit('exit', 0, null);
});
- expect(result.stdout).toBe('');
- expect(result.stderr).toBe('');
expect(result.output).toBe('');
expect(onOutputEventMock).not.toHaveBeenCalled();
});
@@ -173,9 +430,7 @@ describe('ShellExecutionService', () => {
});
expect(result.exitCode).toBe(127);
- expect(result.stderr).toBe('command not found');
- expect(result.stdout).toBe('');
- expect(result.output).toBe('\ncommand not found');
+ expect(result.output).toBe('command not found');
expect(result.error).toBeNull();
});
@@ -185,7 +440,7 @@ describe('ShellExecutionService', () => {
});
expect(result.exitCode).toBeNull();
- expect(result.signal).toBe('SIGTERM');
+ expect(result.signal).toBe(15);
});
it('should handle a spawn error', async () => {
@@ -247,7 +502,7 @@ describe('ShellExecutionService', () => {
expectedSignal,
);
} else {
- expect(mockSpawn).toHaveBeenCalledWith(expectedCommand, [
+ expect(mockCpSpawn).toHaveBeenCalledWith(expectedCommand, [
'/pid',
String(mockChildProcess.pid),
'/f',
@@ -265,11 +520,12 @@ describe('ShellExecutionService', () => {
// Don't await the result inside the simulation block for this specific test.
// We need to control the timeline manually.
const abortController = new AbortController();
- const handle = ShellExecutionService.execute(
+ const handle = await ShellExecutionService.execute(
'unresponsive_process',
'/test/dir',
onOutputEventMock,
abortController.signal,
+ true,
);
abortController.abort();
@@ -296,7 +552,7 @@ describe('ShellExecutionService', () => {
vi.useRealTimers();
expect(result.aborted).toBe(true);
- expect(result.signal).toBe('SIGKILL');
+ expect(result.signal).toBe(9);
// The individual kill calls were already asserted above.
expect(mockProcessKill).toHaveBeenCalledTimes(2);
});
@@ -341,7 +597,6 @@ describe('ShellExecutionService', () => {
cp.emit('exit', 0, null);
});
- // FIX: Provide explicit type for the 'call' parameter in the map function.
const eventTypes = onOutputEventMock.mock.calls.map(
(call: [ShellOutputEvent]) => call[0].type,
);
@@ -361,7 +616,7 @@ describe('ShellExecutionService', () => {
cp.emit('exit', 0, null),
);
- expect(mockSpawn).toHaveBeenCalledWith(
+ expect(mockCpSpawn).toHaveBeenCalledWith(
'dir "foo bar"',
[],
expect.objectContaining({
@@ -375,7 +630,7 @@ describe('ShellExecutionService', () => {
mockPlatform.mockReturnValue('linux');
await simulateExecution('ls "foo bar"', (cp) => cp.emit('exit', 0, null));
- expect(mockSpawn).toHaveBeenCalledWith(
+ expect(mockCpSpawn).toHaveBeenCalledWith(
'ls "foo bar"',
[],
expect.objectContaining({
@@ -386,3 +641,110 @@ describe('ShellExecutionService', () => {
});
});
});
+
+describe('ShellExecutionService execution method selection', () => {
+ let onOutputEventMock: Mock<(event: ShellOutputEvent) => void>;
+ let mockPtyProcess: EventEmitter & {
+ pid: number;
+ kill: Mock;
+ onData: Mock;
+ onExit: Mock;
+ };
+ let mockChildProcess: EventEmitter & Partial<ChildProcess>;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ onOutputEventMock = vi.fn();
+
+ // Mock for pty
+ mockPtyProcess = new EventEmitter() as EventEmitter & {
+ pid: number;
+ kill: Mock;
+ onData: Mock;
+ onExit: Mock;
+ };
+ mockPtyProcess.pid = 12345;
+ mockPtyProcess.kill = vi.fn();
+ mockPtyProcess.onData = vi.fn();
+ mockPtyProcess.onExit = vi.fn();
+ mockPtySpawn.mockReturnValue(mockPtyProcess);
+ mockGetPty.mockResolvedValue({
+ module: { spawn: mockPtySpawn },
+ name: 'mock-pty',
+ });
+
+ // Mock for child_process
+ mockChildProcess = new EventEmitter() as EventEmitter &
+ Partial<ChildProcess>;
+ mockChildProcess.stdout = new EventEmitter() as Readable;
+ mockChildProcess.stderr = new EventEmitter() as Readable;
+ mockChildProcess.kill = vi.fn();
+ Object.defineProperty(mockChildProcess, 'pid', {
+ value: 54321,
+ configurable: true,
+ });
+ mockCpSpawn.mockReturnValue(mockChildProcess);
+ });
+
+ it('should use node-pty when shouldUseNodePty is true and pty is available', async () => {
+ const abortController = new AbortController();
+ const handle = await ShellExecutionService.execute(
+ 'test command',
+ '/test/dir',
+ onOutputEventMock,
+ abortController.signal,
+ true, // shouldUseNodePty
+ );
+
+ // Simulate exit to allow promise to resolve
+ mockPtyProcess.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+ const result = await handle.result;
+
+ expect(mockGetPty).toHaveBeenCalled();
+ expect(mockPtySpawn).toHaveBeenCalled();
+ expect(mockCpSpawn).not.toHaveBeenCalled();
+ expect(result.executionMethod).toBe('mock-pty');
+ });
+
+ it('should use child_process when shouldUseNodePty is false', async () => {
+ const abortController = new AbortController();
+ const handle = await ShellExecutionService.execute(
+ 'test command',
+ '/test/dir',
+ onOutputEventMock,
+ abortController.signal,
+ false, // shouldUseNodePty
+ );
+
+ // Simulate exit to allow promise to resolve
+ mockChildProcess.emit('exit', 0, null);
+ const result = await handle.result;
+
+ expect(mockGetPty).not.toHaveBeenCalled();
+ expect(mockPtySpawn).not.toHaveBeenCalled();
+ expect(mockCpSpawn).toHaveBeenCalled();
+ expect(result.executionMethod).toBe('child_process');
+ });
+
+ it('should fall back to child_process if pty is not available even if shouldUseNodePty is true', async () => {
+ mockGetPty.mockResolvedValue(null);
+
+ const abortController = new AbortController();
+ const handle = await ShellExecutionService.execute(
+ 'test command',
+ '/test/dir',
+ onOutputEventMock,
+ abortController.signal,
+ true, // shouldUseNodePty
+ );
+
+ // Simulate exit to allow promise to resolve
+ mockChildProcess.emit('exit', 0, null);
+ const result = await handle.result;
+
+ expect(mockGetPty).toHaveBeenCalled();
+ expect(mockPtySpawn).not.toHaveBeenCalled();
+ expect(mockCpSpawn).toHaveBeenCalled();
+ expect(result.executionMethod).toBe('child_process');
+ });
+});
diff --git a/packages/core/src/services/shellExecutionService.ts b/packages/core/src/services/shellExecutionService.ts
index 3749fcf6..59e998bd 100644
--- a/packages/core/src/services/shellExecutionService.ts
+++ b/packages/core/src/services/shellExecutionService.ts
@@ -4,35 +4,47 @@
* SPDX-License-Identifier: Apache-2.0
*/
-import { spawn } from 'child_process';
+import { getPty, PtyImplementation } 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: Terminal) => {
+ const buffer = terminal.buffer.active;
+ const lines: string[] = [];
+ 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 structured result from a shell command execution. */
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. */
@@ -50,8 +62,6 @@ 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;
}
@@ -73,7 +83,7 @@ export type ShellOutputEvent =
*/
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.
@@ -82,172 +92,369 @@ export class ShellExecutionService {
* @returns An object containing the process ID (pid) and a promise that
* resolves with the complete execution result.
*/
- static execute(
+ static async execute(
commandToExecute: string,
cwd: string,
onOutputEvent: (event: ShellOutputEvent) => void,
abortSignal: AbortSignal,
- ): ShellExecutionHandle {
- const isWindows = os.platform() === 'win32';
+ shouldUseNodePty: boolean,
+ terminalColumns?: number,
+ terminalRows?: number,
+ ): Promise<ShellExecutionHandle> {
+ 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
+ }
+ }
+ }
- const child = spawn(commandToExecute, [], {
+ return this.childProcessFallback(
+ 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',
- },
- });
+ onOutputEvent,
+ abortSignal,
+ );
+ }
+
+ private static childProcessFallback(
+ commandToExecute: string,
+ cwd: string,
+ onOutputEvent: (event: ShellOutputEvent) => void,
+ abortSignal: AbortSignal,
+ ): ShellExecutionHandle {
+ try {
+ const isWindows = os.platform() === 'win32';
- const result = new Promise<ShellExecutionResult>((resolve) => {
- // Use decoders to handle multi-byte characters safely (for streaming output).
- let stdoutDecoder: TextDecoder | null = null;
- let stderrDecoder: TextDecoder | null = null;
+ 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',
+ },
+ });
- let stdout = '';
- let stderr = '';
- const outputChunks: Buffer[] = [];
- let error: Error | null = null;
- let exited = false;
+ const result = new Promise<ShellExecutionResult>((resolve) => {
+ let stdoutDecoder: TextDecoder | null = null;
+ let stderrDecoder: TextDecoder | null = null;
- let isStreamingRawContent = true;
- const MAX_SNIFF_SIZE = 4096;
- let sniffedBytes = 0;
+ let stdout = '';
+ let stderr = '';
+ const outputChunks: Buffer[] = [];
+ let error: Error | null = null;
+ let exited = false;
- const handleOutput = (data: Buffer, stream: 'stdout' | 'stderr') => {
- if (!stdoutDecoder || !stderrDecoder) {
- const encoding = getCachedEncodingForBuffer(data);
- try {
- stdoutDecoder = new TextDecoder(encoding);
- stderrDecoder = new TextDecoder(encoding);
- } 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');
+ let isStreamingRawContent = true;
+ const MAX_SNIFF_SIZE = 4096;
+ let sniffedBytes = 0;
+
+ const handleOutput = (data: Buffer, stream: 'stdout' | 'stderr') => {
+ 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');
+ }
}
- }
- outputChunks.push(data);
+ outputChunks.push(data);
+
+ if (isStreamingRawContent && sniffedBytes < MAX_SNIFF_SIZE) {
+ const sniffBuffer = Buffer.concat(outputChunks.slice(0, 20));
+ sniffedBytes = sniffBuffer.length;
- // 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)) {
+ isStreamingRawContent = false;
+ onOutputEvent({ type: 'binary_detected' });
+ }
+ }
+
+ const decoder = stream === 'stdout' ? stdoutDecoder : stderrDecoder;
+ const decodedChunk = decoder.decode(data, { stream: true });
+ const strippedChunk = stripAnsi(decodedChunk);
- if (isBinary(sniffBuffer)) {
- // Change state to stop streaming raw content.
- isStreamingRawContent = false;
- onOutputEvent({ type: 'binary_detected' });
+ if (stream === 'stdout') {
+ stdout += strippedChunk;
+ } else {
+ stderr += strippedChunk;
}
- }
- const decodedChunk =
- stream === 'stdout'
- ? stdoutDecoder.decode(data, { stream: true })
- : stderrDecoder.decode(data, { stream: true });
- const strippedChunk = stripAnsi(decodedChunk);
+ if (isStreamingRawContent) {
+ onOutputEvent({ type: 'data', chunk: strippedChunk });
+ } else {
+ const totalBytes = outputChunks.reduce(
+ (sum, chunk) => sum + chunk.length,
+ 0,
+ );
+ onOutputEvent({
+ type: 'binary_progress',
+ bytesReceived: totalBytes,
+ });
+ }
+ };
- if (stream === 'stdout') {
- stdout += strippedChunk;
- } else {
- stderr += strippedChunk;
- }
+ const handleExit = (
+ code: number | null,
+ signal: NodeJS.Signals | null,
+ ) => {
+ 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 : '');
- 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 });
- }
- };
+ 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) => {
- const { stdout, stderr, finalBuffer } = cleanup();
- error = err;
- resolve({
- error,
- stdout,
- stderr,
- rawOutput: finalBuffer,
- output: stdout + (stderr ? `\n${stderr}` : ''),
- exitCode: 1,
- signal: null,
- aborted: false,
- pid: child.pid,
+ 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) {
- 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 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');
}
- } catch (_e) {
- // Fall back to killing just the main process if group kill fails.
- 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 };
}
+ });
+
+ return { pid: child.pid, result };
+ } catch (e) {
+ const error = e as Error;
+ return {
+ pid: undefined,
+ result: Promise.resolve({
+ error,
+ rawOutput: Buffer.from(''),
+ output: '',
+ exitCode: 1,
+ signal: null,
+ aborted: false,
+ pid: undefined,
+ executionMethod: 'none',
+ }),
};
+ }
+ }
- abortSignal.addEventListener('abort', abortHandler, { once: true });
+ private static executeWithPty(
+ commandToExecute: string,
+ cwd: string,
+ onOutputEvent: (event: ShellOutputEvent) => void,
+ abortSignal: AbortSignal,
+ terminalColumns: number | undefined,
+ terminalRows: number | undefined,
+ ptyInfo: PtyImplementation | undefined,
+ ): ShellExecutionHandle {
+ 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];
- child.on('exit', (code: number, signal: NodeJS.Signals) => {
- const { stdout, stderr, finalBuffer } = cleanup();
+ 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,
+ });
- resolve({
- rawOutput: finalBuffer,
- output: stdout + (stderr ? `\n${stderr}` : ''),
- stdout,
- stderr,
- exitCode: code,
- signal,
- error,
- aborted: abortSignal.aborted,
- pid: child.pid,
+ const result = new Promise<ShellExecutionResult>((resolve) => {
+ const headlessTerminal = new Terminal({
+ allowProposedApi: true,
+ cols,
+ rows,
});
- });
+ let processingChain = Promise.resolve();
+ let decoder: TextDecoder | null = null;
+ let output = '';
+ const outputChunks: Buffer[] = [];
+ const error: Error | null = null;
+ let exited = false;
- /**
- * 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());
- }
+ let isStreamingRawContent = true;
+ const MAX_SNIFF_SIZE = 4096;
+ let sniffedBytes = 0;
- const finalBuffer = Buffer.concat(outputChunks);
+ const handleOutput = (data: Buffer) => {
+ processingChain = processingChain.then(
+ () =>
+ new Promise<void>((resolve) => {
+ if (!decoder) {
+ const encoding = getCachedEncodingForBuffer(data);
+ try {
+ decoder = new TextDecoder(encoding);
+ } catch {
+ decoder = new TextDecoder('utf-8');
+ }
+ }
- return { stdout, stderr, finalBuffer };
- }
- });
+ 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' });
+ }
+ }
+
+ 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: string) => {
+ const bufferData = Buffer.from(data, 'utf-8');
+ handleOutput(bufferData);
+ });
+
+ ptyProcess.onExit(
+ ({ exitCode, signal }: { exitCode: number; signal?: number }) => {
+ exited = true;
+ abortSignal.removeEventListener('abort', abortHandler);
+
+ processingChain.then(() => {
+ const finalBuffer = Buffer.concat(outputChunks);
- return { pid: child.pid, result };
+ 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 });
+ });
+
+ return { pid: ptyProcess.pid, result };
+ } catch (e) {
+ const error = e as Error;
+ return {
+ pid: undefined,
+ result: Promise.resolve({
+ error,
+ rawOutput: Buffer.from(''),
+ output: '',
+ exitCode: 1,
+ signal: null,
+ aborted: false,
+ pid: undefined,
+ executionMethod: 'none',
+ }),
+ };
+ }
}
}
diff --git a/packages/core/src/tools/shell.test.ts b/packages/core/src/tools/shell.test.ts
index c0b409fa..79354cf8 100644
--- a/packages/core/src/tools/shell.test.ts
+++ b/packages/core/src/tools/shell.test.ts
@@ -56,6 +56,7 @@ describe('ShellTool', () => {
getSummarizeToolOutputConfig: vi.fn().mockReturnValue(undefined),
getWorkspaceContext: () => createMockWorkspaceContext('.'),
getGeminiClient: vi.fn(),
+ getShouldUseNodePtyShell: vi.fn().mockReturnValue(false),
} as unknown as Config;
shellTool = new ShellTool(mockConfig);
@@ -123,13 +124,12 @@ describe('ShellTool', () => {
const fullResult: ShellExecutionResult = {
rawOutput: Buffer.from(result.output || ''),
output: 'Success',
- stdout: 'Success',
- stderr: '',
exitCode: 0,
signal: null,
error: null,
aborted: false,
pid: 12345,
+ executionMethod: 'child_process',
...result,
};
resolveExecutionPromise(fullResult);
@@ -152,6 +152,9 @@ describe('ShellTool', () => {
expect.any(String),
expect.any(Function),
mockAbortSignal,
+ false,
+ undefined,
+ undefined,
);
expect(result.llmContent).toContain('Background PIDs: 54322');
expect(vi.mocked(fs.unlinkSync)).toHaveBeenCalledWith(tmpFile);
@@ -164,13 +167,12 @@ describe('ShellTool', () => {
resolveShellExecution({
rawOutput: Buffer.from(''),
output: '',
- stdout: '',
- stderr: '',
exitCode: 0,
signal: null,
error: null,
aborted: false,
pid: 12345,
+ executionMethod: 'child_process',
});
await promise;
expect(mockShellExecutionService).toHaveBeenCalledWith(
@@ -178,6 +180,9 @@ describe('ShellTool', () => {
expect.any(String),
expect.any(Function),
mockAbortSignal,
+ false,
+ undefined,
+ undefined,
);
});
@@ -189,16 +194,14 @@ describe('ShellTool', () => {
error,
exitCode: 1,
output: 'err',
- stderr: 'err',
rawOutput: Buffer.from('err'),
- stdout: '',
signal: null,
aborted: false,
pid: 12345,
+ executionMethod: 'child_process',
});
const result = await promise;
- // The final llmContent should contain the user's command, not the wrapper
expect(result.llmContent).toContain('Error: wrapped command failed');
expect(result.llmContent).not.toContain('pgrep');
});
@@ -231,13 +234,12 @@ describe('ShellTool', () => {
resolveExecutionPromise({
output: 'long output',
rawOutput: Buffer.from('long output'),
- stdout: 'long output',
- stderr: '',
exitCode: 0,
signal: null,
error: null,
aborted: false,
pid: 12345,
+ executionMethod: 'child_process',
});
const result = await promise;
@@ -283,7 +285,6 @@ describe('ShellTool', () => {
// First chunk, should be throttled.
mockShellOutputCallback({
type: 'data',
- stream: 'stdout',
chunk: 'hello ',
});
expect(updateOutputMock).not.toHaveBeenCalled();
@@ -294,24 +295,22 @@ describe('ShellTool', () => {
// Send a second chunk. THIS event triggers the update with the CUMULATIVE content.
mockShellOutputCallback({
type: 'data',
- stream: 'stderr',
- chunk: 'world',
+ chunk: 'hello world',
});
// It should have been called once now with the combined output.
expect(updateOutputMock).toHaveBeenCalledOnce();
- expect(updateOutputMock).toHaveBeenCalledWith('hello \nworld');
+ expect(updateOutputMock).toHaveBeenCalledWith('hello world');
resolveExecutionPromise({
rawOutput: Buffer.from(''),
output: '',
- stdout: '',
- stderr: '',
exitCode: 0,
signal: null,
error: null,
aborted: false,
pid: 12345,
+ executionMethod: 'child_process',
});
await promise;
});
@@ -350,13 +349,12 @@ describe('ShellTool', () => {
resolveExecutionPromise({
rawOutput: Buffer.from(''),
output: '',
- stdout: '',
- stderr: '',
exitCode: 0,
signal: null,
error: null,
aborted: false,
pid: 12345,
+ executionMethod: 'child_process',
});
await promise;
});
diff --git a/packages/core/src/tools/shell.ts b/packages/core/src/tools/shell.ts
index 8d5c624c..3fce7c2d 100644
--- a/packages/core/src/tools/shell.ts
+++ b/packages/core/src/tools/shell.ts
@@ -96,6 +96,8 @@ class ShellToolInvocation extends BaseToolInvocation<
async execute(
signal: AbortSignal,
updateOutput?: (output: string) => void,
+ terminalColumns?: number,
+ terminalRows?: number,
): Promise<ToolResult> {
const strippedCommand = stripShellWrapper(this.params.command);
@@ -128,13 +130,11 @@ class ShellToolInvocation extends BaseToolInvocation<
this.params.directory || '',
);
- let cumulativeStdout = '';
- let cumulativeStderr = '';
-
+ let cumulativeOutput = '';
let lastUpdateTime = Date.now();
let isBinaryStream = false;
- const { result: resultPromise } = ShellExecutionService.execute(
+ const { result: resultPromise } = await ShellExecutionService.execute(
commandToExecute,
cwd,
(event: ShellOutputEvent) => {
@@ -147,15 +147,9 @@ class ShellToolInvocation extends BaseToolInvocation<
switch (event.type) {
case 'data':
- if (isBinaryStream) break; // Don't process text if we are in binary mode
- if (event.stream === 'stdout') {
- cumulativeStdout += event.chunk;
- } else {
- cumulativeStderr += event.chunk;
- }
- currentDisplayOutput =
- cumulativeStdout +
- (cumulativeStderr ? `\n${cumulativeStderr}` : '');
+ if (isBinaryStream) break;
+ cumulativeOutput = event.chunk;
+ currentDisplayOutput = cumulativeOutput;
if (Date.now() - lastUpdateTime > OUTPUT_UPDATE_INTERVAL_MS) {
shouldUpdate = true;
}
@@ -186,6 +180,9 @@ class ShellToolInvocation extends BaseToolInvocation<
}
},
signal,
+ this.config.getShouldUseNodePtyShell(),
+ terminalColumns,
+ terminalRows,
);
const result = await resultPromise;
@@ -217,7 +214,7 @@ class ShellToolInvocation extends BaseToolInvocation<
if (result.aborted) {
llmContent = 'Command was cancelled by user before it could complete.';
if (result.output.trim()) {
- llmContent += ` Below is the output (on stdout and stderr) before it was cancelled:\n${result.output}`;
+ llmContent += ` Below is the output before it was cancelled:\n${result.output}`;
} else {
llmContent += ' There was no output before it was cancelled.';
}
@@ -231,8 +228,7 @@ class ShellToolInvocation extends BaseToolInvocation<
llmContent = [
`Command: ${this.params.command}`,
`Directory: ${this.params.directory || '(root)'}`,
- `Stdout: ${result.stdout || '(empty)'}`,
- `Stderr: ${result.stderr || '(empty)'}`,
+ `Output: ${result.output || '(empty)'}`,
`Error: ${finalError}`, // Use the cleaned error string.
`Exit Code: ${result.exitCode ?? '(none)'}`,
`Signal: ${result.signal ?? '(none)'}`,
diff --git a/packages/core/src/utils/getPty.ts b/packages/core/src/utils/getPty.ts
new file mode 100644
index 00000000..2d7cb16f
--- /dev/null
+++ b/packages/core/src/utils/getPty.ts
@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+export type PtyImplementation = {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ module: any;
+ name: 'lydell-node-pty' | 'node-pty';
+} | null;
+
+export interface PtyProcess {
+ readonly pid: number;
+ onData(callback: (data: string) => void): void;
+ onExit(callback: (e: { exitCode: number; signal?: number }) => void): void;
+ kill(signal?: string): void;
+}
+
+export const getPty = async (): Promise<PtyImplementation> => {
+ try {
+ const lydell = '@lydell/node-pty';
+ const module = await import(lydell);
+ return { module, name: 'lydell-node-pty' };
+ } catch (_e) {
+ try {
+ const nodePty = 'node-pty';
+ const module = await import(nodePty);
+ return { module, name: 'node-pty' };
+ } catch (_e2) {
+ return null;
+ }
+ }
+};
generated by cgit v1.2.3 (git 2.51.0) at 2025-11-05 05:16:58 +0000