@google/gemini-cli-core 0.39.0-preview.2 → 0.40.0-preview.0

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

@@ -270,6 +270,22 @@ describe('Server Config (config.ts)', () => {
                 backgroundCompletionBehavior: 'notify',
             }));
         });
+        it('should ignore properties that are explicitly undefined and preserve existing values', () => {
+            const config = new Config(baseParams);
+            config.setShellExecutionConfig({
+                terminalWidth: 80,
+                showColor: true,
+            });
+            expect(config.getShellExecutionConfig().terminalWidth).toBe(80);
+            expect(config.getShellExecutionConfig().showColor).toBe(true);
+            // Provide undefined for terminalWidth, which should be ignored
+            config.setShellExecutionConfig({
+                terminalWidth: undefined,
+                showColor: false,
+            });
+            expect(config.getShellExecutionConfig().terminalWidth).toBe(80); // Should still be 80, not undefined
+            expect(config.getShellExecutionConfig().showColor).toBe(false); // Should be updated
+        });
     });
     beforeEach(() => {
         // Reset mocks if necessary
@@ -551,6 +567,56 @@ describe('Server Config (config.ts)', () => {
                 expect(config.getGemini31FlashLiteLaunchedSync()).toBe(true);
             });
         });
+        describe('getProModelNoAccessSync', () => {
+            it('should return experiment value for AuthType.LOGIN_WITH_GOOGLE', async () => {
+                vi.mocked(getExperiments).mockResolvedValue({
+                    experimentIds: [],
+                    flags: {
+                        [ExperimentFlags.PRO_MODEL_NO_ACCESS]: {
+                            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.getProModelNoAccessSync()).toBe(true);
+            });
+            it('should return experiment value for AuthType.COMPUTE_ADC', async () => {
+                vi.mocked(getExperiments).mockResolvedValue({
+                    experimentIds: [],
+                    flags: {
+                        [ExperimentFlags.PRO_MODEL_NO_ACCESS]: {
+                            boolValue: true,
+                        },
+                    },
+                });
+                const config = new Config(baseParams);
+                vi.mocked(createContentGeneratorConfig).mockResolvedValue({
+                    authType: AuthType.COMPUTE_ADC,
+                });
+                await config.refreshAuth(AuthType.COMPUTE_ADC);
+                expect(config.getProModelNoAccessSync()).toBe(true);
+            });
+            it('should return false for other auth types even if experiment is true', async () => {
+                vi.mocked(getExperiments).mockResolvedValue({
+                    experimentIds: [],
+                    flags: {
+                        [ExperimentFlags.PRO_MODEL_NO_ACCESS]: {
+                            boolValue: true,
+                        },
+                    },
+                });
+                const config = new Config(baseParams);
+                vi.mocked(createContentGeneratorConfig).mockResolvedValue({
+                    authType: AuthType.USE_GEMINI,
+                });
+                await config.refreshAuth(AuthType.USE_GEMINI);
+                expect(config.getProModelNoAccessSync()).toBe(false);
+            });
+        });
         describe('getRequestTimeoutMs', () => {
             it('should return undefined if the flag is not set', () => {
                 const config = new Config(baseParams);
@@ -609,11 +675,24 @@ describe('Server Config (config.ts)', () => {
             };
             vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
             await config.refreshAuth(authType);
-            expect(createContentGeneratorConfig).toHaveBeenCalledWith(config, authType, undefined, undefined, undefined);
+            expect(createContentGeneratorConfig).toHaveBeenCalledWith(config, authType, undefined, undefined, undefined, undefined);
             // Verify that contentGeneratorConfig is updated
             expect(config.getContentGeneratorConfig()).toEqual(mockContentConfig);
             expect(GeminiClient).toHaveBeenCalledWith(config);
         });
+        it('should pass Vertex AI routing settings when refreshing auth', async () => {
+            const vertexAiRouting = {
+                requestType: 'shared',
+                sharedRequestType: 'priority',
+            };
+            const config = new Config({
+                ...baseParams,
+                vertexAiRouting,
+            });
+            vi.mocked(createContentGeneratorConfig).mockResolvedValue({});
+            await config.refreshAuth(AuthType.USE_VERTEX_AI);
+            expect(createContentGeneratorConfig).toHaveBeenCalledWith(config, AuthType.USE_VERTEX_AI, undefined, undefined, undefined, vertexAiRouting);
+        });
         it('should reset model availability status', async () => {
             const config = new Config(baseParams);
             const service = config.getModelAvailabilityService();
@@ -1391,6 +1470,72 @@ describe('Server Config (config.ts)', () => {
         expect(config1.topicState.getTopic()).toBe('Topic 1');
         expect(config2.topicState.getTopic()).toBe('Topic 2');
     });
+    it('updates storage session-scoped directories when the sessionId changes', async () => {
+        const config = new Config({
+            ...baseParams,
+            sessionId: 'session-one',
+            plan: true,
+        });
+        await config.initialize();
+        const tempDir = config.storage.getProjectTempDir();
+        const oldPlansDir = path.join(tempDir, 'session-one', 'plans');
+        const oldTrackerService = config.getTrackerService();
+        config.setSessionId('session-two');
+        expect(config.getSessionId()).toBe('session-two');
+        expect(config.storage.getProjectTempPlansDir()).toBe(path.join(tempDir, 'session-two', 'plans'));
+        expect(config.storage.getProjectTempTrackerDir()).toBe(path.join(tempDir, 'session-two', 'tracker'));
+        expect(config.getTrackerService()).not.toBe(oldTrackerService);
+        expect(config.getTrackerService().trackerDir).toBe(path.join(tempDir, 'session-two', 'tracker'));
+        expect(config.getWorkspaceContext().getDirectories()).not.toContain(oldPlansDir);
+    });
+    it('does not throw when changing sessions before the previous plans dir exists', async () => {
+        const config = new Config({
+            ...baseParams,
+            sessionId: 'session-one',
+            plan: true,
+        });
+        await config.initialize();
+        const missingPlansDir = config.storage.getProjectTempPlansDir();
+        const realpathMock = vi.mocked(fs.realpathSync);
+        const originalImplementation = realpathMock.getMockImplementation();
+        try {
+            realpathMock.mockImplementation((input) => {
+                const normalizedInput = typeof input === 'string' || Buffer.isBuffer(input)
+                    ? input
+                    : input.toString();
+                if (normalizedInput === missingPlansDir) {
+                    const error = new Error(`ENOENT: no such file or directory, ${normalizedInput}`);
+                    Object.assign(error, { code: 'ENOENT' });
+                    throw error;
+                }
+                if (originalImplementation) {
+                    return originalImplementation(input);
+                }
+                return normalizedInput;
+            });
+            expect(() => config.setSessionId('session-two')).not.toThrow();
+        }
+        finally {
+            realpathMock.mockImplementation((input) => {
+                if (originalImplementation) {
+                    return originalImplementation(input);
+                }
+                return typeof input === 'string' || Buffer.isBuffer(input)
+                    ? input
+                    : input.toString();
+            });
+        }
+    });
+    it('clears the approved plan when starting a new session', () => {
+        const config = new Config({
+            ...baseParams,
+            sessionId: 'session-one',
+        });
+        config.setApprovedPlanPath('/tmp/session-one/plans/approved.md');
+        expect(() => config.resetNewSessionState('session-two')).not.toThrow();
+        expect(config.getSessionId()).toBe('session-two');
+        expect(config.getApprovedPlanPath()).toBeUndefined();
+    });
 });
 describe('GemmaModelRouterSettings', () => {
     const MODEL = DEFAULT_GEMINI_MODEL;
@@ -1426,6 +1571,8 @@ describe('GemmaModelRouterSettings', () => {
         const config = new Config(baseParams);
         const settings = config.getGemmaModelRouterSettings();
         expect(settings.enabled).toBe(false);
+        expect(settings.autoStartServer).toBe(true);
+        expect(settings.binaryPath).toBe('');
         expect(settings.classifier?.host).toBe('http://localhost:9379');
         expect(settings.classifier?.model).toBe('gemma3-1b-gpu-custom');
     });
@@ -1434,6 +1581,8 @@ describe('GemmaModelRouterSettings', () => {
             ...baseParams,
             gemmaModelRouter: {
                 enabled: true,
+                autoStartServer: false,
+                binaryPath: '/custom/lit',
                 classifier: {
                     host: 'http://custom:1234',
                     model: 'custom-gemma',
@@ -1443,6 +1592,8 @@ describe('GemmaModelRouterSettings', () => {
         const config = new Config(params);
         const settings = config.getGemmaModelRouterSettings();
         expect(settings.enabled).toBe(true);
+        expect(settings.autoStartServer).toBe(false);
+        expect(settings.binaryPath).toBe('/custom/lit');
         expect(settings.classifier?.host).toBe('http://custom:1234');
         expect(settings.classifier?.model).toBe('custom-gemma');
     });
@@ -1456,6 +1607,8 @@ describe('GemmaModelRouterSettings', () => {
         const config = new Config(params);
         const settings = config.getGemmaModelRouterSettings();
         expect(settings.enabled).toBe(true);
+        expect(settings.autoStartServer).toBe(true);
+        expect(settings.binaryPath).toBe('');
         expect(settings.classifier?.host).toBe('http://localhost:9379');
         expect(settings.classifier?.model).toBe('gemma3-1b-gpu-custom');
     });
@@ -2604,7 +2757,97 @@ describe('Config JIT Initialization', () => {
         expect(MemoryContextManager).not.toHaveBeenCalled();
         expect(config.getUserMemory()).toBe('Initial Memory');
     });
-    describe('isMemoryManagerEnabled', () => {
+    describe('isMemoryV2Enabled', () => {
+        it('should default to true', () => {
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+            };
+            config = new Config(params);
+            expect(config.isMemoryV2Enabled()).toBe(true);
+        });
+        it('should return false when experimentalMemoryV2 is explicitly false', () => {
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                experimentalMemoryV2: false,
+            };
+            config = new Config(params);
+            expect(config.isMemoryV2Enabled()).toBe(false);
+        });
+        it('should return true when experimentalMemoryV2 is true', () => {
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                experimentalMemoryV2: true,
+            };
+            config = new Config(params);
+            expect(config.isMemoryV2Enabled()).toBe(true);
+        });
+        it('should NOT add the global ~/.gemini directory to the workspace when enabled', async () => {
+            // The prompt-driven memoryV2 mode does not broaden the workspace
+            // to include the global ~/.gemini/ directory. Cross-project personal
+            // preferences are routed to ~/.gemini/GEMINI.md via the surgical
+            // isPathAllowed allowlist instead — see the next two tests.
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                experimentalMemoryV2: true,
+            };
+            config = new Config(params);
+            await config.initialize();
+            const directories = config.getWorkspaceContext().getDirectories();
+            expect(directories).not.toContain(Storage.getGlobalGeminiDir());
+        });
+        it('should allow isPathAllowed to write the global ~/.gemini/GEMINI.md file', async () => {
+            // Surgical allowlist: when memoryV2 is on, the prompt routes
+            // cross-project personal preferences to ~/.gemini/GEMINI.md, so the
+            // agent must be able to edit that exact file via edit/write_file.
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                experimentalMemoryV2: true,
+            };
+            config = new Config(params);
+            await config.initialize();
+            const globalGeminiMdPath = path.join(Storage.getGlobalGeminiDir(), 'GEMINI.md');
+            expect(config.isPathAllowed(globalGeminiMdPath)).toBe(true);
+        });
+        it('should NOT allow isPathAllowed to write other files under ~/.gemini/ (least privilege)', async () => {
+            // The allowlist is surgical: only ~/.gemini/GEMINI.md is reachable.
+            // settings.json, keybindings.json, credentials, etc. remain disallowed.
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                experimentalMemoryV2: true,
+            };
+            config = new Config(params);
+            await config.initialize();
+            const globalDir = Storage.getGlobalGeminiDir();
+            expect(config.isPathAllowed(path.join(globalDir, 'settings.json'))).toBe(false);
+            expect(config.isPathAllowed(path.join(globalDir, 'keybindings.json'))).toBe(false);
+            expect(config.isPathAllowed(path.join(globalDir, 'oauth_creds.json'))).toBe(false);
+        });
+    });
+    describe('isAutoMemoryEnabled', () => {
         it('should default to false', () => {
             const params = {
                 sessionId: 'test-session',
@@ -2614,19 +2857,32 @@ describe('Config JIT Initialization', () => {
                 cwd: '/tmp/test',
             };
             config = new Config(params);
-            expect(config.isMemoryManagerEnabled()).toBe(false);
+            expect(config.isAutoMemoryEnabled()).toBe(false);
+        });
+        it('should return true when experimentalAutoMemory is true', () => {
+            const params = {
+                sessionId: 'test-session',
+                targetDir: '/tmp/test',
+                debugMode: false,
+                model: 'test-model',
+                cwd: '/tmp/test',
+                experimentalAutoMemory: true,
+            };
+            config = new Config(params);
+            expect(config.isAutoMemoryEnabled()).toBe(true);
         });
-        it('should return true when experimentalMemoryManager is true', () => {
+        it('should be independent of experimentalMemoryV2', () => {
             const params = {
                 sessionId: 'test-session',
                 targetDir: '/tmp/test',
                 debugMode: false,
                 model: 'test-model',
                 cwd: '/tmp/test',
-                experimentalMemoryManager: true,
+                experimentalMemoryV2: true,
             };
             config = new Config(params);
-            expect(config.isMemoryManagerEnabled()).toBe(true);
+            expect(config.isMemoryV2Enabled()).toBe(true);
+            expect(config.isAutoMemoryEnabled()).toBe(false);
         });
     });
     describe('reloadSkills', () => {