@xcanwin/manyoyo 8.7.0 → 8.7.2

package/README.md

@@ -54,7 +54,7 @@ manyoyo init all   # 把本机已有的 Agent 配置搬进来
 manyoyo run -y c   # 在沙箱里以 YOLO 模式启动 Claude Code
 ```
 
-默认镜像 `ghcr.io/xcanwin/manyoyo` 首次使用时自动拉取；需要自定义镜像时再执行 `manyoyo build --iv 2.3.0-common`。更多命令见[命令速查](https://xcanwin.github.io/manyoyo/reference/cli-options)。
+默认镜像 `ghcr.io/xcanwin/manyoyo` 首次使用时自动拉取；需要自定义镜像时再执行 `manyoyo build --iv 2.3.1-common`。更多命令见[命令速查](https://xcanwin.github.io/manyoyo/reference/cli-options)。
 
 ## 它能做什么
 
@@ -110,7 +110,7 @@ manyoyo init all   # import the agent configs already on this machine
 manyoyo run -y c   # start Claude Code in YOLO mode inside the sandbox
 ```
 
-The default image `ghcr.io/xcanwin/manyoyo` is pulled automatically on first use; run `manyoyo build --iv 2.3.0-common` only if you need a custom image. More commands: [CLI reference](https://xcanwin.github.io/manyoyo/en/reference/cli-options).
+The default image `ghcr.io/xcanwin/manyoyo` is pulled automatically on first use; run `manyoyo build --iv 2.3.1-common` only if you need a custom image. More commands: [CLI reference](https://xcanwin.github.io/manyoyo/en/reference/cli-options).
 
 ## What it does
 

package/docker/res/claude/settings.json

@@ -14,15 +14,15 @@
                 "hooks": [
                     {
                         "type": "command",
-                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; sleep 0; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
+                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; case \"$MANYOYO_CLAUDE_BELL\" in 0) exit 0;; esac; sleep 0; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
                     },
                     {
                         "type": "command",
-                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; sleep 0.3; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
+                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; case \"$MANYOYO_CLAUDE_BELL\" in 0|1) exit 0;; esac; sleep 0.3; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
                     },
                     {
                         "type": "command",
-                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; sleep 0.6; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
+                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; case \"$MANYOYO_CLAUDE_BELL\" in 0|1) exit 0;; esac; sleep 0.6; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
                     }
                 ]
             }

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/container-init.sh

@@ -35,6 +35,51 @@ run_autostart() {
     log "自启动脚本退出，退出码 $?"
 }
 
+# trust_workdir:预先信任容器的工作目录,交互式 claude / codex 首次启动不再停在“信任此文件夹”。
+# 任何失败都静默,不影响 init。目录只经环境变量传给 node,不拼进脚本文本。
+# BEGIN trust_workdir
+trust_workdir() {
+    local dir
+    dir=$(pwd -P 2>/dev/null) || return 0
+    [ -n "$dir" ] || return 0
+    if [ -f "$HOME/.claude.json" ] && command -v node >/dev/null 2>&1; then
+        TRUST_DIR="$dir" node -e '
+const fs = require("fs");
+const file = process.env.HOME + "/.claude.json";
+const dir = process.env.TRUST_DIR;
+let data;
+try { data = JSON.parse(fs.readFileSync(file, "utf8")); } catch (e) { process.exit(0); }
+if (!data || typeof data !== "object" || Array.isArray(data)) process.exit(0);
+if (!data.projects || typeof data.projects !== "object") data.projects = {};
+const project = data.projects[dir] && typeof data.projects[dir] === "object" ? data.projects[dir] : {};
+if (project.hasTrustDialogAccepted === true) process.exit(0);
+project.hasTrustDialogAccepted = true;
+data.projects[dir] = project;
+const text = JSON.stringify(data, null, 2);
+const tmp = file + ".manyoyo-tmp";
+try {
+    fs.writeFileSync(tmp, text, { mode: fs.statSync(file).mode & 0o777 });
+    fs.renameSync(tmp, file);
+} catch (e) {
+    // 目录不可写或文件是单独挂进来的（rename 会失败）：直接原地写
+    try { fs.unlinkSync(tmp); } catch (e2) {}
+    fs.writeFileSync(file, text);
+}
+' >/dev/null 2>&1
+    fi
+    if [ -f "$HOME/.codex/config.toml" ]; then
+        case "$dir" in
+            *[\"\\]*|*[[:cntrl:]]*) return 0 ;;
+        esac
+        # 已经有这个目录的 [projects.…] 表（写法可能不同：单引号、行尾注释）就不再追加，重复的表会让 codex 解析配置失败
+        grep -F "$dir" "$HOME/.codex/config.toml" 2>/dev/null | grep -q '^[[:space:]]*\[projects\.' \
+            || printf '\n[projects."%s"]\ntrust_level = "trusted"\n' "$dir" >> "$HOME/.codex/config.toml" 2>/dev/null
+    fi
+    return 0
+}
+# END trust_workdir
+(trust_workdir) >/dev/null 2>&1 &
+
 setsid bash -c "$(declare -f log load_env run_autostart); BOX=$BOX SYS=$SYS GATE=$GATE LOG=$LOG; run_autostart" >/dev/null 2>&1 &
 
 while :; do sleep 3600 & wait $!; done

package/lib/image-pull.js

@@ -39,6 +39,26 @@ function pullImageProcess(options) {
     });
 }
 
