dsh-liuhen 0.1.2 → 0.1.3

package/README.md

@@ -91,12 +91,41 @@ dsh plugin --profile web add dsh-liuhen
 - **打包不再调 `zip` 命令**：自己拼 zip 容器（`lib/zip.js`，只用 Node 自带的 `zlib`）。
   0.1.1 在电脑上会报 `打包失败：spawnSync zip ENOENT`，根就在这儿。
 - **面板「打开」不再调 `unzip -l`**：直接读 zip 的中央目录，中文文件名按 UTF-8 原样读回来。
+- **软链/目录联接会被解开**：以前 `fs.cpSync` 原样重建软链，Windows 建软链要管理员权限，
+  于是 `.dsh/vault` 是个联接的机器会报 `EPERM: operation not permitted, symlink …`。
+  现在一律跟着链接拷真内容（0.1.3）。
 - **共享目录按平台走**（`lib/platform.js`）：手机 → `/storage/emulated/0/DSHBox`；
   Windows → `%USERPROFILE%\Downloads`；macOS → `~/Downloads`。面板文案也跟着换，
   电脑上不会再写「存到手机」。
 - 打包是**可复现**的：同一天同样的数据，打两次 `sha256` 一样（目录条目固定时间戳，
   脱敏后把 mtime 拨回去）——面板上那个 sha 才有核对的意义。
 
+### 拿一台新机器，先体检
+
+```bash
+node scripts/doctor.js
+```
+
+只读、不碰真数据、30 秒跑完，逐项说清这台机器上哪一层不行：
+
+- 十六个模块能不能 `require`
+- 三层数据在哪、**是不是软链/目录联接**
+- `zstd` 有没有（Node ≥ 22.15 才有，存档与会话回填要用）
+- zip 能不能自己写自己读（中文名）
+- 软链/联接能不能拷出真内容
+- 包该放到哪、那个目录在不在
+
+带 ❌ 的那几行就是病灶，整段贴出来即可。
+
+**离线装（不发 npm 也能验）**：把 `dsh-liuhen-x.y.z.tgz` 解出来得到 `package/`：
+
+```bash
+node package/scripts/doctor.js                      # 先体检，确认环境没问题
+# 备份旧的，再把 package/ 整个覆盖到插件目录（一般在 <DSH_HOME>\profiles\web
+ode_modules\dsh-liuhen）
+# 然后重启 DSH
+```
+
 **在电脑上验一遍**（`lib/*.js` 改了必须重启一次 DSH，面板的 HMR 管不到服务端）：
 
 ```bash
@@ -106,6 +135,14 @@ dsh plugin --profile web add dsh-liuhen
 # 4. 自检（可选，Windows 上也能跑）：node scripts/selfcheck.js → 82/82
 ```
 
+## 0.1.3 · 电脑也能用（小更新，不是第二版）
+
+- **修 Windows 上的 `EPERM … symlink`**：`$DSH_HOME/vault` 是软链 / 目录联接时，打包会在
+  「把数据拷进沙箱」这一步炸。根因是 `fs.cpSync` 会原样重建软链，而 Windows 建符号链接要
+  管理员权限或开发者模式。现在换成自己走目录树、解开链接拷真内容（`copyTree`），
+  顺带挡住了软链绕圈导致的无限递归。
+- 自检仍 82/82；软链场景已单独验过（vault 是软链时，包里带的是真实文件内容）
+
 ## 0.1.2（小更新，不是第二版）
 
 - **电脑分支**：打包与列清单不再依赖系统的 `zip` / `unzip` 命令（Windows 上两者都没有），

package/lib/box.js

@@ -186,6 +186,48 @@ function manifestBody(rebuildDate, where) {
   ].join('\n')
 }
 
