dsh-deepseek-import 0.1.0 → 0.1.2

package/README.md

@@ -54,7 +54,7 @@ Double-click **`dsh-import.cmd`** in the workspace (or drop JSON files onto it).
 
 - Lists your DSH workspaces; pick one by number
 - Each conversation becomes one session: title, order and body (including code blocks and tables) are preserved
-- **Attachments** (images, txt, pdf, docx…) that can be downloaded are saved under `<workspace>/.dsh-imported/<sessionId>/` with their original names; anything that cannot be downloaded degrades to `[附件未下载：name (size) 原链接]`
+- **Attachments** (images, txt, pdf, docx…): saved under `<workspace>/.dsh-imported/<sessionId>/` with their original names **only when the data source carries them**; anything that cannot be downloaded degrades to `[附件未下载：name (size) 原链接]`. DeepSeek's IndexedDB cache copy usually carries no attachments
 - **Thinking** goes to `thinking.md` in the same folder (never injected into the context)
 - **Edited / regenerated versions**: only the selected branch stays in the body, all versions go to `revisions.md`
 - **Interrupted outputs** keep only a numbered placeholder (`[中断输出 #27：未产生完整正文…]`); add `--keep-interrupted` to keep the partial text
@@ -134,6 +134,17 @@ node dsh-import.mjs export.json --from-match "some text you typed"
 node dsh-import.mjs export.json --from-index 157
 ```
 
+### Auditing imported sessions
+
+DSH session format v4 requires the first model-visible node to be a `system/message`.
+Imports from `0.1.0` predate that fix and would break the moment you kept chatting in them.
+`0.1.1` writes the head on import, and this command repairs sessions created earlier:
+
+```powershell
+node dsh-import.mjs --audit     # report only
+node dsh-import.mjs --repair    # insert/move the head, resequence, drop the projection cache
+```
+
 - `--from-match` does a case-insensitive substring match over **user messages**, first hit wins
 - If the same text was edited and appears several times, the TUI lists them chronologically and you pick by number
 - Choosing a branch point disables auto-trim (your choice wins); the full text still goes to `transcript.md`
@@ -177,6 +188,8 @@ Open the conversation and click **Capture chat**; then check the "来源" (sourc
 
 ## Known limitations
 
+- **Citations and attachments depend on the data source**: DeepSeek's IndexedDB cache copy keeps the body and thinking only; the `references` table and `files` field are usually absent. `references.md` and the attachment folder are therefore created **only when the source carries them** — their absence is a normal result, not a failure.
+
 - **Thinking is archived, not inlined**: DSH reasoning blocks carry provider signatures; faking them would poison later requests. Read `thinking.md`, or force inline with `--thinking`.
 - **Attachments are not added to DSH's attachment store**: they are written to disk and referenced by path. When no download URL is available only the name and size survive.
 - **Web-search citations**: the cache record has no `references` table, so `[reference:N]` markers stay as plain text with no links.

package/README.zh.md

@@ -57,7 +57,7 @@ DeepSeek 的长对话是**分页加载**的，每次只能看到一屏。扩展
 
 - 会列出 DSH 里的工作区，选序号决定导入到哪个工作区
 - 每个对话重建为一个会话，标题、顺序、正文（含代码块/表格等 Markdown）原样保留
-- **附件**（图片、txt、pdf、docx…）能下载的落盘到 `<工作区>/.dsh-imported/<sessionId>/`，保留原文件名；下载不到时退化成 `[附件未下载：文件名（大小） 原链接]`，由你本机匹配
+- **附件**（图片、txt、pdf、docx…）：**仅当数据源带附件时**才落盘到 `<工作区>/.dsh-imported/<sessionId>/`，保留原文件名；下载不到时退化成 `[附件未下载：文件名（大小） 原链接]`，由你本机匹配。DeepSeek 的 IndexedDB 缓存副本通常不含附件
 - **思考过程**写进同目录的 `thinking.md`（旁挂存档，不进入对话上下文）
 - **编辑/重新生成留下的多个版本**：正文只保留当前分支，全部版本写进同目录的 `revisions.md`
 - 改动 `workspace.json` 前自动备份为 `workspace.json.bak-<时间>`
@@ -120,6 +120,8 @@ node dsh-import.mjs 导出.json --keep-interrupted # 保留不完整的中断输
 node dsh-import.mjs 导出.json --only "<对话 id>"       # 只导指定对话（逗号分隔可多个）
 node dsh-import.mjs 导出.json --from-match "某句话"     # 从匹配到的用户消息开始分支
 node dsh-import.mjs 导出.json --from-index 157         # 按消息序号分支
+node dsh-import.mjs --audit                            # 体检已导入会话（system 头是否完好）
+node dsh-import.mjs --repair                           # 批量修掉有隐患的会话
 
 > --tail 与 --from-index/--from-match 互斥（一个是取最后 N 轮，一个是从指定位置开始），同时给出会直接报错退出；--from-* 只能用于单个对话。
 ```
