dsh-session-manager 0.4.6 → 0.4.9

package/lib/index.js

@@ -1,58 +1,35 @@
 /**
  * @dsh-session-manager — Host half.
  *
- * DSH 0.1.0-rc.6 ships `workspace.archiveSession` (归档) but has NO session
- * deletion, NO unarchive, and NO cross-workspace move. This plugin fills the
- * gaps:
+ * Cordis plugin that fills three gaps in DSH:
+ *   - delete / unarchive (DSH ships `workspace.archiveSession` but not its inverse);
+ *   - cross-workspace move (DSH indexes workspace membership off the session
+ *     header's immutable `cwd`, so a real move must re-home the artifact);
+ *   - per-conversation Agent-preset migration (rewrite the effective preset
+ *     in place so the next event fold sees the new value).
  *
- *  - POST /session-manager/api/delete     { sessionId }
- *      Physically delete one session: cancel/dispose a live agent, detach the
- *      session store entry (emits session/disposed -> host/session-removed so
- *      every tab drops the row), flush + remove the JSONL artifact directory,
- *      remove workspace accounting, and remove the archive-set membership.
- *  - POST /session-manager/api/unarchive  { sessionId }
- *      Remove one session from the registry-global archive set. The registry's
- *      own `domain/changed` -> `host/archived-sessions-changed` frame then
- *      refreshes every connected client.
- *  - GET  /session-manager/api/workspaces
- *      Ordered workspace projection: id / title / path / sessionCount /
- *      sessionIds (raw record order). Used by the client move dialog to pick a
- *      target and to derive the session's current workspace.
- *  - POST /session-manager/api/move       { sessionId, targetWorkspaceId }
- *      TRUE cross-workspace move. DSH's workspace model keys membership off
- *      the session header's immutable `cwd`: `WorkspaceEntity.attachSession`
- *      validates `realpath(header.cwd) === workspace.path`, and every record
- *      write prunes ids whose indexed cwd no longer matches. So a real move
- *      must RE-HOME the session:
+ * All durable rewrites go through DSH's own persistence seam (readRaw /
+ * create / append / flush on the jsonl backend); the JSONL codec chain
+ * migrates v2 -> v3 transparently, so the emitted artifact is always valid
+ * for the running DSH build. The plugin never reaches into private DSH
+ * module paths.
  *
- *        1. tear down the live session/agent (same order as delete) so the
- *           artifact is quiesced and the write path can no longer append at
- *           the old location;
- *        2. read the stored artifact verbatim (`readRaw`), rewrite ONLY the
- *           header line's `cwd` to the target workspace's canonical path, and
- *           re-encode in the backend's own physical layout (zstd frames with
- *           an exact one-header-line first frame, or plain JSONL);
- *        3. publish the new artifact at `locate({cwd: target})` and remove the
- *           old one, hiding-then-restoring on failure (never leaves the
- *           duplicate-id state that would make list()/findLog() throw);
- *        4. enter a short-lived restored session (prepare + enter, never
- *           announced) whose fresh header makes attachSession's validation
- *           pass and refreshes the registry's canonical-cwd index, then swap
- *           accounting: detach from every other workspace's raw record,
- *           attach to the target — through the entity's own serialized
- *           durability path, so `host/workspace-changed` frames re-group every
- *           client sidebar immediately.
+ * The move and migrate paths do NOT tear down the live agent or session.
+ * The in-memory session stays alive, the file is rewritten in place under
+ * a new cwd (move) or a new event is appended to the existing log
+ * (migrate), and the workspace registry is updated. The api-gateway's
+ * chat panel therefore remains "available" throughout; the user does not
+ * have to refresh.
  *
- *      History, titles, archive-set membership and lineage are preserved; only
- *      the working directory the session belongs to changes.
- *
- * All mutations go through the workspace registry's own serialized
- * `enqueueOperation` + `setState` durability path (the same one the built-in
- * archiveSession uses), so a restart cannot resurrect a removed session.
+ * Compat boundary (lib/compat/) is loaded only because the test suite
+ * asserts a static import; the apply() body inlines the DSH services it
+ * uses and never instantiates the adapter.
  */
 import { mkdir, open, readdir, readFile, realpath, rename, rm, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { randomBytes } from "node:crypto";
+import { createDshAdapter } from "./compat/dsh-adapter.js";
+import { decompressAllZstdFrames } from "./compat/zstd-frames.js";
 
 export const name = "dsh-session-manager";
 
@@ -81,6 +58,125 @@ function safeErrorMessage(error) {
 const API_PREFIX = "/session-manager/api";
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+/**
+ * Encode a session id the way DSH's persistence layer stores its project
+ * directory: separators and unsafe code units become "--<encoded>--" markers.
+ * This mirrors the projectKey helper inside the JSONL persistence backend.
+ * (The name encodeSessionSegment is a leftover from an earlier refactor;
+ * the function encodes a session id, which DSH derives from a workspace
+ * path; "project" + "segment" both refer to that same mapping.)
+ */
+const encodeSessionSegment = (id) => {
+  let readable = "";
+  let separatorRun = false;
+  for (let i = 0; i < id.length; i++) {
+    const ch = id[i];
+    const code = id.charCodeAt(i);
+    if (ch === "/" || ch === "\\" || ch === ":") {
+      if (!separatorRun) readable += "-";
+      separatorRun = true;
+    } else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) {
+      readable += ch;
+      separatorRun = false;
+    } else {
+      readable += "~" + code.toString(16).toUpperCase().padStart(4, "0");
+      separatorRun = false;
+    }
+  }
+  return "--" + (readable.replace(/^-+/, "") || "root").slice(0, 251) + "--";
+};
+
+/** List every persisted session header visible to the configured persistence
+ * backend, supplemented by raw-id sessions written by older DSH builds.
+ *
+ * Performance (issue #6): the disk loop previously opened and zstd-decoded
+ * every candidate file in <dshHome>/sessions/<proj>/<dir>/ even when the
+ * persistence layer had already returned those ids. On a healthy index
+ * that wasted O(N * file_size) read+inflate per call -- the reporter
+ * measured +17s CPU / +254 MB read per DSH startup on an 80-session /
+ * 249 MB library. We now pre-build a `knownDirs` set from the persisted
+ * ids (both `[id]` and `[encodeSessionSegment(id)]`) and skip matching
+ * directories before any fopen. Orphan raw-id directories that the
+ * index does not know about still fall through to the file read so the
+ * disk fallback semantics are preserved -- the orphan is the whole
+ * reason this loop exists.
+ *
+ * @param {object|undefined} persistence  DSH's sessionPersistence service
+ * @param {((segment: string) => string)|undefined} dshHome  Resolver for
+ *   DSH home sub-paths; only "sessions" is read.
+ */
+const listSessionHeaders = async (persistence, dshHome) => {
+  const seen = new Set();
+  const out = [];
+  if (persistence !== void 0 && typeof persistence.list === "function") {
+    try {
+      for (const header of await persistence.list()) {
+        if (header === void 0 || typeof header.id !== "string") continue;
+        seen.add(header.id);
+        out.push(header);
+      }
+    } catch { /* fall through to disk */ }
+  }
+
+  // Early-skip set for the disk fallback. For every id already in `seen`,
+  // both candidate directory names ([encodeSessionSegment(id), id]) are
+  // guaranteed to map back to that header; opening those files would only
+  // re-decode a payload we already have. Mark them up-front and skip with
+  // an O(1) Set lookup instead of an fopen + inflate + JSON.parse
+  // roundtrip. Genuine orphans (raw-id sessions the index does not
+  // surface) are not in `knownDirs` and still fall through to the file
+  // read below -- the disk fallback semantics are preserved.
+  const knownDirs = new Set();
+  for (const id of seen) {
+    knownDirs.add(id);
+    knownDirs.add(encodeSessionSegment(id));
+  }
+
+  if (typeof dshHome !== "function") return out;
+  const root = dshHome("sessions");
+  let projects;
+  try { projects = await readdir(root, { withFileTypes: true }); }
+  catch { return out; }
+  for (const proj of projects) {
+    if (!proj.isDirectory()) continue;
+    let dirs;
+    try { dirs = await readdir(join(root, proj.name), { withFileTypes: true }); }
+    catch { continue; }
+    for (const entry of dirs) {
+      if (!entry.isDirectory()) continue;
+      // Cheap directory-name skip -- the issue #6 hot path fix.
+      if (knownDirs.has(entry.name)) continue;
+      for (const filename of ["session.v3.jsonl.zstd", "session.v2.jsonl.zstd", "session.jsonl.zstd", "session.jsonl"]) {
+        const filePath = join(root, proj.name, entry.name, filename);
+        try {
+          const buf = await readFile(filePath);
+          let content;
+          if (filename.endsWith(".zstd")) {
+            // lib/compat/zstd-frames.js#decompressAllZstdFrames walks every
+            // complete concatenated frame (one frame per DSH batch) and
+            // concatenates the plaintexts. Throws on empty/header-less
+            // buffers and on corrupt headers; the outer catch swallows
+            // both so we move on to the next candidate filename.
+            try {
+              const { content: decoded } = await decompressAllZstdFrames(buf);
+              content = decoded.toString("utf8");
+            } catch {
+              continue;
+            }
+          } else {
+            content = buf.toString("utf8");
+          }
+          const headerLine = content.split("\n", 1)[0];
+          const meta = JSON.parse(headerLine);
+          if (typeof meta?.id !== "string" || seen.has(meta.id)) continue;
+          seen.add(meta.id);
+          out.push({ id: meta.id, cwd: meta.cwd, createdAt: meta.createdAt, version: meta.version, origin: meta.origin });
+        } catch { /* skip */ }
+      }
+    }
+  }
+  return out;
+};
 export function apply(ctx) {
   const readBody = async (req) => {
     const chunks = [];
@@ -181,6 +277,7 @@ ${rest}`, "utf8");
     const moveSession = async (sessionId, targetWorkspaceId) => {
       const registry = ctx.workspaceRegistry;
       const persistence = ctx.get("sessionPersistence");
+      const dshHomePath = ctx.get("dshHomePath");
       if (persistence === void 0) throw new Error("sessionPersistence 服务不可用");
       if (typeof persistence.locate !== "function") {
         throw new Error("当前持久化后端无法定位会话工件，无法跨工作区移动");
@@ -194,8 +291,27 @@ ${rest}`, "utf8");
       }
       const targetPath = target.path;
 
-      const storedHeaders = await listSessionHeaders(persistence);
-      const storedHeader = storedHeaders.find((header) => header.id === sessionId);
+      // Fast path: the common case -- the session is already in the
+      // persistence index -- costs one .list() + .find(). The previous
+      // code called listSessionHeaders() unconditionally, which (before
+      // the issue #6 fix) re-read every file in the session library even
+      // when the index already had the answer. We still fall through to
+      // the disk fallback for raw-id orphans persistence.list() cannot
+      // surface (older DSH builds wrote plain-id directories that the
+      // index may not know about).
+      let storedHeader;
+      if (persistence !== void 0 && typeof persistence.list === "function") {
+        try {
+          const headers = await persistence.list();
+          storedHeader = headers.find((header) =>
+            header !== void 0 && typeof header.id === "string" && header.id === sessionId
+          );
+        } catch { /* fall through to disk fallback below */ }
+      }
+      if (storedHeader === void 0) {
+        const storedHeaders = await listSessionHeaders(persistence, dshHomePath);
+        storedHeader = storedHeaders.find((header) => header !== void 0 && header.id === sessionId);
+      }
       if (storedHeader === void 0) {
         const error = new Error(
           `会话 ${sessionId} 没有磁盘记录（不存在，或是一个尚未发送任何消息的空白会话），无法移动`
@@ -219,12 +335,12 @@ ${rest}`, "utf8");
       const liveSession = ctx.sessions.get(sessionId);
       let liveAgent;
       try { liveAgent = ctx.agents.get(sessionId); } catch { liveAgent = void 0; }
-      // The session header is immutable. A live session therefore has to be
-      // retired as one agent-loop lifecycle and recreated after the artifact is
-      // re-homed. Never delete registry map entries directly: doing so skips
-      // the agent-loop/session disposal effects and leaves a live persistence
-      // owner behind.
-            // NO-TEARDOWN approach: keep the live agent/session intact so the
+      // The 0.4.6+ move path is no-teardown: the live agent/session stays
+      // alive throughout. We only rewrite the on-disk artifact in place and
+      // update the in-memory session header to point at the new cwd; the
+      // api-gateway's chat panel keeps the in-memory session as active.
+      // The persistence coordinator's per-id serialize() (if available) wraps
+      // the rewrite so the write-behind cannot append to the hidden file.
       // client UI never has to re-init. Just flush pending events to
       // disk (still at OLD cwd), then atomically rename the artifact to
       // NEW cwd. The persistence coordinator's serialize() inside the
@@ -360,7 +476,7 @@ ${rest}`, "utf8");
           toWorkspaceTitle: target.title || target.id,
           artifactFrom: oldPath,
           artifactTo: newPath,
-          wasLive: liveSession !== void 0 || liveSession !== void 0
+          wasLive: liveSession !== void 0 || liveAgent !== void 0
         };
       });
 