+/**
+ * 把源目录拷进沙箱：跟着软链走、拷真内容。
+ *
+ * 为什么不用 fs.cpSync（2026-11-01 在 Windows 上踩到的）：
+ * cpSync 遇到软链 / 目录联接会「原样重建一个软链」，而 Windows 创建符号链接
+ * 要管理员权限或开发者模式，没有就报
+ *   EPERM: operation not permitted, symlink 'C:\Users\…\.dsh\vault' -> '…\.box-stage-…\vault'
+ * 整个打包直接废。小盒子要的是内容，不是链接本身，所以一律解开。
+ *
+ * mtime 手动带过去：zip 条目要写时间戳，不带的话每次拷贝都盖成"现在"，
+ * 同一份数据打两次 sha256 就不一样了。
+ */
+function copyTree(from, to, keep, seen, depth) {
+  const visited = seen || new Set()
+  const level = depth || 0
+  if (level > 32) return
+  let stat
+  try { stat = fs.statSync(from) } catch { return }  /* 跟随软链；断链就跳过 */
+  if (stat.isDirectory()) {
+    let real = from
+    try { real = fs.realpathSync(from) } catch {}
+    /* 软链绕回来会无限递归：撞见过的真实目录就停 */
+    if (visited.has(real)) return
+    visited.add(real)
+    try { fs.mkdirSync(to, { recursive: true, mode: 0o700 }) } catch { return }
+    let names = []
+    try { names = fs.readdirSync(from) } catch { return }
+    for (const name of names) {
+      const child = path.join(from, name)
+      if (keep && !keep(child)) continue
+      copyTree(child, path.join(to, name), keep, visited, level + 1)
+    }
+    try { fs.utimesSync(to, stat.atime, stat.mtime) } catch {}
+    return
+  }
+  if (!stat.isFile()) return
+  try {
+    fs.copyFileSync(from, to)
+    try { fs.utimesSync(to, stat.atime, stat.mtime) } catch {}
+  } catch {}
+}
+
 /**
  * 打小盒子。
  *
@@ -225,27 +267,19 @@ function exportBox(options = {}) {
      */
     try { fs.rmSync(out, { force: true }) } catch {}
     /* 三层都拷进沙箱；private/、备份、半成品一概不拷，连排除参数都省了。 */
