dsh-mobile-plugin 0.5.19 → 0.5.21

package/lib/routes/canvas-desktop.js

@@ -0,0 +1,196 @@
+'use strict';
+
+/**
+ * 桌面端画布的库读写（`/api/relay/canvas/*`）：本机信任、明文。
+ *
+ * 手机那条走的是 `/api/mobile/v1/canvas/*`，字节过设备加密信封；桌面端这一页由插件在同一个
+ * 源上吐出，同机回环直接用明文 HTTP 就够了，不必也不该把设备凭据搬到桌面。两条路由读写的
+ * 是**同一份库**（`mobile/canvas-store.js`）：清单复用它的两个 handler，字节直接落
+ * `objects/`（盘上本来就是明文）。
+ *
+ * 能力边界：客户端只给域、哈希、字节，给不了任意路径；`file-put` 只按内容哈希落库（去重），
+ * 与手机那条同一口径。
+ */
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { pipeline } = require('node:stream/promises');
+
+const { sendJson, readJsonBody } = require('../shared/http-util');
+const store = require('../mobile/canvas-store');
+
+const MAX_UPLOAD_BYTES = store.MAX_OBJECT_BYTES;
+
+/** POST /api/relay/canvas/file {hash,mimeType} → 原始字节（明文）。 */
+async function handleFileGet(req, res) {
+  const body = await readJsonBody(req, 64 * 1024);
+  const hash = body && typeof body.hash === 'string' ? body.hash : '';
+  const target = store.objectPathOf(hash);
+  if (!target) return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: 'hash 形状不对' } });
+  let stat;
+  try {
+    stat = await fsp.stat(target);
+  } catch {
+    return sendJson(res, 404, { ok: false, error: { code: 'missing', message: '这份字节不在电脑上了' } });
+  }
+  if (!stat.isFile()) return sendJson(res, 404, { ok: false, error: { code: 'missing', message: '这份字节不在电脑上了' } });
+  const mime = body && typeof body.mimeType === 'string' && body.mimeType ? body.mimeType.slice(0, 120) : 'application/octet-stream';
+  res.writeHead(200, { 'content-type': mime, 'content-length': String(stat.size) });
+  try {
+    await pipeline(fs.createReadStream(target), res);
+  } catch {
+    // 头已经发出去了，只能断开让对端按截断处理（与会话文件那条一致）。
+    try { res.destroy(); } catch { /* 连接已关闭 */ }
+  }
+}
+
+/** POST /api/relay/canvas/file-put?name=… 请求体是原始字节 → { hash, bytes }。 */
+async function handleFilePut(req, res) {
+  const temp = path.join(store.rootDir(), `tmp-upload-${crypto.randomBytes(8).toString('hex')}`);
+  await fsp.mkdir(path.dirname(temp), { recursive: true });
+  let total = 0;
+  try {
+    await new Promise((resolve, reject) => {
+      const out = fs.createWriteStream(temp);
+      let aborted = false;
+      req.on('data', (chunk) => {
+        total += chunk.length;
+        if (total > MAX_UPLOAD_BYTES && !aborted) {
+          aborted = true;
+          const error = Object.assign(new Error('这份文件太大，画布库装不下'), { status: 413 });
+          req.unpipe(out);
+          out.destroy();
+          reject(error);
+        }
+      });
+      req.on('error', reject);
+      out.on('error', reject);
+      out.on('finish', resolve);
+      req.pipe(out);
+    });
+    if (total === 0) {
+      try { await fsp.unlink(temp); } catch { /* 已经不在了 */ }
+      return sendJson(res, 400, { ok: false, error: { code: 'empty', message: '请求体里没有字节' } });
+    }
+    const result = await store.storeUploadedFile(temp);
+    return sendJson(res, 200, { ok: true, hash: result.hash, bytes: result.bytes });
+  } catch (error) {
+    try { await fsp.unlink(temp); } catch { /* 已经不在了 */ }
+    if (error && error.status === 413) {
+      return sendJson(res, 413, { ok: false, error: { code: 'too-large', message: error.message } });
+    }
+    return sendJson(res, 500, { ok: false, error: { code: 'upload-failed', message: String((error && error.message) || error) } });
+  }
+}
+
+/** 转发请求体的上限（模型接口带 base64 图的 POST 也不小；给足但别让整份进内存失控）。 */
+const MAX_PROXY_BODY_BYTES = 128 * 1024 * 1024;
+/** 转发时不该带给上游的请求头：跳数头、压缩协商（交给 fetch 自己解压）。 */
+const STRIP_REQUEST_HEADERS = new Set([
+  'host', 'connection', 'accept-encoding', 'content-length', 'transfer-encoding',
+  'origin', 'referer', 'upgrade', 'keep-alive',
+]);
+/** 回给页面时不该带回来的响应头：长度与压缩由这一层重新决定（body 已解压）。 */
+const STRIP_RESPONSE_HEADERS = new Set(['content-encoding', 'content-length', 'transfer-encoding', 'connection', 'keep-alive']);
+
+function readRawBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    req.on('data', (chunk) => {
+      total += chunk.length;
+      if (total > MAX_PROXY_BODY_BYTES) {
+        reject(Object.assign(new Error('请求体太大'), { status: 413 }));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('error', reject);
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+  });
+}
+
+/**
+ * GET/POST /api/relay/canvas/net?u=<上游地址> —— 桌面端画布的本地转发。
+ *
+ * 和手机上那只原生环回服务同一件事：页面以为自己在请求同源地址，插件用 Node 的 fetch 去取
+ * 上游，响应边收边写回。同源请求没有预检；`accept-encoding` 剥掉让 fetch 自己解压，回写时
+ * 再把长度 / 压缩头去掉，body 交给页面按流读（SSE 那条才有用）。
+ */
+async function handleNet(req, res) {
+  let upstreamUrl;
+  try {
+    upstreamUrl = new URL(new URL(req.url, 'http://x').searchParams.get('u') || '');
+  } catch {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '缺少或非法的上游地址' } });
+  }
+  if (upstreamUrl.protocol !== 'http:' && upstreamUrl.protocol !== 'https:') {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '只支持 http / https' } });
+  }
+  const method = (req.method || 'GET').toUpperCase();
+  const headers = {};
+  for (const [name, value] of Object.entries(req.headers)) {
+    if (STRIP_REQUEST_HEADERS.has(name.toLowerCase())) continue;
+    if (value === undefined) continue;
+    headers[name] = Array.isArray(value) ? value.join(', ') : value;
+  }
+  let body;
+  if (method !== 'GET' && method !== 'HEAD') {
+    try {
+      body = await readRawBody(req);
+    } catch (error) {
+      return sendJson(res, error && error.status === 413 ? 413 : 400, { ok: false, error: { code: 'bad-request', message: String((error && error.message) || error) } });
+    }
+  }
+  let upstream;
+  try {
+    upstream = await fetch(upstreamUrl, { method, headers, body, redirect: 'follow' });
+  } catch (error) {
+    // 上游根本没连上：回一个带标记的 502，页面据此还原成网络错误（与手机那条一致）。
+    res.writeHead(502, { 'content-type': 'application/json', 'x-dsh-net-error': '1' });
+    return res.end(JSON.stringify({ ok: false, error: { code: 'network', message: String((error && error.message) || error) } }));
+  }
+  const outHeaders = {};
+  for (const [name, value] of upstream.headers.entries()) {
+    if (STRIP_RESPONSE_HEADERS.has(name.toLowerCase())) continue;
+    outHeaders[name] = value;
+  }
+  res.writeHead(upstream.status, outHeaders);
+  if (!upstream.body) return res.end();
+  try {
+    const reader = upstream.body.getReader();
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!res.write(Buffer.from(value))) {
+        await new Promise((resolve) => res.once('drain', resolve));
+      }
+    }
+    res.end();
+  } catch {
+    try { res.destroy(); } catch { /* 连接已关闭 */ }
+  }
+}
+
+/**
+ * 挂四条桌面端画布数据路由。`ctx` 原样转给 canvas-store 的 handler（它们目前不用它）。
+ *
+ * @param {{ registerRoute: Function, localOnly: Function, ctx?: object }} deps
+ */
+function registerCanvasDesktopRoutes({ registerRoute, localOnly, ctx = null }) {
+  const manifestGet = localOnly('GET', (req, res) => store.handleCanvasManifestGet(ctx, req, res));
+  const manifestSave = localOnly('POST', (req, res) => store.handleCanvasManifestSave(ctx, req, res));
+  const fileGet = localOnly('POST', (req, res) => handleFileGet(req, res));
+  const filePut = localOnly('POST', (req, res) => handleFilePut(req, res));
+  const net = localOnly(['GET', 'POST'], (req, res) => handleNet(req, res));
+  registerRoute({ kind: 'exact', path: '/api/relay/canvas/manifest', handler: manifestGet });
+  registerRoute({ kind: 'exact', path: '/api/relay/canvas/manifest/save', handler: manifestSave });
+  registerRoute({ kind: 'exact', path: '/api/relay/canvas/file', handler: fileGet });
+  registerRoute({ kind: 'exact', path: '/api/relay/canvas/file-put', handler: filePut });
+  registerRoute({ kind: 'exact', path: '/api/relay/canvas/net', handler: net });
+}
+
+module.exports = { registerCanvasDesktopRoutes };