@@ -223,6 +225,8 @@ node check-sessions.mjs
 
 ## 已知限制
 
+- **引用与附件取决于数据源**：DeepSeek 的 IndexedDB 缓存副本只保留正文和思考，`references` 表与 `files` 字段通常不在里面。因此 `references.md` 和附件目录**只在数据源带这两类数据时才会生成**，没有生成是正常结果，不是失败。想找回图片只能回原网页另存。
+
 - **思考过程旁挂**：写进 `thinking.md`，不进上下文。DSH 的 reasoning 块带 provider 签名，硬塞正文会污染后续请求；想看时直接翻文件，或加 `--thinking` 强制内联。
 - **附件不进 DSH 附件库**：DSH 的图片是内容寻址附件（`~/.dsh/attachments/v1/objects/...`），伪造引用有损坏历史的风险；这里改为落盘 + 路径引用，模型可以用工具读。拿不到下载地址时只留文件名与大小。
 - **正文完整性**：历史接口 `/api/v0/chat/history_messages` 返回的正文可能偏短；回答生成时的 `/api/v0/chat/completion` 是 `text/event-stream` 补丁流（`THINK` 片段=思考，其余片段=正文），扩展会边读边拼，生成完即写入捕获。所以**新回答**是完整的；很久以前的老回答以历史接口返回的内容为准。

package/dsh-import.mjs

