@hibanacloud/cli 0.3.15

package/dist/src/config/config.js

@@ -0,0 +1,678 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { extensionsCommand } from '../commands/extensions.js';
+import { ApprovalMode, Config, DEFAULT_QWEN_EMBEDDING_MODEL, DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, EditTool, FileDiscoveryService, getCurrentGeminiMdFilename, loadServerHierarchicalMemory, setGeminiMdFilename as setServerGeminiMdFilename, ShellTool, WriteFileTool, resolveTelemetrySettings, FatalConfigError, Storage, InputFormat, OutputFormat, } from '@hibanacloud/core';
+import yargs, {} from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { resolvePath } from '../utils/resolvePath.js';
+import { getCliVersion } from '../utils/version.js';
+import { annotateActiveExtensions } from './extension.js';
+import { loadSandboxConfig } from './sandboxConfig.js';
+import { appEvents } from '../utils/events.js';
+import { mcpCommand } from '../commands/mcp.js';
+import { isWorkspaceTrusted } from './trustedFolders.js';
+import { buildWebSearchConfig } from './webSearch.js';
+// Simple console logger for now - replace with actual logger if available
+const logger = {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    debug: (...args) => console.debug('[DEBUG]', ...args),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    warn: (...args) => console.warn('[WARN]', ...args),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error: (...args) => console.error('[ERROR]', ...args),
+};
+const VALID_APPROVAL_MODE_VALUES = [
+    'plan',
+    'default',
+    'auto-edit',
+    'yolo',
+];
+function formatApprovalModeError(value) {
+    return new Error(`Invalid approval mode: ${value}. Valid values are: ${VALID_APPROVAL_MODE_VALUES.join(', ')}`);
+}
+function parseApprovalModeValue(value) {
+    const normalized = value.trim().toLowerCase();
+    switch (normalized) {
+        case 'plan':
+            return ApprovalMode.PLAN;
+        case 'default':
+            return ApprovalMode.DEFAULT;
+        case 'yolo':
+            return ApprovalMode.YOLO;
+        case 'auto_edit':
+        case 'autoedit':
+        case 'auto-edit':
+            return ApprovalMode.AUTO_EDIT;
+        default:
+            throw formatApprovalModeError(value);
+    }
+}
+function normalizeOutputFormat(format) {
+    if (!format) {
+        return undefined;
+    }
+    if (format === OutputFormat.STREAM_JSON) {
+        return OutputFormat.STREAM_JSON;
+    }
+    if (format === 'json' || format === OutputFormat.JSON) {
+        return OutputFormat.JSON;
+    }
+    return OutputFormat.TEXT;
+}
+export async function parseArguments(settings) {
+    const rawArgv = hideBin(process.argv);
+    const yargsInstance = yargs(rawArgv)
+        .locale('en')
+        .scriptName('hibana')
+        .usage('Usage: hibana [options] [command]\n\nHibana CLI - AI-powered terminal assistant, use -p/--prompt for non-interactive mode')
+        .option('telemetry', {
+        type: 'boolean',
+        description: 'Enable telemetry? This flag specifically controls if telemetry is sent. Other --telemetry-* flags set specific values but do not enable telemetry on their own.',
+    })
+        .option('telemetry-target', {
+        type: 'string',
+        choices: ['local', 'gcp'],
+        description: 'Set the telemetry target (local or gcp). Overrides settings files.',
+    })
+        .option('telemetry-otlp-endpoint', {
+        type: 'string',
+        description: 'Set the OTLP endpoint for telemetry. Overrides environment variables and settings files.',
+    })
+        .option('telemetry-otlp-protocol', {
+        type: 'string',
+        choices: ['grpc', 'http'],
+        description: 'Set the OTLP protocol for telemetry (grpc or http). Overrides settings files.',
+    })
+        .option('telemetry-log-prompts', {
+        type: 'boolean',
+        description: 'Enable or disable logging of user prompts for telemetry. Overrides settings files.',
+    })
+        .option('telemetry-outfile', {
+        type: 'string',
+        description: 'Redirect all telemetry output to the specified file.',
+    })
+        .deprecateOption('telemetry', 'Use the "telemetry.enabled" setting in settings.json instead. This flag will be removed in a future version.')
+        .deprecateOption('telemetry-target', 'Use the "telemetry.target" setting in settings.json instead. This flag will be removed in a future version.')
+        .deprecateOption('telemetry-otlp-endpoint', 'Use the "telemetry.otlpEndpoint" setting in settings.json instead. This flag will be removed in a future version.')
+        .deprecateOption('telemetry-otlp-protocol', 'Use the "telemetry.otlpProtocol" setting in settings.json instead. This flag will be removed in a future version.')
+        .deprecateOption('telemetry-log-prompts', 'Use the "telemetry.logPrompts" setting in settings.json instead. This flag will be removed in a future version.')
+        .deprecateOption('telemetry-outfile', 'Use the "telemetry.outfile" setting in settings.json instead. This flag will be removed in a future version.')
+        .option('debug', {
+        alias: 'd',
+        type: 'boolean',
+        description: 'Run in debug mode?',
+        default: false,
+    })
+        .option('proxy', {
+        type: 'string',
+        description: 'Proxy for Hibana CLI, like schema://user:password@host:port',
+    })
+        .deprecateOption('proxy', 'Use the "proxy" setting in settings.json instead. This flag will be removed in a future version.')
+        .command('$0 [query..]', 'Launch Hibana CLI', (yargsInstance) => yargsInstance
+        .positional('query', {
+        description: 'Positional prompt. Defaults to one-shot; use -i/--prompt-interactive for interactive.',
+    })
+        .option('model', {
+        alias: 'm',
+        type: 'string',
+        description: `Model`,
+    })
+        .option('prompt', {
+        alias: 'p',
+        type: 'string',
+        description: 'Prompt. Appended to input on stdin (if any).',
+    })
+        .option('prompt-interactive', {
+        alias: 'i',
+        type: 'string',
+        description: 'Execute the provided prompt and continue in interactive mode',
+    })
+        .option('sandbox', {
+        alias: 's',
+        type: 'boolean',
+        description: 'Run in sandbox?',
+    })
+        .option('sandbox-image', {
+        type: 'string',
+        description: 'Sandbox image URI.',
+    })
+        .option('all-files', {
+        alias: ['a'],
+        type: 'boolean',
+        description: 'Include ALL files in context?',
+        default: false,
+    })
+        .option('show-memory-usage', {
+        type: 'boolean',
+        description: 'Show memory usage in status bar',
+        default: false,
+    })
+        .option('yolo', {
+        alias: 'y',
+        type: 'boolean',
+        description: 'Automatically accept all actions (aka YOLO mode, see https://www.youtube.com/watch?v=xvFZjo5PgG0 for more details)?',
+        default: false,
+    })
+        .option('approval-mode', {
+        type: 'string',
+        choices: ['plan', 'default', 'auto-edit', 'yolo'],
+        description: 'Set the approval mode: plan (plan only), default (prompt for approval), auto-edit (auto-approve edit tools), yolo (auto-approve all tools)',
+    })
+        .option('checkpointing', {
+        alias: 'c',
+        type: 'boolean',
+        description: 'Enables checkpointing of file edits',
+        default: false,
+    })
+        .option('experimental-acp', {
+        type: 'boolean',
+        description: 'Starts the agent in ACP mode',
+    })
+        .option('allowed-mcp-server-names', {
+        type: 'array',
+        string: true,
+        description: 'Allowed MCP server names',
+        coerce: (mcpServerNames) => 
+        // Handle comma-separated values
+        mcpServerNames.flatMap((mcpServerName) => mcpServerName.split(',').map((m) => m.trim())),
+    })
+        .option('allowed-tools', {
+        type: 'array',
+        string: true,
+        description: 'Tools that are allowed to run without confirmation',
+        coerce: (tools) => 
+        // Handle comma-separated values
+        tools.flatMap((tool) => tool.split(',').map((t) => t.trim())),
+    })
+        .option('extensions', {
+        alias: 'e',
+        type: 'array',
+        string: true,
+        description: 'A list of extensions to use. If not provided, all extensions are used.',
+        coerce: (extensions) => 
+        // Handle comma-separated values
+        extensions.flatMap((extension) => extension.split(',').map((e) => e.trim())),
+    })
+        .option('list-extensions', {
+        alias: 'l',
+        type: 'boolean',
+        description: 'List all available extensions and exit.',
+    })
+        .option('include-directories', {
+        type: 'array',
+        string: true,
+        description: 'Additional directories to include in the workspace (comma-separated or multiple --include-directories)',
+        coerce: (dirs) => 
+        // Handle comma-separated values
+        dirs.flatMap((dir) => dir.split(',').map((d) => d.trim())),
+    })
+        .option('openai-logging', {
+        type: 'boolean',
+        description: 'Enable logging of OpenAI API calls for debugging and analysis',
+    })
+        .option('openai-logging-dir', {
+        type: 'string',
+        description: 'Custom directory path for OpenAI API logs. Overrides settings files.',
+    })
+        .option('openai-api-key', {
+        type: 'string',
+        description: 'OpenAI API key to use for authentication',
+    })
+        .option('openai-base-url', {
+        type: 'string',
+        description: 'OpenAI base URL (for custom endpoints)',
+    })
+        .option('tavily-api-key', {
+        type: 'string',
+        description: 'Tavily API key for web search',
+    })
+        .option('google-api-key', {
+        type: 'string',
+        description: 'Google Custom Search API key',
+    })
+        .option('google-search-engine-id', {
+        type: 'string',
+        description: 'Google Custom Search Engine ID',
+    })
+        .option('web-search-default', {
+        type: 'string',
+        description: 'Default web search provider (dashscope, tavily, google)',
+    })
+        .option('screen-reader', {
+        type: 'boolean',
+        description: 'Enable screen reader mode for accessibility.',
+    })
+        .option('vlm-switch-mode', {
+        type: 'string',
+        choices: ['once', 'session', 'persist'],
+        description: 'Default behavior when images are detected in input. Values: once (one-time switch), session (switch for entire session), persist (continue with current model). Overrides settings files.',
+        default: process.env['VLM_SWITCH_MODE'],
+    })
+        .option('input-format', {
+        type: 'string',
+        choices: ['text', 'stream-json'],
+        description: 'The format consumed from standard input.',
+        default: 'text',
+    })
+        .option('output-format', {
+        alias: 'o',
+        type: 'string',
+        description: 'The format of the CLI output.',
+        choices: ['text', 'json', 'stream-json'],
+    })
+        .option('include-partial-messages', {
+        type: 'boolean',
+        description: 'Include partial assistant messages when using stream-json output.',
+        default: false,
+    })
+        .deprecateOption('show-memory-usage', 'Use the "ui.showMemoryUsage" setting in settings.json instead. This flag will be removed in a future version.')
+        .deprecateOption('sandbox-image', 'Use the "tools.sandbox" setting in settings.json instead. This flag will be removed in a future version.')
+        .deprecateOption('checkpointing', 'Use the "general.checkpointing.enabled" setting in settings.json instead. This flag will be removed in a future version.')
+        .deprecateOption('all-files', 'Use @ includes in the application instead. This flag will be removed in a future version.')
+        .deprecateOption('prompt', 'Use the positional prompt instead. This flag will be removed in a future version.')
+        // Ensure validation flows through .fail() for clean UX
+        .fail((msg, err, yargs) => {
+        console.error(msg || err?.message || 'Unknown error');
+        yargs.showHelp();
+        process.exit(1);
+    })
+        .check((argv) => {
+        // The 'query' positional can be a string (for one arg) or string[] (for multiple).
+        // This guard safely checks if any positional argument was provided.
+        const query = argv['query'];
+        const hasPositionalQuery = Array.isArray(query)
+            ? query.length > 0
+            : !!query;
+        if (argv['prompt'] && hasPositionalQuery) {
+            return 'Cannot use both a positional prompt and the --prompt (-p) flag together';
+        }
+        if (argv['prompt'] && argv['promptInteractive']) {
+            return 'Cannot use both --prompt (-p) and --prompt-interactive (-i) together';
+        }
+        if (argv['yolo'] && argv['approvalMode']) {
+            return 'Cannot use both --yolo (-y) and --approval-mode together. Use --approval-mode=yolo instead.';
+        }
+        if (argv['includePartialMessages'] &&
+            argv['outputFormat'] !== OutputFormat.STREAM_JSON) {
+            return '--include-partial-messages requires --output-format stream-json';
+        }
+        if (argv['inputFormat'] === 'stream-json' &&
+            argv['outputFormat'] !== OutputFormat.STREAM_JSON) {
+            return '--input-format stream-json requires --output-format stream-json';
+        }
+        return true;
+    }))
+        // Register MCP subcommands
+        .command(mcpCommand);
+    if (settings?.experimental?.extensionManagement ?? true) {
+        yargsInstance.command(extensionsCommand);
+    }
+    yargsInstance
+        .version(await getCliVersion()) // This will enable the --version flag based on package.json
+        .alias('v', 'version')
+        .help()
+        .alias('h', 'help')
+        .strict()
+        .demandCommand(0, 0); // Allow base command to run with no subcommands
+    yargsInstance.wrap(yargsInstance.terminalWidth());
+    const result = await yargsInstance.parse();
+    // If yargs handled --help/--version it will have exited; nothing to do here.
+    // Handle case where MCP subcommands are executed - they should exit the process
+    // and not return to main CLI logic
+    if (result._.length > 0 &&
+        (result._[0] === 'mcp' || result._[0] === 'extensions')) {
+        // MCP commands handle their own execution and process exit
+        process.exit(0);
+    }
+    // Normalize query args: handle both quoted "@path file" and unquoted @path file
+    const queryArg = result.query;
+    const q = Array.isArray(queryArg)
+        ? queryArg.join(' ')
+        : queryArg;
+    // Route positional args: explicit -i flag -> interactive; else -> one-shot (even for @commands)
+    if (q && !result['prompt']) {
+        const hasExplicitInteractive = result['promptInteractive'] === '' || !!result['promptInteractive'];
+        if (hasExplicitInteractive) {
+            result['promptInteractive'] = q;
+        }
+        else {
+            result['prompt'] = q;
+        }
+    }
+    // Keep CliArgs.query as a string for downstream typing
+    result['query'] = q || undefined;
+    // The import format is now only controlled by settings.memoryImportFormat
+    // We no longer accept it as a CLI argument
+    return result;
+}
+// This function is now a thin wrapper around the server's implementation.
+// It's kept in the CLI for now as App.tsx directly calls it for memory refresh.
+// TODO: Consider if App.tsx should get memory via a server call or if Config should refresh itself.
+export async function loadHierarchicalGeminiMemory(currentWorkingDirectory, includeDirectoriesToReadGemini = [], debugMode, fileService, settings, extensionContextFilePaths = [], folderTrust, memoryImportFormat = 'tree', fileFilteringOptions) {
+    // FIX: Use real, canonical paths for a reliable comparison to handle symlinks.
+    const realCwd = fs.realpathSync(path.resolve(currentWorkingDirectory));
+    const realHome = fs.realpathSync(path.resolve(homedir()));
+    const isHomeDirectory = realCwd === realHome;
+    // If it is the home directory, pass an empty string to the core memory
+    // function to signal that it should skip the workspace search.
+    const effectiveCwd = isHomeDirectory ? '' : currentWorkingDirectory;
+    if (debugMode) {
+        logger.debug(`CLI: Delegating hierarchical memory load to server for CWD: ${currentWorkingDirectory} (memoryImportFormat: ${memoryImportFormat})`);
+    }
+    // Directly call the server function with the corrected path.
+    return loadServerHierarchicalMemory(effectiveCwd, includeDirectoriesToReadGemini, debugMode, fileService, extensionContextFilePaths, folderTrust, memoryImportFormat, fileFilteringOptions, settings.context?.discoveryMaxDirs);
+}
+export function isDebugMode(argv) {
+    return (argv.debug ||
+        [process.env['DEBUG'], process.env['DEBUG_MODE']].some((v) => v === 'true' || v === '1'));
+}
+export async function loadCliConfig(settings, extensions, extensionEnablementManager, sessionId, argv, cwd = process.cwd()) {
+    const debugMode = isDebugMode(argv);
+    const memoryImportFormat = settings.context?.importFormat || 'tree';
+    const ideMode = settings.ide?.enabled ?? false;
+    const folderTrust = settings.security?.folderTrust?.enabled ?? false;
+    const trustedFolder = isWorkspaceTrusted(settings)?.isTrusted ?? true;
+    const allExtensions = annotateActiveExtensions(extensions, cwd, extensionEnablementManager);
+    const activeExtensions = extensions.filter((_, i) => allExtensions[i].isActive);
+    // Set the context filename in the server's memoryTool module BEFORE loading memory
+    // TODO(b/343434939): This is a bit of a hack. The contextFileName should ideally be passed
+    // directly to the Config constructor in core, and have core handle setGeminiMdFilename.
+    // However, loadHierarchicalGeminiMemory is called *before* createServerConfig.
+    if (settings.context?.fileName) {
+        setServerGeminiMdFilename(settings.context.fileName);
+    }
+    else {
+        // Reset to default if not provided in settings.
+        setServerGeminiMdFilename(getCurrentGeminiMdFilename());
+    }
+    const extensionContextFilePaths = activeExtensions.flatMap((e) => e.contextFiles);
+    // Automatically load output-language.md if it exists
+    const outputLanguageFilePath = path.join(Storage.getGlobalHibanaDir(), 'output-language.md');
+    if (fs.existsSync(outputLanguageFilePath)) {
+        extensionContextFilePaths.push(outputLanguageFilePath);
+        if (debugMode) {
+            logger.debug(`Found output-language.md, adding to context files: ${outputLanguageFilePath}`);
+        }
+    }
+    const fileService = new FileDiscoveryService(cwd);
+    const fileFiltering = {
+        ...DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
+        ...settings.context?.fileFiltering,
+    };
+    const includeDirectories = (settings.context?.includeDirectories || [])
+        .map(resolvePath)
+        .concat((argv.includeDirectories || []).map(resolvePath));
+    // Call the (now wrapper) loadHierarchicalGeminiMemory which calls the server's version
+    const { memoryContent, fileCount } = await loadHierarchicalGeminiMemory(cwd, settings.context?.loadMemoryFromIncludeDirectories
+        ? includeDirectories
+        : [], debugMode, fileService, settings, extensionContextFilePaths, trustedFolder, memoryImportFormat, fileFiltering);
+    let mcpServers = mergeMcpServers(settings, activeExtensions);
+    const question = argv.promptInteractive || argv.prompt || '';
+    const inputFormat = argv.inputFormat ?? InputFormat.TEXT;
+    const argvOutputFormat = normalizeOutputFormat(argv.outputFormat);
+    const settingsOutputFormat = normalizeOutputFormat(settings.output?.format);
+    const outputFormat = argvOutputFormat ?? settingsOutputFormat ?? OutputFormat.TEXT;
+    const outputSettingsFormat = outputFormat === OutputFormat.STREAM_JSON
+        ? settingsOutputFormat &&
+            settingsOutputFormat !== OutputFormat.STREAM_JSON
+            ? settingsOutputFormat
+            : OutputFormat.TEXT
+        : outputFormat;
+    const includePartialMessages = Boolean(argv.includePartialMessages);
+    // Determine approval mode with backward compatibility
+    let approvalMode;
+    if (argv.approvalMode) {
+        approvalMode = parseApprovalModeValue(argv.approvalMode);
+    }
+    else if (argv.yolo) {
+        approvalMode = ApprovalMode.YOLO;
+    }
+    else if (settings.tools?.approvalMode) {
+        approvalMode = parseApprovalModeValue(settings.tools.approvalMode);
+    }
+    else {
+        approvalMode = ApprovalMode.DEFAULT;
+    }
+    // Force approval mode to default if the folder is not trusted.
+    if (!trustedFolder &&
+        approvalMode !== ApprovalMode.DEFAULT &&
+        approvalMode !== ApprovalMode.PLAN) {
+        logger.warn(`Approval mode overridden to "default" because the current folder is not trusted.`);
+        approvalMode = ApprovalMode.DEFAULT;
+    }
+    let telemetrySettings;
+    try {
+        telemetrySettings = await resolveTelemetrySettings({
+            argv,
+            env: process.env,
+            settings: settings.telemetry,
+        });
+    }
+    catch (err) {
+        if (err instanceof FatalConfigError) {
+            throw new FatalConfigError(`Invalid telemetry configuration: ${err.message}.`);
+        }
+        throw err;
+    }
+    // Interactive mode determination with priority:
+    // 1. If promptInteractive (-i flag) is provided, it is explicitly interactive
+    // 2. If outputFormat is stream-json or json (no matter input-format) along with query or prompt, it is non-interactive
+    // 3. If no query or prompt is provided, check isTTY: TTY means interactive, non-TTY means non-interactive
+    const hasQuery = !!argv.query;
+    const hasPrompt = !!argv.prompt;
+    let interactive;
+    if (argv.promptInteractive) {
+        // Priority 1: Explicit -i flag means interactive
+        interactive = true;
+    }
+    else if ((outputFormat === OutputFormat.STREAM_JSON ||
+        outputFormat === OutputFormat.JSON) &&
+        (hasQuery || hasPrompt)) {
+        // Priority 2: JSON/stream-json output with query/prompt means non-interactive
+        interactive = false;
+    }
+    else if (!hasQuery && !hasPrompt) {
+        // Priority 3: No query or prompt means interactive only if TTY (format arguments ignored)
+        interactive = process.stdin.isTTY ?? false;
+    }
+    else {
+        // Default: If we have query/prompt but output format is TEXT, assume non-interactive
+        // (fallback for edge cases where query/prompt is provided with TEXT output)
+        interactive = false;
+    }
+    // In non-interactive mode, exclude tools that require a prompt.
+    const extraExcludes = [];
+    if (!interactive && !argv.experimentalAcp) {
+        switch (approvalMode) {
+            case ApprovalMode.PLAN:
+            case ApprovalMode.DEFAULT:
+                // In default non-interactive mode, all tools that require approval are excluded.
+                extraExcludes.push(ShellTool.Name, EditTool.Name, WriteFileTool.Name);
+                break;
+            case ApprovalMode.AUTO_EDIT:
+                // In auto-edit non-interactive mode, only tools that still require a prompt are excluded.
+                extraExcludes.push(ShellTool.Name);
+                break;
+            case ApprovalMode.YOLO:
+                // No extra excludes for YOLO mode.
+                break;
+            default:
+                // This should never happen due to validation earlier, but satisfies the linter
+                break;
+        }
+    }
+    const excludeTools = mergeExcludeTools(settings, activeExtensions, extraExcludes.length > 0 ? extraExcludes : undefined);
+    const blockedMcpServers = [];
+    if (!argv.allowedMcpServerNames) {
+        if (settings.mcp?.allowed) {
+            mcpServers = allowedMcpServers(mcpServers, settings.mcp.allowed, blockedMcpServers);
+        }
+        if (settings.mcp?.excluded) {
+            const excludedNames = new Set(settings.mcp.excluded.filter(Boolean));
+            if (excludedNames.size > 0) {
+                mcpServers = Object.fromEntries(Object.entries(mcpServers).filter(([key]) => !excludedNames.has(key)));
+            }
+        }
+    }
+    if (argv.allowedMcpServerNames) {
+        mcpServers = allowedMcpServers(mcpServers, argv.allowedMcpServerNames, blockedMcpServers);
+    }
+    const resolvedModel = argv.model ||
+        process.env['OPENAI_MODEL'] ||
+        process.env['QWEN_MODEL'] ||
+        settings.model?.name;
+    const sandboxConfig = await loadSandboxConfig(settings, argv);
+    const screenReader = argv.screenReader !== undefined
+        ? argv.screenReader
+        : (settings.ui?.accessibility?.screenReader ?? false);
+    const vlmSwitchMode = argv.vlmSwitchMode || settings.experimental?.vlmSwitchMode;
+    return new Config({
+        sessionId,
+        embeddingModel: DEFAULT_QWEN_EMBEDDING_MODEL,
+        sandbox: sandboxConfig,
+        targetDir: cwd,
+        includeDirectories,
+        loadMemoryFromIncludeDirectories: settings.context?.loadMemoryFromIncludeDirectories || false,
+        debugMode,
+        question,
+        fullContext: argv.allFiles || false,
+        coreTools: settings.tools?.core || undefined,
+        allowedTools: argv.allowedTools || settings.tools?.allowed || undefined,
+        excludeTools,
+        toolDiscoveryCommand: settings.tools?.discoveryCommand,
+        toolCallCommand: settings.tools?.callCommand,
+        mcpServerCommand: settings.mcp?.serverCommand,
+        mcpServers,
+        userMemory: memoryContent,
+        geminiMdFileCount: fileCount,
+        approvalMode,
+        showMemoryUsage: argv.showMemoryUsage || settings.ui?.showMemoryUsage || false,
+        accessibility: {
+            ...settings.ui?.accessibility,
+            screenReader,
+        },
+        telemetry: telemetrySettings,
+        usageStatisticsEnabled: settings.privacy?.usageStatisticsEnabled ?? true,
+        fileFiltering: settings.context?.fileFiltering,
+        checkpointing: argv.checkpointing || settings.general?.checkpointing?.enabled,
+        proxy: argv.proxy ||
+            process.env['HTTPS_PROXY'] ||
+            process.env['https_proxy'] ||
+            process.env['HTTP_PROXY'] ||
+            process.env['http_proxy'],
+        cwd,
+        fileDiscoveryService: fileService,
+        bugCommand: settings.advanced?.bugCommand,
+        model: resolvedModel,
+        extensionContextFilePaths,
+        sessionTokenLimit: settings.model?.sessionTokenLimit ?? -1,
+        maxSessionTurns: settings.model?.maxSessionTurns ?? -1,
+        experimentalZedIntegration: argv.experimentalAcp || false,
+        listExtensions: argv.listExtensions || false,
+        extensions: allExtensions,
+        blockedMcpServers,
+        noBrowser: !!process.env['NO_BROWSER'],
+        authType: settings.security?.auth?.selectedType,
+        inputFormat,
+        outputFormat,
+        includePartialMessages,
+        generationConfig: {
+            ...(settings.model?.generationConfig || {}),
+            model: resolvedModel,
+            apiKey: argv.openaiApiKey ||
+                // For HIBANA_OAUTH, prioritize settings over env vars
+                (settings.security?.auth?.selectedType === 'hibana-oauth'
+                    ? settings.security?.auth?.apiKey || process.env['OPENAI_API_KEY']
+                    : process.env['OPENAI_API_KEY'] || settings.security?.auth?.apiKey),
+            baseUrl: argv.openaiBaseUrl ||
+                settings.security?.auth?.baseUrl ||
+                process.env['HIBANA_BASE_URL'] ||
+                'https://api-ai.hibanacloud.com/v1',
+            enableOpenAILogging: (typeof argv.openaiLogging === 'undefined'
+                ? settings.model?.enableOpenAILogging
+                : argv.openaiLogging) ?? false,
+            openAILoggingDir: argv.openaiLoggingDir || settings.model?.openAILoggingDir,
+        },
+        cliVersion: await getCliVersion(),
+        webSearch: buildWebSearchConfig(argv, settings, settings.security?.auth?.selectedType),
+        summarizeToolOutput: settings.model?.summarizeToolOutput,
+        ideMode,
+        chatCompression: settings.model?.chatCompression,
+        folderTrust,
+        interactive,
+        trustedFolder,
+        useRipgrep: settings.tools?.useRipgrep,
+        useBuiltinRipgrep: settings.tools?.useBuiltinRipgrep,
+        shouldUseNodePtyShell: settings.tools?.shell?.enableInteractiveShell,
+        skipNextSpeakerCheck: settings.model?.skipNextSpeakerCheck,
+        skipLoopDetection: settings.model?.skipLoopDetection ?? false,
+        skipStartupContext: settings.model?.skipStartupContext ?? false,
+        vlmSwitchMode,
+        truncateToolOutputThreshold: settings.tools?.truncateToolOutputThreshold,
+        truncateToolOutputLines: settings.tools?.truncateToolOutputLines,
+        enableToolOutputTruncation: settings.tools?.enableToolOutputTruncation,
+        eventEmitter: appEvents,
+        useSmartEdit: argv.useSmartEdit ?? settings.useSmartEdit,
+        output: {
+            format: outputSettingsFormat,
+        },
+    });
+}
+function allowedMcpServers(mcpServers, allowMCPServers, blockedMcpServers) {
+    const allowedNames = new Set(allowMCPServers.filter(Boolean));
+    if (allowedNames.size > 0) {
+        mcpServers = Object.fromEntries(Object.entries(mcpServers).filter(([key, server]) => {
+            const isAllowed = allowedNames.has(key);
+            if (!isAllowed) {
+                blockedMcpServers.push({
+                    name: key,
+                    extensionName: server.extensionName || '',
+                });
+            }
+            return isAllowed;
+        }));
+    }
+    else {
+        blockedMcpServers.push(...Object.entries(mcpServers).map(([key, server]) => ({
+            name: key,
+            extensionName: server.extensionName || '',
+        })));
+        mcpServers = {};
+    }
+    return mcpServers;
+}
+function mergeMcpServers(settings, extensions) {
+    const mcpServers = { ...(settings.mcpServers || {}) };
+    for (const extension of extensions) {
+        Object.entries(extension.config.mcpServers || {}).forEach(([key, server]) => {
+            if (mcpServers[key]) {
+                logger.warn(`Skipping extension MCP config for server with key "${key}" as it already exists.`);
+                return;
+            }
+            mcpServers[key] = {
+                ...server,
+                extensionName: extension.config.name,
+            };
+        });
+    }
+    return mcpServers;
+}
+function mergeExcludeTools(settings, extensions, extraExcludes) {
+    const allExcludeTools = new Set([
+        ...(settings.tools?.exclude || []),
+        ...(extraExcludes || []),
+    ]);
+    for (const extension of extensions) {
+        for (const tool of extension.config.excludeTools || []) {
+            allExcludeTools.add(tool);
+        }
+    }
+    return [...allExcludeTools];
+}
+//# sourceMappingURL=config.js.map