+// 镜像拉不到时给网页弹窗用的结构化信息：判断用的是系统 docker / 系统 podman / 自带的私有 podman，
+// 给出对应的一条在线拉取命令和一条本地构建命令（命令里的镜像引用和版本都来自 imageRef，已经是校验过的名字）
+function describeImageProblem(imageRef, dockerCmd) {
+    const cmd = String(dockerCmd || '');
+    const base = cmd.split('/').pop();
+    const isPrivate = /[\\/]\.manyoyo[\\/]runtime[\\/]podman[\\/]/.test(cmd);
+    const runtime = isPrivate ? 'private-podman' : (base === 'podman' ? 'podman' : 'docker');
+    const labels = { 'private-podman': 'MANYOYO 自带的 Podman', podman: '系统的 Podman', docker: '系统的 Docker' };
+    const pullCommand = isPrivate ? `my podman pull ${imageRef}` : `${runtime} pull ${imageRef}`;
+    const tag = String(imageRef || '').split(':').pop();
+    const version = /^\d+\.\d+\.\d+-[A-Za-z0-9][A-Za-z0-9._-]*$/.test(tag) ? tag : '<x.y.z-后缀>';
+    return {
+        imageRef,
+        runtime,
+        runtimeLabel: labels[runtime],
+        pullCommand,
+        buildCommand: `my build --iv ${version}`
+    };
+}
+
 function toFriendlyPullError(error, imageRef, command) {
     const text = `${error && error.output || ''}\n${error && error.message || ''}`;
     const info = describeError(text, { imageRef, command });
@@ -46,6 +66,9 @@ function toFriendlyPullError(error, imageRef, command) {
         ? `${info.reason}\n${info.action}`
         : `拉取镜像 ${imageRef} 失败: ${String(error && error.message || error).split('\n')[0]}`);
     friendly.code = info ? info.code : 'IMAGE_PULL_FAILED';
+    if (friendly.code === 'IMAGE_NOT_FOUND' || friendly.code === 'IMAGE_PULL_FAILED') {
+        friendly.imageProblem = { code: friendly.code, ...describeImageProblem(imageRef, command) };
+    }
     friendly.cause = error;
     return friendly;
 }
@@ -70,6 +93,7 @@ async function ensureImagePresent(options) {
 }
 
 module.exports = {
+    describeImageProblem,
     pullImageProcess,
     toFriendlyPullError,
     ensureImagePresent

package/lib/init-config.js

@@ -22,10 +22,13 @@ const AGENT_ENV_SCHEMA = {
             { name: 'CLAUDE_CODE_OAUTH_TOKEN', description: 'Claude Code OAuth 令牌（订阅登录）', secret: true },
             { name: 'ANTHROPIC_BASE_URL', description: 'API 地址（使用官方服务可留空）', secret: false },
             { name: 'ANTHROPIC_MODEL', description: '默认模型', secret: false },
-            { 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: 'ANTHROPIC_DEFAULT_FABLE_MODEL', description: '顶级模型（Fable）对应的模型', secret: false },
+            { 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_AUTO_COMPACT_WINDOW', description: '上下文到多少才自动压缩', secret: false },
+            { name: 'ENABLE_TOOL_SEARCH', description: '工具搜索（部分兼容服务要设为 false，否则模型调不了工具）', secret: false }
         ]
     },
     codex: {
@@ -481,6 +484,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 };