Sync upstream Gemini-CLI v0.8.2 (#838)

packages/core/src/services/shellExecutionService.test.ts

@@ -4,14 +4,13 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { type ChildProcess } from 'child_process';
-import EventEmitter from 'events';
-import type { Readable } from 'stream';
-import { beforeEach, describe, expect, it, vi, type Mock } from 'vitest';
-import {
-  ShellExecutionService,
-  type ShellOutputEvent,
-} from './shellExecutionService.js';
+import { vi, describe, it, expect, beforeEach, type Mock } from 'vitest';
+import EventEmitter from 'node:events';
+import type { Readable } from 'node:stream';
+import { type ChildProcess } from 'node:child_process';
+import type { ShellOutputEvent } from './shellExecutionService.js';
+import { ShellExecutionService } from './shellExecutionService.js';
+import type { AnsiOutput } from '../utils/terminalSerializer.js';
 
 // Hoisted Mocks
 const mockPtySpawn = vi.hoisted(() => vi.fn());
@@ -19,6 +18,7 @@ const mockCpSpawn = vi.hoisted(() => vi.fn());
 const mockIsBinary = vi.hoisted(() => vi.fn());
 const mockPlatform = vi.hoisted(() => vi.fn());
 const mockGetPty = vi.hoisted(() => vi.fn());
+const mockSerializeTerminalToObject = vi.hoisted(() => vi.fn());
 
 // Top-level Mocks
 vi.mock('@lydell/node-pty', () => ({
@@ -51,17 +51,59 @@ vi.mock('os', () => ({
 vi.mock('../utils/getPty.js', () => ({
   getPty: mockGetPty,
 }));
+vi.mock('../utils/terminalSerializer.js', () => ({
+  serializeTerminalToObject: mockSerializeTerminalToObject,
+}));
 
 const mockProcessKill = vi
   .spyOn(process, 'kill')
   .mockImplementation(() => true);
 
+const shellExecutionConfig = {
+  terminalWidth: 80,
+  terminalHeight: 24,
+  pager: 'cat',
+  showColor: false,
+  disableDynamicLineTrimming: true,
+};
+
+const createExpectedAnsiOutput = (text: string | string[]): AnsiOutput => {
+  const lines = Array.isArray(text) ? text : text.split('\n');
+  const expected: AnsiOutput = Array.from(
+    { length: shellExecutionConfig.terminalHeight },
+    (_, i) => [
+      {
+        text: expect.stringMatching((lines[i] || '').trim()),
+        bold: false,
+        italic: false,
+        underline: false,
+        dim: false,
+        inverse: false,
+        fg: '',
+        bg: '',
+      },
+    ],
+  );
+  return expected;
+};
+
 describe('ShellExecutionService', () => {
   let mockPtyProcess: EventEmitter & {
     pid: number;
     kill: Mock;
     onData: Mock;
     onExit: Mock;
+    write: Mock;
+    resize: Mock;
+  };
+  let mockHeadlessTerminal: {
+    resize: Mock;
+    scrollLines: Mock;
+    buffer: {
+      active: {
+        viewportY: number;
+      };
+    };
   };
   let onOutputEventMock: Mock<(event: ShellOutputEvent) => void>;
 
@@ -82,11 +124,25 @@ describe('ShellExecutionService', () => {
       kill: Mock;
       onData: Mock;
       onExit: Mock;
+      write: Mock;
+      resize: Mock;
     };
     mockPtyProcess.pid = 12345;
     mockPtyProcess.kill = vi.fn();
     mockPtyProcess.onData = vi.fn();
     mockPtyProcess.onExit = vi.fn();
+    mockPtyProcess.write = vi.fn();
+    mockPtyProcess.resize = vi.fn();
+
+    mockHeadlessTerminal = {
+      resize: vi.fn(),
+      scrollLines: vi.fn(),
+      buffer: {
+        active: {
+          viewportY: 0,
+        },
+      },
+    };
 
     mockPtySpawn.mockReturnValue(mockPtyProcess);
   });
@@ -98,6 +154,7 @@ describe('ShellExecutionService', () => {
       ptyProcess: typeof mockPtyProcess,
       ac: AbortController,
     ) => void,
+    config = shellExecutionConfig,
   ) => {
     const abortController = new AbortController();
     const handle = await ShellExecutionService.execute(
@@ -106,9 +163,10 @@ describe('ShellExecutionService', () => {
       onOutputEventMock,
       abortController.signal,
       true,
+      config,
     );
 
-    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => process.nextTick(resolve));
     simulation(mockPtyProcess, abortController);
     const result = await handle.result;
     return { result, handle, abortController };
@@ -130,12 +188,12 @@ describe('ShellExecutionService', () => {
       expect(result.signal).toBeNull();
       expect(result.error).toBeNull();
       expect(result.aborted).toBe(false);
-      expect(result.output).toBe('file1.txt');
+      expect(result.output.trim()).toBe('file1.txt');
       expect(handle.pid).toBe(12345);
 
       expect(onOutputEventMock).toHaveBeenCalledWith({
         type: 'data',
-        chunk: 'file1.txt',
+        chunk: createExpectedAnsiOutput('file1.txt'),
       });
     });
 
@@ -145,11 +203,13 @@ describe('ShellExecutionService', () => {
         pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
       });
 
-      expect(result.output).toBe('aredword');
-      expect(onOutputEventMock).toHaveBeenCalledWith({
-        type: 'data',
-        chunk: 'aredword',
-      });
+      expect(result.output.trim()).toBe('aredword');
+      expect(onOutputEventMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'data',
+          chunk: createExpectedAnsiOutput('aredword'),
+        }),
+      );
     });
 
     it('should correctly decode multi-byte characters split across chunks', async () => {
@@ -159,16 +219,81 @@ describe('ShellExecutionService', () => {
         pty.onData.mock.calls[0][0](multiByteChar.slice(1));
         pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
       });
-      expect(result.output).toBe('你好');
+      expect(result.output.trim()).toBe('你好');
     });
 
     it('should handle commands with no output', async () => {
-      const { result } = await simulateExecution('touch file', (pty) => {
+      await simulateExecution('touch file', (pty) => {
         pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
       });
 
-      expect(result.output).toBe('');
-      expect(onOutputEventMock).not.toHaveBeenCalled();
+      expect(onOutputEventMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          chunk: createExpectedAnsiOutput(''),
+        }),
+      );
+    });
+
+    it('should call onPid with the process id', async () => {
+      const abortController = new AbortController();
+      const handle = await ShellExecutionService.execute(
+        'ls -l',
+        '/test/dir',
+        onOutputEventMock,
+        abortController.signal,
+        true,
+        shellExecutionConfig,
+      );
+      mockPtyProcess.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      await handle.result;
+      expect(handle.pid).toBe(12345);
+    });
+  });
+
+  describe('pty interaction', () => {
+    beforeEach(() => {
+      vi.spyOn(ShellExecutionService['activePtys'], 'get').mockReturnValue({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ptyProcess: mockPtyProcess as any,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        headlessTerminal: mockHeadlessTerminal as any,
+      });
+    });
+
+    it('should write to the pty and trigger a render', async () => {
+      vi.useFakeTimers();
+      await simulateExecution('interactive-app', (pty) => {
+        ShellExecutionService.writeToPty(pty.pid!, 'input');
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+
+      expect(mockPtyProcess.write).toHaveBeenCalledWith('input');
+      // Use fake timers to check for the delayed render
+      await vi.advanceTimersByTimeAsync(17);
+      // The render will cause an output event
+      expect(onOutputEventMock).toHaveBeenCalled();
+      vi.useRealTimers();
+    });
+
+    it('should resize the pty and the headless terminal', async () => {
+      await simulateExecution('ls -l', (pty) => {
+        pty.onData.mock.calls[0][0]('file1.txt\n');
+        ShellExecutionService.resizePty(pty.pid!, 100, 40);
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+
+      expect(mockPtyProcess.resize).toHaveBeenCalledWith(100, 40);
+      expect(mockHeadlessTerminal.resize).toHaveBeenCalledWith(100, 40);
+    });
+
+    it('should scroll the headless terminal', async () => {
+      await simulateExecution('ls -l', (pty) => {
+        pty.onData.mock.calls[0][0]('file1.txt\n');
+        ShellExecutionService.scrollPty(pty.pid!, 10);
+        pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+      });
+
+      expect(mockHeadlessTerminal.scrollLines).toHaveBeenCalledWith(10);
     });
   });
 
@@ -180,7 +305,7 @@ describe('ShellExecutionService', () => {
       });
 
       expect(result.exitCode).toBe(127);
-      expect(result.output).toBe('command not found');
+      expect(result.output.trim()).toBe('command not found');
       expect(result.error).toBeNull();
     });
 
@@ -206,6 +331,7 @@ describe('ShellExecutionService', () => {
         onOutputEventMock,
         new AbortController().signal,
         true,
+        {},
       );
       const result = await handle.result;
 
@@ -228,7 +354,7 @@ describe('ShellExecutionService', () => {
       );
 
       expect(result.aborted).toBe(true);
-      expect(mockPtyProcess.kill).toHaveBeenCalled();
+      // The process kill is mocked, so we just check that the flag is set.
     });
   });
 
@@ -265,7 +391,6 @@ describe('ShellExecutionService', () => {
       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 });
@@ -275,7 +400,6 @@ describe('ShellExecutionService', () => {
         (call: [ShellOutputEvent]) => call[0].type,
       );
       expect(eventTypes).toEqual([
-        'data',
         'binary_detected',
         'binary_progress',
         'binary_progress',
@@ -310,6 +434,92 @@ describe('ShellExecutionService', () => {
       );
     });
   });
+
+  describe('AnsiOutput rendering', () => {
+    it('should call onOutputEvent with AnsiOutput when showColor is true', async () => {
+      const coloredShellExecutionConfig = {
+        ...shellExecutionConfig,
+        showColor: true,
+        defaultFg: '#ffffff',
+        defaultBg: '#000000',
+        disableDynamicLineTrimming: true,
+      };
+      const mockAnsiOutput = [
+        [{ text: 'hello', fg: '#ffffff', bg: '#000000' }],
+      ];
+      mockSerializeTerminalToObject.mockReturnValue(mockAnsiOutput);
+
+      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 });
+        },
+        coloredShellExecutionConfig,
+      );
+
+      expect(mockSerializeTerminalToObject).toHaveBeenCalledWith(
+        expect.anything(), // The terminal object
+      );
+
+      expect(onOutputEventMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'data',
+          chunk: mockAnsiOutput,
+        }),
+      );
+    });
+
+    it('should call onOutputEvent with AnsiOutput when showColor is false', async () => {
+      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 });
+        },
+        {
+          ...shellExecutionConfig,
+          showColor: false,
+          disableDynamicLineTrimming: true,
+        },
+      );
+
+      const expected = createExpectedAnsiOutput('aredword');
+
+      expect(onOutputEventMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'data',
+          chunk: expected,
+        }),
+      );
+    });
+
+    it('should handle multi-line output correctly when showColor is false', async () => {
+      await simulateExecution(
+        'ls --color=auto',
+        (pty) => {
+          pty.onData.mock.calls[0][0](
+            'line 1\n\u001b[32mline 2\u001b[0m\nline 3',
+          );
+          pty.onExit.mock.calls[0][0]({ exitCode: 0, signal: null });
+        },
+        {
+          ...shellExecutionConfig,
+          showColor: false,
+          disableDynamicLineTrimming: true,
+        },
+      );
+
+      const expected = createExpectedAnsiOutput(['line 1', 'line 2', 'line 3']);
+
+      expect(onOutputEventMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'data',
+          chunk: expected,
+        }),
+      );
+    });
+  });
 });
 
 describe('ShellExecutionService child_process fallback', () => {
@@ -351,9 +561,10 @@ describe('ShellExecutionService child_process fallback', () => {
       onOutputEventMock,
       abortController.signal,
       true,
+      shellExecutionConfig,
     );
 
-    await new Promise((resolve) => setImmediate(resolve));
+    await new Promise((resolve) => process.nextTick(resolve));
     simulation(mockChildProcess, abortController);
     const result = await handle.result;
     return { result, handle, abortController };
@@ -365,6 +576,7 @@ describe('ShellExecutionService child_process fallback', () => {
         cp.stdout?.emit('data', Buffer.from('file1.txt\n'));
         cp.stderr?.emit('data', Buffer.from('a warning'));
         cp.emit('exit', 0, null);
+        cp.emit('close', 0, null);
       });
 
       expect(mockCpSpawn).toHaveBeenCalledWith(
@@ -377,15 +589,11 @@ describe('ShellExecutionService child_process fallback', () => {
       expect(result.error).toBeNull();
       expect(result.aborted).toBe(false);
       expect(result.output).toBe('file1.txt\na warning');
-      expect(handle.pid).toBe(12345);
+      expect(handle.pid).toBe(undefined);
 
       expect(onOutputEventMock).toHaveBeenCalledWith({
         type: 'data',
-        chunk: 'file1.txt\n',
-      });
-      expect(onOutputEventMock).toHaveBeenCalledWith({
-        type: 'data',
-        chunk: 'a warning',
+        chunk: 'file1.txt\na warning',
       });
     });
 
@@ -393,13 +601,16 @@ describe('ShellExecutionService child_process fallback', () => {
       const { result } = await simulateExecution('ls --color=auto', (cp) => {
         cp.stdout?.emit('data', Buffer.from('a\u001b[31mred\u001b[0mword'));
         cp.emit('exit', 0, null);
+        cp.emit('close', 0, null);
       });
 
-      expect(result.output).toBe('aredword');
-      expect(onOutputEventMock).toHaveBeenCalledWith({
-        type: 'data',
-        chunk: 'aredword',
-      });
+      expect(result.output.trim()).toBe('aredword');
+      expect(onOutputEventMock).toHaveBeenCalledWith(
+        expect.objectContaining({
+          type: 'data',
+          chunk: 'aredword',
+        }),
+      );
     });
 
     it('should correctly decode multi-byte characters split across chunks', async () => {
@@ -408,16 +619,18 @@ describe('ShellExecutionService child_process fallback', () => {
         cp.stdout?.emit('data', multiByteChar.slice(0, 2));
         cp.stdout?.emit('data', multiByteChar.slice(2));
         cp.emit('exit', 0, null);
+        cp.emit('close', 0, null);
       });
-      expect(result.output).toBe('你好');
+      expect(result.output.trim()).toBe('你好');
     });
 
     it('should handle commands with no output', async () => {
       const { result } = await simulateExecution('touch file', (cp) => {
         cp.emit('exit', 0, null);
+        cp.emit('close', 0, null);
       });
 
-      expect(result.output).toBe('');
+      expect(result.output.trim()).toBe('');
       expect(onOutputEventMock).not.toHaveBeenCalled();
     });
   });
@@ -427,16 +640,18 @@ describe('ShellExecutionService child_process fallback', () => {
       const { result } = await simulateExecution('a-bad-command', (cp) => {
         cp.stderr?.emit('data', Buffer.from('command not found'));
         cp.emit('exit', 127, null);
+        cp.emit('close', 127, null);
       });
 
       expect(result.exitCode).toBe(127);
-      expect(result.output).toBe('command not found');
+      expect(result.output.trim()).toBe('command not found');
       expect(result.error).toBeNull();
     });
 
     it('should capture a termination signal', async () => {
       const { result } = await simulateExecution('long-process', (cp) => {
         cp.emit('exit', null, 'SIGTERM');
+        cp.emit('close', null, 'SIGTERM');
       });
 
       expect(result.exitCode).toBeNull();
@@ -448,6 +663,7 @@ describe('ShellExecutionService child_process fallback', () => {
       const { result } = await simulateExecution('protected-cmd', (cp) => {
         cp.emit('error', spawnError);
         cp.emit('exit', 1, null);
+        cp.emit('close', 1, null);
       });
 
       expect(result.error).toBe(spawnError);
@@ -458,6 +674,7 @@ describe('ShellExecutionService child_process fallback', () => {
       const error = new Error('spawn abc ENOENT');
       const { result } = await simulateExecution('touch cat.jpg', (cp) => {
         cp.emit('error', error); // No exit event is fired.
+        cp.emit('close', 1, null);
       });
 
       expect(result.error).toBe(error);
@@ -487,10 +704,14 @@ describe('ShellExecutionService child_process fallback', () => {
             'sleep 10',
             (cp, abortController) => {
               abortController.abort();
-              if (expectedExit.signal)
+              if (expectedExit.signal) {
                 cp.emit('exit', null, expectedExit.signal);
-              if (typeof expectedExit.code === 'number')
+                cp.emit('close', null, expectedExit.signal);
+              }
+              if (typeof expectedExit.code === 'number') {
                 cp.emit('exit', expectedExit.code, null);
+                cp.emit('close', expectedExit.code, null);
+              }
             },
           );
 
@@ -526,6 +747,7 @@ describe('ShellExecutionService child_process fallback', () => {
         onOutputEventMock,
         abortController.signal,
         true,
+        {},
       );
 
       abortController.abort();
@@ -547,14 +769,13 @@ describe('ShellExecutionService child_process fallback', () => {
 
       // Finally, simulate the process exiting and await the result
       mockChildProcess.emit('exit', null, 'SIGKILL');
+      mockChildProcess.emit('close', null, 'SIGKILL');
       const result = await handle.result;
 
       vi.useRealTimers();
 
       expect(result.aborted).toBe(true);
       expect(result.signal).toBe(9);
-      // The individual kill calls were already asserted above.
-      expect(mockProcessKill).toHaveBeenCalledTimes(2);
     });
   });
 
@@ -573,18 +794,10 @@ describe('ShellExecutionService child_process fallback', () => {
       expect(result.rawOutput).toEqual(
         Buffer.concat([binaryChunk1, binaryChunk2]),
       );
-      expect(onOutputEventMock).toHaveBeenCalledTimes(3);
+      expect(onOutputEventMock).toHaveBeenCalledTimes(1);
       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,
-      });
     });
 
     it('should not emit data events after binary is detected', async () => {
@@ -600,12 +813,7 @@ describe('ShellExecutionService child_process fallback', () => {
       const eventTypes = onOutputEventMock.mock.calls.map(
         (call: [ShellOutputEvent]) => call[0].type,
       );
-      expect(eventTypes).toEqual([
-        'data',
-        'binary_detected',
-        'binary_progress',
-        'binary_progress',
-      ]);
+      expect(eventTypes).toEqual(['binary_detected']);
     });
   });
 
@@ -649,6 +857,8 @@ describe('ShellExecutionService execution method selection', () => {
     kill: Mock;
     onData: Mock;
     onExit: Mock;
+    write: Mock;
+    resize: Mock;
   };
   let mockChildProcess: EventEmitter & Partial<ChildProcess>;
 
@@ -662,11 +872,16 @@ describe('ShellExecutionService execution method selection', () => {
       kill: Mock;
       onData: Mock;
       onExit: Mock;
+      write: Mock;
+      resize: Mock;
     };
     mockPtyProcess.pid = 12345;
     mockPtyProcess.kill = vi.fn();
     mockPtyProcess.onData = vi.fn();
     mockPtyProcess.onExit = vi.fn();
+    mockPtyProcess.write = vi.fn();
+    mockPtyProcess.resize = vi.fn();
+
     mockPtySpawn.mockReturnValue(mockPtyProcess);
     mockGetPty.mockResolvedValue({
       module: { spawn: mockPtySpawn },
@@ -694,6 +909,7 @@ describe('ShellExecutionService execution method selection', () => {
       onOutputEventMock,
       abortController.signal,
       true, // shouldUseNodePty
+      shellExecutionConfig,
     );
 
     // Simulate exit to allow promise to resolve
@@ -714,6 +930,7 @@ describe('ShellExecutionService execution method selection', () => {
       onOutputEventMock,
       abortController.signal,
       false, // shouldUseNodePty
+      {},
     );
 
     // Simulate exit to allow promise to resolve
@@ -736,6 +953,7 @@ describe('ShellExecutionService execution method selection', () => {
       onOutputEventMock,
       abortController.signal,
       true, // shouldUseNodePty
+      shellExecutionConfig,
     );
 
     // Simulate exit to allow promise to resolve