dsh-sessions-manager 3.2.2 → 3.3.0

package/lib/index.js

@@ -1,8 +1,8 @@
 // src/index.js
-import { mkdir, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join } from "node:path";
-import { readFileSync as readFileSync2 } from "node:fs";
-import { homedir } from "node:os";
+import { mkdir as mkdir2, realpath, rename as rename2, stat, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join as join2 } from "node:path";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
 
 // src/zstd-frame.js
 import zlib from "node:zlib";
@@ -41,12 +41,221 @@ function rewriteFrame0Cwd(filePath, newCwd) {
   writeFileSync(filePath, Buffer.concat([newFrame0, rest]));
 }
 
+// src/markdown.js
+var MAX_TOOL_ARG = 200;
+function isoTime(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return null;
+  try {
+    return new Date(value).toISOString();
+  } catch {
+    return null;
+  }
+}
+function yamlString(value) {
+  return `"${String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, "\\n")}"`;
+}
+function blocksOf(value) {
+  return Array.isArray(value) ? value.filter((b) => b && typeof b === "object") : [];
+}
+function textFromBlocks(blocks) {
+  const parts = [];
+  for (const block of blocks) {
+    if (block.type === "text" && typeof block.text === "string") parts.push(block.text);
+  }
+  return parts.join("\n\n").trim();
+}
+function imageCountOf(blocks) {
+  let count = 0;
+  for (const block of blocks) if (block.type === "image") count++;
+  return count;
+}
+function reasoningFromBlocks(blocks) {
+  const parts = [];
+  for (const block of blocks) {
+    if (block.type === "reasoning" && typeof block.text === "string" && block.text.trim()) parts.push(block.text.trim());
+  }
+  return parts.join("\n\n");
+}
+function summarizeToolArguments(name2, rawArguments) {
+  let parsed = null;
+  if (typeof rawArguments === "string") {
+    try {
+      parsed = JSON.parse(rawArguments);
+    } catch {
+      parsed = null;
+    }
+  } else if (rawArguments && typeof rawArguments === "object") {
+    parsed = rawArguments;
+  }
+  if (parsed === null) return typeof rawArguments === "string" ? rawArguments.slice(0, MAX_TOOL_ARG) : "";
+  if (typeof parsed !== "object") return String(parsed).slice(0, MAX_TOOL_ARG);
+  const preferred = ["command", "file_path", "path", "query", "url", "pattern"];
+  for (const key of preferred) {
+    if (typeof parsed[key] === "string" && parsed[key].trim()) return parsed[key];
+  }
+  const keys = Object.keys(parsed);
+  if (keys.length === 0) return "";
+  const rest = {};
+  for (const key of keys.slice(0, 6)) {
+    const value = parsed[key];
+    rest[key] = typeof value === "string" ? value : JSON.stringify(value);
+  }
+  return JSON.stringify(rest).slice(0, MAX_TOOL_ARG);
+}
+function renderSessionMarkdown(meta, events, options = {}) {
+  const includeReasoning = options.includeReasoning === true;
+  const includeToolResults = options.includeToolResults === true;
+  const header = meta && typeof meta === "object" ? meta : {};
+  const list = Array.isArray(events) ? events : [];
+  let title = typeof header.title === "string" && header.title.trim() ? header.title.trim() : null;
+  for (const ev of list) {
+    const data = ev && ev.data;
+    if (ev && ev.type === "session/title" && data && typeof data.title === "string" && data.title.trim()) {
+      title = data.title.trim();
+    }
+  }
+  const front = ["---"];
+  if (title) front.push(`title: ${yamlString(title)}`);
+  if (typeof header.id === "string" && header.id) front.push(`sessionId: ${yamlString(header.id)}`);
+  if (typeof header.cwd === "string" && header.cwd) front.push(`cwd: ${yamlString(header.cwd)}`);
+  const created = isoTime(header.createdAt);
+  if (created) front.push(`createdAt: ${created}`);
+  const exported = isoTime(options.exportedAt);
+  if (exported) front.push(`exportedAt: ${exported}`);
+  front.push("---");
+  const out = [front.join("\n")];
+  if (title) out.push("", `# ${title}`);
+  let turn = null;
+  for (const ev of list) {
+    if (!ev || typeof ev !== "object") continue;
+    const data = ev.data && typeof ev.data === "object" ? ev.data : {};
+    const type = ev.type;
+    if (type === "turn/start") {
+      const next = Number.isInteger(data.turn) ? data.turn : null;
+      if (next !== null && next !== turn) {
+        turn = next;
+        out.push("", `## \u7B2C ${turn} \u8F6E`);
+      }
+      continue;
+    }
+    if (type === "user/message") {
+      const blocks = blocksOf(data.content);
+      const text = textFromBlocks(blocks);
+      const images = imageCountOf(blocks);
+      if (!text && images === 0) continue;
+      out.push("", "### \u7528\u6237", "");
+      if (text) out.push(text);
+      for (let i = 0; i < images; i++) out.push("", `![\u56FE\u7247 ${i + 1}](attachment)`);
+      continue;
+    }
+    if (type === "assistant/message") {
+      const message = data.message && typeof data.message === "object" ? data.message : {};
+      const blocks = blocksOf(message.content);
+      const text = textFromBlocks(blocks);
+      const reasoning = includeReasoning ? reasoningFromBlocks(blocks) : "";
+      if (!text && !reasoning) continue;
+      out.push("", "### \u52A9\u624B", "");
+      if (reasoning) out.push("> \u601D\u8003\uFF1A" + reasoning.split("\n").join("\n> "), "");
+      if (text) out.push(text);
+      continue;
+    }
+    if (type === "tool/call") {
+      const name2 = typeof data.name === "string" && data.name ? data.name : "tool";
+      const summary = summarizeToolArguments(name2, data.arguments);
+      out.push("", `### \u5DE5\u5177\u8C03\u7528\uFF1A\`${name2}\``, "");
+      out.push(summary ? "```\n" + summary + "\n```" : "\uFF08\u65E0\u53C2\u6570\uFF09");
+      continue;
+    }
+    if (type === "tool/result" && includeToolResults) {
+      const message = data.message && typeof data.message === "object" ? data.message : {};
+      const blocks = blocksOf(message.content);
+      let text = "";
+      for (const block of blocks) {
+        if (block.type === "tool-result") text = textFromBlocks(blocksOf(block.content));
+      }
+      if (text) out.push("", "<details><summary>\u5DE5\u5177\u7ED3\u679C</summary>", "", "```\n" + text.slice(0, 2e3) + "\n```", "", "</details>");
+    }
+  }
+  out.push("");
+  return out.join("\n");
+}
+
+// src/star-index.js
+import { mkdir, rename, writeFile } from "node:fs/promises";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var STAR_SCHEMA_VERSION = 3;
+var DEFAULT_STAR_DIR = join(homedir(), ".dsh", "sessions-manager");
+function isSafeSessionId(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 200 && !/[\\/\0]/.test(value) && value !== "." && value !== "..";
+}
+function normalizeStarStore(raw) {
+  const legacy = Array.isArray(raw) ? raw : null;
+  const source = legacy || (raw && typeof raw === "object" ? raw : null);
+  const ids = source && Array.isArray(source.starredSessionIds) ? source.starredSessionIds : legacy || [];
+  const clean = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of ids) {
+    if (!isSafeSessionId(id)) continue;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    clean.push(id);
+  }
+  return { schemaVersion: STAR_SCHEMA_VERSION, starredSessionIds: clean };
+}
+function createStarIndex(options = {}) {
+  const dir = options.dir || process.env.DSH_SESSIONS_MANAGER_STAR_DIR || DEFAULT_STAR_DIR;
+  const indexPath = options.indexPath || join(dir, "star.json");
+  let mutation = Promise.resolve();
+  async function read() {
+    try {
+      return normalizeStarStore(JSON.parse(readFileSync2(indexPath, "utf8")));
+    } catch {
+      return normalizeStarStore(null);
+    }
+  }
+  async function write(store) {
+    await mkdir(dir, { recursive: true });
+    const tmp = join(dir, `.star-${process.pid}-${Date.now()}.tmp`);
+    await writeFile(tmp, JSON.stringify(normalizeStarStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename(tmp, indexPath);
+  }
+  function mutate(mutator) {
+    const operation = mutation.then(async () => {
+      const store = await read();
+      const result = await mutator(store);
+      await write(store);
+      return result;
+    });
+    mutation = operation.catch(() => {
+    });
+    return operation;
+  }
+  function setStarred(ids, starred) {
+    const wanted = (Array.isArray(ids) ? ids : []).filter(isSafeSessionId).map(String);
+    return mutate((store) => {
+      const set = new Set(store.starredSessionIds);
+      for (const id of wanted) {
+        if (starred) set.add(id);
+        else set.delete(id);
+      }
+      store.starredSessionIds = [...set];
+      return store.starredSessionIds;
+    });
+  }
+  function removeIds(ids) {
+    return setStarred(ids, false);
+  }
+  return { read, write, mutate, setStarred, removeIds, indexPath, dir };
+}
+
 // src/index.js
 var name = "dsh-sessions-manager";
 var inject = ["webServer", "workspaceRegistry", "sessionPersistence", "sessionQuery", "storageDomain"];
 var MAX_TITLE = 80;
-var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join(homedir(), ".dsh", "sessions-manager-trash");
-var TRASH_INDEX = join(TRASH_DIR, "index.json");
+var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join2(homedir2(), ".dsh", "sessions-manager-trash");
+var TRASH_INDEX = join2(TRASH_DIR, "index.json");
 var TRASH_SCHEMA_VERSION = 2;
 var DEFAULT_TRASH_SETTINGS = Object.freeze({ retentionDays: 0 });
 var FETCH_TOOL_RE = /search|fetch|download|browse/i;
@@ -77,14 +286,14 @@ function parseIds(body) {
   const raw = body && body.sessionIds;
   if (!Array.isArray(raw)) return null;
   const ids = [];
-  for (const v of raw) if (typeof v === "string" && isSafeSessionId(v)) ids.push(v);
+  for (const v of raw) if (typeof v === "string" && isSafeSessionId2(v)) ids.push(v);
   return ids;
 }
-function isSafeSessionId(value) {
+function isSafeSessionId2(value) {
   return typeof value === "string" && value.length > 0 && value.length <= 200 && !/[\\/\0]/.test(value) && value !== "." && value !== "..";
 }
 function requireSessionId(value) {
-  if (!isSafeSessionId(value)) {
+  if (!isSafeSessionId2(value)) {
     const error = new Error("\u65E0\u6548\u7684 sessionId");
     error.status = 400;
     throw error;
@@ -213,12 +422,12 @@ function apply(ctx) {
       schemaVersion: TRASH_SCHEMA_VERSION,
       settings: { retentionDays },
       items: raw && Array.isArray(raw.items) ? raw.items : [],
-      purgedSessionIds: raw && Array.isArray(raw.purgedSessionIds) ? [...new Set(raw.purgedSessionIds.filter(isSafeSessionId).map(String))] : []
+      purgedSessionIds: raw && Array.isArray(raw.purgedSessionIds) ? [...new Set(raw.purgedSessionIds.filter(isSafeSessionId2).map(String))] : []
     };
   }
   async function readTrashStore() {
     try {
-      return normalizeTrashStore(JSON.parse(readFileSync2(TRASH_INDEX, "utf8")));
+      return normalizeTrashStore(JSON.parse(readFileSync3(TRASH_INDEX, "utf8")));
     } catch (e) {
       return normalizeTrashStore(null);
     }
@@ -227,10 +436,10 @@ function apply(ctx) {
     return (await readTrashStore()).items;
   }
   async function writeTrashStore(store) {
-    await mkdir(TRASH_DIR, { recursive: true });
-    const tmp = join(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
-    await writeFile(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
-    await rename(tmp, TRASH_INDEX);
+    await mkdir2(TRASH_DIR, { recursive: true });
+    const tmp = join2(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
+    await writeFile2(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename2(tmp, TRASH_INDEX);
   }
   function mutateTrash(mutator) {
     const operation = trashMutation.then(async () => {
@@ -243,6 +452,16 @@ function apply(ctx) {
     });
     return operation;
   }
+  const stars = createStarIndex();
+  async function gcStars(validIds) {
+    try {
+      const store = await stars.read();
+      const valid = new Set(validIds.map(String));
+      const gone = store.starredSessionIds.filter((id) => !valid.has(id));
+      if (gone.length) await stars.removeIds(gone);
+    } catch (e) {
+    }
+  }
   async function deleteOne(sid) {
     requireSessionId(sid);
     let header = null;
@@ -382,6 +601,8 @@ function apply(ctx) {
       purged = true;
     });
     if (!purged) throw new Error("\u5F7B\u5E95\u5220\u9664\u5931\u8D25");
+    stars.removeIds([sid]).catch(() => {
+    });
     return { ok: true, purged: true };
   }
   async function trashSettings(next) {
@@ -416,8 +637,8 @@ function apply(ctx) {
   async function moveTargetWorkspace(rawPath) {
     if (typeof rawPath !== "string" || !rawPath.trim()) throw new Error("\u7F3A\u5C11\u76EE\u6807\u5DE5\u4F5C\u533A\u8DEF\u5F84");
     let p = String(rawPath).trim();
-    if (p.startsWith("~/")) p = join(homedir(), p.slice(2));
-    if (!isAbsolute(p)) p = join(homedir(), p);
+    if (p.startsWith("~/")) p = join2(homedir2(), p.slice(2));
+    if (!isAbsolute(p)) p = join2(homedir2(), p);
     let canonical = null;
     try {
       canonical = await realpath(p);
@@ -425,7 +646,7 @@ function apply(ctx) {
       canonical = null;
     }
     if (canonical === null) {
-      await mkdir(p, { recursive: true });
+      await mkdir2(p, { recursive: true });
       canonical = await realpath(p);
     }
     return { canonical, entity: await w.create(canonical, basename(canonical) || "workspace") };
@@ -463,13 +684,13 @@ function apply(ctx) {
       if (!oldPath || !newPath || oldPath === newPath) return false;
       const backupPath = `${oldPath}.move-backup-${Date.now()}`;
       try {
-        await mkdir(dirname(newPath), { recursive: true });
-        await rename(oldPath, backupPath);
+        await mkdir2(dirname(newPath), { recursive: true });
+        await rename2(oldPath, backupPath);
         await rewriteFrame0Cwd(backupPath, canonical);
-        await rename(backupPath, newPath);
+        await rename2(backupPath, newPath);
       } catch (e) {
         try {
-          await rename(backupPath, oldPath);
+          await rename2(backupPath, oldPath);
         } catch (_) {
         }
         if (e && e.code !== "ENOENT") throw e;
@@ -515,7 +736,7 @@ function apply(ctx) {
         const backupPath = oldPath ? `${oldPath}.move-backup-${Date.now()}` : null;
         if (backupPath) {
           try {
-            await rename(oldPath, backupPath);
+            await rename2(oldPath, backupPath);
           } catch (e) {
             if (e && e.code !== "ENOENT") throw new Error("\u79FB\u52A8\u5931\u8D25\uFF1A\u65E0\u6CD5\u5907\u4EFD\u65E7\u7684\u4F1A\u8BDD\u65E5\u5FD7");
           }
@@ -523,7 +744,7 @@ function apply(ctx) {
         const restore = async () => {
           if (backupPath) {
             try {
-              await rename(backupPath, oldPath);
+              await rename2(backupPath, oldPath);
             } catch (_) {
             }
           }
@@ -620,9 +841,11 @@ function apply(ctx) {
   async function allSessionItems() {
     let materialized = /* @__PURE__ */ new Set();
     let live = ctx.get("sessions");
+    let headersOk = false;
     try {
       const headers = await sp.list();
       materialized = new Set(headers.map((h) => String(h.id)));
+      headersOk = true;
     } catch (e) {
     }
     const ids = [];
@@ -658,6 +881,13 @@ function apply(ctx) {
       const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map(resolveOne));
       for (const it of res2) items.push({ ...it, archived: currentArchived.has(it.sessionId) });
     }
+    let starredSet = /* @__PURE__ */ new Set();
+    try {
+      starredSet = new Set((await stars.read()).starredSessionIds);
+    } catch (e) {
+    }
+    for (const it of items) it.starred = starredSet.has(String(it.sessionId));
+    if (headersOk) await gcStars(ids);
     return items;
   }
   async function sidebarAuthority() {
@@ -1053,6 +1283,51 @@ function apply(ctx) {
         }
       }
     }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/star/set",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const starred = !!(body && body.starred);
+          let ids = parseIds(body);
+          if ((!ids || ids.length === 0) && body && typeof body.sessionId === "string") {
+            ids = isSafeSessionId2(body.sessionId) ? [body.sessionId] : null;
+          }
+          if (!ids || ids.length === 0) return json(res, { ok: false, error: "missing sessionId" }, 400);
+          const starredSessionIds = await stars.setStarred(ids, starred);
+          json(res, { ok: true, starredSessionIds });
+        } catch (e) {
+          json(res, { ok: false, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/export-md",
+      handler: async (req, res) => {
+        try {
+          const url = new URL(req.url, "http://localhost");
+          const sid = url.searchParams.get("sessionId");
+          requireSessionId(sid);
+          const r = await sp.readFrom(sid, 0);
+          if (!r || !r.meta) {
+            const error = new Error("\u65E0\u6CD5\u8BFB\u53D6\u8BE5\u4F1A\u8BDD\u7684\u65E5\u5FD7");
+            error.status = 404;
+            throw error;
+          }
+          const md = renderSessionMarkdown({ ...r.meta, id: sid }, r.events || []);
+          res.writeHead(200, {
+            "content-type": "text/markdown; charset=utf-8",
+            "content-disposition": `attachment; filename="dsh-session-${sid}.md"`,
+            "cache-control": "no-store"
+          });
+          res.end(md);
+        } catch (e) {
+          json(res, { error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
     disposers.push(ctx.webServer.register({
       kind: "exact",
       path: "/archived-sessions/sidebar-state",