@@ -85,6 +85,9 @@ function parseArgs(argv) {
     else if (arg === '--keep-interrupted') opts.keepInterrupted = true;
     else if (arg === '--tail') opts.tail = Number(argv[++i]);
     else if (arg === '--no-auto-trim') opts.autoTrim = false;
+    else if (arg === '--no-system-head') opts.noSystemHead = true;
+    else if (arg === '--audit') opts.audit = true;
+    else if (arg === '--repair') { opts.audit = true; opts.applyRepair = true; }
     else if (arg === '--no-sidecar' || arg === '--sidecar') opts.noSidecar = true;
     else if (arg === '--sidecar-dir') opts.sidecarDir = argv[++i];
     else if (arg === '--context-window') opts.contextWindow = Number(argv[++i]) || null;
@@ -362,6 +365,9 @@ function conversationsOf(file) {
 
 // ---------------------------------------------------------------- 生成会话
 
+const IMPORT_SYSTEM_NOTE =
+  '本会话的历史来自 DeepSeek 网页对话的导入，以下消息为用户与助手的原始记录，顺序与原文一致。';
+
 const DATA_URL = /^data:([^;,]+);base64,(.*)$/s;
 const MIME_EXT = {
   'image/png': 'png',
@@ -418,7 +424,7 @@ function sidecarDir(workspacePath, sessionId) {
     const ignore = path.join(root, '.gitignore');
     if (!fs.existsSync(ignore)) {
       try {
-        fs.writeFileSync(ignore, '# DSH 导入存档（思考 / 引用 / 全文 / 附件）\n*\n');
+        fs.writeFileSync(ignore, '# DSH 导入存档（思考 / 全文 / 多版本；数据源带引用或附件时另存）\n*\n');
       } catch {
         /* 没有写权限就算了 */
       }
@@ -706,6 +712,21 @@ function buildEvents(conversation, workspacePath, sessionId) {
         });
       }
       push('step/start', { turn, step });
+      // v4 不变量：surface 的第 0 个节点必须是受保护的 system 头。
+      // 导入的历史前面没有 system/message 时，会话能打开，但一旦继续对话、
+      // 运行时追加自己的 system/message 就会被校验器判为损坏。
+      if (turn === 1 && !opts.noSystemHead) {
+        push('system/message', {
+          turn,
+          step,
+          message: {
+            role: 'system',
+            content: [{ type: 'text', text: IMPORT_SYSTEM_NOTE }],
+            source: { kind: 'system-prompt' },
+            id: crypto.randomUUID(),
+          },
+        }, { surfaceOp: 'append' });
+      }
       const seqNow = seq;
       // 只在第一条用户消息尾部附上存档索引
       if (sidecarNote && firstUserSeq === undefined) text += sidecarNote;
@@ -884,6 +905,12 @@ function writeTranscript(conversation, workspacePath, sessionId) {
 // ---------------------------------------------------------------- 主流程
 
 async function main() {
+  if (opts.audit) {
+    const { auditSessions } = await import('./repair-session.mjs');
+    auditSessions({ dryRun: opts.dryRun, apply: opts.applyRepair === true });
+    return { audited: true };
+  }
+
   // ---------- 参数自检：互相排斥的组合直接拒绝 ----------
   if (opts.tail !== undefined && opts.tail !== null) {
     if (!Number.isInteger(opts.tail) || opts.tail < 1) {

package/edge-extension/content.js

@@ -437,11 +437,31 @@
     try {
       const cached = await readCachedHistory();
       if (cached.ok && cached.messages?.length) {
-        pushCapture(cached.messages);
+        // 缓存里没有附件（DeepSeek 不把 files 写进 IndexedDB）。
+        // 当前屏幕上已渲染的消息能拿到 <img>，按「角色+正文完全相同」贴回去，
+        // 只做并集、不新增消息，避免重复。
+        let withFiles = cached.messages;
+        try {
+          const domMessages = domExtract().messages || [];
+          const byKey = new Map(withFiles.map((m) => [`${m.role}|${String(m.content || '').trim()}`, m]));
+          let attached = 0;
+          for (const domMessage of domMessages) {
+            if (!(domMessage.files || []).length) continue;
+            const target = byKey.get(`${domMessage.role}|${String(domMessage.content || '').trim()}`);
+            if (!target) continue;
+            target.files = [...(target.files || []), ...domMessage.files];
+            attached += domMessage.files.length;
+          }
+          if (attached) withFiles = [...withFiles];
+        } catch {
+          /* DOM 读不到就维持原样 */
+        }
+
+        pushCapture(withFiles);
         return {
           ok: true,
           source: 'cache',
-          messages: cached.messages,
+          messages: withFiles,
           rounds: 0,
           captures: 1,
           delta: 0,

package/edge-extension/merge.js

@@ -16,8 +16,25 @@
     return (message?.content || '').length + (message?.thinking || '').length;
   }
 
+  /** 同一消息的两份副本：正文取更全的，附件取并集 */
+  function unionFiles(a, b) {
+    const merged = [];
+    const seen = new Set();
+    for (const file of [...(a || []), ...(b || [])]) {
+      const key = file?.dataUrl ? String(file.dataUrl).slice(0, 64) : file?.url || file?.name;
+      if (!key || seen.has(key)) continue;
+      seen.add(key);
+      merged.push(file);
+    }
+    return merged;
+  }
+
   function richer(a, b) {
-    return score(b) > score(a) ? b : a;
+    if (!a) return b;
+    if (!b) return a;
+    const winner = score(b) > score(a) ? b : a;
+    const files = unionFiles(a.files, b.files);
+    return files.length ? { ...winner, files } : winner;
   }
 
   function keyOf(message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-deepseek-import",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "DeepSeek web chat → DeepSeek Harness sessions (Edge extension + importer CLI)",
   "type": "module",
   "license": "MIT",
@@ -14,6 +14,7 @@
     "dsh-import.cmd",
     "move-session.mjs",
     "remove-session.mjs",
+    "repair-session.mjs",
     "audit-imports.mjs",
     "edge-extension/",
     "README.md",
@@ -39,6 +40,7 @@
   },
   "scripts": {
     "list": "node dsh-import.mjs --list",
-    "tui": "node dsh-import-tui.mjs"
+    "tui": "node dsh-import-tui.mjs",
+    "audit": "node repair-session.mjs --audit"
   }
 }

package/repair-session.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+/**
+ * repair-session.mjs — 给导入的会话补上 v4 要求的「受保护 system 头」
+ *
+ * 背景：DSH 会话格式 v4 要求 surface 的第 0 个节点是 system/message。
+ * 早期的导入器没写这一条，会话能打开，但一旦继续对话、运行时追加自己的
+ * system/message，就会报 `system/message requires a protected first surface head`。
+ *
+ * 用法：
+ *   node repair-session.mjs --audit              # 体检所有会话
+ *   node repair-session.mjs <session-dir> --dry-run
+ *   node repair-session.mjs <session-dir>
+ *   node repair-session.mjs --all [--dry-run]    # 批量修所有需要修的
+ */
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import zlib from 'node:zlib';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+
+const DSH_HOME = process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+const SESSIONS = path.join(DSH_HOME, 'sessions');
+const CACHE = path.join(DSH_HOME, 'storages', 'session_projcache', 'sessions');
+
+const NOTE =
+  '本会话的历史来自 DeepSeek 网页对话的导入，以下消息为用户与助手的原始记录，顺序与原文一致。';
+
+const args = process.argv.slice(2);
+const dryRun = args.includes('--dry-run');
+const audit = args.includes('--audit');
+const all = args.includes('--all');
+const targets = args.filter((a) => !a.startsWith('--'));
+
+function readFrames(file) {
+  const buf = fs.readFileSync(file);
+  const magic = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
+  const offsets = [];
+  for (let i = -1; (i = buf.indexOf(magic, i + 1)) !== -1;) offsets.push(i);
+  const texts = [];
+  for (let k = 0; k < offsets.length; k++) {
+    texts.push(zlib.zstdDecompressSync(buf.subarray(offsets[k], offsets[k + 1] ?? buf.length)).toString('utf8'));
+  }
+  return texts;
+}
+
+function writeFrames(file, texts) {
+  const encoded = Buffer.concat(texts.map((text) => zlib.zstdCompressSync(Buffer.from(text, 'utf8'))));
+  fs.writeFileSync(file, encoded);
+}
+
+function sessionFiles() {
+  const out = [];
+  if (!fs.existsSync(SESSIONS)) return out;
+  for (const project of fs.readdirSync(SESSIONS)) {
+    const dir = path.join(SESSIONS, project);
+    if (!fs.statSync(dir).isDirectory()) continue;
+    for (const entry of fs.readdirSync(dir)) {
+      if (!entry.startsWith('session-')) continue;
+      const file = path.join(dir, entry, 'session.v4.jsonl.zstd');
+      if (fs.existsSync(file)) out.push({ id: entry, file });
+    }
+  }
+  return out;
+}
+
+/** 返回 { status, header, events, firstSurfaceIndex, systemIndexes } */
+function inspect(file) {
+  const texts = readFrames(file);
+  const rows = texts.join('').split('\n').filter(Boolean).map((line) => JSON.parse(line));
+  const header = rows[0];
+  const events = rows.slice(1);
+  const systemIndexes = events.map((e, i) => (e.type === 'system/message' ? i : -1)).filter((i) => i >= 0);
+  const surfaceTypes = new Set(['user/message', 'assistant/message', 'system/message', 'tool/result', 'developer/message']);
+  const firstSurfaceIndex = events.findIndex((e) => surfaceTypes.has(e.type));
+  return { texts, header, events, systemIndexes, firstSurfaceIndex };
+}
+
+function makeSystemEvent(turn, step) {
+  return {
+    type: 'system/message',
+    seq: 0,
+    time: Date.now(),
+    data: {
+      turn,
+      step,
+      message: {
+        role: 'system',
+        content: [{ type: 'text', text: NOTE }],
+        source: { kind: 'system-prompt' },
+        id: crypto.randomUUID(),
+      },
+    },
+    surfaceOp: 'append',
+  };
+}
+
+function planRepair({ events, systemIndexes, firstSurfaceIndex }) {
+  if (firstSurfaceIndex < 0) return { action: 'skip', reason: '没有 surface 事件' };
+  if (systemIndexes.length && systemIndexes[0] === firstSurfaceIndex) {
+    return { action: 'ok' };
+  }
+
+  const copy = events.map((e) => ({ ...e }));
+  if (systemIndexes.length) {
+    // 已有 system 但在后面：把它挪到 surface 最前面
+    const source = copy[systemIndexes[0]];
+    copy.splice(systemIndexes[0], 1);
+    const target = firstSurfaceIndex;
+    copy.splice(target, 0, {
+      ...source,
+      data: { ...source.data, turn: 1, step: 1 },
+      surfaceOp: 'append',
+    });
+    return { action: 'move', events: copy };
+  }
+
+  // 完全没有 system：插到第一个 surface 事件之前
+  copy.splice(firstSurfaceIndex, 0, makeSystemEvent(1, 1));
+  return { action: 'insert', events: copy };
+}
+
+function resequence(events) {
+  const mapping = new Map();
+  events.forEach((event, index) => mapping.set(event.seq, index));
+  const next = events.map((event, index) => ({ ...event, seq: index }));
+  // 改写对 seq 的引用（session/title 的 messageSeqs）
+  for (const event of next) {
+    if (event.type === 'session/title' && Array.isArray(event.data?.messageSeqs)) {
+      event.data = {
+        ...event.data,
+        messageSeqs: event.data.messageSeqs.map((seq) => mapping.get(seq) ?? seq),
+      };
+    }
+  }
+  return next;
+}
+
+function sessionDirOf(file) {
+  return path.dirname(file);
+}
+
+function repair(file, plan) {
+  const { texts, header } = inspect(file);
+  const events = resequence(plan.events);
+  const lines = [JSON.stringify(header), ...events.map((e) => JSON.stringify(e))];
+  writeFrames(file, lines.map((line) => `${line}\n`));
+
+  const id = path.basename(sessionDirOf(file));
+  const cached = path.join(CACHE, `${id}.json`);
+  let cacheNote = '';
+  if (fs.existsSync(cached)) {
+    fs.rmSync(cached, { force: true });
+    cacheNote = '，投影缓存已清除';
+  }
+  return `${plan.action === 'insert' ? '已插入 system 头' : '已把 system 头移到最前'}（${events.length} 条事件${cacheNote}）`;
+}
+
+export function auditSessions({ dryRun = false, apply = false } = {}) {
+  const list = sessionFiles();
+  const problems = [];
+  for (const item of list) {
+    let info;
+    try {
+      info = inspect(item.file);
+    } catch (error) {
+      problems.push({ ...item, status: `读取失败：${error.message}` });
+      continue;
+    }
+    const plan = planRepair(info);
+    if (plan.action === 'ok') continue;
+    problems.push({ ...item, status: plan.action, plan });
+  }
+
+  console.log(`会话总数 ${list.length}，需要处理 ${problems.length}`);
+  for (const item of problems) {
+    console.log(`  ${item.id}  ${item.status}`);
+    if (dryRun || !apply || !item.plan) continue;
+    console.log(`    → ${repair(item.file, item.plan)}`);
+  }
+  if (dryRun) console.log('\n[dry-run] 没有修改任何文件');
+  return problems;
+}
+
+export function repairSessions(paths, { dryRun = false } = {}) {
+  for (const target of paths) {
+    const dir = target.endsWith('session.v4.jsonl.zstd') ? path.dirname(target) : target;
+    const file = path.join(dir, 'session.v4.jsonl.zstd');
+    if (!fs.existsSync(file)) {
+      console.error(`找不到 ${file}`);
+      continue;
+    }
+    const info = inspect(file);
+    const plan = planRepair(info);
+    console.log(`${path.basename(dir)}: ${plan.action}`);
+    if (plan.action === 'ok' || plan.action === 'skip' || dryRun) continue;
+    console.log('  → ' + repair(file, plan));
+  }
+}
+
+// ---------------------------------------------------------------- 入口
+
+const invokedDirectly =
+  process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
+
+if (invokedDirectly) {
+  if (audit || all) {
+    auditSessions({ dryRun, apply: all });
+    process.exit(0);
+  }
+
+  if (!targets.length) {
+    console.error('用法：node repair-session.mjs --audit | <session-dir> [--dry-run] | --all');
+    process.exit(1);
+  }
+
+  repairSessions(targets, { dryRun });
+}
+