dsh-mobile-plugin 0.1.100 → 0.2.1

package/lib/mobile/uploads.js

@@ -40,8 +40,11 @@ const { sendJson, readJsonBody } = require('../shared/http-util');
 const CHUNK_BYTES = 256 * 1024;
 // 片大小的上限（原始字节）：base64 后约 2.73MB，仍在下面 8MB 的请求体预算内。
 const CHUNK_MAX_BYTES = 2 * 1024 * 1024;
-/** 单片请求体上限：4MB base64 后约 5.33MB，留出信封与转义余量。 */
-const CHUNK_MAX_BODY = 8 * 1024 * 1024;
+/**
+ * 单片请求体上限（**明文**字节）：4MB base64 后约 5.33MB，再按 §8.3(9) 的 4/3 信封
+ * 放大到 11MB —— 按线上长度直接卡 8MB 等于悄悄砍掉四分之一的可用额度。
+ */
+const CHUNK_MAX_BODY = Math.ceil(8 * 1024 * 1024 * 4 / 3);
 /** 文件名上限（按字符算，避开各文件系统的字节上限差异）。 */
 const NAME_MAX_CHARS = 120;
 /** 暂存残片的最长寿命：手机上传中断后没人来 abort 的清理依据。 */
@@ -49,6 +52,44 @@ const STAGING_TTL_MS = 24 * 60 * 60 * 1000;
 /** 分片必须是标准 base64：Node 的 Buffer.from 会静默丢弃非法字符，光靠解码判不出坏片。 */
 const BASE64_RE = /^[A-Za-z0-9+/]*={0,2}$/;
 
+/**
+ * 刚落盘的上传：uploadId → { path, name, bytes, at }。
+ *
+ * 存在的理由：`session/send` 以前只认内联 base64 的图片块，一张 4MB 照片线上要
+ * 7MB 左右，而那条请求的预算只有 8 秒 —— 大图必超时。现在图片先走分片上传（每片都
+ * 落在预算内），再在 send 里用 uploadId 换字节。这张表就是那个「换」的凭据。
+ *
+ * 只在内存里、30 分钟过期、条数封顶：过期之后手机重传一次就行，不留长期文件索引。
+ */
+const finishedUploads = new Map();
+const FINISHED_TTL_MS = 30 * 60 * 1000;
+const FINISHED_MAX = 64;
+
+function rememberFinishedUpload(uploadId, record) {
+  if (!uploadId) return;
+  finishedUploads.set(uploadId, { ...record, at: Date.now() });
+  if (finishedUploads.size > FINISHED_MAX) {
+    const oldest = [...finishedUploads.entries()].sort((a, b) => a[1].at - b[1].at).slice(0, finishedUploads.size - FINISHED_MAX);
+    for (const [key] of oldest) finishedUploads.delete(key);
+  }
+}
+
+/**
+ * 按 uploadId 取刚落盘的上传。过期 / 不存在返回 null。
+ *
+ * @returns {{ path: string, name: string, bytes: number } | null}
+ */
+function resolveFinishedUpload(uploadId) {
+  const id = String(uploadId || '');
+  const record = finishedUploads.get(id);
+  if (!record) return null;
+  if (Date.now() - record.at > FINISHED_TTL_MS) {
+    finishedUploads.delete(id);
+    return null;
+  }
+  return { path: record.path, name: record.name, bytes: record.bytes };
+}
+
 /** 进行中的上传：uploadId → { name, stagingPath, received, bytes, expiresAt, expiryTimer }。 */
 const uploads = new Map();
 
@@ -240,12 +281,22 @@ async function handleUploadChunk(_ctx, req, res) {
   sendJson(res, 200, { ok: true, received: job.received });
 }
 
