@quantum-ai/gemini-cli 0.45.8 → 0.45.9

package/dist/config/mcp/mcpServerEnablement.js

@@ -0,0 +1,278 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { Storage, coreEvents } from '@google/gemini-cli-core';
+/**
+ * Normalize a server ID to canonical lowercase form.
+ */
+export function normalizeServerId(serverId) {
+    return serverId.toLowerCase().trim();
+}
+/**
+ * Check if a server ID is in a settings list (with backward compatibility).
+ * Handles case-insensitive matching and plain name fallback for ext: servers.
+ */
+export function isInSettingsList(serverId, list) {
+    const normalizedId = normalizeServerId(serverId);
+    const normalizedList = list.map(normalizeServerId);
+    // Exact canonical match
+    if (normalizedList.includes(normalizedId)) {
+        return { found: true };
+    }
+    // Backward compat: for ext: servers, check if plain name matches
+    if (normalizedId.startsWith('ext:')) {
+        const plainName = normalizedId.split(':').pop();
+        if (plainName && normalizedList.includes(plainName)) {
+            return {
+                found: true,
+                deprecationWarning: `Settings reference '${plainName}' matches extension server '${serverId}'. ` +
+                    `Update your settings to use the full identifier '${serverId}' instead.`,
+            };
+        }
+    }
+    return { found: false };
+}
+/**
+ * Single source of truth for whether a server can be loaded.
+ * Used by: isAllowedMcpServer(), connectServer(), CLI handlers, slash handlers.
+ *
+ * Uses callbacks instead of direct enablementManager reference to keep
+ * packages/core independent of packages/cli.
+ */
+export async function canLoadServer(serverId, config) {
+    const normalizedId = normalizeServerId(serverId);
+    // 1. Admin kill switch
+    if (!config.adminMcpEnabled) {
+        return {
+            allowed: false,
+            reason: 'MCP servers are disabled by administrator. Check admin settings or contact your admin.',
+            blockType: 'admin',
+        };
+    }
+    // 2. Allowlist check
+    if (config.allowedList !== undefined) {
+        const { found, deprecationWarning } = isInSettingsList(normalizedId, config.allowedList);
+        if (deprecationWarning) {
+            coreEvents.emitFeedback('warning', deprecationWarning);
+        }
+        if (!found) {
+            return {
+                allowed: false,
+                reason: `Server '${serverId}' is not in mcp.allowed list. Add it to settings.json mcp.allowed array to enable.`,
+                blockType: 'allowlist',
+            };
+        }
+    }
+    // 3. Excludelist check
+    if (config.excludedList) {
+        const { found, deprecationWarning } = isInSettingsList(normalizedId, config.excludedList);
+        if (deprecationWarning) {
+            coreEvents.emitFeedback('warning', deprecationWarning);
+        }
+        if (found) {
+            return {
+                allowed: false,
+                reason: `Server '${serverId}' is blocked by mcp.excluded. Remove it from settings.json mcp.excluded array to enable.`,
+                blockType: 'excludelist',
+            };
+        }
+    }
+    // 4. Session disable check (before file-based enablement)
+    if (config.enablement?.isSessionDisabled(normalizedId)) {
+        return {
+            allowed: false,
+            reason: `Server '${serverId}' is disabled for this session. Run 'gemini mcp enable ${serverId} --session' to clear.`,
+            blockType: 'session',
+        };
+    }
+    // 5. File-based enablement check
+    if (config.enablement &&
+        !(await config.enablement.isFileEnabled(normalizedId))) {
+        return {
+            allowed: false,
+            reason: `Server '${serverId}' is disabled. Run 'gemini mcp enable ${serverId}' to enable.`,
+            blockType: 'enablement',
+        };
+    }
+    return { allowed: true };
+}
+const MCP_ENABLEMENT_FILENAME = 'mcp-server-enablement.json';
+/**
+ * McpServerEnablementManager
+ *
+ * Manages the enabled/disabled state of MCP servers.
+ * Uses a simplified format compared to ExtensionEnablementManager.
+ * Supports both persistent (file) and session-only (in-memory) states.
+ *
+ * NOTE: Use getInstance() to get the singleton instance. This ensures
+ * session state (sessionDisabled Set) is shared across all code paths.
+ */
+export class McpServerEnablementManager {
+    static instance = null;
+    configFilePath;
+    configDir;
+    sessionDisabled = new Set();
+    /**
+     * Get the singleton instance.
+     */
+    static getInstance() {
+        if (!McpServerEnablementManager.instance) {
+            McpServerEnablementManager.instance = new McpServerEnablementManager();
+        }
+        return McpServerEnablementManager.instance;
+    }
+    /**
+     * Reset the singleton instance (for testing only).
+     */
+    static resetInstance() {
+        McpServerEnablementManager.instance = null;
+    }
+    constructor() {
+        this.configDir = Storage.getGlobalGeminiDir();
+        this.configFilePath = path.join(this.configDir, MCP_ENABLEMENT_FILENAME);
+    }
+    /**
+     * Check if server is enabled in FILE (persistent config only).
+     * Does NOT include session state.
+     */
+    async isFileEnabled(serverName) {
+        const config = await this.readConfig();
+        const state = config[normalizeServerId(serverName)];
+        return state?.enabled ?? true;
+    }
+    /**
+     * Check if server is session-disabled.
+     */
+    isSessionDisabled(serverName) {
+        return this.sessionDisabled.has(normalizeServerId(serverName));
+    }
+    /**
+     * Check effective enabled state (combines file + session).
+     * Convenience method; canLoadServer() uses separate callbacks for granular blockType.
+     */
+    async isEffectivelyEnabled(serverName) {
+        if (this.isSessionDisabled(serverName)) {
+            return false;
+        }
+        return this.isFileEnabled(serverName);
+    }
+    /**
+     * Enable a server persistently.
+     * Removes the server from config file (defaults to enabled).
+     */
+    async enable(serverName) {
+        const normalizedName = normalizeServerId(serverName);
+        const config = await this.readConfig();
+        if (normalizedName in config) {
+            delete config[normalizedName];
+            await this.writeConfig(config);
+        }
+    }
+    /**
+     * Disable a server persistently.
+     * Adds server to config file with enabled: false.
+     */
+    async disable(serverName) {
+        const config = await this.readConfig();
+        config[normalizeServerId(serverName)] = { enabled: false };
+        await this.writeConfig(config);
+    }
+    /**
+     * Disable a server for current session only (in-memory).
+     */
+    disableForSession(serverName) {
+        this.sessionDisabled.add(normalizeServerId(serverName));
+    }
+    /**
+     * Clear session disable for a server.
+     */
+    clearSessionDisable(serverName) {
+        this.sessionDisabled.delete(normalizeServerId(serverName));
+    }
+    /**
+     * Get display state for a specific server (for UI).
+     */
+    async getDisplayState(serverName) {
+        const isSessionDisabled = this.isSessionDisabled(serverName);
+        const isPersistentDisabled = !(await this.isFileEnabled(serverName));
+        return {
+            enabled: !isSessionDisabled && !isPersistentDisabled,
+            isSessionDisabled,
+            isPersistentDisabled,
+        };
+    }
+    /**
+     * Get all display states (for UI listing).
+     */
+    async getAllDisplayStates(serverIds) {
+        const result = {};
+        for (const serverId of serverIds) {
+            result[normalizeServerId(serverId)] =
+                await this.getDisplayState(serverId);
+        }
+        return result;
+    }
+    /**
+     * Get enablement callbacks for passing to core.
+     */
+    getEnablementCallbacks() {
+        return {
+            isSessionDisabled: (id) => this.isSessionDisabled(id),
+            isFileEnabled: (id) => this.isFileEnabled(id),
+        };
+    }
+    /**
+     * Auto-enable any disabled MCP servers by name.
+     * Returns server names that were actually re-enabled.
+     */
+    async autoEnableServers(serverNames) {
+        const enabledServers = [];
+        for (const serverName of serverNames) {
+            const normalizedName = normalizeServerId(serverName);
+            const state = await this.getDisplayState(normalizedName);
+            let wasDisabled = false;
+            if (state.isPersistentDisabled) {
+                await this.enable(normalizedName);
+                wasDisabled = true;
+            }
+            if (state.isSessionDisabled) {
+                this.clearSessionDisable(normalizedName);
+                wasDisabled = true;
+            }
+            if (wasDisabled) {
+                enabledServers.push(serverName);
+            }
+        }
+        return enabledServers;
+    }
+    /**
+     * Read config from file asynchronously.
+     */
+    async readConfig() {
+        try {
+            const content = await fs.readFile(this.configFilePath, 'utf-8');
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                'code' in error &&
+                error.code === 'ENOENT') {
+                return {};
+            }
+            coreEvents.emitFeedback('error', 'Failed to read MCP server enablement config.', error);
+            return {};
+        }
+    }
+    /**
+     * Write config to file asynchronously.
+     */
+    async writeConfig(config) {
+        await fs.mkdir(this.configDir, { recursive: true });
+        await fs.writeFile(this.configFilePath, JSON.stringify(config, null, 2));
+    }
+}