-    for (const name of present) {
-      fs.cpSync(path.join(paths.home, name), path.join(stage, name), {
-        recursive: true,
-        /*
-         * 保住源文件的 mtime：zip 条目要写时间戳，不保的话每次拷贝都盖上"现在"，
-         * 同一份数据打两次 sha256 就不一样了。
-         */
-        preserveTimestamps: true,
-        filter: (src) => {
-          const base = path.basename(src)
-          if (name === 'liuhen' && base === 'private') return false
-          if (base.endsWith('.tmp')) return false
-          /* 锁文件是运行时的临时物，不该进包 */
-          if (base.endsWith('.lock')) return false
-          if (/\.bak($|[-.])/.test(base)) return false
-          if (name === 'liuhen' && base === 'backfill.json') return false
-          if (base.startsWith('.box-stage-')) return false
-          /* 按日期补打：仓库只装那一天的原文 */
-          if (name === 'vault' && rebuildDate && base.endsWith('.jsonl')) return base === `${rebuildDate}.jsonl`
-          return true
-        }
+    for (const layer of present) {
+      copyTree(path.join(paths.home, layer), path.join(stage, layer), (src) => {
+        const base = path.basename(src)
+        if (layer === 'liuhen' && base === 'private') return false
+        if (base.endsWith('.tmp')) return false
+        /* 锁文件是运行时的临时物，不该进包 */
+        if (base.endsWith('.lock')) return false
+        if (/\.bak($|[-.])/.test(base)) return false
+        if (layer === 'liuhen' && base === 'backfill.json') return false
+        if (base.startsWith('.box-stage-')) return false
+        /* 按日期补打：仓库只装那一天的原文 */
+        if (layer === 'vault' && rebuildDate && base.endsWith('.jsonl')) return base === `${rebuildDate}.jsonl`
+        return true
       })
     }
     /*
@@ -300,4 +334,5 @@ function exportBox(options = {}) {
   return { ok: true, path: out, name: path.basename(out), bytes, sha256: sha, excluded: EXCLUDES, shared }
 }
 
-module.exports = { exportBox, boxPath }
+/* copyTree 给 scripts/doctor.js 用：体检要能在不碰真数据的前提下验「软链拷不拷得动」。 */
+module.exports = { exportBox, boxPath, copyTree }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-liuhen",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "留痕 Trace — 可核对的 AI 记忆：索引、溯源、自动注入（默认关）、可选日记。",
   "author": "xiaoman000",
   "keywords": [
@@ -17,7 +17,7 @@
   "main": "lib/index.js",
   "files": [
     "lib",
-    "scripts/selfcheck.js",
+    "scripts",
     "client.js",
     "cordis.patch.yml",
     "README.md",

package/scripts/dedupe-vault.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+'use strict'
+
+/**
+ * 仓库物理去重：把 vault/<日期>.jsonl 里重复的 (session, seq) 收成一条。
+ *
+ * 为什么要单独一个脚本：2026-10-26 加跨进程锁之前，两个进程同时回填会各写一遍，
+ * 同一个 DSH_HOME 里真出过重复行（这次 3 条）。
+ * 读取侧已经按 session:seq 去重了（看 readDay），这里只是把文件本身也收干净。
+ *
+ * 只动"同一条消息写了两份"这种重复：正文取先写的那份，批注全部保留。
+ * 不认识的坏行照丢（跟读取侧同一条规矩）。
+ *
+ * 用法：
+ *   node scripts/dedupe-vault.js            # 预演，只报数
+ *   node scripts/dedupe-vault.js --write    # 真写（先自己备份）
+ */
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const { paths } = require('../lib/paths')
+const { isGoodRow } = require('../lib/rows')
+
+const WRITE = process.argv.includes('--write')
+
+function dayFiles() {
+  const dir = path.join(paths.home, 'vault')
+  try {
+    return fs.readdirSync(dir).filter((name) => name.endsWith('.jsonl')).sort()
+  } catch { return [] }
+}
+
+function dedupeDay(file) {
+  const raw = fs.readFileSync(file, 'utf8').split('\n').filter((line) => line.trim() !== '')
+  const marks = []
+  const order = []
+  const byKey = new Map()
+  let dropped = 0
+  let bad = 0
+  for (const line of raw) {
+    let row
+    try { row = JSON.parse(line) } catch { bad += 1; continue }
+    if (row && row.m === 'mark') { marks.push(line); continue }
+    if (!isGoodRow(row)) { bad += 1; continue }
+    const key = `${row.s}:${row.n}`
+    const kept = byKey.get(key)
+    if (kept) { dropped += 1; continue }
+    byKey.set(key, line)
+    order.push(line)
+  }
+  return { lines: order.concat(marks), rows: order.length, marks: marks.length, dropped, bad }
+}
+
+let totalDropped = 0
+let totalBad = 0
+for (const name of dayFiles()) {
+  const file = path.join(paths.home, 'vault', name)
+  const result = dedupeDay(file)
+  totalDropped += result.dropped
+  totalBad += result.bad
+  if (result.dropped > 0 || result.bad > 0) {
+    console.log(`${name}：${result.rows} 条 + ${result.marks} 条批注，重复 ${result.dropped}，坏行 ${result.bad}`)
+    if (WRITE) {
+      const tmp = `${file}.tmp`
+      fs.writeFileSync(tmp, result.lines.length ? `${result.lines.join('\n')}\n` : '', { mode: 0o600 })
+      fs.renameSync(tmp, file)
+    }
+  }
+}
+if (totalDropped === 0 && totalBad === 0) console.log('仓库很干净：没有重复行，也没有坏行。')
+else console.log(WRITE ? `已写回：去掉 ${totalDropped} 条重复、${totalBad} 条坏行。` : `预演：会去掉 ${totalDropped} 条重复、${totalBad} 条坏行（加 --write 才真写）。`)

package/scripts/doctor.js

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+'use strict'
+
+/**
+ * 留痕 · 体检（doctor）——只读，不碰真数据，专门用来回答「这台机器上到底哪个模块不行」。
+ *
+ * 自检（selfcheck）是往沙箱里拷一份数据跑全部 82 条；体检是轻量的、只看这台机器的
+ * 环境与三条关键能力：模块能不能加载、三层数据在哪、打包/压缩/软链能不能用。
+ *
+ * 为什么要有它（2026-11-01）：插件要在「电脑 + 手机」两种机器上都成立，
+ * 但我手里只有手机。电脑上出问题（zip 命令没有、vault 是联接、权限位是摆设），
+ * 光看面板一句红字分不清是哪一层坏的——所以给一台机器一份 30 秒能跑完的清单。
+ *
+ * 用法：node scripts/doctor.js        （Windows / macOS / 手机都一样）
+ * 全程只读：唯一会写的是自己建的临时目录，跑完就删；不会打真包、不碰共享目录。
+ */
+
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const zlib = require('node:zlib')
+
+const ROOT = path.resolve(__dirname, '..')
+const ok = (t) => `✅ ${t}`
+const warn = (t) => `⚠️  ${t}`
+const bad = (t) => `❌ ${t}`
+
+let failures = 0
+const lines = []
+function say(text) { lines.push(text); console.log(text) }
+function fail(text) { failures += 1; say(bad(text)) }
+
+const { paths } = require(path.join(ROOT, 'lib', 'paths'))
+
+say('留痕 · 体检')
+say(`平台：${process.platform} · Node ${process.version} · ${os.arch()}`)
+say(`DSH_HOME：${paths.home}`)
+say('')
+
+/* ── 一、模块能不能加载 ───────────────────────────── */
+const MODULES = ['config', 'store', 'paths', 'redact', 'diary', 'notes', 'inject', 'tools',
+  'autoindex', 'box', 'index', 'retention', 'vault', 'feelbox', 'zip', 'platform']
+say('一、模块')
+for (const name of MODULES) {
+  try {
+    const mod = require(path.join(ROOT, 'lib', name))
+    const n = Object.keys(mod).length
+    if (!n) fail(`${name}.js 加载了但没导出东西`)
+    else say(`  ${ok(name.padEnd(10))} ${n} 个导出`)
+  } catch (error) {
+    fail(`${name}.js 加载失败：${error && error.message ? error.message : error}`)
+  }
+}
+say('')
+
+/* ── 二、三层数据在哪、是不是软链 ─────────────────── */
+say('二、数据三层')
+function describeDir(dir) {
+  let st
+  try { st = fs.lstatSync(dir) } catch { return null }
+  const link = st.isSymbolicLink()
+  let real = ''
+  if (link) { try { real = fs.readlinkSync(dir) } catch {} }
+  let files = 0
+  let bytes = 0
+  const walk = (d) => {
+    let items = []
+    try { items = fs.readdirSync(d, { withFileTypes: true }) } catch { return }
+    for (const it of items) {
+      const full = path.join(d, it.name)
+      let s2 = null
+      try { s2 = fs.statSync(full) } catch {}
+      if (!s2) continue
+      if (s2.isDirectory()) { walk(full); continue }
+      files += 1
+      bytes += s2.size
+    }
+  }
+  walk(dir)
+  return { link, real, files, bytes }
+}
+let smallest = null
+for (const name of ['pet-memory', 'liuhen', 'vault']) {
+  const dir = path.join(paths.home, name)
+  const info = describeDir(dir)
+  if (info === null) {
+    /* 三层缺一层还算能用（新装会缺），只是提醒 */
+    say(`  ${warn(name.padEnd(10))} 没有这个目录（新装通常如此）`)
+    continue
+  }
+  const kb = `${(info.bytes / 1024).toFixed(0)} KB`
+  if (info.link) say(`  ${ok(name.padEnd(10))} 软链/联接 → ${info.real} · ${info.files} 个文件 · ${kb}`)
+  else say(`  ${ok(name.padEnd(10))} ${info.files} 个文件 · ${kb}`)
+  if (smallest === null || info.bytes < smallest.bytes) smallest = { name, dir, bytes: info.bytes }
+}
+say('')
+
+/* ── 三、三条关键能力 ─────────────────────────────── */
+say('三、能力')
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'liuhen-doctor-'))
+try {
+  /* 1. 压缩库：存档/回填要用 zstd，Node 太老就没有 */
+  if (typeof zlib.zstdCompressSync === 'function' && typeof zlib.zstdDecompressSync === 'function') {
+    say(`  ${ok('zstd'.padEnd(10))} node:zlib 自带（存档、会话回填要用）`)
+  } else {
+    fail(`zstd 不可用：这个 Node（${process.version}）里没有 zlib.zstd*，需要 Node ≥ 22.15`)
+  }
+
+  /* 2. zip 往返：自己写的 writer/reader，中文名不能乱 */
+  try {
+    const { writeZip, listZip, readEntry } = require(path.join(ROOT, 'lib', 'zip'))
+    const z = path.join(tmp, 'roundtrip.zip')
+    const body = '中文名 · 往返测试\n'
+    writeZip(z, [{ name: '中文目录/读我.txt', data: body }, { name: 'liuhen/', data: Buffer.alloc(0), dir: true }])
+    const names = listZip(z).map((e) => e.name)
+    const back = readEntry(z, '中文目录/读我.txt').toString('utf8')
+    if (!names.includes('中文目录/读我.txt') || back !== body) fail('zip 往返不对（中文名或内容）')
+    else say(`  ${ok('zip'.padEnd(10))} 自己读写正常，中文名不乱码（${names.length} 条）`)
+  } catch (error) {
+    fail(`zip 读写失败：${error && error.message ? error.message : error}`)
+  }
+
+  /* 3. 软链/联接能不能拷：Windows 上 vault 常常是联接，拷不动就整包废 */
+  if (smallest === null) {
+    say(`  ${warn('软链'.padEnd(10))} 没有数据目录，跳过`)
+  } else {
+    try {
+      const { copyTree } = require(path.join(ROOT, 'lib', 'box'))
+      const dest = path.join(tmp, 'copytree')
+      copyTree(smallest.dir, dest, null)
+      let copied = 0
+      const count = (d) => {
+        let items = []
+        try { items = fs.readdirSync(d, { withFileTypes: true }) } catch { return }
+        for (const it of items) {
+          const full = path.join(d, it.name)
+          let s2 = null
+          try { s2 = fs.statSync(full) } catch {}
+          if (!s2) continue
+          if (s2.isDirectory()) count(full)
+          else copied += 1
+        }
+      }
+      count(dest)
+      const origin = describeDir(smallest.dir)
+      if (copied === 0) fail(`软链拷出来是空的（${smallest.name}）`)
+      else if (origin && copied !== origin.files) fail(`软链拷出来少了：${copied}/${origin.files}`)
+      else say(`  ${ok('软链'.padEnd(10))} ${smallest.name} 解开拷成功（${copied} 个文件）`)
+    } catch (error) {
+      fail(`软链拷不动：${error && error.message ? error.message : error}`)
+    }
+  }
+} finally {
+  try { fs.rmSync(tmp, { recursive: true, force: true }) } catch {}
+}
+
+/* ── 四、这台机器上包该放哪 ───────────────────────── */
+say('')
+say('四、共享目录')
+try {
+  const platform = require(path.join(ROOT, 'lib', 'platform'))
+  const where = platform.describe()
+  say(`  ${ok('位置'.padEnd(10))} ${where.label}`)
+  say(`  ${where.exists ? ok('存在'.padEnd(10)) : warn('不存在'.padEnd(10))} ${where.exists ? '可以往里放一份' : '打包后会留在容器里，用面板「保存」取走'}`)
+} catch (error) {
+  fail(`平台判断失败：${error && error.message ? error.message : error}`)
+}
+
+/* ── 结论 ─────────────────────────────────────────── */
+say('')
+if (failures === 0) {
+  say('结论：这台机器上留痕的模块都能起来，打包/压缩/软链三条路都通。')
+  process.exit(0)
+}
+say(`结论：${failures} 处不行，上面带 ❌ 的就是。把这份输出整段贴给作者。`)
+process.exit(1)

package/scripts/selfcheck.js

@@ -278,6 +278,11 @@ check('感受待播：当天留着、10 分钟内不重复、跨天自动清', (
   assert(nextDay.length === 0, '昨天的还在念')
   assert(box.pending().length === 0, '跨天没清')
   assert(box.read().delivered.some((x) => x.purged), '清掉的那条没留底')
+  /* Windows 上 mode 是摆设（NTFS 不给 POSIX 权限位），这条只验"文件在、别的没被破坏"。 */
+  if (process.platform === 'win32') {
+    try { fs.rmSync(file, { force: true }) } catch {}
+    return '当天留着 · 10 分钟节流 · 跨天清（Windows 不验 600，跳过）'
+  }
   const mode = fs.statSync(file).mode & 0o777
   assert(mode === 0o600, `权限是 ${mode.toString(8)}，该 600`)
   try { fs.rmSync(file, { force: true }) } catch {}
@@ -848,6 +853,11 @@ check('目录权限：新建的目录一律 700', () => {
   const { ensureDir } = require('../lib/paths')
   const dir = path.join(sandbox, 'perm-check', 'a', 'b')
   ensureDir(dir)
+  /*
+   * Windows 的 chmod 是空操作，stat 回来的是 666/777 这类默认位——
+   * 在那儿断言 700 只会造出一条假失败，把真问题埋了。
+   */
+  if (process.platform === 'win32') return 'Windows 不验权限位（跳过）'
   const mode = fs.statSync(dir).mode & 0o777
   assert(mode === 0o700, `权限是 ${mode.toString(8)}，该 700`)
   return '700'
@@ -1002,6 +1012,15 @@ check('client.js 语法', () => {
   return `${(source.length / 1024).toFixed(1)} KB，语法通过`
 })
 
+check('scripts/doctor.js 存在且语法通过', () => {
+  const file = path.join(ROOT, 'scripts', 'doctor.js')
+  assert(fs.existsSync(file), '体检脚本不在了——电脑上就没法自报家门')
+  /* 去掉 #! 再验语法：Function 不认 shebang。只验语法，不执行——doctor 会读真数据。 */
+  const source = fs.readFileSync(file, 'utf8').replace(/^#![^\n]*\n/, '')
+  new Function(source)
+  return `${(source.length / 1024).toFixed(1)} KB`
+})
+
 /* ── 汇总（等异步的那几条也落表）──────────────────── */
 Promise.all(pending).then(() => {
 console.log('留痕自检 · 沙箱 ' + sandbox)