dsh-mobile-plugin 0.5.28 → 0.5.29

package/lib/mobile/extension-catalog.js

@@ -27,7 +27,9 @@ const CATALOG_FILE = 'catalog.json';
 const SLUG_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
 /** 整包上限：与开发包同一档，太重的包手机也不该整份拉。 */
 const MAX_PACKAGE_BYTES = 20 * 1024 * 1024;
-const MAX_PACKAGE_FILES = 200;
+// 2026-11-08 从 200 抬到 400：整份网页前端做成的扩展（例如 magpie）光图标就一两百个、
+// 按名字动态引用删不得，260 多个文件是常态；400 仍挡得住离谱的大包。
+const MAX_PACKAGE_FILES = 400;
 /** 单个文件上限：一条 base64 响应要塞进手机内存，再大就不该走这条路。 */
 const MAX_FILE_BYTES = 8 * 1024 * 1024;
 
@@ -158,6 +160,12 @@ function listPackages(root) {
       apiVersion: textField(manifest.apiVersion, textField(manifest.api_version, '1')),
       releaseNotes: entry.releaseNotes,
       capabilities: capabilitiesOf(manifest.capabilities),
+      // 取数声明一起下发：手机上「已装记录」里若缺这一项（早期版本装下的包），App 用当前电脑上
+      // 这一份清单把老记录补上，页面才不会把 /api/… 解析成 file://… 而永远转圈。只下发声明，
+      // 不在这里做任何放行判断（真正的边界在 extension-data.js 的服务登记表里）。
+      hostData: manifest.hostData && typeof manifest.hostData === 'object' && !Array.isArray(manifest.hostData)
+        ? manifest.hostData
+        : null,
       size: acc.bytes,
       fileCount: acc.files.length,
       files: acc.files,
@@ -176,6 +184,37 @@ async function handleCatalog(_ctx, _req, res, root = catalogRoot()) {
   sendJson(res, 200, { ok: true, packages: listPackages(root) });
 }
 
+/**
+ * GET /api/mobile/v1/extension/catalog/archive?slug=…（token）
+ *
+ * 整包一次下发：把一个已审核扩展的 **zip** 整个回成 base64。手机下载一个包、本地解包，
+ * 不再按文件逐个拉几百次（那正是「269 次往返、两三百 KB/s」的病根）。zip 由产包脚本放在
+ * `<root>/<slug>.zip`（与 slug 目录平级，不属于任何一包的文件清单）。
+ *
+ * 审核闸门与取单文件一致：没登记进 catalog.json 的 slug 一律 404。zip 体积按包上限兜住。
+ */
+async function handleCatalogArchive(_ctx, req, res, root = catalogRoot()) {
+  const url = new URL(req.url || '/', 'http://x');
+  const slug = (url.searchParams.get('slug') || '').trim();
+  if (!slug || !SLUG_PATTERN.test(slug)) {
+    return fail(res, 400, 'bad-request', '需要合法的 slug');
+  }
+  if (!readCatalog(root).some((entry) => entry.slug === slug)) {
+    return fail(res, 404, 'package-missing', `审核清单里没有 ${slug} 这个包`);
+  }
+  const zipPath = path.join(root, `${slug}.zip`);
+  let raw;
+  try {
+    const stat = fs.statSync(zipPath);
+    if (stat.size > MAX_PACKAGE_BYTES) return fail(res, 413, 'package-too-large', `${slug}.zip 超过整包上限`);
+    raw = fs.readFileSync(zipPath);
+  } catch {
+    // 没有 zip 不算错误：老插件 / 没打 zip 的包照旧走逐文件那条（App 侧会回退）。
+    return fail(res, 404, 'archive-missing', `${slug} 没有整包 zip，走逐文件下载`);
+  }
+  sendJson(res, 200, { ok: true, slug, size: raw.length, sha256: sha256Hex(raw), content: raw.toString('base64') });
+}
+
 /**
  * GET /api/mobile/v1/extension/catalog/file?slug=…&path=…（token）
  *
@@ -238,6 +277,7 @@ module.exports = {
   listPackages,
   handleCatalog,
   handleCatalogFile,
+  handleCatalogArchive,
   MAX_PACKAGE_BYTES,
   MAX_PACKAGE_FILES,
   MAX_FILE_BYTES,

package/lib/mobile/extension-data.js

@@ -0,0 +1,224 @@
+'use strict';
+
+/**
+ * 扩展页「读宿主数据」那条通道的宿主侧（能力 `host.data`）。
+ *
+ * **为什么需要这一层**：扩展页是从手机本地 `file://` 加载的网页，它自己的 `fetch` 够不到
+ * 这台电脑上的服务——跨源、还要凭据。声明了 `hostData` 的扩展把命中的请求（例如 `/api/`）
+ * 交给 App，App 转到这里，由宿主**以自己人身份**去问目标服务，再把结果原样递回去。
+ *
+ * **这是通用通道，不是给 magpie 开的专口子**：`SERVICES` 是一张登记表，键是扩展包里声明的
+ * 服务名；要接一个新后台，在这一张表里登记一个服务即可，App 侧与协议一个字都不用改。
+ * 每个服务自己负责「怎么找到它、怎么带凭据」，以及「允许访问哪些路径前缀」（`allow`）——
+ * 一个服务只该被够到它自己的那部分路径，别拿它当跳板去够同端口的别处。
+ *
+ * **边界仍然收着**：只有配好对的手机（这条路由在 token 守卫之后）能调；只能到登记过的服务；
+ * 路径必须落在该服务的 `allow` 前缀内；不暴露 shell、系统设置、任意文件读写。请求体与响应体
+ * 都有限长，超了如实回错，不硬吃进内存。
+ *
+ * 纯 Node（http + 文件），无 cordis 依赖，测试可以直接 require 走假服务。
+ */
+
+const http = require('node:http');
+
+const { sendJson, readJsonBody } = require('../shared/http-util');
+const { ensureWeb } = require('./magpie-web.js');
+
+/** 请求体的上限：扩展页发来的是「一条请求」，几个 KB 的 JSON 足够，2MB 已经很宽松。 */
+const MAX_REQUEST_BYTES = 2 * 1024 * 1024;
+/** 响应体的上限：几百 KB 是常态（magpie 供应商列表就 324KB），给到 16MB 兜住异常大包。 */
+const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+/** 一条代理请求的总时限。目标都是本机服务，慢到这份上就是它自己卡住了。 */
+const REQUEST_TIMEOUT_MS = 20000;
+/** 只放行这几种方法：读、写、删各一个，别的一律当非法。 */
+const METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']);
+
+/** 拿 cookie 的结果缓存（端口 + key → { cookie, at }），同一把 key 不必每发一个请求都换一次。 */
+const cookieCache = new Map();
+const COOKIE_TTL_MS = 60 * 1000;
+
+/**
+ * 服务登记表。键＝扩展包里 `hostData.service` 写的名字。
+ *
+ * 每个服务：
+ *  - `allow`：允许被够到的路径前缀（都相对该服务的 origin）；
+ *  - `resolve()`：返回 `{ port, key }`，即这个服务此刻在哪、用什么凭据；
+ *  - `cookie(port, key)`：把凭据换成请求要带的 `Cookie`（没有就返回空串）。
+ *
+ * magpie 先登记在这儿。以后接别的后台，在这里加一项即可。
+ */
+const SERVICES = {
+  magpie: {
+    allow: ['/api/'],
+    async resolve() {
+      const entry = await ensureWeb({});
+      if (!entry || !entry.available) {
+        const error = new Error('service-unavailable');
+        error.code = 'service-unavailable';
+        error.reason = entry && entry.reason ? entry.reason : 'unavailable';
+        throw error;
+      }
+      return { port: entry.port, key: entry.key };
+    },
+    async cookie(port, key) {
+      return magpieCookie(port, key);
+    },
+  },
+};
+
+/**
+ * magpie 网页版的登录那一跳：`GET /?k=<key>` 会 303 并 `Set-Cookie`，把 key 换成一张 cookie。
+ * 后面每条 `/api/*` 都靠这张 cookie 认证。取不到就回空串（各接口会按 401 如实回，页面能看到）。
+ */
+function magpieCookie(port, key) {
+  const cacheKey = `${port}:${key}`;
+  const hit = cookieCache.get(cacheKey);
+  if (hit && Date.now() - hit.at < COOKIE_TTL_MS) return Promise.resolve(hit.cookie);
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (cookie) => {
+      if (done) return;
+      done = true;
+      try { req.destroy(); } catch { /* 已经断了 */ }
+      if (cookie) cookieCache.set(cacheKey, { cookie, at: Date.now() });
+      resolve(cookie);
+    };
+    const req = http.request({
+      host: '127.0.0.1',
+      port,
+      path: `/?k=${encodeURIComponent(key)}`,
+      method: 'GET',
+      timeout: 5000,
+    }, (res) => {
+      const raw = res.headers['set-cookie'];
+      res.resume();
+      if (!raw || !raw.length) return finish('');
+      // 只取 `name=value` 那一段，属性（Path/HttpOnly…）不进请求头。
+      finish(String(raw[0]).split(';')[0]);
+    });
+    req.on('timeout', () => finish(''));
+    req.on('error', () => finish(''));
+    req.end();
+  });
+}
+
+/** 只要这几项响应头：页面解析正文够用了，别把一整套头也搬来搬去。 */
+function pickHeaders(headers) {
+  const out = {};
+  if (headers && typeof headers['content-type'] === 'string') out['content-type'] = headers['content-type'];
+  return out;
+}
+
+/** 把一条请求原样代发到目标服务，收集状态码 / 头 / 正文（utf8）。失败回 0 + 一段错误正文。 */
+function proxyRequest(port, cookie, method, path, body, contentType) {
+  return new Promise((resolve) => {
+    const headers = { accept: 'application/json, */*' };
+    if (cookie) headers.cookie = cookie;
+    const hasBody = typeof body === 'string' && body.length > 0;
+    if (hasBody) {
+      headers['content-type'] = contentType || 'application/json';
+      headers['content-length'] = Buffer.byteLength(body);
+    }
+    let done = false;
+    const finish = (result) => {
+      if (done) return;
+      done = true;
+      resolve(result);
+    };
+    const req = http.request({
+      host: '127.0.0.1',
+      port,
+      path,
+      method,
+      headers,
+      timeout: REQUEST_TIMEOUT_MS,
+    }, (res) => {
+      const chunks = [];
+      let total = 0;
+      res.on('data', (chunk) => {
+        total += chunk.length;
+        if (total > MAX_RESPONSE_BYTES) {
+          req.destroy();
+          finish({ status: 0, headers: {}, body: JSON.stringify({ code: 'response-too-large' }) });
+          return;
+        }
+        chunks.push(chunk);
+      });
+      res.on('end', () => finish({
+        status: res.statusCode || 0,
+        headers: pickHeaders(res.headers),
+        body: Buffer.concat(chunks).toString('utf8'),
+      }));
+      res.on('error', (error) => finish({ status: 0, headers: {}, body: JSON.stringify({ code: 'response-failed', message: String(error.message || error) }) }));
+    });
+    req.on('timeout', () => {
+      req.destroy();
+      finish({ status: 0, headers: {}, body: JSON.stringify({ code: 'timeout' }) });
+    });
+    req.on('error', (error) => finish({ status: 0, headers: {}, body: JSON.stringify({ code: 'request-failed', message: String(error.message || error) }) }));
+    if (hasBody) req.write(body);
+    req.end();
+  });
+}
+
+/** 一个失败但形状正常的回包：App 侧永远读 `{ status, headers, body }` 这套字段。 */
+function failure(res, status, code, message) {
+  return sendJson(res, 200, {
+    ok: false,
+    status,
+    headers: {},
+    body: JSON.stringify({ code, message }),
+    code,
+    ...(message === undefined ? {} : { message }),
+  });
+}
+
+/**
+ * POST /api/mobile/v1/extension/data（token）
+ * body: { service, path, method?, body?, contentType? }
+ *
+ * 只有登记过的服务、落在它 `allow` 前缀内的路径才放行。目标服务的状态码 / 头 / 正文原样带回，
+ * 让扩展页像对待一个普通 Response 一样对待它（4xx / 5xx 也照原样，页面自己判断）。
+ */
+async function handleExtensionData(_ctx, req, res) {
+  const body = await readJsonBody(req, MAX_REQUEST_BYTES);
+  if (!body || typeof body.service !== 'string' || typeof body.path !== 'string') {
+    return failure(res, 400, 'bad-request', '需要 { service, path }');
+  }
+  const service = body.service.trim();
+  const spec = SERVICES[service];
+  if (!spec) return failure(res, 404, 'service-unknown', `没有登记这个服务：${service}`);
+
+  const method = typeof body.method === 'string' ? body.method.trim().toUpperCase() : 'GET';
+  if (!METHODS.has(method)) return failure(res, 400, 'bad-method', `不支持的方法：${method}`);
+
+  const path = body.path.trim();
+  if (!path.startsWith('/') || path.startsWith('//')) return failure(res, 400, 'bad-path', '路径必须是本源内的绝对路径');
+  const pathname = path.split('?')[0];
+  if (spec.allow.length > 0 && !spec.allow.some((prefix) => pathname.startsWith(prefix))) {
+    return failure(res, 403, 'path-not-allowed', `这个服务不开放该路径：${pathname}`);
+  }
+
+  let target;
+  try {
+    target = await spec.resolve();
+  } catch (error) {
+    return failure(res, 503, 'service-unavailable', `${service} 现在不可用：${(error && error.reason) || 'unavailable'}`);
+  }
+
+  let cookie = '';
+  if (typeof spec.cookie === 'function') {
+    try { cookie = await spec.cookie(target.port, target.key); } catch { cookie = ''; }
+  }
+  const reqBody = typeof body.body === 'string' ? body.body : undefined;
+  const contentType = typeof body.contentType === 'string' ? body.contentType : undefined;
+  const result = await proxyRequest(target.port, cookie, method, path, reqBody, contentType);
+  sendJson(res, 200, { ok: true, status: result.status, headers: result.headers, body: result.body });
+}
+
+module.exports = {
+  handleExtensionData,
+  SERVICES,
+  MAX_REQUEST_BYTES,
+  MAX_RESPONSE_BYTES,
+};

