@runtimescope/collector 0.7.1 → 0.8.0

package/dist/{chunk-VZSMLTUQ.js → chunk-BKRGXAJB.js}

@@ -233,6 +233,17 @@ var EventStore = class {
       return true;
     });
   }
+  getUIInteractions(filter = {}) {
+    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
+    return this.buffer.query((e) => {
+      if (e.eventType !== "ui") return false;
+      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
+      const ue = e;
+      if (ue.timestamp < since) return false;
+      if (filter.action && ue.action !== filter.action) return false;
+      return true;
+    });
+  }
   // ============================================================
   // Recon event queries — returns the most recent event of each type
   // ============================================================
@@ -296,41 +307,94 @@ var EventStore = class {
 };
 
 // src/sqlite-store.ts
-import Database from "better-sqlite3";
-var SqliteStore = class {
+import { renameSync, existsSync } from "fs";
+import { createRequire } from "module";
+var DatabaseConstructor;
+function getDatabase() {
+  if (!DatabaseConstructor) {
+    const require2 = createRequire(import.meta.url);
+    DatabaseConstructor = require2("better-sqlite3");
+  }
+  return DatabaseConstructor;
+}
+var SqliteStore = class _SqliteStore {
   db;
   writeBuffer = [];
   flushTimer = null;
   batchSize;
+  dbPath;
+  static MAX_SNAPSHOTS_PER_SESSION = 50;
   insertEventStmt;
   insertSessionStmt;
   updateSessionDisconnectedStmt;
   constructor(options) {
-    this.db = new Database(options.dbPath);
+    this.dbPath = options.dbPath;
     this.batchSize = options.batchSize ?? 50;
-    if (options.walMode !== false) {
-      this.db.pragma("journal_mode = WAL");
+    this.db = this.openDatabase(options);
+    const flushInterval = options.flushIntervalMs ?? 100;
+    this.flushTimer = setInterval(() => this.flush(), flushInterval);
+  }
+  openDatabase(options) {
+    const Db = getDatabase();
+    try {
+      const db = new Db(options.dbPath);
+      if (options.walMode !== false) {
+        db.pragma("journal_mode = WAL");
+      }
+      db.pragma("synchronous = NORMAL");
+      const check = db.pragma("integrity_check");
+      if (check[0]?.integrity_check !== "ok") {
+        throw new Error("Integrity check failed");
+      }
+      this.createSchema(db);
+      this.prepareStatements(db);
+      return db;
+    } catch (err) {
+      console.error(
+        `[RuntimeScope] SQLite database corrupt or unreadable (${err.message}), recreating...`
+      );
+      try {
+        if (existsSync(options.dbPath)) {
+          const backupPath = `${options.dbPath}.corrupt.${Date.now()}`;
+          renameSync(options.dbPath, backupPath);
+          console.error(`[RuntimeScope] Renamed corrupt DB to ${backupPath}`);
+        }
+        for (const suffix of ["-wal", "-shm"]) {
+          const p = options.dbPath + suffix;
+          if (existsSync(p)) {
+            renameSync(p, `${p}.corrupt.${Date.now()}`);
+          }
+        }
+      } catch {
+      }
+      const db = new Db(options.dbPath);
+      if (options.walMode !== false) {
+        db.pragma("journal_mode = WAL");
+      }
+      db.pragma("synchronous = NORMAL");
+      this.createSchema(db);
+      this.prepareStatements(db);
+      return db;
     }
-    this.db.pragma("synchronous = NORMAL");
-    this.createSchema();
-    this.insertEventStmt = this.db.prepare(`
+  }
+  prepareStatements(db) {
+    this.insertEventStmt = db.prepare(`
       INSERT INTO events (event_id, session_id, project, event_type, timestamp, data)
       VALUES (?, ?, ?, ?, ?, ?)
     `);
-    this.insertSessionStmt = this.db.prepare(`
+    this.insertSessionStmt = db.prepare(`
       INSERT OR REPLACE INTO sessions (
         session_id, project, app_name, connected_at, sdk_version,
         event_count, is_connected, build_meta
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
     `);
-    this.updateSessionDisconnectedStmt = this.db.prepare(`
+    this.updateSessionDisconnectedStmt = db.prepare(`
       UPDATE sessions SET is_connected = 0, disconnected_at = ? WHERE session_id = ?
     `);
-    const flushInterval = options.flushIntervalMs ?? 100;
-    this.flushTimer = setInterval(() => this.flush(), flushInterval);
   }
-  createSchema() {
-    this.db.exec(`
+  createSchema(db) {
+    const d = db ?? this.db;
+    d.exec(`
       CREATE TABLE IF NOT EXISTS events (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         event_id TEXT NOT NULL UNIQUE,
@@ -374,7 +438,7 @@ var SqliteStore = class {
       CREATE INDEX IF NOT EXISTS idx_snapshots_session ON session_snapshots(session_id);
       CREATE INDEX IF NOT EXISTS idx_snapshots_project ON session_snapshots(project, created_at);
     `);
-    this.migrateSessionMetrics();
+    this.migrateSessionMetrics(d);
   }
   // --- Write Operations ---
   addEvent(event, project) {
@@ -427,6 +491,21 @@ var SqliteStore = class {
       INSERT INTO session_snapshots (session_id, project, label, metrics, created_at)
       VALUES (?, ?, ?, ?, ?)
     `).run(sessionId, project, label ?? null, JSON.stringify(metrics), Date.now());
+    this.pruneSnapshots(sessionId);
+  }
+  /** Remove oldest snapshots for a session beyond the retention limit */
+  pruneSnapshots(sessionId) {
+    const count = this.db.prepare("SELECT COUNT(*) as cnt FROM session_snapshots WHERE session_id = ?").get(sessionId).cnt;
+    if (count > _SqliteStore.MAX_SNAPSHOTS_PER_SESSION) {
+      this.db.prepare(`
+        DELETE FROM session_snapshots WHERE id IN (
+          SELECT id FROM session_snapshots
+          WHERE session_id = ?
+          ORDER BY created_at ASC
+          LIMIT ?
+        )
+      `).run(sessionId, count - _SqliteStore.MAX_SNAPSHOTS_PER_SESSION);
+    }
   }
   // --- Read Operations ---
   getEvents(filter) {
@@ -552,17 +631,17 @@ var SqliteStore = class {
     return rows.map((row) => JSON.parse(row.data));
   }
   // --- Migration ---
-  migrateSessionMetrics() {
-    const hasOldTable = this.db.prepare(
+  migrateSessionMetrics(db) {
+    const hasOldTable = db.prepare(
       "SELECT name FROM sqlite_master WHERE type='table' AND name='session_metrics'"
     ).get();
     if (hasOldTable) {
-      this.db.exec(`
+      db.exec(`
         INSERT OR IGNORE INTO session_snapshots (session_id, project, label, metrics, created_at)
         SELECT session_id, project, 'auto-disconnect', metrics, created_at
         FROM session_metrics
       `);
-      this.db.exec("DROP TABLE session_metrics");
+      db.exec("DROP TABLE session_metrics");
     }
   }
   // --- Maintenance ---
@@ -584,14 +663,14 @@ var SqliteStore = class {
 };
 
 // src/sqlite-check.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 var _checked = false;
 var _available = false;
 function isSqliteAvailable() {
   if (_checked) return _available;
   _checked = true;
   try {
-    const require2 = createRequire(import.meta.url);
+    const require2 = createRequire2(import.meta.url);
     require2("better-sqlite3");
     _available = true;
   } catch {
@@ -727,6 +806,7 @@ var CollectorServer = class {
   connectCallbacks = [];
   disconnectCallbacks = [];
   pruneTimer = null;
+  heartbeatTimer = null;
   tlsConfig = null;
   constructor(options = {}) {
     this.store = new EventStore(options.bufferSize ?? 1e4);
@@ -786,6 +866,8 @@ var CollectorServer = class {
         httpsServer.on("listening", () => {
           this.wss = wss;
           this.setupConnectionHandler(wss);
+          this.setupPersistentErrorHandler(wss);
+          this.startHeartbeat(wss);
           console.error(`[RuntimeScope] Collector listening on wss://${host}:${port}`);
           resolve2();
         });
@@ -799,6 +881,8 @@ var CollectorServer = class {
         wss.on("listening", () => {
           this.wss = wss;
           this.setupConnectionHandler(wss);
+          this.setupPersistentErrorHandler(wss);
+          this.startHeartbeat(wss);
           console.error(`[RuntimeScope] Collector listening on ws://${host}:${port}`);
           resolve2();
         });
@@ -844,8 +928,33 @@ var CollectorServer = class {
     }
     return sqliteStore;
   }
+  /** Catch runtime errors on the WSS so an unhandled error doesn't crash the process */
+  setupPersistentErrorHandler(wss) {
+    wss.on("error", (err) => {
+      console.error("[RuntimeScope] WebSocket server runtime error:", err.message);
+    });
+  }
+  /** Ping all connected clients every 15s — terminate those that don't respond */
+  startHeartbeat(wss) {
+    this.heartbeatTimer = setInterval(() => {
+      for (const ws of wss.clients) {
+        const ext = ws;
+        if (ext._rsAlive === false) {
+          ws.terminate();
+          continue;
+        }
+        ext._rsAlive = false;
+        ws.ping();
+      }
+    }, 15e3);
+  }
   setupConnectionHandler(wss) {
     wss.on("connection", (ws) => {
+      const ext = ws;
+      ext._rsAlive = true;
+      ws.on("pong", () => {
+        ext._rsAlive = true;
+      });
       if (this.authManager?.isEnabled()) {
         this.pendingHandshakes.add(ws);
         const authTimeout = setTimeout(() => {
@@ -1040,10 +1149,27 @@ var CollectorServer = class {
     });
   }
   stop() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
     if (this.pruneTimer) {
       clearInterval(this.pruneTimer);
       this.pruneTimer = null;
     }
+    if (this.wss) {
+      for (const client of this.wss.clients) {
+        if (client.readyState === 1) {
+          try {
+            client.send(JSON.stringify({
+              type: "__server_restart",
+              timestamp: Date.now()
+            }));
+          } catch {
+          }
+        }
+      }
+    }
     for (const [name, sqliteStore] of this.sqliteStores) {
       try {
         sqliteStore.close();
@@ -1061,7 +1187,7 @@ var CollectorServer = class {
 };
 
 // src/project-manager.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync, existsSync, readdirSync } from "fs";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, readdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 var DEFAULT_GLOBAL_CONFIG = {
@@ -1093,7 +1219,7 @@ var ProjectManager = class {
     this.mkdirp(this.baseDir);
     this.mkdirp(join(this.baseDir, "projects"));
     const configPath = join(this.baseDir, "config.json");
-    if (!existsSync(configPath)) {
+    if (!existsSync2(configPath)) {
       this.writeJson(configPath, DEFAULT_GLOBAL_CONFIG);
     }
   }
@@ -1101,7 +1227,7 @@ var ProjectManager = class {
     const projectDir = this.getProjectDir(projectName);
     this.mkdirp(projectDir);
     const configPath = join(projectDir, "config.json");
-    if (!existsSync(configPath)) {
+    if (!existsSync2(configPath)) {
       const config = {
         name: projectName,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1115,7 +1241,7 @@ var ProjectManager = class {
   // --- Config ---
   getGlobalConfig() {
     const configPath = join(this.baseDir, "config.json");
-    if (!existsSync(configPath)) return { ...DEFAULT_GLOBAL_CONFIG };
+    if (!existsSync2(configPath)) return { ...DEFAULT_GLOBAL_CONFIG };
     return { ...DEFAULT_GLOBAL_CONFIG, ...this.readJson(configPath) };
   }
   saveGlobalConfig(config) {
@@ -1123,7 +1249,7 @@ var ProjectManager = class {
   }
   getProjectConfig(projectName) {
     const configPath = join(this.getProjectDir(projectName), "config.json");
-    if (!existsSync(configPath)) return null;
+    if (!existsSync2(configPath)) return null;
     return this.readJson(configPath);
   }
   saveProjectConfig(projectName, config) {
@@ -1131,12 +1257,12 @@ var ProjectManager = class {
   }
   getInfrastructureConfig(projectName) {
     const jsonPath = join(this.getProjectDir(projectName), "infrastructure.json");
-    if (existsSync(jsonPath)) {
+    if (existsSync2(jsonPath)) {
       const config = this.readJson(jsonPath);
       return this.resolveConfigEnvVars(config);
     }
     const yamlPath = join(this.getProjectDir(projectName), "infrastructure.yaml");
-    if (existsSync(yamlPath)) {
+    if (existsSync2(yamlPath)) {
       try {
         const content = readFileSync2(yamlPath, "utf-8");
         return this.resolveConfigEnvVars(this.parseSimpleYaml(content));
@@ -1148,17 +1274,17 @@ var ProjectManager = class {
   }
   getClaudeInstructions(projectName) {
     const filePath = join(this.getProjectDir(projectName), "claude-instructions.md");
-    if (!existsSync(filePath)) return null;
+    if (!existsSync2(filePath)) return null;
     return readFileSync2(filePath, "utf-8");
   }
   // --- Discovery ---
   listProjects() {
     const projectsDir = join(this.baseDir, "projects");
-    if (!existsSync(projectsDir)) return [];
+    if (!existsSync2(projectsDir)) return [];
     return readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   }
   projectExists(projectName) {
-    return existsSync(this.getProjectDir(projectName));
+    return existsSync2(this.getProjectDir(projectName));
   }
   // --- Environment variable resolution ---
   resolveEnvVars(value) {
@@ -1168,7 +1294,7 @@ var ProjectManager = class {
   }
   // --- Private helpers ---
   mkdirp(dir) {
-    if (!existsSync(dir)) {
+    if (!existsSync2(dir)) {
       mkdirSync(dir, { recursive: true });
     }
   }
@@ -1508,14 +1634,14 @@ var SessionManager = class {
 // src/http-server.ts
 import { createServer } from "http";
 import { createServer as createHttpsServer2 } from "https";
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
 import { resolve, dirname } from "path";
 import { fileURLToPath } from "url";
 import { WebSocketServer as WebSocketServer2 } from "ws";
 
 // src/pm/pm-routes.ts
 import { readdir, readFile, writeFile, unlink, mkdir } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 import { spawn, execSync, execFileSync } from "child_process";
@@ -2450,7 +2576,7 @@ function parseGitStatus(porcelain) {
 }
 async function readRuleFile(filePath) {
   try {
-    if (existsSync2(filePath)) {
+    if (existsSync3(filePath)) {
       const content = await readFile(filePath, "utf-8");
       return { path: filePath, content, exists: true };
     }
@@ -2653,6 +2779,15 @@ var HttpServer = class {
       });
       this.json(res, { data: events, count: events.length });
     });
+    this.routes.set("GET /api/events/ui", (_req, res, params) => {
+      const action = params.get("action");
+      const events = this.store.getUIInteractions({
+        action: action ?? void 0,
+        sinceSeconds: numParam(params, "since_seconds"),
+        sessionId: params.get("session_id") ?? void 0
+      });
+      this.json(res, { data: events, count: events.length });
+    });
     this.routes.set("DELETE /api/events", (_req, res) => {
       const result = this.store.clear();
       this.json(res, result);
@@ -2700,6 +2835,9 @@ var HttpServer = class {
         "dom_snapshot",
         "performance",
         "database",
+        "custom",
+        "navigation",
+        "ui",
         "recon_metadata",
         "recon_design_tokens",
         "recon_fonts",
@@ -2745,7 +2883,7 @@ var HttpServer = class {
       // npm installed
     ];
     for (const p of candidates) {
-      if (existsSync3(p)) {
+      if (existsSync4(p)) {
         this.sdkBundlePath = p;
         return p;
       }
@@ -3018,11 +3156,11 @@ function numParam(params, key) {
 }
 
 // src/pm/pm-store.ts
-import Database2 from "better-sqlite3";
+import Database from "better-sqlite3";
 var PmStore = class {
   db;
   constructor(options) {
-    this.db = new Database2(options.dbPath);
+    this.db = new Database(options.dbPath);
     if (options.walMode !== false) {
       this.db.pragma("journal_mode = WAL");
     }
@@ -4101,7 +4239,7 @@ async function parseSessionJsonl(jsonlPath, sessionId, projectId) {
 // src/pm/project-discovery.ts
 import { readdir as readdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
 import { join as join3, basename as basename2 } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { homedir as homedir3 } from "os";
 var LOG_PREFIX = "[RuntimeScope PM]";
 async function detectSdkInstalled(projectPath) {
@@ -4168,7 +4306,7 @@ function slugifyPath(fsPath) {
 }
 function decodeClaudeKey(key) {
   const naive = "/" + key.slice(1).replace(/-/g, "/");
-  if (existsSync4(naive)) return naive;
+  if (existsSync5(naive)) return naive;
   const parts = key.slice(1).split("-");
   return resolvePathSegments(parts);
 }
@@ -4176,16 +4314,16 @@ function resolvePathSegments(parts) {
   if (parts.length === 0) return null;
   function tryResolve(prefix, remaining) {
     if (remaining.length === 0) {
-      return existsSync4(prefix) ? prefix : null;
+      return existsSync5(prefix) ? prefix : null;
     }
     for (let count = remaining.length; count >= 1; count--) {
       const segment = remaining.slice(0, count).join("-");
       const candidate = join3(prefix, segment);
       if (count === remaining.length) {
-        if (existsSync4(candidate)) return candidate;
+        if (existsSync5(candidate)) return candidate;
       } else {
         try {
-          if (existsSync4(candidate)) {
+          if (existsSync5(candidate)) {
             const result = tryResolve(candidate, remaining.slice(count));
             if (result) return result;
           }
@@ -4679,4 +4817,4 @@ export {
   parseSessionJsonl,
   ProjectDiscovery
 };
-//# sourceMappingURL=chunk-VZSMLTUQ.js.map
+//# sourceMappingURL=chunk-BKRGXAJB.js.map