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

package/dist/src/config/config.test.js

@@ -50,6 +50,7 @@ vi.mock('../tools/tool-registry', () => {
     ToolRegistryMock.prototype.sortTools = vi.fn();
     ToolRegistryMock.prototype.getAllTools = vi.fn(() => []); // Mock methods if needed
     ToolRegistryMock.prototype.getTool = vi.fn();
+    ToolRegistryMock.prototype.getAllToolNames = vi.fn(() => []);
     ToolRegistryMock.prototype.getFunctionDeclarations = vi.fn(() => []);
     return { ToolRegistry: ToolRegistryMock };
 });
@@ -161,12 +162,13 @@ vi.mock('../utils/events.js', async (importOriginal) => {
 vi.mock('../utils/fetch.js', () => ({
     setGlobalProxy: mockSetGlobalProxy,
 }));
-vi.mock('../services/contextManager.js', () => ({
-    ContextManager: vi.fn().mockImplementation(() => ({
+vi.mock('../context/memoryContextManager.js', () => ({
+    MemoryContextManager: vi.fn().mockImplementation(() => ({
         refresh: vi.fn(),
         getGlobalMemory: vi.fn().mockReturnValue(''),
         getExtensionMemory: vi.fn().mockReturnValue(''),
         getEnvironmentMemory: vi.fn().mockReturnValue(''),
+        getUserProjectMemory: vi.fn().mockReturnValue(''),
         getLoadedPaths: vi.fn().mockReturnValue(new Set()),
     })),
 }));
@@ -174,7 +176,7 @@ import { BaseLlmClient } from '../core/baseLlmClient.js';
 import { tokenLimit } from '../core/tokenLimits.js';
 import { getCodeAssistServer } from '../code_assist/codeAssist.js';
 import { getExperiments } from '../code_assist/experiments/experiments.js';
-import { ContextManager } from '../services/contextManager.js';
+import { MemoryContextManager } from '../context/memoryContextManager.js';
 import { UserTierId } from '../code_assist/types.js';
 import { LocalLiteRtLmClient } from '../core/localLiteRtLmClient.js';
 vi.mock('../core/baseLlmClient.js');
@@ -184,6 +186,9 @@ vi.mock('../core/tokenLimits.js', () => ({
 }));
 vi.mock('../code_assist/codeAssist.js');
 vi.mock('../code_assist/experiments/experiments.js');
+afterEach(() => {
+    vi.clearAllMocks();
+});
 describe('Server Config (config.ts)', () => {
     const MODEL = DEFAULT_GEMINI_MODEL;
     const SANDBOX = createMockSandboxConfig({
@@ -473,6 +478,91 @@ describe('Server Config (config.ts)', () => {
                 expect(await config.getResolvedClassifierThreshold()).toBe(90);
             });
         });
+        describe('getGemini31LaunchedSync', () => {
+            it.each([AuthType.USE_GEMINI, AuthType.USE_VERTEX_AI, AuthType.GATEWAY])('should return true for %s', async (authType) => {
+                const config = new Config(baseParams);
+                vi.mocked(createContentGeneratorConfig).mockResolvedValue({
+                    authType,
+                });
+                await config.refreshAuth(authType);
+                expect(config.getGemini31LaunchedSync()).toBe(true);
+            });
+            it('should fallback to experiments for other auth types', async () => {
+                vi.mocked(getExperiments).mockResolvedValue({
+                    experimentIds: [],
+                    flags: {
+                        [ExperimentFlags.GEMINI_3_1_PRO_LAUNCHED]: {
+                            flagId: ExperimentFlags.GEMINI_3_1_PRO_LAUNCHED,
+                            boolValue: true,
+                        },
+                    },
+                });
+                const config = new Config(baseParams);
+                vi.mocked(createContentGeneratorConfig).mockResolvedValue({
+                    authType: AuthType.LOGIN_WITH_GOOGLE,
+                });
+                await config.refreshAuth(AuthType.LOGIN_WITH_GOOGLE);
+                expect(config.getGemini31LaunchedSync()).toBe(true);
+            });
+        });
+        describe('getGemini31FlashLiteLaunchedSync', () => {
+            it.each([AuthType.USE_GEMINI, AuthType.USE_VERTEX_AI, AuthType.GATEWAY])('should return true for %s', async (authType) => {
+                const config = new Config(baseParams);
+                vi.mocked(createContentGeneratorConfig).mockResolvedValue({
+                    authType,
+                });
+                await config.refreshAuth(authType);
+                expect(config.getGemini31FlashLiteLaunchedSync()).toBe(true);
+            });
+        });
+        describe('getRequestTimeoutMs', () => {
+            it('should return undefined if the flag is not set', () => {
+                const config = new Config(baseParams);
+                expect(config.getRequestTimeoutMs()).toBeUndefined();
+            });
+            it('should return timeout in milliseconds if flag is set', () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.DEFAULT_REQUEST_TIMEOUT]: {
+                                intValue: '30',
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(config.getRequestTimeoutMs()).toBe(30000);
+            });
+            it('should return undefined if intValue is not a valid integer', () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.DEFAULT_REQUEST_TIMEOUT]: {
+                                intValue: 'abc',
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(config.getRequestTimeoutMs()).toBeUndefined();
+            });
+            it('should return undefined if intValue is negative', () => {
+                const config = new Config({
+                    ...baseParams,
+                    experiments: {
+                        flags: {
+                            [ExperimentFlags.DEFAULT_REQUEST_TIMEOUT]: {
+                                intValue: '-10',
+                            },
+                        },
+                        experimentIds: [],
+                    },
+                });
+                expect(config.getRequestTimeoutMs()).toBeUndefined();
+            });
+        });
     });
     describe('refreshAuth', () => {
         it('should refresh auth and update config', async () => {
@@ -1162,6 +1252,20 @@ describe('Server Config (config.ts)', () => {
             expect(browserConfig.customConfig.headless).toBe(true);
             expect(browserConfig.customConfig.profilePath).toBe('/path/to/profile');
             expect(browserConfig.customConfig.visualModel).toBe('custom-visual-model');
+            expect(browserConfig.customConfig.maxActionsPerTask).toBe(100); // default
+        });
+        it('should return custom maxActionsPerTask', () => {
+            const params = {
+                ...baseParams,
+                agents: {
+                    browser: {
+                        maxActionsPerTask: 50,
+                    },
+                },
+            };
+            const config = new Config(params);
+            const browserConfig = config.getBrowserAgentConfig();
+            expect(browserConfig.customConfig.maxActionsPerTask).toBe(50);
         });
         it('should apply defaults for partial custom config', () => {
             const params = {
@@ -1192,7 +1296,9 @@ describe('Server Config (config.ts)', () => {
                 sandbox: undefined,
             });
             expect(config.getSandboxEnabled()).toBe(false);
-            expect(config.getSandboxAllowedPaths()).toEqual([]);
+            expect(config.getSandboxAllowedPaths()).toEqual([
+                Storage.getGlobalTempDir(),
+            ]);
             expect(config.getSandboxNetworkAccess()).toBe(false);
         });
         it('should store provided sandbox settings', () => {
@@ -1208,7 +1314,11 @@ describe('Server Config (config.ts)', () => {
                 sandbox,
             });
             expect(config.getSandboxEnabled()).toBe(true);
-            expect(config.getSandboxAllowedPaths()).toEqual(['/tmp/foo', '/var/bar']);
+            expect(config.getSandboxAllowedPaths()).toEqual([
+                '/tmp/foo',
+                '/var/bar',
+                Storage.getGlobalTempDir(),
+            ]);
             expect(config.getSandboxNetworkAccess()).toBe(true);
             expect(config.getSandbox()?.command).toBe('docker');
             expect(config.getSandbox()?.image).toBe('my-image');
@@ -1223,9 +1333,36 @@ describe('Server Config (config.ts)', () => {
                 },
             });
             expect(config.getSandboxEnabled()).toBe(true);
-            expect(config.getSandboxAllowedPaths()).toEqual(['/only/this']);
+            expect(config.getSandboxAllowedPaths()).toEqual([
+                '/only/this',
+                Storage.getGlobalTempDir(),
+            ]);
             expect(config.getSandboxNetworkAccess()).toBe(false);
         });
+        it('lazily resolves forbidden paths when first accessed', async () => {
+            const config = new Config({
+                ...baseParams,
+                sandbox: { enabled: true, command: 'docker' },
+            });
+            const fileService = config.getFileService();
+            vi.spyOn(fileService, 'getIgnoredPaths').mockResolvedValue([
+                '/tmp/forbidden',
+            ]);
+            await config.initialize();
+            expect(fileService.getIgnoredPaths).not.toHaveBeenCalled();
+            // Access resolved paths via the internal resolver
+            const resolved = await config.getSandboxForbiddenPaths();
+            expect(fileService.getIgnoredPaths).toHaveBeenCalled();
+            expect(resolved).toEqual(['/tmp/forbidden']);
+        });
+    });
+    it('should have independent TopicState across instances', () => {
+        const config1 = new Config(baseParams);
+        const config2 = new Config(baseParams);
+        config1.topicState.setTopic('Topic 1');
+        config2.topicState.setTopic('Topic 2');
+        expect(config1.topicState.getTopic()).toBe('Topic 1');
+        expect(config2.topicState.getTopic()).toBe('Topic 2');
     });
 });
 describe('GemmaModelRouterSettings', () => {
@@ -1319,6 +1456,11 @@ describe('setApprovalMode with folder trust', () => {
         vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
         expect(() => config.setApprovalMode(ApprovalMode.DEFAULT)).not.toThrow();
     });
+    it('should NOT throw an error when setting PLAN mode in an untrusted folder', () => {
+        const config = new Config(baseParams);
+        vi.spyOn(config, 'isTrustedFolder').mockReturnValue(false);
+        expect(() => config.setApprovalMode(ApprovalMode.PLAN)).not.toThrow();
+    });
     it('should NOT throw an error when setting any mode in a trusted folder', () => {
         const config = new Config(baseParams);
         vi.spyOn(config, 'isTrustedFolder').mockReturnValue(true);
@@ -1544,8 +1686,15 @@ describe('BaseLlmClient Lifecycle', () => {
         model: MODEL,
         usageStatisticsEnabled: false,
     };
+    it('should throw an error if getBaseLlmClient is called before experiments have been fetched', () => {
+        const config = new Config(baseParams);
+        // By default on a new Config instance, experiments are undefined
+        expect(() => config.getBaseLlmClient()).toThrow('BaseLlmClient not initialized. Ensure experiments have been fetched and configuration is ready.');
+    });
     it('should throw an error if getBaseLlmClient is called before refreshAuth', () => {
         const config = new Config(baseParams);
+        // Explicitly set experiments to avoid triggering the new missing-experiments error
+        config.setExperiments({ flags: {}, experimentIds: [] });
         expect(() => config.getBaseLlmClient()).toThrow('BaseLlmClient not initialized. Ensure authentication has occurred and ContentGenerator is ready.');
     });
     it('should successfully initialize BaseLlmClient after refreshAuth is called', async () => {
@@ -2305,21 +2454,22 @@ describe('Config Quota & Preview Model Access', () => {
 });
 describe('Config JIT Initialization', () => {
     let config;
-    let mockContextManager;
+    let mockMemoryContextManager;
     beforeEach(() => {
         vi.clearAllMocks();
-        mockContextManager = {
+        mockMemoryContextManager = {
             refresh: vi.fn(),
             getGlobalMemory: vi.fn().mockReturnValue('Global Memory'),
             getExtensionMemory: vi.fn().mockReturnValue('Extension Memory'),
             getEnvironmentMemory: vi
                 .fn()
                 .mockReturnValue('Environment Memory\n\nMCP Instructions'),
+            getUserProjectMemory: vi.fn().mockReturnValue(''),
             getLoadedPaths: vi.fn().mockReturnValue(new Set(['/path/to/GEMINI.md'])),
         };
-        ContextManager.mockImplementation(() => mockContextManager);
+        MemoryContextManager.mockImplementation(() => mockMemoryContextManager);
     });
-    it('should initialize ContextManager, load memory, and delegate to it when experimentalJitContext is enabled', async () => {
+    it('should initialize MemoryContextManager, load memory, and delegate to it when experimentalJitContext is enabled', async () => {
         const params = {
             sessionId: 'test-session',
             targetDir: '/tmp/test',
@@ -2331,12 +2481,13 @@ describe('Config JIT Initialization', () => {
         };
         config = new Config(params);
         await config.initialize();
-        expect(ContextManager).toHaveBeenCalledWith(config);
-        expect(mockContextManager.refresh).toHaveBeenCalled();
+        expect(MemoryContextManager).toHaveBeenCalledWith(config);
+        expect(mockMemoryContextManager.refresh).toHaveBeenCalled();
         expect(config.getUserMemory()).toEqual({
             global: 'Global Memory',
             extension: 'Extension Memory',
             project: 'Environment Memory\n\nMCP Instructions',
+            userProjectMemory: '',
         });
         // Tier 1: system instruction gets only global memory
         expect(config.getSystemInstructionMemory()).toBe('Global Memory');
@@ -2351,11 +2502,11 @@ describe('Config JIT Initialization', () => {
         expect(sessionMemory).toContain('MCP Instructions');
         expect(sessionMemory).toContain('</project_context>');
         expect(sessionMemory).toContain('</loaded_context>');
-        // Verify state update (delegated to ContextManager)
+        // Verify state update (delegated to MemoryContextManager)
         expect(config.getGeminiMdFileCount()).toBe(1);
         expect(config.getGeminiMdFilePaths()).toEqual(['/path/to/GEMINI.md']);
     });
-    it('should NOT initialize ContextManager when experimentalJitContext is disabled', async () => {
+    it('should NOT initialize MemoryContextManager when experimentalJitContext is disabled', async () => {
         const params = {
             sessionId: 'test-session',
             targetDir: '/tmp/test',
@@ -2367,7 +2518,7 @@ describe('Config JIT Initialization', () => {
         };
         config = new Config(params);
         await config.initialize();
-        expect(ContextManager).not.toHaveBeenCalled();
+        expect(MemoryContextManager).not.toHaveBeenCalled();
         expect(config.getUserMemory()).toBe('Initial Memory');
     });
     describe('isMemoryManagerEnabled', () => {
@@ -2641,4 +2792,27 @@ describe('ConfigSchema validation', () => {
         }
     });
 });
+describe('ADKSettings', () => {
+    const baseParams = {
+        sessionId: 'test',
+        targetDir: '.',
+        debugMode: false,
+        model: 'test-model',
+        cwd: '.',
+    };
+    it('should default agentSessionNoninteractiveEnabled to false', () => {
+        const config = new Config(baseParams);
+        expect(config.getAgentSessionNoninteractiveEnabled()).toBe(false);
+    });
+    it('should return provided agentSessionNoninteractiveEnabled', () => {
+        const params = {
+            ...baseParams,
+            adk: {
+                agentSessionNoninteractiveEnabled: true,
+            },
+        };
+        const config = new Config(params);
+        expect(config.getAgentSessionNoninteractiveEnabled()).toBe(true);
+    });
+});
 //# sourceMappingURL=config.test.js.map