auxilo-mcp 0.9.2 → 0.9.4

package/scripts/sources/roo-code.js

@@ -0,0 +1,35 @@
+/**
+ * scripts/sources/roo-code.js — Roo Code (VS Code extension) Transcript Source (UC-3)
+ *
+ * Roo Code is a maintained fork of Cline and preserves its storage layout:
+ *
+ *   <vscode-user-dir>/globalStorage/<publisher>/tasks/<taskId>/
+ *     api_conversation_history.json
+ *
+ * Publisher dirs probed (the extension id changed across releases):
+ *   rooveterinaryinc.roo-cline   (original "Roo Cline" id, still used)
+ *   rooveterinaryinc.roo-code    (post-rename id)
+ *
+ * Everything else — discovery, the Anthropic-messages format probe,
+ * normalization, fail-silent refusal — is inherited from ClineSource.
+ *
+ * NOTE (2026-07-19): like cline.js, built from the documented fork layout;
+ * no Roo Code installation existed on the build machine to verify against.
+ * Strict probe + fail-silent (UC §5). Publicly labeled best-effort (UC-3).
+ *
+ * @module sources/roo-code
+ */
+
+'use strict';
+
+const { ClineSource } = require('./cline');
+
+class RooCodeSource extends ClineSource {
+  static id = 'roo-code';
+  static displayName = 'Roo Code (VS Code)';
+  static version = '1.0.0';
+
+  static publisherDirs = ['rooveterinaryinc.roo-cline', 'rooveterinaryinc.roo-code'];
+}
+
+module.exports = { RooCodeSource };

package/scripts/sources/source.interface.js

@@ -13,6 +13,50 @@
 
 'use strict';
 
+const fs = require('fs');
+
+// ─── Session read-size cap (Wave 5C N1) ─────────────────────────────────────
+//
+// discoverSessions() returns `bytes` per the contract above, but nothing ever
+// enforced a ceiling: every adapter's readSession() did an unbounded
+// fs.readFileSync (54MB observed in the wild; a multi-GB transcript OOMs a
+// constrained sweeper node) — all to feed a pipeline that truncates to 30k
+// chars anyway (runner.js MAX_CHARS).
+//
+// Why 64MB: the ceiling's job is OOM-protection, not thrift. 54MB was proven
+// in the wild AND extracted successfully — a cap below that silently regresses
+// real coverage (the exact silent-loss class Wave 5C closes). 64MB = proven
+// max + ~18% headroom; worst-case read peaks at low-hundreds-MB RSS
+// (survivable on a 512MB node) while multi-GB is structurally refused.
+// Constrained sweepers tighten via AUXILO_MAX_SESSION_BYTES.
+
+const DEFAULT_MAX_SESSION_BYTES = 64 * 1024 * 1024;
+
+/**
+ * Resolve the effective cap. Env override AUXILO_MAX_SESSION_BYTES must be a
+ * positive integer; anything else (absent, garbage, zero, negative) falls back
+ * to the default. Read at CALL time, not module load, so sweepers and tests
+ * can tune per-invocation.
+ */
+function resolveMaxSessionBytes(env = process.env) {
+  const raw = env.AUXILO_MAX_SESSION_BYTES;
+  if (raw === undefined || raw === null || raw === '') return DEFAULT_MAX_SESSION_BYTES;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n <= 0) return DEFAULT_MAX_SESSION_BYTES;
+  return n;
+}
+
+/** Thrown by readSessionCapped BEFORE any read when a session exceeds the cap. */
+class SessionTooLargeError extends Error {
+  constructor(sessionRef, bytes, maxBytes) {
+    super(`Session ${sessionRef && sessionRef.sessionId ? sessionRef.sessionId : '(unknown)'} is ${bytes} bytes — exceeds the ${maxBytes}-byte cap (AUXILO_MAX_SESSION_BYTES)`);
+    this.name = 'SessionTooLargeError';
+    this.code = 'SESSION_TOO_LARGE';
+    this.bytes = bytes;
+    this.maxBytes = maxBytes;
+  }
+}
+
 /**
  * Abstract base class for transcript source adapters.
  *
@@ -67,6 +111,40 @@ class TranscriptSource {
     throw new Error('TranscriptSource.readSession() must be implemented by subclass');
   }
 
+  /**
+   * Size-capped session read — the ONLY entry point the runner uses (N1).
+   *
+   * CONCRETE on the base class so every adapter (including the generic-jsonl
+   * fallback and any future self-registered UC-3 adapter) inherits the cap
+   * through the shared path — no per-adapter copies. Size resolution: a fresh
+   * fs.statSync of sessionRef.path when the file stats (authoritative, costs
+   * nothing), else the discoverSessions-supplied sessionRef.bytes. Over-cap
+   * throws SessionTooLargeError BEFORE any byte is read; callers treat
+   * code === 'SESSION_TOO_LARGE' as a counted skip, never a failure.
+   *
+   * Subclasses must NOT override this — override readSession() only.
+   *
+   * @param {object} sessionRef - A session reference from discoverSessions()
+   * @returns {Promise<{transcript: string, metadata: object}>}
+   * @throws {SessionTooLargeError} when the session exceeds the cap
+   */
+  async readSessionCapped(sessionRef) {
+    const maxBytes = resolveMaxSessionBytes();
+    let bytes = null;
+    if (sessionRef && sessionRef.path) {
+      try { bytes = fs.statSync(sessionRef.path).size; } catch { /* fall through */ }
+    }
+    if (bytes === null && sessionRef && Number.isFinite(sessionRef.bytes)) {
+      bytes = sessionRef.bytes;
+    }
+    // Gate-A 5C F1: unknown size fails CLOSED — a future adapter without byte
+    // metadata must not silently reopen the unbounded-read OOM class this cap exists for.
+    if (bytes === null || bytes > maxBytes) {
+      throw new SessionTooLargeError(sessionRef, bytes === null ? -1 : bytes, maxBytes);
+    }
+    return this.readSession(sessionRef);
+  }
+
   /**
    * Register a callback for session-end events (live hook mode).
    *
@@ -82,4 +160,9 @@ class TranscriptSource {
   }
 }
 
-module.exports = { TranscriptSource };
+module.exports = {
+  TranscriptSource,
+  SessionTooLargeError,
+  DEFAULT_MAX_SESSION_BYTES,
+  resolveMaxSessionBytes,
+};