-/** POST /api/mobile/v1/upload/finish { uploadId } → { ok, path, name, bytes }。 */
+/** POST /api/mobile/v1/upload/finish { uploadId } → { ok, path, name, bytes }。
+ *
+ * **同一 uploadId 再收一次是回放，不是新上传**：落盘（rename）已经做完、回包却在路上丢了
+ * 的时候，手机那边只能再收一次 —— 那一发必须拿回第一次的那份结果，否则它会把一次成功的
+ * 上传判成失败、让用户白传一遍整个文件。认不出的 uploadId 仍然 404（不能靠「新建一个空
+ * 上传」蒙过去）。
+ */
 async function handleUploadFinish(_ctx, req, res) {
   const body = await readJsonBody(req);
   const uploadId = String((body && body.uploadId) || '');
   const job = uploads.get(uploadId);
-  if (!job) return fail(res, 404, 'unknown-upload', '上传会话不存在或已结束');
+  if (!job) {
+    const replay = resolveFinishedUpload(uploadId);
+    if (replay) return sendJson(res, 200, { ok: true, ...replay, uploadId });
+    return fail(res, 404, 'unknown-upload', '上传会话不存在或已结束');
+  }
   removeUpload(uploadId, job);
 
   const dir = path.join(inboxRoot(), today());
@@ -253,7 +304,9 @@ async function handleUploadFinish(_ctx, req, res) {
     await fsp.mkdir(dir, { recursive: true });
     const target = await uniquePath(dir, job.name);
     await fsp.rename(job.stagingPath, target);
-    sendJson(res, 200, { ok: true, path: target, name: path.basename(target), bytes: job.bytes });
+    // 记住这一份：发送图片时用它把「分片上传的字节」换回内联块，见 resolveFinishedUpload。
+    rememberFinishedUpload(uploadId, { path: target, name: path.basename(target), bytes: job.bytes });
+    sendJson(res, 200, { ok: true, path: target, name: path.basename(target), bytes: job.bytes, uploadId });
   } catch (error) {
     try { await fsp.unlink(job.stagingPath); } catch { /* 已经不在了 */ }
     return fail(res, 500, 'inbox-unavailable', `落盘失败：${error.message}`);
@@ -272,6 +325,37 @@ async function handleUploadAbort(_ctx, req, res) {
   sendJson(res, 200, { ok: true });
 }
 
+/** 一张图片的明文上限：超过就按「传太大」拒，而不是把宿主内存撑爆。 */
+const MAX_IMAGE_UPLOAD_BYTES = 10 * 1024 * 1024;
+
+const UPLOAD_EXPIRED_MESSAGE = '这张图片的上传已过期，请重新发送';
+
+/**
+ * 把 content 里带 `uploadId` 的图片块补成内联 base64。
+ *
+ * 宿主的 `session.prompt` 只认 `{type:'image', mediaType, data}`，所以这一步要在宿主
+ * 那一跳之前完成：手机到宿主这一段只传 uploadId，字节早就在分片上传时落盘了。
+ *
+ * @returns {Promise<string|null>} 有块补不上就回一句给用户看的话，全补上了回 null。
+ */
+async function inlineUploadedImageBlocks(content) {
+  for (const block of content) {
+    if (!block || block.type !== 'image') continue;
+    if (typeof block.data === 'string' && block.data) continue;
+    const record = resolveFinishedUpload(block.uploadId);
+    if (!record) return UPLOAD_EXPIRED_MESSAGE;
+    try {
+      const bytes = await fsp.readFile(record.path);
+      if (!bytes.length || bytes.length > MAX_IMAGE_UPLOAD_BYTES) return UPLOAD_EXPIRED_MESSAGE;
+      block.data = bytes.toString('base64');
+      if (!block.name) block.name = record.name;
+    } catch {
+      return UPLOAD_EXPIRED_MESSAGE;
+    }
+  }
+  return null;
+}
+
 module.exports = {
   handleUploadBegin,
   handleUploadChunk,
@@ -284,4 +368,6 @@ module.exports = {
   STAGING_TTL_MS,
   CHUNK_BYTES,
   CHUNK_MAX_BYTES,
+  resolveFinishedUpload,
+  inlineUploadedImageBlocks,
 };

package/lib/mobile/workspaces.js

@@ -17,6 +17,9 @@
 const { sendJson, readJsonBody } = require('../shared/http-util');
 const { isFreshRequest } = require('../shared/fresh-request');
 const { stableRevision, unchangedListBody } = require('../shared/list-revision.js');
+const { listSignal: sharedListSignal } = require('../shared/list-signal.js');
+// 条件刷新要记的那几样按 ctx 隔离：这类模块级状态只许住在 session-cache.js。
+const { workspaceShortcutStateOf } = require('./session-cache.js');
 // 会话列表缓存归 sessions.js 管。归档/移动会话会改变列表行本身，必须让那边立刻失效，
 // 否则手机端按完「归档会话」，那一行最长 10 秒还留在侧栏里，看着像没归档。
 const { invalidateSessionList } = require('./sessions.js');
@@ -51,17 +54,25 @@ async function attachGitMarkers(items, options) {
     if (!item || typeof item !== 'object') return item;
     const path = typeof item.path === 'string' ? item.path.trim() : '';
     if (!path) return item;
-    return { ...item, git: await describeProjectGit(path, options) };
+    const marker = await describeProjectGit(path, options);
+    // 手机上只用到「是不是仓库」「仓库根在哪」（侧栏入口的可见性与跳转参数），分支
+    // 留在里面是因为它参与 revision、换分支确实该让镜像更新。**并列仓库清单不下发**：
+    // 一份最多二十条、每条带着仓库/子模块/worktree 的路径与身份，而 Git 页是自己现查的，
+    // 这份数组在列表响应里纯属白占字节。
+    return {
+      ...item,
+      git: { isRepo: marker.isRepo, root: marker.root, branch: marker.branch },
+    };
   }));
 }
 
 /**
  * 构建工作区快照 body（供移动端镜像同步推送复用）。
  *
- * `archivedSessionIds` 必须原样透传：宿主 `workspace.list` 一直在返回它，
- * 但此前这里只保留 `items`，把它整个丢掉。于是 App 点完「归档会话」拿不到任何
- * 归档状态，侧边栏那一行永远不消失——归档在移动端表现为一次没有反馈的空操作。
- * 它同时也是将来做「取消归档」入口的唯一数据来源。
+ * 归档集合（宿主 `workspace.list` 的 `archivedSessionIds`）**只参与 revision 计算，
+ * 不再下发**：App 从来没有读过这个字段（归档会话由 `/sessions` 直接剔除，取消归档走
+ * 单独的写接口），而它是一份可能几十 KB 的纯字符串数组 —— 每发一次完整工作区快照就白传
+ * 一次。留在 revision 里是为了「仅归档集合变化」也能判成新版本，镜像该更新还得更新。
  *
  * `options.fresh` 透传给仓库识别，跳过它那 15 秒的目录缓存（写后刷新 / 下拉刷新）。
  */
