codexmate 0.0.54 → 0.0.56

package/cli.js

@@ -218,6 +218,29 @@ const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
 const CODEBUDDY_DIR = path.join(os.homedir(), '.codebuddy');
 const CODEBUDDY_PROJECTS_DIR = path.join(CODEBUDDY_DIR, 'projects');
 const CODEXMATE_DIR = path.join(os.homedir(), '.codexmate');
+const PROVIDER_CACHE_FILE_GROUPS = Object.freeze({
+    claude: [
+        'claude-providers.json'
+    ],
+    codex: [
+        'codex-providers.json',
+        'codex-provider-current-models.json'
+    ],
+    opencode: [
+        'opencode-providers.json',
+        'opencode-provider-current-models.json'
+    ]
+});
+const PROVIDER_CACHE_PROVIDER_FILES = Object.freeze([
+    'codex-providers.json',
+    'claude-providers.json',
+    'opencode-providers.json'
+]);
+const PROVIDER_CACHE_CURRENT_MODEL_FILES = Object.freeze([
+    'codex-provider-current-models.json',
+    'opencode-provider-current-models.json'
+]);
+const PROVIDER_CACHE_MAX_FILE_BYTES = 256 * 1024;
 const CODEXMATE_PREFERENCES_FILE = path.join(CODEXMATE_DIR, 'preferences.json');
 const CODEXMATE_OPENCODE_DIR = path.join(CODEXMATE_DIR, 'opencode');
 const CODEXMATE_OPENCODE_PROVIDER_STORE_FILE = path.join(CODEXMATE_OPENCODE_DIR, 'providers.json');
@@ -915,6 +938,102 @@ function writeCodexmatePreferences(preferences) {
     writeJsonAtomic(CODEXMATE_PREFERENCES_FILE, isPlainObject(preferences) ? preferences : {});
 }
 
