dsh-session-mng 0.1.3 → 0.2.0

package/lib/store-jsonl.js

@@ -21,7 +21,7 @@
 
 import zlib from 'node:zlib'
 import { homedir } from 'node:os'
-import { dirname, join } from 'node:path'
+import { basename, dirname, join } from 'node:path'
 import { access, cp, mkdir, open, readdir, readFile, rename, rm, stat } from 'node:fs/promises'
 
 import { SessionMngError, messageOf } from './errors.js'
@@ -160,7 +160,81 @@ export async function currentLogFile(dir) {
     }
   }
   if (best === undefined) return undefined
-  return { path: join(dir, best.name), name: best.name, compressed: best.compressed }
+  return { path: join(dir, best.name), name: best.name, compressed: best.compressed, generation: bestGeneration }
+}
+
+/**
+ * Size and format facts of one stored session's current log, at the cost of
+ * exactly one readdir plus one stat.
+ *
+ * The directory comes from the backend's own zero-I/O locator, then
+ * {@link currentLogFile} picks the highest released generation inside it. That
+ * is deliberately NOT `findSessionDirs`/`stat(id)`: both fall back to scanning
+ * every project directory, which must never happen on a page request. The
+ * format status is inferred by comparing the selected generation with the one
+ * `locate()` names as current, so an older-generation log is reported honestly
+ * instead of being labelled current.
+ *
+ * @param {object} persistence - the host's JSONL persistence service.
+ * @param {string} id - stored session id.
+ * @param {string} [cwd] - the session's stored working directory.
+ * @returns {Promise<{sizeBytes: number, formatStatus: string, logName: string}|undefined>}
+ */
+export async function readLogFacts(persistence, id, cwd) {
+  let located
+  try {
+    located = persistence?.locate?.({ id, cwd })
+  } catch {
+    return undefined
+  }
+  const path = typeof located?.path === 'string' ? located.path : ''
+  if (path === '') return undefined
+  const currentGeneration = generationOf(basename(path))
+  const log = await currentLogFile(dirname(path))
+  if (log === undefined) return undefined
+  let size
+  try {
+    size = (await stat(log.path)).size
+  } catch {
+    return undefined
+  }
+  const migrationRequired = currentGeneration !== undefined && log.generation < currentGeneration
+  return {
+    sizeBytes: size,
+    formatStatus: migrationRequired ? 'migration-required' : 'current',
+    logName: log.name,
+  }
+}
+
+/** Maximum concurrent per-log stat batches; small enough to stay polite. */
+const FACT_CONCURRENCY = 8
+
+/**
+ * Read {@link readLogFacts} for a bounded batch (one page at most in practice).
+ *
+ * @param {object} persistence
+ * @param {{id: string, cwd?: string}[]} items
+ * @param {number} [concurrency]
+ * @returns {Promise<Map<string, {sizeBytes: number, formatStatus: string, logName: string}>>}
+ */
+export async function readLogFactsBatch(persistence, items, concurrency = FACT_CONCURRENCY) {
+  const found = new Map()
+  if (!Array.isArray(items) || items.length === 0) return found
+  let next = 0
+  const worker = async () => {
+    for (;;) {
+      const index = next
+      next += 1
+      if (index >= items.length) return
+      const item = items[index]
+      if (typeof item?.id !== 'string') continue
+      const facts = await readLogFacts(persistence, item.id, item.cwd).catch(() => undefined)
+      if (facts !== undefined) found.set(item.id, facts)
+    }
+  }
+  const width = Math.max(1, Math.min(Math.trunc(concurrency) || 1, items.length))
+  await Promise.all(Array.from({ length: width }, worker))
+  return found
 }
 
 /** Every offset where a Zstandard frame magic begins. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-mng",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "type": "module",
   "description": "Session management for DeepSeek Harness: one Settings page for every session — whole-session title generation, archive/restore, cross-workspace move, and permanent deletion of archived sessions.",
   "license": "MIT",