@corenel/sidecar 0.5.1 → 0.6.0

package/dist/cli.js

@@ -21444,6 +21444,15 @@ import { join as join18 } from "node:path";
 import { readFileSync } from "node:fs";
 import { spawn as spawn9 } from "node:child_process";
 
+// ../protocol/ports.ts
+function compareSessionKeys(a2, b2) {
+  if (a2.mtime !== b2.mtime) return b2.mtime - a2.mtime;
+  return a2.path < b2.path ? -1 : a2.path > b2.path ? 1 : 0;
+}
+function isAfterSessionKey(k2, before) {
+  return compareSessionKeys(before, k2) < 0;
+}
+
 // ../protocol/files.ts
 var PROMPD_INSTALL_DIR = ".prompd";
 var INSTALL_TYPE_DIRS = ["packages", "workflows", "skills", "templates"];
@@ -24043,7 +24052,7 @@ var NodeFileService = class {
           out.push({ name: e2.name, path, kind: "directory", children: await walk(absChild) });
         } else {
           const st2 = await fs3.stat(absChild).catch(() => null);
-          out.push({ name: e2.name, path, kind: "file", size: st2?.size, ext: extOf(e2.name) });
+          out.push({ name: e2.name, path, kind: "file", size: st2?.size, mtime: st2?.mtimeMs, ext: extOf(e2.name) });
         }
       }
       return out;