+function normalizeShareCommandPrefixPreference(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return normalized === 'codexmate' ? 'codexmate' : 'npm start';
+}
+
+function normalizeBooleanPreference(value, defaultValue = true) {
+    if (value === true) return true;
+    if (value === false) return false;
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === '1' || normalized === 'true' || normalized === 'on' || normalized === 'yes') return true;
+    if (normalized === '0' || normalized === 'false' || normalized === 'off' || normalized === 'no') return false;
+    return defaultValue !== false;
+}
+
+function normalizeSessionTrashRetentionPreference(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric < 1) return 30;
+    return Math.min(365, Math.max(1, Math.floor(numeric)));
+}
+
+function normalizeSessionTimelineStylePreference(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return normalized === 'bar' ? 'bar' : 'dots';
+}
+
+function normalizeSettingsTabPreference(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return normalized === 'data' ? 'data' : 'general';
+}
+
+function normalizeMainTabPreference(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    const allowed = new Set(['dashboard', 'config', 'sessions', 'usage', 'orchestration', 'market', 'plugins', 'docs', 'settings', 'trash', 'prompts']);
+    return allowed.has(normalized) ? normalized : 'dashboard';
+}
+
+function normalizeConfigModePreference(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return ['codex', 'claude', 'openclaw', 'opencode'].includes(normalized) ? normalized : 'codex';
+}
+
+function normalizeUsageTimeRangePreference(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    if (normalized === 'all' || normalized === '30d') return normalized;
+    return '7d';
+}
+
+function normalizePromptsSubTabPreference(value) {
+    const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+    return normalized === 'claude-project' ? 'claude-project' : 'codex';
+}
+
+function normalizeWebUiPreferences(value = {}) {
+    const source = isPlainObject(value) ? value : {};
+    const navigation = isPlainObject(source.navigation) ? source.navigation : {};
+    return {
+        shareCommandPrefix: normalizeShareCommandPrefixPreference(source.shareCommandPrefix),
+        sessionTrashEnabled: normalizeBooleanPreference(source.sessionTrashEnabled, true),
+        sessionTrashRetentionDays: normalizeSessionTrashRetentionPreference(source.sessionTrashRetentionDays),
+        sessionTimelineStyle: normalizeSessionTimelineStylePreference(source.sessionTimelineStyle),
+        configTemplateDiffConfirmEnabled: normalizeBooleanPreference(source.configTemplateDiffConfirmEnabled, true),
+        sessionsUsageTimeRange: normalizeUsageTimeRangePreference(source.sessionsUsageTimeRange),
+        promptsSubTab: normalizePromptsSubTabPreference(source.promptsSubTab),
+        projectClaudeMdPath: typeof source.projectClaudeMdPath === 'string' ? source.projectClaudeMdPath : '',
+        navigation: {
+            mainTab: normalizeMainTabPreference(navigation.mainTab),
+            configMode: normalizeConfigModePreference(navigation.configMode),
+            settingsTab: normalizeSettingsTabPreference(navigation.settingsTab),
+            skillsTargetApp: navigation.skillsTargetApp === 'claude' ? 'claude' : 'codex',
+            promptTemplatesMode: navigation.promptTemplatesMode === 'manage' ? 'manage' : 'compose'
+        }
+    };
+}
+
+function readWebUiPreferences() {
+    const preferences = readCodexmatePreferences();
+    return normalizeWebUiPreferences(preferences.webUi || {});
+}
+
+function setWebUiPreferences(params = {}) {
+    const preferences = readCodexmatePreferences();
+    const current = isPlainObject(preferences.webUi) ? preferences.webUi : {};
+    const incoming = isPlainObject(params && params.preferences) ? params.preferences : {};
+    const next = normalizeWebUiPreferences({
+        ...current,
+        ...incoming,
+        navigation: {
+            ...(isPlainObject(current.navigation) ? current.navigation : {}),
+            ...(isPlainObject(incoming.navigation) ? incoming.navigation : {})
+        }
+    });
+    preferences.webUi = next;
+    writeCodexmatePreferences(preferences);
+    return { success: true, preferences: next };
+}
+
 function readToolConfigPermissions() {
     const preferences = readCodexmatePreferences();
     return normalizeToolConfigPermissions(preferences.toolConfigPermissions || TOOL_CONFIG_PERMISSION_DEFAULTS);
@@ -973,7 +1092,8 @@ function getApiToolConfigWriteTarget(action) {
         'restore-claude-dir',
         'claude-local-bridge-toggle',
         'claude-local-bridge-set-excluded',
-        'claude-local-bridge-sync-providers'
+        'claude-local-bridge-sync-providers',
+        'delete-provider-cache-record'
     ]);
     const opencodeWriteActions = new Set([
         'apply-opencode-config',
@@ -2506,6 +2626,513 @@ function updateProviderInConfig(params = {}) {
     }
 }
 
+
+function redactProviderCacheValue(value) {
+    const secretKeyPattern = /(?:^key$|api[_-]?key|auth[_-]?token|access[_-]?token|refresh[_-]?token|id[_-]?token|token|password|passwd|secret|credential|authorization|bearer|cookie|session|private[_-]?key|client[_-]?secret|x-api-key)/i;
+    const secretQueryPattern = /(?:api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|token|password|passwd|secret|credential|authorization|client[_-]?secret|key)/i;
+    const secretValuePattern = /^(?:bearer\s+|sk-[A-Za-z0-9]|sk_[A-Za-z0-9]|gsk_|AIza|xox[baprs]-|gh[pousr]_|or-[A-Za-z0-9]|ds-[A-Za-z0-9])/i;
+    const redactSecretString = (text) => String(text || '') ? '***' : '';
+    const redactUrlString = (text) => {
+        if (typeof text !== 'string' || !/^https?:\/\//i.test(text)) return text;
+        try {
+            const parsed = new URL(text);
+            if (parsed.username) parsed.username = '***';
+            if (parsed.password) parsed.password = '***';
+            for (const key of Array.from(parsed.searchParams.keys())) {
+                if (secretQueryPattern.test(key)) parsed.searchParams.set(key, '***');
+            }
+            return parsed.toString();
+        } catch (_) {
+            return text.replace(/([?&](?:api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|token|password|passwd|secret|credential|authorization|client[_-]?secret|key)=)[^&#]*/gi, '$1***');
+        }
+    };
+    const visit = (input, key = '') => {
+        if (secretKeyPattern.test(key)) {
+            if (typeof input === 'boolean' || typeof input === 'number') return input;
+            if (input === null || input === undefined || input === '') return input === undefined ? null : input;
+            return redactSecretString(input);
+        }
+        if (Array.isArray(input)) {
+            return input.map((item) => visit(item, key));
+        }
+        if (isPlainObject(input)) {
+            const output = {};
+            for (const [childKey, childValue] of Object.entries(input)) {
+                output[childKey] = visit(childValue, childKey);
+            }
+            return output;
+        }
+        if (typeof input === 'string') {
+            const urlRedacted = redactUrlString(input);
+            if (urlRedacted !== input) return urlRedacted;
+            if (secretValuePattern.test(input.trim())) return redactSecretString(input.trim());
+        }
+        return input;
+    };
+    return visit(value);
+}
+
+function getProviderCacheDisplayPath(fileName) {
+    return `~/.codexmate/${fileName}`;
+}
+
+function sanitizeProviderCacheErrorMessage(message, fileName, fallback = '读取缓存文件失败') {
+    const raw = typeof message === 'string' && message.trim() ? message : fallback;
+    const displayPath = getProviderCacheDisplayPath(fileName);
+    const absolutePath = path.join(CODEXMATE_DIR, fileName);
+    return raw
+        .split(absolutePath).join(displayPath)
+        .split(CODEXMATE_DIR).join('~/.codexmate');
+}
+
+function pickProviderCacheString(source, keys) {
+    if (!isPlainObject(source)) return '';
+    for (const key of keys) {
+        const value = source[key];
+        if (typeof value === 'string' && value.trim()) return value.trim();
+        if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+    }
+    return '';
+}
+
+function summarizeProviderCacheEntry(name, entry = {}) {
+    const provider = isPlainObject(entry) ? entry : {};
+    const providerName = pickProviderCacheString(provider, ['name', 'id', 'provider', 'title']) || String(name || '').trim() || 'provider';
+    const baseUrl = pickProviderCacheString(provider, ['base_url', 'baseUrl', 'url', 'endpoint']);
+    const wireApi = pickProviderCacheString(provider, ['wire_api', 'wireApi', 'api', 'type']);
+    const authMethod = pickProviderCacheString(provider, ['preferred_auth_method', 'authMethod', 'auth_method']);
+    const model = pickProviderCacheString(provider, ['model', 'default_model', 'defaultModel']);
+    return {
+        name: providerName,
+        baseUrl: baseUrl ? redactProviderCacheValue(baseUrl) : '',
+        wireApi,
+        authMethod: authMethod ? redactProviderCacheValue(authMethod) : '',
+        model,
+        data: redactProviderCacheValue(provider)
+    };
+}
+
+function extractProviderCacheSummaries(data) {
+    const providers = [];
+    const seen = new Set();
+    const addProvider = (name, entry) => {
+        const summary = summarizeProviderCacheEntry(name, entry);
+        const key = `${summary.name}\u0000${summary.baseUrl}\u0000${summary.wireApi}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        providers.push(summary);
+    };
+    const visitContainer = (container) => {
+        if (!container) return;
+        if (Array.isArray(container)) {
+            for (const item of container) {
+                if (!isPlainObject(item)) continue;
+                addProvider(pickProviderCacheString(item, ['name', 'id', 'provider']) || `provider-${providers.length + 1}`, item);
+            }
+            return;
+        }
+        if (!isPlainObject(container)) return;
+        for (const [name, entry] of Object.entries(container)) {
+            if (isPlainObject(entry)) addProvider(name, entry);
+        }
+    };
+
+    if (isPlainObject(data)) {
+        visitContainer(data.providers);
+        visitContainer(data.configs);
+        visitContainer(data.providerConfigs);
+        visitContainer(data.items);
+        if (providers.length === 0 && (data.base_url || data.baseUrl || data.url || data.endpoint)) {
+            addProvider(pickProviderCacheString(data, ['name', 'id', 'provider']) || 'default', data);
+        }
+    } else if (Array.isArray(data)) {
+        visitContainer(data);
+    }
+    return providers.sort((a, b) => String(a.name || '').localeCompare(String(b.name || '')));
+}
+
+function buildProviderCacheFileRecord(fileName) {
+    const filePath = path.join(CODEXMATE_DIR, fileName);
+    const displayPath = getProviderCacheDisplayPath(fileName);
+    const record = {
+        name: fileName,
+        path: displayPath,
+        displayPath,
+        exists: false,
+        ok: true,
+        tooLarge: false,
+        size: 0,
+        mtime: '',
+        data: null,
+        providers: [],
+        providerCount: 0,
+        error: ''
+    };
+    if (!fs.existsSync(filePath)) {
+        return record;
+    }
+    record.exists = true;
+    try {
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile()) {
+            record.ok = false;
+            record.error = '缓存路径不是普通文件，已跳过读取';
+            return record;
+        }
+        record.size = Number(stat.size) || 0;
+        record.mtime = stat.mtime instanceof Date && !Number.isNaN(stat.mtime.getTime())
+            ? stat.mtime.toISOString()
+            : '';
+    } catch (e) {
+        record.ok = false;
+        record.error = sanitizeProviderCacheErrorMessage(e && e.message ? e.message : String(e || '读取缓存文件状态失败'), fileName, '读取缓存文件状态失败');
+        return record;
+    }
+    if (record.size > PROVIDER_CACHE_MAX_FILE_BYTES) {
+        record.ok = false;
+        record.tooLarge = true;
+        record.error = `缓存文件过大，已跳过 JSON 读取（${record.size} bytes > ${PROVIDER_CACHE_MAX_FILE_BYTES} bytes）`;
+        return record;
+    }
+    try {
+        const content = stripUtf8Bom(fs.readFileSync(filePath, 'utf-8'));
+        const parsed = content.trim() ? JSON.parse(content) : null;
+        record.data = redactProviderCacheValue(parsed);
+        record.providers = extractProviderCacheSummaries(parsed);
+        record.providerCount = record.providers.length;
+    } catch (e) {
+        record.ok = false;
+        record.error = sanitizeProviderCacheErrorMessage(e && e.message ? e.message : String(e || '读取缓存文件失败'), fileName);
+    }
+    return record;
+}
+
+function listProviderCacheFileNamesForGroup(groupKey) {
+    const defaults = PROVIDER_CACHE_FILE_GROUPS[groupKey] || [];
+    const names = new Set(defaults);
+    try {
+        if (fs.existsSync(CODEXMATE_DIR)) {
+            for (const fileName of fs.readdirSync(CODEXMATE_DIR)) {
+                if (typeof fileName !== 'string' || !fileName.endsWith('.json')) continue;
+                if (groupKey === 'opencode' && /^opencode[-_]/i.test(fileName)) {
+                    names.add(fileName);
+                }
+            }
+        }
+    } catch (_) {}
+    return Array.from(names).sort((a, b) => a.localeCompare(b));
+}
+
+function readProviderCacheRecords() {
+    const groupLabels = {
+        claude: 'Claude',
+        codex: 'Codex',
+        opencode: 'OpenCode'
+    };
+    const groups = Object.keys(PROVIDER_CACHE_FILE_GROUPS).map((key) => {
+        const files = listProviderCacheFileNamesForGroup(key).map((fileName) => buildProviderCacheFileRecord(fileName));
+        return {
+            key,
+            label: groupLabels[key] || key,
+            files,
+            existingCount: files.filter((file) => file && file.exists).length
+        };
+    });
+    return {
+        root: '~/.codexmate',
+        maxFileBytes: PROVIDER_CACHE_MAX_FILE_BYTES,
+        generatedAt: new Date().toISOString(),
+        groups
+    };
+}
+
+function readProviderCacheJsonObject(fileName) {
+    const filePath = path.join(CODEXMATE_DIR, fileName);
+    try {
+        if (!fs.existsSync(filePath)) return {};
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile()) return {};
+        const parsed = JSON.parse(stripUtf8Bom(fs.readFileSync(filePath, 'utf-8')) || '{}');
+        return isPlainObject(parsed) ? parsed : {};
+    } catch (_) {
+        return {};
+    }
+}
+
+function writeProviderCacheJsonObject(fileName, data) {
+    ensureDir(CODEXMATE_DIR);
+    const filePath = path.join(CODEXMATE_DIR, fileName);
+    writeJsonAtomic(filePath, isPlainObject(data) ? data : {});
+    try {
+        fs.chmodSync(filePath, 0o600);
+    } catch (_) {}
+    return getProviderCacheDisplayPath(fileName);
+}
+
+function normalizeProviderCacheProviderMap(rawProviders) {
+    const providers = {};
+    if (Array.isArray(rawProviders)) {
+        for (const item of rawProviders) {
+            if (!isPlainObject(item)) continue;
+            const name = pickProviderCacheString(item, ['name', 'id', 'provider']);
+            if (name) providers[name] = item;
+        }
+        return providers;
+    }
+    if (isPlainObject(rawProviders)) {
+        for (const [name, entry] of Object.entries(rawProviders)) {
+            if (isPlainObject(entry)) providers[name] = entry;
+        }
+    }
+    return providers;
+}
+
+function removeProviderFromProviderCacheContainer(rawProviders, providerName) {
+    const targetName = typeof providerName === 'string' ? providerName.trim() : '';
+    if (!targetName) return { value: rawProviders, changed: false };
+
+    const matchesProviderName = (name) => String(name || '').trim() === targetName;
+    if (Array.isArray(rawProviders)) {
+        const filtered = rawProviders.filter((item) => {
+            if (!isPlainObject(item)) return true;
+            const itemName = pickProviderCacheString(item, ['name', 'id', 'provider']);
+            return !matchesProviderName(itemName);
+        });
+        return { value: filtered, changed: filtered.length !== rawProviders.length };
+    }
+    if (!isPlainObject(rawProviders)) return { value: rawProviders, changed: false };
+
+    const next = { ...rawProviders };
+    let changed = false;
+    for (const [name, entry] of Object.entries(rawProviders)) {
+        const entryName = isPlainObject(entry)
+            ? pickProviderCacheString(entry, ['name', 'id', 'provider'])
+            : '';
+        if (matchesProviderName(name) || matchesProviderName(entryName)) {
+            delete next[name];
+            changed = true;
+        }
+    }
+    return { value: next, changed };
+}
+
+function resolveProviderCacheDeleteGroups(groups) {
+    const requested = Array.isArray(groups) ? groups : (groups ? [groups] : []);
+    const normalized = requested
+        .map((item) => String(item || '').trim().toLowerCase())
+        .filter((item) => Object.prototype.hasOwnProperty.call(PROVIDER_CACHE_FILE_GROUPS, item));
+    return normalized.length ? Array.from(new Set(normalized)) : Object.keys(PROVIDER_CACHE_FILE_GROUPS);
+}
+
+function removeProviderFromProviderCacheRecords(providerName, options = {}) {
+    const targetName = typeof providerName === 'string' ? providerName.trim() : '';
+    const summary = { removed: false, providerFiles: [], currentModelFiles: [] };
+    if (!targetName) return summary;
+
+    const groups = resolveProviderCacheDeleteGroups(options.groups || options.group);
+    const providerFiles = groups
+        .flatMap((group) => PROVIDER_CACHE_FILE_GROUPS[group] || [])
+        .filter((fileName) => PROVIDER_CACHE_PROVIDER_FILES.includes(fileName));
+    const currentModelFiles = groups
+        .flatMap((group) => PROVIDER_CACHE_FILE_GROUPS[group] || [])
+        .filter((fileName) => PROVIDER_CACHE_CURRENT_MODEL_FILES.includes(fileName));
+
+    for (const fileName of Array.from(new Set(providerFiles))) {
+        const existing = readProviderCacheJsonObject(fileName);
+        if (!isPlainObject(existing) || !Object.prototype.hasOwnProperty.call(existing, 'providers')) continue;
+        const removed = removeProviderFromProviderCacheContainer(existing.providers, targetName);
+        if (!removed.changed) continue;
+        writeProviderCacheJsonObject(fileName, {
+            ...existing,
+            generatedAt: new Date().toISOString(),
+            providers: removed.value
+        });
+        summary.removed = true;
+        summary.providerFiles.push(fileName);
+    }
+
+    for (const fileName of Array.from(new Set(currentModelFiles))) {
+        const existing = readProviderCacheJsonObject(fileName);
+        if (!isPlainObject(existing) || !Object.prototype.hasOwnProperty.call(existing, targetName)) continue;
+        const next = { ...existing };
+        delete next[targetName];
+        writeProviderCacheJsonObject(fileName, next);
+        summary.removed = true;
+        summary.currentModelFiles.push(fileName);
+    }
+    return summary;
+}
+
+function deleteProviderCacheRecord(params = {}) {
+    const name = typeof params.name === 'string' ? params.name.trim() : '';
+    if (!name) return { error: '名称不能为空' };
+    const group = typeof params.group === 'string' ? params.group.trim().toLowerCase() : '';
+    const groups = resolveProviderCacheDeleteGroups(group || params.groups);
+    const summary = removeProviderFromProviderCacheRecords(name, { groups });
+    return {
+        success: true,
+        name,
+        groups,
+        removed: summary.removed,
+        providerFiles: summary.providerFiles,
+        currentModelFiles: summary.currentModelFiles,
+        records: readProviderCacheRecords()
+    };
+}
+
+function readClaudeProviderCacheProvider(name) {
+    const targetName = typeof name === 'string' ? name.trim() : '';
+    if (!targetName) return null;
+    const cached = normalizeProviderCacheProviderMap(readProviderCacheJsonObject('claude-providers.json').providers);
+    const entry = cached[targetName];
+    return isPlainObject(entry) ? { name: targetName, ...entry } : null;
+}
+
+function readClaudeProviderCacheConfigs() {
+    const cached = normalizeProviderCacheProviderMap(readProviderCacheJsonObject('claude-providers.json').providers);
+    const providers = [];
+    for (const [name, entry] of Object.entries(cached)) {
+        if (!name || !isPlainObject(entry)) continue;
+        const baseUrl = typeof entry.baseUrl === 'string' ? entry.baseUrl.trim() : '';
+        const model = typeof entry.model === 'string' ? entry.model.trim() : '';
+        if (!baseUrl || !model) continue;
+        providers.push({
+            name,
+            baseUrl,
+            model,
+            targetApi: normalizeClaudeTargetApi(entry.targetApi),
+            hasKey: typeof entry.apiKey === 'string' && entry.apiKey.trim().length > 0,
+            providerCacheRef: name,
+            source: 'provider-cache'
+        });
+    }
+    return { providers: providers.sort((a, b) => a.name.localeCompare(b.name)) };
+}
+
+function buildProviderCacheSyncProviders() {
+    const configResult = readConfigOrVirtualDefault();
+    if (hasConfigLoadError(configResult)) {
+        return { error: (configResult.error && configResult.error.configPublicReason) || '读取 config.toml 失败' };
+    }
+    const config = configResult.config || {};
+    const providers = isPlainObject(config.model_providers) ? config.model_providers : {};
+    const currentModels = readCurrentModels();
+    const activeProvider = typeof config.model_provider === 'string' ? config.model_provider.trim() : '';
+    const activeModel = typeof config.model === 'string' ? config.model.trim() : '';
+    const syncProviders = [];
+
+    for (const [name, provider] of Object.entries(providers)) {
+        if (!name || !isPlainObject(provider) || isBuiltinManagedProvider(name)) continue;
+        const bridgeType = typeof provider.codexmate_bridge === 'string' ? provider.codexmate_bridge.trim() : '';
+        const isOpenaiBridgeProvider = bridgeType === 'openai'
+            || (typeof provider.base_url === 'string' && provider.base_url.includes('/bridge/openai/'));
+        let baseUrl = typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
+        let apiKey = typeof provider.preferred_auth_method === 'string' ? provider.preferred_auth_method : '';
+        if (isOpenaiBridgeProvider) {
+            const upstream = resolveOpenaiBridgeUpstream(OPENAI_BRIDGE_SETTINGS_FILE, name);
+            if (upstream && !upstream.error) {
+                baseUrl = upstream.baseUrl || baseUrl;
+                apiKey = upstream.apiKey || apiKey;
+            }
+        }
+        const wireApi = typeof provider.wire_api === 'string' && provider.wire_api.trim()
+            ? provider.wire_api.trim()
+            : 'responses';
+        const model = typeof currentModels[name] === 'string' && currentModels[name].trim()
+            ? currentModels[name].trim()
+            : (activeProvider === name ? activeModel : '');
+        syncProviders.push({
+            name,
+            baseUrl,
+            apiKey,
+            wireApi,
+            model,
+            bridge: bridgeType || (isOpenaiBridgeProvider ? 'openai' : '')
+        });
+    }
+    return { providers: syncProviders.sort((a, b) => a.name.localeCompare(b.name)) };
+}
+
+function mergeProviderCacheFile(fileName, nextProviders, buildEntry) {
+    const existing = readProviderCacheJsonObject(fileName);
+    const existingProviders = normalizeProviderCacheProviderMap(existing.providers);
+    const providers = {};
+    for (const provider of nextProviders) {
+        const previous = isPlainObject(providers[provider.name]) ? providers[provider.name] : {};
+        const cachedPrevious = isPlainObject(existingProviders[provider.name]) ? existingProviders[provider.name] : previous;
+        providers[provider.name] = { ...cachedPrevious, ...buildEntry(provider) };
+    }
+    const next = {
+        ...existing,
+        version: Number(existing.version) > 0 ? Number(existing.version) : 1,
+        generatedAt: new Date().toISOString(),
+        providers
+    };
+    const displayPath = writeProviderCacheJsonObject(fileName, next);
+    return { path: displayPath, providerCount: Object.keys(providers).length };
+}
+
+function mergeProviderCacheCurrentModelsFile(fileName, nextProviders) {
+    const existing = readProviderCacheJsonObject(fileName);
+    const next = {};
+    for (const provider of nextProviders) {
+        if (provider.model) {
+            next[provider.name] = provider.model;
+        } else if (typeof existing[provider.name] === 'string' && existing[provider.name].trim()) {
+            next[provider.name] = existing[provider.name];
+        }
+    }
+    const displayPath = writeProviderCacheJsonObject(fileName, next);
+    return { path: displayPath, modelCount: Object.keys(next).length };
+}
+
+function syncProviderCacheRecords() {
+    const built = buildProviderCacheSyncProviders();
+    if (built.error) return { error: built.error };
+    const providers = built.providers || [];
+    if (providers.length === 0) {
+        return { errorKey: 'modal.providerCache.noSyncableProviders', error: 'No syncable providers' };
+    }
+
+    const writtenFiles = [];
+    writtenFiles.push(mergeProviderCacheFile('codex-providers.json', providers, (provider) => ({
+        name: provider.name,
+        base_url: provider.baseUrl,
+        wire_api: provider.wireApi,
+        preferred_auth_method: provider.apiKey,
+        model: provider.model,
+        ...(provider.bridge ? { codexmate_bridge: provider.bridge } : {})
+    })));
+    writtenFiles.push(mergeProviderCacheCurrentModelsFile('codex-provider-current-models.json', providers));
+    writtenFiles.push(mergeProviderCacheFile('claude-providers.json', providers, (provider) => ({
+        name: provider.name,
+        baseUrl: provider.baseUrl,
+        apiKey: provider.apiKey,
+        model: provider.model,
+        targetApi: normalizeClaudeTargetApi(provider.wireApi),
+        ...(provider.bridge ? { bridge: provider.bridge } : {})
+    })));
+    writtenFiles.push(mergeProviderCacheFile('opencode-providers.json', providers, (provider) => ({
+        name: provider.name,
+        baseUrl: provider.baseUrl,
+        apiKey: provider.apiKey,
+        model: provider.model,
+        disabled: false,
+        ...(provider.bridge ? { bridge: provider.bridge } : {})
+    })));
+    writtenFiles.push(mergeProviderCacheCurrentModelsFile('opencode-provider-current-models.json', providers));
+
+    return {
+        success: true,
+        summary: {
+            providerCount: providers.length,
+            fileCount: writtenFiles.length,
+            writtenFiles
+        },
+        records: readProviderCacheRecords()
+    };
+}
+
 function getProviderKey(params = {}) {
     const name = typeof params.name === 'string' ? params.name.trim() : '';
     if (!name) return { error: '名称不能为空' };
@@ -2694,6 +3321,7 @@ function performProviderDeletion(name, options = {}) {
 
     writeCurrentModels(currentModels);
     writeConfig(updatedContent.trimEnd() + lineEnding);
+    removeProviderFromProviderCacheRecords(name);
 
     return result;
 }
@@ -9492,21 +10120,35 @@ async function applyToClaudeSettings(config = {}) {
     let proxyStarted = false;
     try {
         assertToolConfigWriteAllowed('claude');
-        const apiKey = (config.apiKey || '').trim();
-        const targetApi = normalizeClaudeTargetApi(config.targetApi);
+        const providerCacheRef = typeof config.providerCacheRef === 'string' ? config.providerCacheRef.trim() : '';
+        const cachedProvider = providerCacheRef ? readClaudeProviderCacheProvider(providerCacheRef) : null;
+        if (providerCacheRef && !cachedProvider) {
+            return { success: false, mode: 'provider-cache', error: '缓存中的 Claude provider 不存在，请重新同步' };
+        }
+        const effectiveConfig = cachedProvider
+            ? {
+                ...config,
+                apiKey: cachedProvider.apiKey || config.apiKey || '',
+                baseUrl: cachedProvider.baseUrl || config.baseUrl || '',
+                model: cachedProvider.model || config.model || '',
+                targetApi: cachedProvider.targetApi || config.targetApi || 'responses'
+            }
+            : config;
+        const apiKey = (effectiveConfig.apiKey || '').trim();
+        const targetApi = normalizeClaudeTargetApi(effectiveConfig.targetApi);
         if (!apiKey && targetApi !== 'ollama') {
             return { success: false, mode: 'settings-file', error: '请先输入 API Key' };
         }
 
-        const configuredBaseUrl = typeof config.baseUrl === 'string' ? config.baseUrl.trim() : '';
+        const configuredBaseUrl = typeof effectiveConfig.baseUrl === 'string' ? effectiveConfig.baseUrl.trim() : '';
         const baseUrl = (configuredBaseUrl || (targetApi === 'ollama' ? 'http://127.0.0.1:11434' : 'https://open.bigmodel.cn/api/anthropic')).trim();
-        const model = (config.model || DEFAULT_CLAUDE_MODEL).trim();
+        const model = (effectiveConfig.model || DEFAULT_CLAUDE_MODEL).trim();
         let settingsBaseUrl = baseUrl;
         let settingsApiKey = apiKey;
         let proxyResult = null;
 
         if (targetApi === 'chat_completions' || targetApi === 'ollama') {
-            const upstreamProviderName = typeof config.name === 'string' ? config.name.trim() : '';
+            const upstreamProviderName = typeof effectiveConfig.name === 'string' ? effectiveConfig.name.trim() : '';
             if (targetApi === 'chat_completions' && !configuredBaseUrl && !upstreamProviderName) {
                 return {
                     success: false,
@@ -11695,6 +12337,12 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'get-tool-config-permissions':
                             result = { permissions: readToolConfigPermissions() };
                             break;
+                        case 'get-web-ui-preferences':
+                            result = { preferences: readWebUiPreferences() };
+                            break;
+                        case 'set-web-ui-preferences':
+                            result = setWebUiPreferences(params || {});
+                            break;
                         case 'set-tool-config-permission':
                             result = setToolConfigPermission(params || {});
                             break;
@@ -11839,6 +12487,18 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'get-provider-key':
                             result = getProviderKey(params || {});
                             break;
+                        case 'get-provider-cache-records':
+                            result = readProviderCacheRecords();
+                            break;
+                        case 'get-claude-provider-cache-configs':
+                            result = readClaudeProviderCacheConfigs();
+                            break;
+                        case 'sync-provider-cache-records':
+                            result = syncProviderCacheRecords();
+                            break;
+                        case 'delete-provider-cache-record':
+                            result = deleteProviderCacheRecord(params || {});
+                            break;
                         case 'delete-provider':
                             result = deleteProviderFromConfig(params || {});
                             break;