dsh-crossterm 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # dsh-crossterm 变更记录
 
+## 0.8.3 — 2026-10-19
+
+### 已归档会话只备份一次，卡片把备份拆成「已归档 / 活跃中」
+
+- **归档清单**：DSH 把已归档会话记在 `<DSH_HOME>/storages/workspace.json` 的 `global.archivedSessionIds`（本机 24 个）。
+  新增 `readArchivedIds(dshHome)` 读它，读不到就当没有归档（不让备份停摆）。
+- **归档会话备份一次就别再备**：`backupSessions()` 把会话分成「已归档 / 活跃中」两类，
+  归档会话第一次传完在 `backup-state.json` 里记 `archived: true`，之后每轮直接跳过、连大小都不比；
+  万一归档文件事后被写大（理论上不会），仍然补传一次再回到跳过。
+- **计数进状态**：每轮写 `state.lastRun = {at, archivedTotal, activeTotal, archivedDone, activeDone}`；
+  `backupSummary()` 带出 `archived / active / archivedBackedUp / activeBackedUp`。
+- **卡片**：「会话备份」行显示 `已归档 24/24 · 活跃中 9/9 · 43.1 MB · 上次 2 分钟前`。
+- **修**：`loadState()` 原来会把不认识的字段丢掉，导致 `lastRun` 存不进总结；改成保留未知字段。
+- 探针 `F:\dsh\001X\crossterm-work\probe-archived-backup.mjs` **16 PASS**（首轮分类、次轮全跳过、归档变大补一次、清单缺失回落活跃）；
+  `probe-cloud-home` 42、`probe-security-080` 21、`probe-relay-082` 7 回归通过。
+- **要不要跟着动手：不用**（纯备份策略与显示）。
+
 ## 0.8.2 — 2026-10-19
 
 ### 复测反馈：F7 只修一半、A6、F14、F16

package/README.md

@@ -28,23 +28,23 @@ A 终端看不到 B 终端里有哪个会话、在干什么，也没法把一条
 > `locatePkgJson()` 对子路径行返回 undefined），而插件页顶部标题与这一行共用同一份 `locale/zh.json` 的 meta，
 > 所以它单独做总开关，标题带「（总开关）」；卡片头用 `shortTitle` 显示短名「跨端互通」。
 
-**本版更新（0.8.2）**
+**本版更新（0.8.3）**
 
-- **死信不再无限重试**：投不出去的信按 20s / 1m / 5m / 15m / 1h 退避，连续 8 次移进 `<设备目录>/dead/`。
-- **收件人写设备名也能投**：`to` 写 `yoce-c-4fb38e` 这种设备名、或写错会话名时，自动回退到「最近活跃会话」，
-  并在正文注明回退原因（以前会一直留在对方 inbox 里重试）。
-- **同一个信封不会投两次**：文件名与信封 id 对齐（`state.seen`），同 id 的重复副本直接归档。
-- **补 A6**：`/crossterm/api/*` 全部要求 `Host` 是本机回环地址，挡 DNS rebinding 偷令牌。
+- **已归档会话不再反复备份**：备份前先读 DSH 的归档清单（`storages/workspace.json`），
+  归档会话第一次传完就标记，之后每轮直接跳过（本机 24 个已归档、9 个活跃中）。
+- **卡片细分**：「会话备份」行改成 `已归档 24/24 · 活跃中 9/9 · 43.1 MB · 上次 …`，
+  一眼看出哪类备份完了。
+- **活跃会话照旧增量**：从 `_session.json` 的水位往后传，不会重传整份。
 
-**上一版（0.8.1）**
+**上一版（0.8.2）**
 
-- 升级边角：旧布局缓存里没有签名密钥时，`relaySecret` 原来会一直不生成（验签等于没开），现在会重算并写回。
+- 死信按 20s / 1m / 5m / 15m / 1h 退避，8 次后进 `dead/`；收件人写设备名会回退「最近活跃会话」；
+  同一个信封不会投两次；`/crossterm/api/*` 要求本机回环 `Host`。
 
