@machina.ai/cell-cli 1.36.0-rc1 → 1.38.1-rc2

package/dist/src/acp/acpClient.test.js

@@ -6,7 +6,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
 import { GeminiAgent, Session } from './acpClient.js';
 import * as acp from '@agentclientprotocol/sdk';
-import { AuthType, ToolConfirmationOutcome, StreamEventType, isWithinRoot, ReadManyFilesTool, LlmRole, } from '@google/gemini-cli-core';
+import { AuthType, ToolConfirmationOutcome, StreamEventType, ReadManyFilesTool, LlmRole, processSingleFileContent, InvalidStreamError, } from '@google/gemini-cli-core';
 import { SettingScope, loadSettings, } from '../config/settings.js';
 import { loadCliConfig } from '../config/config.js';
 import * as fs from 'node:fs/promises';
@@ -61,19 +61,10 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
     const actual = await importOriginal();
     return {
         ...actual,
-        ReadManyFilesTool: vi.fn().mockImplementation(() => ({
-            name: 'read_many_files',
-            kind: 'read',
-            build: vi.fn().mockReturnValue({
-                getDescription: () => 'Read files',
-                toolLocations: () => [],
-                execute: vi.fn().mockResolvedValue({
-                    llmContent: ['--- file.txt ---\n\nFile content\n\n'],
-                }),
-            }),
-        })),
+        updatePolicy: vi.fn(),
+        createPolicyUpdater: vi.fn(),
+        ReadManyFilesTool: vi.fn(),
         logToolCall: vi.fn(),
-        isWithinRoot: vi.fn().mockReturnValue(true),
         LlmRole: {
             MAIN: 'main',
             SUBAGENT: 'subagent',
@@ -96,6 +87,7 @@ vi.mock('@google/gemini-cli-core', async (importOriginal) => {
             Cancelled: 'cancelled',
             AwaitingApproval: 'awaiting_approval',
         },
+        processSingleFileContent: vi.fn(),
     };
 });
 // Helper to create mock streams
