@xcanwin/manyoyo 8.6.10 → 8.6.12

package/lib/provider-presets.js

@@ -0,0 +1,86 @@
+'use strict';
+
+// 模型服务商预设：网页向导与命令行向导共用的唯一数据源。
+// 只收录实测可用（Base URL 不带 Key 请求得到 401）且官方文档给了接入方式的服务商。
+// claude：Anthropic 兼容接口；codex：Responses 接口（只收官方文档确认支持 Responses 的）。
+// models 只作“模型”输入框的占位提示，不会自动写入配置；defaultModel 是官方文档要求必须填的，用户可改。
+// Codex 不认环境变量 OPENAI_BASE_URL（0.160 / 0.164 实测），向导写的仍是环境变量，
+// 由 lib/agent-adapters 的 withCodexBaseUrl 在容器里展开成 `-c openai_base_url=…` 才生效。
+// 智谱的接口把鉴权失败写在 200 响应体里（`{"code":401,...}`），其余三家直接返回 HTTP 401。
+const PROVIDER_PRESETS = [
+    {
+        id: 'deepseek',
+        label: 'DeepSeek',
+        docUrl: 'https://api-docs.deepseek.com/guides/coding_agents',
+        claude: { baseUrl: 'https://api.deepseek.com/anthropic', keyEnv: 'ANTHROPIC_AUTH_TOKEN', models: ['deepseek-flash[1m]'], defaultModel: 'deepseek-flash[1m]' }
+    },
+    {
+        id: 'zhipu',
+        label: '智谱 GLM',
+        docUrl: 'https://docs.bigmodel.cn/cn/coding-plan/tool/claude',
+        claude: { baseUrl: 'https://open.bigmodel.cn/api/anthropic', keyEnv: 'ANTHROPIC_AUTH_TOKEN' },
+        codex: { baseUrl: 'https://open.bigmodel.cn/api/v1', keyEnv: 'OPENAI_API_KEY', docUrl: 'https://docs.bigmodel.cn/cn/coding-plan/tool/codex' }
+    },
+    {
+        id: 'zai',
+        label: 'Z.ai（智谱国际）',
+        docUrl: 'https://docs.z.ai/devpack/tool/claude',
+        claude: { baseUrl: 'https://api.z.ai/api/anthropic', keyEnv: 'ANTHROPIC_AUTH_TOKEN' }
+    },
+    {
+        id: 'kimi',
+        label: 'Kimi',
+        docUrl: 'https://platform.kimi.com/docs/guide/claude-code-kimi.md',
+        claude: { baseUrl: 'https://api.moonshot.cn/anthropic', keyEnv: 'ANTHROPIC_AUTH_TOKEN' },
+        codex: { baseUrl: 'https://api.moonshot.cn/v1', keyEnv: 'OPENAI_API_KEY', docUrl: 'https://platform.kimi.com/docs/guide/codex-kimi.md' }
+    },
+    {
+        id: 'kimi-code',
+        label: 'Kimi Code（订阅，海外）',
+        docUrl: 'https://www.kimi.com/code/docs/en/third-party-tools/claude-code.html',
+        claude: { baseUrl: 'https://api.kimi.ai/coding/', keyEnv: 'ANTHROPIC_API_KEY' }
+    },
+    {
+        id: 'aliyun',
+        label: '阿里云百炼',
+        docUrl: 'https://help.aliyun.com/zh/model-studio/claude-code',
+        claude: { baseUrl: 'https://coding.dashscope.aliyuncs.com/apps/anthropic', keyEnv: 'ANTHROPIC_AUTH_TOKEN' }
+    },
+    {
+        id: 'tencent',
+        label: '腾讯云',
+        docUrl: 'https://cloud.tencent.com/document/product/1823/130097',
+        claude: { baseUrl: 'https://api.lkeap.cloud.tencent.com/coding/anthropic', keyEnv: 'ANTHROPIC_AUTH_TOKEN', models: ['glm-5'] }
+    },
+    {
+        id: 'volcengine',
+        label: '火山方舟',
+        docUrl: 'https://www.volcengine.com/docs/82379/1928262',
+        claude: { baseUrl: 'https://ark.cn-beijing.volces.com/api/coding', keyEnv: 'ANTHROPIC_AUTH_TOKEN' },
+        codex: { baseUrl: 'https://ark.cn-beijing.volces.com/api/coding/v3', keyEnv: 'OPENAI_API_KEY' }
+    },
+    {
+        id: 'minimax',
+        label: 'MiniMax',
+        docUrl: 'https://platform.minimax.cn/docs/token-plan/claude-code',
+        claude: { baseUrl: 'https://api.minimax.cn/anthropic', keyEnv: 'ANTHROPIC_AUTH_TOKEN' },
+        codex: { baseUrl: 'https://api.minimax.cn/v1', keyEnv: 'OPENAI_API_KEY', docUrl: 'https://platform.minimax.cn/docs/token-plan/codex' }
+    }
+];
+
+/** 某个 Agent 可用的预设（扁平：{id, label, docUrl, baseUrl, keyEnv, models, defaultModel}） */
+function providersForAgent(agentId) {
+    return PROVIDER_PRESETS
+        .filter(item => item[agentId])
+        .map(item => ({
+            id: item.id,
+            label: item.label,
+            docUrl: item[agentId].docUrl || item.docUrl,
+            baseUrl: item[agentId].baseUrl,
+            keyEnv: item[agentId].keyEnv,
+            models: [...(item[agentId].models || [])],
+            defaultModel: item[agentId].defaultModel || ''
+        }));
+}
+
+module.exports = { PROVIDER_PRESETS, providersForAgent };

