dsh-liuhen 0.1.1 → 0.1.2

package/README.md

@@ -63,7 +63,8 @@
 - 小盒子会连仓库一起打包，并把 `pet-memory/`（名字、承诺、跨会话汇总、交接信）带上；箱子里有一张 `00-读我.txt` 说明三层关系
   - **打的时候会脱敏**（B 方案）：姓名保留，生日、学校、籍贯/住址在**包里那份副本**上换成 `[已隐去]`；磁盘原件一个字不改
   - 按日期补打：`exportBox({ date: 'YYYY-MM-DD' })` 只装那天的原文，索引截到那天
-  - ⚠️ **这个包里有完整原文**（明文）。它会复制到手机的共享目录，别的 App 读得到；`pet-memory/` 里还有个人信息。存好，别随手转出去
+  - 打完往共享目录放一份：手机是 `/storage/emulated/0/DSHBox`，电脑（Windows / macOS）是下载文件夹
+  - ⚠️ **这个包里有完整原文**（明文）。落到共享目录后，同一台机器上别的程序也读得到；`pet-memory/` 里还有个人信息。存好，别随手转出去
 
 ## 隐私
 
@@ -83,6 +84,38 @@
 dsh plugin --profile web add dsh-liuhen
 ```
 
+## 电脑上也能用（0.1.2 起）
+
+同一份插件，Windows / macOS / 手机都跑，不用装 7-Zip 之类的东西：
+
+- **打包不再调 `zip` 命令**：自己拼 zip 容器（`lib/zip.js`，只用 Node 自带的 `zlib`）。
+  0.1.1 在电脑上会报 `打包失败：spawnSync zip ENOENT`，根就在这儿。
+- **面板「打开」不再调 `unzip -l`**：直接读 zip 的中央目录，中文文件名按 UTF-8 原样读回来。
+- **共享目录按平台走**（`lib/platform.js`）：手机 → `/storage/emulated/0/DSHBox`；
+  Windows → `%USERPROFILE%\Downloads`；macOS → `~/Downloads`。面板文案也跟着换，
+  电脑上不会再写「存到手机」。
+- 打包是**可复现**的：同一天同样的数据，打两次 `sha256` 一样（目录条目固定时间戳，
+  脱敏后把 mtime 拨回去）——面板上那个 sha 才有核对的意义。
+
+**在电脑上验一遍**（`lib/*.js` 改了必须重启一次 DSH，面板的 HMR 管不到服务端）：
+
+```bash
+# 1. 重启 DSH 后，打开面板 → 小盒子 → 「打一份小盒子」
+# 2. 没有红灯、出现「已放进下载文件夹：C:\Users\<你>\Downloads\留痕-YYYY-MM-DD.zip」即通过
+# 3. 解压那个 zip，看中文名是否正常、00-读我.txt 第 20 行左右有没有「去向：」
+# 4. 自检（可选，Windows 上也能跑）：node scripts/selfcheck.js → 82/82
+```
+
+## 0.1.2（小更新，不是第二版）
+
+- **电脑分支**：打包与列清单不再依赖系统的 `zip` / `unzip` 命令（Windows 上两者都没有），
+  改成 `lib/zip.js` 自己读写；`lib/platform.js` 管共享目录与文案
+- 打包结果**可复现**：同一天同样的数据两次打包 sha256 一致
+- 包里补回**目录条目**（含空目录），解出来的结构跟打进去的一致
+- `/summary` 多带一个 `where` 字段（`os` / `kind` / `dir` / `label` / `word`），
+  面板据此说「手机」还是「下载文件夹」
+- 自检 76 → 82 条：新增跨平台 4 条（手机路径、电脑路径、面板文案、zip 中文名往返）
+
 ## 0.1.1（小更新，不是第二版）
 
 - 面板每 30 秒自动刷新，不用关掉重开

package/client.js

@@ -108,6 +108,15 @@
         }).sort((a, b) => (a.first.t < b.first.t ? -1 : 1))
       }
 
+      /*
+       * 这台机器把包往哪放：手机上是「手机的 DSHBox」，电脑上是「下载文件夹」。
+       * 文案从后端来（status.where）：面板跑在 WebView 里，读不到 process.platform，
+       * 写死就会在电脑上写着「存到手机」。取不到时退成中性词。
+       */
+      function spotWord(d) {
+        return (d && d.where && d.where.word) || '共享目录'
+      }
+
       function pairRows(rows, options) {
         const desc = Boolean(options && options.desc)
         const sessions = buildSessions(rows)
@@ -511,12 +520,12 @@
           Card('装着我的小盒子',
             h('div', { style: S.muted }, '把留痕的数据打成一个 zip：索引摘要、完整原文（仓库）、日记、自省、承诺，加上 pet-memory（我是谁、答应过的事、跨会话汇总、交接信）。换机器就靠它。箱子里有 00-读我.txt 说明三层怎么对应。'),
             h('div', { style: { ...S.muted, marginTop: '6px', color: '#d9534f' } },
-              '这个包里有完整原文：你说过的每句话都在里面，明文的；pet-memory 里还有个人信息（名字、生日、学校）。放进手机 DSHBox 后，别的 App 也读得到——存好，别再转出去。'),
+              `这个包里有完整原文：你说过的每句话都在里面，明文的；pet-memory 里还有个人信息（名字、生日、学校）。落到${spotWord(d)}之后，同一台机器上别的程序也读得到——存好，别再转出去。`),
             d.box
               ? h('div', { style: { marginTop: '10px', padding: '10px', borderRadius: '8px', background: 'rgba(127,127,127,.07)' } },
                   h('div', { style: { fontSize: '12.5px', marginBottom: '4px', wordBreak: 'break-all' } }, `${d.box.name} · ${(d.box.bytes / 1024).toFixed(1)} KB`),
                   h('div', { style: { ...S.muted, marginBottom: '8px', wordBreak: 'break-all' } },
-                    d.box.shared ? `已放进手机的 DSHBox 文件夹：${d.box.shared}（用「文件」app 找得到）` : '还没同步到手机共享目录，可用下面的「保存」取走。'),
+                    d.box.shared ? `已放进${spotWord(d)}：${d.box.shared}（用系统自带的文件管理器找得到）` : `还没同步到${spotWord(d)}，可用下面的「保存」取走。`),
                   h('div', { style: S.row },
                     h('button', { type: 'button', style: S.btn, disabled: boxList.loading, onClick: () => {
                       if (boxList.count > 0 && !boxList.loading) { setBoxList({ loading: false, entries: [], count: 0, error: '' }); return }
@@ -529,7 +538,7 @@
                     h('a', {
                       href: `${PREFIX}/box/file`,
                       style: { ...S.btn, display: 'inline-block', textDecoration: 'none', color: 'inherit' }
-                    }, '存到手机'),
+                    }, d.where && d.where.kind === 'desktop' ? '存到下载文件夹' : '存到手机'),
                     h('button', { type: 'button', style: S.btn, disabled: boxSend.busy, onClick: () => {
                       setBoxSend({ busy: true, msg: '', error: '' })
                       fetch(`${PREFIX}/box/send`, { method: 'POST', headers: { 'content-type': 'application/json' }, credentials: 'same-origin', body: '{}' })

package/lib/box.js

@@ -5,10 +5,11 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const crypto = require('node:crypto')
-const { execFileSync } = require('node:child_process')
 
 const { paths, dayKey } = require('./paths')
 const { redact } = require('./redact')
+const { writeZip } = require('./zip')
+const platform = require('./platform')
 
 /** 永远不打包出去的东西：用户画像、备份、半成品。 */
 const EXCLUDES = [
@@ -73,7 +74,14 @@ function sanitizeTree(root) {
         if (stat.size > 8 * 1024 * 1024) continue
         const before = fs.readFileSync(full, 'utf8')
         const after = sanitizeText(before)
-        if (after !== before) fs.writeFileSync(full, after, { mode: 0o600 })
+        if (after !== before) {
+          fs.writeFileSync(full, after, { mode: 0o600 })
+          /*
+           * 改完把 mtime 拨回去：脱敏是"打这份副本"的动作，不是"这份数据变了"。
+           * 不拨回去的话，每打一次包 mtime 都变成现在，sha256 跟着漂。
+           */
+          try { fs.utimesSync(full, stat.atime, stat.mtime) } catch {}
+        }
       } catch {}
     }
   }
@@ -81,29 +89,71 @@ function sanitizeTree(root) {
 }
 
 /*
- * proot 把手机的 /storage/emulated/0/DSHBox 挂在 /root/share/DSHBox。
- * 打包后往那儿放一份，用户用「文件」app 就能找到，不用猜浏览器存到哪了。
+ * 打包后往共享目录放一份，人用系统自带的「文件 / 资源管理器」就能找到，不用猜浏览器存到哪了。
+ * 具体是哪个目录交给 platform.js：手机是 proot 挂的 DSHBox，电脑是 Downloads。
  */
 /* 打开箱子第一眼该看到的东西：三层怎么对应、先读哪份。 */
 const MANIFEST = '00-读我.txt'
 
-const SHARED_DIR = '/root/share/DSHBox'
-const SHARED_LABEL = '/storage/emulated/0/DSHBox'
-
 function publishCopy(src, name, allowed) {
   if (allowed === false) return null
   try {
-    if (!fs.existsSync(SHARED_DIR)) return null
-    fs.copyFileSync(src, path.join(SHARED_DIR, name))
-    return `${SHARED_LABEL}/${name}`
+    const dir = platform.sharedDir()
+    if (!fs.existsSync(dir)) return null
+    fs.copyFileSync(src, path.join(dir, name))
+    return `${platform.sharedLabel()}/${name}`
   } catch { return null }
 }
 
+/**
+ * 把沙箱里的文件收成 zip 条目（路径相对沙箱，统一 / 分隔）。
+ *
+ * 按名字排序：同样的数据打两次，包内顺序一致，sha256 才对得上——
+ * 面板上那个 sha 是给人核对「这份和上次那份是不是同一份」用的，乱序就没意义了。
+ */
+function collectEntries(root) {
+  const out = []
+  const walk = (dir, prefix) => {
+    let items = []
+    try { items = fs.readdirSync(dir, { withFileTypes: true }) } catch { return }
+    for (const item of items) {
+      const full = path.join(dir, item.name)
+      const rel = prefix === '' ? item.name : `${prefix}/${item.name}`
+      if (item.isDirectory()) {
+        /*
+         * 空目录也要进包：以前 `zip -qr` 会给每个目录写一条（名字以 / 结尾）。
+         * 不写的话，像 pet-memory/自省/ 这种暂时还空着的目录，解出来就没了，
+         * 而「解出来的样子」应该和「打进去的样子」一样。
+         *
+         * 时间戳钉成 1980-01-01：目录 mtime 会随着往里面拷文件而变，
+         * 带着它走 sha256 就会漂；目录的时间戳本来也没人看。
+         */
+        out.push({ name: `${rel}/`, data: Buffer.alloc(0), dir: true, mtime: new Date(0) })
+        walk(full, rel)
+        continue
+      }
+      try {
+        out.push({ name: rel, data: fs.readFileSync(full), mtime: fs.statSync(full).mtime })
+      } catch {}
+    }
+  }
+  walk(root, '')
+  out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+  return out
+}
+
 /**
  * 箱子里那张纸条：谁打开这个 zip，一眼就知道里面有什么、隐私怎么处理过。
  * 写在沙箱里，随包打进去，打完跟着沙箱一起删。
+ *
+ * where 是 platform.describe() 的结果——「放进手机 DSHBox 后」这句话在电脑上说不通，
+ * 而这张纸条是要跟着包走的，说不通就等于没写。
  */
-function manifestBody(rebuildDate) {
+function manifestBody(rebuildDate, where) {
+  const spot = where || platform.describe()
+  const placed = spot.exists
+    ? `打完顺手放了一份在${spot.word}：${spot.label}`
+    : `打完没找到${spot.word}，包留在容器里，用面板上的「保存」取走。`
   return [
     ...(rebuildDate ? [`补打：按 ${rebuildDate} 那天重打（原文只含那天，索引截到那天）。`, ''] : []),
         '留痕 · 小盒子 —— 一个"我"搬家用的箱子',
@@ -125,11 +175,13 @@ function manifestBody(rebuildDate) {
         '',
         '没有 liuhen/private/（用户画像），也没有备份文件。',
         '',
+        `去向：${placed}`,
+        '',
         '隐私处理（2026-10-26 定的 B 方案）：',
         '  姓名保留；生日、学校、籍贯/住址已隐去（写成「[已隐去]」）。',
         '  只改了包里这份副本，磁盘上的原件一个字没动。',
         '',
-        '⚠️ 这个包里是明文。放进手机共享目录后，别的 App 也读得到——存好，别再转出去。',
+        `⚠️ 这个包里是明文。放进${spot.word}之后，同一台机器上别的程序也读得到——存好，别再转出去。`,
         ''
   ].join('\n')
 }
@@ -176,6 +228,11 @@ function exportBox(options = {}) {
     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
@@ -208,9 +265,25 @@ function exportBox(options = {}) {
     for (const name of present) sanitizeTree(path.join(stage, name))
 
     /* 纸条也放进沙箱，压完随沙箱一起删。 */
-    fs.writeFileSync(path.join(stage, MANIFEST), manifestBody(rebuildDate), { mode: 0o600 })
-    const args = ['-qr', out, ...present, MANIFEST]
-    execFileSync('zip', args, { cwd: stage })
+    const where = platform.describe()
+    const manifestFile = path.join(stage, MANIFEST)
+    fs.writeFileSync(manifestFile, manifestBody(rebuildDate, where), { mode: 0o600 })
+    /*
+     * 纸条的时间戳钉在当天零点：它是每次现写的，要是按"现在"记，
+     * 同一份数据隔一分钟打两次，sha256 就变了——那个 sha 是给人核对
+     * 「这份和我早上那份是不是同一份」用的，会漂就没意义。
+     * 其余条目的 mtime 来自源文件，本来就不变。
+     */
+    try {
+      const stamp = new Date(`${rebuildDate || dayKey()}T00:00:00`)
+      fs.utimesSync(manifestFile, stamp, stamp)
+    } catch {}
+    /*
+     * 自己拼 zip（lib/zip.js）：Windows 上没有 zip 命令，spawn 直接 ENOENT——
+     * 这就是 0.1.1 在电脑上「打包失败：spawnSync zip ENOENT」的根。
+     * 以前 `zip -qr` 顺带做的递归收集，现在 collectEntries 干。
+     */
+    writeZip(out, collectEntries(stage))
   } catch (error) {
     return { ok: false, text: `打包失败：${error && error.message ? error.message : error}` }
   } finally {

package/lib/index.js

@@ -17,6 +17,8 @@ const { backfill, readIndex, messagesFor, readOriginal, remarkSensitive } = requ
 const { diaryStatus, readDiary } = require('./diary')
 const { readNotes, readPromises } = require('./notes')
 const { exportBox } = require('./box')
+const platform = require('./platform')
+const { listZip } = require('./zip')
 const { archiveOld, retentionStats } = require('./retention')
 const vault = require('./vault')
 const { isDate } = require('./rows')
@@ -183,13 +185,21 @@ exports.apply = function apply(ctx) {
                 /* 感受之外还有犹豫、权衡、没说出口的：一起数，面板上分开看。 */
                 feels: vault.markCounts(today),
                 promises: readPromises(),
+                /*
+                 * 这台机器是什么系统、包该往哪放、该怎么说。
+                 * 面板跑在浏览器里，读不到 process.platform——不从这里带过去，
+                 * 电脑上就会写着「存到手机」。
+                 */
+                where: platform.describe(),
                 box: fs.existsSync(boxFile)
                   ? {
                       name: path.basename(boxFile),
                       bytes: fs.statSync(boxFile).size,
-                      shared: fs.existsSync(path.join('/root/share/DSHBox', path.basename(boxFile)))
-                        ? `/storage/emulated/0/DSHBox/${path.basename(boxFile)}`
-                        : null
+                      shared: (() => {
+                        const dir = platform.sharedDir()
+                        const base = path.basename(boxFile)
+                        return fs.existsSync(path.join(dir, base)) ? `${platform.sharedLabel(dir)}/${base}` : null
+                      })()
                     }
                   : null
               })
@@ -288,12 +298,12 @@ exports.apply = function apply(ctx) {
               const file = path.join(paths.home, `留痕-${dayKey()}.zip`)
               if (!fs.existsSync(file)) return json(404, { ok: false, error: '还没有小盒子，先打一份' })
               try {
-                const out = require('node:child_process').execFileSync('unzip', ['-l', file], { encoding: 'utf8' })
-                const entries = []
-                for (const line of out.split('\n')) {
-                  const m = /^\s*(\d+)\s+(\d{4}-\d{2}-\d{2}|\S+)\s+(\S+)\s+(.+)$/.exec(line)
-                  if (m) entries.push({ bytes: Number(m[1]), time: m[2], name: String(m[4]).trim() })
-                }
+                /*
+                 * 以前是 `unzip -l` 解文本再正则抠——Windows 上一样没有 unzip，
+                 * 「打开」按钮跟着挂。现在直接读 zip 的中央目录（lib/zip.js），
+                 * 不依赖机器上装了什么，而且名字是 UTF-8 原样，不怕空格和中文。
+                 */
+                const entries = listZip(file).map((e) => ({ bytes: e.bytes, time: e.time, name: e.name }))
                 return json(200, { ok: true, name: path.basename(file), count: entries.length, entries: entries.slice(0, 300) })
               } catch (error) {
                 return json(500, { ok: false, error: String(error && error.message ? error.message : error) })

package/lib/platform.js

@@ -0,0 +1,79 @@
+'use strict'
+
+/**
+ * 平台分支：只回答两件事——打好包往哪放、让人怎么找到它。
+ *
+ * 为什么单开一个文件（2026-10-27 主人定的 A 方案）：
+ * 手机（proot 里的 Android）和电脑（Windows / macOS）跑的是同一份插件，
+ * 差别只在这两件事上。要是把 `if (isAndroid)` 撒进 box.js 和 index.js，
+ * 加第三个平台就得改十处，还会像 190 行那段一样抄出第二份映射。
+ *
+ * 每个函数都收一个可选的 os 参数（默认 process.platform）：
+ * 自检要靠它模拟 win32，不然"电脑分支"在手机上永远验不到——那才是白加。
+ */
+
+const path = require('node:path')
+const fs = require('node:fs')
+
+/* 手机那条路的固定坐标：proot 把 /storage/emulated/0/DSHBox 挂在 /root/share/DSHBox。 */
+const ANDROID_SHARED_DIR = '/root/share/DSHBox'
+const ANDROID_SHARED_LABEL = '/storage/emulated/0/DSHBox'
+
+function osName(os) {
+  return String(os || process.platform)
+}
+
+/** 用户主目录：Windows 上没有 HOME，只有 USERPROFILE。 */
+function homeDir() {
+  return process.env.USERPROFILE || process.env.HOME || '/root'
+}
+
+/**
+ * 打包好的 zip 复制到哪：系统的「文件/资源管理器」里一眼能找到的地方。
+ * 手机是 DSHBox（用户自己建的共享目录），电脑是 Downloads。
+ */
+function sharedDir(os) {
+  const name = osName(os)
+  if (name === 'win32') return path.join(homeDir(), 'Downloads')
+  if (name === 'darwin') return path.join(homeDir(), 'Downloads')
+  return ANDROID_SHARED_DIR
+}
+
+/** 给人看的那个路径：对外说「去这儿找」，不能把 proot 里的 /root/share 说给电脑用户听。 */
+function sharedLabel(os, dir) {
+  const name = osName(os)
+  if (name === 'win32' || name === 'darwin') return dir || sharedDir(os)
+  return ANDROID_SHARED_LABEL
+}
+
+/** 这个平台上到底有没有那个共享目录（电脑上可能没有 Downloads 这个叫法的目录）。 */
+function sharedExists(os) {
+  try {
+    return fs.existsSync(sharedDir(os))
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 面板上该怎么说这个包去哪了。
+ * 手机：「能放进手机的 DSHBox」；电脑：「下载文件夹」。一句话，两边都读得懂。
+ */
+function describe(os) {
+  const name = osName(os)
+  if (name === 'win32' || name === 'darwin') {
+    return { os: name, kind: 'desktop', dir: sharedDir(os), label: sharedLabel(os), exists: sharedExists(os), word: '下载文件夹' }
+  }
+  return { os: name, kind: 'phone', dir: sharedDir(os), label: sharedLabel(os), exists: sharedExists(os), word: '手机的 DSHBox' }
+}
+
+module.exports = {
+  ANDROID_SHARED_DIR,
+  ANDROID_SHARED_LABEL,
+  osName,
+  homeDir,
+  sharedDir,
+  sharedLabel,
+  sharedExists,
+  describe
+}

package/lib/zip.js

@@ -0,0 +1,234 @@
+'use strict'
+
+/**
+ * 最小 ZIP：自己写、自己读。零外部命令、零 npm 依赖。
+ *
+ * 为什么不用 zip / unzip 命令（2026-10-27 踩到的）：
+ * Windows 上既没有 zip 也没有 unzip——打包直接 `spawnSync zip ENOENT`，
+ * 面板的「打开」也跟着 500。而 Node 自带 zlib，拼一个 ZIP 容器是几十行的事，
+ * 比让用户在每台机器上装 7-Zip 靠谱。
+ *
+ * 只实现两边用得到的：
+ *   写：deflate（method 8）；压不动就退回 store（method 0）——小文件压缩反而更大
+ *   读：中央目录（列清单）+ 单个条目（自检要把 00-读我.txt 读出来对照）
+ * 不做：目录条目（解压器会按路径自己建）、注释、ZIP64（4GB 以上不认，留痕的包几 MB）。
+ *
+ * 中文文件名必须打上 UTF-8 标志位（bit 11），否则 Windows 资源管理器按 CP437 解，
+ * 文件名全成乱码——「留痕-2026-10-27.zip」解出来会是一串问号。
+ */
+
+const fs = require('node:fs')
+const zlib = require('node:zlib')
+
+const SIG_LOCAL = 0x04034b50
+const SIG_CENTRAL = 0x02014b50
+const SIG_END = 0x06054b50
+const UTF8_FLAG = 0x0800
+/* 解压后应有的权限：文件 600、目录 700。版本号高字节 3 = unix，低字节 20 = zip 2.0。 */
+const MADE_BY_UNIX = 0x0314
+const FILE_ATTRS = (0o100600 << 16) >>> 0
+const DIR_ATTRS = (0o040700 << 16) >>> 0
+
+/** CRC32 查表，建一次用到底。 */
+const CRC_TABLE = (() => {
+  const table = new Int32Array(256)
+  for (let i = 0; i < 256; i += 1) {
+    let c = i
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1
+    table[i] = c
+  }
+  return table
+})()
+
+function crc32(buf) {
+  let c = -1
+  for (let i = 0; i < buf.length; i += 1) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8)
+  return (c ^ -1) >>> 0
+}
+
+/** MS-DOS 时间戳：1980 起算，秒按 2 秒一格。 */
+function dosStamp(at) {
+  const d = at instanceof Date && !Number.isNaN(at.getTime()) ? at : new Date()
+  const year = Math.max(1980, d.getFullYear())
+  return {
+    date: ((year - 1980) << 9) | ((d.getMonth() + 1) << 5) | d.getDate(),
+    time: (d.getHours() << 11) | (d.getMinutes() << 5) | Math.floor(d.getSeconds() / 2)
+  }
+}
+
+function dosToText(date, time) {
+  const year = 1980 + ((date >> 9) & 0x7f)
+  const month = String((date >> 5) & 0x0f).padStart(2, '0')
+  const day = String(date & 0x1f).padStart(2, '0')
+  const hour = String((time >> 11) & 0x1f).padStart(2, '0')
+  const minute = String((time >> 5) & 0x3f).padStart(2, '0')
+  return `${year}-${month}-${day} ${hour}:${minute}`
+}
+
+/**
+ * 写一个 zip。
+ *
+ * @param {string} outPath 落盘位置（已存在的会被覆盖）
+ * @param {Array<{name: string, data: Buffer|string, mtime?: Date}>} entries
+ * @returns {{entries: number, bytes: number, ratio: number}} ratio = 压缩后 / 原始
+ */
+function writeZip(outPath, entries) {
+  const fd = fs.openSync(outPath, 'w', 0o600)
+  const central = []
+  let offset = 0
+  let rawTotal = 0
+  try {
+    for (const entry of entries) {
+      /* 统一用 / 分隔：zip 规范只认这个，Windows 的 \ 解出来会变成一个长文件名。 */
+      const name = Buffer.from(String(entry.name).replace(/\\/g, '/'), 'utf8')
+      const raw = Buffer.isBuffer(entry.data)
+        ? entry.data
+        : Buffer.from(String(entry.data === undefined ? '' : entry.data), 'utf8')
+      const crc = crc32(raw)
+      let method = 0
+      let body = raw
+      try {
+        const packed = zlib.deflateRawSync(raw, { level: 9 })
+        if (packed.length < raw.length) {
+          method = 8
+          body = packed
+        }
+      } catch {
+        /* 压不动就用原文，不影响正确性 */
+      }
+      const stamp = dosStamp(entry.mtime)
+
+      const local = Buffer.alloc(30)
+      local.writeUInt32LE(SIG_LOCAL, 0)
+      local.writeUInt16LE(20, 4)
+      local.writeUInt16LE(UTF8_FLAG, 6)
+      local.writeUInt16LE(method, 8)
+      local.writeUInt16LE(stamp.time, 10)
+      local.writeUInt16LE(stamp.date, 12)
+      local.writeUInt32LE(crc, 14)
+      local.writeUInt32LE(body.length, 18)
+      local.writeUInt32LE(raw.length, 22)
+      local.writeUInt16LE(name.length, 26)
+      local.writeUInt16LE(0, 28)
+      fs.writeSync(fd, local)
+      fs.writeSync(fd, name)
+      fs.writeSync(fd, body)
+
+      central.push({ name, crc, method, body: body.length, raw: raw.length, dir: entry.dir === true, ...stamp, offset })
+      rawTotal += raw.length
+      offset += 30 + name.length + body.length
+    }
+
+    const cdStart = offset
+    let cdSize = 0
+    for (const c of central) {
+      const head = Buffer.alloc(46)
+      head.writeUInt32LE(SIG_CENTRAL, 0)
+      head.writeUInt16LE(MADE_BY_UNIX, 4)
+      head.writeUInt16LE(20, 6)
+      head.writeUInt16LE(UTF8_FLAG, 8)
+      head.writeUInt16LE(c.method, 10)
+      head.writeUInt16LE(c.time, 12)
+      head.writeUInt16LE(c.date, 14)
+      head.writeUInt32LE(c.crc, 16)
+      head.writeUInt32LE(c.body, 20)
+      head.writeUInt32LE(c.raw, 24)
+      head.writeUInt16LE(c.name.length, 28)
+      head.writeUInt16LE(0, 30)
+      head.writeUInt16LE(0, 32)
+      head.writeUInt16LE(0, 34)
+      head.writeUInt16LE(0, 36)
+      head.writeUInt32LE(c.dir === true ? DIR_ATTRS : FILE_ATTRS, 38)
+      head.writeUInt32LE(c.offset, 42)
+      fs.writeSync(fd, head)
+      fs.writeSync(fd, c.name)
+      cdSize += 46 + c.name.length
+    }
+
+    const end = Buffer.alloc(22)
+    end.writeUInt32LE(SIG_END, 0)
+    end.writeUInt16LE(0, 4)
+    end.writeUInt16LE(0, 6)
+    end.writeUInt16LE(central.length, 8)
+    end.writeUInt16LE(central.length, 10)
+    end.writeUInt32LE(cdSize, 12)
+    end.writeUInt32LE(cdStart, 16)
+    end.writeUInt16LE(0, 20)
+    fs.writeSync(fd, end)
+
+    return {
+      entries: central.length,
+      bytes: cdStart + cdSize + 22,
+      rawBytes: rawTotal,
+      ratio: rawTotal === 0 ? 1 : Math.round(((cdStart + cdSize + 22) / rawTotal) * 100) / 100
+    }
+  } finally {
+    fs.closeSync(fd)
+  }
+}
+
+/** 找 EOCD：可能是 22 字节，也可能带注释，所以从尾部往前扫（最多 64KB）。 */
+function findEnd(buf) {
+  const floor = Math.max(0, buf.length - 65557)
+  for (let i = buf.length - 22; i >= floor; i -= 1) {
+    if (buf.readUInt32LE(i) === SIG_END) return i
+  }
+  return -1
+}
+
+/** 解析中央目录。抛错就说明这不是个能读的 zip——调用方自己决定怎么兜。 */
+function readCentral(zipPath) {
+  const buf = fs.readFileSync(zipPath)
+  if (buf.length < 22) throw new Error('不是 zip：文件太小')
+  const end = findEnd(buf)
+  if (end < 0) throw new Error('不是 zip：找不到结尾记录')
+  const count = buf.readUInt16LE(end + 10)
+  let cursor = buf.readUInt32LE(end + 16)
+  const entries = []
+  for (let i = 0; i < count; i += 1) {
+    if (cursor + 46 > buf.length) throw new Error('不是 zip：中央目录越界')
+    if (buf.readUInt32LE(cursor) !== SIG_CENTRAL) throw new Error('不是 zip：中央目录标记不对')
+    const method = buf.readUInt16LE(cursor + 10)
+    const time = buf.readUInt16LE(cursor + 12)
+    const date = buf.readUInt16LE(cursor + 14)
+    const bytes = buf.readUInt32LE(cursor + 20)
+    const rawBytes = buf.readUInt32LE(cursor + 24)
+    const nameLen = buf.readUInt16LE(cursor + 28)
+    const extraLen = buf.readUInt16LE(cursor + 30)
+    const commentLen = buf.readUInt16LE(cursor + 32)
+    const offset = buf.readUInt32LE(cursor + 42)
+    const name = buf.subarray(cursor + 46, cursor + 46 + nameLen).toString('utf8')
+    entries.push({ name, bytes, rawBytes, method, time: dosToText(date, time), offset })
+    cursor += 46 + nameLen + extraLen + commentLen
+  }
+  return { buf, entries }
+}
+
+/** 列清单：面板「打开」和自检共用。不依赖机器上装了什么。 */
+function listZip(zipPath) {
+  return readCentral(zipPath).entries.map(({ name, bytes, rawBytes, method, time }) => ({
+    name, bytes, rawBytes, method, time
+  }))
+}
+
+/**
+ * 读一个条目出来。
+ * 找不到就抛——自检靠它区分"条目为空"和"条目缺失"。
+ */
+function readEntry(zipPath, entryName) {
+  const { buf, entries } = readCentral(zipPath)
+  const wanted = String(entryName).replace(/\\/g, '/')
+  const hit = entries.find((e) => e.name === wanted)
+  if (!hit) throw new Error(`zip 里没有 ${wanted}`)
+  const head = hit.offset
+  if (buf.readUInt32LE(head) !== SIG_LOCAL) throw new Error('不是 zip：条目头不对')
+  const nameLen = buf.readUInt16LE(head + 26)
+  const extraLen = buf.readUInt16LE(head + 28)
+  const start = head + 30 + nameLen + extraLen
+  const body = buf.subarray(start, start + hit.bytes)
+  if (hit.method === 0) return Buffer.from(body)
+  if (hit.method === 8) return zlib.inflateRawSync(body)
+  throw new Error(`不认识的压缩方式：${hit.method}`)
+}
+
+module.exports = { writeZip, listZip, readEntry, crc32 }

package/package.json

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