codexmate 0.0.19 → 0.0.20

package/web-ui/modules/app.methods.openclaw-editing.mjs

@@ -0,0 +1,337 @@
+export function createOpenclawEditingMethods() {
+    return {
+        applyOpenclawStructuredToText() {
+            const parsed = this.parseOpenclawContent(this.openclawEditing.content, { allowEmpty: true });
+            if (!parsed.ok) {
+                this.showMessage('解析 OpenClaw 配置失败: ' + parsed.error, 'error');
+                return;
+            }
+
+            const config = parsed.data;
+            const agents = config.agents && typeof config.agents === 'object' && !Array.isArray(config.agents)
+                ? config.agents
+                : {};
+            const defaults = agents.defaults && typeof agents.defaults === 'object' && !Array.isArray(agents.defaults)
+                ? agents.defaults
+                : {};
+            const model = defaults.model && typeof defaults.model === 'object' && !Array.isArray(defaults.model)
+                ? defaults.model
+                : {};
+
+            const primary = (this.openclawStructured.agentPrimary || '').trim();
+            const fallbacks = this.normalizeStringList(this.openclawStructured.agentFallbacks);
+            if (primary) {
+                model.primary = primary;
+            } else {
+                delete model.primary;
+            }
+            if (fallbacks.length) {
+                model.fallbacks = fallbacks;
+            } else {
+                delete model.fallbacks;
+            }
+            if (Object.keys(model).length > 0) {
+                defaults.model = model;
+            } else {
+                delete defaults.model;
+            }
+            if (config.agent && typeof config.agent === 'object' && !Array.isArray(config.agent)) {
+                if (primary) {
+                    config.agent.model = primary;
+                } else {
+                    delete config.agent.model;
+                }
+            }
+
+            const workspace = (this.openclawStructured.workspace || '').trim();
+            if (workspace) {
+                defaults.workspace = workspace;
+            } else {
+                delete defaults.workspace;
+            }
+
+            const timeout = this.parseOptionalNumber(this.openclawStructured.timeout, 'Timeout');
+            if (!timeout.ok) {
+                this.showMessage(timeout.error, 'error');
+                return;
+            }
+            if (timeout.value !== null) {
+                defaults.timeout = timeout.value;
+            } else {
+                delete defaults.timeout;
+            }
+
+            const contextTokens = this.parseOptionalNumber(this.openclawStructured.contextTokens, 'Context Tokens');
+            if (!contextTokens.ok) {
+                this.showMessage(contextTokens.error, 'error');
+                return;
+            }
+            if (contextTokens.value !== null) {
+                defaults.contextTokens = contextTokens.value;
+            } else {
+                delete defaults.contextTokens;
+            }
+
+            const maxConcurrent = this.parseOptionalNumber(this.openclawStructured.maxConcurrent, 'Max Concurrent');
+            if (!maxConcurrent.ok) {
+                this.showMessage(maxConcurrent.error, 'error');
+                return;
+            }
+            if (maxConcurrent.value !== null) {
+                defaults.maxConcurrent = maxConcurrent.value;
+            } else {
+                delete defaults.maxConcurrent;
+            }
+
+            if (Object.keys(defaults).length > 0) {
+                config.agents = agents;
+                config.agents.defaults = defaults;
+            } else if (agents.defaults) {
+                delete agents.defaults;
+                if (Object.keys(agents).length > 0) {
+                    config.agents = agents;
+                } else {
+                    delete config.agents;
+                }
+            }
+
+            const envResult = this.normalizeEnvItems(this.openclawStructured.envItems);
+            if (!envResult.ok) {
+                this.showMessage(envResult.error, 'error');
+                return;
+            }
+            if (Object.keys(envResult.items).length > 0) {
+                config.env = envResult.items;
+            } else if (config.env) {
+                delete config.env;
+            }
+
+            const profile = (this.openclawStructured.toolsProfile || '').trim();
+            const allowList = this.normalizeStringList(this.openclawStructured.toolsAllow);
+            const denyList = this.normalizeStringList(this.openclawStructured.toolsDeny);
+            const hasTools = profile || allowList.length || denyList.length || (config.tools && typeof config.tools === 'object');
+            if (hasTools) {
+                const tools = config.tools && typeof config.tools === 'object' && !Array.isArray(config.tools)
+                    ? config.tools
+                    : {};
+                if (profile) {
+                    tools.profile = profile;
+                } else {
+                    delete tools.profile;
+                }
+                if (allowList.length) {
+                    tools.allow = allowList;
+                } else {
+                    delete tools.allow;
+                }
+                if (denyList.length) {
+                    tools.deny = denyList;
+                } else {
+                    delete tools.deny;
+                }
+                if (Object.keys(tools).length > 0) {
+                    config.tools = tools;
+                } else {
+                    delete config.tools;
+                }
+            }
+
+            this.openclawEditing.content = this.stringifyOpenclawConfig(config);
+            this.refreshOpenclawProviders(config);
+            this.refreshOpenclawAgentsList(config);
+            this.fillOpenclawQuickFromConfig(config);
+            this.showMessage('已写入', 'success');
+        },
+
+        applyOpenclawQuickToText() {
+            const parsed = this.parseOpenclawContent(this.openclawEditing.content, { allowEmpty: true });
+            if (!parsed.ok) {
+                this.showMessage('解析 OpenClaw 配置失败: ' + parsed.error, 'error');
+                return;
+            }
+
+            const providerName = (this.openclawQuick.providerName || '').trim();
+            const modelId = (this.openclawQuick.modelId || '').trim();
+            if (!providerName) {
+                this.showMessage('请填写名称', 'error');
+                return;
+            }
+            if (providerName.includes('/')) {
+                this.showMessage('Provider 名称不能包含 "/"', 'error');
+                return;
+            }
+            if (!modelId) {
+                this.showMessage('请填写模型', 'error');
+                return;
+            }
+
+            const config = parsed.data;
+            const ensureObject = (value) => (value && typeof value === 'object' && !Array.isArray(value)) ? value : {};
+            const models = ensureObject(config.models);
+            const providers = ensureObject(models.providers);
+            const provider = ensureObject(providers[providerName]);
+            const baseUrl = (this.openclawQuick.baseUrl || '').trim();
+            if (!baseUrl && !provider.baseUrl) {
+                this.showMessage('请填写 URL', 'error');
+                return;
+            }
+
+            const contextWindow = this.parseOptionalNumber(this.openclawQuick.contextWindow, '上下文长度');
+            if (!contextWindow.ok) {
+                this.showMessage(contextWindow.error, 'error');
+                return;
+            }
+            const maxTokens = this.parseOptionalNumber(this.openclawQuick.maxTokens, '最大输出');
+            if (!maxTokens.ok) {
+                this.showMessage(maxTokens.error, 'error');
+                return;
+            }
+
+            const shouldOverrideProvider = !!this.openclawQuick.overrideProvider;
+            const apiKey = (this.openclawQuick.apiKey || '').trim();
+            const apiType = (this.openclawQuick.apiType || '').trim();
+            const setProviderField = (key, value) => {
+                if (!value) return;
+                if (shouldOverrideProvider || provider[key] === undefined || provider[key] === null || provider[key] === '') {
+                    provider[key] = value;
+                }
+            };
+            setProviderField('baseUrl', baseUrl);
+            setProviderField('api', apiType);
+            if (apiKey) {
+                setProviderField('apiKey', apiKey);
+            }
+
+            const modelName = (this.openclawQuick.modelName || '').trim() || modelId;
+            const modelEntry = {
+                id: modelId,
+                name: modelName,
+                reasoning: false,
+                input: ['text'],
+                cost: {
+                    input: 0,
+                    output: 0,
+                    cacheRead: 0,
+                    cacheWrite: 0
+                }
+            };
+            if (contextWindow.value !== null) {
+                modelEntry.contextWindow = contextWindow.value;
+            }
+            if (maxTokens.value !== null) {
+                modelEntry.maxTokens = maxTokens.value;
+            }
+
+            const existingModels = Array.isArray(provider.models) ? [...provider.models] : [];
+            if (this.openclawQuick.overrideModels || existingModels.length === 0) {
+                provider.models = [modelEntry];
+            } else {
+                const idx = existingModels.findIndex(item => item && item.id === modelId);
+                if (idx >= 0) {
+                    existingModels[idx] = this.mergeOpenclawModelEntry(existingModels[idx], modelEntry, false);
+                } else {
+                    existingModels.push(modelEntry);
+                }
+                provider.models = existingModels;
+            }
+
+            providers[providerName] = provider;
+            models.providers = providers;
+            config.models = models;
+
+            if (this.openclawQuick.setPrimary) {
+                const agents = ensureObject(config.agents);
+                const defaults = ensureObject(agents.defaults);
+                const modelConfig = defaults.model && typeof defaults.model === 'object' && !Array.isArray(defaults.model)
+                    ? defaults.model
+                    : {};
+                modelConfig.primary = `${providerName}/${modelId}`;
+                defaults.model = modelConfig;
+                agents.defaults = defaults;
+                config.agents = agents;
+                if (config.agent && typeof config.agent === 'object' && !Array.isArray(config.agent)) {
+                    config.agent.model = modelConfig.primary;
+                }
+            }
+
+            this.openclawEditing.content = this.stringifyOpenclawConfig(config);
+            this.fillOpenclawStructured(config);
+            this.refreshOpenclawProviders(config);
+            this.refreshOpenclawAgentsList(config);
+            this.showMessage('配置已写入', 'success');
+        },
+
+        addOpenclawFallback() {
+            this.openclawStructured.agentFallbacks.push('');
+        },
+
+        removeOpenclawFallback(index) {
+            this.openclawStructured.agentFallbacks.splice(index, 1);
+            if (this.openclawStructured.agentFallbacks.length === 0) {
+                this.openclawStructured.agentFallbacks.push('');
+            }
+        },
+
+        addOpenclawEnvItem() {
+            this.openclawStructured.envItems.push({ key: '', value: '', show: false });
+        },
+
+        removeOpenclawEnvItem(index) {
+            this.openclawStructured.envItems.splice(index, 1);
+            if (this.openclawStructured.envItems.length === 0) {
+                this.openclawStructured.envItems.push({ key: '', value: '', show: false });
+            }
+        },
+
+        toggleOpenclawEnvItem(index) {
+            const item = this.openclawStructured.envItems[index];
+            if (item) {
+                item.show = !item.show;
+            }
+        },
+
+        addOpenclawToolsAllow() {
+            this.openclawStructured.toolsAllow.push('');
+        },
+
+        removeOpenclawToolsAllow(index) {
+            this.openclawStructured.toolsAllow.splice(index, 1);
+            if (this.openclawStructured.toolsAllow.length === 0) {
+                this.openclawStructured.toolsAllow.push('');
+            }
+        },
+
+        addOpenclawToolsDeny() {
+            this.openclawStructured.toolsDeny.push('');
+        },
+
+        removeOpenclawToolsDeny(index) {
+            this.openclawStructured.toolsDeny.splice(index, 1);
+            if (this.openclawStructured.toolsDeny.length === 0) {
+                this.openclawStructured.toolsDeny.push('');
+            }
+        },
+
+        openclawHasContent(config) {
+            return !!(config && typeof config.content === 'string' && config.content.trim());
+        },
+
+        openclawSubtitle(config) {
+            if (!this.openclawHasContent(config)) {
+                return '未设置配置';
+            }
+            const length = config.content.trim().length;
+            return `已保存 ${length} 字符`;
+        },
+
+        saveOpenclawConfigs() {
+            try {
+                localStorage.setItem('openclawConfigs', JSON.stringify(this.openclawConfigs));
+                return true;
+            } catch (_) {
+                this.showMessage('保存本地 OpenClaw 配置失败', 'error');
+                return false;
+            }
+        }
+    };
+}

