@mzzsfy/dsh-session-manager 0.7.1 → 0.9.0

package/test/parity.test.mjs

@@ -211,17 +211,6 @@ test('源码契约:client 分页粒度常量与 core ARCHIVE_PAGE_SIZE 同值',
   assert.ok(guard.test(CLIENT_SRC), 'client 分页粒度常量与 core 漂移')
 })
 
-test('源码契约:client fetchInputs 必须解包 host 响应信封 { inputs }', () => {
-  // host 与 client 对信封各自测试自洽时,信封形状漂移只会以运行时 TypeError 暴露;
-  // 此守卫锁定解包点存在,防消费侧把信封对象当数组使用
-  const guard = /Array\.isArray\((\w+)\.inputs\)/
-  assert.ok(guard.test('Array.isArray(payload.inputs)'), '守卫正则必须命中合规样本')
-  const fetchStart = CLIENT_SRC.indexOf('function fetchInputs(')
-  const fetchBody = fetchStart >= 0 ? CLIENT_SRC.slice(fetchStart, CLIENT_SRC.indexOf('}', fetchStart)) : ''
-  assert.ok(fetchBody.includes('api(INPUTS_URL'), '未找到 fetchInputs 的 host 请求')
-  assert.ok(guard.test(fetchBody), 'fetchInputs 缺少 payload.inputs 数组解包')
-})
-
 test('parity 文案:client 确认态文案与 host MESSAGES.unsupportedBackend 同值', () => {
   const match = INDEX_SRC.match(/unsupportedBackend: '([^']+)'/)
   assert.ok(match, 'index.js 缺少 unsupportedBackend 文案')

package/test/trash.test.mjs

@@ -2,11 +2,11 @@
 
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { mkdtemp, writeFile, rm, access } from 'node:fs/promises'
+import { mkdtemp, mkdir, writeFile, readFile, rm, access } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
 
-import { TRASH_ENV_NAME, trashCommandFor, trashPath } from '../src/trash.mjs'
+import { TRASH_ENV_NAME, moveToQuarantine, restoreFromQuarantine, trashCommandFor, trashPath } from '../src/trash.mjs'
 
 test('Windows 走 PowerShell VisualBasic 回收站,路径经环境变量传递', () => {
   const cmd = trashCommandFor('win32', 'C:\\logs\\a.jsonl')
@@ -71,3 +71,74 @@ test('trashPath 向执行器传递超时配置', async () => {
   await trashPath('C:\\x\\a.jsonl', { platform: 'linux', run, timeoutMs: 5 * 1000 })
   assert.equal(captured[1].timeout, 5 * 1000)
 })
+
+// Given 回收区目录不存在与同名基名, When moveToQuarantine, Then 目录整体搬入回收区
+// 且返回唯一暂存路径(原路径消失,暂存路径存在)
+test('moveToQuarantine:目录整体搬入回收区并返回暂存路径(真实 rename)', { skip: process.platform !== 'win32' && process.platform !== 'linux' && process.platform !== 'darwin' }, async () => {
+  const base = await mkdtemp(path.join(tmpdir(), 'dsh-quarantine-'))
+  const quarantineDir = path.join(base, 'held')
+  const artifactDir = path.join(base, 'sess-1')
+  await mkdir(path.join(artifactDir, 'inner'), { recursive: true })
+  await writeFile(path.join(artifactDir, 'inner', 'a.jsonl'), '{"header":1}\n')
+  try {
+    const heldPath = await moveToQuarantine(artifactDir, quarantineDir)
+    assert.ok(heldPath.startsWith(quarantineDir), '暂存路径应在回收区目录内')
+    await assert.rejects(access(artifactDir), '原路径应消失')
+    const moved = await readFile(path.join(heldPath, 'inner', 'a.jsonl'), 'utf8')
+    assert.equal(moved, '{"header":1}\n')
+  } finally {
+    await rm(base, { recursive: true, force: true })
+  }
+})
+
+// Given rename 因跨设备失败(EXDEV), When moveToQuarantine, Then 回退为复制后删除原路径
+test('moveToQuarantine:EXDEV 回退复制+删除(注入 fs)', async () => {
+  const calls = []
+  const fakeFs = {
+    rename: async (from, to) => {
+      calls.push(['rename', from, to])
+      throw Object.assign(new Error('cross-device'), { code: 'EXDEV' })
+    },
+    cp: async (from, to) => { calls.push(['cp', from, to]) },
+    rm: async (target) => { calls.push(['rm', target]) },
+    mkdir: async () => { calls.push(['mkdir']) },
+  }
+  const heldPath = await moveToQuarantine('/data/sess-1', '/home/.dsh/held', { fs: fakeFs, now: () => 1234 })
+  assert.equal(heldPath, path.join('/home/.dsh/held', 'sess-1-1234'))
+  assert.deepEqual(calls, [
+    ['mkdir'],
+    ['rename', '/data/sess-1', heldPath],
+    ['cp', '/data/sess-1', heldPath],
+    ['rm', '/data/sess-1'],
+  ])
+})
+
+// Given 回收区暂存的目录与空缺的原位置, When restoreFromQuarantine, Then 目录回到原位置且暂存消失
+test('restoreFromQuarantine:移回原位置且暂存消失(真实 rename)', { skip: process.platform !== 'win32' && process.platform !== 'linux' && process.platform !== 'darwin' }, async () => {
+  const base = await mkdtemp(path.join(tmpdir(), 'dsh-quarantine-'))
+  const quarantineDir = path.join(base, 'held')
+  const originalDir = path.join(base, 'sess-2')
+  await mkdir(path.join(originalDir, 'inner'), { recursive: true })
+  await writeFile(path.join(originalDir, 'inner', 'a.jsonl'), '{"header":1}\n')
+  try {
+    const heldPath = await moveToQuarantine(originalDir, quarantineDir)
+    await restoreFromQuarantine(heldPath, originalDir)
+    await assert.rejects(access(heldPath), '暂存路径应消失')
+    const restored = await readFile(path.join(originalDir, 'inner', 'a.jsonl'), 'utf8')
+    assert.equal(restored, '{"header":1}\n')
+  } finally {
+    await rm(base, { recursive: true, force: true })
+  }
+})
+
+// Given rename 因原位置已被占用而失败, When restoreFromQuarantine, Then 错误原样抛出由调用方响应
+test('restoreFromQuarantine:原位置已存在时失败上抛(注入 fs)', async () => {
+  const occupied = Object.assign(new Error('not empty'), { code: 'ENOTEMPTY' })
+  const fakeFs = {
+    rename: async () => { throw occupied },
+    cp: async () => { throw new Error('不应回退复制') },
+    rm: async () => { throw new Error('不应删除') },
+    mkdir: async () => {},
+  }
+  await assert.rejects(restoreFromQuarantine('/held/s1', '/data/s1', { fs: fakeFs }), (error) => error.code === 'ENOTEMPTY')
+})

package/src/history-cache.mjs

@@ -1,127 +0,0 @@
-// 历史输入工作区缓存:每工作区一个 JSON 文件(~/.dsh/historyPrompt/<工作区>-<hash>.json),
-// 记录该工作区聚合后的人类输入(带 sid 溯源)。浮层请求直接读文件(毫秒级)立即返回,
-// 对齐在后台解压最新产物与缓存合并写回——解压成本不落在用户等待路径上。
-// extracts 段持久化每会话的提取结果与其产物 stat 指纹(mtimeMs+size):
-// 对齐时先 stat 比对指纹,产物没变的会话不再解压——判断完全基于磁盘,跨重启生效。
-// 文件名 = 工作区路径末段(可辨认)+ 路径哈希前缀(防不同目录同名冲突)
-
-import { createHash } from 'node:crypto'
-import { mkdir, readFile, readdir, stat, writeFile, rename } from 'node:fs/promises'
-import { dirname, join, sep } from 'node:path'
-
-function workspaceFile(dir, cwd) {
-  const leaf = cwd.split(/[\\/]/).filter(Boolean).pop() || 'root'
-  const hash = createHash('sha1').update(cwd).digest('hex').slice(0, 8)
-  return join(dir, `${leaf}-${hash}.json`)
-}
-
-export function ensureCacheDir(dir) {
-  return mkdir(dir, { recursive: true })
-}
-
-function normalize(parsed, cwd) {
-  if (!parsed || parsed.cwd !== cwd || !Array.isArray(parsed.entries)) return null
-  return {
-    cwd,
-    entries: parsed.entries,
-    extracts: parsed.extracts && typeof parsed.extracts === 'object' ? parsed.extracts : {},
-  }
-}
-
-export async function readWorkspaceCache(dir, cwd) {
-  try {
-    return normalize(JSON.parse(await readFile(workspaceFile(dir, cwd), 'utf8')), cwd)
-  } catch {
-    return null
-  }
-}
-
-// 原子写:先写临时文件再改名,进程中断不会留下半截 JSON
-export async function writeWorkspaceCache(dir, cwd, cache) {
-  await ensureCacheDir(dir)
-  const target = workspaceFile(dir, cwd)
-  const tmp = target + '.tmp'
-  await writeFile(tmp, JSON.stringify({ cwd, entries: cache.entries, extracts: cache.extracts }, null, 0), 'utf8')
-  await rename(tmp, target)
-}
-
-// global 浮层轮询用指纹缓存:每 3s 轮询都全量读取并 JSON.parse 所有工作区缓存文件,
-// 单文件 entries 可达数百条,持续打开浮层时是秒级重复大 IO+CPU。以 (mtimeMs,size)
-// 指纹复用上次解析结果,产物未变的文件不再读盘;写入侧经临时文件改名,mtime 必变,
-// 指纹天然失效。模块级 Map 以全路径为键(防多目录同名文件串扰),条目数有界。
-const globalCachePollState = new Map()
-
-export async function listWorkspaceCachesCached(dir) {
-  let names
-  try {
-    names = await readdir(dir)
-  } catch {
-    // 目录缺失/不可读:仅清本目录条目(分隔符锚定,防误清兄弟目录),条目自愈
-    for (const key of globalCachePollState.keys()) {
-      if (key.startsWith(dir + sep)) globalCachePollState.delete(key)
-    }
-    return []
-  }
-  const live = new Set()
-  const caches = await Promise.all(names
-    .filter((name) => name.endsWith('.json') && name !== PROMPTS_FILE)
-    .map(async (name) => {
-      const file = join(dir, name)
-      live.add(file)
-      let fingerprint
-      try {
-        const info = await stat(file)
-        fingerprint = { mtimeMs: info.mtimeMs, size: info.size }
-      } catch {
-        globalCachePollState.delete(file)
-        return null
-      }
-      const hit = globalCachePollState.get(file)
-      if (hit !== undefined && hit.fp.mtimeMs === fingerprint.mtimeMs && hit.fp.size === fingerprint.size) {
-        return hit.parsed
-      }
-      try {
-        const parsed = JSON.parse(await readFile(file, 'utf8'))
-        if (!parsed || typeof parsed.cwd !== 'string' || !Array.isArray(parsed.entries)) {
-          globalCachePollState.delete(file)
-          return null
-        }
-        globalCachePollState.set(file, { fp: fingerprint, parsed })
-        return parsed
-      } catch {
-        globalCachePollState.delete(file)
-        return null
-      }
-    }))
-  for (const key of globalCachePollState.keys()) {
-    if (!live.has(key)) globalCachePollState.delete(key)
-  }
-  return caches.filter((cache) => cache && typeof cache.cwd === 'string' && Array.isArray(cache.entries))
-}
-
-// 常用提示词:全局单文件(不按工作区),记录用户显式收藏的输入文本。
-// 收藏是用户意志,与自动对齐的历史缓存互不覆写
-const PROMPTS_FILE = 'prompts.json'
-
-function normalizePrompts(parsed) {
-  if (!parsed || !Array.isArray(parsed.items)) return []
-  return parsed.items
-    .filter((item) => item && typeof item.text === 'string' && item.text.length > 0)
-    .map((item) => ({ text: item.text, at: typeof item.at === 'number' ? item.at : 0 }))
-}
-
-export async function readPrompts(dir) {
-  try {
-    return normalizePrompts(JSON.parse(await readFile(join(dir, PROMPTS_FILE), 'utf8')))
-  } catch {
-    return []
-  }
-}
-
-export async function writePrompts(dir, items) {
-  await ensureCacheDir(dir)
-  const target = join(dir, PROMPTS_FILE)
-  const tmp = target + '.tmp'
-  await writeFile(tmp, JSON.stringify({ items }, null, 0), 'utf8')
-  await rename(tmp, target)
-}

package/test/history-cache.test.mjs

@@ -1,84 +0,0 @@
-// global 浮层轮询指纹缓存 BDD:stat 指纹命中不重复读盘,产物变更即失效,
-// 删除/损坏文件与目录缺失不残留缓存条目。
-
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtemp, writeFile, utimes, rm, readdir, mkdir } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-const { listWorkspaceCachesCached } = await import('../src/history-cache.mjs')
-
-async function makeDir(t) {
-  const dir = await mkdtemp(join(tmpdir(), 'sm-fp-cache-'))
-  t.after(() => rm(dir, { recursive: true, force: true }))
-  return dir
-}
-
-async function writeCache(dir, name, cwd, entries, mtime) {
-  const file = join(dir, name)
-  await writeFile(file, JSON.stringify({ cwd, entries }), 'utf8')
-  if (mtime !== undefined) await utimes(file, mtime, mtime)
-  return file
-}
-
-test('指纹命中:产物未变时复用解析结果,内容对象同引用', async (t) => {
-  const dir = await makeDir(t)
-  await writeCache(dir, 'a-1.json', 'C:\\a', [{ sid: 's1', text: 'x' }])
-  const first = await listWorkspaceCachesCached(dir)
-  assert.equal(first.length, 1)
-  assert.equal(first[0].cwd, 'C:\\a')
-  // When 再次读取(文件未动)
-  const second = await listWorkspaceCachesCached(dir)
-  // Then 指纹命中,返回缓存中的同一解析对象
-  assert.equal(second[0], first[0])
-})
-
-test('指纹失效:文件内容变更后重读,新内容可见', async (t) => {
-  const dir = await makeDir(t)
-  const stamp = new Date()
-  const file = await writeCache(dir, 'b-1.json', 'C:\\b', [{ sid: 's1', text: 'old' }], stamp)
-  const first = await listWorkspaceCachesCached(dir)
-  assert.equal(first[0].entries[0].text, 'old')
-  // When 追加条目并推进 mtime(写入侧经临时文件改名,mtime 必变)
-  await writeFile(file, JSON.stringify({ cwd: 'C:\\b', entries: [{ sid: 's1', text: 'old' }, { sid: 's2', text: 'new' }] }), 'utf8')
-  const later = new Date(stamp.getTime() + 2000)
-  await utimes(file, later, later)
-  const second = await listWorkspaceCachesCached(dir)
-  // Then 新内容可见
-  assert.equal(second[0].entries.length, 2)
-  assert.equal(second[0].entries[1].text, 'new')
-})
-
-test('卫生:文件删除与目录缺失清空对应缓存', async (t) => {
-  const dir = await makeDir(t)
-  const file = await writeCache(dir, 'c-1.json', 'C:\\c', [])
-  await listWorkspaceCachesCached(dir)
-  // When 删除文件后再读
-  await rm(file)
-  const afterRemove = await listWorkspaceCachesCached(dir)
-  // Then 结果为空(目录仍在,缓存条目清除)
-  assert.deepEqual(afterRemove, [])
-  // When 目录整个消失(缓存目录被手工清理)
-  await rm(dir, { recursive: true, force: true })
-  const afterDirGone = await listWorkspaceCachesCached(dir)
-  // Then 返回空数组不抛
-  assert.deepEqual(afterDirGone, [])
-  // 目录恢复后缓存可重建
-  await mkdir(dir, { recursive: true })
-  assert.deepEqual(await readdir(dir), [])
-  await writeCache(dir, 'd-1.json', 'C:\\d', [{ sid: 's9', text: 'fresh' }])
-  const rebuilt = await listWorkspaceCachesCached(dir)
-  assert.equal(rebuilt.length, 1)
-  assert.equal(rebuilt[0].entries[0].text, 'fresh')
-})
-
-test('过滤:损坏文件与 prompts.json 不进结果', async (t) => {
-  const dir = await makeDir(t)
-  await writeFile(join(dir, 'broken.json'), '{not json', 'utf8')
-  await writeFile(join(dir, 'prompts.json'), JSON.stringify({ items: [] }), 'utf8')
-  await writeCache(dir, 'ok-1.json', 'C:\\ok', [])
-  const caches = await listWorkspaceCachesCached(dir)
-  assert.equal(caches.length, 1)
-  assert.equal(caches[0].cwd, 'C:\\ok')
-})