@xcanwin/manyoyo 8.6.10 → 8.6.12

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.2.0-common`。更多命令见[命令速查](https://xcanwin.github.io/manyoyo/reference/cli-options)。
+默认镜像 `ghcr.io/xcanwin/manyoyo` 首次使用时自动拉取；需要自定义镜像时再执行 `manyoyo build --iv 2.3.0-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.2.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.0-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/bin/manyoyo.js

@@ -9,6 +9,7 @@ const net = require('net');
 const readline = require('readline');
 const { Command, Help } = require('commander');
 const { startWebServer } = require('../lib/web/server');
+const { authSessionsFilePath } = require('../lib/web/auth-store');
 const { isSidecarName } = require('../lib/egress-sidecar');
 const { buildContainerRunArgs, buildContainerRunCommand, runWithEnvFile, hasNetworkArg } = require('../lib/container-run');
 const { getManyoyoConfigPath, readManyoyoConfig, syncGlobalImageVersion } = require('../lib/global-config');
@@ -34,7 +35,7 @@ const { launchApp, getAppStatePath, openBrowser } = require('../lib/app-launcher
 const { initAgentConfigs } = require('../lib/init-config');
 const { buildImage } = require('../lib/image-build');
 const { resolveAgentResumeArg, buildAgentResumeCommand } = require('../lib/agent-resume');
-const { resolveYoloCommand } = require('../lib/agent-adapters');
+const { resolveYoloCommand, withCodexBaseUrl } = require('../lib/agent-adapters');
 const { runDoctorChecks, applyDoctorFixes } = require('../lib/doctor');
 const { resolveContainerMode } = require('../lib/container-modes');
 const { runPlaywrightCommand, buildContainerIntegration, mergeIntegration } = require('../lib/plugin');
@@ -871,14 +872,20 @@ async function updateOfflineInstall(mode, options, globalConfig) {
             // MANYOYO_TEST_CODE_BASE 只给测试用（指向本地下载站替身）
             const outcome = await codeUpdate.installCodeUpdate({
                 appRoot, branch: options.code, installed, fetchImpl: github.fetch, targetOs: appUpdate.platformOs(),
-                downloadBase: process.env.MANYOYO_TEST_CODE_BASE || undefined, log: line => console.log(`   ${line}`)
+                downloadBase: process.env.MANYOYO_TEST_CODE_BASE || undefined, log: line => console.log(`   ${line}`),
+                // 校验通过后、下载或切换之前先说清楚装的是哪个提交
+                onInfo: info => console.log(`${CYAN}   ${options.code}@${info.commit.slice(0, 7)} ${info.subject}（构建于 ${codeUpdate.formatBuiltAt(info.builtAt)}）${NC}`)
             });
             const label = `${options.code}@${outcome.info.commit.slice(0, 7)}`;
             if (outcome.status === 'same') {
                 console.log(`${GREEN}✅ 已是 ${label}，无需更新${NC}`);
                 return;
             }
-            console.log(`${CYAN}   ${label} ${outcome.info.subject}（构建于 ${outcome.info.builtAt || '未知时间'}）${NC}`);
+            if (outcome.status === 'same-release') {
+                console.log(`${GREEN}✅ ${label} 就是当前正式版 ${installed} 的代码，无需更新${NC}`);
+                return;
+            }
+            if (outcome.status === 'reused') console.log(`${CYAN}   使用本地已有的 ${outcome.version}，无需下载${NC}`);
             result = outcome;
         } catch (error) {
             if (error instanceof appUpdate.UpdateError && error.code === 'NETWORK') {
@@ -2346,7 +2353,7 @@ async function executeInContainer(runtime, defaultCommand) {
     const exec = buildExecArgs({ homeDir: os.homedir(), dockerExecArgs }, runtime.containerName, {
         interactive: true,
         tty: true,
-        command: runtime.execCommand ? ['/bin/bash', '-c', runtime.execCommand] : ['/bin/bash']
+        command: runtime.execCommand ? ['/bin/bash', '-c', withCodexBaseUrl(runtime.execCommand)] : ['/bin/bash']
     });
     try {
         spawnSync(`${DOCKER_CMD}`, exec.args, { stdio: 'inherit', env: DOCKER_ENV });
@@ -2568,6 +2575,7 @@ async function runWebServerMode(runtime) {
         importState: () => readImportState(),
         updateInfo: () => updateChecker.getInfo(),
         loginTokenDir: getLoginTokenDir(),
+        authSessionsFile: authSessionsFilePath(os.homedir(), runtime.serverHost, runtime.serverPort),
         doctorCheck: async () => runDoctorChecks({
             selectRuntime: () => CONTAINER_RUNTIME,
             runCommand: runRuntimeCommandAsync,

package/docker/manyoyo.Dockerfile

@@ -2,7 +2,7 @@
 # Stage 1: 缓存准备阶段 - 智能检测缓存或下载
 # ==============================================================================
 # 镜像源参数化（默认使用阿里云，可按需覆盖），两个阶段共享同一默认值
-ARG APT_MIRROR=https://mirrors.aliyun.com
+ARG APT_MIRROR=https://mirrors.tencent.com
 ARG NODEJS_MIRROR=https://mirrors.tencent.com/nodejs-release/
 
 FROM ubuntu:24.04 AS cache-stage

package/docker/res/claude/settings.json

@@ -7,5 +7,25 @@
     "statusLine": {
         "type": "command",
         "command": "bash /root/.claude/statusline.sh"
+    },
+    "hooks": {
+        "Stop": [
+            {
+                "hooks": [
+                    {
+                        "type": "command",
+                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; sleep 0; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
+                    },
+                    {
+                        "type": "command",
+                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; sleep 0.3; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
+                    },
+                    {
+                        "type": "command",
+                        "command": "[ \"$CLAUDE_CODE_ENTRYPOINT\" = cli ] || exit 0; sleep 0.6; printf '%s' '{\"terminalSequence\":\"\\u0007\"}'"
+                    }
+                ]
+            }
+        ]
     }
 }

package/lib/agent-adapters/index.js

@@ -41,7 +41,24 @@ 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 就以用户的为准。
+const CODEX_BASE_URL_FLAGS = '${OPENAI_BASE_URL:+-c "openai_base_url=\\"$OPENAI_BASE_URL\\""}';
+// 有 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|$)/;
+
+function withCodexBaseUrl(command) {
+    const text = String(command || '');
+    if (!text || /openai_base_url/.test(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)}`;
+}
+
 module.exports = {
     AGENT_ADAPTERS,
-    resolveYoloCommand
+    resolveYoloCommand,
+    withCodexBaseUrl
 };

package/lib/app-update.js

@@ -206,6 +206,19 @@ function pruneApps(appRoot, keep) {
     }
 }
 
+/**
+ * 切换 current 到 app/<version>/（目录必须已就位）、写 .update.json（记下上一版本）、清理旧版本。
+ * installFromArchive 与代码版的“本地已有就直接切换”共用；manifest 原样放进返回值，供调用方做收尾。
+ */
+function switchInstalled({ appRoot, version, manifest }) {
+    const previous = currentVersion(appRoot);
+    switchCurrent(appRoot, version);
+    writeUpdateRecord(appRoot, { previous: previous && previous !== version ? previous : readUpdateRecord(appRoot).previous || '', current: version, updatedAt: new Date().toISOString() });
+    const record = readUpdateRecord(appRoot);
+    pruneApps(appRoot, [version, record.previous].filter(Boolean));
+    return { version, previous: record.previous || '', manifest };
+}
+
 /**
  * 解开已校验过的 -app.tar.gz 并切换 current（网络下载与 --file 共用）。包不完整/内容不符都在切换前中止。
  */
@@ -234,11 +247,7 @@ async function installFromArchive({ appRoot, archive, version, targetArch, targe
         const target = path.join(appRoot, version);
         if (version !== previous) fs.rmSync(target, { recursive: true, force: true });
         if (version !== previous) fs.renameSync(staging, target);
-        switchCurrent(appRoot, version);
-        writeUpdateRecord(appRoot, { previous: previous && previous !== version ? previous : readUpdateRecord(appRoot).previous || '', current: version, updatedAt: new Date().toISOString() });
-        const record = readUpdateRecord(appRoot);
-        pruneApps(appRoot, [version, record.previous].filter(Boolean));
-        return { version, previous: record.previous || '', manifest };
+        return switchInstalled({ appRoot, version, manifest });
     } finally {
         fs.rmSync(staging, { recursive: true, force: true });
     }
@@ -397,6 +406,7 @@ module.exports = {
     compareVersions,
     isAppVersion,
     installFromArchive,
+    switchInstalled,
     detectInstallMode,
     fetchLatestRelease,
     parseSha256Sums,

package/lib/code-update.js

@@ -9,9 +9,9 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const appUpdate = require('./app-update');
-const { downloadVerified } = require('./download-verified');
+const { downloadVerified, sha256File } = require('./download-verified');
 
-const { UpdateError, compareVersions, networkError, request, installFromArchive } = appUpdate;
+const { UpdateError, compareVersions, networkError, request, installFromArchive, switchInstalled } = appUpdate;
 
 const DOWNLOAD_BASE = 'https://github.com/xcanwin/manyoyo/releases/download/';
 const BRANCH_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,100}$/;
@@ -102,23 +102,70 @@ async function fetchCodeInfo({ branch, fetchImpl = fetch, downloadBase = DOWNLOA
     return validateCodeInfo(parsed, { branch });
 }
 
+// 当前版本的 manyoyo/package.json 里的 gitHead（正式包与代码版包构建时写入）；读不到或格式不对当作没有
+function readCurrentGitHead(appRoot) {
+    try {
+        const head = JSON.parse(fs.readFileSync(path.join(appRoot, 'current', 'manyoyo', 'package.json'), 'utf-8')).gitHead;
+        return typeof head === 'string' && /^[0-9a-f]{40}$/.test(head) ? head : '';
+    } catch (error) {
+        return '';
+    }
+}
+
+/**
+ * 本地 app/<版本>/ 已经是这个代码版时返回它的 manifest，否则 null（调用方照常下载，不报错）。
+ * --rollback 直接切到本地目录，所以这里的检查不能比它宽松：目录结构完整，并额外核对 manifest 与 .installed、提交号。
+ */
+async function findLocalCopy({ appRoot, info, targetArch, targetOs }) {
+    const dir = path.join(appRoot, info.version);
+    try {
+        for (const required of ['node/bin/node', 'manyoyo/bin/manyoyo.js', 'manifest.json', '.installed']) {
+            if (!fs.existsSync(path.join(dir, required))) return null;
+        }
+        const manifest = JSON.parse(fs.readFileSync(path.join(dir, 'manifest.json'), 'utf-8'));
+        if (!manifest || manifest.version !== info.version || manifest.kind !== 'app' || manifest.arch !== targetArch || manifest.os !== targetOs) return null;
+        if (!manifest.source || manifest.source.commit !== info.commit) return null;
+        // installFromArchive 安装时把 manifest.json 的哈希写进 .installed：对得上才说明目录没被动过
+        if (fs.readFileSync(path.join(dir, '.installed'), 'utf-8').trim() !== await sha256File(path.join(dir, 'manifest.json'))) return null;
+        return manifest;
+    } catch (error) {
+        return null;
+    }
+}
+
+// 构建时间按本机时区显示成 YYYY-MM-DD HH:mm；timeZone 可注入（测试不依赖运行机器的时区）
+function formatBuiltAt(builtAt, timeZone) {
+    const date = new Date(builtAt);
+    if (typeof builtAt !== 'string' || !builtAt || Number.isNaN(date.getTime())) return '未知时间';
+    const parts = Object.fromEntries(new Intl.DateTimeFormat('en-CA', { timeZone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' })
+        .formatToParts(date).map(part => [part.type, part.value]));
+    return `${parts.year}-${parts.month}-${parts.day} ${parts.hour}:${parts.minute}`;
+}
+
 /**
  * 安装某个分支的代码版。installed 是当前版本号。
- * 返回 { status: 'same', info } 或 { status: 'installed', info, version, previous, manifest }。
+ * 返回：{ status: 'same', info }（已是这个版本）、{ status: 'same-release', info }（与当前正式版同一个提交）、
+ * { status: 'reused' | 'installed', info, version, previous, manifest }（本地已有就直接切换 / 下载安装）。
  * 校验失败 / 镜像未发布 / 版本更旧都在下载与切换之前中止，current 不变。
+ * onInfo(info)：全部校验通过后、下载或切换之前调用，让调用方先告诉用户装的是哪个提交。
  */
-async function installCodeUpdate({ appRoot, branch, installed, fetchImpl = fetch, downloadBase = DOWNLOAD_BASE, notFoundRetryMs, targetArch = appUpdate.arch(), targetOs = appUpdate.platformOs(), run, log = () => {}, tmpRoot = os.tmpdir() }) {
+async function installCodeUpdate({ appRoot, branch, installed, fetchImpl = fetch, downloadBase = DOWNLOAD_BASE, notFoundRetryMs, onInfo, targetArch = appUpdate.arch(), targetOs = appUpdate.platformOs(), run, log = () => {}, tmpRoot = os.tmpdir() }) {
     const info = await fetchCodeInfo({ branch, fetchImpl, downloadBase, notFoundRetryMs });
     if (info.version === installed) return { status: 'same', info };
+    if (readCurrentGitHead(appRoot) === info.commit) return { status: 'same-release', info };
     if (compareVersions(info.version, installed) < 0) {
         throw new UpdateError('OLDER', `分支 ${branch} 的代码版是 ${info.version}，比当前的 ${installed} 旧。${branch} 的最新提交可能还在构建，稍后再试；要换回正式版请用 manyoyo update --rollback 或重新运行安装命令。`);
     }
     if (!info.imageReady) {
         throw new UpdateError('IMAGE_NOT_READY', `这个代码版需要镜像 ${info.imageVersion}，但它还没有发布，现在升级会让容器拉不到镜像。请等镜像发布后再试，或换一个分支。`);
     }
+    // 降级与镜像检查都排在本地复用之前，否则本地留着旧目录时会绕过它们
+    const local = await findLocalCopy({ appRoot, info, targetArch, targetOs });
     const asset = info.assets[`${targetOs}-${targetArch}`];
-    const url = asset ? `${tagBase(downloadBase, branch)}${asset.name}` : '';
-    if (!asset) throw new UpdateError('NO_ASSET', `代码版 ${info.version} 里没有适合这台机器（${targetOs}-${targetArch}）的升级包。`);
+    if (!local && !asset) throw new UpdateError('NO_ASSET', `代码版 ${info.version} 里没有适合这台机器（${targetOs}-${targetArch}）的升级包。`);
+    if (typeof onInfo === 'function') onInfo(info);
+    if (local) return { status: 'reused', info, ...switchInstalled({ appRoot, version: info.version, manifest: local }) };
+    const url = `${tagBase(downloadBase, branch)}${asset.name}`;
     // 包是按 CODE.json 里的固定命名拼出来的：先确认确实存在（404 就是没有）
     const probe = await request(fetchImpl, url, { method: 'HEAD' });
     if (probe.status === 404) throw new UpdateError('NO_ASSET', `代码版 ${info.version} 的升级包 ${asset.name} 还没有上传完整，请稍后再试。`);
@@ -162,4 +209,4 @@ function latestReleaseNotice(installed, latest) {
     return `已是最新版本 ${installed}`;
 }
 
-module.exports = { isCodeVersion, latestReleaseNotice, DOWNLOAD_BASE, isValidBranch, codeTagForBranch, codeAssetName, validateCodeInfo, fetchCodeInfo, installCodeUpdate };
+module.exports = { formatBuiltAt, isCodeVersion, latestReleaseNotice, DOWNLOAD_BASE, isValidBranch, codeTagForBranch, codeAssetName, validateCodeInfo, fetchCodeInfo, installCodeUpdate };

package/lib/container-network.js

@@ -113,6 +113,11 @@ function uniqueBy(items, keyFn) {
     });
 }
 
+// 默认镜像本地没有时各运行时的报错（--pull=never）：podman `image not known`，docker `Unable to find image … locally` / `No such image`
+function isMissingImageError(error) {
+    return /image not known|no such image|unable to find image|image .* not found locally/i.test(String(error && error.message || error));
+}
+
 function createNetworkManager(options) {
     const homeDir = options.homeDir || os.homedir();
     const command = options.command;
@@ -153,8 +158,33 @@ function createNetworkManager(options) {
         });
     }
 
+    // 一次性 helper（改规则的 nft、读 /etc/hosts）和 sidecar 用哪个镜像：
+    // 优先用 serve 的默认镜像——它一定有 nft、node 和 sidecar 要的文件（2.1.x 及更早的镜像里没有 nft，
+    // 用户可能拿旧镜像建过容器，不能默认用容器自己的镜像）。只有默认镜像本地没有（--pull=never 下报“镜像不存在”）时，
+    // 才退回目标容器自己的镜像。判断靠运行失败的输出，不额外起进程：
+    // podman 报 `<镜像>: image not known`；docker 报 `Unable to find image '<镜像>' locally` 或 `No such image: <镜像>`
+    function ownImageOf(info) {
+        return info && info.Config && typeof info.Config.Image === 'string' ? info.Config.Image : '';
+    }
+
+    async function runWithFallbackImage(info, makeArgs, runOptions) {
+        const primary = getImageRef();
+        const own = ownImageOf(info);
+        try {
+            return await run(makeArgs(primary), runOptions);
+        } catch (e) {
+            if (!isMissingImageError(e) || !own || own === primary) throw e;
+            try {
+                return await run(makeArgs(own), runOptions);
+            } catch (e2) {
+                if (isMissingImageError(e2)) throw new Error(`默认镜像 ${primary} 和容器自己的镜像 ${own} 本地都没有: ${e2.message}`);
+                throw e2;
+            }
+        }
+    }
+
     // 域名规则的过滤代理：manyoyo 网络里的 sidecar 容器，按来源 IP 认容器（见 egress-sidecar.js）
-    const sidecar = createSidecarManager({ run, command, homeDir, imageRef: getImageRef, networkName: NETWORK_NAME, ensureNetwork: ensureBridgeNetwork, getUpstream });
+    const sidecar = createSidecarManager({ run, command, homeDir, imageRef: getImageRef, isMissingImageError, networkName: NETWORK_NAME, ensureNetwork: ensureBridgeNetwork, getUpstream });
 
     // buildExecArgs 只需要同步 inspect 取 id；这里 withEnv:false 不会用到
     const execCtx = { homeDir, dockerExecArgs: () => '' };
@@ -236,8 +266,7 @@ function createNetworkManager(options) {
         const hostConfig = info.HostConfig || {};
         (hostConfig.Dns || []).filter(ip => net.isIP(ip)).forEach(ip => args.push('--dns', ip));
         (hostConfig.ExtraHosts || []).filter(entry => /^[A-Za-z0-9._-]+:(?:host-gateway|[0-9a-fA-F:.]+)$/.test(entry)).forEach(entry => args.push('--add-host', entry));
-        args.push('--entrypoint', 'cat', getImageRef(), '/etc/hosts', '/etc/resolv.conf');
-        return await run(args, { timeout: 30000 });
+        return await runWithFallbackImage(info, image => [...args, '--entrypoint', 'cat', image, '/etc/hosts', '/etc/resolv.conf'], { timeout: 30000 });
     }
 
     // 容器间：别的容器入站规则里允许了本容器（来源写 @containers 或 @container:<本容器>），本容器才能出去到它（派生行）。
@@ -303,7 +332,7 @@ function createNetworkManager(options) {
         if (proxied) {
             const selfBridge = safeBridge(self.info);
             if (!selfBridge) throw new Error('域名规则需要容器在 manyoyo 网络里，这个容器的网络不支持');
-            const proxy = await sidecar.ensure();
+            const proxy = await sidecar.ensure({ fallbackImage: ownImageOf(self.info) });
             allow.push({ ip: proxy.ip, ports: String(proxy.port), proto: 'tcp' });
             antiSpoof.push({ daddr: proxy.ip, saddr: selfBridge.ip });
             const url = `http://${proxy.ip}:${proxy.port}`;
@@ -363,8 +392,8 @@ function createNetworkManager(options) {
         sidecar.writeClients(clients);
     }
 
-    async function sendRuleset(name, text) {
-        await run([
+    async function sendRuleset(name, text, info) {
+        await runWithFallbackImage(info, image => [
             'run', '--rm', '-i',
             '--network', `container:${name}`,
             '--user', 'root',
@@ -372,7 +401,7 @@ function createNetworkManager(options) {
             '--security-opt', 'no-new-privileges',
             '--entrypoint', 'nft',
             '--pull=never',
-            getImageRef(),
+            image,
             '-f', '-'
         ], { input: text, timeout: 30000 });
     }
@@ -419,7 +448,7 @@ function createNetworkManager(options) {
             if (endpoints.proxyPolicy && selfBridge) clientCache.set(self.id, { ip: selfBridge.ip, entry: { id: self.id, ...endpoints.proxyPolicy } });
             else clientCache.delete(self.id);
             syncEgressClients(all); // 先让代理认得这个容器，再放行门闩
-            await sendRuleset(name, policyLib.buildNftRuleset(policy, endpoints));
+            await sendRuleset(name, policyLib.buildNftRuleset(policy, endpoints), self.info);
             await execInContainer(name, ['/bin/sh', '-c', `mkdir -p ${path.posix.dirname(GATE_READY)} && : > ${GATE_READY}`]);
             const privileged = Boolean(self.info.HostConfig && self.info.HostConfig.Privileged);
             const status = {
@@ -479,7 +508,7 @@ function createNetworkManager(options) {
             if (policyLib.usesProxy(policy)) {
                 try {
                     if (!await sidecar.isHealthy()) {
-                        await sidecar.ensure();
+                        await sidecar.ensure({ fallbackImage: ownImageOf(info) });
                         syncEgressClients(await listManaged());
                     }
                 } catch (e) { warn(`域名规则代理恢复失败: ${e.message}`); }
@@ -534,6 +563,15 @@ function createNetworkManager(options) {
         });
     }
 
+    // 没有“触发它的那个容器”时（定时自愈），用第一个要用代理的容器的镜像当退路
+    function fallbackImageOfProxied(all) {
+        const item = all.find(entry => {
+            if (!state.stateExists(homeDir, entry.id)) return false;
+            try { return policyLib.usesProxy(loadPolicy(entry.id)); } catch (e) { return false; }
+        });
+        return item ? ownImageOf(item.info) : '';
+    }
+
     // 过滤代理容器自己退出 / 被删：有用到它的容器就拉起来，并重写映射
     let lastHealAt = 0;
     let healTimer = null;
@@ -554,7 +592,7 @@ function createNetworkManager(options) {
         lastHealAt = Date.now();
         const all = await listManaged();
         if (!await needsSidecar(all)) return;
-        await sidecar.ensure();
+        await sidecar.ensure({ fallbackImage: fallbackImageOfProxied(all) });
         syncEgressClients(all);
     }
 

package/lib/egress-sidecar.js

@@ -111,6 +111,7 @@ function appFileContents() {
  * @param {string} options.command 运行时命令名（docker / podman，用来判断宿主机别名）
  * @param {string} options.homeDir
  * @param {() => string} options.imageRef 当前镜像
+ * @param {(error: Error) => boolean} [options.isMissingImageError] 运行失败是不是“镜像本地不存在”（决定要不要换备用镜像重试）
  * @param {string} options.networkName manyoyo 网络名
  * @param {() => Promise<void>} options.ensureNetwork
  * @param {() => string} [options.getUpstream] 上游代理（宿主机视角）
@@ -180,7 +181,7 @@ function createSidecarManager(options) {
         throw new Error(`域名规则代理没有起来${tail ? `: ${String(tail).trim().split('\n').slice(-2).join(' ')}` : ''}`);
     }
 
-    async function doEnsure() {
+    async function doEnsure(fallbackImage = '') {
         await options.ensureNetwork();
         const subnet = subnetOfNetwork(JSON.parse((await run(['network', 'inspect', networkName, '--format', '{{json .}}'])).trim().split('\n')[0] || 'null'));
         const ip = chooseSidecarIp(subnet, homeDir);
@@ -213,9 +214,22 @@ function createSidecarManager(options) {
             '--env', `EGRESS_PORT=${SIDECAR_PORT}`, '--env', `EGRESS_HOST_ALIAS=${hostAlias}`
         ];
         if (isDocker) args.push('--add-host', 'host.docker.internal:host-gateway');
-        args.push('--entrypoint', 'node', options.imageRef(), '/app/egress-sidecar-main.js');
+        const tail = ['/app/egress-sidecar-main.js'];
+        const runWith = image => run([...args, '--entrypoint', 'node', image, ...tail], { timeout: 60000 });
         try {
-            await run(args, { timeout: 60000 });
+            try {
+                await runWith(options.imageRef());
+            } catch (first) {
+                // 默认镜像本地没有（--pull=never）：用触发它的那个容器的镜像（只要里面有 node 就行，程序文件是从宿主机只读挂进去的）
+                const isMissing = options.isMissingImageError || (() => false);
+                if (!fallbackImage || fallbackImage === options.imageRef() || !isMissing(first)) throw first;
+                try {
+                    await runWith(fallbackImage);
+                } catch (second) {
+                    if (isMissing(second)) throw new Error(`默认镜像 ${options.imageRef()} 和容器自己的镜像 ${fallbackImage} 本地都没有: ${second.message}`);
+                    throw second;
+                }
+            }
         } catch (e) {
             const message = String(e.message);
             // 另一个进程（CLI / serve）刚好同时建好了它：直接用现成的
@@ -235,8 +249,8 @@ function createSidecarManager(options) {
     }
 
     /** 保证 sidecar 在运行，返回 {name, ip, port}；多处同时调用合并成一次。 */
-    function ensure() {
-        if (!inflight) inflight = doEnsure().finally(() => { inflight = null; });
+    function ensure({ fallbackImage = '' } = {}) {
+        if (!inflight) inflight = doEnsure(fallbackImage).finally(() => { inflight = null; });
         return inflight;
     }
 

package/lib/image-agents.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const PROBE_AGENTS = ['claude', 'codex', 'gemini', 'opencode'];
+const PROBE_SCRIPT = `for c in ${PROBE_AGENTS.join(' ')}; do command -v "$c" >/dev/null 2>&1 && echo "$c"; done`;
+const PROBE_TIMEOUT_MS = 30000;
+
+/**
+ * 探测镜像里装了哪些 Agent CLI。结果按镜像 ID 缓存，同一镜像只探测一次；
+ * 同时到来的请求共用一次探测。拿不到结果时返回 null（未知，不缓存）。
+ * exec(args, { timeout }) → Promise<stdout>，抛错表示失败。
+ */
+function createImageAgentProbe(exec) {
+    const cache = new Map();
+    const inflight = new Map();
+
+    async function run(imageRef) {
+        let imageId = '';
+        try {
+            imageId = String(await exec(['image', 'inspect', '--format', '{{.Id}}', imageRef], { timeout: 10000 })).trim();
+        } catch (e) {
+            return null;
+        }
+        if (!imageId) return null;
+        if (cache.has(imageId)) return cache.get(imageId);
+        try {
+            const out = await exec([
+                'run', '--rm', '--network', 'none', '--entrypoint', '/bin/sh', imageRef, '-c', PROBE_SCRIPT
+            ], { timeout: PROBE_TIMEOUT_MS });
+            const found = String(out).split('\n').map(line => line.trim()).filter(line => PROBE_AGENTS.includes(line));
+            cache.set(imageId, found);
+            return found;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    return function probeImageAgents(imageRef) {
+        if (inflight.has(imageRef)) return inflight.get(imageRef);
+        const promise = run(imageRef).finally(() => inflight.delete(imageRef));
+        inflight.set(imageRef, promise);
+        return promise;
+    };
+}
+
+module.exports = { createImageAgentProbe, PROBE_AGENTS };

package/lib/init-config.js

@@ -13,11 +13,12 @@ const AGENT_ENV_SCHEMA = {
         label: 'Claude Code',
         yolo: 'c',
         modelKey: 'ANTHROPIC_MODEL',
-        requiredAnyOf: ['ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN'],
+        requiredAnyOf: ['ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_API_KEY', 'CLAUDE_CODE_OAUTH_TOKEN'],
         baseUrlKey: 'ANTHROPIC_BASE_URL',
         baseUrlPresets: [{ label: 'Anthropic 官方', value: 'https://api.anthropic.com' }],
         env: [
             { name: 'ANTHROPIC_AUTH_TOKEN', description: 'Anthropic API Key 或兼容服务的令牌', secret: true },
+            { name: 'ANTHROPIC_API_KEY', description: '部分服务商（如 Kimi Code）要求用 API Key 方式', secret: true },
             { 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 },

package/lib/network-endpoints.js

@@ -4,6 +4,7 @@ const dns = require('dns').promises;
 const net = require('net');
 const { normalizePolicy, normalizeDomain, isUnrestricted } = require('./network-policy');
 const { isRestrictedAddress } = require('./egress-proxy');
+const { AGENT_ENV_SCHEMA } = require('./init-config');
 
 // 新建容器时从用户在创建时填写的 env 里推断“Agent 要访问的端点”（如 ANTHROPIC_BASE_URL、OPENAI_BASE_URL 指向宿主机上的
 // Ollama 或局域网网关），把落在私有网段的写进网络策略，否则默认收紧会让 Agent 一上来就连不上自己配置的模型服务。
@@ -43,6 +44,60 @@ function envUrlDomains(envLines) {
     return out;
 }
 
+/**
+ * Agent 的模型域名：env 里的 URL 域名，再加官方默认域名（取自 AGENT_ENV_SCHEMA 的 baseUrlPresets）。
+ * 官方域名只在该 Agent 没配 BASE_URL 时才算；给了 agentId 就只看这个 Agent，没给则只看配了 Key 的 Agent。
+ */
+function modelDomains(envLines, agentId) {
+    const out = envUrlDomains(envLines);
+    const env = {};
+    for (const line of envLines || []) {
+        const text = String(line);
+        const i = text.indexOf('=');
+        if (i > 0) env[text.slice(0, i)] = text.slice(i + 1);
+    }
+    const agents = agentId ? [agentId] : Object.keys(AGENT_ENV_SCHEMA);
+    for (const id of agents) {
+        const spec = AGENT_ENV_SCHEMA[id];
+        if (!spec || env[spec.baseUrlKey]) continue;
+        if (!agentId && !spec.requiredAnyOf.some(key => env[key])) continue;
+        for (const preset of spec.baseUrlPresets) {
+            const target = urlOf(preset.value);
+            if (!target) continue;
+            let domain;
+            try { domain = normalizeDomain(target.host); } catch (e) { continue; }
+            if (!out.includes(domain)) out.push(domain);
+        }
+    }
+    return out;
+}
+
+/**
+ * 判断“被拦的是不是这个 Agent 自己的模型地址”用的：只认该 Agent 的 BASE_URL 变量（配了）或官方默认域名（没配）。
+ * 比 modelDomains 窄：env 里别的 URL（npm 源、pip 源……）被拦不能当成模型地址去中止一轮。
+ */
+function agentModelDomains(envLines, agentId) {
+    const spec = AGENT_ENV_SCHEMA[agentId];
+    if (!spec) return [];
+    const out = [];
+    let configured = '';
+    for (const line of envLines || []) {
+        const text = String(line);
+        const i = text.indexOf('=');
+        if (i > 0 && text.slice(0, i) === spec.baseUrlKey) configured = text.slice(i + 1);
+    }
+    const urls = configured ? [configured] : spec.baseUrlPresets.map(item => item.value);
+    for (const value of urls) {
+        const target = urlOf(value);
+        if (!target || net.isIP(target.host) || HOST_ALIASES.has(target.host)) continue;
+        try {
+            const domain = normalizeDomain(target.host);
+            if (!out.includes(domain)) out.push(domain);
+        } catch (e) { /* 非法域名忽略 */ }
+    }
+    return out;
+}
+
 /**
  * @param {string[]} envLines KEY=VALUE（创建时的用户 env）
  * @param {(host: string) => Promise<string[]>} [lookup]
@@ -95,4 +150,4 @@ async function withEnvEndpoints(policy, envLines, lookup) {
     return normalizePolicy({ ...policy, outbound: [...policy.outbound, ...added] });
 }
 
-module.exports = { inferEnvEndpoints, withEnvEndpoints, envUrlDomains };
+module.exports = { inferEnvEndpoints, withEnvEndpoints, envUrlDomains, modelDomains, agentModelDomains };

package/lib/plugin/playwright.js

@@ -935,12 +935,19 @@ class PlaywrightPlugin {
         const runtimeCommand = this.runtimeCommand();
         const integration = await this.buildContainerIntegration({ runtimeCommand });
         const name = `manyoyo-probe-${process.pid}`;
-        const args = ['run', '--rm', '--init', '--name', name, '--shm-size=1g', ...integration.extraArgs];
-        for (const volume of integration.volumes) args.push('--volume', volume);
-        for (const entry of integration.env) args.push('--env', entry);
-        args.push(image, 'sh', '-c', CONTAINER_PROBE_SCRIPT);
+        const buildArgs = withInit => {
+            const args = ['run', '--rm', ...(withInit ? ['--init'] : []), '--name', name, '--shm-size=1g', ...integration.extraArgs];
+            for (const volume of integration.volumes) args.push('--volume', volume);
+            for (const entry of integration.env) args.push('--env', entry);
+            args.push(image, 'sh', '-c', CONTAINER_PROBE_SCRIPT);
+            return args;
+        };
         const started = Date.now();
-        const result = this.runtimeCall(args, { timeout: CONTAINER_PROBE_TIMEOUT_MS });
+        let result = this.runtimeCall(buildArgs(true), { timeout: CONTAINER_PROBE_TIMEOUT_MS });
+        // podman 的 --init 要宿主机装了 catatonit（没装报 `lookup init binary`），不是浏览器的问题：不带 --init 再来一次
+        if (result.status !== 0 && /catatonit|init binary/i.test(`${result.stdout}${result.stderr}`)) {
+            result = this.runtimeCall(buildArgs(false), { timeout: CONTAINER_PROBE_TIMEOUT_MS });
+        }
         if (result.status !== 0) this.runtimeCall(['rm', '-f', name]); // 超时时容器客户端被杀，容器本身可能还在
         if (result.status === 0 && /manyoyo-ok/.test(result.stdout)) {
             this.out(`真实探测: 通过（default，${Date.now() - started}ms）`);