mingdao-harness 0.6.2 → 0.6.4

package/src/skill-registry.js

@@ -23,10 +23,37 @@ const DEFAULT_HOSTS = [
 const TTL_MS = 60 * 60 * 1000;
 const MAX_FILE = 512 * 1024;
 
+// 回环/本机地址：本地开发与内网自建 registry 的常见形态，允许明文 http
+function isLoopbackHost(/** @type {string} */ host) {
+  return /^(127\.0\.0\.1|localhost|\[::1\]|::1)(:\d+)?$/i.test(host);
+}
+
 function registryBase() {
   const env = process.env.MINGDAO_REGISTRY_URL;
   if (env) {
-    const u = String(env).replace(/\/index\.json$/, '').replace(/\/+$/, '');
+    const raw = String(env).trim();
+    const u = raw.replace(/\/index\.json$/, '').replace(/\/+$/, '');
+    // v0.6.3（审计 M-7）：自建 registry **拒绝明文 http**（回环除外）。
+    //
+    // 为什么必须拒：自定义源的内容会直接决定"装进用户机器里的技能正文"，
+    // 而 registry 索引里的 sha256 是**自证**的（正文与哈希同在索引里，见 M-6）——
+    // 明文 http 下内网中间人可同时替换正文与哈希，校验必然通过。
+    // 也就是说 TLS 是这条链上**唯一**的外部信任锚，不能默认放弃。
+    // 回环地址（127.0.0.1/localhost/[::1]）不经过网络，允许明文以便本地开发。
+    const scheme = (u.match(/^([a-z][a-z0-9+.-]*):\/\//i) || [])[1];
+    if (scheme && scheme.toLowerCase() !== 'https' && scheme.toLowerCase() !== 'http') {
+      return { hosts: [], isCustom: true, error: `MINGDAO_REGISTRY_URL 的协议不支持：${scheme}://（只支持 https，或回环地址上的 http）` };
+    }
+    if (scheme && scheme.toLowerCase() === 'http' && !isLoopbackHost(u.replace(/^https?:\/\//i, ''))) {
+      return {
+        hosts: [],
+        isCustom: true,
+        error:
+          `MINGDAO_REGISTRY_URL 使用明文 http（${u}）已被拒绝：技能正文与该索引里的 sha256 同源，` +
+          '明文链路下中间人可同时替换两者，校验必然通过——TLS 是这条链上唯一的外部信任锚。' +
+          '请改用 https；若确为本机开发，请用 127.0.0.1/localhost。',
+      };
+    }
     return { hosts: [u], isCustom: true };
   }
   return { hosts: DEFAULT_HOSTS, isCustom: false };
@@ -71,7 +98,8 @@ export async function fetchRegistryIndex({ force = false, allowNetwork = true }
       return { error: '尚无线上技能库缓存（点击「刷新线上」拉取，或设置 MINGDAO_REGISTRY_URL 指向自建 registry）' };
     }
   }
-  const { hosts, isCustom } = registryBase();
+  const { hosts, isCustom, error: baseError } = registryBase();
+  if (baseError) return { error: baseError };
   let lastErr = null;
   for (const host of hosts) {
     try {
@@ -123,6 +151,7 @@ export async function installFromRegistry(/** @type {any} */ name) {
     // 逐文件下载按镜像回退（审计：国内网络下 raw.githubusercontent 常超时/被断，
     // 此前只试首选主机 → 安装报「This operation was aborted」；gitee/gitcode 国内秒开）
     const base = registryBase();
+    if (base.error) return { error: base.error };
     const hosts = [r.host, ...base.hosts.filter((h) => h !== r.host)];
     const allowPrivate = base.isCustom; // 用户显式配置的源（可能是内网自建 registry）
     let verified = false; // 每个文件都必须通过 sha256 校验（缺哈希直接拒绝安装），成功即 true

package/src/sync-server.js

@@ -408,24 +408,29 @@ function doDelete(username, name) {
  * @param {any} username
  * @param {any} body
  */
-function doChangePassword(username, body) {
+async function doChangePassword(username, body) {
   const oldPassword = String(body.oldPassword || '');
   const newPassword = String(body.newPassword || '');
   if (newPassword.length < 8) return { error: '新密码至少 8 位' };
-  const users = readJson(usersFile(), {});
-  const u = users[username];
-  if (!u) return { unauthorized: '用户不存在' };
-  if (!verifyPassword(oldPassword, u.salt, u.hash)) return { unauthorized: '旧密码错误' };
-  const salt = crypto.randomBytes(12).toString('hex');
-  users[username] = { ...u, salt, hash: hashPassword(newPassword, salt), updatedAt: Date.now() };
-  writeJson(usersFile(), users);
-  // 改密吊销既有设备 token：密码可能已泄露，旧 token 一律失效（当前设备也需重新登录）
-  const devices = readJson(devicesFile(), {});
-  delete devices[username];
-  writeJson(devicesFile(), devices);
-  invalidateDeviceCache();
-  log('password-changed', username, '（全部设备已吊销）');
-  return { ok: true, note: '密码已修改，所有设备需重新登录' };
+  return withWriteLock(() => {
+    // v0.6.3（P0-4）：改密会 `delete devices[username]`（吊销全部设备 token），而设备表另有
+    // 一把 registerLock/写锁——此前这里是**锁外**读改写，于是"吊销"可以被一次并发的 pair
+    // 写回覆盖，已吊销的旧 token 复活。改密与设备表写必须互斥。
+    const users = readJson(usersFile(), {});
+    const u = users[username];
+    if (!u) return { unauthorized: '用户不存在' };
+    if (!verifyPassword(oldPassword, u.salt, u.hash)) return { unauthorized: '旧密码错误' };
+    const salt = crypto.randomBytes(12).toString('hex');
+    users[username] = { ...u, salt, hash: hashPassword(newPassword, salt), updatedAt: Date.now() };
+    writeJson(usersFile(), users);
+    // 改密吊销既有设备 token：密码可能已泄露，旧 token 一律失效（当前设备也需重新登录）
+    const devices = readJson(devicesFile(), {});
+    delete devices[username];
+    writeJson(devicesFile(), devices);
+    invalidateDeviceCache();
+    log('password-changed', username, '（全部设备已吊销）');
+    return { ok: true, note: '密码已修改，所有设备需重新登录' };
+  });
 }
 
 // ---------- 会话分享 ----------
@@ -518,14 +523,20 @@ function doShareAccept(username, shareId) {
     atomicWriteFileSync(target, content, { mode: 0o600 }); // 质检 H4
   }
   return withWriteLock(() => {
+    // v0.6.3（P0-4）：**锁内重读**。此前 shares/accepted 是在锁**外**读的，写回的是陈旧快照——
+    // 于是"revoke 之后的一次并发 accept"会把已删除的 shareId 写回去（分享复活），
+    // 同理也会覆盖并发的 pulls/accepted 更新。这里重新读取并再次校验存在性。
+    const shares2 = readJson(sharesFile(), {});
+    if (!shares2[shareId]) return { notFound: '分享不存在（可能已被并发撤销）' };
+    const accepted2 = readJson(acceptedFile(), {});
     const meta = readJson(metaFile(username), {});
     meta[savedAs] = { mtime: Date.now(), size: Buffer.byteLength(content) };
     writeJson(metaFile(username), meta);
-    accepted[username] = accepted[username] || {};
-    accepted[username][shareId] = { owner: s.owner, name: s.name, savedAs, acceptedAt: Date.now(), copyHash: sha(content) };
-    writeJson(acceptedFile(), accepted);
-    shares[shareId].pulls = (shares[shareId].pulls || 0) + 1;
-    writeJson(sharesFile(), shares);
+    accepted2[username] = accepted2[username] || {};
+    accepted2[username][shareId] = { owner: s.owner, name: s.name, savedAs, acceptedAt: Date.now(), copyHash: sha(content) };
+    writeJson(acceptedFile(), accepted2);
+    shares2[shareId].pulls = (shares2[shareId].pulls || 0) + 1;
+    writeJson(sharesFile(), shares2);
     log('share-accept', username, shareId, savedAs, conflict ? '(conflict-copy)' : '(refresh)');
     return {
       ok: true,
@@ -583,13 +594,21 @@ async function handle(req, res) {
     if (nowSeen - (dev.device.lastSeen || 0) > 60000) {
       dev.device.lastSeen = nowSeen;
       // 质检 A1：与 pair 的 devices 写入互斥（60s 节流只降频，不消除竞态——加锁消除）
-      withWriteLock(() => {
-        const devices = readJson(devicesFile(), {});
-        if (devices[dev.username]?.[dev.deviceId]) {
-          devices[dev.username][dev.deviceId] = dev.device;
-          writeJson(devicesFile(), devices);
-        }
-      });
+      // v0.6.3（P0-4）：**必须 await**。withWriteLock 是 async：临界区里任何 I/O 异常
+      // （ENOSPC/EACCES/ENOENT）都会让返回的 promise reject，而无人处理 → Node 15+ 默认
+      // `--unhandled-rejections=throw` → **整个同步服务进程退出**（所有在线设备一起掉线）。
+      try {
+        await withWriteLock(() => {
+          const devices = readJson(devicesFile(), {});
+          if (devices[dev.username]?.[dev.deviceId]) {
+            devices[dev.username][dev.deviceId] = dev.device;
+            writeJson(devicesFile(), devices);
+          }
+        });
+      } catch (/** @type {any} */ e) {
+        // lastSeen 写失败不影响本次请求的语义（它只是"最近在线"标记），但必须留痕而不是崩掉进程
+        log('lastSeen-write-failed', dev.username, String(e?.message || e));
+      }
     }
 
     if (req.method === 'POST' && p === '/api/devices') {
@@ -627,7 +646,7 @@ async function handle(req, res) {
     if (req.method === 'POST' && p === '/api/password') {
       if (rateLimited(req, 10)) return json(res, 429, { error: '尝试过于频繁，请稍后再试' });
       const body = await parseBody(req);
-      const r = doChangePassword(dev.username, body);
+      const r = await doChangePassword(dev.username, body); // v0.6.3（P0-4）：改为持锁执行，必须 await
       if (r.error) return json(res, 400, r);
       if (r.unauthorized) return json(res, 401, r);
       return json(res, 200, r);

package/src/sync.js

@@ -17,6 +17,7 @@ import { loadCredentials, saveCredentials } from './credentials.js';
 import { listSessions, CONFLICT_BACKUP_RE } from './session.js';
 import { atomicWriteFileSync, withFileLockSync } from './atomic-write.js';
 import { decideEgress, currentPolicy } from './net-guard.js';
+import { redactSecrets } from './redact.js';
 
 const TIMEOUT_MS = 20000;
 // 自签证书（--insecure）只影响同步请求本身，不再改写进程级 NODE_TLS_REJECT_UNAUTHORIZED
@@ -287,6 +288,7 @@ export async function syncPush(name) {
   /** @type {Record<string, any>} */
   const delta = {}; // 本次真正变更的状态键（T19：末尾按增量合并）
   const pushed = [];
+  const redactedSessions = []; // 上传前被脱敏的会话（调用方据此提示用户）
   const conflicts = [];
   const skipped = [];
   for (const s of locals) {
@@ -303,11 +305,23 @@ export async function syncPush(name) {
       skipped.push(s.name);
       continue;
     }
-    const content = fs.readFileSync(s.file, 'utf8');
-    if (!content.trim()) {
+    const rawContent = fs.readFileSync(s.file, 'utf8');
+    if (!rawContent.trim()) {
       skipped.push(s.name); // 空会话文件（刚创建未写消息）不推送
       continue;
     }
+    // v0.6.3（审计 H-2）：**上传前必须脱敏**。
+    //
+    // 会话原文会原样记录用户粘贴的 `sk-*`、PEM、JWT、`AWS_SECRET_ACCESS_KEY=…`；
+    // 而账本与审计日志都做到了「写入即脱敏」，唯独**信息量最大的会话原文两边都不脱敏**，
+    // 且自动同步默认开启——于是用户配置过同步/配对后，这些凭据会以**明文上传到同步服务器**。
+    //
+    // 本地文件保持原样（用户自己的会话不该被改写），只在**出网前**这一层脱敏：
+    // 远端拿到的是掩码版，其它设备拉回来也是掩码版——这正是我们要的语义。
+    // 冲突判定仍用脱敏后的文本（与远端同一口径），否则每次同步都会被判成"内容不同"。
+    const content = redactSecrets(rawContent);
+    const redacted = content !== rawContent;
+    if (redacted) redactedSessions.push(s.name);
     if (Buffer.byteLength(content) > 19 * 1024 * 1024) {
       return { error: `${s.name} 超过 20MB 上限，跳过同步` };
     }
@@ -337,7 +351,7 @@ export async function syncPush(name) {
     }
   }
   commitState(delta);
-  return { ok: true, pushed, conflicts, skipped };
+  return { ok: true, pushed, conflicts, skipped, redacted: redactedSessions };
 }
 
 // 拉取单个/全部会话。本地有不同内容时保留本地，远端写入 .remote- 副本。

package/src/task-state.js

@@ -15,7 +15,16 @@ function taskStateDir() {
 
 /** @param {any} sessionName */
 export function taskStateFile(sessionName) {
-  return path.join(taskStateDir(), `${String(sessionName)}.json`);
+  const dir = taskStateDir();
+  const file = path.join(dir, `${String(sessionName)}.json`);
+  // v0.6.3（BUG-067）：**包含性检查**。sessionName 直接来自调用方（会话文件名/CLI 参数），
+  // 此前不校验：`../../x` 会把检查点写到仓库之外（读写任意 .json）。
+  // 判据用 path.relative 而不是"过滤 ../"——后者挡不住绝对路径、Windows 盘符与符号链接归一后的形态。
+  const rel = path.relative(dir, file);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new Error(`会话名非法（会越出检查点目录）：${String(sessionName)}`);
+  }
+  return file;
 }
 
 /** @param {any} sessionName */

package/src/tasks.js

@@ -7,7 +7,7 @@ import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { relativeTime } from './session.js';
-import { atomicWriteFileSync, withFileLockSync } from './atomic-write.js';
+import { atomicWriteFileSync, atomicWritePrivateSync, withFileLockSync } from './atomic-write.js';
 import { procAlive, pidOwnedBy, spawnOpts } from './proc.js';
 
 const CLI_PATH = fileURLToPath(new URL('./cli.js', import.meta.url));
@@ -55,10 +55,10 @@ export function readTask(/** @type {any} */ home, /** @type {any} */ id) {
 }
 
 export function writeTask(/** @type {any} */ home, /** @type {any} */ task) {
-  fs.mkdirSync(tasksDir(home), { recursive: true });
+  fs.mkdirSync(tasksDir(home), { recursive: true, mode: 0o700 });
   // 原子写：先临时文件再改名，避免崩溃留下半截 JSON
   const target = path.join(tasksDir(home), task.id + '.json');
-  atomicWriteFileSync(target, JSON.stringify(task, null, 2) + '\n'); // 质检 H4：tmp 名含 pid+随机
+  atomicWritePrivateSync(target, JSON.stringify(task, null, 2) + '\n'); // 质检 H4：tmp 名含 pid+随机；0600（含提问原文）
 }
 
 export function isValidTaskId(/** @type {any} */ id) {
@@ -247,11 +247,17 @@ export async function flushKillEscalation() {
 }
 
 export function killTask(/** @type {any} */ home, /** @type {any} */ id) {
-  if (!isValidTaskId(id)) return false;
-  // 质检 H3：读-改-写加锁（与 worker 自身的状态写互斥）
-  return withFileLockSync(path.join(tasksDir(home), '.lock'), () => killTaskInner(home, id));
-}
-function killTaskInner(/** @type {any} */ home, /** @type {any} */ id) {
+  // v0.6.2（P2-7 阻塞面）：进程操作全部移到锁**外**，临界区只剩状态读-改-写。
+  //
+  // 原实现把 killTaskInner 整个包在锁里，而它内部会：
+  //   · pidOwnedBy() —— 非 Linux 上回退到**同步** execFileSync('ps')；
+  //   · killTree()   —— Windows 上走**同步** spawnSync('taskkill')；
+  // 于是临界区里夹着外部进程调用，持锁时间从毫秒级变成百毫秒级，**每个等锁的人都被拖住**。
+  // 实测（本机）纯状态读-改-写约 0.13ms、最坏的 cache-stats 轮转也只有 6ms——
+  // 也就是说，锁被长时间持有完全是自己把慢操作放进去造成的。
+  //
+  // 语义不变：状态写回仍在锁内（与 worker 的终态写互斥），P3 T20 的「killed 优先」保护
+  // 仍在 patchTask 里；把进程操作提前到锁外不影响任何一条竞态路径的最终状态。
   const t = readTask(home, id);
   if (!t) return false;
   if (t.status === 'running' && t.pid) {
@@ -269,8 +275,14 @@ function killTaskInner(/** @type {any} */ home, /** @type {any} */ id) {
       pendingKill = escalateKill(t.pid);
     }
   }
-  patchTask(home, id, { status: 'killed', durationMs: t.durationMs ?? Date.now() - t.startedAt });
-  return true;
+  // 状态写回：仍在跨进程锁内（只做读-改-写，毫秒级）
+  return killTaskInner(home, id) !== null;
+}
+/** 临界区内的状态写回（进程部分见 killTask，已移到锁外） */
+function killTaskInner(/** @type {any} */ home, /** @type {any} */ id) {
+  const t = readTask(home, id);
+  if (!t) return null;
+  return patchTask(home, id, { status: 'killed', durationMs: t.durationMs ?? Date.now() - t.startedAt });
 }
 
 const MARK = { running: '▶', done: '✓', failed: '✖', killed: '■' };

package/src/tools/bash.js

@@ -86,9 +86,89 @@ function foldRepeats(/** @type {any} */ s) {
   }
   return out.join('\n');
 }
+/**
+ * 子进程输出解码：**一次**解整段字节，而不是逐块 `toString()`。
+ *
+ * 两处乱码根因（v0.6.3，桌面版实测）：
+ *   ① 逐块解码：中文 3 字节被管道切成两半 → 两半各自解出 U+FFFD；
+ *   ② Windows 上本工具走 `cmd.exe /d /s /c`，输出是 OEM 代码页（中文 = GBK/CP936），
+ *      按 UTF-8 解就是花屏。故严格 UTF-8 失败时用 GBK 再解一次。
+ * 导出的目的是让这两类乱码能被**确定性**测到——②只在 Windows 出现，CI 上跑不出真环境。
+ * @param {Buffer} buf
+ */
+export function decodeProcessOutput(buf) {
+  if (!buf || !buf.length) return '';
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(buf);
+  } catch {
+    try {
+      return new TextDecoder('gbk').decode(buf);
+    } catch {
+      return buf.toString('utf8');
+    }
+  }
+}
+
+/**
+ * 子进程输出采集器（**导出以便确定性测试**）。
+ *
+ * 为什么单独成一个原语：乱码的两个根因都藏在这里，而"端到端跑一个大输出"根本测不准——
+ * 输出上限（约 60KB）比一个管道块（64KB）还小，保留的尾部常常落在**单块之内**，
+ * 跨块解码的缺陷于是照样通过（第一版回归就是这么假绿的，靠变异验证才发现）。
+ * 把 push/text 暴露出来，测试就能**人工把汉字切成两半**喂进去。
+ *
+ * @param {number} maxBytes 只保留尾部这么多字节（超出丢弃头部）
+ */
+export function createOutputCapture(maxBytes) {
+  /** @type {{chunks: Buffer[], bytes: number}} */
+  const st = { chunks: [], bytes: 0 };
+  const snapBoundary = () => {
+    // **对齐到字符边界**：按字节裁会把 UTF-8 从字符中间切断，于是"整段严格解码"必然失败
+    // → 误触发 GBK 回退 → 反而解成花屏（本修复第一版的真实缺陷，被单测抓出来的）。
+    // UTF-8 的续字节形如 10xxxxxx，丢掉它们即可让缓冲区从**前导字节**开始。
+    while (st.chunks.length && st.chunks[0].length && (st.chunks[0][0] & 0xc0) === 0x80) {
+      st.chunks[0] = st.chunks[0].subarray(1);
+      st.bytes -= 1;
+      if (!st.chunks[0].length) st.chunks.shift();
+    }
+  };
+  return {
+    /** @param {Buffer} d */
+    push(d) {
+      st.chunks.push(d);
+      st.bytes += d.length;
+      while (st.bytes > maxBytes && st.chunks.length) {
+        const first = st.chunks[0];
+        const drop = Math.min(first.length, st.bytes - maxBytes);
+        if (drop >= first.length) {
+          st.chunks.shift();
+          st.bytes -= first.length;
+        } else {
+          st.chunks[0] = first.subarray(drop);
+          st.bytes -= drop;
+        }
+      }
+      snapBoundary();
+    },
+    /** 结束时**一次**解码整段字节（绝不能逐块 toString：会把汉字劈成 U+FFFD） */
+    text() {
+      return st.chunks.length ? decodeProcessOutput(Buffer.concat(st.chunks)) : '';
+    },
+    get bytes() {
+      return st.bytes;
+    },
+  };
+}
+
 function tail(/** @type {any} */ s, /** @type {any} */ n) {
   const folded = foldRepeats(stripAnsi(s));
-  return folded.length > n ? `…[输出过长，已截断头部]\n${folded.slice(-n)}` : folded;
+  if (folded.length <= n) return folded;
+  let t = folded.slice(-n);
+  // 不要把**代理对**劈成两半：BMP 以外的字符（emoji 等）被切一半会渲染成 U+FFFD。
+  // 与 context.js 的同类问题同源（登记簿 BUG-079）。
+  const c0 = t.charCodeAt(0);
+  if (c0 >= 0xdc00 && c0 <= 0xdfff) t = t.slice(1);
+  return `…[输出过长，已截断头部]\n${t}`;
 }
 
 export function runBash(/** @type {any} */ args, /** @type {any} */ ctx) {
@@ -140,15 +220,17 @@ export function runBash(/** @type {any} */ args, /** @type {any} */ ctx) {
       detached: true, // POSIX：自成进程组，超时/结束可整组清理，孙进程不成孤儿
       ...spawnOpts({ piped: true }), // Windows：不 detach + 隐藏控制台（否则每次命令弹一个终端）
     });
-    let out = '';
-    let err = '';
+    // v0.6.3（桌面版 bash 输出乱码，两处根因）：
+    //   ① **不能逐块 `toString()`**：中文 3 字节，被管道切成两半时两半各自解出 U+FFFD（乱码）。
+    //      改为按 **Buffer** 累积、结束时**一次**解码。
+    //   ② **Windows 上这里走的是 `cmd.exe /d /s /c`**，其输出是 OEM 代码页（中文 = GBK/CP936），
+    //      按 UTF-8 解就是花屏（"回访"→"»Ø·Ã"）。故严格 UTF-8 解失败时用 GBK 再解一次。
+    //      Node 官方构建带 full-icu，`new TextDecoder('gbk')` 可用；不支持时退回非严格 UTF-8。
+    const MAX_BYTES = MAX_OUTPUT * 2; // 按字节预留（中文 1 字 ≈ 3 字节）
+    const outCap = createOutputCapture(MAX_BYTES);
+    const errCap = createOutputCapture(MAX_BYTES);
     let done = false;
     let timedOut = false;
-    // 输出增量截断：超长输出只保留尾部，避免内存无限累积
-    const cap = (/** @type {any} */ s, /** @type {any} */ d) => {
-      const t = s + d;
-      return t.length > MAX_OUTPUT * 2 ? t.slice(-MAX_OUTPUT * 2) : t;
-    };
     const killGroup = (/** @type {any} */ sig) => {
       try {
         process.kill(-(/** @type {any} */ (child)).pid, sig);
@@ -175,17 +257,13 @@ export function runBash(/** @type {any} */ args, /** @type {any} */ ctx) {
         timedOut,
         sandbox,
         note: timedOut ? '命令超时，已强杀进程组' : '输出管道未释放，已清理子进程组',
-        stdout: tail(out, MAX_OUTPUT),
-        stderr: tail(err, MAX_OUTPUT),
+        stdout: tail(outCap.text(), MAX_OUTPUT),
+        stderr: tail(errCap.text(), MAX_OUTPUT),
       });
     }, timeoutSec * 1000 + 3000);
 
-    child.stdout.on('data', (d) => {
-      out = cap(out, d);
-    });
-    child.stderr.on('data', (d) => {
-      err = cap(err, d);
-    });
+    child.stdout.on('data', (d) => outCap.push(d));
+    child.stderr.on('data', (d) => errCap.push(d));
     child.on('error', (e) => {
       if (done) return;
       done = true;
@@ -204,8 +282,8 @@ export function runBash(/** @type {any} */ args, /** @type {any} */ ctx) {
         timedOut,
         sandbox,
         note: note || undefined,
-        stdout: tail(out, MAX_OUTPUT),
-        stderr: tail(err, MAX_OUTPUT),
+        stdout: tail(outCap.text(), MAX_OUTPUT),
+        stderr: tail(errCap.text(), MAX_OUTPUT),
       });
     });
   });

package/src/tools/fetch.js

@@ -63,6 +63,28 @@ export function isPrivateHost(/** @type {string} */ hostname) {
   return a === 10 || a === 127 || a === 0 || a >= 224 || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) || (a === 192 && b === 168) || (a === 100 && b >= 64 && b <= 127);
 }
 
+// v0.6.3（P1-8）：**云元数据端点无条件拒绝**——它不属于"内网可信服务"那一类，
+// 任何开关（web.allowPrivateEndpoints / allowPrivate）都不该放行：那里放的是实例凭据。
+// 各家元数据的明文地址（AWS/GCP/Azure/Oracle 169.254.169.254、腾讯 169.254.0.23、
+// 阿里 100.100.100.200、ECS 任务元数据 169.254.170.2、IPv6 fd00:ec2::254）与
+// Google 的 DNS 名。放在这里而不是各调用点，是因为"单一来源"正是这条防线此前的失守方式。
+const METADATA_HOSTS = new Set([
+  '169.254.169.254',
+  '169.254.0.23',
+  '169.254.170.2',
+  '100.100.100.200',
+  'fd00:ec2::254',
+  'metadata.google.internal',
+  'metadata.goog',
+]);
+/** @param {string} hostname */
+export function isMetadataHost(hostname) {
+  const h = String(hostname || '')
+    .toLowerCase()
+    .replace(/^\[|\]$/g, '');
+  return METADATA_HOSTS.has(h);
+}
+
 // IP 字面量判定（含 IPv6）：用于跳过 DNS 复检分支（此前只认点分 IPv4，导致带方括号的 IPv6
 // 字面量被送进 lookup 失败后「放行」）。
 /** @param {string} h */
@@ -81,6 +103,7 @@ export async function runFetch(/** @type {any} */ args, /** @type {any} */ _ctx)
   }
   if (u.protocol !== 'http:' && u.protocol !== 'https:') return { ok: false, error: '仅支持 http/https 地址。' };
   const host = String(u.hostname || '').toLowerCase();
+  if (isMetadataHost(host)) return { ok: false, error: `拒绝访问云元数据端点（${host}）——SSRF 防护，此地址无任何放行开关。` };
   let blocked = isPrivateHost(host);
   if (!blocked && host && host !== 'localhost' && !isIpLiteral(host)) {
     try {
@@ -100,6 +123,7 @@ export async function runFetch(/** @type {any} */ args, /** @type {any} */ _ctx)
     let res = /** @type {any} */ (null);
     for (let hop = 0; hop <= 5; hop++) {
       const ch = String(cur.hostname || '').toLowerCase();
+      if (isMetadataHost(ch)) return { ok: false, error: `拒绝访问云元数据端点（${ch}）——SSRF 重定向防护。` };
       let hopBlocked = isPrivateHost(ch);
       if (!hopBlocked && ch && ch !== 'localhost' && !isIpLiteral(ch)) {
         try {

package/src/web/app.js

@@ -388,7 +388,7 @@ async function send(){
       else if(ev.type==='reasoning'){ if(!reason){ reason=addReasoning(msg); reason.dataset.full=''; } if(!reason.parentElement.open) reason.parentElement.open=true; reason.parentElement.querySelector('summary').classList.add('live'); reason.dataset.full+=ev.delta; const full=reason.dataset.full; reason.textContent=(full.length>9000?full.slice(-9000)+'\n…（思考内容较长，仅显示末尾；已 '+full.length+' 字符）':full); reason.scrollTop=reason.scrollHeight; scroll(); }
       else if(ev.type==='turnStart'){ stepsCount+=1; curSteps+=1; msg._steps=curSteps; curPhase='模型推理中'; msg._traj.push({kind:'turn', t:Date.now()}); showThink(); think.textContent='💭 第 '+msg._steps+' 回合：模型推理中…'; renderWorkStatus(); scroll(); }
       else if(ev.type==='turnEnd'){ curPhase='回合完成，进入下一回合'; showThink(); think.textContent='⏸ 第 '+msg._steps+' 回合完成（累计 '+(ev.toolSteps||0)+' 工具步）· 进入下一回合…'; renderWorkStatus(); }
-      else if(ev.type==='toolStart'){ stepsCount+=1; curSteps+=1; curPhase=ev.name==='task'?'子代理执行中':'执行工具中'; msg._steps=curSteps; msg._traj.push({kind:'tool', seq:ev.seq, name:ev.name, args:ev.args, t:Date.now(), done:false}); onActivity(); update(); renderToolStartEvent(ev); renderWorkStatus(); }
+      else if(ev.type==='toolStart'){ stepsCount+=1; curSteps+=1; curPhase=ev.name==='task'?'子 Agent 执行中':'执行工具中'; msg._steps=curSteps; msg._traj.push({kind:'tool', seq:ev.seq, name:ev.name, args:ev.args, t:Date.now(), done:false}); onActivity(); update(); renderToolStartEvent(ev); renderWorkStatus(); }
       else if(ev.type==='code'){ onActivity(); const pre=document.createElement('pre'); pre.innerHTML='<code>'+highlight(ev.code,ev.lang)+'</code>'; insertBeforeActiveMsg(pre); scroll(); }
       else if(ev.type==='tool'){ onActivity(); update(); const pending=runningTools.get(ev.seq); if(pending){ pending.remove(); runningTools.delete(ev.seq); } const tj=msg._traj.find(x=>x.kind==='tool'&&x.seq===ev.seq); if(tj){ tj.done=true; tj.result=ev.result; tj.durationMs=ev.durationMs; tj.card=pending||null; } if(ev.name==='task'){ sessionSubs.push({seq:ev.seq, question:String(ev.args?.question||ev.args?.prompt||''), result:ev.result, durationMs:ev.durationMs, msg}); renderSubPanel(); } renderToolEvent(ev); }
       else if(ev.type==='toolDenied'){ onActivity(); const tj=msg._traj.find(x=>x.kind==='tool'&&x.seq===ev.seq); if(tj){ tj.done=true; tj.denied=ev.reason||'未授权'; } const d=document.createElement('div'); d.className='errline'; d.textContent='✖ '+(ev.reason==='未授权'||!ev.reason?'未授权':ev.reason)+'：'+ev.name; msg.appendChild(d); scroll(); }
@@ -422,7 +422,7 @@ function renderWorkStatus(){
   let tip='';
   if(generating){
     const secs=curWorkT0?Math.round((Date.now()-curWorkT0)/1000):0;
-    html='<span class="ws-busy"><span class="spinner"></span><span class="ws-phase">'+esc(curPhase)+'</span><span>⏳ 第 '+curSteps+' 步 · '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 · '+curTools+' 工具步'+(curTasks>0?' · '+curTasks+' 个子代理':'')+'</span></span>';
+    html='<span class="ws-busy"><span class="spinner"></span><span class="ws-phase">'+esc(curPhase)+'</span><span>⏳ 第 '+curSteps+' 步 · '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 · '+curTools+' 工具步'+(curTasks>0?' · '+curTasks+' 个子 Agent':'')+'</span></span>';
   } else if(bgRunning>0){
     // 后台任务 chip（非顶部，位于输入框上方）：计数 + 最新任务 + 悬浮详情 tooltip，点击打开详情面板
     const running=bgTasks.filter((/** @type {any} */ t)=>t.status==='running');
@@ -441,7 +441,7 @@ function renderLiveBar(){
   const secs=curWorkT0?Math.round((Date.now()-curWorkT0)/1000):0;
   el.style.display='flex';
   el.innerHTML='<span class="spinner"></span><span class="lb-phase">正在执行：'+esc(curPhase)+'</span>'+
-    '<span class="lb-stat">第 '+curSteps+' 步 · 已 '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 · '+curTools+' 工具步'+(curTasks>0?' · '+curTasks+' 个子代理':'')+'</span>';
+    '<span class="lb-stat">第 '+curSteps+' 步 · 已 '+Math.floor(secs/60)+' 分 '+Math.round(secs%60)+' 秒 · '+curTools+' 工具步'+(curTasks>0?' · '+curTasks+' 个子 Agent':'')+'</span>';
 }
 // 轨迹元行：任务完成后附在本轮消息顶部（步数/子代理数，点击打开轨迹面板）
 function attachTrajMeta(msg){
@@ -450,7 +450,7 @@ function attachTrajMeta(msg){
   const subs=tools.filter(x=>x.name==='task');
   const meta=document.createElement('div'); meta.className='msg-meta';
   const b=document.createElement('button'); b.className='trajBtn';
-  b.textContent='🧭 轨迹：'+(msg._steps||tools.length)+' 步 · '+subs.length+' 个子代理';
+  b.textContent='🧭 轨迹：'+(msg._steps||tools.length)+' 步 · '+subs.length+' 个子 Agent';
   b.onclick=()=>openTraj(msg);
   meta.appendChild(b);
   msg.insertBefore(meta, msg.firstChild);
@@ -459,7 +459,7 @@ function openTraj(msg){
   const list=$('#tjList'); list.innerHTML='';
   const tools=msg._traj.filter(x=>x.kind==='tool');
   const subs=tools.filter(x=>x.name==='task');
-  $('#tjSummary').textContent='（'+(msg._steps||tools.length)+' 步 · '+subs.length+' 个子代理）';
+  $('#tjSummary').textContent='（'+(msg._steps||tools.length)+' 步 · '+subs.length+' 个子 Agent）';
   let turnN=0;
   for(const e of msg._traj){
     if(e.kind==='turn'){ turnN+=1;
@@ -470,7 +470,7 @@ function openTraj(msg){
     const ico={'read':'📄','write':'✏️','edit':'✎','bash':'⚙','grep':'🔎','glob':'🔎','ls':'📁','task':'🤖','skill':'🧩','todo':'☑','undo':'↩'}[e.name]||'🔌';
     const args = e.name==='bash' ? (e.args&&e.args.command) : (e.args&&(e.args.path||e.args.pattern||e.args.name||e.args.question||''))||'';
     const div=document.createElement('div'); div.className='tj-item'+(isSub?' tj-sub':'');
-    const subLabel=isSub?'子代理：':'';
+    const subLabel=isSub?'子 Agent：':'';
     div.innerHTML='<div class="tj-head"><span>'+ico+'</span><span style="white-space:nowrap">'+esc(subLabel+e.name)+'</span><span class="tj-args">'+esc(String(args).slice(0,80))+'</span><span style="margin-left:auto;color:var(--faint)">'+(e.done?(e.denied?'✖ '+esc(e.denied):'✓'+(e.durationMs!=null?' '+e.durationMs+'ms':'')):'执行中…')+'</span></div>';
     const body=document.createElement('div'); body.className='tj-body';
     if(isSub){
@@ -534,7 +534,7 @@ function renderSubPanel(){
     div.onclick=(e)=>{ if(e.target.closest('.sb-body')) return; div.classList.toggle('open'); };
     list.appendChild(div);
   }
-  if(!count) list.innerHTML='<div class="empty" style="color:var(--faint);font-size:12px;padding:10px">本会话还没有子代理（task 工具会派生子代理）</div>';
+  if(!count) list.innerHTML='<div class="empty" style="color:var(--faint);font-size:12px;padding:10px">本会话还没有子 Agent（task 工具会派生子 Agent）</div>';
 }
 const toggleSubPanel=()=>{
   const p=$('#subPanel');

package/src/web/attachments.js

@@ -23,7 +23,13 @@ export function buildUserContent(/** @type {any} */ message, /** @type {any} */
         return { error: `图片过大：${a.name || '未命名'}（单张 ≤5MB）` };
       }
       if (!visionSupported) {
-        return { error: '当前模型不支持图片输入（请切换到 deepseek-v4-flash-vision-exp 或支持视觉的自定义模型）' };
+        return {
+          error:
+            '当前模型不支持图片输入。三种开启方式：' +
+            '① 切换到支持视觉的内置模型（deepseek-v4-flash-vision-exp）；' +
+            '② 在 config.customModels.<模型名>.vision = true 显式声明（纯能力声明，不会改变请求发往哪里）；' +
+            '③ 自定义 Provider 模块（~/.mingdao/providers/<provider>.mjs）里 export const supportsVision = true。',
+        };
       }
       imageParts.push({ type: 'image_url', image_url: { url: dataUrl } });
       persistParts.push(`[图片：${a.name || '未命名'}]`);

package/src/web/index.html

@@ -281,10 +281,10 @@ footer{flex:none;border-top:1px solid var(--border);background:var(--bg2);paddin
 </header>
 <div id="trajRail">
   <button class="rail-btn" id="trajRailBtn" title="轨迹（点击查看详情）">🧭</button>
-  <button class="rail-btn" id="subRailBtn" title="子代理">🤖<span class="rail-badge" id="subBadge" style="display:none"></span></button>
+  <button class="rail-btn" id="subRailBtn" title="子 Agent">🤖<span class="rail-badge" id="subBadge" style="display:none"></span></button>
 </div>
 <aside id="subPanel" style="display:none">
-  <div class="sb-head">🤖 子代理<span id="sbCount" style="font-size:11.5px;color:var(--faint);font-weight:400"></span><button id="sbClose">关闭</button></div>
+  <div class="sb-head">🤖 子 Agent<span id="sbCount" style="font-size:11.5px;color:var(--faint);font-weight:400"></span><button id="sbClose">关闭</button></div>
   <div id="sbList"></div>
 </aside>
 <aside id="trajPanel" style="display:none">

package/src/web/routes/api.js

@@ -40,10 +40,33 @@ export function createApiDispatch(deps) {
       return json(res, 403, { error: 'Host 校验失败：请通过绑定地址访问（DNS rebinding 防护）' });
     }
 
-    // CSRF 防护：跨源请求一律拒绝；POST 仅接受 JSON（拦截表单/纯文本跨站盲提交）。
+    // v0.6.3（H-5 / H-6）：**跨站浏览器请求一律拒绝**。
+    //
+    // 威胁模型：默认 `mingdao web`（回环且未配置令牌）不校验令牌，靠"本机信任"。但浏览器的
+    // 同源策略**不保护本机端口**：任意网页都能用 `<img>` / `fetch(...,{mode:'no-cors'})` 发起
+    // 盲打请求（读不到响应，但副作用已经发生），而这类请求不带 Origin、也无法靠 Content-Type
+    // 拦截——这正是 H-6 里"读取即删除的 GET /api/draft""带外呼的 GET /api/sync?refresh"的真实入口。
+    //
+    // `Sec-Fetch-Site` 是浏览器强制附加的**元数据头**，页面脚本无法伪造（属于 forbidden header）：
+    //   · same-origin —— SPA 自己的请求（正常路径）
+    //   · none        —— 地址栏直接访问 / 书签（正常路径）
+    //   · cross-site  —— 其它站点发起的请求，**含 img/no-cors 盲打**
+    //   · same-site   —— 同站但跨源（如子域）：同样按跨站处理
+    // 因此拒绝 cross-site/same-site 就等于一次性关掉整条浏览器攻击面，且不改任何既有 UX。
+    // 老浏览器不发这个头 → 缺失时按既有策略处理（不引入新的硬依赖）。
+    const site = String(req.headers['sec-fetch-site'] || '').toLowerCase();
+    const isStaticShell = p === '/' || p === '/index.html' || p === '/app.js' || p === '/favicon.ico' || p === '/icon.svg' || p === '/manifest.webmanifest' || p === '/sw.js';
+    const isNavigation = (method === 'GET' || method === 'HEAD') && isStaticShell;
+    if ((site === 'cross-site' || site === 'same-site') && !isNavigation) {
+      return json(res, 403, { error: '跨站请求被拒绝（Sec-Fetch-Site）。请从本机打开 WebUI 地址，不要从其它网页发起请求。' });
+    }
+
+    // CSRF 防护：Origin 校验覆盖**所有方法**（原先只覆盖非 GET）。同源 GET 不带 Origin，
+    // 所以这条扩展不会误伤正常页面；它拦的是"带 Origin 的跨源 GET"（另一种盲打形态）。
+    // POST 另需 JSON Content-Type（拦截表单/纯文本跨站盲提交）。
     // v0.4.7（T21）：HEAD 是安全方法（无请求体），此前落入「必须带 JSON Content-Type」分支 →
     // 对 /api/state 等做 HEAD 探活会拿到 415，破坏监控/反代脚本。与 GET 同等对待。
-    if (method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS') {
+    {
       const origin = req.headers.origin;
       if (origin) {
         try {
@@ -52,6 +75,8 @@ export function createApiDispatch(deps) {
           return json(res, 403, { error: '非法 Origin' });
         }
       }
+    }
+    if (method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS') {
       const ct = String(req.headers['content-type'] || '');
       if (!ct.includes('application/json') && !ct.includes('text/plain')) {
         return json(res, 415, { error: '仅接受 JSON 请求体' });