@@ -135,6 +127,24 @@ describe('GeminiAgent', () => {
             getHasAccessToPreviewModel: vi.fn().mockReturnValue(false),
             getCheckpointingEnabled: vi.fn().mockReturnValue(false),
             getDisableAlwaysAllow: vi.fn().mockReturnValue(false),
+            validatePathAccess: vi.fn().mockReturnValue(null),
+            getWorkspaceContext: vi.fn().mockReturnValue({
+                addReadOnlyPath: vi.fn(),
+            }),
+            getPolicyEngine: vi.fn().mockReturnValue({
+                addRule: vi.fn(),
+            }),
+            messageBus: {
+                publish: vi.fn(),
+                subscribe: vi.fn(),
+                unsubscribe: vi.fn(),
+            },
+            storage: {
+                getWorkspaceAutoSavedPolicyPath: vi.fn(),
+                getAutoSavedPolicyPath: vi.fn(),
+                setClientName: vi.fn(),
+            },
+            setClientName: vi.fn(),
             get config() {
                 return this;
             },
@@ -149,11 +159,15 @@ describe('GeminiAgent', () => {
         mockArgv = {};
         mockConnection = {
             sessionUpdate: vi.fn(),
+            requestPermission: vi.fn(),
         };
         loadCliConfig.mockResolvedValue(mockConfig);
         loadSettings.mockImplementation(() => ({
             merged: {
-                security: { auth: { selectedType: AuthType.LOGIN_WITH_GOOGLE } },
+                security: {
+                    auth: { selectedType: AuthType.LOGIN_WITH_GOOGLE },
+                    enablePermanentToolApproval: true,
+                },
                 mcpServers: {},
             },
             setValue: vi.fn(),
@@ -296,6 +310,21 @@ describe('GeminiAgent', () => {
             }),
         ]));
     });
+    it('should include gemini-3.1-flash-lite when useGemini31FlashLite is true', async () => {
+        mockConfig.getHasAccessToPreviewModel = vi.fn().mockReturnValue(true);
+        mockConfig.getGemini31LaunchedSync = vi.fn().mockReturnValue(true);
+        mockConfig.getGemini31FlashLiteLaunchedSync = vi.fn().mockReturnValue(true);
+        const response = await agent.newSession({
+            cwd: '/tmp',
+            mcpServers: [],
+        });
+        expect(response.models?.availableModels).toEqual(expect.arrayContaining([
+            expect.objectContaining({
+                modelId: 'gemini-3.1-flash-lite-preview',
+                name: 'gemini-3.1-flash-lite-preview',
+            }),
+        ]));
+    });
     it('should return modes with plan mode when plan is enabled', async () => {
         mockConfig.getContentGeneratorConfig = vi.fn().mockReturnValue({
             apiKey: 'test-key',
@@ -472,6 +501,7 @@ describe('Session', () => {
             sendMessageStream: vi.fn(),
             addHistory: vi.fn(),
             recordCompletedToolCalls: vi.fn(),
+            getHistory: vi.fn().mockReturnValue([]),
         };
         mockTool = {
             kind: 'read',
@@ -493,12 +523,16 @@ describe('Session', () => {
         mockConfig = {
             getModel: vi.fn().mockReturnValue('gemini-pro'),
             getActiveModel: vi.fn().mockReturnValue('gemini-pro'),
+            getModelRouterService: vi.fn().mockReturnValue({
+                route: vi.fn().mockResolvedValue({ model: 'resolved-model' }),
+            }),
             getToolRegistry: vi.fn().mockReturnValue(mockToolRegistry),
             getMcpServers: vi.fn(),
             getFileService: vi.fn().mockReturnValue({
                 shouldIgnoreFile: vi.fn().mockReturnValue(false),
             }),
             getFileFilteringOptions: vi.fn().mockReturnValue({}),
+            getFileSystemService: vi.fn().mockReturnValue({}),
             getTargetDir: vi.fn().mockReturnValue('/tmp'),
             getEnableRecursiveFileSearch: vi.fn().mockReturnValue(false),
             getDebugMode: vi.fn().mockReturnValue(false),
@@ -508,6 +542,10 @@ describe('Session', () => {
             isPlanEnabled: vi.fn().mockReturnValue(true),
             getCheckpointingEnabled: vi.fn().mockReturnValue(false),
             getGitService: vi.fn().mockResolvedValue({}),
+            validatePathAccess: vi.fn().mockReturnValue(null),
+            getWorkspaceContext: vi.fn().mockReturnValue({
+                addReadOnlyPath: vi.fn(),
+            }),
             waitForMcpInit: vi.fn(),
             getDisableAlwaysAllow: vi.fn().mockReturnValue(false),
             get config() {
@@ -527,12 +565,26 @@ describe('Session', () => {
             systemDefaults: { settings: {} },
             user: { settings: {} },
             workspace: { settings: {} },
-            merged: { settings: {} },
+            merged: {
+                security: { enablePermanentToolApproval: true },
+                mcpServers: {},
+            },
             errors: [],
         });
+        ReadManyFilesTool.mockImplementation(() => ({
+            name: 'read_many_files',
+            kind: 'read',
+            build: vi.fn().mockReturnValue({
+                getDescription: () => 'Read files',
+                toolLocations: () => [],
+                execute: vi.fn().mockResolvedValue({
+                    llmContent: ['--- file.txt ---\n\nFile content\n\n'],
+                }),
+            }),
+        }));
     });
     afterEach(() => {
-        vi.clearAllMocks();
+        vi.restoreAllMocks();
     });
     it('should send available commands', async () => {
         await session.sendAvailableCommands();
@@ -591,6 +643,66 @@ describe('Session', () => {
         });
         expect(result).toMatchObject({ stopReason: 'end_turn' });
     });
+    it('should use model router to determine model', async () => {
+        const mockRouter = {
+            route: vi.fn().mockResolvedValue({ model: 'routed-model' }),
+        };
+        mockConfig.getModelRouterService.mockReturnValue(mockRouter);
+        const stream = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: {
+                    candidates: [{ content: { parts: [{ text: 'Hello' }] } }],
+                },
+            },
+        ]);
+        mockChat.sendMessageStream.mockResolvedValue(stream);
+        await session.prompt({
+            sessionId: 'session-1',
+            prompt: [{ type: 'text', text: 'Hi' }],
+        });
+        expect(mockRouter.route).toHaveBeenCalledWith(expect.objectContaining({
+            requestedModel: 'gemini-pro',
+            request: [{ text: 'Hi' }],
+        }));
+        expect(mockChat.sendMessageStream).toHaveBeenCalledWith(expect.objectContaining({ model: 'routed-model' }), expect.any(Array), expect.any(String), expect.any(Object), expect.any(String));
+    });
+    it('should handle prompt with empty response (InvalidStreamError)', async () => {
+        mockChat.sendMessageStream.mockRejectedValue(new InvalidStreamError('Empty response', 'NO_RESPONSE_TEXT'));
+        const result = await session.prompt({
+            sessionId: 'session-1',
+            prompt: [{ type: 'text', text: 'Hi' }],
+        });
+        expect(mockChat.sendMessageStream).toHaveBeenCalled();
+        expect(result).toMatchObject({ stopReason: 'end_turn' });
+    });
+    it('should handle prompt with empty response (NO_RESPONSE_TEXT anomaly)', async () => {
+        mockChat.sendMessageStream.mockRejectedValue({ type: 'NO_RESPONSE_TEXT' });
+        const result = await session.prompt({
+            sessionId: 'session-1',
+            prompt: [{ type: 'text', text: 'Hi' }],
+        });
+        expect(mockChat.sendMessageStream).toHaveBeenCalled();
+        expect(result).toMatchObject({ stopReason: 'end_turn' });
+    });
+    it('should handle prompt with no finish reason (InvalidStreamError)', async () => {
+        mockChat.sendMessageStream.mockRejectedValue(new InvalidStreamError('No finish reason', 'NO_FINISH_REASON'));
+        const result = await session.prompt({
+            sessionId: 'session-1',
+            prompt: [{ type: 'text', text: 'Hi' }],
+        });
+        expect(mockChat.sendMessageStream).toHaveBeenCalled();
+        expect(result).toMatchObject({ stopReason: 'end_turn' });
+    });
+    it('should handle prompt with no finish reason (NO_FINISH_REASON anomaly)', async () => {
+        mockChat.sendMessageStream.mockRejectedValue({ type: 'NO_FINISH_REASON' });
+        const result = await session.prompt({
+            sessionId: 'session-1',
+            prompt: [{ type: 'text', text: 'Hi' }],
+        });
+        expect(mockChat.sendMessageStream).toHaveBeenCalled();
+        expect(result).toMatchObject({ stopReason: 'end_turn' });
+    });
     it('should handle /memory command', async () => {
         const handleCommandSpy = vi
             .spyOn(session
@@ -788,6 +900,132 @@ describe('Session', () => {
             ]),
         }));
     });
+    it('should exclude always allow and save permanent option when enablePermanentToolApproval is false', async () => {
+        mockConfig.getDisableAlwaysAllow = vi.fn().mockReturnValue(false);
+        const confirmationDetails = {
+            type: 'edit',
+            onConfirm: vi.fn(),
+        };
+        mockTool.build.mockReturnValue({
+            getDescription: () => 'Test Tool',
+            toolLocations: () => [],
+            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
+            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
+        });
+        const customSettings = {
+            system: { settings: {} },
+            systemDefaults: { settings: {} },
+            user: { settings: {} },
+            workspace: { settings: {} },
+            merged: {
+                security: { enablePermanentToolApproval: false },
+                mcpServers: {},
+            },
+            errors: [],
+        };
+        const localSession = new Session('session-2', mockChat, mockConfig, mockConnection, customSettings);
+        mockConnection.requestPermission.mockResolvedValueOnce({
+            outcome: {
+                outcome: 'selected',
+                optionId: ToolConfirmationOutcome.ProceedOnce,
+            },
+        });
+        const stream1 = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: {
+                    functionCalls: [{ name: 'test_tool', args: {} }],
+                },
+            },
+        ]);
+        const stream2 = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: { candidates: [] },
+            },
+        ]);
+        mockChat.sendMessageStream
+            .mockResolvedValueOnce(stream1)
+            .mockResolvedValueOnce(stream2);
+        await localSession.prompt({
+            sessionId: 'session-2',
+            prompt: [{ type: 'text', text: 'Call tool' }],
+        });
+        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
+            options: expect.not.arrayContaining([
+                expect.objectContaining({
+                    optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                }),
+            ]),
+        }));
+        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
+            options: expect.arrayContaining([
+                expect.objectContaining({
+                    optionId: ToolConfirmationOutcome.ProceedAlways,
+                }),
+            ]),
+        }));
+    });
+    it('should include always allow and save permanent option when enablePermanentToolApproval is true', async () => {
+        mockConfig.getDisableAlwaysAllow = vi.fn().mockReturnValue(false);
+        const confirmationDetails = {
+            type: 'edit',
+            onConfirm: vi.fn(),
+        };
+        mockTool.build.mockReturnValue({
+            getDescription: () => 'Test Tool',
+            toolLocations: () => [],
+            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
+            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
+        });
+        const customSettings = {
+            system: { settings: {} },
+            systemDefaults: { settings: {} },
+            user: { settings: {} },
+            workspace: { settings: {} },
+            merged: {
+                security: { enablePermanentToolApproval: true },
+                mcpServers: {},
+            },
+            errors: [],
+        };
+        const localSession = new Session('session-2', mockChat, mockConfig, mockConnection, customSettings);
+        mockConnection.requestPermission.mockResolvedValueOnce({
+            outcome: {
+                outcome: 'selected',
+                optionId: ToolConfirmationOutcome.ProceedOnce,
+            },
+        });
+        const stream1 = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: {
+                    functionCalls: [{ name: 'test_tool', args: {} }],
+                },
+            },
+        ]);
+        const stream2 = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: { candidates: [] },
+            },
+        ]);
+        mockChat.sendMessageStream
+            .mockResolvedValueOnce(stream1)
+            .mockResolvedValueOnce(stream2);
+        await localSession.prompt({
+            sessionId: 'session-2',
+            prompt: [{ type: 'text', text: 'Call tool' }],
+        });
+        expect(mockConnection.requestPermission).toHaveBeenCalledWith(expect.objectContaining({
+            options: expect.arrayContaining([
+                expect.objectContaining({
+                    optionId: ToolConfirmationOutcome.ProceedAlwaysAndSave,
+                    name: 'Allow for this file in all future sessions',
+                }),
+            ]),
+        }));
+    });
     it('should use filePath for ACP diff content in permission request', async () => {
         const confirmationDetails = {
             type: 'edit',
@@ -897,6 +1135,48 @@ describe('Session', () => {
             }),
         }));
     });
