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

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

@@ -20,6 +20,7 @@ import { AuthType, createContentGenerator, createContentGeneratorConfig, } from
 import { GeminiClient } from '../core/client.js';
 import { GitService } from '../services/gitService.js';
 import { ShellTool } from '../tools/shell.js';
+import { AgentTool } from '../agents/agent-tool.js';
 import { ReadFileTool } from '../tools/read-file.js';
 import { GrepTool } from '../tools/grep.js';
 import { RipGrepTool, canUseRipgrep } from '../tools/ripGrep.js';
@@ -138,9 +139,6 @@ vi.mock('../agents/registry.js', () => {
     AgentRegistryMock.prototype.getDefinition = vi.fn();
     return { AgentRegistry: AgentRegistryMock };
 });
-vi.mock('../agents/subagent-tool.js', () => ({
-    SubagentTool: vi.fn(),
-}));
 vi.mock('../resources/resource-registry.js', () => ({
     ResourceRegistry: vi.fn(),
 }));
@@ -235,6 +233,61 @@ describe('Server Config (config.ts)', () => {
             expect(config.getMaxAttempts()).toBe(DEFAULT_MAX_ATTEMPTS);
         });
     });
+    describe('setShellExecutionConfig', () => {
+        it('should preserve existing shell execution fields that are not being updated', () => {
+            const config = new Config({
+                ...baseParams,
+                sandbox: {
+                    enabled: true,
+                    command: 'windows-native',
+                    networkAccess: false,
+                },
+                shellBackgroundCompletionBehavior: 'notify',
+            });
+            expect(config.getShellExecutionConfig()).toEqual(expect.objectContaining({
+                sandboxConfig: expect.objectContaining({
+                    enabled: true,
+                    command: 'windows-native',
+                    networkAccess: false,
+                }),
+                backgroundCompletionBehavior: 'notify',
+            }));
+            config.setShellExecutionConfig({
+                terminalWidth: 123,
+                terminalHeight: 45,
+                showColor: true,
+                pager: 'cat',
+                sanitizationConfig: config.sanitizationConfig,
+                sandboxManager: config.sandboxManager,
+            });
+            expect(config.getShellExecutionConfig()).toEqual(expect.objectContaining({
+                terminalWidth: 123,
+                terminalHeight: 45,
+                sandboxConfig: expect.objectContaining({
+                    enabled: true,
+                    command: 'windows-native',
+                    networkAccess: false,
+                }),
+                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
         vi.clearAllMocks();
@@ -515,6 +568,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);
@@ -573,15 +676,32 @@ describe('Server Config (config.ts)', () => {
             };
             vi.mocked(createContentGeneratorConfig).mockResolvedValue(mockContentConfig);
             await config.refreshAuth(authType);
-            expect(createContentGeneratorConfig).toHaveBeenCalledWith(expect.any(Config), authType, {
+            expect(createContentGeneratorConfig).toHaveBeenCalledWith(expect.any(Config), authType, undefined, undefined, undefined, undefined, {
                 clientId: undefined,
                 deviceEndpoint: undefined,
                 tokenEndpoint: undefined,
-            }, undefined, 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, {
+                clientId: undefined,
+                deviceEndpoint: undefined,
+                tokenEndpoint: undefined,
+            }, undefined);
+        });
         it('should reset model availability status', async () => {
             const config = new Config(baseParams);
             const service = config.getModelAvailabilityService();
@@ -1089,6 +1209,13 @@ describe('Server Config (config.ts)', () => {
             const wasReadFileToolRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(ReadFileTool));
             expect(wasReadFileToolRegistered).toBe(false);
         });
+        it('should register AgentTool', async () => {
+            const config = new Config(baseParams);
+            await config.initialize();
+            const registerToolMock = (await vi.importMock('../tools/tool-registry')).ToolRegistry.prototype.registerTool;
+            const wasRegistered = registerToolMock.mock.calls.some((call) => call[0] instanceof vi.mocked(AgentTool));
+            expect(wasRegistered).toBe(true);
+        });
         it('should register EnterPlanModeTool and ExitPlanModeTool when plan is enabled', async () => {
             const params = {
                 ...baseParams,
@@ -1364,6 +1491,75 @@ 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);
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return normalizedInput;
+            });
+            expect(() => config.setSessionId('session-two')).not.toThrow();
+        }
+        finally {
+            realpathMock.mockImplementation((input) => {
+                if (originalImplementation) {
+                    return originalImplementation(input);
+                }
+                const normalizedInput = typeof input === 'string' || Buffer.isBuffer(input)
+                    ? input
+                    : input.toString();
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return normalizedInput;
+            });
+        }
+    });
+    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;
@@ -1399,6 +1595,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');
     });
@@ -1407,6 +1605,8 @@ describe('GemmaModelRouterSettings', () => {
             ...baseParams,
             gemmaModelRouter: {
                 enabled: true,
+                autoStartServer: false,
+                binaryPath: '/custom/lit',
                 classifier: {
                     host: 'http://custom:1234',
                     model: 'custom-gemma',
@@ -1416,6 +1616,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');
     });
@@ -1429,6 +1631,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');
     });
@@ -2337,6 +2541,62 @@ describe('Config Quota & Preview Model Access', () => {
             // Never set => stays null (unknown); getter returns true so UI shows preview
             expect(config.getHasAccessToPreviewModel()).toBe(true);
         });
+        it('should derive quota from remainingFraction when remainingAmount is missing', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [
+                    {
+                        modelId: 'gemini-3-flash-preview',
+                        remainingFraction: 0.96,
+                    },
+                ],
+            });
+            config.setModel('gemini-3-flash-preview');
+            mockCoreEvents.emitQuotaChanged.mockClear();
+            await config.refreshUserQuota();
+            // Normalized: limit=100, remaining=96
+            expect(mockCoreEvents.emitQuotaChanged).toHaveBeenCalledWith(96, 100, undefined);
+            expect(config.getQuotaRemaining()).toBe(96);
+            expect(config.getQuotaLimit()).toBe(100);
+        });
+        it('should store quota from remainingFraction when remainingFraction is 0', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [
+                    {
+                        modelId: 'gemini-3-pro-preview',
+                        remainingFraction: 0,
+                    },
+                ],
+            });
+            config.setModel('gemini-3-pro-preview');
+            mockCoreEvents.emitQuotaChanged.mockClear();
+            await config.refreshUserQuota();
+            // remaining=0, limit=100 but limit>0 check still passes
+            // however remaining=0 means 0% remaining = 100% used
+            expect(config.getQuotaRemaining()).toBe(0);
+            expect(config.getQuotaLimit()).toBe(100);
+        });
+        it('should emit QuotaChanged when model is switched via setModel', async () => {
+            mockCodeAssistServer.retrieveUserQuota.mockResolvedValue({
+                buckets: [
+                    {
+                        modelId: 'gemini-2.5-pro',
+                        remainingAmount: '10',
+                        remainingFraction: 0.2,
+                    },
+                    {
+                        modelId: 'gemini-2.5-flash',
+                        remainingAmount: '80',
+                        remainingFraction: 0.8,
+                    },
+                ],
+            });
+            config.setModel('auto-gemini-2.5');
+            await config.refreshUserQuota();
+            mockCoreEvents.emitQuotaChanged.mockClear();
+            // Switch to a specific model — should re-emit quota for that model
+            config.setModel('gemini-2.5-pro');
+            expect(mockCoreEvents.emitQuotaChanged).toHaveBeenCalledWith(10, 50, undefined);
+        });
     });
     describe('refreshUserQuotaIfStale', () => {
         beforeEach(() => {
@@ -2521,7 +2781,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 ~/.cell-cli directory to the workspace when enabled', async () => {
+            // The prompt-driven memoryV2 mode does not broaden the workspace
+            // to include the global ~/.cell-cli/ directory. Cross-project personal
+            // preferences are routed to ~/.cell-cli/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 ~/.cell-cli/GEMINI.md file', async () => {
+            // Surgical allowlist: when memoryV2 is on, the prompt routes
+            // cross-project personal preferences to ~/.cell-cli/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 ~/.cell-cli/ (least privilege)', async () => {
+            // The allowlist is surgical: only ~/.cell-cli/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',
@@ -2531,19 +2881,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', () => {