@@ -90,18 +101,20 @@ async function buildWorkspacesBody(ctx, options = {}) {
   return {
     ok: true,
     items: marked,
-    archivedSessionIds,
     // 与 sessions 快照同款的新鲜度/空态契约（见 lib/mobile/sessions.js 的说明）：
     // App 把 generatedAt + revision 存进快照用于展示「数据时间」，emptyConfirmed
     // 让「用户真的删光了工作区」不必再靠连续两次空去猜。
     generatedAt: Date.now(),
-    // 归档集合也是工作区快照语义的一部分；仅它变化时也必须让镜像推送判为新版本。
-    // 仓库标记也在里面：换分支是这份快照的一部分，变了就该推新版本。
+    // 归档集合也算进 revision：仅它变化时也必须让镜像推送判为新版本。
+    // 仓库标记只保留下发的那三格；并列仓库清单不进 revision、也不再随清单下发。
     revision: stableRevision({ items: marked, archivedSessionIds }),
     emptyConfirmed: marked.length === 0,
   };
 }
 
+/** 短路状态的最长信任时间：只是兜底，工作区信号一涨就会被判失效。 */
+const WORKSPACE_SHORTCUT_MAX_AGE_MS = 5 * 60 * 1000;
+
 /**
  * GET /api/mobile/v1/workspaces?rev=<上次的 revision>（token）
  *
@@ -117,7 +130,25 @@ async function handleWorkspaces(ctx, req, res) {
   const fresh = isFreshRequest(req.url);
   // 仓库识别也认这一个 `fresh`：写后刷新 / 下拉刷新必须看见刚新建的仓库，
   // 不能被识别那 15 秒的目录缓存挡回去。
+  //
+  // 构建前短路：这份响应里有 `archivedSessionIds`（一份几十 KB 的数组），每 15 秒重建
+  // 一次纯属白费。与 `/sessions` 同一条判据：客户端 rev 命中的那份没变、工作区信号没涨、
+  // 而且真有观众（推送调度器在跑，信号才可信）。
+  const cache = workspaceShortcutStateOf(ctx);
+  if (!fresh && rev && sharedListSignal.watching()) {
+    const current = sharedListSignal.workspaceSnapshot().revision;
+    if (cache.lastRevision === rev && cache.lastSignalRevision === current
+      && Date.now() - cache.lastBuiltAt <= WORKSPACE_SHORTCUT_MAX_AGE_MS) {
+      return sendJson(res, 200, { ok: true, unchanged: true, revision: rev, generatedAt: cache.lastGeneratedAt });
+    }
+  }
   const body = await buildWorkspacesBody(ctx, { fresh });
+  if (body && typeof body.revision === 'string' && body.revision) {
+    cache.lastRevision = body.revision;
+    cache.lastGeneratedAt = body.generatedAt;
+    cache.lastSignalRevision = sharedListSignal.workspaceSnapshot().revision;
+    cache.lastBuiltAt = Date.now();
+  }
   const unchanged = fresh ? null : unchangedListBody(body, rev);
   sendJson(res, 200, unchanged || body);
 }