-**更早（0.8.0）— 安全加固**
+**更早（0.8.1 / 0.8.0）**
 
-- 附件名只认纯文件名 + 路径越界校验；本地写接口要 `x-crossterm-token`、外站 `Origin` 403；
-  信封带 HMAC-SHA256 签名；入站限额（信封 >512 KB 跳过、附件 ≤20、单个 >64 MB 拒收）；按 id 去重、先归档再记状态。
-- **要跟着动手**：账号生成 `relaySecret` 后，<0.8.0 设备发的未签名信封会被拒收，请全部升到 ≥0.8.0。
+- 0.8.1：旧布局缓存缺签名密钥时会重算并补写 `relaySecret`。
+- 0.8.0 安全加固：附件名净化 + 越界校验、写接口要 `x-crossterm-token`、信封 HMAC 签名、入站限额、按 id 去重。
 
 ## 一、安装与卸载
 

package/client/client.js

@@ -197,7 +197,11 @@ window.__ModuleLoader__.load({
 		function backupText(backup) {
 			if (!backup || !backup.files) return "还没有备份（会在开云同步后自动开始）";
 			const when = backup.lastAt ? agoText(backup.lastAt) : "未知";
-			return `${backup.files} 个会话 · ${sizeText(backup.bytes)} · 上次 ${when}`;
+			const parts = [];
+			if (typeof backup.archived === "number") parts.push(`已归档 ${Number(backup.archivedBackedUp || 0)}/${backup.archived}`);
+			if (typeof backup.active === "number") parts.push(`活跃中 ${Number(backup.activeBackedUp || 0)}/${backup.active}`);
+			const head = parts.length ? parts.join(" · ") : `${backup.files} 个会话`;
+			return `${head} · ${sizeText(backup.bytes)} · 上次 ${when}`;
 		}
 
 		function Card() {

package/lib/bus.js

@@ -22,7 +22,7 @@ import os from 'node:os'
 import path from 'node:path'
 import crypto from 'node:crypto'
 
-export const VERSION = '0.8.2'
+export const VERSION = '0.8.3'
 
 /** DSH 的家目录：与宿主其它状态（sessions / profiles）同一个根，多终端天然共享 */
 export function dshHome() {

package/lib/cloud/home.js

@@ -94,6 +94,7 @@ export function createCloudHome({ cfg, device, deviceInfo, pan, busDir, deliver,
         pan,
         layout,
         sessionsRoot,
+        dshHome: home,
         tmpDir: path.join(root, 'tmp'),
         stateFile: backupState,
         log: (line) => log('backup: ' + line),

package/lib/cloud/session-backup.js

@@ -12,7 +12,8 @@ const sha256 = (buf) => crypto.createHash('sha256').update(buf).digest('hex')
 function loadState(file) {
   try {
     const j = JSON.parse(fs.readFileSync(file, 'utf8'))
-    return { at: j.at || 0, sessions: j.sessions || {}, attachments: j.attachments || {} }
+    // 保留未知字段（lastRun 等），否则总结里的归档/活跃计数会被丢掉
+    return { ...j, at: j.at || 0, sessions: j.sessions || {}, attachments: j.attachments || {} }
   } catch {
     return { at: 0, sessions: {}, attachments: {} }
   }
@@ -25,8 +26,22 @@ function saveState(file, state) {
   } catch { /* ignore */ }
 }
 
+/**
+ * 已归档会话 id：DSH 存在 <DSH_HOME>/storages/workspace.json 的 global.archivedSessionIds。
+ * 读不到就当没有归档（不让备份因为读不到清单而停摆）。
+ */
+export function readArchivedIds(dshHome) {
+  try {
+    const j = JSON.parse(fs.readFileSync(path.join(dshHome, 'storages', 'workspace.json'), 'utf8'))
+    const ids = (j && j.global && j.global.archivedSessionIds) || []
+    return new Set(ids.filter((x) => typeof x === 'string' && x))
+  } catch {
+    return new Set()
+  }
+}
+
 /** 列出 <sessionsRoot>/<workspaceKey>/<sessionId>/session.v4.jsonl.zstd */
-export function listTranscripts(sessionsRoot) {
+export function listTranscripts(sessionsRoot, archivedSet) {
   const out = []
   let wsKeys = []
   try { wsKeys = fs.readdirSync(sessionsRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name) } catch { return out }
@@ -43,7 +58,7 @@ export function listTranscripts(sessionsRoot) {
       const full = path.join(dir, file)
       let st = null
       try { st = fs.statSync(full) } catch { continue }
-      out.push({ sessionId: id, workspaceKey: ws, dir, file: full, size: st.size, mtimeMs: st.mtimeMs })
+      out.push({ sessionId: id, workspaceKey: ws, dir, file: full, size: st.size, mtimeMs: st.mtimeMs, archived: Boolean(archivedSet && archivedSet.has(id)) })
     }
   }
   return out
@@ -76,19 +91,38 @@ function pickName(names, sessionId) {
  * @param {Function} [opts.log]
  * @param {number} [opts.maxSessions] 单轮最多处理多少个会话
  * @param {object} [opts.names] sessionId → { name, cwd }
+ * @param {string} [opts.dshHome] 用来读 storages/workspace.json 里的已归档会话清单
  */
-export async function backupSessions({ pan, layout, sessionsRoot, tmpDir, stateFile, log = () => {}, maxSessions = 40, names = {} }) {
+export async function backupSessions({ pan, layout, sessionsRoot, tmpDir, stateFile, log = () => {}, maxSessions = 40, names = {}, dshHome = '' }) {
   const state = loadState(stateFile)
   const remoteRoot = layout.paths.sessionDir
-  const all = listTranscripts(sessionsRoot)
-  const result = { ok: true, total: all.length, uploaded: 0, skipped: 0, bytes: 0, sessions: [], error: '' }
+  const archivedSet = dshHome ? readArchivedIds(dshHome) : new Set()
+  const all = listTranscripts(sessionsRoot, archivedSet)
+  const archivedAll = all.filter((x) => x.archived)
+  const activeAll = all.filter((x) => !x.archived)
+  const result = {
+    ok: true, total: all.length, uploaded: 0, skipped: 0, bytes: 0, sessions: [], error: '',
+    archived: { total: archivedAll.length, uploaded: 0, skipped: 0, done: archivedAll.filter((x) => state.sessions[x.sessionId] && state.sessions[x.sessionId].archived).length },
+    active: { total: activeAll.length, uploaded: 0, skipped: 0 },
+  }
   fs.mkdirSync(tmpDir, { recursive: true })
   let handled = 0
 
   for (const item of all) {
     if (handled >= maxSessions) break
     const prev = state.sessions[item.sessionId] || { bytes: 0, parts: 0 }
-    if (prev.bytes === item.size) { result.skipped += 1; continue }
+    // 已归档：备份过就不再备份（归档会话不会再写，重复上传纯属浪费云盘空间）
+    if (item.archived && prev.archived && prev.bytes === item.size) {
+      result.skipped += 1
+      result.archived.skipped += 1
+      continue
+    }
+    if (prev.bytes === item.size) {
+      result.skipped += 1
+      if (item.archived) result.archived.skipped += 1
+      else result.active.skipped += 1
+      continue
+    }
     handled += 1
     try {
       const remoteDir = `${remoteRoot}/${item.sessionId}`
@@ -121,10 +155,15 @@ export async function backupSessions({ pan, layout, sessionsRoot, tmpDir, stateF
         note: 'bytes = 已备份到的字节位置；下次只传 bytes 之后的新内容',
       }
       await pan.putBuffer(Buffer.from(JSON.stringify(marker, null, 2), 'utf8'), `${remoteDir}/_session.json`)
-      state.sessions[item.sessionId] = { bytes: item.size, parts: chunks.length, chunks, name: marker.name, cwd: marker.cwd, updatedAt: marker.updatedAt, fs_id: up.fs_id }
+      state.sessions[item.sessionId] = {
+        bytes: item.size, parts: chunks.length, chunks, name: marker.name, cwd: marker.cwd,
+        updatedAt: marker.updatedAt, fs_id: up.fs_id, archived: Boolean(item.archived),
+      }
       result.uploaded += 1
       result.bytes += buf.length
-      result.sessions.push({ sessionId: item.sessionId, name: marker.name, bytes: buf.length, from, part: name })
+      if (item.archived) result.archived.uploaded += 1
+      else result.active.uploaded += 1
+      result.sessions.push({ sessionId: item.sessionId, name: marker.name, bytes: buf.length, from, part: name, archived: Boolean(item.archived) })
       saveState(stateFile, { ...state, at: Date.now() })
     } catch (e) {
       result.ok = false
@@ -133,6 +172,14 @@ export async function backupSessions({ pan, layout, sessionsRoot, tmpDir, stateF
       break
     }
   }
+  const archivedDone = archivedAll.filter((x) => state.sessions[x.sessionId] && state.sessions[x.sessionId].archived).length
+  state.lastRun = {
+    at: Date.now(),
+    archivedTotal: archivedAll.length,
+    activeTotal: activeAll.length,
+    archivedDone,
+    activeDone: Math.max(0, Object.keys(state.sessions).length - archivedDone),
+  }
   saveState(stateFile, { ...state, at: Date.now() })
   return result
 }
@@ -186,12 +233,20 @@ export async function backupAttachments({ pan, layout, objectsRoot, stateFile, l
 export function backupSummary(stateFile) {
   const state = loadState(stateFile)
   const sessions = Object.values(state.sessions)
+  const run = state.lastRun || {}
+  const archivedBackedUp = Number(run.archivedDone || 0)
+  const activeBackedUp = Number(run.activeDone || 0)
   return {
     at: state.at || 0,
     lastAt: state.at || 0,
     sessions: sessions.length,
     files: sessions.length,
     lastCount: sessions.length,
+    archived: Number(run.archivedTotal || 0),
+    active: Number(run.activeTotal || 0),
+    archivedBackedUp,
+    activeBackedUp,
+    archivedUntouched: sessions.filter((s) => s.archived).length,
     bytes: sessions.reduce((a, s) => a + Number(s.bytes || 0), 0),
     attachments: Object.keys(state.attachments).length,
     attachmentBytes: Object.values(state.attachments).reduce((a, s) => a + Number(s.size || 0), 0),

package/lib/index.js

@@ -836,8 +836,12 @@ class CrossTerm {
     // 0.8.2 F14：收件人可能是会话名、短号、session-<uuid>，也可能是「设备名」（别的设备只写设备不写会话）。
     // 能解析的照常投；一个都解析不出来就退回「最近活跃会话」，别让信在 inbox 里每 20 秒重试到天荒地老。
     const resolvable = (raw) => {
-      if (/^session-[0-9a-z-]{8,}$/i.test(raw)) return true
-      return Boolean(this.resolveByName(raw))
+      // 必须真的在本机会话表里 —— resolveSessionId 找不到时会「原样返回」，只看返回值会把设备名当会话
+      const list = this.sessions()
+      const hit = list.find((s) => s.id === raw)
+      if (hit) return true
+      const byName = this.resolveByName(raw)
+      return Boolean(byName && list.some((s) => s.id === byName))
     }
     const unknown = rawTargets.filter((t) => !resolvable(t))
     let targets = rawTargets.filter(resolvable)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-crossterm",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "跨端互通：同一 DSH 账号下的会话、终端、设备之间互通 —— 特征码链、内联邮件、云端中转站与自动备份",
   "type": "module",
   "main": "./lib/index.js",