dsh-sessions-manager 3.3.0 → 3.4.0

package/lib/index.js

@@ -1,8 +1,8 @@
 // src/index.js
-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";
+import { mkdir as mkdir3, realpath, rename as rename3, stat, unlink, writeFile as writeFile3 } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join as join3 } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
 
 // src/zstd-frame.js
 import zlib from "node:zlib";
@@ -250,17 +250,179 @@ function createStarIndex(options = {}) {
   return { read, write, mutate, setStarred, removeIds, indexPath, dir };
 }
 
+// src/storage-stats.js
+var UNGROUPED_KEY = "__ungrouped__";
+function isFiniteSize(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function aggregateStorage(items, options = {}) {
+  const topN = Number.isInteger(options.topN) && options.topN > 0 ? options.topN : 10;
+  const list = Array.isArray(items) ? items : [];
+  const buckets = /* @__PURE__ */ new Map();
+  const sized = [];
+  let totalBytes = 0;
+  let unknownSessions = 0;
+  let counted = 0;
+  for (const item of list) {
+    if (!item || item.sessionId == null) continue;
+    counted++;
+    const id = String(item.sessionId);
+    const path = item.workspacePath ? String(item.workspacePath) : null;
+    const key = path || UNGROUPED_KEY;
+    let bucket = buckets.get(key);
+    if (!bucket) {
+      bucket = { key, path, title: item.workspaceTitle ? String(item.workspaceTitle) : null, bytes: 0, sessions: 0 };
+      buckets.set(key, bucket);
+    }
+    bucket.sessions++;
+    if (isFiniteSize(item.sizeBytes)) {
+      bucket.bytes += item.sizeBytes;
+      totalBytes += item.sizeBytes;
+      sized.push({
+        sessionId: id,
+        title: item.title || null,
+        workspacePath: path,
+        workspaceTitle: bucket.title,
+        sizeBytes: item.sizeBytes
+      });
+    } else {
+      unknownSessions++;
+    }
+  }
+  const workspaces = [...buckets.values()].sort((a, b) => b.bytes - a.bytes || b.sessions - a.sessions || a.key.localeCompare(b.key)).map((bucket) => ({ ...bucket, share: totalBytes > 0 ? bucket.bytes / totalBytes : 0 }));
+  const top = sized.sort((a, b) => b.sizeBytes - a.sizeBytes || a.sessionId.localeCompare(b.sessionId)).slice(0, topN);
+  return {
+    totalBytes,
+    sessionCount: counted,
+    sizedSessions: sized.length,
+    unknownSessions,
+    workspaces,
+    top
+  };
+}
+
+// src/auto-archive.js
+import { mkdir as mkdir2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+var AUTO_ARCHIVE_SCHEMA_VERSION = 4;
+var INACTIVE_DAY_OPTIONS = Object.freeze([0, 30, 60, 90]);
+var DAY_MS = 864e5;
+var RUN_INTERVAL_MS = DAY_MS;
+var DEFAULT_DIR = join2(homedir2(), ".dsh", "sessions-manager");
+function normalizeAutoArchiveStore(raw) {
+  const source = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const settings = source.settings && typeof source.settings === "object" ? source.settings : {};
+  const inactiveDays = INACTIVE_DAY_OPTIONS.includes(settings.inactiveDays) ? settings.inactiveDays : 0;
+  return {
+    schemaVersion: AUTO_ARCHIVE_SCHEMA_VERSION,
+    settings: {
+      inactiveDays,
+      // Starred sessions are an explicit "keep" mark, so they are skipped
+      // unless the user opts out.
+      skipStarred: settings.skipStarred !== false
+    },
+    lastRunAt: Number.isFinite(source.lastRunAt) ? source.lastRunAt : null,
+    lastArchivedCount: Number.isInteger(source.lastArchivedCount) && source.lastArchivedCount >= 0 ? source.lastArchivedCount : 0
+  };
+}
+function pickInactiveCandidates(items, options = {}) {
+  const days = options.inactiveDays;
+  if (!INACTIVE_DAY_OPTIONS.includes(days) || days === 0) return [];
+  const now = Number.isFinite(options.now) ? options.now : Date.now();
+  const cutoff = now - days * DAY_MS;
+  const skipStarred = options.skipStarred !== false;
+  const activeId = options.activeSessionId != null ? String(options.activeSessionId) : null;
+  const list = Array.isArray(items) ? items : [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    if (!item || item.sessionId == null) continue;
+    const id = String(item.sessionId);
+    if (seen.has(id)) continue;
+    if (item.archived) continue;
+    if (skipStarred && item.starred) continue;
+    if (activeId !== null && id === activeId) continue;
+    const updatedAt = Number(item.updatedAt);
+    if (!Number.isFinite(updatedAt) || updatedAt <= 0) continue;
+    if (updatedAt < cutoff) {
+      seen.add(id);
+      out.push(id);
+    }
+  }
+  return out;
+}
+function createAutoArchiveStore(options = {}) {
+  const dir = options.dir || process.env.DSH_SESSIONS_MANAGER_AUTO_ARCHIVE_DIR || DEFAULT_DIR;
+  const indexPath = options.indexPath || join2(dir, "auto-archive.json");
+  let mutation = Promise.resolve();
+  async function read() {
+    try {
+      return normalizeAutoArchiveStore(JSON.parse(readFileSync3(indexPath, "utf8")));
+    } catch {
+      return normalizeAutoArchiveStore(null);
+    }
+  }
+  async function write(store) {
+    await mkdir2(dir, { recursive: true });
+    const tmp = join2(dir, `.auto-archive-${process.pid}-${Date.now()}.tmp`);
+    await writeFile2(tmp, JSON.stringify(normalizeAutoArchiveStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename2(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 update(patch = {}) {
+    return mutate((store) => {
+      if (Object.prototype.hasOwnProperty.call(patch, "inactiveDays")) {
+        const days = Number(patch.inactiveDays);
+        if (!INACTIVE_DAY_OPTIONS.includes(days)) {
+          const error = new Error(`inactiveDays \u4EC5\u652F\u6301 ${INACTIVE_DAY_OPTIONS.join("\u3001")}`);
+          error.status = 400;
+          throw error;
+        }
+        store.settings.inactiveDays = days;
+      }
+      if (Object.prototype.hasOwnProperty.call(patch, "skipStarred")) {
+        store.settings.skipStarred = !!patch.skipStarred;
+      }
+      return store.settings;
+    });
+  }
+  function recordRun(count, at = Date.now()) {
+    return mutate((store) => {
+      store.lastRunAt = at;
+      store.lastArchivedCount = Number.isInteger(count) && count >= 0 ? count : 0;
+      return store;
+    });
+  }
+  function isFresh(store, now = Date.now()) {
+    return Number.isFinite(store && store.lastRunAt) && now - store.lastRunAt < RUN_INTERVAL_MS;
+  }
+  return { read, write, mutate, update, recordRun, isFresh, 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 || join2(homedir2(), ".dsh", "sessions-manager-trash");
-var TRASH_INDEX = join2(TRASH_DIR, "index.json");
+var TRASH_DIR = process.env.DSH_SESSIONS_MANAGER_TRASH_DIR || join3(homedir3(), ".dsh", "sessions-manager-trash");
+var TRASH_INDEX = join3(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;
 var MAX_FETCHES = 12;
 var MAX_FILES = 20;
+var MAX_STORAGE_TOP = 50;
 function json(res, value, status = 200) {
   res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
   res.end(JSON.stringify(value));
@@ -372,7 +534,7 @@ function apply(ctx) {
     return operation;
   }
   let wsByPath = {};
-  async function resolveOne(id) {
+  async function resolveOne(id, usage) {
     let title = null, createdAt = null, cwd = null;
     try {
       const o = await sq.readTitleSnapshot(id);
@@ -399,7 +561,7 @@ function apply(ctx) {
     const ws = cwd ? wsByPath[cwd] : void 0;
     const workspaceGone = !!(cwd && !ws);
     const display = title ? String(title).length > MAX_TITLE ? String(title).slice(0, MAX_TITLE) + "\u2026" : String(title) : null;
-    return {
+    const base = {
       sessionId: id,
       title: display,
       createdAt: createdAt || null,
@@ -408,6 +570,39 @@ function apply(ctx) {
       workspaceGone: workspaceGone ? true : false,
       hasWorkspace: !!cwd
     };
+    if (usage) {
+      if (usage.sizeById && usage.sizeById.has(id)) base.sizeBytes = usage.sizeById.get(id);
+      if (usage.mtimeById && usage.mtimeById.has(id)) base.updatedAt = usage.mtimeById.get(id);
+    }
+    return base;
+  }
+  async function collectUsage() {
+    const sizeById = /* @__PURE__ */ new Map();
+    const mtimeById = /* @__PURE__ */ new Map();
+    let headers = [];
+    try {
+      headers = await sp.list();
+    } catch (e) {
+      headers = [];
+    }
+    if (!Array.isArray(headers)) headers = [];
+    const CHUNK = 8;
+    for (let i = 0; i < headers.length; i += CHUNK) {
+      await Promise.all(headers.slice(i, i + CHUNK).map(async (header) => {
+        const id = header && header.id != null ? String(header.id) : null;
+        if (!id) return;
+        try {
+          const loc = sp.locate(header);
+          if (!loc || typeof loc.path !== "string" || !loc.path) return;
+          const st = await stat(loc.path);
+          if (!st) return;
+          if (typeof st.size === "number") sizeById.set(id, st.size);
+          if (typeof st.mtimeMs === "number" && st.mtimeMs > 0) mtimeById.set(id, Math.floor(st.mtimeMs));
+        } catch (e) {
+        }
+      }));
+    }
+    return { sizeById, mtimeById };
   }
   async function restoreOne(sid) {
     requireSessionId(sid);
@@ -427,7 +622,7 @@ function apply(ctx) {
   }
   async function readTrashStore() {
     try {
-      return normalizeTrashStore(JSON.parse(readFileSync3(TRASH_INDEX, "utf8")));
+      return normalizeTrashStore(JSON.parse(readFileSync4(TRASH_INDEX, "utf8")));
     } catch (e) {
       return normalizeTrashStore(null);
     }
@@ -436,10 +631,10 @@ function apply(ctx) {
     return (await readTrashStore()).items;
   }
   async function writeTrashStore(store) {
-    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);
+    await mkdir3(TRASH_DIR, { recursive: true });
+    const tmp = join3(TRASH_DIR, `.index-${process.pid}-${Date.now()}.tmp`);
+    await writeFile3(tmp, JSON.stringify(normalizeTrashStore(store), null, 2), { encoding: "utf8", mode: 384 });
+    await rename3(tmp, TRASH_INDEX);
   }
   function mutateTrash(mutator) {
     const operation = trashMutation.then(async () => {
@@ -453,6 +648,7 @@ function apply(ctx) {
     return operation;
   }
   const stars = createStarIndex();
+  const autoArchive = createAutoArchiveStore();
   async function gcStars(validIds) {
     try {
       const store = await stars.read();
@@ -637,8 +833,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 = join2(homedir2(), p.slice(2));
-    if (!isAbsolute(p)) p = join2(homedir2(), p);
+    if (p.startsWith("~/")) p = join3(homedir3(), p.slice(2));
+    if (!isAbsolute(p)) p = join3(homedir3(), p);
     let canonical = null;
     try {
       canonical = await realpath(p);
@@ -646,7 +842,7 @@ function apply(ctx) {
       canonical = null;
     }
     if (canonical === null) {
-      await mkdir2(p, { recursive: true });
+      await mkdir3(p, { recursive: true });
       canonical = await realpath(p);
     }
     return { canonical, entity: await w.create(canonical, basename(canonical) || "workspace") };
@@ -684,13 +880,13 @@ function apply(ctx) {
       if (!oldPath || !newPath || oldPath === newPath) return false;
       const backupPath = `${oldPath}.move-backup-${Date.now()}`;
       try {
-        await mkdir2(dirname(newPath), { recursive: true });
-        await rename2(oldPath, backupPath);
+        await mkdir3(dirname(newPath), { recursive: true });
+        await rename3(oldPath, backupPath);
         await rewriteFrame0Cwd(backupPath, canonical);
-        await rename2(backupPath, newPath);
+        await rename3(backupPath, newPath);
       } catch (e) {
         try {
-          await rename2(backupPath, oldPath);
+          await rename3(backupPath, oldPath);
         } catch (_) {
         }
         if (e && e.code !== "ENOENT") throw e;
@@ -736,7 +932,7 @@ function apply(ctx) {
         const backupPath = oldPath ? `${oldPath}.move-backup-${Date.now()}` : null;
         if (backupPath) {
           try {
-            await rename2(oldPath, backupPath);
+            await rename3(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");
           }
@@ -744,7 +940,7 @@ function apply(ctx) {
         const restore = async () => {
           if (backupPath) {
             try {
-              await rename2(backupPath, oldPath);
+              await rename3(backupPath, oldPath);
             } catch (_) {
             }
           }
@@ -838,7 +1034,7 @@ function apply(ctx) {
       return { next: null, value: { ok: true, archived: true } };
     });
   }
-  async function allSessionItems() {
+  async function allSessionItems(opts = {}) {
     let materialized = /* @__PURE__ */ new Set();
     let live = ctx.get("sessions");
     let headersOk = false;
@@ -876,9 +1072,10 @@ function apply(ctx) {
     }
     const currentArchived = new Set((await archivedState().catch(() => ({ archivedSessionIds: [] }))).archivedSessionIds || []);
     const items = [];
+    const usage = opts && opts.usage ? await collectUsage() : null;
     const CHUNK = 6;
     for (let i = 0; i < visibleIds.length; i += CHUNK) {
-      const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map(resolveOne));
+      const res2 = await Promise.all(visibleIds.slice(i, i + CHUNK).map((id) => resolveOne(id, usage)));
       for (const it of res2) items.push({ ...it, archived: currentArchived.has(it.sessionId) });
     }
     let starredSet = /* @__PURE__ */ new Set();
@@ -890,6 +1087,40 @@ function apply(ctx) {
     if (headersOk) await gcStars(ids);
     return items;
   }
+  async function buildStorage(opts = {}) {
+    const items = await allSessionItems({ usage: true });
+    const raw = Number(opts && opts.topN);
+    const topN = Number.isInteger(raw) && raw > 0 ? Math.min(raw, MAX_STORAGE_TOP) : 10;
+    return aggregateStorage(items, { topN });
+  }
+  async function autoArchiveSweep(opts = {}) {
+    const store = await autoArchive.read();
+    const days = store.settings.inactiveDays;
+    if (!days) return { ok: true, skipped: "disabled", archived: 0 };
+    const now = Date.now();
+    if (!(opts && opts.force) && autoArchive.isFresh(store, now)) {
+      return { ok: true, skipped: "throttled", archived: 0, lastRunAt: store.lastRunAt, lastArchivedCount: store.lastArchivedCount };
+    }
+    const items = await allSessionItems({ usage: true });
+    const candidates = pickInactiveCandidates(items, {
+      inactiveDays: days,
+      skipStarred: store.settings.skipStarred,
+      activeSessionId: getActiveSessionId(ctx),
+      now
+    });
+    let archived = 0;
+    const failed = [];
+    for (const sid of candidates) {
+      try {
+        const result = await archiveOne(sid);
+        if (result && result.archived) archived++;
+      } catch (e) {
+        failed.push({ sessionId: sid, error: String(e && e.message || e) });
+      }
+    }
+    await autoArchive.recordRun(archived, now);
+    return { ok: true, archived, candidates: candidates.length, failed, lastRunAt: now };
+  }
   async function sidebarAuthority() {
     const ids = [];
     try {
@@ -1096,7 +1327,7 @@ function apply(ctx) {
           const items = [];
           const CHUNK = 6;
           for (let i = 0; i < idStrs.length; i += CHUNK) {
-            const res2 = await Promise.all(idStrs.slice(i, i + CHUNK).map(resolveOne));
+            const res2 = await Promise.all(idStrs.slice(i, i + CHUNK).map((id) => resolveOne(id)));
             items.push.apply(items, res2);
           }
           json(res, { items });
@@ -1421,6 +1652,55 @@ function apply(ctx) {
         }
       }
     }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/storage",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          json(res, await buildStorage({ topN: body && body.topN }));
+        } catch (e) {
+          json(res, { error: String(e && e.message || e) }, 500);
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/auto-archive/settings",
+      handler: async (req, res) => {
+        try {
+          const body = await readJsonBody(req);
+          const patch = {};
+          if (body && Object.prototype.hasOwnProperty.call(body, "inactiveDays")) patch.inactiveDays = body.inactiveDays;
+          if (body && Object.prototype.hasOwnProperty.call(body, "skipStarred")) patch.skipStarred = body.skipStarred;
+          const settings = Object.keys(patch).length ? await autoArchive.update(patch) : (await autoArchive.read()).settings;
+          const sweep = await autoArchiveSweep();
+          const store = await autoArchive.read();
+          json(res, {
+            ok: true,
+            settings,
+            lastRunAt: store.lastRunAt,
+            lastArchivedCount: store.lastArchivedCount,
+            sweep
+          });
+        } catch (e) {
+          json(res, { ok: false, error: String(e && e.message || e) }, errorStatus(e));
+        }
+      }
+    }));
+    disposers.push(ctx.webServer.register({
+      kind: "exact",
+      path: "/archived-sessions/auto-archive/run",
+      handler: async (req, res) => {
+        try {
+          const sweep = await autoArchiveSweep({ force: true });
+          const store = await autoArchive.read();
+          json(res, { ok: true, ...sweep, settings: store.settings, lastRunAt: store.lastRunAt, lastArchivedCount: store.lastArchivedCount });
+        } catch (e) {
+          json(res, { ok: false, error: String(e && e.message || e) }, 500);
+        }
+      }
+    }));
     return () => {
       for (const d of disposers) d();
     };