@device1999/dsh-session-archive-delete 0.0.0-stage → 0.1.0

package/cordis.patch.yml

@@ -0,0 +1,6 @@
+# Bundle patch layer: 把 dsh-session-archive-delete 插入 profile 的插件行。
+# 客户端脚本不走 dsh.client，而由宿主半通过 webserver/index-inject 以 <script> 注入
+# （与 dsh-local-patches / dsh1024 同一种机制）。
+- insert:
+    - id: dsh-session-archive-delete
+      name: '@device1999/dsh-session-archive-delete'

package/lib/backup.js

@@ -0,0 +1,221 @@
+/**
+ * dsh-session-archive-delete · 备份
+ *
+ * 把「一个会话」完整复制到它自己的文件夹里，逐文件校验大小与数量，通过后才返回。
+ * 目录结构与 delete-archived-sessions.ps1 完全一致，两边可以互相恢复：
+ *
+ *   <backupRoot>\<id前8位>-<标题>\
+ *     sessions\<工作区目录>\session-<完整id>\   会话原始文件（原名）
+ *     projcache\session-<完整id>.json           投影缓存（原名）
+ *     meta\workspace.json                       删除前的元数据快照
+ *     meta\session_projcache.json
+ *     manifest.json                             清单
+ *     RESTORE.txt / 恢复说明.txt                恢复步骤
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { listFiles, isInside, uniqueDir } from './paths.js'
+
+/**
+ * 按 dateStyle 生成备份文件夹名。
+ * dateStyle：
+ *   'default'      → 日期+主题          20261020_安装验证 DSH 插件
+ *   'id-title'     → ID前8位+主题       a6ccb2ee-安装验证 DSH 插件
+ *   'title'        → 纯主题             安装验证 DSH 插件
+ *   'id-title-date'→ 前八位+主题+日期    a6ccb2ee-安装验证 DSH 插件_20261020
+ * 日期一律紧凑格式 YYYYMMDD；重名由 uniqueDir 加 -2/-3。
+ */
+export function folderNameByStyle(dateStyle, sessionId, title, now) {
+  const d = now instanceof Date ? now : new Date()
+  const y = d.getFullYear()
+  const m = String(d.getMonth() + 1).padStart(2, '0')
+  const day = String(d.getDate()).padStart(2, '0')
+  const date = '' + y + m + day
+  const t = safeTitle(title)
+  const id8 = idPrefixOf(sessionId)
+  switch (dateStyle) {
+    case 'id-title':
+      return (id8 ? id8 + '-' : '') + t
+    case 'title':
+      return t
+    case 'id-title-date':
+      return (id8 ? id8 + '-' : '') + t + '_' + date
+    case 'default':
+    default:
+      return date + '_' + t
+  }
+}
+
+// 内部小工具：避免与 paths.js 的命名函数耦合
+import { safeFileName as _safeFileName, idPrefix as _idPrefix } from './paths.js'
+function safeTitle(title) {
+  const s = _safeFileName(title) || '未命名'
+  return s
+}
+function idPrefixOf(sessionId) {
+  try {
+    return _idPrefix(sessionId)
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * 比较源目录与备份目录：文件数一致、每个文件大小一致。
+ * @returns {string|null} 不一致原因；一致返回 null
+ */
+export function verifyCopy(srcRoot, dstRoot) {
+  const src = listFiles(srcRoot)
+  for (const f of src) {
+    const rel = path.relative(srcRoot, f)
+    const dst = path.join(dstRoot, rel)
+    if (!fs.existsSync(dst)) return '备份缺少文件：' + rel
+    const a = fs.statSync(f).size
+    const b = fs.statSync(dst).size
+    if (a !== b) return '备份大小不一致：' + rel
+  }
+  const dst = listFiles(dstRoot)
+  if (dst.length !== src.length) return '备份文件数不一致：源 ' + src.length + '，备份 ' + dst.length
+  return null
+}
+
+/**
+ * 备份一个会话。
+ *
+ * @param {object} p
+ * @param {string} p.backupRoot   备份根目录（必须已解析）
+ * @param {string} p.sessionId    完整会话 id
+ * @param {string} p.sessionDir   会话目录绝对路径
+ * @param {string|null} p.cacheFile 投影缓存文件绝对路径
+ * @param {string} p.workspace    工作区目录名（sessions 下的那层）
+ * @param {string} p.title        标题
+ * @param {object} p.snapshots    { workspaceJson, projcacheJson } 快照源路径
+ * @returns {{ok:boolean, dir?:string, name?:string, error?:string}}
+ */
+export function backupSession(p) {
+  const { backupRoot, sessionId, sessionDir, cacheFile, workspace, title, snapshots, extraSessions } = p
+
+  try {
+    if (!backupRoot) throw new Error('备份根目录为空')
+    fs.mkdirSync(backupRoot, { recursive: true })
+    if (!isInside(backupRoot, sessionDir)) {
+      // sessionDir 不必在 backupRoot 下，但必须是一个真实存在的会话目录
+      if (!fs.existsSync(sessionDir)) throw new Error('会话目录不存在：' + sessionDir)
+    }
+
+    const name = folderNameByStyle(p.dateStyle, sessionId, title)
+    const dir = uniqueDir(backupRoot, name)
+
+    const sessionsDst = path.join(dir, 'sessions')
+    const cacheDst = path.join(dir, 'projcache')
+    const metaDst = path.join(dir, 'meta')
+    for (const d of [sessionsDst, cacheDst, metaDst]) fs.mkdirSync(d, { recursive: true })
+
+    // 1) 会话目录：原名复制
+    const leaf = path.basename(sessionDir)
+    const sessTarget = path.join(sessionsDst, workspace, leaf)
+    fs.mkdirSync(path.dirname(sessTarget), { recursive: true })
+    fs.cpSync(sessionDir, sessTarget, { recursive: true, force: true, errorOnExist: false })
+    const problem = verifyCopy(sessionDir, sessTarget)
+    if (problem) throw new Error(problem)
+
+    // 2) 投影缓存：原名复制
+    let cacheLeaf = null
+    if (cacheFile && fs.existsSync(cacheFile)) {
+      cacheLeaf = path.basename(cacheFile)
+      fs.copyFileSync(cacheFile, path.join(cacheDst, cacheLeaf))
+      const a = fs.statSync(cacheFile).size
+      const b = fs.statSync(path.join(cacheDst, cacheLeaf)).size
+      if (a !== b) throw new Error('缓存备份大小不一致')
+    }
+
+    // 3) 元数据快照
+    const metaFiles = []
+    for (const src of [snapshots && snapshots.workspaceJson, snapshots && snapshots.projcacheJson]) {
+      if (src && fs.existsSync(src)) {
+        const n = path.basename(src)
+        fs.copyFileSync(src, path.join(metaDst, n))
+        metaFiles.push(n)
+      }
+    }
+
+    // 4) 子代理会话：一起备份进同一个文件夹（sessions/<工作区>/<目录名> + projcache）
+    const subagents = []
+    for (const sub of extraSessions || []) {
+      if (!sub || !sub.dir || !fs.existsSync(sub.dir)) continue
+      const subLeaf = path.basename(sub.dir)
+      const subWs = sub.workspace || workspace
+      const subTarget = path.join(sessionsDst, subWs, subLeaf)
+      try {
+        fs.mkdirSync(path.dirname(subTarget), { recursive: true })
+        fs.cpSync(sub.dir, subTarget, { recursive: true, force: true, errorOnExist: false })
+        const bad = verifyCopy(sub.dir, subTarget)
+        if (bad) throw new Error(bad)
+        // 子会话的投影缓存（存在就带上）
+        if (sub.cacheFile && fs.existsSync(sub.cacheFile)) {
+          fs.copyFileSync(sub.cacheFile, path.join(cacheDst, path.basename(sub.cacheFile)))
+        }
+        subagents.push({ id: sub.id, workspace: subWs, dirName: subLeaf })
+      } catch (err) {
+        // 子会话备份失败不阻断主会话，但记录下来
+        subagents.push({ id: sub.id, workspace: subWs, dirName: subLeaf, error: String((err && err.message) || err) })
+      }
+    }
+
+    // 5) 清单
+    const fileCount = listFiles(sessTarget).length
+    let bytes = 0
+    for (const f of listFiles(sessTarget)) bytes += fs.statSync(f).size
+
+    const manifest = {
+      schema: 3,
+      createdAt: new Date().toISOString(),
+      generator: 'dsh-session-archive-delete',
+      backupDir: dir,
+      layout: 'one folder per session; files keep their original names',
+      session: {
+        id: sessionId,
+        title: title || null,
+        workspace,
+        source: sessionDir,
+        files: fileCount,
+        bytes,
+        cacheFile: cacheFile || null,
+      },
+      subagents: subagents.length > 0 ? subagents : undefined,
+      metaFiles,
+    }
+    fs.writeFileSync(path.join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2), 'utf8')
+
+    // 6) 恢复说明
+    const restore = [
+      'DSH 会话备份（单会话）',
+      '========================',
+      '备份时间：' + new Date().toLocaleString(),
+      '会话 id ：' + sessionId,
+      '标题    ：' + (title || '（无）'),
+      '工作区  ：' + workspace,
+      subagents.length > 0 ? '子代理  ：' + subagents.length + ' 个（见下方说明）' : '',
+      '',
+      '如何恢复',
+      '--------',
+      '1. 完全退出 DSH。',
+      '2. 把 sessions\\' + workspace + '\\' + leaf + ' 复制回 ~/.dsh/sessions/' + workspace + '/',
+      '3. 把 projcache\\' + (cacheLeaf || '<缓存文件>') + ' 复制回 ~/.dsh/storages/session_projcache/sessions/',
+      '4. 在 ~/.dsh/storages/workspace.json 中把 session id 加回 global.archivedSessionIds',
+      '5. 启动 DSH。',
+      subagents.length > 0 ? '' : null,
+      subagents.length > 0 ? '子代理会话（同样复制回各自的 sessions\\<工作区>\\ 下）：' : null,
+      ...subagents.map((s) => '  - sessions\\' + s.workspace + '\\' + s.dirName + (s.error ? '（备份失败：' + s.error + '）' : '')),
+      '',
+      '注意：恢复前先关闭 DSH，否则它可能用内存里的旧状态覆盖元数据。',
+    ]
+      .filter((x) => x !== null)
+      .join('\r\n')
+    fs.writeFileSync(path.join(dir, 'RESTORE.txt'), restore, 'utf8')
+
+    return { ok: true, dir, name: path.basename(dir), subagents }
+  } catch (err) {
+    return { ok: false, error: String((err && err.message) || err) }
+  }
+}

package/lib/delete.js

@@ -0,0 +1,252 @@
+/**
+ * dsh-session-archive-delete · 删除
+ *
+ * 删除顺序参照 dsh-session-menu 的 removeSession，尽量做到「不留半删除会话」：
+ *   1. 运行中 → 取消当前轮次并等待结束（最长 3 秒），不阻塞
+ *   2. 先 detach 运行时，避免 dispose 阶段把日志目录写回来
+ *   3. 删除磁盘上的会话目录（删前确认目录名与会话 id 一致）
+ *   4. 删除后复查 3 次，防止句柄把目录重建
+ *   5. 最后才清理归档账本（unarchiveSession / unpinSession）
+ *
+ * 注意：预算备份由调用方在真正删除前完成，本模块只负责「删」。
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import { dshHome } from './paths.js'
+
+const SESSION_ID_RE = /^(session-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export function isValidSessionId(id) {
+  return SESSION_ID_RE.test(String(id || ''))
+}
+
+/**
+ * 静默停止运行中的 agent。
+ * @returns {boolean} 是否真的取消了一个正在运行的 agent
+ */
+async function stopIfRunning(ctx, sessionId) {
+  const agents = ctx.get ? ctx.get('agents') : ctx.agents
+  if (!agents || typeof agents.get !== 'function') return false
+  const agent = agents.get(sessionId)
+  if (!agent) return false
+  try {
+    if (typeof agent.cancel === 'function') agent.cancel({ kind: 'user' })
+  } catch {}
+  if (typeof agent.whenIdle === 'function') {
+    try {
+      await Promise.race([agent.whenIdle(), new Promise((r) => setTimeout(r, 3000))])
+    } catch {}
+  }
+  return true
+}
+
+/** 从运行时摘除会话，防止 dispose 阶段回写目录 */
+function detachLive(ctx, sessionId) {
+  const sessions = ctx.get ? ctx.get('sessions') : ctx.sessions
+  if (!sessions) return false
+  try {
+    const live = typeof sessions.get === 'function' ? sessions.get(sessionId) : undefined
+    if (!live) return false
+    if (typeof sessions.liveEntryFor === 'function' && typeof sessions.detachEntered === 'function') {
+      const entry = sessions.liveEntryFor(live)
+      if (entry !== undefined) {
+        sessions.detachEntered(entry)
+        return true
+      }
+    }
+  } catch {}
+  return false
+}
+
+/** 清掉归档 / 置顶账本里的记录（方法不存在时静默跳过） */
+async function forgetLedger(ctx, sessionId) {
+  const reg = ctx.get ? ctx.get('workspaceRegistry') : ctx.workspaceRegistry
+  if (!reg) return false
+  let touched = false
+  for (const m of ['unarchiveSession', 'unpinSession']) {
+    try {
+      if (typeof reg[m] === 'function') {
+        await reg[m](sessionId)
+        touched = true
+      }
+    } catch {}
+  }
+  return touched
+}
+
+/**
+ * 直接从 workspace.json 里摘掉会话引用（B 方案：先写账本，再删文件）。
+ *
+ * 为什么必须直接改文件：宿主的内存状态在删除后仍可能 flush 一次，
+ * 把 sessionIds / archivedSessionIds 又写回来。先落盘摘引用，
+ * 删文件后即使发生 flush，也只会带着「已摘除」的状态写回。
+ *
+ * 只动这三处，其他字段一字不改：
+ *   global.archivedSessionIds
+ *   global.pinnedSessionIds
+ *   tables.workspaces.*.sessionIds
+ *
+ * @returns {{ok:boolean, removed:number, error?:string}}
+ */
+function stripWorkspaceJson(sessionId) {
+  const home = dshHome()
+  const file = path.join(home, 'storages', 'workspace.json')
+  if (!fs.existsSync(file)) return { ok: false, removed: 0, error: 'workspace.json 不存在' }
+  try {
+    const raw = fs.readFileSync(file, 'utf8')
+    const doc = JSON.parse(raw)
+    const leaf = sessionId.replace(/^session-/, '')
+    const variants = new Set([sessionId, leaf, 'session-' + leaf])
+    let removed = 0
+    const keep = (arr) => {
+      if (!Array.isArray(arr)) return arr
+      const out = arr.filter((x) => !variants.has(String(x)))
+      removed += arr.length - out.length
+      return out
+    }
+    if (doc.global) {
+      if (Array.isArray(doc.global.archivedSessionIds)) doc.global.archivedSessionIds = keep(doc.global.archivedSessionIds)
+      if (Array.isArray(doc.global.pinnedSessionIds)) doc.global.pinnedSessionIds = keep(doc.global.pinnedSessionIds)
+    }
+    const workspaces = doc.tables && doc.tables.workspaces
+    if (workspaces && typeof workspaces === 'object') {
+      for (const key of Object.keys(workspaces)) {
+        const ws = workspaces[key]
+        if (ws && Array.isArray(ws.sessionIds)) ws.sessionIds = keep(ws.sessionIds)
+      }
+    }
+    if (removed > 0) {
+      const tmp = file + '.ad-tmp'
+      fs.writeFileSync(tmp, JSON.stringify(doc, null, 2), 'utf8')
+      fs.renameSync(tmp, file)
+    }
+    return { ok: true, removed }
+  } catch (e) {
+    return { ok: false, removed: 0, error: String((e && e.message) || e) }
+  }
+}
+
+/**
+ * 同步清理投影缓存索引（storages/session_projcache.json）。
+ * 只删 tables.sessions 下本会话那几条，其他结构不动。
+ */
+function stripProjCacheIndex(sessionId) {
+  const home = dshHome()
+  const file = path.join(home, 'storages', 'session_projcache.json')
+  if (!fs.existsSync(file)) return { ok: true, removed: 0 }
+  try {
+    const doc = JSON.parse(fs.readFileSync(file, 'utf8'))
+    const leaf = sessionId.replace(/^session-/, '')
+    const variants = new Set([sessionId, leaf, 'session-' + leaf])
+    let removed = 0
+    const sessions = doc && doc.tables && doc.tables.sessions
+    if (sessions && typeof sessions === 'object') {
+      for (const k of Object.keys(sessions)) {
+        if (variants.has(k)) {
+          delete sessions[k]
+          removed++
+        }
+      }
+    }
+    if (removed > 0) {
+      const tmp = file + '.ad-tmp'
+      fs.writeFileSync(tmp, JSON.stringify(doc, null, 2), 'utf8')
+      fs.renameSync(tmp, file)
+    }
+    return { ok: true, removed }
+  } catch (e) {
+    return { ok: false, removed: 0, error: String((e && e.message) || e) }
+  }
+}
+
+/**
+ * 删除一个会话。
+ *
+ * 执行顺序（B 方案）：
+ *   0. 先摘掉 workspace.json 里的引用并落盘  ← 防止删除后被内存 flush 写回
+ *   1. 运行中 → 取消当前轮次并等待结束（最长 3 秒）
+ *   2. detach 运行时，避免 dispose 阶段把日志目录写回
+ *   3. 删磁盘会话目录（删前校验目录名与会话 id 一致）
+ *   4. 复查 3 次，防止句柄把目录重建
+ *   5. 删投影缓存文件
+ *   6. 再摘一次引用（兜底：上面几步耗时期间可能又被写回）
+ *
+ * @param {object} ctx       插件上下文（提供 get）
+ * @param {string} sessionId 完整会话 id
+ * @param {string} sessionDir 会话目录绝对路径（删除前会做名字校验）
+ * @param {string} sessionsRoot sessions 根目录（边界校验）
+ * @param {string|null} cacheFile 投影缓存文件
+ * @returns {Promise<{ok:boolean, removed?:boolean, stopped?:boolean, detached?:boolean, ledger?:boolean, unlinked?:number, error?:string}>}
+ */
+export async function deleteSession({ ctx, sessionId, sessionDir, sessionsRoot, cacheFile }) {
+  if (!isValidSessionId(sessionId)) {
+    return { ok: false, error: 'invalid session id: ' + sessionId }
+  }
+
+  // 硬性边界：目录必须在 sessions 根下，且目录名就是会话 id
+  const resolvedDir = path.resolve(sessionDir)
+  const resolvedRoot = path.resolve(sessionsRoot || path.dirname(path.dirname(resolvedDir)))
+  if (!resolvedDir.startsWith(resolvedRoot + path.sep)) {
+    return { ok: false, error: '路径越界：' + resolvedDir }
+  }
+  if (path.basename(resolvedDir) !== sessionId) {
+    return { ok: false, error: '目录名与会话 id 不一致，拒绝删除：' + path.basename(resolvedDir) }
+  }
+
+  // 0) 先摘账本引用并落盘
+  const pre = stripWorkspaceJson(sessionId)
+  stripProjCacheIndex(sessionId)
+
+  const stopped = await stopIfRunning(ctx, sessionId)
+  const detached = detachLive(ctx, sessionId)
+
+  let removed = false
+  try {
+    if (fs.existsSync(resolvedDir)) {
+      fs.rmSync(resolvedDir, { recursive: true, force: true })
+      removed = true
+    }
+  } catch (err) {
+    return { ok: false, stopped, detached, error: '删除失败：' + String((err && err.message) || err) }
+  }
+
+  // 复查：句柄可能把目录重建
+  for (let i = 0; i < 3; i++) {
+    if (!fs.existsSync(resolvedDir)) break
+    await new Promise((r) => setTimeout(r, 150))
+    try {
+      fs.rmSync(resolvedDir, { recursive: true, force: true })
+    } catch {}
+  }
+  if (fs.existsSync(resolvedDir)) {
+    return { ok: false, stopped, detached, error: '目录删除后又被重建：' + resolvedDir }
+  }
+
+  // 缓存文件
+  if (cacheFile && fs.existsSync(cacheFile)) {
+    try {
+      fs.rmSync(cacheFile, { force: true })
+    } catch {}
+  }
+
+  const ledger = await forgetLedger(ctx, sessionId)
+
+  // 6) 兜底：上面耗时期间内存可能又 flush 写回，再摘一次
+  await new Promise((r) => setTimeout(r, 200))
+  const post = stripWorkspaceJson(sessionId)
+  stripProjCacheIndex(sessionId)
+  if (cacheFile && fs.existsSync(cacheFile)) {
+    try {
+      fs.rmSync(cacheFile, { force: true })
+    } catch {}
+  }
+
+  return {
+    ok: true,
+    removed,
+    stopped,
+    detached,
+    ledger,
+    unlinked: Math.max(pre.removed || 0, post.removed || 0),
+  }
+}