package/lib/setup-cli.js

@@ -154,11 +154,23 @@ async function runSetupCli(deps) {
             }));
             keyName = agent.requiredAnyOf[keyIndex];
         }
+        let defaultModel = '';
         if (modeIndex === 1) {
-            const baseUrlItems = [...agent.baseUrlPresets.map(item => `${item.label}  ${item.value}`), '自定义地址'];
+            const providers = agent.providers || [];
+            const baseUrlItems = [
+                ...providers.map(item => `${item.label}  ${item.baseUrl}`),
+                ...agent.baseUrlPresets.map(item => `${item.label}  ${item.value}`),
+                '自定义地址'
+            ];
             const baseIndex = await chooseNumber(prompter, log, 'Base URL：', baseUrlItems);
-            if (baseIndex < agent.baseUrlPresets.length) {
-                env[agent.baseUrlKey] = agent.baseUrlPresets[baseIndex].value;
+            if (baseIndex < providers.length) {
+                const provider = providers[baseIndex];
+                env[agent.baseUrlKey] = provider.baseUrl;
+                keyName = provider.keyEnv;
+                defaultModel = provider.defaultModel;
+                log(`官方说明：${provider.docUrl}`);
+            } else if (baseIndex < providers.length + agent.baseUrlPresets.length) {
+                env[agent.baseUrlKey] = agent.baseUrlPresets[baseIndex - providers.length].value;
             } else {
                 const custom = String(await prompter.ask('请输入 Base URL: ')).trim();
                 if (!custom) {
@@ -174,7 +186,9 @@ async function runSetupCli(deps) {
             return 1;
         }
         env[keyName] = key;
-        const model = String(await prompter.ask(`模型（${agent.modelKey}，可选，回车跳过）: `)).trim();
+        const model = String(await prompter.ask(defaultModel
+            ? `模型（${agent.modelKey}，回车使用 ${defaultModel}）: `
+            : `模型（${agent.modelKey}，可选，回车跳过）: `)).trim() || defaultModel;
         if (model) env[agent.modelKey] = model;
 
         log('\n第 3 / 4 步 · 工作目录');

package/lib/setup.js

@@ -2,6 +2,7 @@
 
 const { AGENT_ENV_SCHEMA } = require('./init-config');
 const { parseEnvEntry } = require('./runtime-normalizers');
+const { providersForAgent } = require('./provider-presets');
 
 const SETUP_AGENTS = Object.keys(AGENT_ENV_SCHEMA);
 
@@ -20,6 +21,7 @@ function listSetupAgents() {
             requiredAnyOf: [...spec.requiredAnyOf],
             baseUrlKey: spec.baseUrlKey,
             baseUrlPresets: spec.baseUrlPresets.map(item => ({ ...item })),
+            providers: providersForAgent(id),
             env: spec.env.map(item => ({ ...item }))
         };
     });
@@ -92,7 +94,7 @@ const CONNECTION_RULES = [
 ];
 
 /**
- * 把容器内最小请求的结果归类为 success / network / auth / other。
+ * 把容器内最小请求的结果归类为 success / network / auth / missing_cli / other。
  * 返回值只含固定文案和经过脱敏的尾部片段，不回传完整输出。
  */
 function classifyConnectionResult(result, secrets = []) {
@@ -105,6 +107,10 @@ function classifyConnectionResult(result, secrets = []) {
     if (exitCode === 124) {
         return { category: 'network', message: '请求超时：60 秒内没有得到响应，请检查网络、代理或 Base URL', detail };
     }
+    const missing = output.match(/([A-Za-z0-9_.-]+): (?:command )?not found/i);
+    if (missing) {
+        return { category: 'missing_cli', message: `镜像里没有 ${missing[1]}`, detail };
+    }
     for (const rule of CONNECTION_RULES) {
         if (rule.pattern.test(output)) {
             return { category: rule.category, message: rule.message, detail };

package/lib/web/AGENTS.md

@@ -14,10 +14,13 @@
   - `content_delta`：每条 assistant 消息落地时下发一次的权威全文，前端**整体覆盖**。
   - `queue_next`（新增）：这一轮结束后服务端接着发排队的下一条，前端收到后结束这条流、改走恢复轮询（见下面“追加提示词”）。
   - `trace`：**不保证带结构化 `traceEvent`**。stderr 行（`emitStderrTraceLine`）和解析不出 JSON 的 stdout 行只有 `text` + `stream`，前端靠 `toTraceEvent()` 兜底成 `kind="output"` 的事件展示。新增只认 `traceEvent` 的分支等于把自定义 CLI、CLI 报错的输出全吞掉。
+  - `network_denied`：`{host, model}`，过滤代理拦下了一个域名。`model:true` 表示是本轮 Agent 自己的模型地址（`modelDomains`：env 里的 URL 域名 + 没配 BASE_URL 时 `AGENT_ENV_SCHEMA` 的官方域名），服务端随后用 `terminateWebAgentRun` 中止本轮（**不能走 `stopWebAgentRun`**：它会把排队暂停落盘；本轮结束后也不自动发队列），最终回复带 `networkDenied:{host,model}` 并落盘，`result` 事件同带该字段；前端据历史里最后一条回复推出“允许并重试”提示条，所以刷新页面也在。非模型域名的拦截仍只是一条 `trace`。
   - `ping`：保活心跳，前端忽略。`DEFAULT_AGENT_STREAM_HEARTBEAT_MS` 必须明显小于反向代理的空闲读超时（nginx `proxy_read_timeout` 默认 60s），否则 agent 静默期间流会被 RST，浏览器侧表现为输入框上方冒出 `network error`。
   - token 级增量**不写**事件日志、历史落盘按 `AGENT_STREAM_PARTIAL_PERSIST_INTERVAL_MS` 节流；新增逐事件的落盘/日志动作前先想清楚它会不会被每个 token 触发一次。
 - **追加提示词（排队）**：任务进行中用户可以追加提示词，队列存在 `agentSession.queue`（`lib/web/agent-queue.js`，最多 10 条，`when` 为 `now` / `step` / `turn`；`normalizeWebAgentSession` 的字段白名单里要有它，否则落盘后丢失）。接口 `POST /api/sessions/:name/agent/queue`（clientMessageId 幂等；容器被别的会话占着返回 409）、`DELETE .../agent/queue/:id`、`POST .../agent/queue/continue`；`/messages` 带 `queue`。一轮对话的完整流程抽成 `runWebAgentStreamTurn(..., res)`：前端不在线时传 `createHeadlessResponse()` 顶替 `res`，事件照常落盘。每一轮结束（完成 / 失败 / 被追加打断，**用户点停止除外**，由 `stopWebAgentRun` 置 `runState.userStopped`，并把 `agentSession.queuePaused` **落盘**——只记在内存里的话，serve 重启或用户下一次正常发送、那一轮结束后，停止前的排队会被自动发出去；暂停只有 `POST .../agent/queue/continue` 能解除，队列清空时自动解除，`/messages` 带 `queuePaused`）后若队列可以自动发（`agentQueue.shouldAutoDispatch`），先给连着的流发一个 `queue_next` 事件（前端据此结束这条流、改走恢复轮询），再 `setImmediate` 调 `dispatchNextQueued`（同步取出队首并占锁，开不起来就放回队首）。`now` 立即走进程树信号；`step` 在 `isStepBoundary`（一次工具 / 子 Agent / 说明完成）处打断，`agentStepFallbackMs`（默认 120 秒）等不到就退化成 `now`。serve 重启后 `startContainerServices` 末尾调 `resumeQueuedAgentTurns`，把留在队列里（暂停的除外）又没有任务在跑的内容当作 `turn` 发出；发之前用 `buildLiveRunsCommand`（只读，校验规则同停止脚本）看容器里还有没有活着的 Agent 进程，有就不发、排队留给用户——那可能是上一个 serve 的孤儿任务，也可能是同一 HOME 下另一个 serve 实例正在跑的任务，所以只检测不杀。
 - **停止 / 打断必须进到容器里发信号**（`lib/web/agent-run-control.js`）：只杀宿主机上的 `docker exec` 客户端，容器里的 Agent 进程会继续跑（实测）。命令被包成 `echo $$ > /tmp/manyoyo-run-<id>.pid; <命令>; exit $?`，**末尾的 `exit $?` 不能省**——命令是最后一条简单命令时 bash 会 exec 替换自己，`/proc/<pid>/cmdline` 里的 `manyoyo-run-<id>.pid` 标记就没了，停止时会因“认不出进程”而不杀（真实容器测出来的，单测里用 `sleep 61; true` 测不到）。PID 文件容器里可写，按不可信输入处理（纯数字、普通文件、命令行带标记才发信号），再按子孙进程树逐级 INT → TERM → KILL。真实的 claude 收到 SIGINT 会正常收尾、**退出码为 0**，所以 `interrupted` 看“发过信号”（`runState.signaled`）而不只是退出码。已验证 Claude 打断后 `-r <id>` 能接上上下文；Codex / Gemini / OpenCode 没有环境验证，拿不到引擎会话 id 时走既有的历史注入降级。
+- **登录会话落盘**（`lib/web/auth-store.js`）：内存为准，落盘到 `~/.manyoyo/serve/auth-sessions-<host>_<port>.json`（按监听地址分开；`bin/manyoyo.js` 传 `authSessionsFile`，测试不传就只在内存里，别让测试写真实目录）。只存 `sha256(token)` 和凭据指纹 `HMAC(盐, 用户名\0密码)`：用户名 / 密码变了（含每次启动随机生成的密码）整份作废并**马上覆盖**（不覆盖的话改回旧密码旧会话会复活）。登录 / 登出立刻写，滑动续期只在到期时间比已落盘的晚 1 小时以上才合并延迟写；文件损坏、权限不是 0600 当空的并 warn。会话到期时间用真实 `Date.now`，不要用测试可注入的 `ctx.nowMs`（限速用例会拨时钟）。
+- **启动对账**（`reconcileOrphanTurns`，在 `startWebServer` 里直接挂，**不要**挂在 `startContainerNetworkWatch` 上：测试替身没有 `watchStarts`）：启动时记下当时 `pending===true` 的消息 id，只处理这批。容器里没有活着的运行（`listLiveRunsInContainer`；容器不存在 / 没运行 / 查询失败都算没有）→ 立即标 `interrupted`，执行过程补“[任务] 服务重启，本轮已中断”，流式半截回复末尾（没有就新建一条）写说明，并记 `process.interrupted` 控制事件；还有活着的（docker 下 agent 比 serve 活得久）→ 每 5 秒（`orphanPollMs`）查一次，跑完再按“后台跑完”文案处理。该会话已有新的一轮在跑时不在末尾插入说明。`resumeQueuedAgentTurns` 先等这次对账，否则会在还挂着旧 pending 的会话上再开新一轮。
 - **子 Agent**：Claude 的 `Agent`（旧名 `Task`）工具生成 `kind: "subagent"` 事件，子 Agent 里的事件带 `parentToolId`（取自 `parent_tool_use_id`）；带 `parent_tool_use_id` 的 assistant 文本不当作主 Agent 的回复。`--forward-subagent-text` 只在 `claude --help` 里有该参数时才加（命令里就地探测，约 50ms，不缓存）。样本 fixture：`test/fixtures/claude-subagent.ndjson`。
 - **最终回复的取值**（`resolveAgentFinalOutput`）：原始 stdout 只保留开头 `AGENT_RAW_OUTPUT_MAX_CHARS`（32MB，会话 id 在开头），另外用 `createTailBuffer` 保留结尾（8MB）。最终回复和用量都在结尾：超过上限后只解析开头，会把截断点之前的某条中间说明当成最终回复（每个 token 一行约 260 字节的增量，加上思考 token、子 Agent、大段工具结果，长任务很容易超过）；所以截断时先从结尾提取，提取不到再看开头，用量也优先看结尾（`stdoutTail`）。Claude 以最后一个 `result` 事件的 `result` 为准（后台任务场景结尾有两个 `result`，第一个是中间结论）。提取到的最终回复**不截断**（与流式落盘一致），提取不到才退回原始输出并按 `WEB_OUTPUT_MAX_CHARS` 截断。子进程的 stdout / stderr 必须 `setEncoding('utf8')` 按流解码：逐块 `toString` 会把跨块的中文拆成乱码。测试可用 `agentRawOutputMaxChars` 调小上限；真实样本 `test/fixtures/claude-background-task.ndjson`、`claude-subagent-parallel.ndjson`（claude 2.1.290，已精简）。
 - **历史读写在 `lib/web/history-store.js`**：进程内缓存 + 原子写（`writeConfigFileSecure`，0600）+ 合并写盘。读靠 `stat` 的 `ino + mtimeMs + size` 判断缓存是否还有效（别的进程原子替换也能识别）；`loadWebSessionHistory` 返回的是**缓存里的同一个对象**，改了必须 `saveWebSessionHistory`，只读路由不要改它（`getWebAgentSession(..., { create: true })` 会在缓存里留一个未保存的空 agent，只在马上要写的路径里用）。流式过程中的 trace patch 和控制事件走 `{ defer: true }`（只改内存，最迟 `AGENT_STREAM_PARTIAL_PERSIST_INTERVAL_MS` 后落盘）；`process.exit` / serve 关闭会 flush；`result` / `error` 类事件（`WEB_STREAM_FLUSH_EVENT_TYPES`）和所有非 defer 写入立即写盘并带上攒着的内容。`kill -9` 最多丢约 1 秒的 trace。文件解析失败会留一份 `.corrupt-<时间>` 备份再按空历史处理，不要绕过它。磁盘格式只有 `agents.<id>.messages`（不再有顶层 `messages`，紧凑 JSON），老版本（含 `update --rollback`）读取时优先用 `agents`，能读新文件。

package/lib/web/agent-queue.js

@@ -4,6 +4,7 @@
 // 只放纯函数，调用方负责 saveWebSessionHistory。
 
 const crypto = require('crypto');
+const { IMAGE_PATH_PATTERN } = require('./uploads');
 
 const QUEUE_MAX = 10;
 const QUEUE_WHEN = ['now', 'step', 'turn'];
@@ -31,13 +32,14 @@ function publicQueue(agentSession) {
         id: item.id,
         clientMessageId: item.clientMessageId,
         text: item.text,
+        ...(Array.isArray(item.images) && item.images.length ? { images: item.images } : {}),
         when: item.when,
         createdAt: item.createdAt
     }));
 }
 
 // now / step 排在所有 turn 之前（它们之间保持先来先到）；turn 排到队尾
-function enqueue(agentSession, { clientMessageId, text, when }) {
+function enqueue(agentSession, { clientMessageId, text, when, images }) {
     const queue = getQueue(agentSession);
     if (clientMessageId) {
         const existing = queue.find(item => item.clientMessageId === clientMessageId);
@@ -52,6 +54,7 @@ function enqueue(agentSession, { clientMessageId, text, when }) {
         id: `q-${crypto.randomBytes(6).toString('hex')}`,
         clientMessageId: clientMessageId || '',
         text,
+        ...(Array.isArray(images) && images.length ? { images } : {}),
         when,
         createdAt: new Date().toISOString()
     };
@@ -126,6 +129,7 @@ function normalizeStoredQueue(value) {
             id: item.id,
             clientMessageId: typeof item.clientMessageId === 'string' ? item.clientMessageId : '',
             text: item.text,
+            ...(Array.isArray(item.images) ? { images: item.images.filter(path => typeof path === 'string' && IMAGE_PATH_PATTERN.test(path)).slice(0, 5) } : {}),
             when: item.when,
             createdAt: typeof item.createdAt === 'string' ? item.createdAt : new Date().toISOString()
         }));

package/lib/web/auth-store.js

@@ -0,0 +1,167 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { writeConfigFileSecure } = require('../secure-file');
+
+// 网页登录会话：内存为准，落盘只为 serve 重启后不把人踢下线。
+// 文件只存 sha256(token)（不存 token 明文）和一个“凭据指纹”HMAC(随机盐, 用户名\0密码)：
+// 改了用户名或密码（含每次启动随机生成的密码变了）指纹就对不上，整份作废。
+const FILE_VERSION = 1;
+const DEFAULT_FLUSH_DELAY_MS = 1000;
+// 滑动续期不是每个请求都写盘：新的到期时间比已落盘的晚到这个值才写
+const REWRITE_SLACK_MS = 60 * 60 * 1000;
+
+function hashToken(token) {
+    return crypto.createHash('sha256').update(String(token)).digest('hex');
+}
+
+function fingerprintOf(salt, user, pass) {
+    return crypto.createHmac('sha256', Buffer.from(salt, 'hex')).update(`${user}\0${pass}`).digest('hex');
+}
+
+function authSessionsFilePath(homeDir, host, port) {
+    const safeHost = String(host || 'host').replace(/[^A-Za-z0-9.-]/g, '_');
+    return path.join(homeDir, '.manyoyo', 'serve', `auth-sessions-${safeHost}_${Number(port) || 0}.json`);
+}
+
+function safeEqualHex(a, b) {
+    const x = Buffer.from(String(a), 'hex');
+    const y = Buffer.from(String(b), 'hex');
+    return x.length === y.length && x.length > 0 && crypto.timingSafeEqual(x, y);
+}
+
+/**
+ * @param {object} options
+ * @param {string} [options.file] 落盘路径；不给就只在内存里
+ * @param {string} options.user
+ * @param {string} options.pass
+ * @param {number} options.ttlMs
+ * @param {() => number} [options.now]
+ * @param {(message: string) => void} [options.warn]
+ */
+function createAuthStore(options) {
+    const now = options.now || Date.now;
+    const warn = options.warn || (() => {});
+    const file = options.file || '';
+    const ttlMs = options.ttlMs;
+    const flushDelayMs = options.flushDelayMs || DEFAULT_FLUSH_DELAY_MS;
+    const sessions = new Map(); // sha256(token) → { username, expiresAt }
+    const persisted = new Map(); // sha256(token) → 已落盘的 expiresAt
+    let salt = crypto.randomBytes(16).toString('hex');
+    let timer = null;
+    let dirty = false;
+    let warnedWrite = false;
+
+    function serialize() {
+        const out = {};
+        for (const [key, session] of sessions) out[key] = { username: session.username, expiresAt: session.expiresAt };
+        return `${JSON.stringify({ version: FILE_VERSION, salt, fingerprint: fingerprintOf(salt, options.user, options.pass), sessions: out })}\n`;
+    }
+
+    function flush() {
+        if (timer) { clearTimeout(timer); timer = null; }
+        dirty = false;
+        if (!file) return;
+        try {
+            writeConfigFileSecure(file, serialize());
+            persisted.clear();
+            for (const [key, session] of sessions) persisted.set(key, session.expiresAt);
+        } catch (e) {
+            if (!warnedWrite) {
+                warnedWrite = true;
+                warn(`登录会话写盘失败（重启后需要重新登录）: ${e && e.message}`);
+            }
+        }
+    }
+
+    function scheduleFlush() {
+        if (!file) return;
+        dirty = true;
+        if (timer) return;
+        timer = setTimeout(flush, flushDelayMs);
+        if (typeof timer.unref === 'function') timer.unref();
+    }
+
+    function load() {
+        if (!file) return;
+        let raw;
+        try {
+            const stat = fs.lstatSync(file);
+            if (!stat.isFile() || (stat.mode & 0o077) !== 0) {
+                warn(`登录会话文件不是 0600 的普通文件，已忽略: ${file}`);
+                flush();
+                return;
+            }
+            raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        } catch (e) {
+            if (e && e.code === 'ENOENT') return;
+            warn(`登录会话文件读取失败，已忽略: ${e && e.message}`);
+            flush();
+            return;
+        }
+        const valid = raw && raw.version === FILE_VERSION && typeof raw.salt === 'string' && /^[0-9a-f]{32}$/.test(raw.salt)
+            && typeof raw.fingerprint === 'string' && raw.sessions && typeof raw.sessions === 'object';
+        if (!valid || !safeEqualHex(raw.fingerprint, fingerprintOf(raw.salt, options.user, options.pass))) {
+            // 改过用户名或密码：整份作废，并马上覆盖（否则改回旧密码后旧会话会复活）
+            flush();
+            return;
+        }
+        salt = raw.salt;
+        const current = now();
+        for (const [key, session] of Object.entries(raw.sessions)) {
+            if (/^[0-9a-f]{64}$/.test(key) && session && typeof session.username === 'string' && Number.isFinite(session.expiresAt) && session.expiresAt > current) {
+                sessions.set(key, { username: session.username, expiresAt: session.expiresAt });
+                persisted.set(key, session.expiresAt);
+            }
+        }
+    }
+
+    function prune() {
+        const current = now();
+        let removed = false;
+        for (const [key, session] of sessions) {
+            if (session.expiresAt <= current) {
+                sessions.delete(key);
+                removed = true;
+            }
+        }
+        if (removed) scheduleFlush();
+    }
+
+    load();
+
+    return {
+        create(username) {
+            prune();
+            const token = crypto.randomBytes(24).toString('hex');
+            sessions.set(hashToken(token), { username, expiresAt: now() + ttlMs });
+            flush();
+            return token;
+        },
+        // 命中则顺延到期时间（滑动过期）
+        touch(token) {
+            if (!token) return null;
+            prune();
+            const key = hashToken(token);
+            const session = sessions.get(key);
+            if (!session) return null;
+            session.expiresAt = now() + ttlMs;
+            if (file && session.expiresAt - (persisted.get(key) || 0) >= REWRITE_SLACK_MS) scheduleFlush();
+            return { username: session.username };
+        },
+        remove(token) {
+            if (!token) return;
+            if (sessions.delete(hashToken(token))) flush();
+        },
+        close() {
+            if (dirty) flush();
+            else if (timer) { clearTimeout(timer); timer = null; }
+        },
+        // 仅测试用
+        size() { return sessions.size; }
+    };
+}
+
+module.exports = { createAuthStore, authSessionsFilePath };

package/lib/web/container-manage.js

@@ -6,7 +6,7 @@ const state_ = require('../container-state');
 const { resolveContainerId } = require('../container-exec');
 const { normalizePolicy, resolveContainerRefs, isUnrestricted, domainRuleAllows, targetKind } = require('../network-policy');
 const { parseEnvEntry } = require('../runtime-normalizers');
-const { envUrlDomains } = require('../network-endpoints');
+const { modelDomains } = require('../network-endpoints');
 const { egressPaths } = require('../egress-sidecar');
 const deniedLib = require('../egress-denied');
 const { isBrowserBackground } = require('../browser-background');
@@ -206,7 +206,7 @@ function createContainerManageRoutes({ ctx, state, req, res, deps }) {
             ...state_.readEnv(homeDir, target.id).entries.map(entry => `${entry.key}=${entry.value}`),
             ...state_.envFileEntries(homeDir, target.id).map(entry => `${entry.key}=${entry.value}`)
         ];
-        const suggestedDomains = envUrlDomains(envLines).filter(domain => !domainRuleAllows(policy, domain));
+        const suggestedDomains = modelDomains(envLines).filter(domain => !domainRuleAllows(policy, domain));
         return {
             legacy: false,
             id: target.id,

package/lib/web/denied-notify.js

@@ -9,6 +9,8 @@ const DEFAULT_INTERVAL_MS = 2000;
  * @param {() => {host: string, port: number, count: number}[]} options.read 当前拦截记录
  * @param {(host: string) => boolean} options.isIgnored 不提示的域名（已放行、浏览器后台请求）
  * @param {(text: string) => void} options.emit
+ * @param {(host: string) => boolean} [options.isModelHost] 是否 Agent 自己的模型域名
+ * @param {(host: string) => void} [options.onModelDenied] 模型域名被拦时调用（每个域名一次）
  */
 function createDeniedNotifier(options) {
     const intervalMs = options.intervalMs || DEFAULT_INTERVAL_MS;
@@ -28,6 +30,9 @@ function createDeniedNotifier(options) {
                 if (record.count > (baseline.get(key) || 0) && !notified.has(record.host) && !options.isIgnored(record.host)) {
                     notified.add(record.host);
                     options.emit(`[提示] 已拦截：${record.host}（不在白名单），可在「容器 → 网络」里一键允许`);
+                    if (options.onModelDenied && options.isModelHost && options.isModelHost(record.host)) {
+                        options.onModelDenied(record.host);
+                    }
                 }
                 baseline.set(key, record.count);
             });