codexmate 0.0.19 → 0.0.21

package/web-ui/modules/app.methods.providers.mjs

@@ -0,0 +1,363 @@
+const PROVIDER_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
+const RESERVED_PROXY_PROVIDER_NAME = 'codexmate-proxy';
+
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+
+function normalizeProviderUrl(value) {
+    return normalizeText(value).replace(/\/+$/g, '');
+}
+
+function isValidHttpUrl(value) {
+    if (!value) return false;
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    } catch (_) {
+        return false;
+    }
+}
+
+function isReservedProviderCreationNameInput(name) {
+    const normalized = normalizeText(name).toLowerCase();
+    return normalized === RESERVED_PROXY_PROVIDER_NAME;
+}
+
+function isValidProviderNameInputValue(name) {
+    return PROVIDER_NAME_PATTERN.test(normalizeText(name));
+}
+
+function isValidProviderUrlInputValue(url) {
+    return isValidHttpUrl(normalizeProviderUrl(url));
+}
+
+function findProviderByName(list, name) {
+    const target = normalizeText(name);
+    if (!target) return null;
+    return (Array.isArray(list) ? list : []).find((item) => item && normalizeText(item.name) === target) || null;
+}
+
+function normalizeProviderDraftState(target) {
+    if (!target || typeof target !== 'object') return;
+    if (typeof target.name === 'string') {
+        target.name = target.name.trim();
+    }
+    if (typeof target.url === 'string') {
+        target.url = normalizeProviderUrl(target.url);
+    }
+}
+
+function getProviderValidationForContext(vm, mode = 'add') {
+    const draft = mode === 'edit' ? vm.editingProvider : vm.newProvider;
+    const editingName = mode === 'edit' ? normalizeText(draft && draft.name) : '';
+    const name = normalizeText(draft && draft.name);
+    const url = normalizeProviderUrl(draft && draft.url);
+    const errors = {
+        name: '',
+        url: ''
+    };
+
+    if (mode === 'add') {
+        if (!name) {
+            errors.name = '名称不能为空';
+        } else if (!isValidProviderNameInputValue(name)) {
+            errors.name = '名称仅支持字母/数字/._-';
+        } else if (isReservedProviderCreationNameInput(name)) {
+            errors.name = 'codexmate-proxy 为保留名称，不可手动添加';
+        } else if (findProviderByName(vm.providersList, name)) {
+            errors.name = '名称已存在';
+        }
+    } else if (!editingName) {
+        errors.name = '提供商名称不能为空';
+    }
+
+    if (!url) {
+        errors.url = 'URL 必填';
+    } else if (!isValidProviderUrlInputValue(url)) {
+        errors.url = 'URL 仅支持 http/https';
+    }
+
+    return {
+        mode,
+        name,
+        url,
+        errors,
+        ok: !errors.name && !errors.url
+    };
+}
+
+function canSubmitProviderForContext(vm, mode = 'add') {
+    if (mode === 'edit' && vm.editingProvider && (vm.editingProvider.readOnly || vm.editingProvider.nonEditable)) {
+        return false;
+    }
+    return getProviderValidationForContext(vm, mode).ok;
+}
+
+export function createProvidersMethods(options = {}) {
+    const { api } = options;
+
+    return {
+        normalizeProviderDraft(mode = 'add') {
+            normalizeProviderDraftState(mode === 'edit' ? this.editingProvider : this.newProvider);
+        },
+
+        isReservedProviderCreationName(name) {
+            return isReservedProviderCreationNameInput(name);
+        },
+
+        isValidProviderNameInput(name) {
+            return isValidProviderNameInputValue(name);
+        },
+
+        isValidProviderUrlInput(url) {
+            return isValidProviderUrlInputValue(url);
+        },
+
+        findProviderByName(name) {
+            return findProviderByName(this.providersList, name);
+        },
+
+        getProviderValidation(mode = 'add') {
+            return getProviderValidationForContext(this, mode);
+        },
+
+        providerFieldError(mode, fieldName) {
+            const validation = getProviderValidationForContext(this, mode);
+            return validation && validation.errors && typeof validation.errors[fieldName] === 'string'
+                ? validation.errors[fieldName]
+                : '';
+        },
+
+        canSubmitProvider(mode = 'add') {
+            return canSubmitProviderForContext(this, mode);
+        },
+
+        async addProvider() {
+            normalizeProviderDraftState(this.newProvider);
+            const validation = getProviderValidationForContext(this, 'add');
+            if (!validation.ok) {
+                return this.showMessage(validation.errors.name || validation.errors.url || '名称和URL必填', 'error');
+            }
+
+            try {
+                const res = await api('add-provider', {
+                    name: validation.name,
+                    url: validation.url,
+                    key: this.newProvider.key || ''
+                });
+                if (res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+
+                this.showMessage('操作成功', 'success');
+                this.closeAddModal();
+                await this.loadAll();
+            } catch (e) {
+                this.showMessage('添加失败', 'error');
+            }
+        },
+
+        getCurrentCodexAuthProfile() {
+            const list = Array.isArray(this.codexAuthProfiles) ? this.codexAuthProfiles : [];
+            return list.find((item) => !!(item && item.current)) || null;
+        },
+
+        providerPillState(provider) {
+            const configured = !!(provider && provider.hasKey);
+            return {
+                configured,
+                text: configured ? '已配置' : '未配置'
+            };
+        },
+
+        providerPillConfigured(provider) {
+            return this.providerPillState(provider).configured;
+        },
+
+        providerPillText(provider) {
+            return this.providerPillState(provider).text;
+        },
+
+        isReadOnlyProvider(providerOrName) {
+            if (!providerOrName) return false;
+            if (typeof providerOrName === 'object') {
+                return !!providerOrName.readOnly;
+            }
+            const name = String(providerOrName).trim();
+            if (!name) return false;
+            const target = (this.providersList || []).find((item) => item && item.name === name);
+            return !!(target && target.readOnly);
+        },
+
+        isNonDeletableProvider(providerOrName) {
+            if (!providerOrName) return false;
+            if (typeof providerOrName === 'object') {
+                return !!providerOrName.nonDeletable;
+            }
+            const name = String(providerOrName).trim();
+            if (!name) return false;
+            const target = (this.providersList || []).find((item) => item && item.name === name);
+            return !!(target && target.nonDeletable);
+        },
+
+        shouldShowProviderDelete(provider) {
+            return !this.isReadOnlyProvider(provider) && !this.isNonDeletableProvider(provider);
+        },
+
+        shouldShowProviderEdit(provider) {
+            return !this.isReadOnlyProvider(provider) && !this.isNonDeletableProvider(provider);
+        },
+
+        shouldAllowProviderShare(provider) {
+            return !this.isReadOnlyProvider(provider);
+        },
+
+        async deleteProvider(name) {
+            if (this.isNonDeletableProvider(name)) {
+                this.showMessage('该 provider 为保留项，不可删除', 'info');
+                return;
+            }
+            try {
+                const res = await api('delete-provider', { name });
+                if (res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                if (res.switched && res.provider) {
+                    this.showMessage(`已删除提供商，自动切换到 ${res.provider}${res.model ? ` / ${res.model}` : ''}`, 'success');
+                } else {
+                    this.showMessage('操作成功', 'success');
+                }
+                await this.loadAll();
+            } catch (_) {
+                this.showMessage('删除失败', 'error');
+            }
+        },
+
+        openEditModal(provider) {
+            if (!this.shouldShowProviderEdit(provider)) {
+                this.showMessage('该 provider 为保留项，不可编辑', 'info');
+                return;
+            }
+            this.editingProvider = {
+                name: provider.name,
+                url: normalizeProviderUrl(provider.url || ''),
+                key: '',
+                readOnly: !!provider.readOnly,
+                nonEditable: this.isNonDeletableProvider(provider)
+            };
+            this.showEditModal = true;
+        },
+
+        async updateProvider() {
+            if (this.editingProvider.readOnly || this.editingProvider.nonEditable) {
+                this.showMessage('该 provider 为保留项，不可编辑', 'error');
+                this.closeEditModal();
+                return;
+            }
+            normalizeProviderDraftState(this.editingProvider);
+            const validation = getProviderValidationForContext(this, 'edit');
+            if (!validation.ok) {
+                return this.showMessage(validation.errors.name || validation.errors.url || 'URL 必填', 'error');
+            }
+
+            const params = { name: validation.name, url: validation.url };
+            if (typeof this.editingProvider.key === 'string' && this.editingProvider.key.trim()) {
+                params.key = this.editingProvider.key;
+            }
+            try {
+                const res = await api('update-provider', params);
+                if (res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                this.closeEditModal();
+                this.showMessage('操作成功', 'success');
+                await this.loadAll();
+            } catch (e) {
+                this.showMessage('更新失败', 'error');
+            }
+        },
+
+        closeEditModal() {
+            this.showEditModal = false;
+            this.editingProvider = { name: '', url: '', key: '', readOnly: false, nonEditable: false };
+        },
+
+        async resetConfig() {
+            if (this.resetConfigLoading) return;
+            this.resetConfigLoading = true;
+            try {
+                const res = await api('reset-config');
+                if (res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                const backup = res.backupFile ? `（已备份: ${res.backupFile}）` : '';
+                this.showMessage(`配置已重装${backup}`, 'success');
+                await this.loadAll();
+            } catch (e) {
+                this.showMessage('重装失败', 'error');
+            } finally {
+                this.resetConfigLoading = false;
+            }
+        },
+
+        async addModel() {
+            if (!this.newModelName || !this.newModelName.trim()) {
+                return this.showMessage('请输入模型', 'error');
+            }
+            try {
+                const res = await api('add-model', { model: this.newModelName.trim() });
+                if (res.error) {
+                    this.showMessage(res.error, 'error');
+                } else {
+                    this.showMessage('操作成功', 'success');
+                    this.closeModelModal();
+                    await this.loadAll();
+                }
+            } catch (_) {
+                this.showMessage('新增模型失败', 'error');
+            }
+        },
+
+        async removeModel(model) {
+            try {
+                const res = await api('delete-model', { model });
+                if (res.error) {
+                    this.showMessage(res.error, 'error');
+                } else {
+                    this.showMessage('操作成功', 'success');
+                    await this.loadAll();
+                }
+            } catch (_) {
+                this.showMessage('删除模型失败', 'error');
+            }
+        },
+
+        closeAddModal() {
+            this.showAddModal = false;
+            this.newProvider = { name: '', url: '', key: '' };
+        },
+
+        closeModelModal() {
+            this.showModelModal = false;
+            this.newModelName = '';
+        },
+
+        formatKey(key) {
+            if (!key) return '(未设置)';
+            if (key.length > 10) {
+                return key.substring(0, 3) + '****' + key.substring(key.length - 3);
+            }
+            return '****';
+        },
+
+        displayApiKey(configName) {
+            const key = this.claudeConfigs[configName]?.apiKey;
+            return this.formatKey(key);
+        }
+    };
+}

package/web-ui/modules/app.methods.runtime.mjs

@@ -0,0 +1,323 @@
+import {
+    buildSpeedTestIssue,
+    formatLatency
+} from '../logic.mjs';
+
+function clearProgressResetTimer(context, timerKey) {
+    if (!context || !timerKey || !context[timerKey]) {
+        return;
+    }
+    clearTimeout(context[timerKey]);
+    context[timerKey] = null;
+}
+
+function scheduleProgressResetTimer(context, timerKey, progressKey, delayMs = 800) {
+    if (!context || !timerKey || !progressKey) {
+        return;
+    }
+    clearProgressResetTimer(context, timerKey);
+    context[timerKey] = setTimeout(() => {
+        context[progressKey] = 0;
+        context[timerKey] = null;
+    }, delayMs);
+}
+
+export function createRuntimeMethods(options = {}) {
+    const { api } = options;
+
+    return {
+        formatLatency,
+
+        buildSpeedTestIssue(name, result) {
+            return buildSpeedTestIssue(name, result);
+        },
+
+        async runSpeedTest(name, options = {}) {
+            if (!name || this.speedLoading[name]) return null;
+            const silent = !!options.silent;
+            this.speedLoading[name] = true;
+            try {
+                const res = await api('speed-test', { name });
+                if (res.error) {
+                    this.speedResults[name] = { ok: false, error: res.error };
+                    if (!silent) {
+                        this.showMessage(res.error, 'error');
+                    }
+                    return { ok: false, error: res.error };
+                }
+                this.speedResults[name] = res;
+                if (!silent) {
+                    const status = res.status ? ` (${res.status})` : '';
+                    this.showMessage(`Speed ${name}: ${this.formatLatency(res)}${status}`, 'success');
+                }
+                return res;
+            } catch (e) {
+                const message = e && e.message ? e.message : 'Speed test failed';
+                this.speedResults[name] = { ok: false, error: message };
+                if (!silent) {
+                    this.showMessage(message, 'error');
+                }
+                return { ok: false, error: message };
+            } finally {
+                this.speedLoading[name] = false;
+            }
+        },
+
+        async runClaudeSpeedTest(name, config) {
+            if (!name || this.claudeSpeedLoading[name]) return null;
+            const baseUrl = config && typeof config.baseUrl === 'string' ? config.baseUrl.trim() : '';
+            this.claudeSpeedLoading[name] = true;
+            try {
+                if (!baseUrl) {
+                    const res = { ok: false, error: 'Missing base URL' };
+                    this.claudeSpeedResults[name] = res;
+                    return res;
+                }
+                const res = await api('speed-test', { url: baseUrl });
+                if (res.error) {
+                    this.claudeSpeedResults[name] = { ok: false, error: res.error };
+                    return { ok: false, error: res.error };
+                }
+                this.claudeSpeedResults[name] = res;
+                return res;
+            } catch (e) {
+                const message = e && e.message ? e.message : 'Speed test failed';
+                const res = { ok: false, error: message };
+                this.claudeSpeedResults[name] = res;
+                return res;
+            } finally {
+                this.claudeSpeedLoading[name] = false;
+            }
+        },
+
+        async downloadClaudeDirectory() {
+            if (this.claudeDownloadLoading) return;
+            clearProgressResetTimer(this, '__claudeDownloadResetTimer');
+            this.claudeDownloadLoading = true;
+            this.claudeDownloadProgress = 5;
+            this.claudeDownloadTimer = setInterval(() => {
+                if (this.claudeDownloadProgress < 90) {
+                    this.claudeDownloadProgress += 5;
+                }
+            }, 400);
+            try {
+                const res = await api('download-claude-dir');
+                if (res && res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                if (!res || res.success !== true || !res.fileName) {
+                    this.showMessage('备份失败', 'error');
+                    return;
+                }
+                this.claudeDownloadProgress = 100;
+                const downloadUrl = `/download/${encodeURIComponent(res.fileName)}`;
+                const link = document.createElement('a');
+                link.href = downloadUrl;
+                link.download = res.fileName;
+                document.body.appendChild(link);
+                link.click();
+                document.body.removeChild(link);
+                this.showMessage('备份成功，开始下载', 'success');
+            } catch (e) {
+                this.showMessage('备份失败：' + (e && e.message ? e.message : '未知错误'), 'error');
+            } finally {
+                if (this.claudeDownloadTimer) {
+                    clearInterval(this.claudeDownloadTimer);
+                    this.claudeDownloadTimer = null;
+                }
+                this.claudeDownloadLoading = false;
+                scheduleProgressResetTimer(this, '__claudeDownloadResetTimer', 'claudeDownloadProgress');
+            }
+        },
+
+        async downloadCodexDirectory() {
+            if (this.codexDownloadLoading) return;
+            clearProgressResetTimer(this, '__codexDownloadResetTimer');
+            this.codexDownloadLoading = true;
+            this.codexDownloadProgress = 5;
+            this.codexDownloadTimer = setInterval(() => {
+                if (this.codexDownloadProgress < 90) {
+                    this.codexDownloadProgress += 5;
+                }
+            }, 400);
+            try {
+                const res = await api('download-codex-dir');
+                if (res && res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                if (!res || res.success !== true || !res.fileName) {
+                    this.showMessage('备份失败', 'error');
+                    return;
+                }
+                this.codexDownloadProgress = 100;
+                const downloadUrl = `/download/${encodeURIComponent(res.fileName)}`;
+                const link = document.createElement('a');
+                link.href = downloadUrl;
+                link.download = res.fileName;
+                document.body.appendChild(link);
+                link.click();
+                document.body.removeChild(link);
+                this.showMessage('备份成功，开始下载', 'success');
+            } catch (e) {
+                this.showMessage('备份失败：' + (e && e.message ? e.message : '未知错误'), 'error');
+            } finally {
+                if (this.codexDownloadTimer) {
+                    clearInterval(this.codexDownloadTimer);
+                    this.codexDownloadTimer = null;
+                }
+                this.codexDownloadLoading = false;
+                scheduleProgressResetTimer(this, '__codexDownloadResetTimer', 'codexDownloadProgress');
+            }
+        },
+
+        triggerClaudeImport() {
+            const input = this.$refs.claudeImportInput;
+            if (input) {
+                input.value = '';
+                input.click();
+            }
+        },
+
+        triggerCodexImport() {
+            const input = this.$refs.codexImportInput;
+            if (input) {
+                input.value = '';
+                input.click();
+            }
+        },
+
+        handleClaudeImportChange(event) {
+            const file = event && event.target && event.target.files ? event.target.files[0] : null;
+            if (file) {
+                void this.importBackupFile('claude', file);
+            }
+        },
+
+        handleCodexImportChange(event) {
+            const file = event && event.target && event.target.files ? event.target.files[0] : null;
+            if (file) {
+                void this.importBackupFile('codex', file);
+            }
+        },
+
+        async importBackupFile(type, file) {
+            const maxSize = 200 * 1024 * 1024;
+            const loadingKey = type === 'claude' ? 'claudeImportLoading' : 'codexImportLoading';
+            if (this[loadingKey]) {
+                this.resetImportInput(type);
+                return;
+            }
+            if (file.size > maxSize) {
+                this.showMessage('备份文件过大，限制 200MB', 'error');
+                this.resetImportInput(type);
+                return;
+            }
+            this[loadingKey] = true;
+            try {
+                const base64 = await this.readFileAsBase64(file);
+                const action = type === 'claude' ? 'restore-claude-dir' : 'restore-codex-dir';
+                const res = await api(action, {
+                    fileName: file.name || `${type}-backup.zip`,
+                    fileBase64: base64
+                });
+                if (res && res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                const backupTip = res && res.backupPath ? `，原配置已备份到临时文件：${res.backupPath}` : '';
+                this.showMessage(`导入成功${backupTip}`, 'success');
+                try {
+                    if (type === 'claude') {
+                        await this.refreshClaudeSelectionFromSettings({ silent: true });
+                    } else {
+                        await this.loadAll();
+                    }
+                } catch (_) {
+                    this.showMessage('导入已完成，但界面刷新失败，请手动刷新', 'error');
+                }
+            } catch (e) {
+                this.showMessage('导入失败：' + (e && e.message ? e.message : '未知错误'), 'error');
+            } finally {
+                this[loadingKey] = false;
+                this.resetImportInput(type);
+            }
+        },
+
+        readFileAsBase64(file) {
+            return new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    const result = reader.result;
+                    if (result instanceof ArrayBuffer) {
+                        resolve(this.arrayBufferToBase64(result));
+                        return;
+                    }
+                    if (typeof result === 'string') {
+                        const idx = result.indexOf('base64,');
+                        resolve(idx >= 0 ? result.slice(idx + 7) : result);
+                        return;
+                    }
+                    reject(new Error('不支持的文件读取结果'));
+                };
+                reader.onerror = () => reject(new Error('读取文件失败'));
+                reader.readAsArrayBuffer(file);
+            });
+        },
+
+        arrayBufferToBase64(buffer) {
+            const bytes = new Uint8Array(buffer);
+            const chunkSize = 0x8000;
+            let binary = '';
+            for (let i = 0; i < bytes.byteLength; i += chunkSize) {
+                binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+            }
+            return btoa(binary);
+        },
+
+        resetImportInput(type) {
+            const refName = type === 'claude' ? 'claudeImportInput' : 'codexImportInput';
+            const el = this.$refs[refName];
+            if (el) {
+                el.value = '';
+            }
+        },
+
+        async loadCodexAuthProfiles(options = {}) {
+            const silent = !!options.silent;
+            try {
+                const res = await api('list-auth-profiles');
+                if (res && res.error) {
+                    if (!silent) {
+                        this.showMessage(res.error, 'error');
+                    }
+                    return;
+                }
+                const list = Array.isArray(res && res.profiles) ? res.profiles : [];
+                this.codexAuthProfiles = list.sort((a, b) => {
+                    if (!!a.current !== !!b.current) {
+                        return a.current ? -1 : 1;
+                    }
+                    return String(a.name || '').localeCompare(String(b.name || ''));
+                });
+            } catch (e) {
+                if (!silent) {
+                    this.showMessage('读取认证列表失败', 'error');
+                }
+            }
+        },
+
+        showMessage(text, type) {
+            if (this._messageTimer) {
+                clearTimeout(this._messageTimer);
+            }
+            this.message = text;
+            this.messageType = type || 'info';
+            this._messageTimer = setTimeout(() => {
+                this.message = '';
+                this._messageTimer = null;
+            }, 3000);
+        }
+    };
+}