package/dist/config/policy.js

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createPolicyEngineConfig as createCorePolicyEngineConfig, createPolicyUpdater as createCorePolicyUpdater, PolicyIntegrityManager, IntegrityStatus, Storage, writeToStderr, debugLogger, } from '@google/gemini-cli-core';
+/**
+ * Temporary flag to automatically accept workspace policies to reduce friction.
+ * Exported as 'let' to allow monkey patching in tests via the setter.
+ */
+export let autoAcceptWorkspacePolicies = true;
+/**
+ * Sets the autoAcceptWorkspacePolicies flag.
+ * Used primarily for testing purposes.
+ */
+export function setAutoAcceptWorkspacePolicies(value) {
+    autoAcceptWorkspacePolicies = value;
+}
+/**
+ * Temporary flag to disable workspace level policies altogether.
+ * Exported as 'let' to allow monkey patching in tests via the setter.
+ */
+export let disableWorkspacePolicies = true;
+/**
+ * Sets the disableWorkspacePolicies flag.
+ * Used primarily for testing purposes.
+ */
+export function setDisableWorkspacePolicies(value) {
+    disableWorkspacePolicies = value;
+}
+export async function createPolicyEngineConfig(settings, approvalMode, workspacePoliciesDir, interactive = true) {
+    // Explicitly construct PolicySettings from Settings to ensure type safety
+    // and avoid accidental leakage of other settings properties.
+    const policySettings = {
+        mcp: settings.mcp,
+        tools: settings.tools,
+        mcpServers: settings.mcpServers,
+        policyPaths: settings.policyPaths,
+        adminPolicyPaths: settings.adminPolicyPaths,
+        workspacePoliciesDir,
+        disableAlwaysAllow: settings.security?.disableAlwaysAllow ||
+            settings.admin?.secureModeEnabled,
+    };
+    return createCorePolicyEngineConfig(policySettings, approvalMode, undefined, interactive);
+}
+export function createPolicyUpdater(policyEngine, messageBus, storage) {
+    return createCorePolicyUpdater(policyEngine, messageBus, storage);
+}
+/**
+ * Resolves the workspace policy state by checking folder trust and policy integrity.
+ */
+export async function resolveWorkspacePolicyState(options) {
+    const { cwd, trustedFolder, interactive } = options;
+    let workspacePoliciesDir;
+    let policyUpdateConfirmationRequest;
+    if (trustedFolder && !disableWorkspacePolicies) {
+        const storage = new Storage(cwd);
+        // If we are in the home directory (or rather, our target Gemini dir is the global one),
+        // don't treat it as a workspace to avoid loading global policies twice.
+        if (storage.isWorkspaceHomeDir()) {
+            return { workspacePoliciesDir: undefined };
+        }
+        const potentialWorkspacePoliciesDir = storage.getWorkspacePoliciesDir();
+        const integrityManager = new PolicyIntegrityManager();
+        const integrityResult = await integrityManager.checkIntegrity('workspace', cwd, potentialWorkspacePoliciesDir);
+        if (integrityResult.status === IntegrityStatus.MATCH) {
+            workspacePoliciesDir = potentialWorkspacePoliciesDir;
+        }
+        else if (integrityResult.status === IntegrityStatus.NEW &&
+            integrityResult.fileCount === 0) {
+            // No workspace policies found
+            workspacePoliciesDir = undefined;
+        }
+        else if (interactive && !autoAcceptWorkspacePolicies) {
+            // Policies changed or are new, and we are in interactive mode and auto-accept is disabled
+            policyUpdateConfirmationRequest = {
+                scope: 'workspace',
+                identifier: cwd,
+                policyDir: potentialWorkspacePoliciesDir,
+                newHash: integrityResult.hash,
+            };
+        }
+        else {
+            // Non-interactive mode or auto-accept is enabled: automatically accept/load
+            await integrityManager.acceptIntegrity('workspace', cwd, integrityResult.hash);
+            workspacePoliciesDir = potentialWorkspacePoliciesDir;
+            if (!interactive) {
+                writeToStderr('WARNING: Workspace policies changed or are new. Automatically accepting and loading them.\n');
+            }
+            else {
+                debugLogger.warn('Workspace policies changed or are new. Automatically accepting and loading them.');
+            }
+        }
+    }
+    return { workspacePoliciesDir, policyUpdateConfirmationRequest };
+}

