@bivy/bivy 0.17.2-staging.4 → 0.17.2-staging.5

package/dist/server.js

@@ -1744,8 +1744,10 @@ function referencedAttachmentHashes() {
     const ids = new Set(metadata.listSessions().map((session) => session.id));
     for (const record of new Set(openSessions.values()))
         ids.add(record.id);
+    // `scan`, not `entries`: this visits every session ever created, and must not pin
+    // each one's full log in the event-log cache.
     for (const id of ids) {
-        for (const entry of eventLog.entries(id)) {
+        for (const entry of eventLog.scan(id, ["attachment", "outbound-attachment", "inline-image"])) {
             if (entry.bivyKind === "attachment")
                 for (const ref of entry.refs)
                     hashes.add(ref.hash);

package/dist/session/event-log.js

@@ -397,12 +397,12 @@ export function baseReplay(entries) {
     }
     return base;
 }
-function parseLogDetailed(body) {
+function parseLogDetailed(body, keep = () => true) {
     const records = [];
     let malformedLines = 0;
     for (const line of body.split("\n")) {
         const trimmed = line.trim();
-        if (!trimmed)
+        if (!trimmed || !keep(trimmed))
             continue;
         try {
             const value = JSON.parse(trimmed);
@@ -429,6 +429,10 @@ export function parseLog(body) {
  * `throttleMs` per session (a burst of same-id deltas within a window collapses to
  * one appended line). Durability at boundaries is explicit `flush()` (turn-end,
  * close, delete, shutdown), mirroring `SidecarStore`.
+ *
+ * The in-memory copy of flushed records is an LRU capped at `maxCachedBytes`
+ * (measured as log-file size): an evicted session simply re-reads its file on next
+ * use, so memory tracks the sessions in use, not the node's whole history.
  */
 export class EventLog {
     dir;
@@ -436,7 +440,10 @@ export class EventLog {
     redact;
     throttleMs;
     onIssue;
+    maxCachedBytes;
     disk = new Map();
+    diskBytes = new Map();
+    cachedBytes = 0;
     pending = new Map();
     timers = new Map();
     lastFlush = new Map();
@@ -446,12 +453,13 @@ export class EventLog {
     // on first use of a session after a restart.
     baseKeys = new Map();
     lastIssue;
-    constructor(dir, pathFor, redact = (t) => t, throttleMs = 500, onIssue = (issue) => console.error(`[event-log] ${issue.operation} failed for ${issue.sessionId}: ${issue.message}`)) {
+    constructor(dir, pathFor, redact = (t) => t, throttleMs = 500, onIssue = (issue) => console.error(`[event-log] ${issue.operation} failed for ${issue.sessionId}: ${issue.message}`), maxCachedBytes = 64 * 1024 * 1024) {
         this.dir = dir;
         this.pathFor = pathFor;
         this.redact = redact;
         this.throttleMs = throttleMs;
         this.onIssue = onIssue;
+        this.maxCachedBytes = maxCachedBytes;
     }
     report(id, operation, error) {
         const issue = {
@@ -493,23 +501,64 @@ export class EventLog {
         }
         return { files, bytes };
     }
-    load(id) {
-        const cached = this.disk.get(id);
-        if (cached)
-            return cached;
-        let data = [];
+    /** Read + parse a session's log file (lines passing `keep`), reporting problems. */
+    readLog(id, keep) {
         try {
-            const parsed = parseLogDetailed(fs.readFileSync(this.pathFor(id), "utf8"));
-            data = parsed.records;
+            const body = fs.readFileSync(this.pathFor(id), "utf8");
+            const parsed = parseLogDetailed(body, keep);
             if (parsed.malformedLines > 0)
                 this.report(id, "parse", new Error(`${parsed.malformedLines} malformed record(s); valid history was recovered`));
+            return { records: parsed.records, bytes: body.length };
         }
         catch (error) {
             if (error?.code !== "ENOENT")
                 this.report(id, "read", error);
+            return { records: [], bytes: 0 };
+        }
+    }
+    load(id) {
+        const cached = this.disk.get(id);
+        if (cached) {
+            // Re-insert to mark most-recently-used (Map iterates in insertion order).
+            this.disk.delete(id);
+            this.disk.set(id, cached);
+            return cached;
         }
-        this.disk.set(id, data);
-        return data;
+        const { records, bytes } = this.readLog(id);
+        this.cache(id, records, bytes);
+        return records;
+    }
+    /** Store a session's flushed records, then evict least-recently-used others past the cap. */
+    cache(id, records, bytes) {
+        this.uncache(id);
+        this.disk.set(id, records);
+        this.diskBytes.set(id, bytes);
+        this.cachedBytes += bytes;
+        for (const oldest of this.disk.keys()) {
+            if (this.cachedBytes <= this.maxCachedBytes || oldest === id)
+                break;
+            this.uncache(oldest);
+        }
+    }
+    uncache(id) {
+        this.cachedBytes -= this.diskBytes.get(id) ?? 0;
+        this.diskBytes.delete(id);
+        this.disk.delete(id);
+    }
+    /**
+     * The session's records of the given kinds, read WITHOUT caching the log. For
+     * whole-store sweeps (attachment GC) that visit every session, where `load` would
+     * pin every log in memory. Uses the cached copy when there is one, and always
+     * includes pending records so unflushed writes are never missed. Off the cache only
+     * candidate lines are parsed: those naming a wanted kind, plus torn lines (not
+     * ending in `}`) so a truncated write is still reported and callers can fail closed.
+     */
+    scan(id, kinds) {
+        const wanted = new Set(kinds);
+        const markers = kinds.map((kind) => `"bivyKind":${JSON.stringify(kind)}`);
+        const flushed = this.disk.get(id) ?? this.readLog(id, (line) => !line.endsWith("}") || markers.some((m) => line.includes(m))).records;
+        const pending = this.pending.get(id)?.values() ?? [];
+        return [...flushed, ...pending].filter((record) => wanted.has(record.bivyKind));
     }
     /** Allocate a unique synthetic coalescing key (for id-less records). */
     syntheticKey(id) {
@@ -681,9 +730,16 @@ export class EventLog {
         const lines = [...batch.values()];
         try {
             fs.mkdirSync(this.dir, { recursive: true });
-            fs.appendFileSync(this.pathFor(id), this.redact(lines.map((e) => JSON.stringify(e)).join("\n") + "\n"));
-            const disk = this.load(id);
-            disk.push(...lines);
+            const body = this.redact(lines.map((e) => JSON.stringify(e)).join("\n") + "\n");
+            fs.appendFileSync(this.pathFor(id), body);
+            // Extend the cached copy only if it is still cached: an evicted session re-reads
+            // the file (which now holds these lines) on next use, so loading here would
+            // double-count them.
+            const cached = this.disk.get(id);
+            if (cached) {
+                cached.push(...lines);
+                this.cache(id, cached, (this.diskBytes.get(id) ?? 0) + body.length);
+            }
             batch.clear();
             this.lastFlush.set(id, Date.now());
         }
@@ -708,10 +764,10 @@ export class EventLog {
         }
         this.pending.delete(id);
         this.baseKeys.delete(id);
-        this.disk.set(id, copy);
+        const body = copy.length ? copy.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
+        this.cache(id, copy, body.length);
         try {
             fs.mkdirSync(this.dir, { recursive: true });
-            const body = copy.length ? copy.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
             fs.writeFileSync(this.pathFor(id), this.redact(body));
             this.lastFlush.set(id, Date.now());
         }
@@ -726,7 +782,7 @@ export class EventLog {
             clearTimeout(timer);
             this.timers.delete(id);
         }
-        this.disk.delete(id);
+        this.uncache(id);
         this.pending.delete(id);
         this.lastFlush.delete(id);
         this.counters.delete(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.17.2-staging.4",
+  "version": "0.17.2-staging.5",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",