dsh-liuhen 0.1.1 → 0.1.3

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,75 @@
 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 原样读回来。
+- **软链/目录联接会被解开**：以前 `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
+# 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.3 · 电脑也能用（小更新，不是第二版）
+
+- **修 Windows 上的 `EPERM … symlink`**：`$DSH_HOME/vault` 是软链 / 目录联接时，打包会在
+  「把数据拷进沙箱」这一步炸。根因是 `fs.cpSync` 会原样重建软链，而 Windows 建符号链接要
+  管理员权限或开发者模式。现在换成自己走目录树、解开链接拷真内容（`copyTree`），
+  顺带挡住了软链绕圈导致的无限递归。
+- 自检仍 82/82；软链场景已单独验过（vault 是软链时，包里带的是真实文件内容）
+
+## 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,15 +175,59 @@ function manifestBody(rebuildDate) {
         '',
         '没有 liuhen/private/（用户画像），也没有备份文件。',
         '',
+        `去向：${placed}`,
+        '',
         '隐私处理（2026-10-26 定的 B 方案）：',
         '  姓名保留；生日、学校、籍贯/住址已隐去（写成「[已隐去]」）。',
         '  只改了包里这份副本，磁盘上的原件一个字没动。',
         '',
-        '⚠️ 这个包里是明文。放进手机共享目录后，别的 App 也读得到——存好，别再转出去。',
+        `⚠️ 这个包里是明文。放进${spot.word}之后，同一台机器上别的程序也读得到——存好，别再转出去。`,
         ''
   ].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 {}
+}
+
 /**
  * 打小盒子。
  *
@@ -173,22 +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,
-        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
       })
     }
     /*
@@ -208,9 +299,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 {
@@ -227,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/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
+}