package/lib/mobile/extension-dev.js

@@ -28,7 +28,9 @@ const DEV_ROOT_NAME = 'extension-dev';
 const SLUG_PATTERN = /^[A-Za-z0-9._-]{1,64}$/;
 /** 整包上限：这是「现读现看」的通道，不是分发管道，太重的包手机也不该整份拉。 */
 const MAX_PACKAGE_BYTES = 20 * 1024 * 1024;
-const MAX_PACKAGE_FILES = 200;
+// 2026-11-08 从 200 抬到 400：整份网页前端做成的扩展（例如 magpie）光图标就一两百个、
+// 按名字动态引用删不得，260 多个文件是常态；400 仍挡得住离谱的大包。
+const MAX_PACKAGE_FILES = 400;
 /** 单个文件上限：一条 base64 响应要塞进手机内存，再大就该走别的路（发布到分发系统）。 */
 const MAX_FILE_BYTES = 8 * 1024 * 1024;
 

package/lib/mobile/file-ops.js

@@ -0,0 +1,252 @@
+'use strict';
+
+/**
+ * 右栏文件浏览器的写操作：新建、删除、重命名。三条都只在「允许区」里动 —— 与
+ * `file-read.js` 同一条判据（宿主已登记的工作区 ∪ 当前会话的项目目录），不碰整台电脑。
+ *
+ * 与 `uploads.js` 的关系：那条负责「把手机上一份文件传进来」（分片、续传、加密信封），
+ * 落点同样受 `allowed-zone` 约束；这里是「已经在右栏里了，就地新建一个空文件 / 改个名字 /
+ * 删掉」。两者都不提供「任意路径写」，能力面没有放宽。
+ *
+ * 四条边界：
+ * 1. `path` 必须是绝对路径，且 `resolve` 之后的落点在允许区内。`..` 爬出去按最终落点算，
+ *    一律 403。判定与 `file-read.js` 共用 `allowed-zone.js`，不另抄一份。
+ * 2. **符号链接不逃逸**：只比字符串不够 —— `工作区/软链目录/x` 字面上在工作区里，物理上可能
+ *    指到工作区外。所以写之前先 `realpath` 目标所在的父目录，要求它落在某个「realpath 之后
+ *    的根」里。删除时先 `lstat`：目标是符号链接就拒绝（既不删链接本身、也绝不顺着删链接指向
+ *    的文件）。
+ * 3. 新建不能凭空替换别人的文件：目标已存在时默认 409，要 `overwrite: true` 才覆盖；覆盖前
+ *    仍然拒绝符号链接与目录。父目录必须已经存在（建目录走 `directory-browse.js` 的
+ *    `directory/create`），这条不顺手递归 `mkdir` —— 少一层就少一处能爬出允许区的路径。
+ * 4. 不写 shell，全程 `node:fs/promises`。
+ */
+
+const { writeFile, unlink, rename, lstat, realpath } = require('node:fs/promises');
+const path = require('node:path');
+
+const { sendJson, readJsonBody } = require('../shared/http-util');
+const { allowedRoots, inAllowedZone } = require('./allowed-zone.js');
+
+const FILE_PATH_MAX = 4096;             // 绝对路径长度上限
+const FILE_NAME_MAX = 255;              // 单个文件名上限（多数文件系统同值）
+const FILE_MAX_CONTENT_BYTES = 256 * 1024; // 新建时正文上限（文本文件；更大的走上传）
+
+/** 400 / 403 / 404 / 409 等统一错误体。 */
+function sendError(res, status, code, message) {
+  sendJson(res, status, { ok: false, error: { code, message } });
+}
+
+/** 解析并按允许区校验请求里的 `path`，同时确认「父目录的物理落点」也在允许区里。 */
+async function preparePath(ctx, body, res) {
+  const declared = body && typeof body.path === 'string' ? body.path.trim() : '';
+  const sessionId = body && typeof body.sessionId === 'string' ? body.sessionId.trim() : '';
+
+  if (!declared) {
+    sendError(res, 400, 'bad-request', '需要 { path }（绝对路径）');
+    return null;
+  }
+  if (!path.isAbsolute(declared)) {
+    sendError(res, 400, 'bad-request', 'path 必须是绝对路径');
+    return null;
+  }
+  if (declared.length > FILE_PATH_MAX) {
+    sendError(res, 400, 'bad-request', 'path 太长');
+    return null;
+  }
+
+  const target = path.resolve(declared);
+
+  let roots;
+  try {
+    roots = await allowedRoots(ctx, sessionId);
+  } catch (error) {
+    // 宿主那句原话回给手机：这条路上「没取到」与「你没有这个目录」必须分得开。
+    sendFailure(res, error);
+    return null;
+  }
+  if (!inAllowedZone(roots, target)) {
+    sendError(res, 403, 'outside-allowed', '这个位置不在能改的范围里（只放行工作区目录和这条会话的项目目录）');
+    return null;
+  }
+
+  const parent = path.dirname(target);
+  let realParent;
+  try {
+    realParent = await realpath(parent);
+  } catch {
+    sendError(res, 404, 'parent-missing', '上级目录不在这台电脑上');
+    return null;
+  }
+  const realRoots = await realRootsOf(roots);
+  if (!inAllowedZone(realRoots, realParent)) {
+    sendError(res, 403, 'outside-allowed', '上级目录的物理位置不在允许区里（可能经过了符号链接）');
+    return null;
+  }
+  return { target, parent, roots };
+}
+
+/** 允许区每个根 realpath 之后的样子；解析不了的根直接跳过（跳过是缩小范围）。 */
+async function realRootsOf(roots) {
+  const resolved = await Promise.all(roots.map((root) => realpath(root).catch(() => null)));
+  return resolved.filter((root) => typeof root === 'string');
+}
+
+/** 502：宿主工作区清单读取失败，把宿主原话转给手机。 */
+function sendFailure(res, error) {
+  sendJson(res, 502, {
+    ok: false,
+    error: {
+      code: (error && error.code) || 'workspace-list-failed',
+      message: String((error && error.message) || error),
+    },
+  });
+}
+
+/**
+ * POST /api/mobile/v1/file/create
+ * body { path（绝对）, sessionId?, content?, overwrite? }
+ */
+async function handleFileCreate(ctx, req, res) {
+  const body = (await readJsonBody(req)) || {};
+  const prepared = await preparePath(ctx, body, res);
+  if (!prepared) return;
+  const { target } = prepared;
+
+  const content = typeof body.content === 'string' ? body.content : (body.content == null ? '' : null);
+  if (content === null) return sendError(res, 400, 'invalid-content', 'content 必须是字符串');
+  const bytes = Buffer.byteLength(content, 'utf8');
+  if (bytes > FILE_MAX_CONTENT_BYTES) {
+    return sendError(res, 413, 'too-large', '文件太大，手机这边不支持一次性新建这么大的文件');
+  }
+
+  let existing = null;
+  try {
+    existing = await lstat(target);
+  } catch {
+    existing = null;
+  }
+  if (existing) {
+    if (existing.isSymbolicLink()) return sendError(res, 400, 'symlink-refused', '这是一个符号链接，不在这里新建或覆盖');
+    if (existing.isDirectory()) return sendError(res, 400, 'not-a-file', '这条路径已经是一个目录');
+    if (!body.overwrite) return sendError(res, 409, 'file-exists', '同名文件已经存在');
+  }
+
+  try {
+    await writeFile(target, content, { encoding: 'utf8', flag: existing ? 'w' : 'wx' });
+  } catch (error) {
+    if (error && error.code === 'EEXIST') return sendError(res, 409, 'file-exists', '同名文件已经存在');
+    return sendError(res, 502, 'write-failed', `写文件失败：${String((error && error.message) || error)}`);
+  }
+
+  sendJson(res, 200, {
+    ok: true,
+    path: target,
+    created: !existing,
+    overwritten: !!existing,
+    bytes,
+  });
+}
+
+/**
+ * POST /api/mobile/v1/file/delete
+ * body { path（绝对）, sessionId? }
+ */
+async function handleFileDelete(ctx, req, res) {
+  const body = (await readJsonBody(req)) || {};
+  const prepared = await preparePath(ctx, body, res);
+  if (!prepared) return;
+  const { target } = prepared;
+
+  let info;
+  try {
+    info = await lstat(target);
+  } catch {
+    return sendError(res, 404, 'missing', '这个文件已经不在这台电脑上了');
+  }
+  if (info.isSymbolicLink()) {
+    // 既不移除链接、也绝不顺着链接去删它指向的文件。
+    return sendError(res, 400, 'symlink-refused', '这是一个符号链接，不删除');
+  }
+  if (!info.isFile()) {
+    return sendError(res, 400, 'not-a-file', '这条路径不是一个文件');
+  }
+
+  try {
+    await unlink(target);
+  } catch (error) {
+    return sendError(res, 502, 'delete-failed', `删除失败：${String((error && error.message) || error)}`);
+  }
+  sendJson(res, 200, { ok: true, path: target, deleted: true });
+}
+
+/** 单个路径段：非空、不是 . / ..、不含分隔符、不过长。 */
+function validSegment(name) {
+  if (typeof name !== 'string') return '';
+  const text = name.trim();
+  if (!text || text === '.' || text === '..' || /[/\\]/.test(text)) return '';
+  if (text.length > FILE_NAME_MAX) return '';
+  return text;
+}
+
+/**
+ * POST /api/mobile/v1/file/rename
+ * body { path（绝对，原路径）, name（新文件名，单段）, sessionId?, overwrite? }
+ *
+ * 只做同目录改名（`name` 是单个路径段），不实现跨目录移动 —— 移动会把「源」和「目标」两个
+ * 落点都变成要各自校验的东西，改名只是在同一个已校验的父目录里换一个名字。
+ */
+async function handleFileRename(ctx, req, res) {
+  const body = (await readJsonBody(req)) || {};
+  const prepared = await preparePath(ctx, body, res);
+  if (!prepared) return;
+  const { target, parent, roots } = prepared;
+
+  const name = validSegment(body.name);
+  if (!name) return sendError(res, 400, 'invalid-name', 'name 必须是单个文件名（不含路径分隔符）');
+
+  let source;
+  try {
+    source = await lstat(target);
+  } catch {
+    return sendError(res, 404, 'missing', '这个文件已经不在这台电脑上了');
+  }
+  if (source.isDirectory()) return sendError(res, 400, 'not-a-file', '这条路径是一个目录，不在这里改名');
+
+  const destination = path.join(parent, name);
+  if (!inAllowedZone(roots, destination)) {
+    // 正常到不了：name 是单段、parent 已校验。留着是防「以后有人把 name 放宽成相对路径」。
+    return sendError(res, 403, 'outside-allowed', '改名后的位置不在允许区里');
+  }
+  if (destination === target) {
+    return sendJson(res, 200, { ok: true, path: target, from: target, renamed: false });
+  }
+
+  let destinationInfo = null;
+  try {
+    destinationInfo = await lstat(destination);
+  } catch {
+    destinationInfo = null;
+  }
+  if (destinationInfo) {
+    if (!body.overwrite) return sendError(res, 409, 'file-exists', '目标名字已经有文件了');
+    if (destinationInfo.isSymbolicLink()) return sendError(res, 400, 'symlink-refused', '目标是一个符号链接，不覆盖');
+    if (destinationInfo.isDirectory()) return sendError(res, 400, 'not-a-file', '目标名字已经是一个目录');
+  }
+
+  try {
+    await rename(target, destination);
+  } catch (error) {
+    return sendError(res, 502, 'rename-failed', `改名失败：${String((error && error.message) || error)}`);
+  }
+  sendJson(res, 200, { ok: true, path: destination, from: target, renamed: true });
+}
+
+module.exports = {
+  FILE_PATH_MAX,
+  FILE_NAME_MAX,
+  FILE_MAX_CONTENT_BYTES,
+  validSegment,
+  handleFileCreate,
+  handleFileDelete,
+  handleFileRename,
+};

