@machina.ai/cell-cli 1.22.5-rc1 → 1.25.0-rc3

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

@@ -6,19 +6,17 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { DEFAULT_FILE_FILTERING_OPTIONS, OutputFormat, SHELL_TOOL_NAME, WRITE_FILE_TOOL_NAME, EDIT_TOOL_NAME, WEB_FETCH_TOOL_NAME, debugLogger, } from '@google/gemini-cli-core';
+import { DEFAULT_FILE_FILTERING_OPTIONS, OutputFormat, SHELL_TOOL_NAME, WRITE_FILE_TOOL_NAME, EDIT_TOOL_NAME, WEB_FETCH_TOOL_NAME, debugLogger, ApprovalMode, } from '@google/gemini-cli-core';
 import { loadCliConfig, parseArguments } from './config.js';
 import * as ServerConfig from '@google/gemini-cli-core';
 import { isWorkspaceTrusted } from './trustedFolders.js';
 import { ExtensionManager } from './extension-manager.js';
 import { RESUME_LATEST } from '../utils/sessionUtils.js';
 vi.mock('./trustedFolders.js', () => ({
-    isWorkspaceTrusted: vi
-        .fn()
-        .mockReturnValue({ isTrusted: true, source: 'file' }), // Default to trusted
+    isWorkspaceTrusted: vi.fn(() => ({ isTrusted: true, source: 'file' })), // Default to trusted
 }));
 vi.mock('./sandboxConfig.js', () => ({
-    loadSandboxConfig: vi.fn().mockResolvedValue(undefined),
+    loadSandboxConfig: vi.fn(async () => undefined),
 }));
 vi.mock('fs', async (importOriginal) => {
     const actualFs = await importOriginal();
@@ -92,6 +90,12 @@ vi.mock('@google/gemini-cli-core', async () => {
             respectGitIgnore: true,
             respectGeminiIgnore: true,
         },
+        createPolicyEngineConfig: vi.fn(async () => ({
+            rules: [],
+            checkers: [],
+            defaultDecision: ServerConfig.PolicyDecision.ASK_USER,
+            approvalMode: ServerConfig.ApprovalMode.DEFAULT,
+        })),
     };
 });
 vi.mock('./extension-manager.js');
@@ -523,13 +527,7 @@ describe('loadCliConfig', () => {
         const config = await loadCliConfig(settings, 'test-session', argv);
         expect(config.getFileFilteringRespectGitIgnore()).toBe(DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore);
         expect(config.getFileFilteringRespectGeminiIgnore()).toBe(DEFAULT_FILE_FILTERING_OPTIONS.respectGeminiIgnore);
-    });
-    it('should default enableMessageBusIntegration to true when unconfigured', async () => {
-        process.argv = ['node', 'script.js'];
-        const argv = await parseArguments({});
-        const settings = {};
-        const config = await loadCliConfig(settings, 'test-session', argv);
-        expect(config['enableMessageBusIntegration']).toBe(true);
+        expect(config.getApprovalMode()).toBe(ApprovalMode.DEFAULT);
     });
 });
 describe('Hierarchical Memory Loading (config.ts) - Placeholder Suite', () => {
@@ -896,7 +894,7 @@ describe('Approval mode tool exclusion logic', () => {
                 disableYoloMode: true,
             },
         };
-        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode when it is disabled by settings');
+        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode since it is disabled by your admin');
     });
     it('should throw an error for invalid approval mode values in loadCliConfig', async () => {
         // Create a mock argv with an invalid approval mode that bypasses argument parsing validation
@@ -1950,4 +1948,217 @@ describe('Telemetry configuration via environment variables', () => {
         expect(config.getTelemetryLogPromptsEnabled()).toBe(false);
     });
 });
