@xcanwin/manyoyo 8.6.12 → 8.7.1

package/bin/manyoyo.js

@@ -61,18 +61,14 @@ const {
     formatServeLogValue,
     getServeProcessSnapshot
 } = require('../lib/serve-log');
+const { formatNow, resolveQuickChatPath, expandTemplate } = require('../lib/name-template');
 const { version: BIN_VERSION, imageVersion: IMAGE_VERSION_DEFAULT } = require('../package.json');
 const IMAGE_VERSION_BASE = String(IMAGE_VERSION_DEFAULT || '1.0.0').split('-')[0];
 const IMAGE_VERSION_HELP_EXAMPLE = IMAGE_VERSION_DEFAULT || `${IMAGE_VERSION_BASE}-common`;
 
-// Helper function to format date like bash $(date +%m%d-%H%M)
+// {now} 与默认容器名用的时间：年月日-时分秒（命令行与网页共用 lib/name-template.js）
 function formatDate() {
-    const now = new Date();
-    const month = String(now.getMonth() + 1).padStart(2, '0');
-    const day = String(now.getDate()).padStart(2, '0');
-    const hour = String(now.getHours()).padStart(2, '0');
-    const minute = String(now.getMinutes()).padStart(2, '0');
-    return `${month}${day}-${hour}${minute}`;
+    return formatNow();
 }
 
 function detectCommandName() {
@@ -95,6 +91,7 @@ const CONFIG = {
 // Default configuration
 let CONTAINER_NAME = `my-${formatDate()}`;
 let HOST_PATH = process.cwd();
+let HOST_PATH_TEMPLATED = false;
 let CONTAINER_PATH = HOST_PATH;
 let IMAGE_NAME = "ghcr.io/xcanwin/manyoyo";
 let IMAGE_VERSION = IMAGE_VERSION_DEFAULT || `${IMAGE_VERSION_BASE}-common`;
@@ -159,11 +156,7 @@ function normalizeCommandSuffix(suffix) {
 }
 
 function resolveContainerNameTemplate(name) {
-    if (typeof name !== 'string') {
-        return name;
-    }
-    const nowValue = formatDate();
-    return name.replace(/\{now\}|\$\{now\}/g, nowValue);
+    return expandTemplate(name, { now: formatDate() }).value;
 }
 
 function pickConfigValue(...values) {
@@ -1598,6 +1591,7 @@ https://github.com/xcanwin/manyoyo
         isServerStopMode,
         pickConfigValue,
         resolveContainerNameTemplate,
+        templateVars: { now: formatDate(), quickChatPath: resolveQuickChatPath(config) },
         normalizeCommandSuffix,
         normalizeJsonEnvMap,
         normalizeCliEnvMap,
@@ -1608,6 +1602,7 @@ https://github.com/xcanwin/manyoyo
     });
 
     HOST_PATH = resolvedRuntime.hostPath;
+    HOST_PATH_TEMPLATED = resolvedRuntime.hostPathTemplated === true;
     CONTAINER_NAME = resolvedRuntime.containerName;
     CONTAINER_PATH = resolvedRuntime.containerPath;
     IMAGE_NAME = resolvedRuntime.imageName;
@@ -1827,6 +1822,7 @@ function createRuntimeContext(modeState = {}) {
     return {
         containerName: CONTAINER_NAME,
         hostPath: HOST_PATH,
+        hostPathTemplated: HOST_PATH_TEMPLATED,
         containerPath: CONTAINER_PATH,
         imageName: IMAGE_NAME,
         imageVersion: IMAGE_VERSION,
@@ -1877,6 +1873,10 @@ function handleRemoveContainer(runtime) {
 }
 
 function validateHostPath(runtime) {
+    // 目录是按模板（{now} / {quickChatPath}）生成的：此刻才建，只在真的要用它的时候建
+    if (runtime.hostPathTemplated && !fs.existsSync(runtime.hostPath)) {
+        fs.mkdirSync(runtime.hostPath, { recursive: true });
+    }
     if (!fs.existsSync(runtime.hostPath)) {
         console.log(`${RED}⚠️  错误: 宿主机路径不存在: ${runtime.hostPath}${NC}`);
         process.exit(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/container-network.js

@@ -701,5 +701,6 @@ module.exports = {
     parseHostsAndResolv,
     parseUrlHostPort,
     isHostTarget,
+    isMissingImageError,
     createNetworkManager
 };

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 };