ccsniff 1.1.17 → 1.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccsniff",
-  "version": "1.1.17",
+  "version": "1.1.19",
   "description": "Watch Claude Code JSONL output files and emit structured events as a Node.js EventEmitter",
   "type": "module",
   "main": "./src/index.js",

package/src/index.js

@@ -195,7 +195,7 @@ export function watch(projectsDir) {
 export class JsonlReplayer extends JsonlWatcher {
   constructor(projectsDir = DEFAULT_DIR) { super(projectsDir); }
 
-  replay({ since = 0, files: fileFilter = null } = {}) {
+  replay({ since = 0, files: fileFilter = null, maxEvents = 0 } = {}) {
     const all = [];
     const collect = (dir, depth) => {
       if (depth > 5) return;
@@ -208,9 +208,19 @@ export class JsonlReplayer extends JsonlWatcher {
       } catch {}
     };
     if (fs.existsSync(this._dir)) collect(this._dir, 0);
-    const chosen = fileFilter ? all.filter(fileFilter) : all;
+    let chosen = fileFilter ? all.filter(fileFilter) : all;
+    // When a maxEvents budget is set, read newest files first and stop once the
+    // budget is met — so a huge projects tree never has its full backlog parsed
+    // into the heap at once (the load-time memory peak this guards against).
+    if (maxEvents > 0) {
+      chosen = chosen
+        .map(fp => { try { return { fp, m: fs.statSync(fp).mtimeMs }; } catch { return { fp, m: 0 }; } })
+        .sort((a, b) => b.m - a.m)
+        .map(x => x.fp);
+    }
     let emitted = 0;
     for (const fp of chosen) {
+      if (maxEvents > 0 && emitted >= maxEvents) break;
       const fallbackSid = path.basename(fp, '.jsonl');
       let data;
       try { data = fs.readFileSync(fp, 'utf8'); } catch { continue; }

package/src/store.js

@@ -7,13 +7,20 @@ import { buildIndex, search, snippet, tokenize } from './bm25.js';
 export const DEFAULT_PROJECTS_DIR =
   process.env.CLAUDE_PROJECTS_DIR || path.join(os.homedir(), '.claude', 'projects');
 
+// Per-event retained-text ceiling. Tool outputs (file reads, command stdout) can
+// be many KB each; held in full across tens of thousands of events they dominate
+// the in-memory footprint. A generous cap preserves search tokens and snippet
+// windows while bounding the heap. Override via CCSNIFF_MAX_TEXT.
+const MAX_TEXT = parseInt(process.env.CCSNIFF_MAX_TEXT || '', 10) || 8192;
+
 export function blockText(b) {
   if (!b) return '';
-  if (typeof b.text === 'string') return b.text;
-  if (typeof b.content === 'string') return b.content;
-  if (Array.isArray(b.content)) return b.content.map(c => c?.text || '').join('');
-  if (b.input) { try { return JSON.stringify(b.input); } catch { return ''; } }
-  return '';
+  let t = '';
+  if (typeof b.text === 'string') t = b.text;
+  else if (typeof b.content === 'string') t = b.content;
+  else if (Array.isArray(b.content)) t = b.content.map(c => c?.text || '').join('');
+  else if (b.input) { try { t = JSON.stringify(b.input); } catch { t = ''; } }
+  return t.length > MAX_TEXT ? t.slice(0, MAX_TEXT) : t;
 }
 
 export function flattenEvent(ev, idx) {
@@ -40,8 +47,16 @@ export function flattenEvent(ev, idx) {
   };
 }
 
+// Cap retained in-memory events so a long-lived server watching an active
+// ~/.claude/projects tree does not grow without bound. The live watcher appends
+// every new event for the life of the process; without a ceiling the heap climbs
+// until OOM. Oldest events are evicted in batches (front-splice is O(n), so we
+// drop a slab at once and rebuild the search index lazily on next search).
+const DEFAULT_MAX_EVENTS = parseInt(process.env.CCSNIFF_MAX_EVENTS || '', 10) || 15000;
+const EVICT_BATCH_FRACTION = 0.1;
+
 export class Store {
-  constructor(projectsDir) {
+  constructor(projectsDir, { maxEvents } = {}) {
     this.projectsDir = projectsDir || DEFAULT_PROJECTS_DIR;
     this.events = [];
     this.errors = [];
@@ -52,16 +67,47 @@ export class Store {
     this.watcher = null;
     this.sseClients = new Set();
     this.convs = new Map();
+    this.maxEvents = maxEvents || DEFAULT_MAX_EVENTS;
+  }
+
+  // Drop oldest events once the cap is exceeded. Evicting shifts array indices,
+  // so the BM25 index (which maps by position) is invalidated and rebuilt lazily.
+  trimEvents() {
+    if (this.events.length > this.maxEvents) {
+      const drop = Math.max(this.events.length - this.maxEvents, Math.floor(this.maxEvents * EVICT_BATCH_FRACTION));
+      this.events.splice(0, drop);
+      this.index = null;
+    }
+    // errors are capped independently of events (a burst of errors must not be
+    // gated behind the events ceiling).
+    if (this.errors.length > this.maxEvents) this.errors.splice(0, this.errors.length - this.maxEvents);
   }
 
   loadOnce() {
     const r = new JsonlReplayer(this.projectsDir);
     let i = 0;
     r.on('conversation_created', ev => this.convs.set(ev.conversation.id, ev.conversation));
-    r.on('streaming_progress', ev => { this.events.push(flattenEvent(ev, i++)); });
+    // Trim during replay (not only after) so the full backlog never materializes
+    // at once — that one-shot peak, not steady-state, is what spikes RSS on a
+    // large ~/.claude/projects tree. A soft headroom above maxEvents keeps the
+    // trim from running on every push.
+    const softCap = Math.floor(this.maxEvents * 1.25);
+    r.on('streaming_progress', ev => {
+      this.events.push(flattenEvent(ev, i++));
+      if (this.events.length > softCap) this.events.splice(0, this.events.length - this.maxEvents);
+    });
     r.on('streaming_error', ev => { this.errors.push({ ts: ev.timestamp, sid: ev.conversationId, error: ev.error, recoverable: ev.recoverable }); });
-    const stats = r.replay({});
+    // Bound the replay to a little above the retention cap and read newest-first,
+    // so a large projects tree never parses its entire backlog into the heap at
+    // once. The post-replay trim then lands exactly on maxEvents.
+    const stats = r.replay({ maxEvents: Math.floor(this.maxEvents * 1.2) });
     this.fileCount = stats.files;
+    // Newest-first file read can leave events out of chronological order; restore
+    // it (downstream sessions/search/snippet logic assumes ascending ts) and
+    // renumber the positional index the BM25 index keys on.
+    this.events.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    this.events.forEach((e, k) => { e.i = k; });
+    this.trimEvents();
     this.rebuildIndex();
     return stats;
   }
@@ -82,6 +128,7 @@ export class Store {
       const fl = flattenEvent(ev, this.events.length);
       this.events.push(fl);
       this.broadcast('event', { sid: fl.sid, payload: fl });
+      this.trimEvents();
     });
     this.watcher.on('streaming_error', ev => {
       const e = { ts: ev.timestamp, sid: ev.conversationId, error: ev.error, recoverable: ev.recoverable };