codexmate 0.0.54 → 0.0.56

package/web-ui/modules/app.methods.claude-config.mjs

@@ -1,3 +1,5 @@
+import { nextClaudeConfigName } from './provider-default-names.mjs';
+
 function normalizeClaudeText(value) {
     return typeof value === 'string' ? value.trim() : '';
 }
@@ -6,6 +8,21 @@ function normalizeClaudeBaseUrl(value) {
     return normalizeClaudeText(value).replace(/\/+$/g, '');
 }
 
+const DELETED_CLAUDE_SETTINGS_IMPORTS_KEY = 'deletedClaudeSettingsImports';
+
+function buildDeletedClaudeSettingsFingerprint(config = {}) {
+    const safe = config && typeof config === 'object' ? config : {};
+    const baseUrl = normalizeClaudeBaseUrl(safe.baseUrl);
+    const model = normalizeClaudeText(safe.model);
+    if (!baseUrl || !model) return null;
+    return {
+        baseUrl,
+        model,
+        providerCacheRef: normalizeClaudeText(safe.providerCacheRef),
+        deletedAt: Date.now()
+    };
+}
+
 function isValidClaudeHttpUrl(value) {
     if (!value) return false;
     try {
@@ -20,6 +37,7 @@ function getClaudeConfigValidationForContext(vm, mode = 'add') {
     const draft = mode === 'edit' ? vm.editingConfig : vm.newClaudeConfig;
     const name = normalizeClaudeText(draft && draft.name);
     const apiKey = normalizeClaudeText(draft && draft.apiKey);
+    const providerCacheRef = normalizeClaudeText(draft && draft.providerCacheRef);
     const externalCredentialType = normalizeClaudeText(draft && draft.externalCredentialType);
     const baseUrl = normalizeClaudeBaseUrl(draft && draft.baseUrl);
     const model = normalizeClaudeText(draft && draft.model);
@@ -40,7 +58,7 @@ function getClaudeConfigValidationForContext(vm, mode = 'add') {
         errors.name = vm.t('validation.claude.nameExists');
     }
 
-    if (!apiKey && !externalCredentialType && targetApi !== 'ollama') {
+    if (!apiKey && !externalCredentialType && !providerCacheRef && targetApi !== 'ollama') {
         errors.apiKey = vm.t('validation.claude.apiKeyRequired');
     }
 
@@ -58,6 +76,7 @@ function getClaudeConfigValidationForContext(vm, mode = 'add') {
         mode,
         name,
         apiKey,
+        providerCacheRef,
         externalCredentialType,
         baseUrl,
         model,
@@ -112,6 +131,122 @@ export function createClaudeConfigMethods(options = {}) {
             this.syncClaudeBridgeProviders();
         },
 
+        rememberDeletedClaudeSettingsImport(config) {
+            const fingerprint = buildDeletedClaudeSettingsFingerprint(config);
+            if (!fingerprint) return;
+            try {
+                const raw = localStorage.getItem(DELETED_CLAUDE_SETTINGS_IMPORTS_KEY);
+                const parsed = raw ? JSON.parse(raw) : [];
+                const entries = Array.isArray(parsed) ? parsed : [];
+                const deduped = entries.filter((entry) => {
+                    if (!entry || typeof entry !== 'object') return false;
+                    return normalizeClaudeBaseUrl(entry.baseUrl) !== fingerprint.baseUrl
+                        || normalizeClaudeText(entry.model) !== fingerprint.model;
+                });
+                deduped.push(fingerprint);
+                localStorage.setItem(DELETED_CLAUDE_SETTINGS_IMPORTS_KEY, JSON.stringify(deduped.slice(-50)));
+            } catch (_) {}
+        },
+
+        async applyCurrentClaudeConfigSilently() {
+            const name = normalizeClaudeText(this.currentClaudeConfig);
+            if (!name || !this.claudeConfigs || !this.claudeConfigs[name]) return false;
+            if (typeof this.applyClaudeConfig !== 'function') return false;
+            return await this.applyClaudeConfig(name, { silent: true });
+        },
+
+        selectClaudeFallbackConfigName(excludedNames = []) {
+            const configs = this.claudeConfigs && typeof this.claudeConfigs === 'object' ? this.claudeConfigs : {};
+            const excluded = new Set((Array.isArray(excludedNames) ? excludedNames : [excludedNames])
+                .map((name) => normalizeClaudeText(name))
+                .filter(Boolean));
+            const names = Object.keys(configs).filter((name) => name && !excluded.has(name));
+            const applyable = names.find((name) => {
+                const config = configs[name] || {};
+                return !!(config.apiKey
+                    || config.providerCacheRef
+                    || config.externalCredentialType
+                    || config.targetApi === 'ollama');
+            });
+            return applyable || names[0] || '';
+        },
+
+        async hydrateClaudeConfigsFromProviderCache(options = {}) {
+            const silent = options && options.silent === true;
+            try {
+                const res = await api('get-claude-provider-cache-configs');
+                if (!res || res.error) {
+                    if (!silent) this.showMessage((res && res.error) || this.t('toast.claude.loadSettingsFail'), 'error');
+                    return false;
+                }
+                const providers = Array.isArray(res.providers) ? res.providers : [];
+                const configs = this.claudeConfigs && typeof this.claudeConfigs === 'object' ? this.claudeConfigs : {};
+                let changed = false;
+                let firstCachedName = '';
+                const liveCacheRefs = new Set();
+                for (const provider of providers) {
+                    if (!provider || typeof provider !== 'object') continue;
+                    const name = normalizeClaudeText(provider.name);
+                    const baseUrl = normalizeClaudeBaseUrl(provider.baseUrl);
+                    const model = normalizeClaudeText(provider.model);
+                    if (!name || !baseUrl || !model) continue;
+                    if (!firstCachedName) firstCachedName = name;
+                    const providerCacheRef = normalizeClaudeText(provider.providerCacheRef) || name;
+                    liveCacheRefs.add(name);
+                    liveCacheRefs.add(providerCacheRef);
+                    const cachedConfig = {
+                        apiKey: '',
+                        baseUrl,
+                        model,
+                        hasKey: provider.hasKey === true,
+                        providerCacheRef,
+                        source: 'provider-cache',
+                        targetApi: normalizeClaudeText(provider.targetApi) || 'responses'
+                    };
+                    const existing = configs[name];
+                    if (existing && existing.source !== 'provider-cache' && existing.providerCacheRef !== cachedConfig.providerCacheRef) {
+                        continue;
+                    }
+                    if (JSON.stringify(existing || {}) !== JSON.stringify(cachedConfig)) {
+                        configs[name] = cachedConfig;
+                        changed = true;
+                    }
+                }
+                for (const [name, existing] of Object.entries(configs)) {
+                    if (!existing || typeof existing !== 'object') continue;
+                    const providerCacheRef = normalizeClaudeText(existing.providerCacheRef);
+                    const source = normalizeClaudeText(existing.source);
+                    const cacheBacked = source === 'provider-cache' || !!providerCacheRef;
+                    if (!cacheBacked) continue;
+                    const ref = providerCacheRef || normalizeClaudeText(name);
+                    if (liveCacheRefs.has(ref) || liveCacheRefs.has(normalizeClaudeText(name))) continue;
+                    delete configs[name];
+                    changed = true;
+                }
+                this.claudeConfigs = configs;
+                const current = normalizeClaudeText(this.currentClaudeConfig);
+                if (current && !configs[current]) {
+                    this.currentClaudeConfig = firstCachedName || Object.keys(configs)[0] || '';
+                    try { localStorage.setItem('currentClaudeConfig', this.currentClaudeConfig); } catch (_) {}
+                    changed = true;
+                } else if (firstCachedName) {
+                    let savedCurrent = '';
+                    try { savedCurrent = localStorage.getItem('currentClaudeConfig') || ''; } catch (_) {}
+                    const currentConfig = current && configs[current] ? configs[current] : null;
+                    if (!savedCurrent && (!current || (currentConfig && currentConfig.hasKey === false && !currentConfig.providerCacheRef))) {
+                        this.currentClaudeConfig = firstCachedName;
+                        try { localStorage.setItem('currentClaudeConfig', firstCachedName); } catch (_) {}
+                        changed = true;
+                    }
+                }
+                if (changed) this.saveClaudeConfigs();
+                return true;
+            } catch (e) {
+                if (!silent) this.showMessage(e && e.message ? e.message : this.t('toast.claude.loadSettingsFail'), 'error');
+                return false;
+            }
+        },
+
         async syncClaudeBridgeProviders() {
             try { await api('claude-local-bridge-sync-providers', { providers: this.claudeConfigs || {} }); } catch (_) {}
         },
@@ -154,6 +289,7 @@ export function createClaudeConfigMethods(options = {}) {
                 model: config.model || '',
                 targetApi: config.targetApi || 'responses'
             };
+            if (config.providerCacheRef) this.editingConfig.providerCacheRef = config.providerCacheRef;
             this.showEditClaudeConfigKey = false;
             this.showEditConfigModal = true;
         },
@@ -165,6 +301,8 @@ export function createClaudeConfigMethods(options = {}) {
             }
             const name = validation.name;
             this.editingConfig.apiKey = validation.apiKey;
+            if (validation.providerCacheRef) this.editingConfig.providerCacheRef = validation.providerCacheRef;
+            else delete this.editingConfig.providerCacheRef;
             this.editingConfig.externalCredentialType = validation.externalCredentialType;
             this.editingConfig.baseUrl = validation.baseUrl;
             this.editingConfig.model = validation.model;
@@ -195,6 +333,8 @@ export function createClaudeConfigMethods(options = {}) {
             }
             const name = validation.name;
             this.editingConfig.apiKey = validation.apiKey;
+            if (validation.providerCacheRef) this.editingConfig.providerCacheRef = validation.providerCacheRef;
+            else delete this.editingConfig.providerCacheRef;
             this.editingConfig.externalCredentialType = validation.externalCredentialType;
             this.editingConfig.baseUrl = validation.baseUrl;
             this.editingConfig.model = validation.model;
@@ -203,7 +343,7 @@ export function createClaudeConfigMethods(options = {}) {
             this.saveClaudeConfigs();
 
             const config = this.claudeConfigs[name];
-            if (!config.apiKey && config.targetApi !== 'ollama') {
+            if (!config.apiKey && !config.providerCacheRef && config.targetApi !== 'ollama') {
                 this.showMessage(this.t('toast.claude.savedWithoutKey'), 'info');
                 this.closeEditConfigModal();
                 if (name === this.currentClaudeConfig) {
@@ -212,7 +352,7 @@ export function createClaudeConfigMethods(options = {}) {
                 return;
             }
 
-            const _claudeKey = `${name}|${config.apiKey || ""}|${config.baseUrl || ""}|${config.model || ""}|${config.targetApi || "responses"}`;
+            const _claudeKey = `${name}|${config.apiKey || ""}|${config.providerCacheRef || ""}|${config.baseUrl || ""}|${config.model || ""}|${config.targetApi || "responses"}`;
             try {
                 const res = await api('apply-claude-config', { config: { ...config, name } });
                 if (res.error || res.success === false) {
@@ -238,6 +378,8 @@ export function createClaudeConfigMethods(options = {}) {
             }
             this.newClaudeConfig.name = validation.name;
             this.newClaudeConfig.apiKey = validation.apiKey;
+            if (validation.providerCacheRef) this.newClaudeConfig.providerCacheRef = validation.providerCacheRef;
+            else delete this.newClaudeConfig.providerCacheRef;
             this.newClaudeConfig.externalCredentialType = validation.externalCredentialType;
             this.newClaudeConfig.baseUrl = validation.baseUrl;
             this.newClaudeConfig.model = validation.model;
@@ -256,6 +398,28 @@ export function createClaudeConfigMethods(options = {}) {
             await this.applyClaudeConfig(name);
         },
 
+        async deleteClaudeProviderCacheRef(configOrName) {
+            const config = configOrName && typeof configOrName === 'object'
+                ? configOrName
+                : (this.claudeConfigs && this.claudeConfigs[configOrName] ? this.claudeConfigs[configOrName] : null);
+            const ref = normalizeClaudeText(config && config.providerCacheRef);
+            const source = normalizeClaudeText(config && config.source);
+            if (!ref && source !== 'provider-cache') return true;
+            const name = ref || normalizeClaudeText(config && config.name) || normalizeClaudeText(configOrName);
+            if (!name) return true;
+            try {
+                const res = await api('delete-provider-cache-record', { name, group: 'claude' });
+                if (res && res.error) {
+                    this.showMessage(res.error, 'error');
+                    return false;
+                }
+                return true;
+            } catch (e) {
+                this.showMessage(e && e.message ? e.message : this.t('toast.operation.fail'), 'error');
+                return false;
+            }
+        },
+
         async deleteClaudeConfig(name) {
             if (Object.keys(this.claudeConfigs).length <= 1) {
                 return this.showMessage(this.t('toast.claude.keepOne'), 'error');
@@ -269,41 +433,60 @@ export function createClaudeConfigMethods(options = {}) {
             });
             if (!confirmed) return;
 
+            const config = this.claudeConfigs[name];
+            const cacheDeleted = await this.deleteClaudeProviderCacheRef(config || name);
+            if (!cacheDeleted) return;
+
+            if (typeof this.rememberDeletedClaudeSettingsImport === 'function') {
+                this.rememberDeletedClaudeSettingsImport(config);
+            }
             delete this.claudeConfigs[name];
             if (this.currentClaudeConfig === name) {
-                this.currentClaudeConfig = Object.keys(this.claudeConfigs)[0];
+                this.currentClaudeConfig = this.selectClaudeFallbackConfigName();
             }
             this.saveClaudeConfigs();
             this.showMessage(this.t('toast.operation.success'), 'success');
-            this.refreshClaudeModelContext();
+            if (this.currentClaudeConfig) {
+                await this.applyCurrentClaudeConfigSilently();
+            } else {
+                this.refreshClaudeModelContext();
+            }
         },
 
-        async applyClaudeConfig(name) {
+        async applyClaudeConfig(name, options = {}) {
+            const silent = !!(options && options.silent);
+            const silentSuccess = silent || !!(options && options.silentSuccess);
+            const silentError = silent || !!(options && options.silentError);
             this.currentClaudeConfig = name;
             try { localStorage.setItem('currentClaudeConfig', name || ''); } catch (_) {}
             this.refreshClaudeModelContext();
             const config = this.claudeConfigs[name];
 
-            if (!config.apiKey && config.targetApi !== 'ollama') {
+            if (!config.apiKey && !config.providerCacheRef && config.targetApi !== 'ollama') {
                 if (config.externalCredentialType) {
+                    if (silentError) return false;
                     return this.showMessage(this.t('toast.claude.externalAuth'), 'info');
                 }
+                if (silentError) return false;
                 return this.showMessage(this.t('toast.claude.apiKeyRequired'), 'error');
             }
 
-            const _claudeKey2 = `${name}|${config.apiKey || ""}|${config.baseUrl || ""}|${config.model || ""}|${config.targetApi || "responses"}`;
+            const _claudeKey2 = `${name}|${config.apiKey || ""}|${config.providerCacheRef || ""}|${config.baseUrl || ""}|${config.model || ""}|${config.targetApi || "responses"}`;
             try {
                 const res = await api('apply-claude-config', { config: { ...config, name } });
                 if (res.error || res.success === false) {
-                    this.showMessage(res.error || this.t('toast.apply.fail'), 'error');
+                    if (!silentError) this.showMessage(res.error || this.t('toast.apply.fail'), 'error');
+                    return false;
                 } else {
-                    if (this._lastAppliedClaudeKey !== _claudeKey2) {
+                    if (!silentSuccess && this._lastAppliedClaudeKey !== _claudeKey2) {
                         this.showMessage(this.t('toast.apply.success'), 'success');
-                        this._lastAppliedClaudeKey = _claudeKey2;
                     }
+                    this._lastAppliedClaudeKey = _claudeKey2;
+                    return true;
                 }
             } catch (_) {
-                this.showMessage(this.t('toast.apply.fail'), 'error');
+                if (!silentError) this.showMessage(this.t('toast.apply.fail'), 'error');
+                return false;
             }
         },
 
@@ -311,7 +494,7 @@ export function createClaudeConfigMethods(options = {}) {
             this.showClaudeConfigModal = false;
             this.showAddClaudeConfigKey = false;
             this.newClaudeConfig = {
-                name: '',
+                name: nextClaudeConfigName(this.claudeConfigs),
                 apiKey: '',
                 externalCredentialType: '',
                 baseUrl: '',