@xcanwin/manyoyo 8.7.0 → 8.7.1

package/lib/agent-adapters/index.js

@@ -41,24 +41,41 @@ function resolveYoloCommand(yolo) {
     return adapter.yoloCommand;
 }
 
-// Codex 0.160 / 0.164 实测不认环境变量 OPENAI_BASE_URL，只认 `-c openai_base_url=...`。
-// 向导给 Codex 配“兼容服务”写的是环境变量，所以执行 codex 的命令要在容器里由 shell 展开出 -c：
-// 变量没设就一个参数都不多；地址只在容器里从环境变量读，不拼进命令文本（也就不会出现在日志和 ps 里）。
-// 只处理以 codex 开头（可带前置的 KEY=值）的命令；命令里已经写了 openai_base_url 就以用户的为准。
+// Codex 0.164 实测：`exec` 不认环境变量 OPENAI_BASE_URL，也不读 OPENAI_API_KEY（DeepSeek 返回 401），
+// 也不读 OPENAI_MODEL；要用自定义 model_provider（env_key 指定读哪个变量，wire_api=responses）。
+// 向导给 Codex 配“兼容服务”写的是环境变量，所以执行 codex 的命令要在容器里由 shell 展开成 -c / --model：
+// 变量没设就一个参数都不多；值只在容器里从环境变量读，不拼进命令文本（也就不会出现在日志和 ps 里）。
+// 只处理以 codex 开头（可带前置的 KEY=值）的命令；命令里已经写了 openai_base_url / model_provider 就以用户的为准。
+// 只有地址没有 OPENAI_API_KEY 时（Codex 用 ChatGPT 登录、地址指向 chatgpt.com 的后端）走内置 provider 换地址的老办法；
+// 两个都有才用自定义 provider。老写法总是带上（对自定义 provider 无影响），这样没有 Key 的老配置不退化。
 const CODEX_BASE_URL_FLAGS = '${OPENAI_BASE_URL:+-c "openai_base_url=\\"$OPENAI_BASE_URL\\""}';
+const CODEX_PROVIDER_FLAGS = '${OPENAI_BASE_URL:+${OPENAI_API_KEY:+-c model_provider=manyoyo -c model_providers.manyoyo.name=manyoyo -c "model_providers.manyoyo.base_url=\\"$OPENAI_BASE_URL\\"" -c model_providers.manyoyo.env_key=OPENAI_API_KEY -c model_providers.manyoyo.wire_api=responses}}';
+const CODEX_MODEL_FLAGS = '${OPENAI_MODEL:+--model "$OPENAI_MODEL"}';
 // 有 exec / exec resume 子命令时插在它们后面（codex exec -c … --json …），保持 `codex exec` 连在一起
 const CODEX_COMMAND_START = /^((?:\s*[A-Za-z_][A-Za-z0-9_]*=(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]*)\s+)*\s*)codex(?:\s+exec(?:\s+resume)?)?(?=\s|$)/;
+// codex 不允许 --model 出现两次，命令里已经指定了模型（会话里选的）就不再追加环境变量里的
+const CODEX_HAS_MODEL = /(?:^|\s)(?:--model|-m)(?:[\s=]|$)|(?:^|\s)model=/;
 
+// 我们自己拼进命令的系统说明（-c 'developer_instructions=…'）里有任意文字，判断“用户有没有写过”时要先去掉
+const CODEX_INSTRUCTIONS_FLAG = /-c\s+'developer_instructions=(?:[^']|'\\'')*'/g;
+
+// 传入的应该是还带着 {prompt} 占位的模板（或没有提示词的命令）：渲染进提示词之后再调用，用户的提示词会干扰“已经写过”的判断
 function withCodexBaseUrl(command) {
     const text = String(command || '');
-    if (!text || /openai_base_url/.test(text)) return text;
+    if (!text) return text;
     const match = text.match(CODEX_COMMAND_START);
     if (!match) return text;
-    return `${match[0]} ${CODEX_BASE_URL_FLAGS}${text.slice(match[0].length)}`;
+    const detect = text.replace(CODEX_INSTRUCTIONS_FLAG, ' ');
+    const parts = [];
+    if (!/openai_base_url|model_provider/.test(detect)) parts.push(CODEX_BASE_URL_FLAGS, CODEX_PROVIDER_FLAGS);
+    if (!CODEX_HAS_MODEL.test(detect)) parts.push(CODEX_MODEL_FLAGS);
+    if (!parts.length) return text;
+    return `${match[0]} ${parts.join(' ')}${text.slice(match[0].length)}`;
 }
 
 module.exports = {
     AGENT_ADAPTERS,
+    findAdapterByAlias,
     resolveYoloCommand,
     withCodexBaseUrl
 };