package/web-ui/modules/app.methods.openclaw-persist.mjs

@@ -0,0 +1,251 @@
+export function createOpenclawPersistMethods(options = {}) {
+    const {
+        api,
+        defaultOpenclawTemplate = ''
+    } = options;
+
+    return {
+        openOpenclawAddModal() {
+            const modalToken = (Number(this.openclawModalLoadToken || 0) + 1);
+            this.openclawModalLoadToken = modalToken;
+            this.openclawEditorTitle = '添加 OpenClaw 配置';
+            this.openclawEditing = {
+                name: '',
+                content: '',
+                lockName: false
+            };
+            this.openclawConfigPath = '';
+            this.openclawConfigExists = false;
+            this.openclawLineEnding = '\n';
+            this.showOpenclawConfigModal = true;
+            void this.loadOpenclawConfigFromFile({
+                silent: true,
+                force: true,
+                fallbackToTemplate: true,
+                modalToken,
+                expectedEditorContent: ''
+            });
+        },
+
+        openOpenclawEditModal(name) {
+            const existing = this.openclawConfigs[name];
+            const modalToken = (Number(this.openclawModalLoadToken || 0) + 1);
+            this.openclawModalLoadToken = modalToken;
+            this.openclawEditorTitle = `编辑 OpenClaw 配置: ${name}`;
+            this.openclawEditing = {
+                name,
+                content: this.openclawHasContent(existing) ? existing.content : '',
+                lockName: true
+            };
+            this.syncOpenclawStructuredFromText({ silent: true });
+            this.showOpenclawConfigModal = true;
+            void this.loadOpenclawConfigFromFile({
+                silent: true,
+                force: false,
+                fallbackToTemplate: false,
+                modalToken,
+                expectedEditorContent: this.openclawEditing.content
+            });
+        },
+
+        closeOpenclawConfigModal(options = {}) {
+            const force = !!options.force;
+            if (!force && (this.openclawSaving || this.openclawApplying)) {
+                return;
+            }
+            this.openclawModalLoadToken = Number(this.openclawModalLoadToken || 0) + 1;
+            this.showOpenclawConfigModal = false;
+            this.openclawEditing = { name: '', content: '', lockName: false };
+            this.openclawSaving = false;
+            this.openclawApplying = false;
+            this.resetOpenclawStructured();
+            this.resetOpenclawQuick();
+        },
+
+        async loadOpenclawConfigFromFile(options = {}) {
+            const silent = !!options.silent;
+            const force = !!options.force;
+            const fallbackToTemplate = options.fallbackToTemplate !== false;
+            const modalToken = Number(options.modalToken || this.openclawModalLoadToken || 0);
+            const expectedEditorContent = typeof options.expectedEditorContent === 'string'
+                ? options.expectedEditorContent
+                : (typeof this.openclawEditing.content === 'string' ? this.openclawEditing.content : '');
+            const requestSeq = (Number(this.openclawFileLoadRequestSeq || 0) + 1);
+            this.openclawFileLoadRequestSeq = requestSeq;
+            this.openclawFileLoading = true;
+            try {
+                const res = await api('get-openclaw-config');
+                if (
+                    requestSeq !== Number(this.openclawFileLoadRequestSeq || 0)
+                    || modalToken !== Number(this.openclawModalLoadToken || 0)
+                ) {
+                    return;
+                }
+                if (res.error) {
+                    if (!silent) {
+                        this.showMessage(res.error, 'error');
+                    }
+                    return;
+                }
+                this.openclawConfigPath = res.path || '';
+                this.openclawConfigExists = !!res.exists;
+                this.openclawLineEnding = res.lineEnding === '\r\n' ? '\r\n' : '\n';
+                const hasContent = !!(res.content && res.content.trim());
+                const currentContent = typeof this.openclawEditing.content === 'string'
+                    ? this.openclawEditing.content
+                    : '';
+                const editorChangedSinceRequest = currentContent !== expectedEditorContent;
+                const shouldOverride = force
+                    ? (!currentContent.trim() || !editorChangedSinceRequest)
+                    : (!currentContent || !currentContent.trim());
+                if (hasContent && shouldOverride) {
+                    this.openclawEditing.content = res.content;
+                } else if (!hasContent && shouldOverride && fallbackToTemplate) {
+                    this.openclawEditing.content = defaultOpenclawTemplate;
+                }
+                this.syncOpenclawStructuredFromText({ silent: true });
+                if (!silent) {
+                    this.showMessage('加载完成', 'success');
+                }
+            } catch (e) {
+                if (
+                    requestSeq !== Number(this.openclawFileLoadRequestSeq || 0)
+                    || modalToken !== Number(this.openclawModalLoadToken || 0)
+                ) {
+                    return;
+                }
+                if (!silent) {
+                    this.showMessage('加载配置失败', 'error');
+                }
+            } finally {
+                if (requestSeq === Number(this.openclawFileLoadRequestSeq || 0)) {
+                    this.openclawFileLoading = false;
+                }
+            }
+        },
+
+        persistOpenclawConfig({ closeModal = true } = {}) {
+            if (!this.openclawEditing.name || !this.openclawEditing.name.trim()) {
+                this.showMessage('请输入名称', 'error');
+                return '';
+            }
+            const name = this.openclawEditing.name.trim();
+            if (!this.openclawEditing.lockName && this.openclawConfigs[name]) {
+                this.showMessage('名称已存在', 'error');
+                return '';
+            }
+            if (!this.openclawEditing.content || !this.openclawEditing.content.trim()) {
+                this.showMessage('配置内容不能为空', 'error');
+                return '';
+            }
+
+            const hadPreviousConfig = Object.prototype.hasOwnProperty.call(this.openclawConfigs, name);
+            const previousConfig = hadPreviousConfig ? this.openclawConfigs[name] : undefined;
+            const previousCurrentConfig = this.currentOpenclawConfig;
+            this.openclawConfigs[name] = {
+                content: this.openclawEditing.content
+            };
+            this.currentOpenclawConfig = name;
+            if (this.saveOpenclawConfigs() === false) {
+                if (hadPreviousConfig) {
+                    this.openclawConfigs[name] = previousConfig;
+                } else {
+                    delete this.openclawConfigs[name];
+                }
+                this.currentOpenclawConfig = previousCurrentConfig;
+                return '';
+            }
+            if (closeModal) {
+                this.closeOpenclawConfigModal({ force: true });
+            }
+            return name;
+        },
+
+        async saveOpenclawConfig() {
+            if (this.openclawSaving || this.openclawApplying) {
+                return;
+            }
+            this.openclawSaving = true;
+            try {
+                const name = this.persistOpenclawConfig();
+                if (!name) return;
+                this.showMessage('操作成功', 'success');
+            } finally {
+                this.openclawSaving = false;
+            }
+        },
+
+        async saveAndApplyOpenclawConfig() {
+            if (this.openclawSaving || this.openclawApplying) {
+                return;
+            }
+            this.openclawApplying = true;
+            try {
+                const name = this.persistOpenclawConfig({ closeModal: false });
+                if (!name) return;
+                const config = this.openclawConfigs[name];
+                const res = await api('apply-openclaw-config', {
+                    content: config.content,
+                    lineEnding: this.openclawLineEnding
+                });
+                if (res.error || res.success === false) {
+                    this.showMessage(res.error || '应用配置失败', 'error');
+                    return;
+                }
+                this.openclawConfigPath = res.targetPath || this.openclawConfigPath;
+                this.openclawConfigExists = true;
+                const targetTip = res.targetPath ? `（${res.targetPath}）` : '';
+                this.showMessage(`已保存并应用 OpenClaw 配置${targetTip}`, 'success');
+                this.closeOpenclawConfigModal({ force: true });
+            } catch (e) {
+                this.showMessage('应用配置失败', 'error');
+            } finally {
+                this.openclawApplying = false;
+            }
+        },
+
+        async deleteOpenclawConfig(name) {
+            if (Object.keys(this.openclawConfigs).length <= 1) {
+                return this.showMessage('至少保留一项', 'error');
+            }
+            const confirmed = await this.requestConfirmDialog({
+                title: '删除 OpenClaw 配置',
+                message: `确定删除配置 "${name}"?`,
+                confirmText: '删除',
+                cancelText: '取消',
+                danger: true
+            });
+            if (!confirmed) return;
+            delete this.openclawConfigs[name];
+            if (this.currentOpenclawConfig === name) {
+                this.currentOpenclawConfig = Object.keys(this.openclawConfigs)[0];
+            }
+            this.saveOpenclawConfigs();
+            this.showMessage('操作成功', 'success');
+        },
+
+        async applyOpenclawConfig(name) {
+            this.currentOpenclawConfig = name;
+            const config = this.openclawConfigs[name];
+            if (!this.openclawHasContent(config)) {
+                return this.showMessage('配置为空', 'error');
+            }
+            try {
+                const res = await api('apply-openclaw-config', {
+                    content: config.content,
+                    lineEnding: this.openclawLineEnding
+                });
+                if (res.error || res.success === false) {
+                    this.showMessage(res.error || '应用配置失败', 'error');
+                } else {
+                    this.openclawConfigPath = res.targetPath || this.openclawConfigPath;
+                    this.openclawConfigExists = true;
+                    const targetTip = res.targetPath ? `（${res.targetPath}）` : '';
+                    this.showMessage(`已应用 OpenClaw 配置: ${name}${targetTip}`, 'success');
+                }
+            } catch (_) {
+                this.showMessage('应用配置失败', 'error');
+            }
+        }
+    };
+}