package/dist/config/sandboxConfig.js

@@ -0,0 +1,116 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { getPackageJson, FatalSandboxError, } from '@google/gemini-cli-core';
+import commandExists from 'command-exists';
+import * as os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const VALID_SANDBOX_COMMANDS = [
+    'docker',
+    'podman',
+    'sandbox-exec',
+    'runsc',
+    'lxc',
+    'windows-native',
+];
+function isSandboxCommand(value) {
+    return VALID_SANDBOX_COMMANDS.includes(value);
+}
+function getSandboxCommand(sandbox) {
+    // If the SANDBOX env var is set, we're already inside the sandbox.
+    if (process.env['SANDBOX']) {
+        return '';
+    }
+    // note environment variable takes precedence over argument (from command line or settings)
+    const environmentConfiguredSandbox = process.env['GEMINI_SANDBOX']?.toLowerCase().trim() ?? '';
+    sandbox =
+        environmentConfiguredSandbox?.length > 0
+            ? environmentConfiguredSandbox
+            : sandbox;
+    if (sandbox === '1' || sandbox === 'true')
+        sandbox = true;
+    else if (sandbox === '0' || sandbox === 'false' || !sandbox)
+        sandbox = false;
+    if (sandbox === false) {
+        return '';
+    }
+    if (typeof sandbox === 'string' && sandbox) {
+        if (!isSandboxCommand(sandbox)) {
+            throw new FatalSandboxError(`Invalid sandbox command '${sandbox}'. Must be one of ${VALID_SANDBOX_COMMANDS.join(', ')}`);
+        }
+        // runsc (gVisor) is only supported on Linux
+        if (sandbox === 'runsc' && os.platform() !== 'linux') {
+            throw new FatalSandboxError('gVisor (runsc) sandboxing is only supported on Linux');
+        }
+        // windows-native is only supported on Windows
+        if (sandbox === 'windows-native' && os.platform() !== 'win32') {
+            throw new FatalSandboxError('Windows native sandboxing is only supported on Windows');
+        }
+        // confirm that specified command exists (unless it's built-in)
+        if (sandbox !== 'windows-native' && !commandExists.sync(sandbox)) {
+            throw new FatalSandboxError(`Missing sandbox command '${sandbox}' (from GEMINI_SANDBOX)`);
+        }
+        // runsc uses Docker with --runtime=runsc; both must be available (prioritize runsc when explicitly chosen)
+        if (sandbox === 'runsc' && !commandExists.sync('docker')) {
+            throw new FatalSandboxError("runsc (gVisor) requires Docker. Install Docker, or use sandbox: 'docker'.");
+        }
+        return sandbox;
+    }
+    // look for seatbelt, docker, or podman, in that order
+    // for container-based sandboxing, require sandbox to be enabled explicitly
+    // note: runsc is NOT auto-detected, it must be explicitly specified
+    if (os.platform() === 'darwin' && commandExists.sync('sandbox-exec')) {
+        return 'sandbox-exec';
+    }
+    else if (commandExists.sync('docker') && sandbox === true) {
+        return 'docker';
+    }
+    else if (commandExists.sync('podman') && sandbox === true) {
+        return 'podman';
+    }
+    // throw an error if user requested sandbox but no command was found
+    if (sandbox === true) {
+        throw new FatalSandboxError('GEMINI_SANDBOX is true but failed to determine command for sandbox; ' +
+            'install docker or podman or specify command in GEMINI_SANDBOX');
+    }
+    return '';
+    // Note: 'lxc' is intentionally not auto-detected because it requires a
+    // pre-existing, running container managed by the user. Use
+    // GEMINI_SANDBOX=lxc or sandbox: "lxc" in settings to enable it.
+}
+export async function loadSandboxConfig(settings, argv) {
+    const sandboxOption = argv.sandbox ?? settings.tools?.sandbox;
+    let sandboxValue;
+    let allowedPaths = [];
+    let networkAccess = true;
+    let customImage;
+    if (typeof sandboxOption === 'object' &&
+        sandboxOption !== null &&
+        !Array.isArray(sandboxOption)) {
+        const config = sandboxOption;
+        sandboxValue = config.enabled ? (config.command ?? true) : false;
+        allowedPaths = config.allowedPaths ?? [];
+        networkAccess = config.networkAccess ?? true;
+        customImage = config.image;
+    }
+    else if (typeof sandboxOption !== 'object' || sandboxOption === null) {
+        sandboxValue = sandboxOption;
+    }
+    const command = getSandboxCommand(sandboxValue);
+    const packageJson = await getPackageJson(__dirname);
+    const image = process.env['GEMINI_SANDBOX_IMAGE'] ??
+        process.env['GEMINI_SANDBOX_IMAGE_DEFAULT'] ??
+        customImage ??
+        packageJson?.config?.sandboxImageUri;
+    const isNative = command === 'windows-native' ||
+        command === 'sandbox-exec' ||
+        command === 'lxc';
+    return command && (image || isNative)
+        ? { enabled: true, allowedPaths, networkAccess, command, image }
+        : undefined;
+}

package/dist/config/settingPaths.js

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export const SettingPaths = {
+    General: {
+        PreferredEditor: 'general.preferredEditor',
+    },
+};