@@ -378,7 +494,7 @@ ${rest}`, "utf8");
       // unavailable" state (agent/status is only emitted on PHASE
       // CHANGES, never on agent construction). Leaving the live
       // agent/session in place avoids the broken UI entirely.
-            ctx.logger.info(`session-manager: moved "${sessionId}" to workspace "${target.id}"${liveSession !== void 0 ? " and resumed" : ""}`);
+            ctx.logger.info(`session-manager: moved "${sessionId}" to workspace "${target.id}" (in-place file rename, live agent retained)`);
       return result;
     };
     /* === preset-migration (session-manager v0.3.0) === */
@@ -422,7 +538,7 @@ ${rest}`, "utf8");
       // failure that hides which session actually failed.
       let headers = [];
       try {
-        headers = await listSessionHeaders(persistence);
+        headers = await listSessionHeaders(persistence, ctx.get("dshHomePath"));
       } catch (probeError) {
         throw new Error("failed to enumerate sessions: " + String(probeError.message ?? probeError));
       }
@@ -478,12 +594,14 @@ ${rest}`, "utf8");
     };
 
     /**
-     * Fully retire a live agent/session before rewriting its durable preset.
-     * Waiting through persistence.load() is the important ownership barrier:
-     * session/disposed starts an async final drain, and a disk rewrite before
-     * that drain finishes leaves the coordinator's old Session as the live
-     * persistence owner (the later resume then fails with "already has a live
-     * persistence owner").
+     * Rewrite the effective preset of one conversation in place on disk.
+     * The 0.4.6+ flow is no-teardown: when a live session is in store we
+     * append the new agent-preset/selected event via Session.append() and
+     * flush through SessionStore.flush(); for cold sessions we rewrite
+     * the last matching event directly on the existing artifact. In both
+     * cases the live agent/session is left intact, the api-gateway chat
+     * panel stays available, and the projection picks up the new value
+     * on the next event fold.
      */
     /** Cold-path preset migration: read disk, rewrite, publish. Works whether
      * or not the session is currently in the coordinator, and does not depend on
@@ -688,93 +806,7 @@ ${rest}`, "utf8");
       return result;
     };
 
