axon-code 2.4.0

package/dist/config/index.js

@@ -0,0 +1,1677 @@
+/**
+ * 配置管理 - 增强版
+ * 支持：Zod验证、配置合并、迁移、导出/导入、热重载
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { z } from 'zod';
+import { envManager, maskSensitiveFields, getValidatedEnv } from '../env/index.js';
+import { VERSION } from '../version.js';
+// ============ Zod Schema 定义 ============
+const McpServerConfigSchema = z.object({
+    type: z.enum(['stdio', 'sse', 'http']),
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string()).optional(),
+    url: z.string().url().optional(),
+    headers: z.record(z.string()).optional(),
+}).refine((data) => {
+    // stdio 类型必须有 command
+    if (data.type === 'stdio' && !data.command)
+        return false;
+    // http/sse 类型必须有 url
+    if ((data.type === 'http' || data.type === 'sse') && !data.url)
+        return false;
+    return true;
+}, {
+    message: 'Invalid MCP server configuration',
+});
+const UserConfigSchema = z.object({
+    // 版本控制
+    version: z.string().default('2.1.7'),
+    // 语言配置 (v2.1.0+) - 配置 Claude 的响应语言
+    // 官方格式：language: "japanese" 会添加到系统提示词
+    language: z.string().optional(),
+    // API 配置
+    apiKey: z.string().optional(),
+    model: z.enum(['claude-opus-4-6', 'claude-opus-4-5-20251101', 'claude-sonnet-4-5-20250929', 'claude-haiku-4-5-20251001', 'opus', 'sonnet', 'haiku']).default('sonnet'),
+    maxTokens: z.number().int().positive().max(200000).default(32000),
+    temperature: z.number().min(0).max(1).default(1),
+    // 后端选择（新增 apiProvider 枚举，保留向后兼容）
+    apiProvider: z.enum(['anthropic', 'bedrock', 'vertex']).default('anthropic').optional(),
+    useBedrock: z.boolean().default(false),
+    useVertex: z.boolean().default(false),
+    oauthToken: z.string().optional(),
+    // WebUI 专用配置（settings.json passthrough 字段）
+    apiBaseUrl: z.string().optional(),
+    customModelName: z.string().optional(),
+    authPriority: z.enum(['apiKey', 'oauth', 'auto']).default('auto').optional(),
+    oauthAccount: z.record(z.any()).optional(),
+    // Ollama / 本地模型配置
+    ollamaUrl: z.string().default('http://localhost:11434').optional(),
+    ollamaModel: z.string().optional(),
+    // 功能配置
+    maxRetries: z.number().int().min(0).max(10).default(3),
+    bashMaxOutputLength: z.number().int().min(1000).max(150000).default(30000),
+    debugLogsDir: z.string().optional(),
+    agentId: z.string().optional(), // 新增：Agent ID
+    // UI 配置
+    theme: z.enum(['dark', 'light', 'auto']).default('auto'),
+    verbose: z.boolean().default(false),
+    editMode: z.enum(['default', 'vim', 'emacs']).default('default'),
+    /** Diff 显示工具 (P0) */
+    diffTool: z.enum(['terminal', 'auto']).default('auto').optional(),
+    /** 输出样式 (P1) */
+    outputStyle: z.enum(['default', 'compact', 'verbose']).default('default').optional(),
+    /** 通知渠道 (P1) */
+    notifChannel: z.enum(['desktop', 'terminal', 'none']).default('terminal').optional(),
+    // 终端配置（新增）
+    terminal: z.object({
+        type: z.enum(['auto', 'vscode', 'cursor', 'windsurf', 'zed', 'ghostty', 'wezterm', 'kitty', 'alacritty', 'warp']).optional(),
+        statusLine: z.object({
+            type: z.enum(['command', 'text', 'disabled']).default('disabled'),
+            command: z.string().optional(),
+            text: z.string().optional(),
+        }).optional(),
+        keybindings: z.record(z.string()).optional(),
+    }).optional(),
+    // 功能开关
+    enableTelemetry: z.boolean().default(false),
+    disableFileCheckpointing: z.boolean().default(false),
+    enableAutoSave: z.boolean().default(true),
+    /** 自动链接理解 - 自动提取用户消息中的 URL 并获取内容注入上下文 */
+    autoLinkUnderstanding: z.boolean().default(true).optional(),
+    /** Extended Thinking 配置 (P0) */
+    thinking: z.object({
+        enabled: z.boolean().default(false),
+        budgetTokens: z.number().int().min(1024).max(128000).default(10000),
+        showThinking: z.boolean().default(false),
+        timeout: z.number().int().positive().default(120000), // 2分钟
+    }).optional(),
+    /** IDE 集成配置 (P0/P1) */
+    autoConnectIde: z.boolean().default(false).optional(),
+    autoInstallIdeExtension: z.boolean().default(true).optional(),
+    /** UI/UX 配置 (P1) */
+    respectGitignore: z.boolean().default(true).optional(),
+    promptSuggestionEnabled: z.boolean().default(false).optional(),
+    fileCheckpointingEnabled: z.boolean().default(true).optional(),
+    autoCompactEnabled: z.boolean().default(true).optional(),
+    sessionMemoryEnabled: z.boolean().default(false).optional(), // Session Memory 压缩功能（TJ1）
+    autoUpdatesChannel: z.enum(['latest', 'disabled']).default('latest').optional(),
+    claudeInChromeDefaultEnabled: z.boolean().default(true).optional(),
+    /** UI 提示和进度 (P2) */
+    spinnerTipsEnabled: z.boolean().default(true).optional(),
+    terminalProgressBarEnabled: z.boolean().default(true).optional(),
+    /** 响应耗时显示 (v2.1.7+) */
+    showTurnDuration: z.boolean().default(true).optional(),
+    /** v2.1.30: Reduced motion mode - 减少动画和视觉效果 */
+    reducedMotion: z.boolean().default(false).optional(),
+    // Git 配置
+    includeCoAuthoredBy: z.boolean().default(true), // 是否在 git commit 中添加 Claude 署名（已弃用，使用 attribution）
+    // Git 署名配置（新增，v2.1.4+）
+    attribution: z.object({
+        commit: z.string().optional(), // commit 消息署名（包含 Co-Authored-By trailer）
+        pr: z.string().optional(), // PR 描述署名（包含链接）
+    }).optional(),
+    // 高级配置
+    maxConcurrentTasks: z.number().int().positive().max(100).default(10),
+    requestTimeout: z.number().int().positive().default(300000), // 5分钟
+    /** Skill Hub URL - 社区 skill 注册中心地址 */
+    skillHubUrl: z.string().url().optional(),
+    // 遥测配置（新增）
+    telemetry: z.object({
+        otelShutdownTimeoutMs: z.number().int().positive().optional(),
+    }).optional(),
+    // 代理配置（新增）
+    proxy: z.object({
+        http: z.string().url().optional(),
+        https: z.string().url().optional(),
+        auth: z.object({
+            username: z.string().optional(),
+            password: z.string().optional(),
+        }).optional(),
+    }).optional(),
+    // 日志配置（新增）
+    logging: z.object({
+        level: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+        logPath: z.string().optional(),
+        maxSize: z.number().int().positive().optional(),
+        maxFiles: z.number().int().positive().optional(),
+    }).optional(),
+    // 缓存配置（新增）
+    cache: z.object({
+        enabled: z.boolean().default(true),
+        location: z.string().optional(),
+        maxSize: z.number().int().positive().optional(), // MB
+        ttl: z.number().int().positive().optional(), // 秒
+    }).optional(),
+    // 安全配置（新增）
+    security: z.object({
+        sensitiveFiles: z.array(z.string()).optional(),
+        dangerousCommands: z.array(z.string()).optional(),
+        allowSandboxEscape: z.boolean().default(false),
+    }).optional(),
+    // MCP 服务器
+    mcpServers: z.record(McpServerConfigSchema).optional(),
+    // 工具过滤
+    allowedTools: z.array(z.string()).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+    // 自定义提示词
+    systemPrompt: z.string().optional(),
+    // 工作目录
+    defaultWorkingDir: z.string().optional(),
+    // 权限配置（匹配官方结构）
+    permissions: z.object({
+        // 默认权限模式（匹配官方 defaultMode）
+        defaultMode: z.enum(['default', 'bypassPermissions', 'dontAsk', 'acceptEdits', 'plan', 'delegate']).default('default').optional(),
+        // 向后兼容字段
+        defaultLevel: z.enum(['accept', 'reject', 'ask']).default('ask').optional(),
+        autoApprove: z.array(z.string()).optional(),
+        // allow/deny/ask 规则（匹配官方）
+        allow: z.array(z.string()).optional(),
+        deny: z.array(z.string()).optional(),
+        ask: z.array(z.string()).optional(),
+        // 工具级权限
+        tools: z.object({
+            allow: z.array(z.string()).optional(),
+            deny: z.array(z.string()).optional(),
+        }).optional(),
+        // 路径级权限（支持 glob patterns）
+        paths: z.object({
+            allow: z.array(z.string()).optional(),
+            deny: z.array(z.string()).optional(),
+        }).optional(),
+        // 命令级权限（支持 glob patterns）
+        commands: z.object({
+            allow: z.array(z.string()).optional(),
+            deny: z.array(z.string()).optional(),
+        }).optional(),
+        // 网络权限
+        network: z.object({
+            allow: z.array(z.string()).optional(),
+            deny: z.array(z.string()).optional(),
+        }).optional(),
+        // 额外允许的目录
+        additionalDirectories: z.array(z.string()).optional(),
+        // 审计日志
+        audit: z.object({
+            enabled: z.boolean().optional(),
+            logFile: z.string().optional(),
+            maxSize: z.number().int().positive().optional(),
+        }).optional(),
+    }).optional(),
+    // Session Manager 配置（新增，v2.1.4+）
+    sessionManager: z.object({
+        /** 自动保存开关 */
+        autoSave: z.boolean().default(true),
+        /** 自动保存间隔 (ms) */
+        autoSaveIntervalMs: z.number().int().positive().default(30000),
+        /** 会话存储目录（默认: ~/.axon/sessions） */
+        sessionDir: z.string().optional(),
+        /** 最大会话数 */
+        maxSessions: z.number().int().positive().default(100),
+        /** 会话过期天数 */
+        sessionExpiryDays: z.number().int().positive().default(30),
+    }).optional(),
+    // v2.1.9: Plan 模式配置
+    plan: z.object({
+        /** 自定义 plan 文件存储目录，相对于项目根目录 */
+        plansDirectory: z.string().optional(),
+    }).optional(),
+    // v2.1.9: plansDirectory 快捷配置（等同于 plan.plansDirectory）
+    plansDirectory: z.string().optional(),
+    // Embedding 配置（向量搜索 + 混合检索）
+    embedding: z.object({
+        provider: z.enum(['openai']).default('openai'),
+        apiKey: z.string().optional(),
+        baseUrl: z.string().optional(),
+        model: z.string().default('text-embedding-3-small'),
+        dimensions: z.number().int().positive().default(1536),
+        hybrid: z.object({
+            enabled: z.boolean().default(true),
+            vectorWeight: z.number().min(0).max(1).default(0.6),
+            textWeight: z.number().min(0).max(1).default(0.4),
+        }).optional(),
+        mmr: z.object({
+            enabled: z.boolean().default(false),
+            lambda: z.number().min(0).max(1).default(0.7),
+        }).optional(),
+    }).optional(),
+    // Agent Network 配置（v2.2.3+）
+    network: z.object({
+        /** 是否启用 Agent Network */
+        enabled: z.boolean().default(false),
+        /** Agent 间通信端口 */
+        port: z.number().int().min(1024).max(65535).default(7860),
+        /** Agent 显示名（默认 hostname-port） */
+        name: z.string().optional(),
+        /** 是否通过 mDNS 广播自己 */
+        advertise: z.boolean().default(true),
+        /** 同 Owner 的 Agent 自动信任 */
+        autoAcceptSameOwner: z.boolean().default(true),
+    }).optional(),
+}).passthrough(); // 允许额外字段，便于扩展
+// ============ 默认配置 ============
+const DEFAULT_CONFIG = {
+    version: '2.1.18',
+    model: 'sonnet',
+    maxTokens: 32000,
+    temperature: 1,
+    theme: 'auto',
+    verbose: false,
+    editMode: 'default',
+    maxRetries: 3,
+    enableTelemetry: false,
+    disableFileCheckpointing: false,
+    enableAutoSave: true,
+    includeCoAuthoredBy: true, // Git 署名默认开启
+    maxConcurrentTasks: 10,
+    requestTimeout: 300000,
+    useBedrock: false,
+    useVertex: false,
+    // ===== 新增默认值 (v2.1.4+) =====
+    /** Diff 工具 */
+    diffTool: 'auto',
+    /** Extended Thinking */
+    thinking: {
+        enabled: false,
+        budgetTokens: 10000,
+        showThinking: false,
+        timeout: 120000,
+    },
+    /** IDE 集成 */
+    autoConnectIde: false,
+    autoInstallIdeExtension: true,
+    /** UI/UX */
+    respectGitignore: true,
+    promptSuggestionEnabled: false,
+    fileCheckpointingEnabled: true,
+    autoCompactEnabled: true,
+    autoUpdatesChannel: 'latest',
+    claudeInChromeDefaultEnabled: true,
+    outputStyle: 'default',
+    notifChannel: 'terminal',
+    /** UI 提示和进度 */
+    spinnerTipsEnabled: true,
+    terminalProgressBarEnabled: true,
+    /** 响应耗时显示 (v2.1.7+) */
+    showTurnDuration: true,
+    /** Session Manager */
+    sessionManager: {
+        autoSave: true,
+        autoSaveIntervalMs: 30000,
+        maxSessions: 100,
+        sessionExpiryDays: 30,
+    },
+};
+// ============ 环境变量解析 ============
+function parseEnvBoolean(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.toLowerCase().trim();
+    if (normalized === 'true' || normalized === '1' || normalized === 'yes')
+        return true;
+    if (normalized === 'false' || normalized === '0' || normalized === 'no')
+        return false;
+    return undefined;
+}
+function parseEnvNumber(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number(value);
+    return isNaN(parsed) ? undefined : parsed;
+}
+function getEnvConfig() {
+    const config = {
+        // ===== ANTHROPIC_* 和 AXON_API_KEY =====
+        apiKey: process.env.ANTHROPIC_API_KEY || process.env.AXON_API_KEY,
+        oauthToken: process.env.AXON_OAUTH_TOKEN,
+        // ===== 性能配置 =====
+        debugLogsDir: process.env.AXON_DEBUG_LOGS_DIR,
+        // ===== Agent 系统 =====
+        agentId: process.env.AXON_AGENT_ID,
+        // ===== IDE 集成 =====
+        autoConnectIde: parseEnvBoolean(process.env.AXON_AUTO_CONNECT_IDE),
+        // ===== 语言配置 =====
+        language: process.env.AXON_LANGUAGE,
+        // ===== UI/UX =====
+        promptSuggestionEnabled: parseEnvBoolean(process.env.AXON_ENABLE_PROMPT_SUGGESTION),
+        respectGitignore: parseEnvBoolean(process.env.AXON_RESPECT_GITIGNORE),
+        autoCompactEnabled: parseEnvBoolean(process.env.DISABLE_COMPACT) === true ? false : undefined,
+        spinnerTipsEnabled: parseEnvBoolean(process.env.AXON_ENABLE_SPINNER_TIPS),
+        terminalProgressBarEnabled: parseEnvBoolean(process.env.AXON_ENABLE_PROGRESS_BAR),
+    };
+    // ===== API Provider（从布尔标志推导）=====
+    if (parseEnvBoolean(process.env.AXON_USE_FOUNDRY)) {
+        config.apiProvider = 'anthropic'; // Foundry 也使用 anthropic provider
+    }
+    // ===== Extended Thinking 配置 =====
+    if (process.env.MAX_THINKING_TOKENS || process.env.DISABLE_INTERLEAVED_THINKING) {
+        config.thinking = {
+            enabled: parseEnvBoolean(process.env.DISABLE_INTERLEAVED_THINKING) !== true,
+            budgetTokens: parseEnvNumber(process.env.MAX_THINKING_TOKENS) ?? 10000,
+            showThinking: false,
+            timeout: 120000,
+        };
+    }
+    // ===== 遥测配置 =====
+    if (process.env.AXON_OTEL_SHUTDOWN_TIMEOUT_MS) {
+        config.telemetry = {
+            otelShutdownTimeoutMs: parseEnvNumber(process.env.AXON_OTEL_SHUTDOWN_TIMEOUT_MS),
+        };
+    }
+    // ===== 代理配置 =====
+    if (process.env.HTTP_PROXY || process.env.HTTPS_PROXY) {
+        config.proxy = {
+            http: process.env.HTTP_PROXY,
+            https: process.env.HTTPS_PROXY,
+        };
+    }
+    // ========== 新增: 更多环境变量支持 (110+) ==========
+    // ===== ANTHROPIC_* 扩展配置 =====
+    if (process.env.ANTHROPIC_BASE_URL) {
+        if (!config.api)
+            config.api = {};
+        config.api.baseURL = process.env.ANTHROPIC_BASE_URL;
+    }
+    if (process.env.ANTHROPIC_MODEL) {
+        config.model = process.env.ANTHROPIC_MODEL;
+    }
+    if (process.env.ANTHROPIC_CUSTOM_HEADERS) {
+        try {
+            config.customHeaders = JSON.parse(process.env.ANTHROPIC_CUSTOM_HEADERS);
+        }
+        catch (e) {
+            console.warn('Failed to parse ANTHROPIC_CUSTOM_HEADERS:', e);
+        }
+    }
+    // ===== Git 集成 =====
+    if (process.env.AXON_GIT_BASH_PATH) {
+        config.git = {
+            bashPath: process.env.AXON_GIT_BASH_PATH,
+        };
+    }
+    // ===== 会话管理扩展 =====
+    if (process.env.AXON_SESSION_ID ||
+        process.env.AXON_PARENT_SESSION_ID ||
+        process.env.AXON_SESSION_ACCESS_TOKEN ||
+        process.env.AXON_SKIP_PROMPT_HISTORY ||
+        process.env.AXON_EXIT_AFTER_STOP_DELAY ||
+        process.env.AXON_SSE_PORT) {
+        config.session = {
+            id: process.env.AXON_SESSION_ID,
+            parentId: process.env.AXON_PARENT_SESSION_ID,
+            accessToken: process.env.AXON_SESSION_ACCESS_TOKEN,
+            skipPromptHistory: parseEnvBoolean(process.env.AXON_SKIP_PROMPT_HISTORY),
+            exitAfterStopDelay: parseEnvNumber(process.env.AXON_EXIT_AFTER_STOP_DELAY),
+            ssePort: parseEnvNumber(process.env.AXON_SSE_PORT),
+        };
+    }
+    // ===== Agent 系统扩展 =====
+    if (process.env.AXON_AGENT_NAME ||
+        process.env.AXON_AGENT_TYPE ||
+        process.env.AXON_SUBAGENT_MODEL ||
+        process.env.AXON_PLAN_V2_AGENT_COUNT ||
+        process.env.AXON_PLAN_V2_EXPLORE_AGENT_COUNT ||
+        process.env.AXON_EFFORT_LEVEL ||
+        process.env.AXON_ACTION) {
+        config.agent = {
+            id: config.agentId,
+            name: process.env.AXON_AGENT_NAME,
+            type: process.env.AXON_AGENT_TYPE,
+            subagentModel: process.env.AXON_SUBAGENT_MODEL,
+            planV2AgentCount: parseEnvNumber(process.env.AXON_PLAN_V2_AGENT_COUNT),
+            planV2ExploreAgentCount: parseEnvNumber(process.env.AXON_PLAN_V2_EXPLORE_AGENT_COUNT),
+            effortLevel: process.env.AXON_EFFORT_LEVEL,
+            action: process.env.AXON_ACTION,
+        };
+    }
+    // ===== IDE 集成扩展 =====
+    if (process.env.AXON_IDE_HOST_OVERRIDE ||
+        process.env.AXON_IDE_SKIP_AUTO_INSTALL ||
+        process.env.AXON_IDE_SKIP_VALID_CHECK) {
+        config.ide = {
+            autoConnect: config.autoConnectIde,
+            hostOverride: process.env.AXON_IDE_HOST_OVERRIDE,
+            skipAutoInstall: parseEnvBoolean(process.env.AXON_IDE_SKIP_AUTO_INSTALL),
+            skipValidCheck: parseEnvBoolean(process.env.AXON_IDE_SKIP_VALID_CHECK),
+        };
+    }
+    // ===== 安全配置 =====
+    if (process.env.AXON_CLIENT_CERT ||
+        process.env.AXON_CLIENT_KEY ||
+        process.env.AXON_CLIENT_KEY_PASSPHRASE ||
+        process.env.AXON_ADDITIONAL_PROTECTION ||
+        process.env.AXON_DISABLE_COMMAND_INJECTION_CHECK) {
+        config.security = {
+            clientCert: process.env.AXON_CLIENT_CERT,
+            clientKey: process.env.AXON_CLIENT_KEY,
+            clientKeyPassphrase: process.env.AXON_CLIENT_KEY_PASSPHRASE,
+            additionalProtection: parseEnvBoolean(process.env.AXON_ADDITIONAL_PROTECTION),
+            disableCommandInjectionCheck: parseEnvBoolean(process.env.AXON_DISABLE_COMMAND_INJECTION_CHECK),
+        };
+    }
+    // ===== Prompt Caching =====
+    if (process.env.DISABLE_PROMPT_CACHING ||
+        process.env.DISABLE_PROMPT_CACHING_SONNET ||
+        process.env.DISABLE_PROMPT_CACHING_OPUS ||
+        process.env.DISABLE_PROMPT_CACHING_HAIKU) {
+        config.promptCaching = {
+            enabled: !parseEnvBoolean(process.env.DISABLE_PROMPT_CACHING),
+            sonnet: !parseEnvBoolean(process.env.DISABLE_PROMPT_CACHING_SONNET),
+            opus: !parseEnvBoolean(process.env.DISABLE_PROMPT_CACHING_OPUS),
+            haiku: !parseEnvBoolean(process.env.DISABLE_PROMPT_CACHING_HAIKU),
+        };
+    }
+    // ===== MCP 配置扩展 =====
+    if (process.env.MCP_TIMEOUT ||
+        process.env.MCP_TOOL_TIMEOUT ||
+        process.env.MAX_MCP_OUTPUT_TOKENS ||
+        process.env.MCP_OAUTH_CALLBACK_PORT ||
+        process.env.MCP_SERVER_CONNECTION_BATCH_SIZE ||
+        process.env.ENABLE_MCP_CLI ||
+        process.env.ENABLE_MCP_CLI_ENDPOINT ||
+        process.env.ENABLE_EXPERIMENTAL_MCP_CLI ||
+        process.env.ENABLE_MCP_LARGE_OUTPUT_FILES) {
+        config.mcp = {
+            timeout: parseEnvNumber(process.env.MCP_TIMEOUT),
+            toolTimeout: parseEnvNumber(process.env.MCP_TOOL_TIMEOUT),
+            maxOutputTokens: parseEnvNumber(process.env.MAX_MCP_OUTPUT_TOKENS),
+            oauthCallbackPort: parseEnvNumber(process.env.MCP_OAUTH_CALLBACK_PORT),
+            serverConnectionBatchSize: parseEnvNumber(process.env.MCP_SERVER_CONNECTION_BATCH_SIZE),
+            enableCli: parseEnvBoolean(process.env.ENABLE_MCP_CLI),
+            enableCliEndpoint: parseEnvBoolean(process.env.ENABLE_MCP_CLI_ENDPOINT),
+            enableExperimentalCli: parseEnvBoolean(process.env.ENABLE_EXPERIMENTAL_MCP_CLI),
+            enableLargeOutputFiles: parseEnvBoolean(process.env.ENABLE_MCP_LARGE_OUTPUT_FILES),
+        };
+    }
+    // ===== 认证跳过 =====
+    if (process.env.AXON_SKIP_BEDROCK_AUTH ||
+        process.env.AXON_SKIP_VERTEX_AUTH ||
+        process.env.AXON_SKIP_FOUNDRY_AUTH) {
+        config.skipAuth = {
+            bedrock: parseEnvBoolean(process.env.AXON_SKIP_BEDROCK_AUTH),
+            vertex: parseEnvBoolean(process.env.AXON_SKIP_VERTEX_AUTH),
+            foundry: parseEnvBoolean(process.env.AXON_SKIP_FOUNDRY_AUTH),
+        };
+    }
+    // ===== 远程会话 =====
+    if (process.env.AXON_REMOTE ||
+        process.env.AXON_REMOTE_ENVIRONMENT_TYPE ||
+        process.env.AXON_REMOTE_SESSION_ID) {
+        config.remote = {
+            enabled: parseEnvBoolean(process.env.AXON_REMOTE),
+            environmentType: process.env.AXON_REMOTE_ENVIRONMENT_TYPE,
+            sessionId: process.env.AXON_REMOTE_SESSION_ID,
+        };
+    }
+    // ===== 沙箱配置 =====
+    if (process.env.AXON_BUBBLEWRAP ||
+        process.env.AXON_BASH_SANDBOX_SHOW_INDICATOR ||
+        process.env.AXON_CONTAINER_ID ||
+        process.env.AXON_SHELL ||
+        process.env.AXON_SHELL_PREFIX ||
+        process.env.AXON_DONT_INHERIT_ENV) {
+        config.sandbox = {
+            bubblewrap: process.env.AXON_BUBBLEWRAP,
+            showIndicator: parseEnvBoolean(process.env.AXON_BASH_SANDBOX_SHOW_INDICATOR) ?? true,
+            containerId: process.env.AXON_CONTAINER_ID,
+            shell: process.env.AXON_SHELL,
+            shellPrefix: process.env.AXON_SHELL_PREFIX,
+            dontInheritEnv: parseEnvBoolean(process.env.AXON_DONT_INHERIT_ENV),
+        };
+    }
+    // ===== 临时目录配置 (v2.1.5+) =====
+    if (process.env.AXON_TMPDIR) {
+        config.tmpDir = process.env.AXON_TMPDIR;
+    }
+    // ===== UI/UX 扩展 =====
+    if (process.env.AXON_DISABLE_ATTACHMENTS ||
+        process.env.AXON_DISABLE_AXON_MDS ||
+        process.env.AXON_DISABLE_FEEDBACK_SURVEY ||
+        process.env.AXON_DISABLE_TERMINAL_TITLE ||
+        process.env.AXON_ENABLE_TOKEN_USAGE_ATTACHMENT ||
+        process.env.AXON_FORCE_FULL_LOGO ||
+        process.env.AXON_SYNTAX_HIGHLIGHT ||
+        process.env.DISABLE_MICROCOMPACT ||
+        process.env.DISABLE_COST_WARNINGS ||
+        process.env.ENABLE_INCREMENTAL_TUI) {
+        config.ui = {
+            disableAttachments: parseEnvBoolean(process.env.AXON_DISABLE_ATTACHMENTS),
+            disableAxonMds: parseEnvBoolean(process.env.AXON_DISABLE_AXON_MDS),
+            disableFeedbackSurvey: parseEnvBoolean(process.env.AXON_DISABLE_FEEDBACK_SURVEY),
+            disableTerminalTitle: parseEnvBoolean(process.env.AXON_DISABLE_TERMINAL_TITLE),
+            enableTokenUsageAttachment: parseEnvBoolean(process.env.AXON_ENABLE_TOKEN_USAGE_ATTACHMENT),
+            forceFullLogo: parseEnvBoolean(process.env.AXON_FORCE_FULL_LOGO),
+            syntaxHighlight: parseEnvBoolean(process.env.AXON_SYNTAX_HIGHLIGHT) ?? true,
+            microcompact: !parseEnvBoolean(process.env.DISABLE_MICROCOMPACT),
+            disableCostWarnings: parseEnvBoolean(process.env.DISABLE_COST_WARNINGS),
+            enableIncrementalTui: parseEnvBoolean(process.env.ENABLE_INCREMENTAL_TUI),
+        };
+    }
+    // ===== 调试配置扩展 =====
+    if (process.env.AXON_DIAGNOSTICS_FILE ||
+        process.env.AXON_PROFILE_QUERY ||
+        process.env.AXON_PROFILE_STARTUP ||
+        process.env.AXON_ENABLE_SDK_FILE_CHECKPOINTING) {
+        config.debug = {
+            diagnosticsFile: process.env.AXON_DIAGNOSTICS_FILE,
+            profileQuery: parseEnvBoolean(process.env.AXON_PROFILE_QUERY),
+            profileStartup: parseEnvBoolean(process.env.AXON_PROFILE_STARTUP),
+            enableSdkFileCheckpointing: parseEnvBoolean(process.env.AXON_ENABLE_SDK_FILE_CHECKPOINTING),
+        };
+    }
+    // ===== 网络配置 =====
+    if (process.env.AXON_PROXY_RESOLVES_HOSTS ||
+        process.env.AXON_DISABLE_NONESSENTIAL_TRAFFIC) {
+        config.network = {
+            proxyResolvesHosts: parseEnvBoolean(process.env.AXON_PROXY_RESOLVES_HOSTS),
+            disableNonessentialTraffic: parseEnvBoolean(process.env.AXON_DISABLE_NONESSENTIAL_TRAFFIC),
+        };
+    }
+    // ===== 工具配置 =====
+    if (process.env.AXON_MAX_TOOL_USE_CONCURRENCY ||
+        process.env.ENABLE_TOOL_SEARCH ||
+        process.env.AXON_USE_NATIVE_FILE_SEARCH ||
+        process.env.ENABLE_BASH_ENV_VAR_MATCHING ||
+        process.env.ENABLE_BASH_WRAPPER_MATCHING) {
+        config.tools = {
+            maxConcurrency: parseEnvNumber(process.env.AXON_MAX_TOOL_USE_CONCURRENCY),
+            enableSearch: parseEnvBoolean(process.env.ENABLE_TOOL_SEARCH),
+            useNativeFileSearch: parseEnvBoolean(process.env.AXON_USE_NATIVE_FILE_SEARCH),
+            enableBashEnvVarMatching: parseEnvBoolean(process.env.ENABLE_BASH_ENV_VAR_MATCHING),
+            enableBashWrapperMatching: parseEnvBoolean(process.env.ENABLE_BASH_WRAPPER_MATCHING),
+        };
+    }
+    // ===== Beta 功能 =====
+    if (process.env.ENABLE_CODE_GUIDE_SUBAGENT ||
+        process.env.ENABLE_BETA_TRACING_DETAILED ||
+        process.env.ENABLE_ENHANCED_TELEMETRY_BETA ||
+        process.env.AXON_DISABLE_EXPERIMENTAL_BETAS) {
+        config.beta = {
+            enableCodeGuideSubagent: parseEnvBoolean(process.env.ENABLE_CODE_GUIDE_SUBAGENT),
+            enableTracingDetailed: parseEnvBoolean(process.env.ENABLE_BETA_TRACING_DETAILED),
+            enableEnhancedTelemetry: parseEnvBoolean(process.env.ENABLE_ENHANCED_TELEMETRY_BETA),
+            disableExperimentalBetas: parseEnvBoolean(process.env.AXON_DISABLE_EXPERIMENTAL_BETAS),
+        };
+    }
+    // ===== 杂项配置 =====
+    if (process.env.AXON_TAGS) {
+        if (!config.misc)
+            config.misc = {};
+        config.misc.tags = process.env.AXON_TAGS.split(',').map((s) => s.trim());
+    }
+    if (process.env.AXON_TEAM_NAME) {
+        if (!config.misc)
+            config.misc = {};
+        config.misc.teamName = process.env.AXON_TEAM_NAME;
+    }
+    if (process.env.AXON_EXTRA_BODY) {
+        if (!config.misc)
+            config.misc = {};
+        try {
+            config.misc.extraBody = JSON.parse(process.env.AXON_EXTRA_BODY);
+        }
+        catch (e) {
+            console.warn('Failed to parse AXON_EXTRA_BODY:', e);
+        }
+    }
+    if (process.env.AXON_TEST_FIXTURES_ROOT ||
+        process.env.AXON_ENTRYPOINT ||
+        process.env.DISABLE_ERROR_REPORTING ||
+        process.env.DISABLE_AUTOUPDATER ||
+        process.env.DISABLE_INSTALLATION_CHECKS ||
+        process.env.DISABLE_AUTO_MIGRATE_TO_NATIVE) {
+        if (!config.misc)
+            config.misc = {};
+        config.misc.testFixturesRoot = process.env.AXON_TEST_FIXTURES_ROOT;
+        config.misc.entrypoint = process.env.AXON_ENTRYPOINT;
+        config.misc.disableErrorReporting = parseEnvBoolean(process.env.DISABLE_ERROR_REPORTING);
+        config.misc.disableAutoUpdater = parseEnvBoolean(process.env.DISABLE_AUTOUPDATER);
+        config.misc.disableInstallationChecks = parseEnvBoolean(process.env.DISABLE_INSTALLATION_CHECKS);
+        config.misc.disableAutoMigrateToNative = parseEnvBoolean(process.env.DISABLE_AUTO_MIGRATE_TO_NATIVE);
+    }
+    // ===== 命令禁用 =====
+    if (process.env.DISABLE_LOGIN_COMMAND ||
+        process.env.DISABLE_LOGOUT_COMMAND ||
+        process.env.DISABLE_BUG_COMMAND ||
+        process.env.DISABLE_DOCTOR_COMMAND ||
+        process.env.DISABLE_FEEDBACK_COMMAND ||
+        process.env.DISABLE_INSTALL_GITHUB_APP_COMMAND ||
+        process.env.DISABLE_UPGRADE_COMMAND ||
+        process.env.DISABLE_EXTRA_USAGE_COMMAND) {
+        config.disableCommands = {
+            login: parseEnvBoolean(process.env.DISABLE_LOGIN_COMMAND),
+            logout: parseEnvBoolean(process.env.DISABLE_LOGOUT_COMMAND),
+            bug: parseEnvBoolean(process.env.DISABLE_BUG_COMMAND),
+            doctor: parseEnvBoolean(process.env.DISABLE_DOCTOR_COMMAND),
+            feedback: parseEnvBoolean(process.env.DISABLE_FEEDBACK_COMMAND),
+            installGithubApp: parseEnvBoolean(process.env.DISABLE_INSTALL_GITHUB_APP_COMMAND),
+            upgrade: parseEnvBoolean(process.env.DISABLE_UPGRADE_COMMAND),
+            extraUsage: parseEnvBoolean(process.env.DISABLE_EXTRA_USAGE_COMMAND),
+        };
+    }
+    // ===== 文件描述符 =====
+    if (process.env.AXON_API_KEY_FILE_DESCRIPTOR ||
+        process.env.AXON_OAUTH_TOKEN_FILE_DESCRIPTOR ||
+        process.env.AXON_WEBSOCKET_AUTH_FILE_DESCRIPTOR ||
+        process.env.AXON_API_KEY_HELPER_TTL_MS) {
+        config.fileDescriptors = {
+            apiKey: parseEnvNumber(process.env.AXON_API_KEY_FILE_DESCRIPTOR),
+            oauthToken: parseEnvNumber(process.env.AXON_OAUTH_TOKEN_FILE_DESCRIPTOR),
+            websocketAuth: parseEnvNumber(process.env.AXON_WEBSOCKET_AUTH_FILE_DESCRIPTOR),
+            apiKeyHelperTtlMs: parseEnvNumber(process.env.AXON_API_KEY_HELPER_TTL_MS),
+        };
+    }
+    // ===== 最大重试和结构化输出 =====
+    if (process.env.MAX_STRUCTURED_OUTPUT_RETRIES) {
+        config.maxStructuredOutputRetries = parseEnvNumber(process.env.MAX_STRUCTURED_OUTPUT_RETRIES);
+    }
+    // ===== 遥测配置扩展 =====
+    if (process.env.AXON_OTEL_FLUSH_TIMEOUT_MS ||
+        process.env.AXON_OTEL_HEADERS_HELPER_DEBOUNCE_MS) {
+        if (!config.telemetry)
+            config.telemetry = {};
+        config.telemetry.otelFlushTimeoutMs = parseEnvNumber(process.env.AXON_OTEL_FLUSH_TIMEOUT_MS);
+        config.telemetry.otelHeadersHelperDebounceMs = parseEnvNumber(process.env.AXON_OTEL_HEADERS_HELPER_DEBOUNCE_MS);
+    }
+    return config;
+}
+const MIGRATIONS = [
+    {
+        version: '2.0.0',
+        migrate: (config) => {
+            // 迁移旧的模型名称
+            if (config.model === 'claude-3-opus')
+                config.model = 'opus';
+            if (config.model === 'claude-3-sonnet')
+                config.model = 'sonnet';
+            if (config.model === 'claude-3-haiku')
+                config.model = 'haiku';
+            return config;
+        },
+    },
+    {
+        version: '2.1.4',
+        migrate: (config) => {
+            // 添加新字段的默认值
+            if (!config.version)
+                config.version = '2.1.4';
+            if (config.autoSave !== undefined) {
+                config.enableAutoSave = config.autoSave;
+                delete config.autoSave;
+            }
+            return config;
+        },
+    },
+];
+function migrateConfig(config) {
+    const currentVersion = config.version || '1.0.0';
+    let migratedConfig = { ...config };
+    for (const migration of MIGRATIONS) {
+        if (compareVersions(currentVersion, migration.version) < 0) {
+            migratedConfig = migration.migrate(migratedConfig);
+        }
+    }
+    migratedConfig.version = VERSION;
+    return migratedConfig;
+}
+function compareVersions(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const p1 = parts1[i] || 0;
+        const p2 = parts2[i] || 0;
+        if (p1 < p2)
+            return -1;
+        if (p1 > p2)
+            return 1;
+    }
+    return 0;
+}
+// 优先级映射
+export const CONFIG_SOURCE_PRIORITY = {
+    'default': 0,
+    'userSettings': 1,
+    'projectSettings': 2,
+    'localSettings': 3,
+    'envSettings': 4,
+    'flagSettings': 5,
+    'policySettings': 6, // 最高优先级
+    'plugin': 3, // 与 localSettings 同级
+    'built-in': 0, // 与 default 同级
+};
+export class ConfigManager {
+    globalConfigDir;
+    userConfigFile; // 用户配置 (~/.axon/settings.json)
+    projectConfigFile; // 项目配置 (.axon/settings.json)
+    localConfigFile; // 本地配置 (.axon/settings.local.json) - 官方命名
+    policyConfigFile; // 企业策略配置 (~/.axon/managed_settings.json)
+    flagConfigFile; // 标志配置文件 (命令行指定的配置文件)
+    mergedConfig;
+    configSources = new Map(); // 记录每个配置项的来源
+    configSourcePaths = new Map(); // 记录每个配置项的来源路径
+    configHistory = new Map(); // 记录配置项的覆盖历史
+    watchers = [];
+    reloadCallbacks = [];
+    debugMode;
+    cliFlags;
+    enterprisePolicy;
+    loadedSources = [];
+    constructor(options) {
+        this.debugMode = options?.debugMode ?? (process.env.AXON_DEBUG === 'true');
+        this.cliFlags = options?.cliFlags;
+        const workingDir = options?.workingDirectory ?? process.cwd();
+        // 全局配置目录
+        this.globalConfigDir = process.env.AXON_CONFIG_DIR ||
+            path.join(process.env.HOME || process.env.USERPROFILE || '~', '.axon');
+        // 用户配置文件 (~/.axon/settings.json)
+        this.userConfigFile = path.join(this.globalConfigDir, 'settings.json');
+        // 企业策略配置文件 (~/.axon/managed_settings.json) - 官方命名
+        // 同时支持 policy.json 作为备选
+        const managedSettingsPath = path.join(this.globalConfigDir, 'managed_settings.json');
+        const policyJsonPath = path.join(this.globalConfigDir, 'policy.json');
+        this.policyConfigFile = fs.existsSync(managedSettingsPath) ? managedSettingsPath : policyJsonPath;
+        // 项目配置文件 (.axon/settings.json)
+        this.projectConfigFile = path.join(workingDir, '.axon', 'settings.json');
+        // 本地配置文件 (.axon/settings.local.json) - 官方命名，应添加到 .gitignore
+        this.localConfigFile = path.join(workingDir, '.axon', 'settings.local.json');
+        // 标志配置文件 (通过命令行 --settings 指定)
+        this.flagConfigFile = options?.flagSettingsPath;
+        // 验证环境变量
+        this.validateEnvironmentVariables();
+        // 加载并合并配置
+        this.mergedConfig = this.loadAndMergeConfig();
+        // 调试输出
+        if (this.debugMode) {
+            this.printDebugInfo();
+        }
+    }
+    /**
+     * 验证所有环境变量
+     */
+    validateEnvironmentVariables() {
+        // 验证环境变量并记录结果
+        const results = envManager.validateAll();
+        // 输出验证警告
+        for (const [name, result] of results) {
+            if (result.status === 'invalid') {
+                console.warn(`[Config] Invalid environment variable ${name}: ${result.message}`);
+            }
+            else if (result.status === 'capped') {
+                console.warn(`[Config] Environment variable ${name} capped: ${result.message}`);
+            }
+        }
+    }
+    /**
+     * 加载并合并所有配置源
+     *
+     * 官方优先级链（从低到高）:
+     * 1. default - 内置默认值
+     * 2. userSettings - 用户全局配置 (~/.axon/settings.json)
+     * 3. projectSettings - 项目配置 (.axon/settings.json)
+     * 4. localSettings - 本地配置 (.axon/settings.local.json)
+     * 5. envSettings - 环境变量
+     * 6. flagSettings - 命令行标志
+     * 7. policySettings - 企业策略（最高优先级，强制覆盖）
+     */
+    loadAndMergeConfig() {
+        this.configSources.clear();
+        this.configSourcePaths.clear();
+        this.configHistory.clear();
+        this.loadedSources = [];
+        const loadTime = new Date();
+        // 1. 默认配置 (优先级 0)
+        let config = { ...DEFAULT_CONFIG };
+        this.trackConfigSource(config, 'default');
+        this.loadedSources.push({
+            source: 'default',
+            priority: CONFIG_SOURCE_PRIORITY.default,
+            exists: true,
+            loadedAt: loadTime,
+        });
+        // 2. 加载企业策略（如果存在）以获取默认值
+        this.enterprisePolicy = this.loadEnterprisePolicy();
+        if (this.enterprisePolicy?.defaults) {
+            // 企业策略的默认值会被用户设置覆盖
+            config = this.mergeConfig(config, this.enterprisePolicy.defaults, 'policySettings', this.policyConfigFile);
+            this.debugLog('Loaded enterprise policy defaults');
+        }
+        // 3. 用户配置 (~/.axon/settings.json) (优先级 1)
+        const userConfigExists = fs.existsSync(this.userConfigFile);
+        this.loadedSources.push({
+            source: 'userSettings',
+            path: this.userConfigFile,
+            priority: CONFIG_SOURCE_PRIORITY.userSettings,
+            exists: userConfigExists,
+            loadedAt: loadTime,
+        });
+        if (userConfigExists) {
+            const userConfig = this.loadConfigFile(this.userConfigFile);
+            if (userConfig) {
+                config = this.mergeConfig(config, userConfig, 'userSettings', this.userConfigFile);
+                this.debugLog(`Loaded user settings from ${this.userConfigFile}`);
+            }
+        }
+        // 4. 项目配置 (.axon/settings.json) (优先级 2)
+        const projectConfigExists = fs.existsSync(this.projectConfigFile);
+        this.loadedSources.push({
+            source: 'projectSettings',
+            path: this.projectConfigFile,
+            priority: CONFIG_SOURCE_PRIORITY.projectSettings,
+            exists: projectConfigExists,
+            loadedAt: loadTime,
+        });
+        if (projectConfigExists) {
+            const projectConfig = this.loadConfigFile(this.projectConfigFile);
+            if (projectConfig) {
+                config = this.mergeConfig(config, projectConfig, 'projectSettings', this.projectConfigFile);
+                this.debugLog(`Loaded project settings from ${this.projectConfigFile}`);
+            }
+        }
+        // 5. 本地配置 (.axon/settings.local.json) (优先级 3)
+        const localConfigExists = fs.existsSync(this.localConfigFile);
+        this.loadedSources.push({
+            source: 'localSettings',
+            path: this.localConfigFile,
+            priority: CONFIG_SOURCE_PRIORITY.localSettings,
+            exists: localConfigExists,
+            loadedAt: loadTime,
+        });
+        if (localConfigExists) {
+            const localConfig = this.loadConfigFile(this.localConfigFile);
+            if (localConfig) {
+                config = this.mergeConfig(config, localConfig, 'localSettings', this.localConfigFile);
+                this.debugLog(`Loaded local settings from ${this.localConfigFile}`);
+            }
+        }
+        // 6. 环境变量 (优先级 4)
+        const envConfig = getEnvConfig();
+        const envKeys = Object.keys(envConfig).filter(k => envConfig[k] !== undefined);
+        if (envKeys.length > 0) {
+            config = this.mergeConfig(config, envConfig, 'envSettings');
+            this.loadedSources.push({
+                source: 'envSettings',
+                priority: CONFIG_SOURCE_PRIORITY.envSettings,
+                exists: true,
+                loadedAt: loadTime,
+            });
+            this.debugLog(`Loaded ${envKeys.length} settings from environment variables`);
+        }
+        // 7. CLI 标志配置 (优先级 5)
+        // 7a. 从配置文件加载（如果指定了 --settings）
+        if (this.flagConfigFile) {
+            const flagConfigExists = fs.existsSync(this.flagConfigFile);
+            this.loadedSources.push({
+                source: 'flagSettings',
+                path: this.flagConfigFile,
+                priority: CONFIG_SOURCE_PRIORITY.flagSettings,
+                exists: flagConfigExists,
+                loadedAt: loadTime,
+            });
+            if (flagConfigExists) {
+                const flagConfig = this.loadConfigFile(this.flagConfigFile);
+                if (flagConfig) {
+                    config = this.mergeConfig(config, flagConfig, 'flagSettings', this.flagConfigFile);
+                    this.debugLog(`Loaded flag settings from ${this.flagConfigFile}`);
+                }
+            }
+        }
+        // 7b. 直接传入的 CLI 标志（最高用户可控优先级）
+        if (this.cliFlags) {
+            const cliKeys = Object.keys(this.cliFlags).filter(k => this.cliFlags[k] !== undefined);
+            if (cliKeys.length > 0) {
+                config = this.mergeConfig(config, this.cliFlags, 'flagSettings');
+                this.debugLog(`Applied ${cliKeys.length} CLI flag overrides`);
+            }
+        }
+        // 8. 企业策略强制设置 (优先级 6 - 最高)
+        // 强制设置会覆盖所有用户配置
+        if (this.enterprisePolicy?.enforced) {
+            config = this.mergeConfig(config, this.enterprisePolicy.enforced, 'policySettings', this.policyConfigFile);
+            this.loadedSources.push({
+                source: 'policySettings',
+                path: this.policyConfigFile,
+                priority: CONFIG_SOURCE_PRIORITY.policySettings,
+                exists: true,
+                loadedAt: loadTime,
+            });
+            this.debugLog('Applied enterprise policy enforced settings (highest priority)');
+        }
+        // 9. 迁移配置
+        config = migrateConfig(config);
+        // 10. 验证配置
+        try {
+            const validated = UserConfigSchema.parse(config);
+            // 10a. 检查未知字段（参考 OpenClaw .strict() 模式，但不拒绝，只告警）
+            this.warnUnknownFields(config);
+            return validated;
+        }
+        catch (error) {
+            // v2.1.33: 改进错误展示 - 将验证错误详细展示给用户
+            if (error?.issues) {
+                const details = error.issues.map((issue) => `- ${issue.path?.join('.') || 'root'}: ${issue.message}`).join('\n');
+                console.error(`Error processing settings:\n${details}`);
+            }
+            else {
+                console.warn('Config validation failed, using defaults:', error);
+            }
+            return UserConfigSchema.parse(DEFAULT_CONFIG);
+        }
+    }
+    /**
+     * 检查配置中的未知字段并输出告警
+     * 参考 OpenClaw 的 .strict() 模式，但不拒绝配置，只告警
+     */
+    warnUnknownFields(config) {
+        if (!config || typeof config !== 'object')
+            return;
+        // UserConfigSchema 定义的合法顶层字段
+        const knownFields = new Set(Object.keys(UserConfigSchema.shape));
+        // 扩展系统使用但不在 schema 中定义的合法字段
+        const extensionFields = new Set([
+            'channels', 'connectors', 'plugins', 'hooks', 'customTools',
+            'browserSettings', 'skills', 'marketplace', 'web',
+        ]);
+        const unknownFields = [];
+        for (const key of Object.keys(config)) {
+            if (!knownFields.has(key) && !extensionFields.has(key)) {
+                unknownFields.push(key);
+            }
+        }
+        if (unknownFields.length > 0) {
+            console.warn(`[Config] Unknown fields in settings.json (possible typos): ${unknownFields.join(', ')}`);
+        }
+    }
+    /**
+     * 加载企业策略配置
+     */
+    loadEnterprisePolicy() {
+        try {
+            if (fs.existsSync(this.policyConfigFile)) {
+                const content = fs.readFileSync(this.policyConfigFile, 'utf-8');
+                const policy = JSON.parse(content);
+                this.debugLog(`Loaded enterprise policy from ${this.policyConfigFile}`);
+                return policy;
+            }
+        }
+        catch (error) {
+            // v2.1.33: 将 managed settings 错误直接展示给用户
+            // 之前只在 debug 模式下输出，现在总是展示
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`Error processing settings: ${errorMsg}`);
+            this.debugLog(`Failed to load enterprise policy: ${error}`);
+        }
+        return undefined;
+    }
+    /**
+     * 调试日志
+     */
+    debugLog(message) {
+        if (this.debugMode) {
+            console.log(`[Config] ${message}`);
+        }
+    }
+    /**
+     * 打印调试信息
+     */
+    printDebugInfo() {
+        console.log('\n=== Configuration Debug Info ===');
+        console.log('Loaded sources:');
+        for (const source of this.loadedSources) {
+            const status = source.exists ? 'OK' : 'NOT FOUND';
+            const pathInfo = source.path ? ` (${source.path})` : '';
+            console.log(`  [${source.priority}] ${source.source}${pathInfo}: ${status}`);
+        }
+        console.log('\nConfiguration key sources:');
+        const sources = this.getAllConfigSources();
+        for (const [key, source] of sources) {
+            const sourcePath = this.configSourcePaths.get(key);
+            const pathInfo = sourcePath ? ` (${sourcePath})` : '';
+            console.log(`  ${key}: ${source}${pathInfo}`);
+        }
+        if (this.enterprisePolicy) {
+            console.log('\nEnterprise policy:');
+            if (this.enterprisePolicy.enforced) {
+                console.log('  Enforced keys:', Object.keys(this.enterprisePolicy.enforced).join(', '));
+            }
+            if (this.enterprisePolicy.disabledFeatures?.length) {
+                console.log('  Disabled features:', this.enterprisePolicy.disabledFeatures.join(', '));
+            }
+        }
+        console.log('================================\n');
+    }
+    /**
+     * 合并配置并追踪来源
+     */
+    mergeConfig(base, override, source, sourcePath) {
+        const merged = this.deepMerge(base, override);
+        this.trackConfigSource(override, source, sourcePath);
+        return merged;
+    }
+    /**
+     * 深度合并对象
+     */
+    deepMerge(base, override) {
+        if (override === undefined)
+            return base;
+        if (base === undefined)
+            return override;
+        if (typeof override !== 'object' || override === null)
+            return override;
+        if (typeof base !== 'object' || base === null)
+            return override;
+        if (Array.isArray(override))
+            return override;
+        const result = { ...base };
+        for (const key of Object.keys(override)) {
+            if (override[key] !== undefined) {
+                if (typeof override[key] === 'object' && !Array.isArray(override[key]) && override[key] !== null) {
+                    result[key] = this.deepMerge(base[key], override[key]);
+                }
+                else {
+                    result[key] = override[key];
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 追踪配置项来源
+     */
+    trackConfigSource(config, source, sourcePath) {
+        this.trackConfigSourceRecursive(config, source, sourcePath, '');
+    }
+    /**
+     * 递归追踪配置项来源
+     */
+    trackConfigSourceRecursive(config, source, sourcePath, prefix) {
+        if (config === undefined || config === null)
+            return;
+        if (typeof config !== 'object')
+            return;
+        for (const key of Object.keys(config)) {
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            const value = config[key];
+            if (value !== undefined) {
+                // 记录当前来源
+                const previousSource = this.configSources.get(fullKey);
+                // 追踪覆盖历史
+                if (previousSource && previousSource !== source) {
+                    const history = this.configHistory.get(fullKey) || [];
+                    history.push({
+                        key: fullKey,
+                        value,
+                        source,
+                        sourcePath,
+                        overriddenBy: previousSource ? [previousSource] : undefined,
+                    });
+                    this.configHistory.set(fullKey, history);
+                }
+                // 更新当前来源
+                this.configSources.set(fullKey, source);
+                if (sourcePath) {
+                    this.configSourcePaths.set(fullKey, sourcePath);
+                }
+                // 递归处理嵌套对象
+                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                    this.trackConfigSourceRecursive(value, source, sourcePath, fullKey);
+                }
+            }
+        }
+    }
+    /**
+     * 从文件加载配置
+     */
+    loadConfigFile(filePath) {
+        try {
+            if (fs.existsSync(filePath)) {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to load config file: ${filePath}`, error);
+        }
+        return null;
+    }
+    /**
+     * 保存配置到用户配置文件 (旧名: 全局配置)
+     */
+    save(config) {
+        if (config) {
+            this.mergedConfig = UserConfigSchema.parse({
+                ...this.mergedConfig,
+                ...config,
+            });
+        }
+        if (!fs.existsSync(this.globalConfigDir)) {
+            fs.mkdirSync(this.globalConfigDir, { recursive: true });
+        }
+        // 备份现有配置
+        this.backupConfig(this.userConfigFile);
+        // 读取当前文件中的内容作为基础
+        let fileContent = {};
+        try {
+            if (fs.existsSync(this.userConfigFile)) {
+                fileContent = JSON.parse(fs.readFileSync(this.userConfigFile, 'utf-8'));
+            }
+        }
+        catch {
+            // 文件读取失败，忽略
+        }
+        // 只把本次 config 参数中的字段合并到文件内容上，不写入整个 mergedConfig
+        // 这样环境变量、项目配置等其他来源的值不会被"烘焙"到用户配置文件
+        const output = config
+            ? { ...fileContent, ...config }
+            : { ...fileContent };
+        // 处理显式设为 undefined 的属性：从 output 中删除
+        for (const key of Object.keys(output)) {
+            if (output[key] === undefined) {
+                delete output[key];
+            }
+        }
+        fs.writeFileSync(this.userConfigFile, JSON.stringify(output, null, 2), 'utf-8');
+    }
+    /**
+     * 保存到本地配置文件 (.axon/settings.local.json)
+     * 此文件应添加到 .gitignore，用于机器特定的配置
+     */
+    saveLocal(config) {
+        const localDir = path.dirname(this.localConfigFile);
+        if (!fs.existsSync(localDir)) {
+            fs.mkdirSync(localDir, { recursive: true });
+        }
+        // 检查配置项是否被企业策略强制
+        if (this.enterprisePolicy?.enforced) {
+            const enforcedKeys = Object.keys(this.enterprisePolicy.enforced);
+            const attemptedEnforcedKeys = Object.keys(config).filter(k => enforcedKeys.includes(k));
+            if (attemptedEnforcedKeys.length > 0) {
+                console.warn(`Cannot save the following settings locally - they are enforced by enterprise policy: ${attemptedEnforcedKeys.join(', ')}`);
+                // 移除被强制的配置项
+                for (const key of attemptedEnforcedKeys) {
+                    delete config[key];
+                }
+            }
+        }
+        const currentLocalConfig = this.loadConfigFile(this.localConfigFile) || {};
+        const newLocalConfig = this.deepMerge(currentLocalConfig, config);
+        this.backupConfig(this.localConfigFile);
+        fs.writeFileSync(this.localConfigFile, JSON.stringify(newLocalConfig, null, 2), 'utf-8');
+        // 确保 .gitignore 包含 settings.local.json
+        this.ensureGitignore(localDir);
+        this.reload();
+    }
+    /**
+     * 确保 .gitignore 包含 settings.local.json
+     */
+    ensureGitignore(claudeDir) {
+        const projectRoot = path.dirname(claudeDir);
+        const gitignorePath = path.join(projectRoot, '.gitignore');
+        try {
+            let content = '';
+            if (fs.existsSync(gitignorePath)) {
+                content = fs.readFileSync(gitignorePath, 'utf-8');
+            }
+            const patterns = [
+                '.axon/settings.local.json',
+                '# Axon local settings (machine-specific)',
+            ];
+            const linesToAdd = [];
+            for (const pattern of patterns) {
+                if (!content.includes(pattern)) {
+                    linesToAdd.push(pattern);
+                }
+            }
+            if (linesToAdd.length > 0) {
+                const newContent = content.trim() + '\n\n' + linesToAdd.join('\n') + '\n';
+                fs.writeFileSync(gitignorePath, newContent, 'utf-8');
+                this.debugLog(`Added settings.local.json to .gitignore`);
+            }
+        }
+        catch (error) {
+            // 忽略 .gitignore 更新失败
+            this.debugLog(`Failed to update .gitignore: ${error}`);
+        }
+    }
+    /**
+     * 保存到项目配置文件
+     */
+    saveProject(config) {
+        const projectDir = path.dirname(this.projectConfigFile);
+        if (!fs.existsSync(projectDir)) {
+            fs.mkdirSync(projectDir, { recursive: true });
+        }
+        const currentProjectConfig = this.loadConfigFile(this.projectConfigFile) || {};
+        const newProjectConfig = { ...currentProjectConfig, ...config };
+        fs.writeFileSync(this.projectConfigFile, JSON.stringify(newProjectConfig, null, 2), 'utf-8');
+        this.reload();
+    }
+    /**
+     * 重新加载配置
+     */
+    reload() {
+        this.mergedConfig = this.loadAndMergeConfig();
+        this.reloadCallbacks.forEach(cb => cb(this.mergedConfig));
+    }
+    /**
+     * 监听配置变化（热重载）
+     */
+    watch(callback) {
+        this.reloadCallbacks.push(callback);
+        // 要监听的配置文件列表
+        const filesToWatch = [
+            this.userConfigFile,
+            this.projectConfigFile,
+            this.localConfigFile,
+            this.policyConfigFile,
+        ];
+        if (this.flagConfigFile) {
+            filesToWatch.push(this.flagConfigFile);
+        }
+        // 监听所有配置文件
+        for (const file of filesToWatch) {
+            if (fs.existsSync(file)) {
+                const watcher = fs.watch(file, () => {
+                    this.reload();
+                });
+                this.watchers.push(watcher);
+            }
+        }
+    }
+    /**
+     * 停止监听
+     */
+    unwatch() {
+        this.watchers.forEach(watcher => watcher.close());
+        this.watchers = [];
+        this.reloadCallbacks = [];
+    }
+    /**
+     * 获取配置项
+     */
+    get(key) {
+        return this.mergedConfig[key];
+    }
+    /**
+     * 设置配置项
+     */
+    set(key, value) {
+        this.mergedConfig[key] = value;
+        this.save({ [key]: value });
+    }
+    /**
+     * 获取所有配置
+     */
+    getAll() {
+        return { ...this.mergedConfig };
+    }
+    /**
+     * 获取 API 密钥
+     */
+    getApiKey() {
+        return this.mergedConfig.apiKey;
+    }
+    /**
+     * 获取验证后的环境变量值
+     */
+    getValidatedEnv(name) {
+        return getValidatedEnv(name);
+    }
+    /**
+     * 获取环境变量管理器
+     */
+    getEnvManager() {
+        return envManager;
+    }
+    /**
+     * 导出配置（掩码敏感信息）
+     */
+    export(maskSecrets = true) {
+        const config = { ...this.mergedConfig };
+        if (maskSecrets) {
+            // 使用统一的敏感字段掩码函数
+            const masked = maskSensitiveFields(config);
+            return JSON.stringify(masked, null, 2);
+        }
+        return JSON.stringify(config, null, 2);
+    }
+    /**
+     * 导入配置
+     */
+    import(configJson) {
+        try {
+            const config = JSON.parse(configJson);
+            const validated = UserConfigSchema.parse(config);
+            this.mergedConfig = validated;
+            this.save(validated);
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to import config:', error);
+            return false;
+        }
+    }
+    /**
+     * 验证配置
+     */
+    validate() {
+        try {
+            UserConfigSchema.parse(this.mergedConfig);
+            return { valid: true };
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                return { valid: false, errors: error };
+            }
+            return { valid: false };
+        }
+    }
+    /**
+     * 重置为默认配置
+     */
+    reset() {
+        const defaults = UserConfigSchema.parse(DEFAULT_CONFIG);
+        this.mergedConfig = defaults;
+        this.save(defaults);
+    }
+    // ============ 配置来源查询 ============
+    /**
+     * 获取配置项的来源
+     */
+    getConfigSource(key) {
+        return this.configSources.get(String(key));
+    }
+    /**
+     * 获取所有配置来源
+     */
+    getAllConfigSources() {
+        return new Map(this.configSources);
+    }
+    /**
+     * 获取配置来源信息
+     */
+    getConfigSourceInfo() {
+        return [...this.loadedSources];
+    }
+    /**
+     * 获取所有可能的配置来源（包括未加载的）
+     */
+    getAllPossibleSources() {
+        return [
+            { source: 'default', priority: CONFIG_SOURCE_PRIORITY.default, exists: true },
+            { source: 'userSettings', path: this.userConfigFile, priority: CONFIG_SOURCE_PRIORITY.userSettings, exists: fs.existsSync(this.userConfigFile) },
+            { source: 'projectSettings', path: this.projectConfigFile, priority: CONFIG_SOURCE_PRIORITY.projectSettings, exists: fs.existsSync(this.projectConfigFile) },
+            { source: 'localSettings', path: this.localConfigFile, priority: CONFIG_SOURCE_PRIORITY.localSettings, exists: fs.existsSync(this.localConfigFile) },
+            { source: 'envSettings', priority: CONFIG_SOURCE_PRIORITY.envSettings, exists: true },
+            { source: 'flagSettings', path: this.flagConfigFile, priority: CONFIG_SOURCE_PRIORITY.flagSettings, exists: this.flagConfigFile ? fs.existsSync(this.flagConfigFile) : false },
+            { source: 'policySettings', path: this.policyConfigFile, priority: CONFIG_SOURCE_PRIORITY.policySettings, exists: fs.existsSync(this.policyConfigFile) },
+        ];
+    }
+    /**
+     * 获取配置项及其来源
+     */
+    getWithSource(key) {
+        const keyStr = String(key);
+        return {
+            value: this.mergedConfig[key],
+            source: this.configSources.get(keyStr) || 'default',
+            sourcePath: this.configSourcePaths.get(keyStr),
+        };
+    }
+    /**
+     * 获取配置项的覆盖历史
+     */
+    getConfigHistory(key) {
+        return this.configHistory.get(key) || [];
+    }
+    /**
+     * 获取所有配置项的详细来源信息
+     */
+    getAllConfigDetails() {
+        const details = [];
+        for (const [key, source] of this.configSources) {
+            details.push({
+                key,
+                value: this.getNestedValue(this.mergedConfig, key),
+                source,
+                sourcePath: this.configSourcePaths.get(key),
+                overriddenBy: this.getConfigHistory(key).map(h => h.source),
+            });
+        }
+        return details;
+    }
+    /**
+     * 获取嵌套值
+     */
+    getNestedValue(obj, path) {
+        const keys = path.split('.');
+        let current = obj;
+        for (const key of keys) {
+            if (current === undefined || current === null)
+                return undefined;
+            current = current[key];
+        }
+        return current;
+    }
+    /**
+     * 检查配置项是否被企业策略强制
+     */
+    isEnforcedByPolicy(key) {
+        if (!this.enterprisePolicy?.enforced)
+            return false;
+        return key in this.enterprisePolicy.enforced;
+    }
+    /**
+     * 获取企业策略信息
+     */
+    getEnterprisePolicy() {
+        return this.enterprisePolicy;
+    }
+    /**
+     * 检查功能是否被企业策略禁用
+     */
+    isFeatureDisabled(feature) {
+        return this.enterprisePolicy?.disabledFeatures?.includes(feature) ?? false;
+    }
+    /**
+     * 获取配置文件路径
+     */
+    getConfigPaths() {
+        return {
+            userSettings: this.userConfigFile,
+            projectSettings: this.projectConfigFile,
+            localSettings: this.localConfigFile,
+            policySettings: this.policyConfigFile,
+            flagSettings: this.flagConfigFile || '',
+            globalConfigDir: this.globalConfigDir,
+        };
+    }
+    // ============ 配置备份和恢复 ============
+    /**
+     * 备份配置文件
+     * v2.1.6 修复: 检查是否已存在相同内容的备份，避免重复备份文件累积
+     */
+    backupConfig(filePath) {
+        if (!fs.existsSync(filePath))
+            return;
+        const backupDir = path.join(path.dirname(filePath), '.backups');
+        if (!fs.existsSync(backupDir)) {
+            fs.mkdirSync(backupDir, { recursive: true });
+        }
+        const filename = path.basename(filePath, '.json');
+        try {
+            // 读取当前配置文件内容
+            const currentContent = fs.readFileSync(filePath, { encoding: 'utf-8' });
+            // 获取现有备份文件列表
+            const existingBackups = fs.readdirSync(backupDir)
+                .filter(f => f.startsWith(filename) && f.endsWith('.json'));
+            // 检查是否已存在相同内容的备份
+            let duplicateFound = false;
+            for (const backupFile of existingBackups) {
+                try {
+                    const backupPath = path.join(backupDir, backupFile);
+                    const backupContent = fs.readFileSync(backupPath, { encoding: 'utf-8' });
+                    if (currentContent === backupContent) {
+                        duplicateFound = true;
+                        this.debugLog(`Skipping backup - identical content already exists: ${backupFile}`);
+                        break;
+                    }
+                }
+                catch {
+                    // 忽略无法读取的备份文件
+                }
+            }
+            // 如果没有找到相同内容的备份，才创建新备份
+            if (!duplicateFound) {
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const backupPath = path.join(backupDir, `${filename}.${timestamp}.json`);
+                fs.copyFileSync(filePath, backupPath);
+                this.debugLog(`Config backed up to: ${backupPath}`);
+            }
+            // 清理旧的备份文件
+            this.cleanOldBackups(backupDir, filename);
+        }
+        catch (error) {
+            console.warn(`Failed to backup config: ${error}`);
+        }
+    }
+    /**
+     * 清理旧的备份文件（保留最近10个）
+     */
+    cleanOldBackups(backupDir, filename) {
+        try {
+            const files = fs.readdirSync(backupDir)
+                .filter(f => f.startsWith(filename))
+                .map(f => ({
+                name: f,
+                path: path.join(backupDir, f),
+                mtime: fs.statSync(path.join(backupDir, f)).mtime,
+            }))
+                .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+            // 保留最近10个备份
+            files.slice(10).forEach(file => {
+                fs.unlinkSync(file.path);
+            });
+        }
+        catch (error) {
+            console.warn(`Failed to clean backups: ${error}`);
+        }
+    }
+    /**
+     * 列出可用的备份
+     */
+    listBackups(configType = 'user') {
+        const configFile = configType === 'user' ? this.userConfigFile :
+            configType === 'project' ? this.projectConfigFile :
+                this.localConfigFile;
+        const backupDir = path.join(path.dirname(configFile), '.backups');
+        if (!fs.existsSync(backupDir))
+            return [];
+        const filename = path.basename(configFile, '.json');
+        return fs.readdirSync(backupDir)
+            .filter(f => f.startsWith(filename))
+            .sort()
+            .reverse();
+    }
+    /**
+     * 从备份恢复配置
+     */
+    restoreFromBackup(backupFilename, configType = 'user') {
+        const configFile = configType === 'user' ? this.userConfigFile :
+            configType === 'project' ? this.projectConfigFile :
+                this.localConfigFile;
+        const backupDir = path.join(path.dirname(configFile), '.backups');
+        const backupPath = path.join(backupDir, backupFilename);
+        if (!fs.existsSync(backupPath)) {
+            console.error(`Backup file does not exist: ${backupPath}`);
+            return false;
+        }
+        try {
+            // 备份当前配置
+            this.backupConfig(configFile);
+            // 恢复备份
+            fs.copyFileSync(backupPath, configFile);
+            // 重新加载配置
+            this.reload();
+            return true;
+        }
+        catch (error) {
+            console.error(`Failed to restore backup: ${error}`);
+            return false;
+        }
+    }
+    // ============ MCP 服务器管理 ============
+    getMcpServers() {
+        return (this.mergedConfig.mcpServers || {});
+    }
+    addMcpServer(name, config) {
+        try {
+            // 验证 MCP 服务器配置
+            McpServerConfigSchema.parse(config);
+            if (!this.mergedConfig.mcpServers) {
+                this.mergedConfig.mcpServers = {};
+            }
+            this.mergedConfig.mcpServers[name] = config;
+            this.save({ mcpServers: this.mergedConfig.mcpServers });
+        }
+        catch (error) {
+            throw new Error(`Invalid MCP server configuration: ${error}`);
+        }
+    }
+    removeMcpServer(name) {
+        if (this.mergedConfig.mcpServers?.[name]) {
+            delete this.mergedConfig.mcpServers[name];
+            this.save({ mcpServers: this.mergedConfig.mcpServers });
+            return true;
+        }
+        return false;
+    }
+    updateMcpServer(name, config) {
+        if (this.mergedConfig.mcpServers?.[name]) {
+            const updated = { ...this.mergedConfig.mcpServers[name], ...config };
+            try {
+                McpServerConfigSchema.parse(updated);
+                this.mergedConfig.mcpServers[name] = updated;
+                this.save({ mcpServers: this.mergedConfig.mcpServers });
+                return true;
+            }
+            catch (error) {
+                throw new Error(`Invalid MCP server configuration: ${error}`);
+            }
+        }
+        return false;
+    }
+}
+// ============ 全局实例 ============
+export const configManager = new ConfigManager();
+// ============ 导出其他模块 ============
+export { AxonMdParser, axonMdParser, 
+// v2.1.2+ @include 二进制文件过滤辅助函数
+isTextFile, isBinaryFile, getTextFileExtensions, hasBinaryContent, } from './axon-md-parser.js';
+export { ConfigCommand, createConfigCommand } from './config-command.js';
+// ============ v2.1.18 Keybindings 模块导出 ============
+export { 
+// 常量
+DEFAULT_KEYBINDINGS, CHORD_KEYBINDINGS, 
+// 函数
+getReservedKeys, parseKeyString, normalizeKeyString, getKeybindingsPath, getDefaultBindings, isUserCustomizationEnabled, loadKeybindings, getKeybindings, initKeybindings, onKeybindingsChange, stopFileWatcher, generateTemplateContent, findKeybinding, getContextBindings, matchKeyInput, } from './keybindings.js';
+// ============ 重新导出环境变量模块 ============
+export { envValidatorRegistry, validateEnvVar, getValidatedEnvValue, validateAllEnvVars, 
+// 内置验证器
+BASH_MAX_OUTPUT_LENGTH, createBooleanValidator, createNumberRangeValidator, createEnumValidator, 
+// 敏感变量
+isSensitiveVar, maskSensitive, maskSensitiveFields, getSensitiveEnvVars, getMaskedSensitiveEnvVars, getSafeEnvVars, 
+// 管理器
+envManager, getValidatedEnv, validateAllEnv, exportSafeEnv, } from '../env/index.js';
+// ============ 环境变量配置（向后兼容） ============
+export const ENV_VARS = {
+    // API 配置（仍支持通过 env 设置 API Key 作为部署方式）
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY,
+    AXON_API_KEY: process.env.AXON_API_KEY,
+    AXON_OAUTH_TOKEN: process.env.AXON_OAUTH_TOKEN,
+    AXON_DEBUG_LOGS_DIR: process.env.AXON_DEBUG_LOGS_DIR,
+    // 以下已迁移到 settings.json：useBedrock, useVertex, maxTokens, maxRetries,
+    // enableTelemetry, disableFileCheckpointing, bashMaxOutputLength
+};
+//# sourceMappingURL=index.js.map