dsh-session-manager 0.6.4 → 0.7.0

package/lib/index.js

@@ -22,10 +22,12 @@
  * The compatibility adapter normalizes service access and list snapshots.
  * Optional live-writer/coordinator internals are guarded before mutation.
  */
+import { statSync } from "node:fs";
 import { lstat, mkdir, readdir, realpath, rename, rm } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
 import { createAnnotationStore } from "./annotation-store.js";
+import { createWorkspaceArchiveStore, assertWorkspaceId } from "./workspace-archive-store.js";
 import { createDshAdapter, normalizeSessionHeader, compareSemver } from "./compat/dsh-adapter.js";
 import { ARTIFACT_NAMES, assertSessionId, assertSessionDirectory, encodeSessionSegment, parseSessionGenerationFromFilename, readSessionHeader, readSessionFile, writeTempFile, replaceSessionFile } from "./session-files.js";
 
@@ -169,7 +171,7 @@ const listSessionHeaders = async (persistence, dshHome) => (await scanSessionHea
 
 export function apply(ctx) {
   try {
-    const buildId = "dsh-session-manager v0.5.2+release-17 (clearSelection-keeps-bulk-mode-on)";
+    const buildId = "dsh-session-manager v0.7.0 (workspace-archive)";
     if (typeof ctx?.logger?.info === "function") ctx.logger.info(buildId);
     else if (typeof console !== "undefined" && console?.info) console.info(buildId);
   } catch (_) { /* ignore logging failures */ }
@@ -183,6 +185,21 @@ export function apply(ctx) {
     }
     return annotationStore;
   };
+  let workspaceArchiveStore;
+  const workspaceArchives = () => {
+    if (!workspaceArchiveStore) {
+      const home = adapter.homePath;
+      if (typeof home === "function") {
+        try {
+          workspaceArchiveStore = createWorkspaceArchiveStore(home("dsh-session-manager"));
+        } catch (_) {}
+      }
+      if (!workspaceArchiveStore) {
+        workspaceArchiveStore = createWorkspaceArchiveStore(null, { memory: true });
+      }
+    }
+    return workspaceArchiveStore;
+  };
   const assertAnnotatable = id => {
     const registry = adapter.workspaceRegistry;
     if (adapter.getSession(id) !== undefined || registry?.headers?.has?.(id)
@@ -360,18 +377,26 @@ export function apply(ctx) {
   /** Ordered workspace projection for the client. */
   const listWorkspaces = () => {
     return ctx.workspaceRegistry.list().map((entity) => {
-        const rawIds = Array.isArray(entity.record?.sessionIds)
-          ? [...entity.record.sessionIds]
-          : [...entity.sessionIds];
-        return {
-                  id: entity.id,
-                  name: entity.title || entity.id,
-          title: entity.title || entity.id,
-          path: entity.path,
-                  sessionCount: rawIds.length,
-          sessionIds: rawIds
-          };
-
+      const rawIds = Array.isArray(entity.record?.sessionIds)
+        ? [...entity.record.sessionIds]
+        : [...entity.sessionIds];
+      let selfUpdatedAt = entity.updatedAt ?? entity.record?.updatedAt ?? null;
+      if (selfUpdatedAt === null && entity.path) {
+        try {
+          const st = statSync(entity.path);
+          selfUpdatedAt = st.mtimeMs;
+        } catch (_) {}
+      }
+      return {
+        id: entity.id,
+        name: entity.title || entity.id,
+        title: entity.title || entity.id,
+        path: entity.path,
+        sessionCount: rawIds.length,
+        sessionIds: rawIds,
+        updatedAt: selfUpdatedAt,
+        createdAt: entity.createdAt ?? entity.record?.createdAt ?? null
+      };
     });
   };
 
@@ -1393,8 +1418,10 @@ ${rest}`, "utf8");
         if (req.method === "POST" && ["/delete", "/unarchive", "/move", "/preset-migrate"].includes(path)) {
           assertSessionId(sessionId);
           let result;
-          if (path === "/delete") result = await mutate(sessionId, () => deleteSession(sessionId));
-          else if (path === "/unarchive") {
+          if (path === "/delete") {
+            result = await mutate(sessionId, () => deleteSession(sessionId));
+            try { await workspaceArchives().removeSession(sessionId); } catch (_) {}
+          } else if (path === "/unarchive") {
             await mutate(sessionId, () => unarchiveSession(sessionId));
             result = { sessionId };
           } else if (path === "/move") {
@@ -1408,6 +1435,38 @@ ${rest}`, "utf8");
           }
           return send(res, 200, { ok: true, result });
         }
+        if (req.method === "POST" && path === "/workspace-archive") {
+          const workspaceId = typeof body.workspaceId === "string" ? body.workspaceId.trim() : "";
+          assertWorkspaceId(workspaceId);
+          const sessionIds = Array.isArray(body.sessionIds) ? body.sessionIds : [];
+          for (const id of sessionIds) assertSessionId(id);
+          const pending = Array.isArray(body.pending) ? body.pending : [];
+          for (const id of pending) assertSessionId(id);
+          const record = await workspaceArchives().setArchive(workspaceId, {
+            sessionIds,
+            pending,
+            archivedAt: typeof body.archivedAt === "number" ? body.archivedAt : Date.now()
+          });
+          return send(res, 200, { ok: true, result: { workspaceId, record } });
+        }
+        if (req.method === "POST" && path === "/workspace-unarchive") {
+          const workspaceId = typeof body.workspaceId === "string" ? body.workspaceId.trim() : "";
+          assertWorkspaceId(workspaceId);
+          const pending = Array.isArray(body.pending) ? body.pending : [];
+          for (const id of pending) assertSessionId(id);
+          const retainSessionIds = body.retainSessionIds === true;
+          const record = await workspaceArchives().setUnarchive(workspaceId, { pending, retainSessionIds });
+          return send(res, 200, { ok: true, result: { workspaceId, record } });
+        }
+        if (req.method === "GET" && path === "/workspace-archives") {
+          let archives = {};
+          try {
+            archives = await workspaceArchives().getAll();
+          } catch (err) {
+            return send(res, 500, { ok: false, error: safeErrorMessage(err) });
+          }
+          return send(res, 200, { ok: true, result: { archives } });
+        }
         if (req.method === "POST" && path === "/batch") {
           // Per-action body shape (each action validates its own payload):
           //   archive       : no payload
@@ -1456,10 +1515,18 @@ ${rest}`, "utf8");
           } });
         }
         if (req.method === "GET" && path === "/workspaces") {
-          const sessionCreatedAt = Object.fromEntries(adapter.cachedSessionHeaders()
+          const cachedHeaders = adapter.cachedSessionHeaders();
+          const sessionCreatedAt = Object.fromEntries(cachedHeaders
             .filter(header => typeof header.createdAt === "number" || typeof header.createdAt === "string")
             .map(header => [header.id, header.createdAt]));
-          return send(res, 200, { ok: true, result: { workspaces: listWorkspaces(), sessionCreatedAt } });
+          const sessionUpdatedAt = Object.fromEntries(cachedHeaders
+            .filter(header => header && (typeof header.updatedAt === "number" || typeof header.updatedAt === "string" || typeof header.lastModified === "number" || typeof header.mtime === "number"))
+            .map(header => [header.id, header.updatedAt ?? header.lastModified ?? header.mtime]));
+          let workspaceArchivesMap = {};
+          try {
+            workspaceArchivesMap = await workspaceArchives().getAll();
+          } catch (_) {}
+          return send(res, 200, { ok: true, result: { workspaces: listWorkspaces(), sessionCreatedAt, sessionUpdatedAt, workspaceArchives: workspaceArchivesMap } });
         }
         if (req.method === "GET" && path === "/preset-scan") {
           const sessionId = url.searchParams.get("sessionId") || "";
@@ -1468,7 +1535,7 @@ ${rest}`, "utf8");
           return send(res, 200, { ok: true, result });
         }
         if (req.method === "GET" && path === "/update/check") {
-          const currentVersion = adapter.pluginVersion() || "0.6.4";
+          const currentVersion = adapter.pluginVersion() || "0.7.0";
           let latestVersion = currentVersion;
           let hasUpdate = false;
           try {

package/lib/workspace-archive-store.js

@@ -0,0 +1,235 @@
+/**
+ * Workspace archive persistence.
+ *
+ * Persists workspace archive state (workspaceId, archived, archivedAt, sessionIds, pending)
+ * outside DSH's own registry so restarting DSH retains the archive list without modifying
+ * or corrupting DSH native workspace records.
+ * Atomic file writes with advisory file lock protect multi-process / multi-window concurrent access.
+ */
+import * as fs from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { randomBytes } from "node:crypto";
+import { setTimeout as delay } from "node:timers/promises";
+import { assertSessionId, writeTempFile } from "./session-files.js";
+
+const fail = (message, code = "bad-request") => Object.assign(new Error(message), { code });
+const isRecord = value => value !== null && typeof value === "object" && !Array.isArray(value);
+
+export function assertWorkspaceId(id) {
+  if (typeof id !== "string" || !id.trim() || id.includes("\0") || id.includes("..")) {
+    throw fail("无效的工作区标识", "invalid-workspace-id");
+  }
+}
+
+export function normalizeWorkspaceArchiveRecord(record) {
+  if (!isRecord(record)) throw fail("工作区归档记录必须为对象");
+  assertWorkspaceId(record.workspaceId);
+  const archived = record.archived === true;
+  const archivedAt = typeof record.archivedAt === "number" && Number.isFinite(record.archivedAt)
+    ? record.archivedAt
+    : Date.now();
+  const sessionIds = Array.isArray(record.sessionIds) ? [...record.sessionIds] : [];
+  for (const sid of sessionIds) assertSessionId(sid);
+  const pending = Array.isArray(record.pending) ? [...record.pending] : [];
+  for (const sid of pending) assertSessionId(sid);
+
+  return {
+    workspaceId: record.workspaceId,
+    archived,
+    archivedAt,
+    sessionIds,
+    pending
+  };
+}
+
+export function createWorkspaceArchiveStore(directory, { io = fs, lockWaitMs = 3000, memory = false } = {}) {
+  if (memory || !directory) {
+    let state = { version: 1, workspaces: {} };
+    return {
+      async read() {
+        return structuredClone(state);
+      },
+      async get(workspaceId) {
+        assertWorkspaceId(workspaceId);
+        return state.workspaces[workspaceId] ? structuredClone(state.workspaces[workspaceId]) : null;
+      },
+      async getAll() {
+        return structuredClone(state.workspaces);
+      },
+      async setArchive(workspaceId, patch) {
+        assertWorkspaceId(workspaceId);
+        const record = normalizeWorkspaceArchiveRecord({ ...patch, workspaceId, archived: true });
+        state.workspaces[workspaceId] = record;
+        return structuredClone(record);
+      },
+      async setUnarchive(workspaceId, { pending = [], retainSessionIds = false } = {}) {
+        assertWorkspaceId(workspaceId);
+        const prev = state.workspaces[workspaceId] || { workspaceId, sessionIds: [] };
+        const hasPending = Array.isArray(pending) && pending.length > 0;
+        const keepRecord = hasPending || (retainSessionIds && Array.isArray(prev.sessionIds) && prev.sessionIds.length > 0);
+        if (keepRecord) {
+          const record = normalizeWorkspaceArchiveRecord({
+            ...prev,
+            workspaceId,
+            archived: false,
+            pending: hasPending ? pending : (Array.isArray(prev.pending) ? prev.pending : [])
+          });
+          state.workspaces[workspaceId] = record;
+          return structuredClone(record);
+        }
+        delete state.workspaces[workspaceId];
+        return null;
+      },
+      async removeSession(sessionId) {
+        let changed = false;
+        for (const [wsId, rec] of Object.entries(state.workspaces)) {
+          if (rec.sessionIds.includes(sessionId) || rec.pending.includes(sessionId)) {
+            rec.sessionIds = rec.sessionIds.filter(id => id !== sessionId);
+            rec.pending = rec.pending.filter(id => id !== sessionId);
+            changed = true;
+          }
+        }
+        return changed;
+      },
+      async clear() {
+        state = { version: 1, workspaces: {} };
+      }
+    };
+  }
+
+  const root = resolve(directory);
+  const path = join(root, "workspace-archives.v1.json");
+  const lockPath = join(root, "workspace-archives.v1.lock");
+
+  let queue = Promise.resolve();
+  const enqueue = operation => {
+    const result = queue.then(operation);
+    queue = result.catch(() => {});
+    return result;
+  };
+
+  const read = async () => {
+    let content;
+    try {
+      const parent = await io.lstat(root);
+      if (!parent.isDirectory() || parent.isSymbolicLink()) throw fail("工作区归档目录不能是符号链接", "workspace-archives-unavailable");
+      const info = await io.lstat(path);
+      if (!info.isFile() || info.isSymbolicLink()) throw fail("工作区归档文件必须是普通文件", "workspace-archives-unavailable");
+      content = await io.readFile(path, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return { version: 1, workspaces: {} };
+      throw error;
+    }
+    try {
+      const state = JSON.parse(content);
+      if (state?.version !== 1 || !isRecord(state.workspaces)) throw new Error("schema");
+      const normalizedWorkspaces = {};
+      for (const [id, item] of Object.entries(state.workspaces)) {
+        normalizedWorkspaces[id] = normalizeWorkspaceArchiveRecord({ ...item, workspaceId: id });
+      }
+      return { version: 1, workspaces: normalizedWorkspaces };
+    } catch {
+      throw fail("工作区归档文件损坏或版本不兼容，已停止写入；请先检查 " + path, "workspace-archives-corrupt");
+    }
+  };
+
+  const withLock = async operation => {
+    await io.mkdir(root, { recursive: true, mode: 0o700 });
+    const parent = await io.lstat(root);
+    if (!parent.isDirectory() || parent.isSymbolicLink()) throw fail("工作区归档目录不能是符号链接", "workspace-archives-unavailable");
+    const token = JSON.stringify({ pid: process.pid, token: randomBytes(12).toString("hex") });
+    const deadline = Date.now() + lockWaitMs;
+    let handle;
+    while (!handle) {
+      try {
+        handle = await io.open(lockPath, "wx", 0o600);
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        if (Date.now() >= deadline) throw fail("工作区归档正由其他进程写入，请稍后重试", "workspace-archives-busy");
+        await delay(Math.min(25, Math.max(1, deadline - Date.now())));
+      }
+    }
+    try {
+      await handle.writeFile(token, "utf8");
+      return await operation();
+    } finally {
+      try { await handle.close(); } catch (_) {}
+      try { await io.unlink(lockPath); } catch (_) {}
+    }
+  };
+
+  const write = async state => {
+    const raw = JSON.stringify(state, null, 2) + "\n";
+    const tempPath = await writeTempFile(path, raw, io);
+    await io.rename(tempPath, path);
+  };
+
+  return {
+    async read() {
+      return enqueue(read);
+    },
+    async get(workspaceId) {
+      assertWorkspaceId(workspaceId);
+      const state = await enqueue(read);
+      return state.workspaces[workspaceId] ? structuredClone(state.workspaces[workspaceId]) : null;
+    },
+    async getAll() {
+      const state = await enqueue(read);
+      return structuredClone(state.workspaces);
+    },
+    async setArchive(workspaceId, patch) {
+      assertWorkspaceId(workspaceId);
+      const record = normalizeWorkspaceArchiveRecord({ ...patch, workspaceId, archived: true });
+      return enqueue(() => withLock(async () => {
+        const state = await read();
+        state.workspaces[workspaceId] = record;
+        await write(state);
+        return structuredClone(record);
+      }));
+    },
+    async setUnarchive(workspaceId, { pending = [], retainSessionIds = false } = {}) {
+      assertWorkspaceId(workspaceId);
+      return enqueue(() => withLock(async () => {
+        const state = await read();
+        const prev = state.workspaces[workspaceId] || { workspaceId, sessionIds: [] };
+        const hasPending = Array.isArray(pending) && pending.length > 0;
+        const keepRecord = hasPending || (retainSessionIds && Array.isArray(prev.sessionIds) && prev.sessionIds.length > 0);
+        if (keepRecord) {
+          const record = normalizeWorkspaceArchiveRecord({
+            ...prev,
+            workspaceId,
+            archived: false,
+            pending: hasPending ? pending : (Array.isArray(prev.pending) ? prev.pending : [])
+          });
+          state.workspaces[workspaceId] = record;
+          await write(state);
+          return structuredClone(record);
+        }
+        delete state.workspaces[workspaceId];
+        await write(state);
+        return null;
+      }));
+    },
+    async removeSession(sessionId) {
+      assertSessionId(sessionId);
+      return enqueue(() => withLock(async () => {
+        const state = await read();
+        let changed = false;
+        for (const [wsId, rec] of Object.entries(state.workspaces)) {
+          if (rec.sessionIds.includes(sessionId) || rec.pending.includes(sessionId)) {
+            rec.sessionIds = rec.sessionIds.filter(id => id !== sessionId);
+            rec.pending = rec.pending.filter(id => id !== sessionId);
+            changed = true;
+          }
+        }
+        if (changed) await write(state);
+        return changed;
+      }));
+    },
+    async clear() {
+      return enqueue(() => withLock(async () => {
+        await write({ version: 1, workspaces: {} });
+      }));
+    }
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-session-manager",
-  "version": "0.6.4",
-  "description": "DeepSeek Harness session manager: delete, archive, move across workspaces, migrate presets, favorites, review-later, search, filter, sort, priority, tags, notes, and batch actions. | DSH 会话管理：删除、归档、跨工作区移动、预设迁移、收藏、待回看、搜索、筛选、排序、优先级、标签、备注及批量操作。",
+  "version": "0.7.0",
+  "description": "All-in-one session and workspace manager for DeepSeek Harness: lifecycle control (delete, archive, move, preset migration), workspace archiving & sidebar hiding, annotations (favorites, review-later, priority, tags, notes), search, and batch actions. | 专为 DeepSeek Harness 打造的一站式会话与工作区管理插件：支持会话生命周期管理、工作区归档与隐藏、多维标注、智能筛选排序及高效批量操作。",
   "license": "MIT",
   "keywords": [
     "dsh",
@@ -15,6 +15,8 @@
     "archive",
     "move",
     "workspace",
+    "workspace-archive",
+    "workspace-management",
     "preset",
     "agent-preset",
     "migration",
@@ -62,7 +64,7 @@
     "node": "^22.15.0 || >=24.0.0"
   },
   "scripts": {
-    "check": "node --check lib/index.js && node --check lib/client.js && node --check lib/session-files.js && node --check lib/annotation-store.js && node --check lib/clipboard-parser.js && node -e \"import('./lib/index.js')\"",
+    "check": "node --check lib/index.js && node --check lib/client.js && node --check lib/session-files.js && node --check lib/annotation-store.js && node --check lib/workspace-archive-store.js && node --check lib/clipboard-parser.js && node -e \"import('./lib/index.js')\"",
     "test": "node scripts/run-tests.mjs",
     "check:package": "node scripts/check-package.mjs"
   }