@@ -24056,7 +24065,7 @@ var NodeFileService = class {
   async stat(path) {
     try {
       const st2 = await fs3.stat(this.abs(path));
-      return { path: normalizeFilePath(path), kind: st2.isDirectory() ? "directory" : "file", size: st2.size, ext: extOf(path) };
+      return { path: normalizeFilePath(path), kind: st2.isDirectory() ? "directory" : "file", size: st2.size, mtime: st2.mtimeMs, ext: extOf(path) };
     } catch {
       return null;
     }
@@ -27215,6 +27224,8 @@ async function assertRealWithinRoot(roots, abs) {
 }
 var ROOT_PARAM = { type: "string", description: "which pre-approved root to resolve the path against (its absolute path; defaults to the primary root)" };
 var MAX_READ_BYTES = 16 * 1024 * 1024;
+var MAX_LIST_DEPTH = 64;
+var MAX_LIST_ENTRIES = 2e4;
 function nodeFsTools(roots) {
   return [
     {
@@ -27290,14 +27301,50 @@ function nodeFsTools(roots) {
       description: "List the entries of a directory on the sidecar machine, relative to a pre-approved root.",
       parameters: {
         type: "object",
-        properties: { path: { type: "string", description: 'directory relative to the chosen root (default ".")' }, root: ROOT_PARAM }
+        properties: {
+          path: { type: "string", description: 'directory relative to the chosen root (default ".")' },
+          detail: { type: "boolean", description: "return one JSON object per line carrying size and mtime, instead of bare names" },
+          depth: { type: "number", description: "with detail: how many directory levels to descend (default 1). Names come back relative to the listed directory." },
+          limit: { type: "number", description: "with detail: stop after this many entries (default 4000)" },
+          skip: { type: "array", items: { type: "string" }, description: "with detail: directory names never descended into (listed, but not walked)" },
+          root: ROOT_PARAM
+        }
       },
       namespace: "sidecar",
       async run(args) {
         const abs = confine(roots, args.root, String(args.path ?? "."));
         await assertRealWithinRoot(roots, abs);
-        const entries = await fs7.readdir(abs, { withFileTypes: true });
-        return entries.map((e2) => e2.isDirectory() ? `${e2.name}/` : e2.name).join("\n");
+        if (!args.detail) {
+          const entries = await fs7.readdir(abs, { withFileTypes: true });
+          return entries.map((e2) => e2.isDirectory() ? `${e2.name}/` : e2.name).join("\n");
+        }
+        const depth = Math.min(
+          typeof args.depth === "number" && args.depth > 0 ? Math.floor(args.depth) : 1,
+          MAX_LIST_DEPTH
+        );
+        const limit2 = Math.min(
+          typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : 4e3,
+          MAX_LIST_ENTRIES
+        );
+        const skip = new Set(Array.isArray(args.skip) ? args.skip.map((x2) => String(x2)) : []);
+        const out = [];
+        const walk = async (dirAbs, rel, left) => {
+          if (out.length >= limit2) return;
+          const entries = await fs7.readdir(dirAbs, { withFileTypes: true }).catch(() => []);
+          for (const e2 of entries) {
+            if (out.length >= limit2) return;
+            const name = rel ? `${rel}/${e2.name}` : e2.name;
+            if (e2.isDirectory()) {
+              out.push(JSON.stringify({ n: name, d: 1 }));
+              if (left > 1 && !skip.has(e2.name)) await walk(resolve2(dirAbs, e2.name), name, left - 1);
+              continue;
+            }
+            const st2 = await fs7.lstat(resolve2(dirAbs, e2.name)).catch(() => null);
+            out.push(JSON.stringify({ n: name, ...st2 ? { s: st2.size, m: Math.round(st2.mtimeMs) } : {} }));
+          }
+        };
+        await walk(abs, "", depth);
+        return out.join("\n");
       }
     },
     {
@@ -39950,6 +39997,20 @@ function reconcileDanglingToolCalls(messages) {
 }
 
 // ../harness/sessions/fileSessionStore.ts
+var READ_CONCURRENCY = 8;
+async function mapPool(items, limit2, fn) {
+  const out = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const i2 = next++;
+      if (i2 >= items.length) return;
+      out[i2] = await fn(items[i2]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit2, items.length) }, worker));
+  return out;
+}
 function uid(prefix) {
   return `${prefix}_${Date.now().toString(36)}${Math.floor(Math.random() * 1e6).toString(36)}`;
 }
@@ -39959,7 +40020,7 @@ function now() {
   lastTs = t2 > lastTs ? t2 : lastTs + 1;
   return lastTs;
 }
-var JsonlSessionStore = class {
+var JsonlSessionStore = class _JsonlSessionStore {
   constructor(getFiles, root = sessionsRoot) {
     this.getFiles = getFiles;
     this.root = root;
@@ -39996,19 +40057,92 @@ var JsonlSessionStore = class {
     }
     return ses;
   }
-  async list(surface) {
+  /** The SESSION.jsonl nodes under the root.
+   *
+   * list(dir) shape differs per backend: MemoryFileService returns a tree
+   * rooted at the WORKSPACE root (the top level is the ancestor chain, e.g.
+   * ['.prompd']), while others return dir's children. Never trust the top
+   * level — flatten and match the SESSION.jsonl files by path. */
+  async sessionFiles() {
     const files = await this.files();
     const root = this.root();
     const nodes = await files.list(root).catch(() => []);
-    const sessionFiles = flattenFiles(nodes).filter((f2) => f2.name === "SESSION.jsonl" && f2.path.startsWith(root + "/"));
-    const out = [];
-    for (const f2 of sessionFiles) {
-      const text = await files.read(f2.path).catch(() => null);
-      const ses = text != null ? foldSession(text) : null;
-      if (ses) out.push(ses);
-    }
-    const scoped = surface ? out.filter((s2) => s2.surface === surface || surface === "agent" && !s2.surface) : out;
-    return scoped.sort((a2, b2) => b2.updatedAt - a2.updatedAt);
+    return flattenFiles(nodes).filter((f2) => f2.name === "SESSION.jsonl" && f2.path.startsWith(root + "/"));
+  }
+  /** Fold the session at `path`, or null when it cannot be read or parsed. */
+  async readSession(path) {
+    const files = await this.files();
+    const text = await files.read(path).catch(() => null);
+    return text != null ? foldSession(text) : null;
+  }
+  static scoped(s2, surface) {
+    return !surface || s2.surface === surface || surface === "agent" && !s2.surface;
+  }
+  async list(surface) {
+    const nodes = await this.sessionFiles();
+    const folded = await mapPool(nodes, READ_CONCURRENCY, (f2) => this.readSession(f2.path));
+    const out = folded.filter((s2) => s2 !== null && _JsonlSessionStore.scoped(s2, surface));
+    return out.sort((a2, b2) => b2.updatedAt - a2.updatedAt);
+  }
+  /**
+   * One page of sessions, newest first, WITHOUT opening the whole history.
+   *
+   * TWO PATHS, chosen by whether the backend dated the listing:
+   *
+   *   mtime present   NodeFileService (so any sidecar workspace) and
+   *                   DirectoryHandleFileService. Sort the directory listing by
+   *                   mtime, cut the page, and read only those files. The
+   *                   cursor is an mtime.
+   *
+   *   mtime absent    MemoryFileService, the virtual IndexedDB workspace, which
+   *                   does not date its entries. There is no way to know which
+   *                   sessions are newest without folding them, so this does
+   *                   exactly what list() always did and pages the result. No
+   *                   faster than before, but not WRONG — and its reads are
+   *                   local and cheap, which is why that trade is acceptable.
+   *
+   * Correctness first: a partially-dated listing (some files with mtime, some
+   * without) takes the slow path too, because sorting undefined against a real
+   * timestamp would silently misorder the history.
+   */
+  async listPage(q2) {
+    const nodes = await this.sessionFiles();
+    const limit2 = Math.max(1, Math.floor(q2.limit));
+    if (nodes.length > 0 && nodes.every((n2) => typeof n2.mtime === "number")) {
+      const keyOf3 = (n2) => ({ mtime: n2.mtime, path: n2.path });
+      const ordered = [...nodes].sort((a2, b2) => compareSessionKeys(keyOf3(a2), keyOf3(b2))).filter((n2) => q2.before === void 0 || isAfterSessionKey(keyOf3(n2), q2.before));
+      const kept = [];
+      for (let i2 = 0; i2 < ordered.length && kept.length <= limit2; i2 += limit2 + 1) {
+        const batch = ordered.slice(i2, i2 + limit2 + 1);
+        const folded = await mapPool(batch, READ_CONCURRENCY, async (n2) => {
+          const s2 = await this.readSession(n2.path);
+          return s2 ? { s: s2, key: keyOf3(n2) } : null;
+        });
+        for (const r2 of folded) if (r2 && _JsonlSessionStore.scoped(r2.s, q2.surface)) kept.push(r2);
+      }
+      const more2 = kept.length > limit2;
+      const page2 = kept.slice(0, limit2);
+      const last2 = page2[page2.length - 1];
+      return {
+        sessions: page2.map((r2) => r2.s),
+        keys: page2.map((r2) => r2.key),
+        ...more2 && last2 ? { cursor: last2.key } : {},
+        more: more2
+      };
+    }
+    const all = await this.list(q2.surface);
+    const keyed = all.map((s2) => ({ s: s2, key: { mtime: s2.updatedAt, path: this.path(s2.id) } }));
+    keyed.sort((a2, b2) => compareSessionKeys(a2.key, b2.key));
+    const from = q2.before === void 0 ? keyed : keyed.filter((r2) => isAfterSessionKey(r2.key, q2.before));
+    const page = from.slice(0, limit2);
+    const more = from.length > limit2;
+    const last = page[page.length - 1];
+    return {
+      sessions: page.map((r2) => r2.s),
+      keys: page.map((r2) => r2.key),
+      ...more && last ? { cursor: last.key } : {},
+      more
+    };
   }
   async save(session) {
     const at2 = now();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corenel/sidecar",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "type": "module",
   "license": "Elastic-2.0",
   "description": "Prompd sidecar — a local capability server. Run it next to Prompd (prompd.app) so the browser app can reach your machine: local LLMs (Ollama/LM Studio/vLLM) without CORS, your filesystem, and (opt-in) shell.",
@@ -36,10 +36,10 @@
     "esbuild": "^0.21.5",
     "tsx": "^4.19.2",
     "typescript": "^5.9.3",
-    "@corenel/protocol": "0.5.0",
+    "@corenel/protocol": "0.6.0",
     "@corenel/crew": "0.0.0",
-    "@corenel/tools-node": "0.2.2",
-    "@corenel/harness": "0.5.1"
+    "@corenel/harness": "0.6.0",
+    "@corenel/tools-node": "0.3.0"
   },
   "repository": {
     "type": "git",