@wangxiaocuo/dsh-session-trash 0.6.1 → 0.6.3

package/lib/errors.js

@@ -62,16 +62,76 @@ export function statusOf(error) {
   return ERROR_STATUS[code] ?? 500
 }
 
+/**
+ * Detail keys the Host may return to the Client. Anything else - notably raw
+ * filesystem paths or nested error text - stays in the Host log, because the
+ * wire contract promises that the trash root's absolute path is never exposed.
+ */
+const SAFE_DETAIL_KEYS = new Set([
+  'sessionId',
+  'trashId',
+  'code',
+  'phase',
+  'copied',
+  'kind',
+  'targetKind',
+  'expected',
+  'measured',
+  'activity',
+  'descendants',
+  'sessions',
+])
+
+/**
+ * Metrics snapshots are the only nested detail value the Host returns; keep
+ * only their numeric counters so no path can ride along.
+ *
+ * @param {unknown} value candidate metrics object.
+ * @returns {object | undefined} the numeric metrics.
+ */
+function sanitizeMetrics(value) {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return undefined
+  const safe = {}
+  for (const key of ['sizeBytes', 'fileCount', 'symlinkCount']) {
+    if (typeof value[key] === 'number') safe[key] = value[key]
+  }
+  return Object.keys(safe).length === 0 ? undefined : safe
+}
+
+/**
+ * @param {unknown} details arbitrary structured context.
+ * @returns {object | undefined} the same context restricted to whitelisted keys.
+ */
+export function sanitizeDetails(details) {
+  if (details === null || typeof details !== 'object' || Array.isArray(details)) return undefined
+  const safe = {}
+  for (const [key, value] of Object.entries(details)) {
+    if (!SAFE_DETAIL_KEYS.has(key)) continue
+    if (key === 'expected' || key === 'measured') {
+      const metrics = sanitizeMetrics(value)
+      if (metrics !== undefined) safe[key] = metrics
+      continue
+    }
+    if (Array.isArray(value)) {
+      safe[key] = value.filter((item) => typeof item === 'string' || typeof item === 'number')
+      continue
+    }
+    if (value === null || ['string', 'number', 'boolean'].includes(typeof value)) safe[key] = value
+  }
+  return Object.keys(safe).length === 0 ? undefined : safe
+}
+
 /**
  * @param {unknown} error arbitrary thrown value.
  * @returns {{ code: string, message: string, details?: object }} the wire error shape.
  */
 export function toWireError(error) {
   if (error instanceof TrashError) {
+    const details = sanitizeDetails(error.details)
     return {
       code: error.code,
       message: error.message,
-      ...(error.details === undefined ? {} : { details: error.details }),
+      ...(details === undefined ? {} : { details }),
     }
   }
   const message = error instanceof Error ? error.message : String(error)

package/lib/fsops.js

@@ -294,6 +294,11 @@ export function metricsMatch(entry, measured) {
   if (entry === null || entry === undefined) return true
   if (typeof entry.sizeBytes === 'number' && entry.sizeBytes !== measured.sizeBytes) return false
   if (typeof entry.fileCount === 'number' && entry.fileCount !== measured.fileCount) return false
+  // A cross-device copy records the symlink count of the source; comparing it
+  // catches a symlink that the copy silently dropped.
+  if (typeof entry.symlinkCount === 'number' && typeof measured.symlinkCount === 'number' && entry.symlinkCount !== measured.symlinkCount) {
+    return false
+  }
   return true
 }
 
@@ -356,10 +361,12 @@ async function copyAcrossDevices(source, destination, expected, rename, copy) {
   try {
     await fs.rm(source, { recursive: true, force: false, maxRetries: 3, retryDelay: 100 })
   } catch (error) {
+    // The paths stay in the Host log; the wire error only carries the error
+    // code and the fact that a verified copy already exists.
     throw new TrashError(
       'IO_ERROR',
       'The session was copied to the destination, but the source could not be removed.',
-      { source, destination, code: errorCode(error) ?? null, copied: true },
+      { code: errorCode(error) ?? null, copied: true },
     )
   }
 }

package/lib/state.js

@@ -5,6 +5,34 @@ import { memberList } from './members.js'
 /** Maximum concurrent filesystem probes while describing entries. */
 const PROBE_CONCURRENCY = 3
 
+/**
+ * Known failure families recorded in `lastError`, in match order. The raw text
+ * stays an English diagnostic for logs and tooltips; the code is what the
+ * Client localizes.
+ */
+const LAST_ERROR_KINDS = [
+  [/^The trash copy of this session is missing\./, 'TRASH_COPY_MISSING'],
+  [/^The trash copy is missing these member sessions:/, 'TRASH_COPY_MISSING_MEMBERS'],
+  [/^The trash object directory is missing\./, 'TRASH_OBJECT_MISSING'],
+  [/^The session log could not be deleted:/, 'PURGE_FAILED'],
+  [/^The restored session (tree )?(is|was) not visible to session storage\./, 'RESTORE_INVISIBLE'],
+  [/^Session storage still reports the moved session tree/, 'MOVE_UNSETTLED'],
+  [/^An original session directory unexpectedly exists/, 'SOURCE_CONFLICT'],
+  [/^The trash index could not be committed/, 'INDEX_WRITE_FAILED'],
+]
+
+/**
+ * @param {unknown} message raw `lastError` text.
+ * @returns {string | null} a stable failure family, or null when none was recorded.
+ */
+export function lastErrorCode(message) {
+  if (typeof message !== 'string' || message === '') return null
+  for (const [pattern, code] of LAST_ERROR_KINDS) {
+    if (pattern.test(message)) return code
+  }
+  return 'IO_ERROR'
+}
+
 /**
  * @param {string | null | undefined} directory candidate workspace directory.
  * @returns {Promise<boolean>} whether the directory exists right now.
@@ -31,7 +59,14 @@ async function directoryExists(directory) {
  * }} deps state inputs.
  * @returns {{ snapshot: () => Promise<object>, describe: (entry: object) => Promise<object> }} the state service.
  */
-export function createStateService({ store, config, trashRootDisplay, nextSweepAt = () => null, cleanup }) {
+export function createStateService({
+  store,
+  config,
+  trashRootDisplay,
+  nextSweepAt = () => null,
+  cleanup,
+  directoryExists: probeDirectory = directoryExists,
+}) {
   /**
    * @returns {object} cleanup diagnostics, or a neutral fallback.
    */
@@ -58,11 +93,17 @@ export function createStateService({ store, config, trashRootDisplay, nextSweepA
 
   /**
    * @param {object} entry committed index entry.
+   * @param {Map<string, Promise<boolean>>} [probeCache] workspace probes already
+   *   started for this snapshot, so entries sharing a cwd probe it once.
    * @returns {Promise<object>} the wire entry.
    */
-  async function describeEntry(entry) {
+  async function describeEntry(entry, probeCache = new Map()) {
     const cwd = typeof entry.originalCwd === 'string' && entry.originalCwd !== '' ? entry.originalCwd : null
-    const workspaceNowExists = cwd === null ? null : await directoryExists(cwd)
+    let workspaceNowExists = null
+    if (cwd !== null) {
+      if (!probeCache.has(cwd)) probeCache.set(cwd, probeDirectory(cwd))
+      workspaceNowExists = await probeCache.get(cwd)
+    }
     const expiresAt =
       typeof entry.trashedAt === 'number' && entry.trashedAt > 0 ? entry.trashedAt + config.retentionDays * 86_400_000 : null
     const trashed = entry.state === 'trashed'
@@ -85,6 +126,7 @@ export function createStateService({ store, config, trashRootDisplay, nextSweepA
       canForget: entry.state === 'missing',
       requiresOrphanRestore: cwd !== null && workspaceNowExists === false,
       lastError: entry.lastError ?? null,
+      lastErrorCode: lastErrorCode(entry.lastError),
       subagentCount: Math.max(0, members.length - 1),
       members: members.map((member) => ({
         sessionId: member.sessionId,
@@ -104,7 +146,8 @@ export function createStateService({ store, config, trashRootDisplay, nextSweepA
      * @returns {Promise<object>} the complete `/state` response body.
      */
     async snapshot() {
-      const entries = await mapLimit(store.entries(), PROBE_CONCURRENCY, (entry) => describeEntry(entry))
+      const probeCache = new Map()
+      const entries = await mapLimit(store.entries(), PROBE_CONCURRENCY, (entry) => describeEntry(entry, probeCache))
       let totalBytes = 0
       let failedEntries = 0
       for (const entry of entries) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wangxiaocuo/dsh-session-trash",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "DeepSeek Harness plugin: move cold sessions into a recoverable trash, restore them within the retention window, or delete their logs permanently.",
   "license": "MIT",
   "author": "wangxiaocuo",
@@ -40,11 +40,12 @@
     "locale/*.json",
     "icon.svg",
     "README.md",
-    "README.en.md"
+    "README.en.md",
+    "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "node --test test/*.test.js",
-    "test:coverage": "node --experimental-test-coverage --test test/*.test.js",
+    "test": "node test/run-unit.mjs",
+    "test:coverage": "node test/run-unit.mjs --experimental-test-coverage",
     "test:e2e": "node test/e2e-web.mjs",
     "test:smoke": "node test/smoke-host.mjs"
   },