package/lib/routes/control-plane.js

@@ -53,6 +53,8 @@ const { clearCompletionForAllDevices, invalidateSessionList } = require('../mobi
 const { recordSessionRead } = require('../mobile/session-last-turn.js');
 // 收件目录的占用与清理：和移动端那条路由是同一份实现（`lib/mobile/inbox-clean.js`）。
 const { scanInbox, clearInbox, usageView, setAutoClear } = require('../mobile/inbox-clean.js');
+// 桌面端画布的库读写（本机明文，与手机共用同一份 `mobile/canvas-store.js`）。
+const { registerCanvasDesktopRoutes } = require('./canvas-desktop.js');
 
 /** 一次 desktop-read 上报最多带多少个会话 id（防灌爆；客户端半边一次最多也就几个）。 */
 const MAX_DESKTOP_READ_IDS = 200;
@@ -107,6 +109,12 @@ function createWebAccessLocalOnly({ localOnly, trustedLocalUi, webAccessWindow,
  * 版本的页面。改版式只有一条路：`React/` 里重建 → 提交产物 → 发新版本 → 完整重启 DSH。
  */
 const PANEL_FILE = path.join(__dirname, '..', 'panel', 'index.html');
+/**
+ * 桌面端画布页：与 `lib/panel/index.html` 同一个做法 —— 整页内联 HTML 整份吐给浏览器。
+ * 产物由 App 的 `scripts/build-canvas-page.mjs` 从同一份 `vendor/canvas/` 顺带生成过来，
+ * 源只有一份；这里只读不构建。
+ */
+const CANVAS_FILE = path.join(__dirname, '..', 'canvas-app.html');
 
 /** 插件包根（`<pkg>/lib/routes` 往上两级）：诊断时读它的 `package.json` 与 `React/`。 */
 const PACKAGE_DIR = path.join(__dirname, '..', '..');
@@ -129,6 +137,7 @@ function generationVersion() {
 
 /** 按 mtime 缓存：文件被换掉之后内容变了，缓存自然失效，不必手工清。 */
 let panelCache = { file: '', mtime: -1, html: '' };
+let canvasCache = { file: '', mtime: -1, html: '' };
 
 function panelHtml() {
   try {
@@ -142,6 +151,18 @@ function panelHtml() {
   }
 }
 
+function canvasHtml() {
+  try {
+    const stat = fs.statSync(CANVAS_FILE);
+    if (canvasCache.file === CANVAS_FILE && canvasCache.mtime === stat.mtimeMs) return canvasCache.html;
+    const html = fs.readFileSync(CANVAS_FILE, 'utf8');
+    canvasCache = { file: CANVAS_FILE, mtime: stat.mtimeMs, html };
+    return html;
+  } catch {
+    return '';
+  }
+}
+
 /**
  * 面板读不到时，说清楚是哪一种读不到。
  *
@@ -488,6 +509,7 @@ function registerControlPlaneRoutes(deps) {
   //   /api/relay/panel            看宿主记的「配没配过」，自己决定先走引导还是直接进主页
   //   /api/relay/panel/setup      强制走引导（想再看一遍流程时用）
   //   /api/relay/panel/settings   强制进主页（演示 / 排查时跳过引导）
+  //   /api/relay/panel/debug      强制进调试页（桌面端那颗手机图标点开的就是它）
   // 整页 HTML 不需要 token，但这几条仍然走 localOnly —— 它读的是本机运维界面，
   // 而局域网与中转那两条链路本来就不该看到它（它们带 dsh_pair/dsh_lan 凭据，会被挡掉）。
   const servePanel = (res) => {
@@ -506,6 +528,32 @@ function registerControlPlaneRoutes(deps) {
   registerRoute({ kind: 'exact', path: '/api/relay/panel', handler: localOnly('GET', async (_req, res) => servePanel(res), { allowDocumentNavigation: true }) })
   registerRoute({ kind: 'exact', path: '/api/relay/panel/setup', handler: localOnly('GET', async (_req, res) => servePanel(res), { allowDocumentNavigation: true }) })
   registerRoute({ kind: 'exact', path: '/api/relay/panel/settings', handler: localOnly('GET', async (_req, res) => servePanel(res), { allowDocumentNavigation: true }) })
+  // 调试页与上面几条吐同一份 HTML，分流同样在 React 侧（`React/src/Root.tsx` 认 `/debug`）。
+  //
+  // 为什么它也放开 `allowDocumentNavigation`：这一页唯一的入口是桌面端那颗手机图标弹的窗
+  // （同源 iframe），而社区桌面壳会把接住的链接原地打开、从自定义协议页跳过来必带
+  // `sec-fetch-site: cross-site` —— 与面板页同一条理由。页面本身仍是只读 HTML，
+  // 里面的 fetch 照样被 localOnly 与两小时窗口挡着。
+  registerRoute({ kind: 'exact', path: '/api/relay/panel/debug', handler: localOnly('GET', async (_req, res) => servePanel(res), { allowDocumentNavigation: true }) })
+  // 桌面端画布页：整页吐同一份内联 HTML，并在 `</head>` 前补一句「这是桌面端」的标记 ——
+  // 画布据此把路由从 BrowserRouter 换成 HashRouter（它被挂在 `/api/relay/canvas` 这种非根
+  // 路径下，BrowserRouter 的 `/` 匹配不上会 404）。手机 WebView 那份不带这个标记，一个字不改。
+  const serveCanvas = (res) => {
+    const html = canvasHtml();
+    if (!html) {
+      process.stderr.write(`[dsh-mobile-plugin] canvas page unavailable ${CANVAS_FILE}\n`);
+      return sendJson(res, 500, { ok: false, error: { code: 'canvas_missing', message: '画布页产物不在：跑 node scripts/build-canvas-page.mjs 重新生成' } });
+    }
+    const withFlag = html.replace(
+      '</head>',
+      '<script>window.__dshCanvasDesktop=true;window.__dshCanvasHostBase=location.origin;</script></head>',
+    );
+    return sendHtml(res, 200, withFlag);
+  };
+  registerRoute({ kind: 'exact', path: '/api/relay/canvas', handler: localOnly('GET', async (_req, res) => serveCanvas(res), { allowDocumentNavigation: true }) })
+  // 桌面端画布的库读写：本机信任、明文，与手机 `/api/mobile/v1/canvas/*` 共用同一份存储
+  // （`mobile/canvas-store.js`）。桌面这一页是同源的，字节没必要再过设备加密信封。
+  registerCanvasDesktopRoutes({ registerRoute, localOnly, ctx })
   // 桌面端工作区视图（侧栏展开态）的回传/读取。桌面端只把展开态记在浏览器
   // localStorage 里，宿主进程读不到，只能由页面内的客户端半边（lib/client.js）
   // 每 2s 变了就 POST 到这里；App 再经 /api/mobile/v1/desktop-view 取走。
@@ -1036,6 +1084,7 @@ const WEB_ACCESS_ROUTES = new Set([
   '/api/relay/panel',
   '/api/relay/panel/setup',
   '/api/relay/panel/settings',
+  '/api/relay/panel/debug',
   '/api/relay/faults',
   // 配对二维码：里面是能派生整条链路密钥的一次性票据，所以它只在两小时窗口开着时给网页看
   // ——窗口由本机设置页亲手开，服务器部署没有「本机屏幕」可看，这条是它唯一的出口。

package/lib/routes/mobile-api.js

@@ -34,6 +34,7 @@ const hostSettings = require('../mobile/host-settings.js');
 const channels = require('../mobile/channels.js');
 const modelCaps = require('../mobile/model-caps.js');
 const deepSeekAccount = require('../mobile/deepseek-account.js');
+const magpieWeb = require('../mobile/magpie-web.js');
 const skills = require('../mobile/skills.js');
 const mobileCredentials = require('../mobile/credentials.js');
 const subagents = require('../mobile/subagents.js');
@@ -426,6 +427,11 @@ function registerMobileRoutes(deps) {
   route('/api/mobile/v1/host-settings', hostSettings.handleHostSettings)
   // DeepSeek 账号只读投影：账户资料、钱包余额与官方用量/充值链接；不开放登录操作或凭据。
   route('/api/mobile/v1/deepseek-account', deepSeekAccount.handleDeepSeekAccount)
+  // magpie 自带的网页版（Agents / Providers / Routing / Usage / Settings 全在里面）。
+  // 手机那边把这一页整个嵌进来，不再自己画一套：它本来就是给手机做的，页面里写着
+  // 「加到主屏后作为独立 App 打开」。网页版是独立进程，没在跑就在这里替用户拉起来。
+  // key 是凭据，所以走 guarded，与 `host-web` 那条同一个口径。
+  route('/api/mobile/v1/magpie/web', magpieWeb.handleMagpieWeb)
   // 改设置：与桌面端同一个 settings.mutate（按路径寻址的 op + expectedRevision 乐观并发）。
   route('/api/mobile/v1/host-settings/mutate', hostSettings.handleHostSettingsMutate)
   route('/api/mobile/v1/llm/providers', hostSettings.handleLlmProviders)

package/lib/session-cleanup.cjs

@@ -316,7 +316,7 @@ function restoreQueuedArchivedClearIds(ctx) {
   return queued
 }
 
-async function pruneOrphanedArchivedSessions(ctx) {
+async function pruneOrphanedArchivedSessions(ctx, skip) {
   const workspaceList = ctx && ctx.apiProxy && ctx.apiProxy.workspace ? ctx.apiProxy.workspace.list : undefined
   if (typeof workspaceList !== 'function') return 0
   const rpcId = 'dsh-mobile-plugin-archive-prune'
@@ -325,7 +325,8 @@ async function pruneOrphanedArchivedSessions(ctx) {
   const archived = value && Array.isArray(value.archivedSessionIds)
     ? value.archivedSessionIds.filter((id) => typeof id === 'string' && id)
     : []
-  const orphans = await archivedIdsWithoutLogs(archived)
+  const skipped = skip instanceof Set ? skip : new Set(Array.isArray(skip) ? skip : [])
+  const orphans = (await archivedIdsWithoutLogs(archived)).filter((id) => !skipped.has(id))
   if (orphans.length === 0) return 0
   const failed = await forgetArchivedSessions(ctx, orphans, rpcId)
   return orphans.length - failed.length
@@ -339,10 +340,12 @@ async function pruneOrphanedArchivedSessions(ctx) {
  *    就是一次未捕获的 ENOENT，宿主直接退出。
  *  - **擦归档集合**：桌面端的会话列表是「连上宿主时拉的一份快照 + 之后的事件增量」，
  *    进程活着的时候擦集合，宿主会把「归档集合变了」广播给桌面端，桌面端就把它快照里
- *    那些其实已经没有日志、本来被归档藏着的行放回正常列表 —— 用户报的正是「清理后
- *    它们又回来了，重启 DSH 才真的消失」。启动时快照本来就从磁盘重新拉，擦掉不会放出
- *    任何行。留在集合里的死 id 不显示在任何地方：「已归档」取的是会话列表与归档集合
- *    的交集，没有日志就没有那一行。
+ *    那些其实已经没有日志、本来被归档藏着的行放回正常列表。所以只在启动时擦，而且**本次
+ *    刚删掉日志的 id 这一轮也先不擦**：宿主启动和删日志是并发的，桌面端的快照完全可能
+ *    在删完之前就取走、把这些行带在身上；这时擦集合照样会把它们放回正常列表（一次重启
+ *    之后它们又出现，再重启才消失）。留到下一次启动再擦，那时它们早已没有日志，任何新
+ *    快照里都不会再有这些行。留在集合里的死 id 依然不显示：「已归档」取的是会话列表与
+ *    归档集合的交集，没有日志就没有那一行。
  *
  * 用进程级标记而不是模块变量：代际热替换会重跑 apply，而桌面端那条快照挂在同一个进程上。
  */
@@ -352,9 +355,21 @@ const PRUNE_RETRY_MS = 500
 async function pruneOrphanedArchivedSessionsOnce(ctx, log) {
   if (globalThis[PRUNE_ONCE]) return
   globalThis[PRUNE_ONCE] = true
+  // 本次启动前盘上就已经没有数据的 id：它们早就不在任何新快照里，这一轮可以直接擦。
+  const alreadyDataLess = new Set(sessionIdsWithoutAnyData(readPendingArchivedClearIds()))
+  let skip = []
   // 删日志不碰宿主，先做：越早越好，别等宿主把 workspace 服务挂齐（那时桌面端可能已经连上）。
   try {
     const { deleted, kept } = await deleteQueuedArchivedSessions(log, ctx)
+    // 本次刚删掉日志的 id，这一轮先别擦归档集合，留到下一次启动再擦。
+    //
+    // 桌面端的会话列表是「启动时拉的一份快照 + 之后的事件增量」，宿主没有删除会话的接口，
+    // 插件在磁盘上删日志它看不见 —— 它快照里还留着这些行，本来靠「已归档」藏着。这时一擦
+    // 集合，宿主就广播「归档集合变了」，桌面端把这些其实已经没有日志的行放回正常列表，用户
+    // 看到的就是「重启一次它们又回来了」。留到下一次启动：那时它们早就没有日志，任何新快照
+    // 里都不会再有这些行，擦集合的广播也就放不出东西来。代价是这些空 id 在归档集合里多留
+    // 一次启动（「已归档」取会话列表与归档集合的交集，没有日志就看不见它）。
+    skip = deleted.filter((id) => !alreadyDataLess.has(id))
     if (deleted.length > 0) log?.(`archived clear queue: deleted ${deleted.length} session logs`)
     if (kept.length > 0) log?.(`archived clear queue: ${kept.length} session logs kept for the next start`)
   } catch (error) {
@@ -365,7 +380,7 @@ async function pruneOrphanedArchivedSessionsOnce(ctx, log) {
   // 的死 id 一直没人清（实测宿主重启过一次，315 个没有日志的 id 原样挂着）。
   for (let attempt = 1; attempt <= PRUNE_ATTEMPTS; attempt += 1) {
     try {
-      const pruned = await pruneOrphanedArchivedSessions(ctx)
+      const pruned = await pruneOrphanedArchivedSessions(ctx, skip)
       if (pruned > 0) log?.(`archived session prune: dropped ${pruned} deleted session ids`)
       return
     } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.5.19",
+  "version": "0.5.21",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (dsh 0.2.x, peers resolved by the host)",
   "license": "MIT",
   "icon": "./icon.png",