+    it('should call updatePolicy when tool permission triggers always allow', async () => {
+        const confirmationDetails = {
+            type: 'info',
+            onConfirm: vi.fn(),
+        };
+        mockTool.build.mockReturnValue({
+            getDescription: () => 'Test Tool',
+            toolLocations: () => [],
+            shouldConfirmExecute: vi.fn().mockResolvedValue(confirmationDetails),
+            execute: vi.fn().mockResolvedValue({ llmContent: 'Tool Result' }),
+        });
+        mockConnection.requestPermission.mockResolvedValue({
+            outcome: {
+                outcome: 'selected',
+                optionId: ToolConfirmationOutcome.ProceedAlways,
+            },
+        });
+        const stream1 = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: {
+                    functionCalls: [{ name: 'test_tool', args: {} }],
+                },
+            },
+        ]);
+        const stream2 = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: { candidates: [] },
+            },
+        ]);
+        mockChat.sendMessageStream
+            .mockResolvedValueOnce(stream1)
+            .mockResolvedValueOnce(stream2);
+        const { updatePolicy } = await import('@google/gemini-cli-core');
+        await session.prompt({
+            sessionId: 'session-1',
+            prompt: [{ type: 'text', text: 'Call tool' }],
+        });
+        expect(confirmationDetails.onConfirm).toHaveBeenCalled();
+        expect(updatePolicy).toHaveBeenCalled();
+    });
     it('should use filePath for ACP diff content in tool result', async () => {
         mockTool.build.mockReturnValue({
             getDescription: () => 'Test Tool',
@@ -1076,7 +1356,6 @@ describe('Session', () => {
         fs.stat.mockResolvedValue({
             isDirectory: () => false,
         });
-        isWithinRoot.mockReturnValue(true);
         const stream = createMockStream([
             {
                 type: StreamEventType.CHUNK,
@@ -1120,7 +1399,6 @@ describe('Session', () => {
         fs.stat.mockResolvedValue({
             isDirectory: () => false,
         });
-        isWithinRoot.mockReturnValue(true);
         const MockReadManyFilesTool = ReadManyFilesTool;
         MockReadManyFilesTool.mockImplementationOnce(() => ({
             name: 'read_many_files',
@@ -1165,6 +1443,129 @@ describe('Session', () => {
             }),
         }));
     });
+    it('should handle @path validation error and bubble it to user', async () => {
+        mockConfig.getTargetDir.mockReturnValue('/workspace');
+        path.resolve.mockReturnValue('/tmp/disallowed.txt');
+        mockConfig.validatePathAccess.mockReturnValue('Path is outside workspace');
+        // Force fs.stat to fail to skip direct reading and triggers the warning
+        fs.stat.mockRejectedValue(new Error('File not found'));
+        const stream = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: { candidates: [] },
+            },
+        ]);
+        mockChat.sendMessageStream.mockResolvedValue(stream);
+        await session.prompt({
+            sessionId: 'session-1',
+            prompt: [
+                {
+                    type: 'resource_link',
+                    uri: 'file://disallowed.txt',
+                    mimeType: 'text/plain',
+                    name: 'disallowed.txt',
+                },
+            ],
+        });
+        // Verify warning sent via sendUpdate
+        expect(mockConnection.sessionUpdate).toHaveBeenCalledWith(expect.objectContaining({
+            update: expect.objectContaining({
+                sessionUpdate: 'agent_thought_chunk',
+                content: expect.objectContaining({
+                    text: expect.stringContaining('Warning: skipping access to `disallowed.txt`. Reason: Path is outside workspace'),
+                }),
+            }),
+        }));
+    });
+    it('should read absolute file directly if outside workspace', async () => {
+        mockConfig.getTargetDir.mockReturnValue('/workspace');
+        const testFilePath = '/tmp/custom.txt';
+        path.resolve.mockReturnValue(testFilePath);
+        mockConfig.validatePathAccess.mockReturnValue('Path is outside workspace');
+        mockConnection.requestPermission.mockResolvedValue({
+            outcome: {
+                outcome: 'selected',
+                optionId: ToolConfirmationOutcome.ProceedOnce,
+            },
+        });
+        const mockStats = {
+            isFile: () => true,
+            isDirectory: () => false,
+        };
+        fs.stat.mockResolvedValue(mockStats);
+        processSingleFileContent.mockResolvedValue({
+            llmContent: 'Absolute File Content',
+        });
+        const stream = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: { candidates: [] },
+            },
+        ]);
+        mockChat.sendMessageStream.mockResolvedValue(stream);
+        await session.prompt({
+            sessionId: 'session-1',
+            prompt: [
+                {
+                    type: 'resource_link',
+                    uri: `file://${testFilePath}`,
+                    mimeType: 'text/plain',
+                    name: 'custom.txt',
+                },
+            ],
+        });
+        expect(processSingleFileContent).toHaveBeenCalledWith(testFilePath, expect.anything(), expect.anything());
+        // Verify content appended to sendMessageStream parts
+        expect(mockChat.sendMessageStream).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([
+            expect.objectContaining({
+                text: 'Absolute File Content',
+            }),
+        ]), expect.anything(), expect.any(AbortSignal), expect.anything());
+    });
+    it('should read escaping relative file directly if outside workspace', async () => {
+        mockConfig.getTargetDir.mockReturnValue('/workspace');
+        const testFilePath = '../../custom.txt';
+        path.resolve.mockReturnValue('/custom.txt');
+        mockConfig.validatePathAccess.mockReturnValue('Path is outside workspace');
+        mockConnection.requestPermission.mockResolvedValue({
+            outcome: {
+                outcome: 'selected',
+                optionId: ToolConfirmationOutcome.ProceedOnce,
+            },
+        });
+        const mockStats = {
+            isFile: () => true,
+            isDirectory: () => false,
+        };
+        fs.stat.mockResolvedValue(mockStats);
+        processSingleFileContent.mockResolvedValue({
+            llmContent: 'Escaping Relative File Content',
+        });
+        const stream = createMockStream([
+            {
+                type: StreamEventType.CHUNK,
+                value: { candidates: [] },
+            },
+        ]);
+        mockChat.sendMessageStream.mockResolvedValue(stream);
+        await session.prompt({
+            sessionId: 'session-1',
+            prompt: [
+                {
+                    type: 'resource_link',
+                    uri: `file://${testFilePath}`,
+                    mimeType: 'text/plain',
+                    name: 'custom.txt',
+                },
+            ],
+        });
+        expect(processSingleFileContent).toHaveBeenCalledWith('/custom.txt', expect.any(String), expect.anything());
+        expect(mockChat.sendMessageStream).toHaveBeenCalledWith(expect.anything(), expect.arrayContaining([
+            expect.objectContaining({
+                text: 'Escaping Relative File Content',
+            }),
+        ]), expect.anything(), expect.any(AbortSignal), expect.anything());
+    });
     it('should handle cancellation during prompt', async () => {
         let streamController;
         const stream = new ReadableStream({
@@ -1332,7 +1733,6 @@ describe('Session', () => {
         fs.stat.mockResolvedValue({
             isDirectory: () => true,
         });
-        isWithinRoot.mockReturnValue(true);
         const stream = createMockStream([
             {
                 type: StreamEventType.CHUNK,