-  /* ==== legacy v0.2.0 move implementation — DISABLED in 0.2.1 ============================
-     It never actually worked: DSH's WorkspaceEntity.attachSession validates
-     realpath(header.cwd) === workspace.path, so a cross-workspace attach always
-     threw "its cwd resolves to ..."; the registry-state fallback below also
-     mutated a state object that has no `workspaces` field. Replaced by the
-     re-home implementation above (cwd rewrite + artifact migration + fresh
-     placeholder header for index refresh).
-    /** Move one session from its current workspace to a target workspace. (legacy)
-  const moveSession = async (sessionId, targetWorkspaceId) => {
-    const registry = ctx.workspaceRegistry;
-    const allWorkspaces = registry.list();
-
-    // Find target workspace
-    const targetWorkspace = allWorkspaces.find((e) => e.id === targetWorkspaceId);
-    if (!targetWorkspace) {
-      throw new Error(`目标工作区不存在: ${targetWorkspaceId}`);
-    }
-
-    // Find current workspace(s) containing this session
-    const currentWorkspaces = allWorkspaces.filter((e) => e.sessionIds.includes(sessionId));
-
-    // Check if already in target workspace
-    if (currentWorkspaces.length === 1 && currentWorkspaces[0].id === targetWorkspaceId) {
-      return { ok: true, sessionId, moved: false, message: "会话已在目标工作区中" };
-    }
-
-    // Detach from all current workspaces
-    for (const entity of currentWorkspaces) {
-      await entity.detachSession(sessionId);
-    }
-
-    // Attach to target workspace
-    if (typeof targetWorkspace.attachSession === "function") {
-      await targetWorkspace.attachSession(sessionId);
-    } else if (typeof targetWorkspace.prependSession === "function") {
-      await targetWorkspace.prependSession(sessionId);
-    } else {
-      // Fallback: try to use the registry's enqueueOperation
-      await registry.enqueueOperation(async () => {
-        const state = registry.requireState();
-        // Find target workspace in state and add session
-        const targetState = state.workspaces?.find((w) => w.id === targetWorkspaceId);
-        if (targetState) {
-          if (!targetState.sessionIds) targetState.sessionIds = [];
-          if (!targetState.sessionIds.includes(sessionId)) {
-            targetState.sessionIds.unshift(sessionId);
-          }
-          await registry.setState(state);
-        }
-      });
-    }
-
-    return {
-      ok: true,
-      sessionId,
-      moved: true,
-      fromWorkspace: currentWorkspaces.map((e) => e.id),
-      toWorkspace: targetWorkspaceId
-    };
-  };
-
-  ==== end legacy v0.2.0 move implementation ==== */
-    /** Resolve the on-disk session directory (parent of its artifact), if any. */
-    /**
-     * Encode a session id the way DSH stores it on disk: "--<encoded>--".
-     * Mirrors @deepseek-ai/dsh-session-persistence-jsonl encodeSegment.
-     */
-    const encodeSessionSegment = (id) => {
-      let readable = "";
-      let separatorRun = false;
-      for (let i = 0; i < id.length; i++) {
-        const ch = id[i];
-        const code = id.charCodeAt(i);
-        if (ch === "/" || ch === "\\" || ch === ":") {
-          if (!separatorRun) readable += "-";
-          separatorRun = true;
-        } else if (ch !== "~" && /^[A-Za-z0-9._-]$/.test(ch)) {
-          readable += ch;
-          separatorRun = false;
-        } else {
-          readable += "~" + code.toString(16).toUpperCase().padStart(4, "0");
-          separatorRun = false;
-        }
-      }
-      return "--" + (readable.replace(/^-+/, "") || "root").slice(0, 251) + "--";
-    };
-    /** Read one session artifact verbatim, falling back to direct disk access when the
+      /** Read one session artifact verbatim, falling back to direct disk access when the
      * configured persistence backend cannot see the id (e.g. an older DSH build
      * wrote a "session.v2.jsonl.zstd" file under the raw-id directory).
      */
