dsh-mobile-plugin 0.4.1 → 0.4.4

package/lib/mobile/file-read.js

@@ -0,0 +1,168 @@
+'use strict';
+
+/**
+ * 按路径读文件（POST /api/mobile/v1/file/read）：右栏文件浏览器「点开一个文件」。
+ *
+ * 与 `/session/file` 的分工：那条服务的是**交付**（卡片、正文里的文件链接），放行面是
+ * 「本会话工作区 ∪ 本轮 present 声明过的路径」；右栏能一路翻到别的已登记工作区，手里的
+ * 就是一串路径，所以这条按 `allowed-zone.js` 判：宿主已登记的工作区 ∪ 当前会话的项目目录。
+ *
+ * 三条边界：
+ * 1. `path` 必须是绝对路径 —— 这条路由没有可信的解析基准，相对路径直接 400，不去猜谁当基准。
+ *    判定用的是 resolve 之后的落点，`..` 爬出允许区一律不认（403 `outside-allowed`）。
+ * 2. 认出允许区之后的失败分开报：盘上没有 404 `missing`、不是普通文件 400 `not-a-file`、
+ *    超过 512MB 413 `too-large`。码与文案跟 `/session/file` 同一套，App 那边一套分支就够。
+ * 3. 字节流式回写，不在插件进程里缓冲。协议 v2 的分块信封**直接调 `/session/file` 那个写入
+ *    函数**：两边抄一份形状必然漂，而漂了的症状是「手机上永远下载中」，没有报错。
+ */
+
+const fs = require('node:fs');
+const { stat } = require('node:fs/promises');
+const path = require('node:path');
+const { pipeline } = require('node:stream/promises');
+
+const { sendJson, readJsonBody } = require('../shared/http-util');
+const { allowedRoots, inAllowedZone } = require('./allowed-zone.js');
+const { writeEncryptedFile, SESSION_FILE_MAX_BYTES } = require('./session-file.js');
+
+/**
+ * 扩展名 → 内容类型。与 `session-file.js` 那张表逐条相同：两条路给同一个文件必须给出同一个
+ * `content-type`，否则 App 那边「按类型决定怎么预览」的分支会看端点选，等于多一种行为。
+ */
+const MEDIA_TYPES = Object.freeze({
+  mp4: 'video/mp4', m4v: 'video/mp4', mov: 'video/quicktime', webm: 'video/webm',
+  mp3: 'audio/mpeg', m4a: 'audio/mp4', wav: 'audio/wav', ogg: 'audio/ogg', flac: 'audio/flac',
+  png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg', gif: 'image/gif',
+  webp: 'image/webp', heic: 'image/heic', bmp: 'image/bmp', svg: 'image/svg+xml',
+  pdf: 'application/pdf',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  zip: 'application/zip', gz: 'application/gzip', tar: 'application/x-tar',
+  json: 'application/json', csv: 'text/csv', html: 'text/html', htm: 'text/html',
+});
+
+const TEXT_EXTENSIONS = new Set([
+  'txt', 'md', 'markdown', 'log', 'json', 'csv', 'tsv', 'html', 'htm', 'css',
+  'js', 'jsx', 'ts', 'tsx', 'mjs', 'cjs', 'py', 'rb', 'go', 'rs', 'java', 'kt',
+  'swift', 'c', 'h', 'cpp', 'sh', 'bash', 'zsh', 'yml', 'yaml', 'toml', 'ini',
+  'conf', 'sql', 'xml', 'svg', 'patch', 'diff',
+]);
+
+/** 取扩展名（小写、不含点）；没有扩展名回空串。 */
+function extensionOf(filePath) {
+  const dot = filePath.lastIndexOf('.');
+  if (dot <= 0 || dot === filePath.length - 1) return '';
+  return filePath.slice(dot + 1).toLowerCase();
+}
+
+/** 回给响应的内容类型：认得出的按表，认不出的按扩展名落文本或 octet-stream。 */
+function mediaTypeOf(filePath) {
+  const ext = extensionOf(filePath);
+  if (MEDIA_TYPES[ext]) return MEDIA_TYPES[ext];
+  if (TEXT_EXTENSIONS.has(ext)) return 'text/plain; charset=utf-8';
+  return 'application/octet-stream';
+}
+
+/**
+ * `content-disposition` 的文件名：头里只能放 ASCII，中文名按 RFC 5987 另给一份
+ * `filename*`。App 不读它（文件名它自己有），留着是给别人抓包时认人用的。
+ */
+function dispositionOf(name) {
+  const ascii = name.replace(/[^\x20-\x7e]/g, '_').replace(/["\\]/g, '_');
+  return `attachment; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(name)}`;
+}
+
+/**
+ * POST { path（绝对）, sessionId? } → 该文件的原始字节。
+ *
+ * @param {object} ctx 插件上下文
+ * @param {object} req node:http IncomingMessage
+ * @param {object} res node:http ServerResponse
+ */
+async function handleFileRead(ctx, req, res) {
+  const body = await readJsonBody(req);
+  const declared = body && typeof body.path === 'string' ? body.path.trim() : '';
+  const sessionId = body && typeof body.sessionId === 'string' ? body.sessionId.trim() : '';
+  if (!declared) {
+    return sendJson(res, 400, { ok: false, error: { code: 'bad-request', message: '需要 { path }（绝对路径）' } });
+  }
+  if (!path.isAbsolute(declared)) {
+    return sendJson(res, 400, {
+      ok: false,
+      error: { code: 'bad-request', message: 'path 必须是绝对路径' },
+    });
+  }
+  const target = path.resolve(declared);
+
+  let roots;
+  try {
+    roots = await allowedRoots(ctx, sessionId);
+  } catch (error) {
+    // 宿主那句原话回给手机：这条路上「没取到」与「你没有这个目录」必须分得开。
+    return sendJson(res, 502, {
+      ok: false,
+      error: {
+        code: (error && error.code) || 'workspace-list-failed',
+        message: String((error && error.message) || error),
+      },
+    });
+  }
+  if (!inAllowedZone(roots, target)) {
+    return sendJson(res, 403, {
+      ok: false,
+      error: { code: 'outside-allowed', message: '这个文件不在能看的范围里（只放行工作区目录和这条会话的项目目录）' },
+    });
+  }
+
+  let info;
+  try {
+    info = await stat(target);
+  } catch {
+    return sendJson(res, 404, { ok: false, error: { code: 'missing', message: '文件已经不在这台电脑上了' } });
+  }
+  if (!info.isFile()) {
+    return sendJson(res, 400, { ok: false, error: { code: 'not-a-file', message: '这条路径不是一个文件' } });
+  }
+  if (info.size > SESSION_FILE_MAX_BYTES) {
+    return sendJson(res, 413, {
+      ok: false,
+      error: { code: 'too-large', message: '这个文件太大，手机这边不支持整份取回' },
+    });
+  }
+
+  const header = {
+    'content-type': mediaTypeOf(target),
+    'content-disposition': dispositionOf(path.basename(target)),
+    'cache-control': 'no-store',
+  };
+
+  // 协议 v2：与 `/session/file` 逐字节同形（`x-dsh-content-type` 带明文类型、chunked，
+  // 真实类型单独给一份让 App 解密后决定怎么预览）。
+  const opened = req && req.__dshE2ee;
+  if (opened && opened.keys && opened.req) {
+    res.writeHead(200, {
+      ...header,
+      'content-type': 'application/x-dsh-e2ee-chunks',
+      'transfer-encoding': 'chunked',
+      'x-dsh-proto': '2',
+      'x-dsh-content-type': header['content-type'],
+    });
+    await writeEncryptedFile(req, res, target, opened);
+    return;
+  }
+
+  res.writeHead(200, { ...header, 'content-length': String(info.size) });
+  if (info.size === 0) return res.end();
+
+  const stream = fs.createReadStream(target);
+  res.on('close', () => stream.destroy());
+  try {
+    await pipeline(stream, res);
+  } catch {
+    // 头已经发出去了，改不了状态码，只能断开让对端按截断处理。
+    try { res.destroy(); } catch { /* 连接已关闭 */ }
+  }
+}
+
+module.exports = { handleFileRead, mediaTypeOf };

package/lib/mobile/history-derive.js

@@ -6,8 +6,13 @@
  * 本模块只做「事件 → 展示结构」的纯计算，不碰 ctx、不发 RPC，因此可以单独测；
  * 原先这些函数与路由 handler 混在 lib/mobile/sessions.js 里（该文件 1964 行），
  * 拆出来后 handler 层只负责 HTTP 与宿主交互。
+ *
+ * 「什么不下发手机」（推理 / 工具参数 / 工具结果正文与 diff）的唯一规则在 `wire-cut.js`，
+ * 这里只负责把留下的事件折成消息结构 —— 直播间那条路调的是同一份。
  */
 
+const { cutAssistantBlock, cutToolResultEvent, createToolNameIndex } = require('./wire-cut.js');
+
 /**
  * 从 session.list 摘要行取会话标题（与桌面端侧栏同源，不再从 history 窗口猜）：
  *  - 优先读 title 投影（dsh-session-title 在「完整日志」上折叠的最新 session/title
@@ -27,55 +32,6 @@ function listTitle(s) {
   return s.sessionId || '';
 }
 
-/** 单文件一行文本的传输上限：整文件 create/overwrite 的 newText 可能极大，超出即截断并标记。 */
-const DIFF_TEXT_MAX_LINES = 400;
-/** 一次工具调用最多回传的 diff 文件数（对齐桌面「一行一张卡」的粒度，避免畸形 meta 撑爆载荷）。 */
-const DIFF_MAX_FILES = 20;
-
-/** 按行数截断一段 diff 文本；未超限原样返回，超限保留前 MAX 行并标记 truncated。 */
-function capDiffText(text) {
-  if (typeof text !== 'string') return undefined;
-  let lines = 0;
-  for (let i = 0; i < text.length; i += 1) {
-    if (text.charCodeAt(i) === 10) lines += 1;
-    if (lines >= DIFF_TEXT_MAX_LINES) {
-      return { text: text.slice(0, i), truncated: true };
-    }
-  }
-  return { text, truncated: false };
-}
-
-/**
- * 收窄 tool/result 的 `data.meta`（write/edit 的 FsDiffMeta）为可回传的 diff 列表。
- *
- * 桌面 diff 卡的数据源头就是这里：fs 工具把「已应用的分块上下文 diff」挂在 `result.meta`
- * 上，随 tool/result 事件持久化。投影只读 message.content 的话 meta 会整个丢掉，App 里
- * write/edit 只剩一坨 JSON 参数。
- *
- * 只接受形状正确的条目（path 非空字符串、newText 字符串、oldText 字符串或 null），畸形数据
- * 返回 undefined 让调用方退回通用卡片，绝不抛错。
- */
-function normalizeResultDiffs(meta) {
-  if (!meta || typeof meta !== 'object' || !Array.isArray(meta.diffs)) return undefined;
-  const out = [];
-  for (const raw of meta.diffs) {
-    if (!raw || typeof raw !== 'object') continue;
-    const path = typeof raw.path === 'string' && raw.path !== '' ? raw.path : undefined;
-    const newText = capDiffText(raw.newText);
-    if (path === undefined || newText === undefined) continue;
-    const oldText = typeof raw.oldText === 'string' ? capDiffText(raw.oldText) : undefined;
-    if (raw.oldText !== null && raw.oldText !== undefined && typeof raw.oldText !== 'string') continue;
-    out.push({
-      path,
-      oldText: oldText === undefined ? null : oldText.text,
-      newText: newText.text,
-      ...newText.truncated || (oldText && oldText.truncated) ? { truncated: true } : {},
-    });
-    if (out.length >= DIFF_MAX_FILES) break;
-  }
-  return out.length > 0 ? out : undefined;
-}
-
 /**
  * tool/result 的可见内容：两种形状都认。
  *
@@ -136,25 +92,32 @@ function toolResultImages(parts) {
   return out;
 }
 
-/** 预扫描 tool/result 事件，构建 callId → {isError, code} 映射（对接桌面 toolRowModel 状态派生）。 */
+/**
+ * 预扫描 tool/result 事件，构建 callId → 状态/图片 映射（对接桌面 toolRowModel 状态派生）。
+ *
+ * 每条结果先过 `wire-cut.js`：正文与结果上的 `meta`（已应用 diff）都不下发，只留状态与图片，
+ * 正文只给定时任务卡要解析的 `schedule_create` 留着。工具名从同一批事件里攒
+ * （`tool/call`、assistant 的 tool-call 块），攒不到就按「不留正文」处理。
+ */
 function buildToolResultMap(events) {
   const map = new Map();
+  const toolNames = createToolNameIndex();
+  toolNames.absorbAll(events);
   for (const entry of events) {
     const e = entry.event || entry;
     if (e.type !== 'tool/result' || !e.data || !e.data.message) continue;
     const msg = e.data.message;
     const src = msg.source;
     if (!src || typeof src.callId !== 'string') continue;
-    const { parts, isError } = toolResultParts(msg);
-    const code = e.data.error && typeof e.data.error.code === 'string' ? e.data.error.code : undefined;
-     const output = parts.map((part) => {
-       if (part && typeof part.text === 'string') return part.text;
-       if (part && typeof part === 'object' && part.type === 'image') return '';
-        try { return JSON.stringify(part); } catch { return ''; }
-     }).filter(Boolean).join('');
-     const images = toolResultImages(parts);
-      const diffs = normalizeResultDiffs(e.data.meta);
-      map.set(src.callId, { isError, code, ...(output ? { output } : {}), ...(images.length ? { images } : {}), ...(diffs ? { diffs } : {}) });
+    const kept = cutToolResultEvent(e, toolNames.nameOf(src.callId));
+    const { parts, isError } = toolResultParts(kept.data.message);
+    const code = kept.data.error && typeof kept.data.error.code === 'string' ? kept.data.error.code : undefined;
+    const output = parts.map((part) => {
+      if (part && typeof part.text === 'string') return part.text;
+      return '';
+    }).filter(Boolean).join('');
+    const images = toolResultImages(parts);
+    map.set(src.callId, { isError, code, ...(output ? { output } : {}), ...(images.length ? { images } : {}) });
   }
   return map;
 }
@@ -162,16 +125,14 @@ function buildToolResultMap(events) {
 /**
  * 把整窗工具结果折成客户端补丁（`/session/messages` 顶层的 `toolResults`）。
  *
- * 补丁本身必须取自整个窗口：调用方游标可能已经越过结果 seq，而工具卡还停在 running，
- * 客户端按 callId 幂等打补丁。但**已经随消息块下发的**那份结果不再重复带正文 ——
- * `items` 里的 tool-call 块本来就是同一张表构出来的，输出/图片/diff 再传一遍等于同一份
- * 工具输出在一条响应里走两趟。客户端打补丁时状态照写、正文只在给了的时候才覆盖，所以
+ * 补丁本身必须取自整个窗口：调用方游标可能已经越过结果 seq，而调用块还停在 running，
+ * 客户端按 callId 幂等打补丁。但**已经随消息块下发的**那份结果不再重复带料 ——
+ * `items` 里的 tool-call 块本来就是同一张表构出来的，图片与定时任务卡要的那份正文再传一遍
+ * 等于同一份内容在一条响应里走两趟。客户端打补丁时状态照写、料只在给了的时候才覆盖，所以
  * 那几格省掉是安全的；消息块不在这份窗口里时才带全。
  *
  * `bodies: false`（增量拉取）连「消息块不在这份窗口里」的那些也只回状态。理由是同一个：
- * 增量拉取的调用方手上已经有一份完整的会话，缺的只是「这几次调用结束了没有」；把整窗的
- * 工具输出再灌一遍，等于每 15 秒把最近两百条消息里的工具输出重发一次（读文件、跑命令的
- * 输出几十到几百 KB 很常见）。要全文的那条路是入口整份拉取（无游标）与展开时重新拉。
+ * 增量拉取的调用方手上已经有一份完整的会话，缺的只是「这几次调用结束了没有」。
  */
 function toolResultPatchesFor(events, items, options = {}) {
   const bodies = options.bodies !== false;
@@ -192,24 +153,20 @@ function toolResultPatchesFor(events, items, options = {}) {
       state,
       ...(result.output ? { output: result.output } : {}),
       ...(result.images && result.images.length ? { images: result.images } : {}),
-      ...(result.diffs && result.diffs.length ? { diffs: result.diffs } : {}),
     };
   });
 }
 
-/** 把 assistant message.content 解析为一个结构块数组（text/reasoning/tool-call/image）。 */
+/** 把 assistant message.content 解析为一个结构块数组（text/tool-call/image）。 */
 function parseBlocks(blocks, toolResults) {
   if (!Array.isArray(blocks)) return [];
   const out = [];
-  for (const b of blocks) {
+  for (const raw of blocks) {
+    // 推理不下发、tool-call 收成骨架（三张轮尾卡的工具留 arguments）—— 与直播间同一条规则。
+    const b = cutAssistantBlock(raw);
     if (!b || typeof b.type !== 'string') continue;
     if (b.type === 'text' && typeof b.text === 'string' && b.text) {
       out.push({ type: 'text', text: b.text });
-    } else if (b.type === 'reasoning') {
-      // Reasoning blocks may be emitted as empty placeholders when the provider
-      // does not expose chain-of-thought. They are known blocks, not unsupported
-      // content; silently omit empty placeholders and avoid leaking their JSON.
-      if (typeof b.text === 'string' && b.text) out.push({ type: 'reasoning', text: b.text });
     } else if (b.type === 'image' && b.dataUnavailable === true) {
       // The image attachment resolver marked this block as unavailable. Keep it out of
       // visible text; pushMessage projects its retry metadata onto unavailableImages.
@@ -220,21 +177,18 @@ function parseBlocks(blocks, toolResults) {
       const entry = imageEntryOf(b);
       if (entry) out.push({ type: 'image', ...entry });
     } else if (b.type === 'tool-call') {
-      // tool-call 块字段为 id/name/arguments（与 harness toAssistantBlock 同口径）。
+      // 块已被上面那条规则收过：非白名单工具只剩 `{ id, name }`，所以 argsRaw 只有三张
+      // 轮尾卡的工具才有（App 从它读计划/扩展/定时任务的料）。
       const callId = b.id != null ? String(b.id) : undefined;
       let state;
-       let output;
-       let images;
-       let diffs;
+      let output;
+      let images;
       if (callId && toolResults) {
         const result = toolResults.get(callId);
         if (result) {
           output = result.output;
-           images = result.images;
-           // write/edit 的已应用分块 diff（桌面 diff 卡的数据源）；结果侧权威，
-           // 有它就替换掉仅凭 arguments 猜出来的调用态。
-           diffs = result.diffs;
-           // 对齐桌面 toolRowModel 状态派生：error.code === 'interrupted' → stopped, isError → error, ok
+          images = result.images;
+          // 对齐桌面 toolRowModel 状态派生：error.code === 'interrupted' → stopped, isError → error, ok
           if (result.isError) {
             state = result.code === 'interrupted' ? 'stopped' : 'error';
           } else {
@@ -248,9 +202,8 @@ function parseBlocks(blocks, toolResults) {
         name: typeof b.name === 'string' ? b.name : undefined,
         argsRaw: typeof b.arguments === 'string' ? b.arguments : (b.arguments != null ? JSON.stringify(b.arguments) : undefined),
         ...state ? { state } : {},
-         ...typeof output === 'string' && output ? { output } : {},
-         ...images && images.length ? { images } : {},
-         ...diffs && diffs.length ? { diffs } : {},
+        ...typeof output === 'string' && output ? { output } : {},
+        ...images && images.length ? { images } : {},
       });
     } else {
       // 桌面端对未知 assistant block 使用 JsonBlock 兜底；移动端没有对应组件，
@@ -261,6 +214,31 @@ function parseBlocks(blocks, toolResults) {
   return out;
 }
 
+/**
+ * 一条消息里 write/edit 成功写过的文件路径。
+ *
+ * 参数不下发手机（见 `wire-cut.js`），但「这一轮动过哪些文件」仍要在本机从**原始**块的
+ * `arguments` 里派生出来：App 拿这份清单解析收尾正文里的行内文件引用。
+ */
+function writtenPaths(content, toolResults) {
+  if (!Array.isArray(content)) return [];
+  const out = [];
+  for (const b of content) {
+    if (!b || typeof b !== 'object' || b.type !== 'tool-call') continue;
+    if (b.name !== 'write' && b.name !== 'edit') continue;
+    const callId = b.id != null ? String(b.id) : undefined;
+    const result = callId && toolResults ? toolResults.get(callId) : undefined;
+    if (!result || result.isError) continue;
+    const raw = typeof b.arguments === 'string' ? b.arguments : (b.arguments != null ? JSON.stringify(b.arguments) : '');
+    try {
+      const args = JSON.parse(raw || '{}');
+      const path = typeof args.path === 'string' ? args.path : typeof args.file_path === 'string' ? args.file_path : null;
+      if (typeof path === 'string' && path) out.push(path);
+    } catch { /* 参数不是 JSON：这条调用不算产出，与「没有参数」同处理 */ }
+  }
+  return out;
+}
+
 /** 从结构块里拼接纯文本（列表预览/标题回退用，仍只取 text 块）。 */
 function blocksToText(blocks) {
   return blocks.filter((b) => b.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n');
@@ -503,15 +481,8 @@ function deriveMessages(events) {
     // 这一轮的轮号（老日志没有）：产出清单与交付声明都按它归并。
     const turn = e.data && typeof e.data.turn === 'number' ? e.data.turn : undefined;
     // 本条消息自己写 / 改过的文件：并进**这一轮**的那一份，不单独挂在它自己头上。
-    const ownWrites = blocks
-      .filter((block) => block.type === 'tool-call' && (block.name === 'write' || block.name === 'edit') && block.state === 'ok')
-      .map((block) => {
-        try {
-          const args = JSON.parse(block.argsRaw || '{}');
-          return typeof args.path === 'string' ? args.path : typeof args.file_path === 'string' ? args.file_path : null;
-        } catch { return null; }
-      })
-      .filter((path) => typeof path === 'string');
+    // 从原始块的 arguments 算（那些参数不下发手机）。
+    const ownWrites = writtenPaths(msg.content, toolResults);
     if (turn !== undefined && ownWrites.length > 0) {
       const bucket = producedByTurn.get(turn) || new Set();
       for (const path of ownWrites) bucket.add(path);
@@ -981,8 +952,6 @@ module.exports = {
   errorDetails,
   promptErrorObject,
   MODEL_UNAVAILABLE_ERROR,
-  capDiffText,
-  normalizeResultDiffs,
   buildToolResultMap,
   toolResultPatchesFor,
   parseBlocks,

package/lib/mobile/local-images.js

@@ -9,7 +9,8 @@
  * 内联形状，App 不需要新增通道。
  *
  * 保守取舍——宁可保留字面 markdown，也不给半截东西：
- * - 只认绝对路径（`/x/y.png`、`file:///x/y.png`、`~/y.png`），http(s)、`data:`、相对路径不碰；
+ * - 本机路径认三种：绝对（`/x/y.png`、`file:///x/y.png`）、`~/y.png`、相对（`deliverables/a.png`，
+ *   按调用方给的工作区目录解析，与桌面端同口径；没给目录就当成不是本机图）；http(s)、`data:` 不碰；
  * - 只认 png/jpg/jpeg/webp/gif，并核对魔术字节，不按扩展名撒谎；
  * - 三级体积预算（单图 / 单段 / 单次响应），超预算就保持字面；
  * - 读不到、不是普通文件、读取失败一律原样保留；
@@ -63,10 +64,13 @@ function sniffMediaType(buf) {
 }
 
 /**
- * `![](…)` 里的地址 → 本机绝对路径；不是本机图片（远程、data、相对路径、非图片后缀）返回 null。
+ * `![](…)` 里的地址 → 本机路径；不是本机图片（远程、data、非图片后缀）返回 null。
  * 尖括号包裹的目的地（CommonMark 允许 `![](</abs/a.png>)`）在这里一并剥掉。
+ *
+ * 相对地址（`deliverables/a.png`、`./a.png`）按 `cwd` 解析——那是会话的工作区目录，也是
+ * 桌面端画正文图的基准；没给 `cwd` 时相对地址照样返回 null（老口径：保持字面 markdown）。
  */
-function localImagePathOf(url) {
+function localImagePathOf(url, cwd) {
   if (typeof url !== 'string') return null;
   let value = url.trim();
   if (!value) return null;
@@ -82,12 +86,39 @@ function localImagePathOf(url) {
   } else if (value === '~' || value.startsWith('~/')) {
     value = path.join(os.homedir(), value.slice(1));
   }
-  if (!path.isAbsolute(value)) return null;
+  if (!path.isAbsolute(value)) {
+    if (!cwd) return null;
+    value = path.resolve(cwd, value);
+  }
   if (!mediaTypeFor(value)) return null;
   return path.normalize(value);
 }
 
-/** 一次响应共用的内联预算；不给就按单次调用算一份。 */
+/**
+ * 正文里有没有「相对地址」的本机图片语法。
+ *
+ * 只有这种文本才值得去取会话的工作区目录（`sessions.list` 要扫一遍全部会话），
+ * 其余情况一条会话列表都不查：绝对路径照常内联，相对地址原样留着。
+ */
+function hasRelativeImage(text) {
+  if (typeof text !== 'string' || text.indexOf('![') < 0) return false;
+  for (const m of text.matchAll(IMAGE_RE)) {
+    let dest = m[2].trim();
+    if (dest.startsWith('<') && dest.endsWith('>')) dest = dest.slice(1, -1).trim();
+    if (!dest || path.isAbsolute(dest)) continue;
+    if (dest === '~' || dest.startsWith('~/')) continue;
+    if (/^[a-z][a-z0-9+.-]*:/i.test(dest)) continue;
+    if (mediaTypeFor(dest)) return true;
+  }
+  return false;
+}
+
+/**
+ * 一次响应共用的内联预算；不给就按单次调用算一份。
+ *
+ * `cwd` 由调用方按需补上（相对地址的解析基准，见 localImagePathOf）：`undefined` 表示
+ * 「还没查过工作区目录」，空串表示「查过了，这条会话没有」。
+ */
 function createTextImageBudget(limit = MAX_RESPONSE_CHARS) {
   return { remaining: limit };
 }
@@ -215,7 +246,7 @@ async function inlineTextImages(text, budget) {
   let cursor = 0;
   for (const m of matches) {
     if (textBudget <= 0 || pool.remaining <= 0) break;
-    const filePath = localImagePathOf(m[2]);
+    const filePath = localImagePathOf(m[2], pool.cwd);
     if (!filePath) continue;
     const uri = await dataUriFor(filePath);
     if (!uri || uri.length > textBudget || uri.length > pool.remaining) continue;
@@ -227,4 +258,4 @@ async function inlineTextImages(text, budget) {
   return cursor === 0 ? text : out + text.slice(cursor);
 }
 
-module.exports = { inlineTextImages, createTextImageBudget, localImagePathOf };
+module.exports = { inlineTextImages, createTextImageBudget, localImagePathOf, hasRelativeImage };

package/lib/mobile/model-vendors.js

@@ -0,0 +1,105 @@
+'use strict';
+
+/**
+ * 模型 → 厂商的识别，以及厂商图标（`vendor-logos.cjs` 那张表）的取用。
+ *
+ * 为什么需要猜：宿主只给「渠道 id + 模型 id」，没有厂商这一栏，而同一个模型在不同渠道下写法
+ * 各不相同 —— `deepseek-v4.1-flash`、`DeepSeek V4.1 flash`、`deepseek_v4_1_flash` 都是同一个
+ * 东西；有些渠道还把模型名整个改掉（`route-model-a`）。所以先规范化（小写、去掉所有分隔符），
+ * 再按关键词认；模型名认不出时再看渠道名（`anthropic`、`moonshotai` 这类渠道 id 往往就是厂商）。
+ *
+ * 认不出来的就**不猜**：宁可那一行退回首字母徽标，也不要给一个错的品牌 —— 厂商名是用户用来
+ * 认模型的，猜错比空着更糟。这条与「取不到就整块不出」是同一个口径。
+ *
+ * 纯函数、不碰网络也不碰文件，守卫直接跑真实现。
+ */
+
+const { VENDOR_LOGOS } = require('./vendor-logos.cjs');
+
+/**
+ * 规范化：小写、只留字母与数字（汉字保留 —— 国产模型的别名经常是中文）。
+ *
+ * 去掉分隔符是关键：`v4.1` / `v4-1` / `v4_1` 都应该落到同一个串上，否则每种写法都要单独列一条。
+ */
+function foldText(value) {
+  return typeof value === 'string' ? value.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '') : '';
+}
+
+/** 按非字母数字切开的小写片段：给「o3」「phi」这种两三个字符的短词用（它们不能按子串认）。 */
+function tokensOf(value) {
+  return typeof value === 'string'
+    ? value.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean)
+    : [];
+}
+
+/**
+ * 认法表。匹配顺序就是优先级，长关键词在前。
+ *
+ * `terms` 在规范化后的串上按子串认（`deepseekv41flash` 里含 `deepseek`）；
+ * `tokens` 按切开后的整段认（`o3-mini` 的 `o3`、`phi-4` 的 `phi`）—— 短词按子串认会把
+ * 一堆无关模型认成同一家。
+ */
+const VENDOR_PATTERNS = [
+  ['deepseek', { terms: ['deepseek', '深度求索', '深度探索'] }],
+  ['anthropic', { terms: ['claude', 'anthropic', 'sonnet', 'opus', 'haiku'] }],
+  ['openai', { terms: ['openai', 'chatgpt', 'gpt', 'codex', 'davinci', 'omni'], tokens: ['o1', 'o3', 'o4'] }],
+  ['google', { terms: ['gemini', 'gemma', 'google', 'vertex', 'bard'] }],
+  ['alibaba', { terms: ['qwen', 'qwq', 'tongyi', 'alibaba', '通义', '千问', '阿里'] }],
+  ['moonshot', { terms: ['kimi', 'moonshot', '月之暗面'] }],
+  ['zhipu', { terms: ['glm', 'chatglm', 'zhipu', '智谱', '清言'] }],
+  ['meta', { terms: ['llama', 'meta'] }],
+  ['mistral', { terms: ['mistral', 'mixtral', 'codestral', 'devstral', 'magistral'] }],
+  ['xai', { terms: ['grok', 'xai'] }],
+  ['cohere', { terms: ['cohere', 'commandr'] }],
+  ['bytedance', { terms: ['doubao', 'bytedance', 'seed', '豆包', '火山'] }],
+  ['baidu', { terms: ['ernie', 'wenxin', 'baidu', '文心', '百度'] }],
+  ['tencent', { terms: ['hunyuan', 'tencent', '混元', '腾讯'] }],
+  ['minimax', { terms: ['minimax', 'abab', '海螺'] }],
+  ['nvidia', { terms: ['nemotron', 'nvidia', '英伟达'] }],
+  ['microsoft', { terms: ['microsoft', 'azure'], tokens: ['phi', 'phi3', 'phi4', 'phi35'] }],
+];
+
+/** 一段文字认哪家；认不出返回空串。 */
+function vendorOfText(value) {
+  const folded = foldText(value);
+  if (!folded) return '';
+  for (const [vendor, rule] of VENDOR_PATTERNS) {
+    if (rule.terms && rule.terms.some((term) => folded.includes(term))) return vendor;
+  }
+  const tokens = tokensOf(value);
+  if (tokens.length > 0) {
+    for (const [vendor, rule] of VENDOR_PATTERNS) {
+      if (rule.tokens && rule.tokens.some((token) => tokens.includes(token))) return vendor;
+    }
+  }
+  return '';
+}
+
+/**
+ * 一条模型用量认哪家：先看模型名 / 模型 id，再看渠道名 / 渠道 id。
+ *
+ * 顺序有意如此 —— 渠道可以挂着任何模型（自建渠道尤其如此），名字写对了就以名字为准；
+ * 只有名字认不出来时才用渠道兜底，这也是很多网关渠道的实际情况（渠道叫 `anthropic`、
+ * 模型名是它自己起的别名）。
+ *
+ * 返回的是**认出来的那一家**，跟它有没有图标无关：有一家（比如 GLM / Grok）暂时没有图标，
+ * 这一行就该退回首字母徽标，而不是接着往下试渠道名 —— 那样「模型名认出 A、渠道名像 B」时会
+ * 认成 B，摆上别家的 logo。认错厂商比不认更糟，这一条是硬规矩。
+ */
+function identifyVendor(entry) {
+  if (!entry || typeof entry !== 'object') return '';
+  const candidates = [entry.modelName, entry.model, entry.providerName, entry.provider];
+  for (const candidate of candidates) {
+    const vendor = vendorOfText(candidate);
+    if (vendor) return vendor;
+  }
+  return '';
+}
+
+/** 厂商的展示名与图标标记；不在表里返回 null。 */
+function vendorLogoOf(vendor) {
+  const entry = VENDOR_LOGOS[vendor];
+  return entry ? { name: entry.name, icon: entry.icon } : null;
+}
+
+module.exports = { foldText, tokensOf, vendorOfText, identifyVendor, vendorLogoOf, VENDOR_PATTERNS };