+describe('PolicyEngine nonInteractive wiring', () => {
+    const originalIsTTY = process.stdin.isTTY;
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+    });
+    afterEach(() => {
+        process.stdin.isTTY = originalIsTTY;
+        vi.restoreAllMocks();
+    });
+    it('should set nonInteractive to true in one-shot mode', async () => {
+        process.stdin.isTTY = true;
+        process.argv = ['node', 'script.js', 'echo hello']; // Positional query makes it one-shot
+        const argv = await parseArguments({});
+        const config = await loadCliConfig({}, 'test-session', argv);
+        expect(config.isInteractive()).toBe(false);
+        expect(config.getPolicyEngine()
+            .nonInteractive).toBe(true);
+    });
+    it('should set nonInteractive to false in interactive mode', async () => {
+        process.stdin.isTTY = true;
+        process.argv = ['node', 'script.js'];
+        const argv = await parseArguments({});
+        const config = await loadCliConfig({}, 'test-session', argv);
+        expect(config.isInteractive()).toBe(true);
+        expect(config.getPolicyEngine()
+            .nonInteractive).toBe(false);
+    });
+});
+describe('Policy Engine Integration in loadCliConfig', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+        vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.restoreAllMocks();
+    });
+    it('should pass merged allowed tools from CLI and settings to createPolicyEngineConfig', async () => {
+        process.argv = ['node', 'script.js', '--allowed-tools', 'cli-tool'];
+        const settings = { tools: { allowed: ['settings-tool'] } };
+        const argv = await parseArguments({});
+        await loadCliConfig(settings, 'test-session', argv);
+        expect(ServerConfig.createPolicyEngineConfig).toHaveBeenCalledWith(expect.objectContaining({
+            tools: expect.objectContaining({
+                allowed: expect.arrayContaining(['cli-tool']),
+            }),
+        }), expect.anything());
+    });
+    it('should pass merged exclude tools from CLI logic and settings to createPolicyEngineConfig', async () => {
+        process.stdin.isTTY = false; // Non-interactive to trigger default excludes
+        process.argv = ['node', 'script.js', '-p', 'test'];
+        const settings = { tools: { exclude: ['settings-exclude'] } };
+        const argv = await parseArguments({});
+        await loadCliConfig(settings, 'test-session', argv);
+        // In non-interactive mode, ShellTool, etc. are excluded
+        expect(ServerConfig.createPolicyEngineConfig).toHaveBeenCalledWith(expect.objectContaining({
+            tools: expect.objectContaining({
+                exclude: expect.arrayContaining([SHELL_TOOL_NAME]),
+            }),
+        }), expect.anything());
+    });
+});
+describe('loadCliConfig disableYoloMode', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+        vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+        vi.mocked(isWorkspaceTrusted).mockReturnValue({
+            isTrusted: true,
+            source: undefined,
+        });
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.restoreAllMocks();
+    });
+    it('should allow auto_edit mode even if yolo mode is disabled', async () => {
+        process.argv = ['node', 'script.js', '--approval-mode=auto_edit'];
+        const argv = await parseArguments({});
+        const settings = {
+            security: { disableYoloMode: true },
+        };
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.getApprovalMode()).toBe(ApprovalMode.AUTO_EDIT);
+    });
+    it('should throw if YOLO mode is attempted when disableYoloMode is true', async () => {
+        process.argv = ['node', 'script.js', '--yolo'];
+        const argv = await parseArguments({});
+        const settings = {
+            security: { disableYoloMode: true },
+        };
+        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode since it is disabled by your admin');
+    });
+});
+describe('loadCliConfig secureModeEnabled', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+        vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+        vi.mocked(isWorkspaceTrusted).mockReturnValue({
+            isTrusted: true,
+            source: undefined,
+        });
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.restoreAllMocks();
+    });
+    it('should throw an error if YOLO mode is attempted when secureModeEnabled is true', async () => {
+        process.argv = ['node', 'script.js', '--yolo'];
+        const argv = await parseArguments({});
+        const settings = {
+            admin: {
+                secureModeEnabled: true,
+            },
+        };
+        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode since it is disabled by your admin');
+    });
+    it('should throw an error if approval-mode=yolo is attempted when secureModeEnabled is true', async () => {
+        process.argv = ['node', 'script.js', '--approval-mode=yolo'];
+        const argv = await parseArguments({});
+        const settings = {
+            admin: {
+                secureModeEnabled: true,
+            },
+        };
+        await expect(loadCliConfig(settings, 'test-session', argv)).rejects.toThrow('Cannot start in YOLO mode since it is disabled by your admin');
+    });
+    it('should set disableYoloMode to true when secureModeEnabled is true', async () => {
+        process.argv = ['node', 'script.js'];
+        const argv = await parseArguments({});
+        const settings = {
+            admin: {
+                secureModeEnabled: true,
+            },
+        };
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.isYoloModeDisabled()).toBe(true);
+    });
+});
+describe('loadCliConfig mcpEnabled', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        vi.mocked(os.homedir).mockReturnValue('/mock/home/user');
+        vi.stubEnv('GEMINI_API_KEY', 'test-api-key');
+        vi.spyOn(ExtensionManager.prototype, 'getExtensions').mockReturnValue([]);
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+        vi.restoreAllMocks();
+    });
+    const mcpSettings = {
+        mcp: {
+            serverCommand: 'mcp-server',
+            allowed: ['serverA'],
+            excluded: ['serverB'],
+        },
+        mcpServers: { serverA: { url: 'http://a' } },
+    };
+    it('should enable MCP by default', async () => {
+        process.argv = ['node', 'script.js'];
+        const argv = await parseArguments({});
+        const settings = { ...mcpSettings };
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.getMcpEnabled()).toBe(true);
+        expect(config.getMcpServerCommand()).toBe('mcp-server');
+        expect(config.getMcpServers()).toEqual({ serverA: { url: 'http://a' } });
+        expect(config.getAllowedMcpServers()).toEqual(['serverA']);
+        expect(config.getBlockedMcpServers()).toEqual(['serverB']);
+    });
+    it('should disable MCP when mcpEnabled is false', async () => {
+        process.argv = ['node', 'script.js'];
+        const argv = await parseArguments({});
+        const settings = {
+            ...mcpSettings,
+            admin: {
+                mcp: {
+                    enabled: false,
+                },
+            },
+        };
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.getMcpEnabled()).toBe(false);
+        expect(config.getMcpServerCommand()).toBeUndefined();
+        expect(config.getMcpServers()).toEqual({});
+        expect(config.getAllowedMcpServers()).toEqual([]);
+        expect(config.getBlockedMcpServers()).toEqual([]);
+    });
+    it('should enable MCP when mcpEnabled is true', async () => {
+        process.argv = ['node', 'script.js'];
+        const argv = await parseArguments({});
+        const settings = {
+            ...mcpSettings,
+            admin: {
+                mcp: {
+                    enabled: true,
+                },
+            },
+        };
+        const config = await loadCliConfig(settings, 'test-session', argv);
+        expect(config.getMcpEnabled()).toBe(true);
+        expect(config.getMcpServerCommand()).toBe('mcp-server');
+        expect(config.getMcpServers()).toEqual({ serverA: { url: 'http://a' } });
+        expect(config.getAllowedMcpServers()).toEqual(['serverA']);
+        expect(config.getBlockedMcpServers()).toEqual(['serverB']);
+    });
+});
 //# sourceMappingURL=config.test.js.map