package/lib/mobile/history-derive.js

@@ -296,6 +296,73 @@ function writtenPaths(content, toolResults) {
 }
 
 /** 从结构块里拼接纯文本（列表预览/标题回退用，仍只取 text 块）。 */
+/**
+ * 系统内部注入的 source.kind：不画成「已注入上下文」行（与 App 侧 structuralItems 同一张名单）。
+ * 这些不是用户可读的普通上下文，一直隐藏；撤销「隐藏普通 Context 注入」不该把它们翻出来。
+ */
+const HIDDEN_CONTEXT_SOURCE_KINDS = new Set(['tool-jobs', 'time-context', 'subagent-settled', 'runtime-context']);
+
+/** 上下文注入的来源展示名（桌面 `ContextMessageNode.producer.label` 的等价读取）。 */
+function contextProducerLabel(source) {
+  const stringsOf = (list, field) => {
+    if (!Array.isArray(list)) return '';
+    const out = [];
+    for (const entry of list) {
+      if (!entry || typeof entry !== 'object') continue;
+      const value = entry[field];
+      if (typeof value === 'string' && value !== '') out.push(value);
+    }
+    return out.join(', ');
+  };
+  if (source.kind === 'session-reference') return stringsOf(source.references, 'label');
+  if (source.kind === 'agent-instructions') return stringsOf(source.changes, 'path');
+  if (source.kind === 'skill-invocation' && typeof source.name === 'string') return source.name;
+  return typeof source.kind === 'string' ? source.kind : '';
+}
+
+/**
+ * 把一条 `user/message`（source.kind 非 user / 非 schedule / 非压缩检查点）折成上下文注入行。
+ * 不是这类消息、或没内容、或是内部系统注入时返回 null。
+ *
+ * 与 App 侧 `structuralItems.contextItemFromEvent` 同一判据、同一组字段 —— 直播与历史两侧口径
+ * 必须一致，否则同一条注入在重进会话后消失或换样。
+ */
+function contextItemOf(msg, e) {
+  const src = msg.source;
+  if (!src || typeof src !== 'object') return null;
+  const kind = src.kind;
+  if (kind === undefined || kind === 'user') return null;
+  if (kind === 'schedule') return null;
+  if (kind === 'plugin' && src.plugin === 'compact') return null;
+  if (typeof kind === 'string' && HIDDEN_CONTEXT_SOURCE_KINDS.has(kind)) return null;
+  const content = Array.isArray(msg.content) ? msg.content : [];
+  const texts = [];
+  const added = [];
+  const removed = [];
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    if (block.type === 'text' && typeof block.text === 'string') texts.push(block.text);
+    else if (block.type === 'tool-addition' && typeof block.toolName === 'string') added.push(block.toolName);
+    else if (block.type === 'tool-removal' && typeof block.toolName === 'string') removed.push(block.toolName);
+  }
+  const text = texts.join('');
+  const hasTools = added.length > 0 || removed.length > 0;
+  if (text.trim() === '' && !hasTools) return null;
+  const label = contextProducerLabel(src);
+  return {
+    id: String(msg.id),
+    kind: 'context',
+    text: '',
+    seq: e.seq,
+    time: e.time,
+    ...(text !== '' ? { contextText: text } : {}),
+    ...(label !== '' ? { contextLabel: label } : {}),
+    ...(kind === 'session-reference' ? { contextRecall: true } : {}),
+    ...(hasTools ? { contextTools: { added, removed } } : {}),
+    ...(e.data && typeof e.data.turn === 'number' ? { turn: e.data.turn } : {}),
+  };
+}
+
 function blocksToText(blocks) {
   return blocks.filter((b) => b.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n');
 }
@@ -728,8 +795,11 @@ function deriveMessages(events, sessionId, lookbackEvents) {
         continue;
       }
       if (src && typeof src === 'object' && src.kind !== 'user') {
-        // 上下文注入/召回（session-reference→召回，其余 kind→注入）：桌面 `isVisibleChatNode`
-        // 只放行携带 tool-addition/tool-removal 的上下文节点，这类提示一律不显示 —— 不下发。
+        // 上下文注入 / 召回（session-reference→召回，其余 kind→注入）。上游 2026-11-03 撤销了
+        // 「隐藏普通 Context 注入」，这类节点现在要**下发**成一条 kind:'context' 的折叠行；
+        // 系统内部注入（tool-jobs / time-context 等）仍由 contextItemOf 挡掉，别漏成用户气泡。
+        const contextItem = contextItemOf(msg, e);
+        if (contextItem) out.push(contextItem);
         continue;
       }
       // 普通用户消息（source 缺失或 kind==='user'）沿用原折叠。
@@ -1023,10 +1093,16 @@ function deriveMessages(events, sessionId, lookbackEvents) {
  */
 const ENTRY_OUTCOME_TOOLS = new Set(['schedule_create', 'exit_plan_mode', 'extension_present']);
 
-/** 一轮的起点：用户自己发的消息，或定时任务唤醒的那一行。 */
+/**
+ * 一轮的起点：用户自己发的消息、定时任务唤醒的那一行，或一条上下文注入行。
+ *
+ * 上下文注入也算起点：会话开头那串 agent-instructions 之类就发生在第一条用户消息之前，
+ * 不认它当起点时入口窗口会把这「半组」当成没有起点的残段整组裁掉（thinning 那条「凭空冒出
+ * 的发言」规则），注入行就永远看不到。认了之后它自带起点、照常保留。
+ */
 function isEntryTurnOpener(item) {
   return Boolean(item) && typeof item === 'object'
-    && (item.role === 'user' || item.kind === 'wake');
+    && (item.role === 'user' || item.kind === 'wake' || item.kind === 'context');
 }
 
 function thinEntryMessages(items, options = {}) {