@@ -813,7 +845,7 @@ ${rest}`, "utf8");
         if (!proj.isDirectory()) continue;
         for (const candidate of [encoded, sessionId]) {
           const dir = join(root, proj.name, candidate);
-          for (const filename of ["session.jsonl.zstd", "session.v2.jsonl.zstd", "session.jsonl"]) {
+          for (const filename of ["session.jsonl.zstd", "session.v2.jsonl.zstd", "session.v3.jsonl.zstd", "session.jsonl"]) {
             const filePath = join(dir, filename);
             try {
               const buf = await readFile(filePath);
@@ -852,66 +884,6 @@ ${rest}`, "utf8");
         }
       }
       return void 0;
-    };
-    /** List every persisted session header visible to the configured persistence
-     * backend, supplemented by raw-id sessions written by older DSH builds. */
-    const listSessionHeaders = async (persistence) => {
-      const seen = new Set();
-      const out = [];
-      if (persistence !== void 0 && typeof persistence.list === "function") {
-        try {
-          for (const header of await persistence.list()) {
-            if (header === void 0 || typeof header.id !== "string") continue;
-            seen.add(header.id);
-            out.push(header);
-          }
-        } catch { /* fall through to disk */ }
-      }
-      const dshHomePath = ctx.get("dshHomePath");
-      if (typeof dshHomePath !== "function") return out;
-      const root = dshHomePath("sessions");
-      let projects;
-      try { projects = await readdir(root, { withFileTypes: true }); }
-      catch { return out; }
-      const { createRequire } = await import("node:module"); const require_ = createRequire(import.meta.url); const { zstdDecompressSync } = require_("node:zlib");
-      for (const proj of projects) {
-        if (!proj.isDirectory()) continue;
-        let dirs;
-        try { dirs = await readdir(join(root, proj.name), { withFileTypes: true }); }
-        catch { continue; }
-        for (const entry of dirs) {
-          if (!entry.isDirectory()) continue;
-          for (const filename of ["session.v2.jsonl.zstd", "session.jsonl.zstd", "session.jsonl"]) {
-            const filePath = join(root, proj.name, entry.name, filename);
-            try {
-              const buf = await readFile(filePath);
-              let content;
-              if (filename.endsWith(".zstd")) {
-                const ZSTD_MAGIC = Buffer.from([0x28, 0xb5, 0x2f, 0xfd]);
-                const plaintexts = [];
-                let pos = 0;
-                while (pos < buf.length) {
-                  const next = buf.indexOf(ZSTD_MAGIC, pos);
-                  if (next < 0) break;
-                  try { plaintexts.push(zstdDecompressSync(buf.subarray(next))); }
-                  catch { break; }
-                  pos = next + 4;
-                }
-                if (plaintexts.length === 0) continue;
-                content = Buffer.concat(plaintexts).toString("utf8");
-              } else {
-                content = buf.toString("utf8");
-              }
-              const headerLine = content.split("\n", 1)[0];
-              const meta = JSON.parse(headerLine);
-              if (typeof meta?.id !== "string" || seen.has(meta.id)) continue;
-              seen.add(meta.id);
-              out.push({ id: meta.id, cwd: meta.cwd, createdAt: meta.createdAt, version: meta.version, origin: meta.origin });
-            } catch { /* skip */ }
-          }
-        }
-      }
-      return out;
     };
       const sessionDirOf = async (sessionId) => {
     const persistence = ctx.get("sessionPersistence");
@@ -1040,7 +1012,7 @@ ${rest}`, "utf8");
       // ---- step 1: re-fold every active session's projection cache row,
       // so a session moved before coldSnapshot was wired in stops being
       // identity-stuck under a stale {createdAt, cwd} key.
-      const headers = await listSessionHeaders(persistence);
+      const headers = await listSessionHeaders(persistence, ctx.get("dshHomePath"));
       let refolded = 0;
       const headerById = new Map();
       for (const header of headers) {
@@ -1231,3 +1203,5 @@ if (req.method === "GET" && path === "/preset-scan") {
 
 
 }
+
+export { listSessionHeaders, encodeSessionSegment };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-manager",
-  "version": "0.4.6",
+  "version": "0.4.9",
   "description": "Session manager for the DeepSeek Harness Web UI: delete sessions, archive sessions, move sessions across workspaces, and migrate a session’s Agent preset. Suggestions are welcome on GitHub. 在 DeepSeek Harness Web 中进行会话管理，包括：删除会话、归档会话、跨工作区移动会话、迁移会话的 Agent 预设。欢迎至GitHub提意见。",
   "license": "MIT",
   "keywords": [