@google/gemini-cli-core 0.1.13 → 0.1.15

package/dist/src/tools/shell.test.js

@@ -3,404 +3,266 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { expect, describe, it, vi, beforeEach } from 'vitest';
+import { vi, describe, it, expect, beforeEach, afterEach, } from 'vitest';
+const mockShellExecutionService = vi.hoisted(() => vi.fn());
+vi.mock('../services/shellExecutionService.js', () => ({
+    ShellExecutionService: { execute: mockShellExecutionService },
+}));
+vi.mock('fs');
+vi.mock('os');
+vi.mock('crypto');
+vi.mock('../utils/summarizer.js');
+import { isCommandAllowed } from '../utils/shell-utils.js';
 import { ShellTool } from './shell.js';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import * as crypto from 'crypto';
 import * as summarizer from '../utils/summarizer.js';
+import { ToolConfirmationOutcome } from './tools.js';
+import { OUTPUT_UPDATE_INTERVAL_MS } from './shell.js';
 describe('ShellTool', () => {
-    it('should allow a command if no restrictions are provided', async () => {
-        const config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => undefined,
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('ls -l');
-        expect(result.allowed).toBe(true);
-    });
-    it('should allow a command if it is in the allowed list', async () => {
-        const config = {
-            getCoreTools: () => ['ShellTool(ls -l)'],
-            getExcludeTools: () => undefined,
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('ls -l');
-        expect(result.allowed).toBe(true);
-    });
-    it('should block a command if it is not in the allowed list', async () => {
-        const config = {
-            getCoreTools: () => ['ShellTool(ls -l)'],
-            getExcludeTools: () => undefined,
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is not in the allowed commands list");
-    });
-    it('should block a command if it is in the blocked list', async () => {
-        const config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => ['ShellTool(rm -rf /)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is blocked by configuration");
-    });
-    it('should allow a command if it is not in the blocked list', async () => {
-        const config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => ['ShellTool(rm -rf /)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('ls -l');
-        expect(result.allowed).toBe(true);
-    });
-    it('should block a command if it is in both the allowed and blocked lists', async () => {
-        const config = {
-            getCoreTools: () => ['ShellTool(rm -rf /)'],
-            getExcludeTools: () => ['ShellTool(rm -rf /)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is blocked by configuration");
-    });
-    it('should allow any command when ShellTool is in coreTools without specific commands', async () => {
-        const config = {
-            getCoreTools: () => ['ShellTool'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('any command');
-        expect(result.allowed).toBe(true);
-    });
-    it('should block any command when ShellTool is in excludeTools without specific commands', async () => {
-        const config = {
-            getCoreTools: () => [],
-            getExcludeTools: () => ['ShellTool'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('any command');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe('Shell tool is globally disabled in configuration');
-    });
-    it('should allow a command if it is in the allowed list using the public-facing name', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(ls -l)'],
-            getExcludeTools: () => undefined,
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('ls -l');
-        expect(result.allowed).toBe(true);
-    });
-    it('should block a command if it is in the blocked list using the public-facing name', async () => {
-        const config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => ['run_shell_command(rm -rf /)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is blocked by configuration");
-    });
-    it('should block any command when ShellTool is in excludeTools using the public-facing name', async () => {
-        const config = {
-            getCoreTools: () => [],
-            getExcludeTools: () => ['run_shell_command'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('any command');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe('Shell tool is globally disabled in configuration');
-    });
-    it('should block any command if coreTools contains an empty ShellTool command list using the public-facing name', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command()'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('any command');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'any command' is not in the allowed commands list");
-    });
-    it('should block any command if coreTools contains an empty ShellTool command list', async () => {
-        const config = {
-            getCoreTools: () => ['ShellTool()'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('any command');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'any command' is not in the allowed commands list");
-    });
-    it('should block a command with extra whitespace if it is in the blocked list', async () => {
-        const config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => ['ShellTool(rm -rf /)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed(' rm  -rf  / ');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is blocked by configuration");
-    });
-    it('should allow any command when ShellTool is present with specific commands', async () => {
-        const config = {
-            getCoreTools: () => ['ShellTool', 'ShellTool(ls)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('any command');
-        expect(result.allowed).toBe(true);
-    });
-    it('should block a command on the blocklist even with a wildcard allow', async () => {
-        const config = {
-            getCoreTools: () => ['ShellTool'],
-            getExcludeTools: () => ['ShellTool(rm -rf /)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is blocked by configuration");
-    });
-    it('should allow a command that starts with an allowed command prefix', async () => {
-        const config = {
-            getCoreTools: () => ['ShellTool(gh issue edit)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('gh issue edit 1 --add-label "kind/feature"');
-        expect(result.allowed).toBe(true);
-    });
-    it('should allow a command that starts with an allowed command prefix using the public-facing name', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(gh issue edit)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('gh issue edit 1 --add-label "kind/feature"');
-        expect(result.allowed).toBe(true);
-    });
-    it('should not allow a command that starts with an allowed command prefix but is chained with another command', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(gh issue edit)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('gh issue edit&&rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is not in the allowed commands list");
-    });
-    it('should not allow a command that is a prefix of an allowed command', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(gh issue edit)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('gh issue');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'gh issue' is not in the allowed commands list");
-    });
-    it('should not allow a command that is a prefix of a blocked command', async () => {
-        const config = {
-            getCoreTools: () => [],
-            getExcludeTools: () => ['run_shell_command(gh issue edit)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('gh issue');
-        expect(result.allowed).toBe(true);
-    });
-    it('should not allow a command that is chained with a pipe', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(gh issue list)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('gh issue list | rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is not in the allowed commands list");
-    });
-    it('should not allow a command that is chained with a semicolon', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(gh issue list)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('gh issue list; rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is not in the allowed commands list");
-    });
-    it('should block a chained command if any part is blocked', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(echo "hello")'],
-            getExcludeTools: () => ['run_shell_command(rm)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('echo "hello" && rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is blocked by configuration");
-    });
-    it('should block a command if its prefix is on the blocklist, even if the command itself is on the allowlist', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(git push)'],
-            getExcludeTools: () => ['run_shell_command(git)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('git push');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'git push' is blocked by configuration");
-    });
-    it('should be case-sensitive in its matching', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(echo)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('ECHO "hello"');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe('Command \'ECHO "hello"\' is not in the allowed commands list');
-    });
-    it('should correctly handle commands with extra whitespace around chaining operators', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(ls -l)'],
-            getExcludeTools: () => ['run_shell_command(rm)'],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('ls -l  ;  rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is blocked by configuration");
-    });
-    it('should allow a chained command if all parts are allowed', async () => {
-        const config = {
-            getCoreTools: () => [
-                'run_shell_command(echo)',
-                'run_shell_command(ls -l)',
-            ],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('echo "hello" && ls -l');
-        expect(result.allowed).toBe(true);
-    });
-    it('should allow a command with command substitution using backticks', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(echo)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('echo `rm -rf /`');
-        expect(result.allowed).toBe(true);
-    });
-    it('should block a command with command substitution using $()', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(echo)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('echo $(rm -rf /)');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe('Command substitution using $() is not allowed for security reasons');
-    });
-    it('should allow a command with I/O redirection', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(echo)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('echo "hello" > file.txt');
-        expect(result.allowed).toBe(true);
-    });
-    it('should not allow a command that is chained with a double pipe', async () => {
-        const config = {
-            getCoreTools: () => ['run_shell_command(gh issue list)'],
-            getExcludeTools: () => [],
-        };
-        const shellTool = new ShellTool(config);
-        const result = shellTool.isCommandAllowed('gh issue list || rm -rf /');
-        expect(result.allowed).toBe(false);
-        expect(result.reason).toBe("Command 'rm -rf /' is not in the allowed commands list");
-    });
-});
-describe('ShellTool Bug Reproduction', () => {
     let shellTool;
-    let config;
+    let mockConfig;
+    let mockShellOutputCallback;
+    let resolveExecutionPromise;
     beforeEach(() => {
-        config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => undefined,
-            getDebugMode: () => false,
-            getGeminiClient: () => ({}),
-            getTargetDir: () => '.',
-            getSummarizeToolOutputConfig: () => ({
-                [shellTool.name]: {},
-            }),
-        };
-        shellTool = new ShellTool(config);
-    });
-    it('should not let the summarizer override the return display', async () => {
-        const summarizeSpy = vi
-            .spyOn(summarizer, 'summarizeToolOutput')
-            .mockResolvedValue('summarized output');
-        const abortSignal = new AbortController().signal;
-        const result = await shellTool.execute({ command: 'echo "hello"' }, abortSignal);
-        expect(result.returnDisplay).toBe('hello\n');
-        expect(result.llmContent).toBe('summarized output');
-        expect(summarizeSpy).toHaveBeenCalled();
-    });
-    it('should not call summarizer if disabled in config', async () => {
-        config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => undefined,
-            getDebugMode: () => false,
-            getGeminiClient: () => ({}),
-            getTargetDir: () => '.',
-            getSummarizeToolOutputConfig: () => ({}),
-        };
-        shellTool = new ShellTool(config);
-        const summarizeSpy = vi
-            .spyOn(summarizer, 'summarizeToolOutput')
-            .mockResolvedValue('summarized output');
-        const abortSignal = new AbortController().signal;
-        const result = await shellTool.execute({ command: 'echo "hello"' }, abortSignal);
-        expect(result.returnDisplay).toBe('hello\n');
-        expect(result.llmContent).not.toBe('summarized output');
-        expect(summarizeSpy).not.toHaveBeenCalled();
-    });
-    it('should pass token budget to summarizer', async () => {
-        config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => undefined,
-            getDebugMode: () => false,
-            getGeminiClient: () => ({}),
-            getTargetDir: () => '.',
-            getSummarizeToolOutputConfig: () => ({
+        vi.clearAllMocks();
+        mockConfig = {
+            getCoreTools: vi.fn().mockReturnValue([]),
+            getExcludeTools: vi.fn().mockReturnValue([]),
+            getDebugMode: vi.fn().mockReturnValue(false),
+            getTargetDir: vi.fn().mockReturnValue('/test/dir'),
+            getSummarizeToolOutputConfig: vi.fn().mockReturnValue(undefined),
+            getGeminiClient: vi.fn(),
+        };
+        shellTool = new ShellTool(mockConfig);
+        vi.mocked(os.platform).mockReturnValue('linux');
+        vi.mocked(os.tmpdir).mockReturnValue('/tmp');
+        vi.mocked(crypto.randomBytes).mockReturnValue(Buffer.from('abcdef', 'hex'));
+        // Capture the output callback to simulate streaming events from the service
+        mockShellExecutionService.mockImplementation((_cmd, _cwd, callback) => {
+            mockShellOutputCallback = callback;
+            return {
+                pid: 12345,
+                result: new Promise((resolve) => {
+                    resolveExecutionPromise = resolve;
+                }),
+            };
+        });
+    });
+    describe('isCommandAllowed', () => {
+        it('should allow a command if no restrictions are provided', () => {
+            mockConfig.getCoreTools.mockReturnValue(undefined);
+            mockConfig.getExcludeTools.mockReturnValue(undefined);
+            expect(isCommandAllowed('ls -l', mockConfig).allowed).toBe(true);
+        });
+        it('should block a command with command substitution using $()', () => {
+            expect(isCommandAllowed('echo $(rm -rf /)', mockConfig).allowed).toBe(false);
+        });
+    });
+    describe('validateToolParams', () => {
+        it('should return null for a valid command', () => {
+            expect(shellTool.validateToolParams({ command: 'ls -l' })).toBeNull();
+        });
+        it('should return an error for an empty command', () => {
+            expect(shellTool.validateToolParams({ command: ' ' })).toBe('Command cannot be empty.');
+        });
+        it('should return an error for a non-existent directory', () => {
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            expect(shellTool.validateToolParams({ command: 'ls', directory: 'rel/path' })).toBe('Directory must exist.');
+        });
+    });
+    describe('execute', () => {
+        const mockAbortSignal = new AbortController().signal;
+        const resolveShellExecution = (result = {}) => {
+            const fullResult = {
+                rawOutput: Buffer.from(result.output || ''),
+                output: 'Success',
+                stdout: 'Success',
+                stderr: '',
+                exitCode: 0,
+                signal: null,
+                error: null,
+                aborted: false,
+                pid: 12345,
+                ...result,
+            };
+            resolveExecutionPromise(fullResult);
+        };
+        it('should wrap command on linux and parse pgrep output', async () => {
+            const promise = shellTool.execute({ command: 'my-command &' }, mockAbortSignal);
+            resolveShellExecution({ pid: 54321 });
+            vi.mocked(fs.existsSync).mockReturnValue(true);
+            vi.mocked(fs.readFileSync).mockReturnValue('54321\n54322\n'); // Service PID and background PID
+            const result = await promise;
+            const tmpFile = path.join(os.tmpdir(), 'shell_pgrep_abcdef.tmp');
+            const wrappedCommand = `{ my-command & }; __code=$?; pgrep -g 0 >${tmpFile} 2>&1; exit $__code;`;
+            expect(mockShellExecutionService).toHaveBeenCalledWith(wrappedCommand, expect.any(String), expect.any(Function), mockAbortSignal);
+            expect(result.llmContent).toContain('Background PIDs: 54322');
+            expect(vi.mocked(fs.unlinkSync)).toHaveBeenCalledWith(tmpFile);
+        });
+        it('should not wrap command on windows', async () => {
+            vi.mocked(os.platform).mockReturnValue('win32');
+            const promise = shellTool.execute({ command: 'dir' }, mockAbortSignal);
+            resolveExecutionPromise({
+                rawOutput: Buffer.from(''),
+                output: '',
+                stdout: '',
+                stderr: '',
+                exitCode: 0,
+                signal: null,
+                error: null,
+                aborted: false,
+                pid: 12345,
+            });
+            await promise;
+            expect(mockShellExecutionService).toHaveBeenCalledWith('dir', expect.any(String), expect.any(Function), mockAbortSignal);
+        });
+        it('should format error messages correctly', async () => {
+            const error = new Error('wrapped command failed');
+            const promise = shellTool.execute({ command: 'user-command' }, mockAbortSignal);
+            resolveShellExecution({
+                error,
+                exitCode: 1,
+                output: 'err',
+                stderr: 'err',
+                rawOutput: Buffer.from('err'),
+                stdout: '',
+                signal: null,
+                aborted: false,
+                pid: 12345,
+            });
+            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');
+        });
+        it('should summarize output when configured', async () => {
+            mockConfig.getSummarizeToolOutputConfig.mockReturnValue({
                 [shellTool.name]: { tokenBudget: 1000 },
-            }),
-        };
-        shellTool = new ShellTool(config);
-        const summarizeSpy = vi
-            .spyOn(summarizer, 'summarizeToolOutput')
-            .mockResolvedValue('summarized output');
-        const abortSignal = new AbortController().signal;
-        await shellTool.execute({ command: 'echo "hello"' }, abortSignal);
-        expect(summarizeSpy).toHaveBeenCalledWith(expect.any(String), expect.any(Object), expect.any(Object), 1000);
-    });
-    it('should use default token budget if not specified', async () => {
-        config = {
-            getCoreTools: () => undefined,
-            getExcludeTools: () => undefined,
-            getDebugMode: () => false,
-            getGeminiClient: () => ({}),
-            getTargetDir: () => '.',
-            getSummarizeToolOutputConfig: () => ({
-                [shellTool.name]: {},
-            }),
-        };
-        shellTool = new ShellTool(config);
-        const summarizeSpy = vi
-            .spyOn(summarizer, 'summarizeToolOutput')
-            .mockResolvedValue('summarized output');
-        const abortSignal = new AbortController().signal;
-        await shellTool.execute({ command: 'echo "hello"' }, abortSignal);
-        expect(summarizeSpy).toHaveBeenCalledWith(expect.any(String), expect.any(Object), expect.any(Object), undefined);
+            });
+            vi.mocked(summarizer.summarizeToolOutput).mockResolvedValue('summarized output');
+            const promise = shellTool.execute({ command: 'ls' }, mockAbortSignal);
+            resolveExecutionPromise({
+                output: 'long output',
+                rawOutput: Buffer.from('long output'),
+                stdout: 'long output',
+                stderr: '',
+                exitCode: 0,
+                signal: null,
+                error: null,
+                aborted: false,
+                pid: 12345,
+            });
+            const result = await promise;
+            expect(summarizer.summarizeToolOutput).toHaveBeenCalledWith(expect.any(String), mockConfig.getGeminiClient(), mockAbortSignal, 1000);
+            expect(result.llmContent).toBe('summarized output');
+            expect(result.returnDisplay).toBe('long output');
+        });
+        it('should clean up the temp file on synchronous execution error', async () => {
+            const error = new Error('sync spawn error');
+            mockShellExecutionService.mockImplementation(() => {
+                throw error;
+            });
+            vi.mocked(fs.existsSync).mockReturnValue(true); // Pretend the file exists
+            await expect(shellTool.execute({ command: 'a-command' }, mockAbortSignal)).rejects.toThrow(error);
+            const tmpFile = path.join(os.tmpdir(), 'shell_pgrep_abcdef.tmp');
+            expect(vi.mocked(fs.unlinkSync)).toHaveBeenCalledWith(tmpFile);
+        });
+        describe('Streaming to `updateOutput`', () => {
+            let updateOutputMock;
+            beforeEach(() => {
+                vi.useFakeTimers({ toFake: ['Date'] });
+                updateOutputMock = vi.fn();
+            });
+            afterEach(() => {
+                vi.useRealTimers();
+            });
+            it('should throttle text output updates', async () => {
+                const promise = shellTool.execute({ command: 'stream' }, mockAbortSignal, updateOutputMock);
+                // First chunk, should be throttled.
+                mockShellOutputCallback({
+                    type: 'data',
+                    stream: 'stdout',
+                    chunk: 'hello ',
+                });
+                expect(updateOutputMock).not.toHaveBeenCalled();
+                // Advance time past the throttle interval.
+                await vi.advanceTimersByTimeAsync(OUTPUT_UPDATE_INTERVAL_MS + 1);
+                // Send a second chunk. THIS event triggers the update with the CUMULATIVE content.
+                mockShellOutputCallback({
+                    type: 'data',
+                    stream: 'stderr',
+                    chunk: 'world',
+                });
+                // It should have been called once now with the combined output.
+                expect(updateOutputMock).toHaveBeenCalledOnce();
+                expect(updateOutputMock).toHaveBeenCalledWith('hello \nworld');
+                resolveExecutionPromise({
+                    rawOutput: Buffer.from(''),
+                    output: '',
+                    stdout: '',
+                    stderr: '',
+                    exitCode: 0,
+                    signal: null,
+                    error: null,
+                    aborted: false,
+                    pid: 12345,
+                });
+                await promise;
+            });
+            it('should immediately show binary detection message and throttle progress', async () => {
+                const promise = shellTool.execute({ command: 'cat img' }, mockAbortSignal, updateOutputMock);
+                mockShellOutputCallback({ type: 'binary_detected' });
+                expect(updateOutputMock).toHaveBeenCalledOnce();
+                expect(updateOutputMock).toHaveBeenCalledWith('[Binary output detected. Halting stream...]');
+                mockShellOutputCallback({
+                    type: 'binary_progress',
+                    bytesReceived: 1024,
+                });
+                expect(updateOutputMock).toHaveBeenCalledOnce();
+                // Advance time past the throttle interval.
+                await vi.advanceTimersByTimeAsync(OUTPUT_UPDATE_INTERVAL_MS + 1);
+                // Send a SECOND progress event. This one will trigger the flush.
+                mockShellOutputCallback({
+                    type: 'binary_progress',
+                    bytesReceived: 2048,
+                });
+                // Now it should be called a second time with the latest progress.
+                expect(updateOutputMock).toHaveBeenCalledTimes(2);
+                expect(updateOutputMock).toHaveBeenLastCalledWith('[Receiving binary output... 2.0 KB received]');
+                resolveExecutionPromise({
+                    rawOutput: Buffer.from(''),
+                    output: '',
+                    stdout: '',
+                    stderr: '',
+                    exitCode: 0,
+                    signal: null,
+                    error: null,
+                    aborted: false,
+                    pid: 12345,
+                });
+                await promise;
+            });
+        });
+    });
+    describe('shouldConfirmExecute', () => {
+        it('should request confirmation for a new command and whitelist it on "Always"', async () => {
+            const params = { command: 'npm install' };
+            const confirmation = await shellTool.shouldConfirmExecute(params, new AbortController().signal);
+            expect(confirmation).not.toBe(false);
+            expect(confirmation && confirmation.type).toBe('exec');
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await confirmation.onConfirm(ToolConfirmationOutcome.ProceedAlways);
+            // Should now be whitelisted
+            const secondConfirmation = await shellTool.shouldConfirmExecute({ command: 'npm test' }, new AbortController().signal);
+            expect(secondConfirmation).toBe(false);
+        });
+        it('should skip confirmation if validation fails', async () => {
+            const confirmation = await shellTool.shouldConfirmExecute({ command: '' }, new AbortController().signal);
+            expect(confirmation).toBe(false);
+        });
     });
 });
 //# sourceMappingURL=shell.test.js.map