package/lib/init-config.js

@@ -25,7 +25,8 @@ const AGENT_ENV_SCHEMA = {
             { name: 'ANTHROPIC_DEFAULT_OPUS_MODEL', description: 'Opus 档位对应的模型', secret: false },
             { name: 'ANTHROPIC_DEFAULT_SONNET_MODEL', description: 'Sonnet 档位对应的模型', secret: false },
             { name: 'ANTHROPIC_DEFAULT_HAIKU_MODEL', description: 'Haiku 档位对应的模型', secret: false },
-            { name: 'CLAUDE_CODE_SUBAGENT_MODEL', description: '子 Agent 使用的模型', secret: false }
+            { name: 'CLAUDE_CODE_SUBAGENT_MODEL', description: '子 Agent 使用的模型', secret: false },
+            { name: 'ENABLE_TOOL_SEARCH', description: '工具搜索（部分兼容服务要设为 false，否则模型调不了工具）', secret: false }
         ]
     },
     codex: {
@@ -481,6 +482,8 @@ async function initAgentConfigs(rawAgents, options = {}) {
 
 module.exports = {
     initAgentConfigs,
+    collectClaudeInitData,
+    collectCodexInitData,
     AGENT_ENV_SCHEMA,
     agentEnvKeys
 };

package/lib/json5-text-edit.js

@@ -224,6 +224,56 @@ function findTopLevelPropertyValueRange(text, propertyName) {
     return findValueRangeByPath(text, [propertyName]);
 }
 
+// 按路径删除一个属性（连同它所在行和行尾 // 注释）；路径不存在就原样返回。
+// 删掉最后一个属性时前一项的逗号会留下成为尾逗号，JSON5 允许。
+function removeValueByPath(text, pathParts) {
+    if (!Array.isArray(pathParts) || pathParts.length === 0) {
+        throw new Error('path 不能为空');
+    }
+    let objectStart = findRootObjectStart(text);
+    if (objectStart === -1) return text;
+    for (let i = 0; i < pathParts.length - 1; i += 1) {
+        const range = findObjectPropertyValueRange(text, objectStart, pathParts[i]);
+        if (!range) return text;
+        const next = skipTrivia(text, range.start);
+        if (text[next] !== '{') return text;
+        objectStart = next;
+    }
+    const target = pathParts[pathParts.length - 1];
+    let cursor = skipTrivia(text, objectStart + 1);
+    while (cursor < text.length) {
+        cursor = skipTrivia(text, cursor);
+        if (text[cursor] === '}') return text;
+        const keyStart = cursor;
+        const token = readPropertyToken(text, cursor);
+        if (!token) return text;
+        cursor = skipTrivia(text, token.end);
+        if (text[cursor] !== ':') return text;
+        const valueStart = skipTrivia(text, cursor + 1);
+        const valueEnd = scanValueEnd(text, valueStart);
+        if (token.value === target) {
+            let end = valueEnd;
+            while (text[end] === ' ' || text[end] === '\t') end += 1;
+            if (text[end] === ',') end += 1;
+            while (text[end] === ' ' || text[end] === '\t') end += 1;
+            if (text[end] === '/' && text[end + 1] === '/') {
+                while (end < text.length && text[end] !== '\n') end += 1;
+            }
+            const lineStart = text.lastIndexOf('\n', keyStart - 1) + 1;
+            const onOwnLine = /^[ \t]*$/.test(text.slice(lineStart, keyStart));
+            if (onOwnLine && text[end] === '\n') end += 1;
+            return `${text.slice(0, onOwnLine ? lineStart : keyStart)}${text.slice(end)}`;
+        }
+        cursor = skipTrivia(text, valueEnd);
+        if (text[cursor] === ',') {
+            cursor += 1;
+            continue;
+        }
+        return text;
+    }
+    return text;
+}
+
 function applyTextReplacements(text, replacements) {
     return replacements
         .slice()
@@ -313,5 +363,6 @@ module.exports = {
     findTopLevelPropertyValueRange,
     findValueRangeByPath,
     applyTextReplacements,
+    removeValueByPath,
     upsertValueByPath
 };

package/lib/model-service-containers.js

@@ -0,0 +1,63 @@
+'use strict';
+
+// 模型服务改了 Key / 地址 / 模型后，已有容器的 box/env 里还是创建时写进去的旧值。
+// 这里按“env 里的 Key 等于旧 Key”找出还在用它的容器，并把新值写进它们的 box/env（每次 exec 都会重新读，下一轮对话生效，不用重建）。
+// 只改指定的几个变量（整行替换，没有就追加，要删的删掉），其余行和注释原样保留。
+const state = require('./container-state');
+const { formatEnvValue, parseEnvText } = require('./env-text');
+const { parseEnvEntry } = require('./runtime-normalizers');
+
+/**
+ * containers：[{ name, id }]（受管容器）；返回 box/env 里 keyEnv 的值等于 keyValue 的那些。
+ * 服务有地址时容器里的地址也要相同：同一个 Key 常被用在不同的服务上（比如 Claude 和 Codex，或两个模型），不能误伤。
+ */
+function findUsingContainers({ homeDir, containers, keyEnv, keyValue, baseUrlKey, baseUrl }) {
+    if (!keyEnv || !keyValue) return [];
+    return containers.filter(item => {
+        if (!state.stateExists(homeDir, item.id)) return false;
+        const { entries } = parseEnvText(state.readEnv(homeDir, item.id).text);
+        if (!entries.some(entry => entry.key === keyEnv && entry.value === keyValue)) return false;
+        return !baseUrlKey || !baseUrl || entries.some(entry => entry.key === baseUrlKey && entry.value === baseUrl);
+    });
+}
+
+/** 返回改写后的 env 文本；set：{ KEY: 新值 }，remove：[KEY…] */
+function rewriteEnvText(text, { set = {}, remove = [] }) {
+    const lines = String(text || '').split('\n');
+    const { entries } = parseEnvText(text);
+    const handled = new Set();
+    const drop = new Set();
+    entries.forEach(entry => {
+        if (Object.prototype.hasOwnProperty.call(set, entry.key)) {
+            lines[entry.line - 1] = `${entry.key}=${formatEnvValue(String(set[entry.key]))}`;
+            handled.add(entry.key);
+        } else if (remove.includes(entry.key)) {
+            drop.add(entry.line - 1);
+        }
+    });
+    let out = lines.filter((_, index) => !drop.has(index)).join('\n');
+    const missing = Object.keys(set).filter(key => !handled.has(key));
+    if (missing.length) {
+        if (out && !out.endsWith('\n')) out += '\n';
+        out += missing.map(key => `${key}=${formatEnvValue(String(set[key]))}`).join('\n');
+    }
+    return out && !out.endsWith('\n') ? `${out}\n` : out;
+}
+
+function applyToContainers({ homeDir, targets, set, remove }) {
+    const updated = [];
+    for (const item of targets) {
+        const current = state.readEnv(homeDir, item.id);
+        // 读到的 etag 随写随比，容器里同时改过就跳过这一个，不覆盖别人的修改
+        // 配置已经保存，一个容器写失败（冲突、写不进）只跳过它，不能让整个请求报错
+        try {
+            state.writeEnv(homeDir, item.id, rewriteEnvText(current.text, { set, remove }), { ifMatch: current.etag, parseEnvEntry });
+            updated.push(item.name);
+        } catch (e) {
+            // 跳过
+        }
+    }
+    return updated;
+}
+
+module.exports = { findUsingContainers, rewriteEnvText, applyToContainers };

package/lib/model-service-import.js

@@ -0,0 +1,98 @@
+'use strict';
+
+// 「从本机导入」：把本机已有的 Claude / Codex 的 Key、地址、模型读出来，让用户预览后写成模型服务。
+// 数据源与 `manyoyo init` 相同（环境变量、~/.claude/settings.json 的 env、~/.codex 的 OPENAI_API_KEY 与 config.toml），
+// 但只提取 Key / 地址 / 模型，不加任何挂载（init 会把整个 ~/.codex 读写挂进容器），也不碰 OAuth 登录凭据。
+const { AGENT_ENV_SCHEMA, collectClaudeInitData, collectCodexInitData } = require('./init-config');
+const { findProviderByBaseUrl } = require('./provider-presets');
+const { listModelServices, keyValueOf, uniqueRunName, keyTail, agentLabelOf } = require('./model-services');
+const { buildAgentRunProfile } = require('./setup');
+
+const IMPORT_AGENTS = [
+    { id: 'claude', collect: collectClaudeInitData, sources: '环境变量、~/.claude/settings.json' },
+    { id: 'codex', collect: collectCodexInitData, sources: '环境变量、~/.codex/auth.json、~/.codex/config.toml' }
+];
+
+// 读不了文件时只当没有，不往终端打印
+const SILENT_CTX = { colors: { YELLOW: '', NC: '' }, log: () => {} };
+
+/**
+ * 扫描本机，返回候选（含内部 env，调用方不能原样下发给前端）。
+ * 每个候选：{ id, agent, env, baseUrl, model, secret, duplicate, invalid }
+ */
+function scanLocalServices(homeDir, config) {
+    const existing = listModelServices(config);
+    const existingKeys = new Set(existing.map(item => `${item.agent}|${keyValueOf(config, item.name)}`));
+    const candidates = [];
+    for (const agent of IMPORT_AGENTS) {
+        const spec = AGENT_ENV_SCHEMA[agent.id];
+        const { values } = agent.collect(homeDir, SILENT_CTX);
+        const env = {};
+        for (const item of spec.env) {
+            const value = values[item.name];
+            // OAuth 令牌不导入：订阅登录只做引导
+            if (item.name.includes('OAUTH')) continue;
+            if (typeof value === 'string' && value.trim()) env[item.name] = value.trim();
+        }
+        const keyName = spec.requiredAnyOf.find(name => env[name]);
+        if (!keyName) continue;
+        const secret = env[keyName];
+        let invalid = '';
+        try {
+            buildAgentRunProfile(agent.id, env, {});
+            // Codex 不会从环境变量读默认模型，有地址没模型的配置导入后请求会直接报错
+            if (agent.id === 'codex' && env[spec.baseUrlKey] && !env[spec.modelKey]) throw new Error('Codex CLI 接兼容服务必须指定模型');
+        } catch (e) {
+            invalid = e.message;
+        }
+        candidates.push({
+            id: agent.id,
+            agent: agent.id,
+            env,
+            secret,
+            baseUrl: env[spec.baseUrlKey] || '',
+            model: env[spec.modelKey] || '',
+            duplicate: existingKeys.has(`${agent.id}|${secret}`),
+            invalid
+        });
+    }
+    return candidates;
+}
+
+/** 给前端预览用：只有 Key 末 4 位，没有 env 原文 */
+function toPreview(candidates) {
+    return candidates.map(item => {
+        const provider = findProviderByBaseUrl(item.agent, item.baseUrl);
+        return {
+            id: item.id,
+            agent: item.agent,
+            agentLabel: agentLabelOf(item.agent),
+            providerLabel: provider ? provider.label : (item.baseUrl ? '自定义地址' : '官方'),
+            baseUrl: item.baseUrl,
+            model: item.model,
+            keyTail: keyTail(item.secret),
+            duplicate: item.duplicate,
+            invalid: item.invalid
+        };
+    });
+}
+
+/** 把选中的候选变成要写入的 [{ name, profile }]；名字冲突就加数字，绝不覆盖已有的运行配置 */
+function buildImportRuns(config, candidates, ids, options = {}) {
+    const runs = { ...(config && config.runs ? config.runs : {}) };
+    const built = [];
+    for (const id of [...new Set(ids)]) {
+        const item = candidates.find(candidate => candidate.id === id);
+        if (!item) throw new Error(`本机没有可导入的 ${id}`);
+        if (item.invalid) throw new Error(`${agentLabelOf(item.agent)} 的本机配置不能导入：${item.invalid}`);
+        const provider = findProviderByBaseUrl(item.agent, item.baseUrl);
+        const name = uniqueRunName(runs, `${item.agent}-${provider ? provider.id : 'local'}`);
+        const profile = buildAgentRunProfile(item.agent, item.env);
+        profile.containerName = `my-${name}-{now}`;
+        runs[name] = profile;
+        built.push({ name, profile });
+    }
+    return built;
+}
+
+module.exports = { IMPORT_AGENTS, scanLocalServices, toPreview, buildImportRuns };

package/lib/model-services.js

@@ -0,0 +1,313 @@
+'use strict';
+
+const JSON5 = require('json5');
+const { isDeepStrictEqual } = require('util');
+
+// 「模型服务」：一套模型服务 = 一个 runs.<名>（Key 写在它的 env 里），不新增配置结构。
+// 这里只放纯逻辑：认出已有的服务、给出“这个 Key 也能给另一个 Agent 用”的建议、构造要写入的配置改动；
+// 读写文件与接口在 lib/web/model-services.js，写盘走 lib/setup-config + lib/secure-file。
+const { AGENT_ENV_SCHEMA } = require('./init-config');
+const { parseEnvEntry } = require('./runtime-normalizers');
+const { providersForAgent, findProviderByBaseUrl } = require('./provider-presets');
+const { identifyRunAgent, buildAgentRunProfile } = require('./setup');
+const { upsertValueByPath, removeValueByPath } = require('./json5-text-edit');
+
+// 界面上说清楚是命令行工具（不是网页版 / 桌面版）
+const AGENT_DISPLAY_LABELS = { claude: 'Claude Code CLI', codex: 'Codex CLI' };
+function agentLabelOf(agent) {
+    return AGENT_DISPLAY_LABELS[agent] || AGENT_ENV_SCHEMA[agent].label;
+}
+
+const RUN_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,39}$/;
+// 订阅登录用的长期令牌；保存它时要删掉同一个运行配置里会盖过订阅的 API Key 类变量（Claude Code 同时有 Key 时优先用 Key）
+const CLAUDE_OAUTH_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
+const CLAUDE_API_KEYS = ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_API_KEY'];
+
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function envText(env, key) {
+    const value = isPlainObject(env) ? env[key] : undefined;
+    return typeof value === 'string' || typeof value === 'number' ? String(value).trim() : '';
+}
+
+function keyTail(secret) {
+    const text = String(secret || '');
+    // 太短的 Key 末 4 位已经泄露了一大半，只显示省略号
+    return text.length >= 12 ? `…${text.slice(-4)}` : (text ? '…' : '');
+}
+
+// 这个运行配置里实际生效的凭据变量：按 schema 的优先顺序取第一个非空的
+function findKey(spec, env) {
+    for (const name of spec.requiredAnyOf) {
+        const value = envText(env, name);
+        if (value) return { name, value };
+    }
+    return null;
+}
+
+/** 列出已有的模型服务；响应里只有 Key 的末 4 位，绝不带出 Key 本身 */
+function listModelServices(config) {
+    const runs = isPlainObject(config && config.runs) ? config.runs : {};
+    const services = [];
+    for (const [name, run] of Object.entries(runs)) {
+        const agent = identifyRunAgent(name, run);
+        if (!agent) continue;
+        const spec = AGENT_ENV_SCHEMA[agent];
+        const env = isPlainObject(run) ? run.env : null;
+        const key = findKey(spec, env);
+        if (!key) continue;
+        const baseUrl = envText(env, spec.baseUrlKey);
+        const provider = findProviderByBaseUrl(agent, baseUrl);
+        const subscription = key.name === CLAUDE_OAUTH_KEY;
+        // 这家服务必需的附加变量里，运行配置里还没有（或值不对）的：界面据此提示“一键修复”
+        const missingExtraEnv = {};
+        if (provider && !subscription) {
+            for (const [extraKey, extraValue] of Object.entries(provider.extraEnv || {})) {
+                if (envText(env, extraKey) !== extraValue) missingExtraEnv[extraKey] = extraValue;
+            }
+        }
+        services.push({
+            name,
+            agent,
+            agentLabel: agentLabelOf(agent),
+            providerId: provider ? provider.id : '',
+            providerLabel: subscription ? '订阅登录' : (provider ? provider.label : (baseUrl ? '自定义地址' : '官方')),
+            authMode: subscription ? 'subscription' : 'key',
+            baseUrl,
+            keyEnv: key.name,
+            keyTail: keyTail(key.value),
+            model: envText(env, spec.modelKey),
+            missingExtraEnv
+        });
+    }
+    return services;
+}
+
+function keyValueOf(config, name) {
+    const run = config.runs && config.runs[name];
+    const agent = identifyRunAgent(name, run);
+    const found = agent ? findKey(AGENT_ENV_SCHEMA[agent], run.env) : null;
+    return found ? found.value : '';
+}
+
+/** “这个 Key 也能给另一个 Agent 用”：同一服务商在另一个 Agent 上有预设、且还没有用同一个 Key 的服务 */
+function suggestReuse(config) {
+    const services = listModelServices(config);
+    const seen = new Set(services.map(item => `${item.agent}|${item.providerId}|${keyValueOf(config, item.name)}`));
+    const suggestions = [];
+    for (const item of services) {
+        if (!item.providerId || item.authMode !== 'key') continue;
+        const secret = keyValueOf(config, item.name);
+        for (const target of ['claude', 'codex']) {
+            if (target === item.agent) continue;
+            if (!providersForAgent(target).some(p => p.id === item.providerId)) continue;
+            const id = `${target}|${item.providerId}|${secret}`;
+            if (seen.has(id)) continue;
+            seen.add(id);
+            suggestions.push({
+                from: item.name,
+                agent: target,
+                providerId: item.providerId,
+                label: `${item.providerLabel} 的 Key 也能给 ${agentLabelOf(target)} 用`
+            });
+        }
+    }
+    return suggestions;
+}
+
+function uniqueRunName(runs, base) {
+    const taken = isPlainObject(runs) ? runs : {};
+    const root = String(base).replace(/[^A-Za-z0-9_.-]/g, '-').replace(/^[^A-Za-z0-9]+/, '').slice(0, 36) || 'model';
+    if (!taken[root]) return root;
+    for (let i = 2; i < 1000; i += 1) {
+        if (!taken[`${root}-${i}`]) return `${root}-${i}`;
+    }
+    throw new Error('无法生成不重名的名字');
+}
+
+function assertRunName(name) {
+    if (!RUN_NAME_PATTERN.test(String(name || ''))) {
+        throw new Error('名字只能包含字母、数字、下划线、点和横线，且以字母或数字开头，最长 40 个字符');
+    }
+}
+
+function presetFor(agent, providerId) {
+    const preset = providersForAgent(agent).find(item => item.id === providerId);
+    if (!preset) throw new Error(`${agentLabelOf(agent)} 没有这个服务商的预设`);
+    return preset;
+}
+
+/**
+ * 新增一套服务，返回要写入的 { name, profile }；绝不覆盖已有的运行配置。
+ * input：{ agent, providerId | baseUrl, key, model?, name?, subscription? }
+ */
+function buildNewService(config, input, options = {}) {
+    const agent = String(input.agent || '').trim();
+    const spec = AGENT_ENV_SCHEMA[agent];
+    if (!spec) throw new Error(`不支持的 Agent: ${agent}`);
+    const runs = isPlainObject(config && config.runs) ? config.runs : {};
+    const secret = String(input.key || '').trim();
+    if (!secret) throw new Error(input.subscription ? '请粘贴订阅令牌' : '请填写 API Key');
+
+    const env = {};
+    let baseName = agent;
+    if (input.subscription) {
+        if (agent !== 'claude') throw new Error('订阅登录令牌目前只支持 Claude Code');
+        env[CLAUDE_OAUTH_KEY] = secret;
+        baseName = `${agent}-subscription`;
+    } else if (input.providerId) {
+        const preset = presetFor(agent, String(input.providerId));
+        env[preset.keyEnv] = secret;
+        env[spec.baseUrlKey] = preset.baseUrl;
+        const model = String(input.model || '').trim() || preset.defaultModel;
+        if (model) env[spec.modelKey] = model;
+        Object.assign(env, preset.extraEnv);
+        baseName = `${agent}-${preset.id}`;
+    } else {
+        const baseUrl = String(input.baseUrl || '').trim();
+        if (baseUrl && !/^https?:\/\//i.test(baseUrl)) throw new Error('Base URL 必须以 http:// 或 https:// 开头');
+        env[spec.requiredAnyOf.find(name => !name.includes('OAUTH')) || spec.requiredAnyOf[0]] = secret;
+        if (baseUrl) env[spec.baseUrlKey] = baseUrl;
+        const model = String(input.model || '').trim();
+        if (model) env[spec.modelKey] = model;
+        baseName = `${agent}-custom`;
+    }
+    if (agent === 'codex' && env[spec.baseUrlKey] && !env[spec.modelKey]) {
+        throw new Error('Codex CLI 接兼容服务必须填写模型名');
+    }
+    const name = input.name ? String(input.name).trim() : uniqueRunName(runs, baseName);
+    assertRunName(name);
+    if (runs[name]) throw new Error(`已有名为 ${name} 的运行配置，请换一个名字`);
+    const profile = buildAgentRunProfile(agent, env);
+    profile.containerName = `my-${name}-{now}`;
+    return { name, profile };
+}
+
+/** 把已有服务的 Key 复用给另一个 Agent（同一服务商）。返回 { name, profile } */
+function buildReuseService(config, fromName, targetAgent, options = {}) {
+    const services = listModelServices(config);
+    const source = services.find(item => item.name === fromName);
+    if (!source) throw new Error(`找不到模型服务: ${fromName}`);
+    if (!source.providerId || source.authMode !== 'key') throw new Error('这个服务不能直接复用给别的 Agent');
+    const built = buildNewService(config, {
+        agent: targetAgent,
+        providerId: source.providerId,
+        key: keyValueOf(config, fromName)
+    }, options);
+    const sourceRun = config.runs[fromName];
+    // 原来那套指定过自己的目录就照抄；是默认工作目录根（老版本写进去的）就不抄
+    const sourceHost = typeof sourceRun.hostPath === 'string' ? sourceRun.hostPath.replace(/\/+$/, '') : '';
+    const defaultRoot = String(options.defaultHostPath || '').replace(/\/+$/, '');
+    if (sourceHost && sourceHost !== defaultRoot && !built.profile.hostPath) {
+        built.profile.hostPath = sourceRun.hostPath;
+    }
+    return built;
+}
+
+/**
+ * 编辑已有服务：key 留空表示不改。返回配置改动列表 ops（set / remove，路径从根开始）。
+ * 订阅令牌：换成订阅令牌时删掉同一个运行配置里的 API Key 类变量和 Base URL。
+ */
+function buildServiceEdit(config, name, patch) {
+    const runs = isPlainObject(config && config.runs) ? config.runs : {};
+    const run = runs[name];
+    const agent = identifyRunAgent(name, run);
+    if (!agent) throw new Error(`找不到模型服务: ${name}`);
+    const spec = AGENT_ENV_SCHEMA[agent];
+    const current = findKey(spec, run.env);
+    const ops = [];
+    const setEnv = (key, value) => {
+        parseEnvEntry(`${key}=${value}`);
+        ops.push({ type: 'set', path: ['runs', name, 'env', key], value: String(value) });
+    };
+    if (patch.applyPresetExtras) {
+        const service = listModelServices(config).find(item => item.name === name);
+        for (const [key, value] of Object.entries(service ? service.missingExtraEnv : {})) setEnv(key, value);
+    }
+    const secret = String(patch.key || '').trim();
+    if (secret) {
+        if (patch.subscription) {
+            if (agent !== 'claude') throw new Error('订阅登录令牌目前只支持 Claude Code');
+            setEnv(CLAUDE_OAUTH_KEY, secret);
+            [...CLAUDE_API_KEYS, spec.baseUrlKey].forEach(key => {
+                if (isPlainObject(run.env) && key in run.env) ops.push({ type: 'remove', path: ['runs', name, 'env', key] });
+            });
+        } else {
+            setEnv(current && current.name !== CLAUDE_OAUTH_KEY ? current.name : spec.requiredAnyOf.find(n => !n.includes('OAUTH')), secret);
+        }
+    }
+    if (patch.baseUrl !== undefined) {
+        const baseUrl = String(patch.baseUrl).trim();
+        if (baseUrl && !/^https?:\/\//i.test(baseUrl)) throw new Error('Base URL 必须以 http:// 或 https:// 开头');
+        if (baseUrl) setEnv(spec.baseUrlKey, baseUrl);
+        else if (isPlainObject(run.env) && spec.baseUrlKey in run.env) ops.push({ type: 'remove', path: ['runs', name, 'env', spec.baseUrlKey] });
+    }
+    if (patch.model !== undefined) {
+        const model = String(patch.model).trim();
+        if (model) setEnv(spec.modelKey, model);
+        else if (isPlainObject(run.env) && spec.modelKey in run.env) ops.push({ type: 'remove', path: ['runs', name, 'env', spec.modelKey] });
+    }
+    // Codex 有地址就必须有模型（不会从环境变量读默认模型，缺了请求直接报错）
+    if (agent === 'codex' && ops.some(op => [spec.baseUrlKey, spec.modelKey].includes(op.path[op.path.length - 1]))) {
+        const after = { ...(isPlainObject(run.env) ? run.env : {}) };
+        for (const op of ops) {
+            const key = op.path[op.path.length - 1];
+            if (op.type === 'set') after[key] = op.value;
+            else delete after[key];
+        }
+        if (envText(after, spec.baseUrlKey) && !envText(after, spec.modelKey)) throw new Error('Codex CLI 接兼容服务必须填写模型名');
+    }
+    return { agent, ops };
+}
+
+// 把改动列表落到配置原文上（局部替换，保留注释和其它字段）
+function applyConfigOps(baseRaw, ops) {
+    let raw = baseRaw;
+    for (const op of ops) {
+        raw = op.type === 'remove'
+            ? removeValueByPath(raw, op.path)
+            : upsertValueByPath(raw, op.path, JSON.stringify(op.value, null, 4));
+    }
+    return raw;
+}
+
+function valueAtPath(root, pathParts) {
+    let node = root;
+    for (const key of pathParts) {
+        if (node === null || typeof node !== 'object' || !Object.prototype.hasOwnProperty.call(node, key)) return undefined;
+        node = node[key];
+    }
+    return node;
+}
+
+/**
+ * 写盘前核对：把改动落到原文后重新解析，每条 set 必须读回同样的值、每条 remove 必须读不到。
+ * 局部文本替换遇到带转义的键名等边角情况可能“静默没改到”或在前面多插一个同名键，不核对就会回报成功却没生效。
+ */
+function assertOpsApplied(nextRaw, ops) {
+    const parsed = JSON5.parse(nextRaw);
+    for (const op of ops) {
+        const actual = valueAtPath(parsed, op.path);
+        if (op.type === 'remove' ? actual !== undefined : !isDeepStrictEqual(actual, JSON.parse(JSON.stringify(op.value)))) {
+            throw new Error(`配置里 ${op.path.join('.')} 没能${op.type === 'remove' ? '删除' : '写入'}，请在「显示 JSON 设置」里手动修改`);
+        }
+    }
+}
+
+module.exports = {
+    agentLabelOf,
+    assertOpsApplied,
+    RUN_NAME_PATTERN,
+    listModelServices,
+    suggestReuse,
+    buildNewService,
+    buildReuseService,
+    buildServiceEdit,
+    applyConfigOps,
+    assertRunName,
+    keyValueOf,
+    uniqueRunName,
+    keyTail
+};