@runtimescope/collector 0.6.2 → 0.7.0

package/dist/index.js

@@ -1,952 +1,25 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/server.ts
-import { createServer as createHttpsServer } from "https";
-import { WebSocketServer } from "ws";
-
-// src/ring-buffer.ts
-var RingBuffer = class {
-  constructor(capacity) {
-    this.capacity = capacity;
-    this.buffer = new Array(capacity);
-  }
-  buffer;
-  head = 0;
-  _count = 0;
-  get count() {
-    return this._count;
-  }
-  push(item) {
-    this.buffer[this.head] = item;
-    this.head = (this.head + 1) % this.capacity;
-    if (this._count < this.capacity) this._count++;
-  }
-  /** Returns all items from oldest to newest. */
-  toArray() {
-    if (this._count === 0) return [];
-    const result = [];
-    const start = this._count < this.capacity ? 0 : this.head;
-    for (let i = 0; i < this._count; i++) {
-      const idx = (start + i) % this.capacity;
-      result.push(this.buffer[idx]);
-    }
-    return result;
-  }
-  /** Returns matching items from newest to oldest (most recent first). */
-  query(predicate) {
-    if (this._count === 0) return [];
-    const result = [];
-    const start = this._count < this.capacity ? 0 : this.head;
-    for (let i = this._count - 1; i >= 0; i--) {
-      const idx = (start + i) % this.capacity;
-      const item = this.buffer[idx];
-      if (predicate(item)) result.push(item);
-    }
-    return result;
-  }
-  clear() {
-    this.buffer = new Array(this.capacity);
-    this.head = 0;
-    this._count = 0;
-  }
-};
-
-// src/store.ts
-var EventStore = class {
-  buffer;
-  sessions = /* @__PURE__ */ new Map();
-  sqliteStore = null;
-  currentProject = null;
-  onEventCallbacks = [];
-  redactor = null;
-  constructor(capacity = 1e4) {
-    this.buffer = new RingBuffer(capacity);
-  }
-  setRedactor(redactor) {
-    this.redactor = redactor;
-  }
-  get eventCount() {
-    return this.buffer.count;
-  }
-  setSqliteStore(store, project) {
-    this.sqliteStore = store;
-    this.currentProject = project;
-  }
-  onEvent(callback) {
-    this.onEventCallbacks.push(callback);
-  }
-  removeEventListener(callback) {
-    const idx = this.onEventCallbacks.indexOf(callback);
-    if (idx !== -1) this.onEventCallbacks.splice(idx, 1);
-  }
-  addEvent(event) {
-    if (this.redactor?.isEnabled()) {
-      event = this.redactor.redactEvent(event);
-    }
-    this.buffer.push(event);
-    if (event.eventType === "session") {
-      const se = event;
-      this.sessions.set(se.sessionId, {
-        sessionId: se.sessionId,
-        appName: se.appName,
-        connectedAt: se.connectedAt,
-        sdkVersion: se.sdkVersion,
-        eventCount: 0,
-        isConnected: true
-      });
-    }
-    const session = this.sessions.get(event.sessionId);
-    if (session) session.eventCount++;
-    if (this.sqliteStore && this.currentProject) {
-      this.sqliteStore.addEvent(event, this.currentProject);
-    }
-    for (const cb of this.onEventCallbacks) {
-      try {
-        cb(event);
-      } catch {
-      }
-    }
-  }
-  getNetworkRequests(filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    return this.buffer.query((e) => {
-      if (e.eventType !== "network") return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      const ne = e;
-      if (ne.timestamp < since) return false;
-      if (filter.urlPattern && !ne.url.includes(filter.urlPattern)) return false;
-      if (filter.status !== void 0 && ne.status !== filter.status) return false;
-      if (filter.method && ne.method.toUpperCase() !== filter.method.toUpperCase())
-        return false;
-      return true;
-    });
-  }
-  getConsoleMessages(filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    return this.buffer.query((e) => {
-      if (e.eventType !== "console") return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      const ce = e;
-      if (ce.timestamp < since) return false;
-      if (filter.level && ce.level !== filter.level) return false;
-      if (filter.search && !ce.message.toLowerCase().includes(filter.search.toLowerCase()))
-        return false;
-      return true;
-    });
-  }
-  getSessionInfo() {
-    return Array.from(this.sessions.values());
-  }
-  markDisconnected(sessionId) {
-    const s = this.sessions.get(sessionId);
-    if (s) s.isConnected = false;
-  }
-  getEventTimeline(filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    const typeSet = filter.eventTypes ? new Set(filter.eventTypes) : null;
-    return this.buffer.toArray().filter((e) => {
-      if (e.timestamp < since) return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      if (typeSet && !typeSet.has(e.eventType)) return false;
-      return true;
-    });
-  }
-  getAllEvents(sinceSeconds, sessionId) {
-    const since = sinceSeconds ? Date.now() - sinceSeconds * 1e3 : 0;
-    return this.buffer.toArray().filter((e) => {
-      if (e.timestamp < since) return false;
-      if (sessionId && e.sessionId !== sessionId) return false;
-      return true;
-    });
-  }
-  getSessionIdsForProject(appName) {
-    return Array.from(this.sessions.values()).filter((s) => s.appName === appName).map((s) => s.sessionId);
-  }
-  getStateEvents(filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    return this.buffer.query((e) => {
-      if (e.eventType !== "state") return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      const se = e;
-      if (se.timestamp < since) return false;
-      if (filter.storeId && se.storeId !== filter.storeId) return false;
-      return true;
-    });
-  }
-  getRenderEvents(filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    return this.buffer.query((e) => {
-      if (e.eventType !== "render") return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      const re = e;
-      if (re.timestamp < since) return false;
-      if (filter.componentName) {
-        const hasMatch = re.profiles.some(
-          (p) => p.componentName.toLowerCase().includes(filter.componentName.toLowerCase())
-        );
-        if (!hasMatch) return false;
-      }
-      return true;
-    });
-  }
-  getPerformanceMetrics(filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    return this.buffer.query((e) => {
-      if (e.eventType !== "performance") return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      const pe = e;
-      if (pe.timestamp < since) return false;
-      if (filter.metricName && pe.metricName !== filter.metricName) return false;
-      return true;
-    });
-  }
-  getDatabaseEvents(filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    return this.buffer.query((e) => {
-      if (e.eventType !== "database") return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      const de = e;
-      if (de.timestamp < since) return false;
-      if (filter.table) {
-        const hasTable = de.tablesAccessed.some(
-          (t) => t.toLowerCase() === filter.table.toLowerCase()
-        );
-        if (!hasTable) return false;
-      }
-      if (filter.minDurationMs !== void 0 && de.duration < filter.minDurationMs) return false;
-      if (filter.search && !de.query.toLowerCase().includes(filter.search.toLowerCase()))
-        return false;
-      if (filter.operation && de.operation !== filter.operation) return false;
-      if (filter.source && de.source !== filter.source) return false;
-      return true;
-    });
-  }
-  // ============================================================
-  // Recon event queries — returns the most recent event of each type
-  // ============================================================
-  getLatestReconEvent(eventType, filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    const results = this.buffer.query((e) => {
-      if (e.eventType !== eventType) return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      if (e.timestamp < since) return false;
-      if (filter.url) {
-        const re = e;
-        if (re.url && !re.url.includes(filter.url)) return false;
-      }
-      return true;
-    });
-    return results[0] ?? null;
-  }
-  getReconEvents(eventType, filter = {}) {
-    const since = filter.sinceSeconds ? Date.now() - filter.sinceSeconds * 1e3 : 0;
-    return this.buffer.query((e) => {
-      if (e.eventType !== eventType) return false;
-      if (filter.sessionId && e.sessionId !== filter.sessionId) return false;
-      if (e.timestamp < since) return false;
-      if (filter.url) {
-        const re = e;
-        if (re.url && !re.url.includes(filter.url)) return false;
-      }
-      return true;
-    });
-  }
-  getReconMetadata(filter = {}) {
-    return this.getLatestReconEvent("recon_metadata", filter);
-  }
-  getReconDesignTokens(filter = {}) {
-    return this.getLatestReconEvent("recon_design_tokens", filter);
-  }
-  getReconFonts(filter = {}) {
-    return this.getLatestReconEvent("recon_fonts", filter);
-  }
-  getReconLayoutTree(filter = {}) {
-    return this.getLatestReconEvent("recon_layout_tree", filter);
-  }
-  getReconAccessibility(filter = {}) {
-    return this.getLatestReconEvent("recon_accessibility", filter);
-  }
-  getReconComputedStyles(filter = {}) {
-    return this.getReconEvents("recon_computed_styles", filter);
-  }
-  getReconElementSnapshots(filter = {}) {
-    return this.getReconEvents("recon_element_snapshot", filter);
-  }
-  getReconAssetInventory(filter = {}) {
-    return this.getLatestReconEvent("recon_asset_inventory", filter);
-  }
-  clear() {
-    const count = this.buffer.count;
-    this.buffer.clear();
-    this.sessions.clear();
-    return { clearedCount: count };
-  }
-};
-
-// src/sqlite-store.ts
-import Database from "better-sqlite3";
-var SqliteStore = class {
-  db;
-  writeBuffer = [];
-  flushTimer = null;
-  batchSize;
-  insertEventStmt;
-  insertSessionStmt;
-  updateSessionDisconnectedStmt;
-  constructor(options) {
-    this.db = new Database(options.dbPath);
-    this.batchSize = options.batchSize ?? 50;
-    if (options.walMode !== false) {
-      this.db.pragma("journal_mode = WAL");
-    }
-    this.db.pragma("synchronous = NORMAL");
-    this.createSchema();
-    this.insertEventStmt = this.db.prepare(`
-      INSERT INTO events (event_id, session_id, project, event_type, timestamp, data)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-    this.insertSessionStmt = this.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(`
-      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(`
-      CREATE TABLE IF NOT EXISTS events (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        event_id TEXT NOT NULL UNIQUE,
-        session_id TEXT NOT NULL,
-        project TEXT NOT NULL,
-        event_type TEXT NOT NULL,
-        timestamp INTEGER NOT NULL,
-        data TEXT NOT NULL
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id);
-      CREATE INDEX IF NOT EXISTS idx_events_type ON events(event_type);
-      CREATE INDEX IF NOT EXISTS idx_events_timestamp ON events(timestamp);
-      CREATE INDEX IF NOT EXISTS idx_events_type_timestamp ON events(event_type, timestamp);
-      CREATE INDEX IF NOT EXISTS idx_events_project ON events(project);
-
-      CREATE TABLE IF NOT EXISTS sessions (
-        session_id TEXT PRIMARY KEY,
-        project TEXT NOT NULL,
-        app_name TEXT NOT NULL,
-        connected_at INTEGER NOT NULL,
-        disconnected_at INTEGER,
-        sdk_version TEXT NOT NULL,
-        event_count INTEGER DEFAULT 0,
-        is_connected INTEGER DEFAULT 1,
-        build_meta TEXT
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions(project);
-
-      CREATE TABLE IF NOT EXISTS session_metrics (
-        session_id TEXT PRIMARY KEY,
-        project TEXT NOT NULL,
-        metrics TEXT NOT NULL,
-        created_at INTEGER NOT NULL,
-        FOREIGN KEY (session_id) REFERENCES sessions(session_id)
-      );
-    `);
-  }
-  // --- Write Operations ---
-  addEvent(event, project) {
-    this.writeBuffer.push({ event, project });
-    if (this.writeBuffer.length >= this.batchSize) {
-      this.flush();
-    }
-  }
-  flush() {
-    if (this.writeBuffer.length === 0) return;
-    const batch = this.writeBuffer.splice(0);
-    const insertMany = this.db.transaction(() => {
-      for (const { event, project } of batch) {
-        try {
-          this.insertEventStmt.run(
-            event.eventId,
-            event.sessionId,
-            project,
-            event.eventType,
-            event.timestamp,
-            JSON.stringify(event)
-          );
-        } catch {
-        }
-      }
-    });
-    try {
-      insertMany();
-    } catch (err) {
-      console.error("[RuntimeScope] SQLite flush error:", err.message);
-    }
-  }
-  saveSession(info) {
-    this.insertSessionStmt.run(
-      info.sessionId,
-      info.project,
-      info.appName,
-      info.connectedAt,
-      info.sdkVersion,
-      info.eventCount,
-      info.isConnected ? 1 : 0,
-      info.buildMeta ? JSON.stringify(info.buildMeta) : null
-    );
-  }
-  updateSessionDisconnected(sessionId, disconnectedAt) {
-    this.updateSessionDisconnectedStmt.run(disconnectedAt, sessionId);
-  }
-  saveSessionMetrics(sessionId, project, metrics) {
-    this.db.prepare(`
-      INSERT OR REPLACE INTO session_metrics (session_id, project, metrics, created_at)
-      VALUES (?, ?, ?, ?)
-    `).run(sessionId, project, JSON.stringify(metrics), Date.now());
-  }
-  // --- Read Operations ---
-  getEvents(filter) {
-    const conditions = [];
-    const params = [];
-    if (filter.project) {
-      conditions.push("project = ?");
-      params.push(filter.project);
-    }
-    if (filter.sessionId) {
-      conditions.push("session_id = ?");
-      params.push(filter.sessionId);
-    }
-    if (filter.eventTypes && filter.eventTypes.length > 0) {
-      const placeholders = filter.eventTypes.map(() => "?").join(", ");
-      conditions.push(`event_type IN (${placeholders})`);
-      params.push(...filter.eventTypes);
-    }
-    if (filter.since) {
-      conditions.push("timestamp >= ?");
-      params.push(filter.since);
-    }
-    if (filter.until) {
-      conditions.push("timestamp <= ?");
-      params.push(filter.until);
-    }
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const limit = filter.limit ? `LIMIT ${filter.limit}` : "LIMIT 1000";
-    const offset = filter.offset ? `OFFSET ${filter.offset}` : "";
-    const rows = this.db.prepare(`SELECT data FROM events ${where} ORDER BY timestamp ASC ${limit} ${offset}`).all(...params);
-    return rows.map((row) => JSON.parse(row.data));
-  }
-  getEventCount(filter) {
-    const conditions = [];
-    const params = [];
-    if (filter.project) {
-      conditions.push("project = ?");
-      params.push(filter.project);
-    }
-    if (filter.sessionId) {
-      conditions.push("session_id = ?");
-      params.push(filter.sessionId);
-    }
-    if (filter.eventTypes && filter.eventTypes.length > 0) {
-      const placeholders = filter.eventTypes.map(() => "?").join(", ");
-      conditions.push(`event_type IN (${placeholders})`);
-      params.push(...filter.eventTypes);
-    }
-    if (filter.since) {
-      conditions.push("timestamp >= ?");
-      params.push(filter.since);
-    }
-    if (filter.until) {
-      conditions.push("timestamp <= ?");
-      params.push(filter.until);
-    }
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const row = this.db.prepare(`SELECT COUNT(*) as count FROM events ${where}`).get(...params);
-    return row.count;
-  }
-  getSessions(project, limit = 50) {
-    const rows = this.db.prepare(`
-        SELECT session_id, project, app_name, connected_at, disconnected_at,
-               sdk_version, event_count, is_connected, build_meta
-        FROM sessions
-        WHERE project = ?
-        ORDER BY connected_at DESC
-        LIMIT ?
-      `).all(project, limit);
-    return rows.map((row) => ({
-      sessionId: row.session_id,
-      project: row.project,
-      appName: row.app_name,
-      connectedAt: row.connected_at,
-      disconnectedAt: row.disconnected_at ?? void 0,
-      sdkVersion: row.sdk_version,
-      eventCount: row.event_count,
-      isConnected: row.is_connected === 1,
-      buildMeta: row.build_meta ? JSON.parse(row.build_meta) : void 0
-    }));
-  }
-  getSessionMetrics(sessionId) {
-    const row = this.db.prepare("SELECT metrics FROM session_metrics WHERE session_id = ?").get(sessionId);
-    return row ? JSON.parse(row.metrics) : null;
-  }
-  getEventsByType(project, eventType, sinceMs) {
-    const conditions = ["project = ?", "event_type = ?"];
-    const params = [project, eventType];
-    if (sinceMs) {
-      conditions.push("timestamp >= ?");
-      params.push(sinceMs);
-    }
-    const where = conditions.join(" AND ");
-    const rows = this.db.prepare(`SELECT data FROM events WHERE ${where} ORDER BY timestamp ASC LIMIT 1000`).all(...params);
-    return rows.map((row) => JSON.parse(row.data));
-  }
-  // --- Maintenance ---
-  deleteOldEvents(beforeTimestamp) {
-    const result = this.db.prepare("DELETE FROM events WHERE timestamp < ?").run(beforeTimestamp);
-    return result.changes;
-  }
-  vacuum() {
-    this.db.exec("VACUUM");
-  }
-  close() {
-    if (this.flushTimer) {
-      clearInterval(this.flushTimer);
-      this.flushTimer = null;
-    }
-    this.flush();
-    this.db.close();
-  }
-};
-
-// src/rate-limiter.ts
-var SessionRateLimiter = class {
-  windows = /* @__PURE__ */ new Map();
-  maxPerSecond;
-  maxPerMinute;
-  _droppedTotal = 0;
-  constructor(config = {}) {
-    this.maxPerSecond = config.maxEventsPerSecond ?? Infinity;
-    this.maxPerMinute = config.maxEventsPerMinute ?? Infinity;
-  }
-  get droppedTotal() {
-    return this._droppedTotal;
-  }
-  isEnabled() {
-    return this.maxPerSecond !== Infinity || this.maxPerMinute !== Infinity;
-  }
-  /** Returns true if the event should be accepted, false if rate-limited. */
-  allow(sessionId) {
-    if (!this.isEnabled()) return true;
-    const now = Date.now();
-    let w = this.windows.get(sessionId);
-    if (!w) {
-      w = {
-        secondCount: 0,
-        secondStart: now,
-        minuteCount: 0,
-        minuteStart: now,
-        lastWarning: 0
-      };
-      this.windows.set(sessionId, w);
-    }
-    if (now - w.secondStart >= 1e3) {
-      w.secondCount = 0;
-      w.secondStart = now;
-    }
-    if (now - w.minuteStart >= 6e4) {
-      w.minuteCount = 0;
-      w.minuteStart = now;
-    }
-    if (w.secondCount >= this.maxPerSecond) {
-      this._droppedTotal++;
-      this.maybeWarn(sessionId, w, now);
-      return false;
-    }
-    if (w.minuteCount >= this.maxPerMinute) {
-      this._droppedTotal++;
-      this.maybeWarn(sessionId, w, now);
-      return false;
-    }
-    w.secondCount++;
-    w.minuteCount++;
-    return true;
-  }
-  /** Allow a batch of N events. Returns the number accepted. */
-  allowBatch(sessionId, count) {
-    let accepted = 0;
-    for (let i = 0; i < count; i++) {
-      if (this.allow(sessionId)) accepted++;
-      else break;
-    }
-    return accepted;
-  }
-  /** Remove tracking for sessions that haven't been seen in maxAgeMs. */
-  prune(maxAgeMs = 3e5) {
-    const cutoff = Date.now() - maxAgeMs;
-    for (const [id, w] of this.windows) {
-      if (w.minuteStart < cutoff) {
-        this.windows.delete(id);
-      }
-    }
-  }
-  maybeWarn(sessionId, w, now) {
-    if (now - w.lastWarning >= 6e4) {
-      w.lastWarning = now;
-      console.error(
-        `[RuntimeScope] Rate limiting session ${sessionId.slice(0, 8)}... (dropped ${this._droppedTotal} total)`
-      );
-    }
-  }
-};
-
-// src/tls.ts
-import { readFileSync } from "fs";
-function loadTlsOptions(config) {
-  return {
-    cert: readFileSync(config.certPath, "utf-8"),
-    key: readFileSync(config.keyPath, "utf-8"),
-    ...config.caPath ? { ca: readFileSync(config.caPath, "utf-8") } : {}
-  };
-}
-function resolveTlsConfig() {
-  const certPath = process.env.RUNTIMESCOPE_TLS_CERT;
-  const keyPath = process.env.RUNTIMESCOPE_TLS_KEY;
-  if (!certPath || !keyPath) return null;
-  return {
-    certPath,
-    keyPath,
-    caPath: process.env.RUNTIMESCOPE_TLS_CA
-  };
-}
-
-// src/server.ts
-var CollectorServer = class {
-  wss = null;
-  store;
-  projectManager;
-  authManager = null;
-  rateLimiter;
-  clients = /* @__PURE__ */ new Map();
-  pendingHandshakes = /* @__PURE__ */ new Set();
-  pendingCommands = /* @__PURE__ */ new Map();
-  sqliteStores = /* @__PURE__ */ new Map();
-  disconnectCallbacks = [];
-  pruneTimer = null;
-  tlsConfig = null;
-  constructor(options = {}) {
-    this.store = new EventStore(options.bufferSize ?? 1e4);
-    this.projectManager = options.projectManager ?? null;
-    this.authManager = options.authManager ?? null;
-    this.rateLimiter = new SessionRateLimiter(options.rateLimits ?? {});
-    this.tlsConfig = options.tls ?? null;
-    if (this.projectManager) {
-      this.projectManager.ensureGlobalDir();
-    }
-    if (this.rateLimiter.isEnabled()) {
-      this.pruneTimer = setInterval(() => this.rateLimiter.prune(), 6e4);
-    }
-  }
-  getStore() {
-    return this.store;
-  }
-  getPort() {
-    const addr = this.wss?.address();
-    return addr && typeof addr === "object" ? addr.port : null;
-  }
-  getClientCount() {
-    return this.clients.size;
-  }
-  getProjectManager() {
-    return this.projectManager;
-  }
-  getSqliteStore(projectName) {
-    return this.sqliteStores.get(projectName);
-  }
-  getSqliteStores() {
-    return this.sqliteStores;
-  }
-  getRateLimiter() {
-    return this.rateLimiter;
-  }
-  onDisconnect(cb) {
-    this.disconnectCallbacks.push(cb);
-  }
-  start(options = {}) {
-    const port = options.port ?? 9090;
-    const host = options.host ?? "127.0.0.1";
-    const maxRetries = options.maxRetries ?? 5;
-    const retryDelayMs = options.retryDelayMs ?? 1e3;
-    const tls = options.tls ?? this.tlsConfig;
-    return this.tryStart(port, host, maxRetries, retryDelayMs, tls);
-  }
-  tryStart(port, host, retriesLeft, retryDelayMs, tls) {
-    return new Promise((resolve2, reject) => {
-      let wss;
-      if (tls) {
-        const httpsServer = createHttpsServer(loadTlsOptions(tls));
-        wss = new WebSocketServer({ server: httpsServer });
-        httpsServer.on("listening", () => {
-          this.wss = wss;
-          this.setupConnectionHandler(wss);
-          console.error(`[RuntimeScope] Collector listening on wss://${host}:${port}`);
-          resolve2();
-        });
-        httpsServer.on("error", (err) => {
-          httpsServer.close();
-          this.handleStartError(err, port, host, retriesLeft, retryDelayMs, tls, resolve2, reject);
-        });
-        httpsServer.listen(port, host);
-      } else {
-        wss = new WebSocketServer({ port, host });
-        wss.on("listening", () => {
-          this.wss = wss;
-          this.setupConnectionHandler(wss);
-          console.error(`[RuntimeScope] Collector listening on ws://${host}:${port}`);
-          resolve2();
-        });
-        wss.on("error", (err) => {
-          wss.close();
-          this.handleStartError(err, port, host, retriesLeft, retryDelayMs, tls, resolve2, reject);
-        });
-      }
-    });
-  }
-  handleStartError(err, port, host, retriesLeft, retryDelayMs, tls, resolve2, reject) {
-    if (err.code === "EADDRINUSE" && retriesLeft > 0) {
-      console.error(
-        `[RuntimeScope] Port ${port} in use, retrying in ${retryDelayMs}ms (${retriesLeft} attempts left)...`
-      );
-      setTimeout(() => {
-        this.tryStart(port, host, retriesLeft - 1, retryDelayMs, tls).then(resolve2).catch(reject);
-      }, retryDelayMs);
-    } else {
-      console.error("[RuntimeScope] WebSocket server error:", err.message);
-      reject(err);
-    }
-  }
-  ensureSqliteStore(projectName) {
-    if (!this.projectManager) return null;
-    let sqliteStore = this.sqliteStores.get(projectName);
-    if (!sqliteStore) {
-      try {
-        this.projectManager.ensureProjectDir(projectName);
-        const dbPath = this.projectManager.getProjectDbPath(projectName);
-        sqliteStore = new SqliteStore({ dbPath });
-        this.sqliteStores.set(projectName, sqliteStore);
-        this.store.setSqliteStore(sqliteStore, projectName);
-        console.error(`[RuntimeScope] SQLite store opened for project "${projectName}"`);
-      } catch (err) {
-        console.error(
-          `[RuntimeScope] Failed to open SQLite for "${projectName}":`,
-          err.message
-        );
-        return null;
-      }
-    }
-    return sqliteStore;
-  }
-  setupConnectionHandler(wss) {
-    wss.on("connection", (ws) => {
-      if (this.authManager?.isEnabled()) {
-        this.pendingHandshakes.add(ws);
-        const authTimeout = setTimeout(() => {
-          if (this.pendingHandshakes.has(ws)) {
-            this.pendingHandshakes.delete(ws);
-            try {
-              ws.send(JSON.stringify({
-                type: "error",
-                payload: { code: "AUTH_TIMEOUT", message: "Handshake timeout" },
-                timestamp: Date.now()
-              }));
-            } catch {
-            }
-            ws.close(4001, "Authentication timeout");
-          }
-        }, 5e3);
-        ws.on("close", () => {
-          clearTimeout(authTimeout);
-          this.pendingHandshakes.delete(ws);
-        });
-      }
-      ws.on("message", (data) => {
-        try {
-          const msg = JSON.parse(data.toString());
-          this.handleMessage(ws, msg);
-        } catch {
-          console.error("[RuntimeScope] Malformed WebSocket message, ignoring");
-        }
-      });
-      ws.on("close", () => {
-        const clientInfo = this.clients.get(ws);
-        if (clientInfo) {
-          this.store.markDisconnected(clientInfo.sessionId);
-          const sqliteStore = this.sqliteStores.get(clientInfo.projectName);
-          if (sqliteStore) {
-            sqliteStore.updateSessionDisconnected(clientInfo.sessionId, Date.now());
-          }
-          console.error(`[RuntimeScope] Session ${clientInfo.sessionId} disconnected`);
-          for (const cb of this.disconnectCallbacks) {
-            try {
-              cb(clientInfo.sessionId, clientInfo.projectName);
-            } catch {
-            }
-          }
-        }
-        this.clients.delete(ws);
-      });
-      ws.on("error", (err) => {
-        console.error("[RuntimeScope] WebSocket client error:", err.message);
-      });
-    });
-  }
-  handleMessage(ws, msg) {
-    switch (msg.type) {
-      case "handshake": {
-        const payload = msg.payload;
-        if (this.authManager?.isEnabled()) {
-          if (!this.authManager.isAuthorized(payload.authToken)) {
-            try {
-              ws.send(JSON.stringify({
-                type: "error",
-                payload: { code: "AUTH_FAILED", message: "Invalid or missing API key" },
-                timestamp: Date.now()
-              }));
-            } catch {
-            }
-            ws.close(4001, "Authentication failed");
-            return;
-          }
-          this.pendingHandshakes.delete(ws);
-        }
-        const projectName = payload.appName;
-        this.clients.set(ws, {
-          sessionId: payload.sessionId,
-          projectName
-        });
-        const sqliteStore = this.ensureSqliteStore(projectName);
-        if (sqliteStore) {
-          const sessionInfo = {
-            sessionId: payload.sessionId,
-            project: projectName,
-            appName: payload.appName,
-            connectedAt: msg.timestamp,
-            sdkVersion: payload.sdkVersion,
-            eventCount: 0,
-            isConnected: true
-          };
-          sqliteStore.saveSession(sessionInfo);
-        }
-        console.error(
-          `[RuntimeScope] Session ${payload.sessionId} connected (${payload.appName} v${payload.sdkVersion})`
-        );
-        break;
-      }
-      case "event": {
-        if (this.pendingHandshakes.has(ws)) return;
-        const clientInfo = this.clients.get(ws);
-        const payload = msg.payload;
-        if (Array.isArray(payload.events)) {
-          for (const event of payload.events) {
-            if (clientInfo && !this.rateLimiter.allow(clientInfo.sessionId)) {
-              break;
-            }
-            this.store.addEvent(event);
-          }
-        }
-        break;
-      }
-      case "command_response": {
-        const resp = msg;
-        const pending = this.pendingCommands.get(resp.requestId);
-        if (pending) {
-          clearTimeout(pending.timer);
-          this.pendingCommands.delete(resp.requestId);
-          pending.resolve(resp.payload);
-        }
-        break;
-      }
-      case "heartbeat":
-        break;
-    }
-  }
-  /** Find the WebSocket for a given sessionId */
-  findWsBySessionId(sessionId) {
-    for (const [ws, info] of this.clients) {
-      if (info.sessionId === sessionId) return ws;
-    }
-    return void 0;
-  }
-  /** Get the first connected session ID (for single-app use) */
-  getFirstSessionId() {
-    for (const [, info] of this.clients) {
-      return info.sessionId;
-    }
-    return void 0;
-  }
-  /** Get the project name for a session */
-  getProjectForSession(sessionId) {
-    for (const [, info] of this.clients) {
-      if (info.sessionId === sessionId) return info.projectName;
-    }
-    return void 0;
-  }
-  /** Send a command to the SDK and await the response */
-  sendCommand(sessionId, command, timeoutMs = 1e4) {
-    return new Promise((resolve2, reject) => {
-      const ws = this.findWsBySessionId(sessionId);
-      if (!ws || ws.readyState !== 1) {
-        reject(new Error(`No active WebSocket for session ${sessionId}`));
-        return;
-      }
-      const timer = setTimeout(() => {
-        this.pendingCommands.delete(command.requestId);
-        reject(new Error(`Command ${command.command} timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.pendingCommands.set(command.requestId, { resolve: resolve2, reject, timer });
-      try {
-        ws.send(JSON.stringify({
-          type: "command",
-          payload: command,
-          timestamp: Date.now(),
-          sessionId
-        }));
-      } catch (err) {
-        clearTimeout(timer);
-        this.pendingCommands.delete(command.requestId);
-        reject(err);
-      }
-    });
-  }
-  stop() {
-    if (this.pruneTimer) {
-      clearInterval(this.pruneTimer);
-      this.pruneTimer = null;
-    }
-    for (const [name, sqliteStore] of this.sqliteStores) {
-      try {
-        sqliteStore.close();
-        console.error(`[RuntimeScope] SQLite store closed for "${name}"`);
-      } catch {
-      }
-    }
-    this.sqliteStores.clear();
-    if (this.wss) {
-      this.wss.close();
-      this.wss = null;
-      console.error("[RuntimeScope] Collector stopped");
-    }
-  }
-};
+import {
+  AuthManager,
+  BUILT_IN_RULES,
+  CollectorServer,
+  EventStore,
+  HttpServer,
+  PmStore,
+  ProjectDiscovery,
+  ProjectManager,
+  Redactor,
+  RingBuffer,
+  SessionManager,
+  SessionRateLimiter,
+  SqliteStore,
+  __require,
+  calculateActiveMinutes,
+  calculateCostMicrodollars,
+  generateApiKey,
+  loadTlsOptions,
+  parseSessionJsonl,
+  resolveTlsConfig
+} from "./chunk-6JZXAFPC.js";
 
 // src/issue-detector.ts
 function detectIssues(events) {
@@ -1249,326 +322,6 @@ function detectPoorWebVitals(events) {
   return issues;
 }
 
-// src/project-manager.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync, existsSync, readdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-var DEFAULT_GLOBAL_CONFIG = {
-  defaultPort: 9090,
-  bufferSize: 1e4,
-  httpPort: 9091
-};
-var ProjectManager = class {
-  baseDir;
-  constructor(baseDir) {
-    this.baseDir = baseDir ?? join(homedir(), ".runtimescope");
-  }
-  get rootDir() {
-    return this.baseDir;
-  }
-  // --- Directory helpers ---
-  getProjectDir(projectName) {
-    return join(this.baseDir, "projects", projectName);
-  }
-  getProjectDbPath(projectName) {
-    return join(this.getProjectDir(projectName), "events.db");
-  }
-  getSessionsDir(projectName) {
-    return join(this.getProjectDir(projectName), "sessions");
-  }
-  getSessionSnapshotPath(projectName, sessionId, timestamp) {
-    const date = new Date(timestamp);
-    const dateStr = date.toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    const shortId = sessionId.slice(0, 8);
-    return join(this.getSessionsDir(projectName), `${dateStr}_${shortId}.db`);
-  }
-  // --- Lifecycle (idempotent) ---
-  ensureGlobalDir() {
-    this.mkdirp(this.baseDir);
-    this.mkdirp(join(this.baseDir, "projects"));
-    const configPath = join(this.baseDir, "config.json");
-    if (!existsSync(configPath)) {
-      this.writeJson(configPath, DEFAULT_GLOBAL_CONFIG);
-    }
-  }
-  ensureProjectDir(projectName) {
-    const projectDir = this.getProjectDir(projectName);
-    this.mkdirp(projectDir);
-    this.mkdirp(this.getSessionsDir(projectName));
-    const configPath = join(projectDir, "config.json");
-    if (!existsSync(configPath)) {
-      const config = {
-        name: projectName,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        settings: {
-          retentionDays: 30
-        }
-      };
-      this.writeJson(configPath, config);
-    }
-  }
-  // --- Config ---
-  getGlobalConfig() {
-    const configPath = join(this.baseDir, "config.json");
-    if (!existsSync(configPath)) return { ...DEFAULT_GLOBAL_CONFIG };
-    return { ...DEFAULT_GLOBAL_CONFIG, ...this.readJson(configPath) };
-  }
-  saveGlobalConfig(config) {
-    this.writeJson(join(this.baseDir, "config.json"), config);
-  }
-  getProjectConfig(projectName) {
-    const configPath = join(this.getProjectDir(projectName), "config.json");
-    if (!existsSync(configPath)) return null;
-    return this.readJson(configPath);
-  }
-  saveProjectConfig(projectName, config) {
-    this.writeJson(join(this.getProjectDir(projectName), "config.json"), config);
-  }
-  getInfrastructureConfig(projectName) {
-    const jsonPath = join(this.getProjectDir(projectName), "infrastructure.json");
-    if (existsSync(jsonPath)) {
-      const config = this.readJson(jsonPath);
-      return this.resolveConfigEnvVars(config);
-    }
-    const yamlPath = join(this.getProjectDir(projectName), "infrastructure.yaml");
-    if (existsSync(yamlPath)) {
-      try {
-        const content = readFileSync2(yamlPath, "utf-8");
-        return this.resolveConfigEnvVars(this.parseSimpleYaml(content));
-      } catch {
-        return null;
-      }
-    }
-    return null;
-  }
-  getClaudeInstructions(projectName) {
-    const filePath = join(this.getProjectDir(projectName), "claude-instructions.md");
-    if (!existsSync(filePath)) return null;
-    return readFileSync2(filePath, "utf-8");
-  }
-  // --- Discovery ---
-  listProjects() {
-    const projectsDir = join(this.baseDir, "projects");
-    if (!existsSync(projectsDir)) return [];
-    return readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-  }
-  projectExists(projectName) {
-    return existsSync(this.getProjectDir(projectName));
-  }
-  // --- Environment variable resolution ---
-  resolveEnvVars(value) {
-    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => {
-      return process.env[varName] ?? "";
-    });
-  }
-  // --- Private helpers ---
-  mkdirp(dir) {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-    }
-  }
-  readJson(path) {
-    const content = readFileSync2(path, "utf-8");
-    return JSON.parse(content);
-  }
-  writeJson(path, data) {
-    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
-  }
-  resolveConfigEnvVars(config) {
-    const resolve2 = (obj) => {
-      if (typeof obj === "string") return this.resolveEnvVars(obj);
-      if (Array.isArray(obj)) return obj.map(resolve2);
-      if (obj && typeof obj === "object") {
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-          result[key] = resolve2(value);
-        }
-        return result;
-      }
-      return obj;
-    };
-    return resolve2(config);
-  }
-  /**
-   * Minimal YAML parser for simple infrastructure config files.
-   * Handles flat key-value pairs and one level of nesting.
-   * For full YAML support, install js-yaml.
-   */
-  parseSimpleYaml(content) {
-    try {
-      const yaml = __require("js-yaml");
-      return yaml.load(content);
-    } catch {
-      try {
-        return JSON.parse(content);
-      } catch {
-        return {};
-      }
-    }
-  }
-};
-
-// src/auth.ts
-import { randomBytes, timingSafeEqual } from "crypto";
-var AuthManager = class {
-  keys = /* @__PURE__ */ new Map();
-  enabled;
-  constructor(config = {}) {
-    this.enabled = config.enabled ?? false;
-    for (const entry of config.apiKeys ?? []) {
-      this.keys.set(entry.key, entry);
-    }
-  }
-  isEnabled() {
-    return this.enabled;
-  }
-  /** Validate an API key. Returns the entry if valid, null if invalid. */
-  validate(key) {
-    if (!this.enabled) return null;
-    if (!key) return null;
-    for (const [storedKey, entry] of this.keys) {
-      if (this.safeCompare(key, storedKey)) {
-        return entry;
-      }
-    }
-    return null;
-  }
-  /** Check if request is authorized. Returns true if auth is disabled or key is valid. */
-  isAuthorized(key) {
-    if (!this.enabled) return true;
-    return this.validate(key) !== null;
-  }
-  /** Extract bearer token from Authorization header value. */
-  static extractBearer(header) {
-    if (!header) return void 0;
-    const match = header.match(/^Bearer\s+(\S+)$/i);
-    return match?.[1];
-  }
-  /** Constant-time string comparison to prevent timing attacks. */
-  safeCompare(a, b) {
-    if (a.length !== b.length) return false;
-    try {
-      return timingSafeEqual(Buffer.from(a, "utf-8"), Buffer.from(b, "utf-8"));
-    } catch {
-      return false;
-    }
-  }
-};
-function generateApiKey(label, project) {
-  return {
-    key: randomBytes(32).toString("hex"),
-    label,
-    project,
-    createdAt: Date.now()
-  };
-}
-
-// src/redactor.ts
-var BUILT_IN_RULES = [
-  {
-    name: "jwt",
-    pattern: /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+/g,
-    replacement: "[REDACTED:jwt]"
-  },
-  {
-    name: "credit_card",
-    pattern: /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g,
-    replacement: "[REDACTED:cc]"
-  },
-  {
-    name: "ssn",
-    pattern: /\b\d{3}-\d{2}-\d{4}\b/g,
-    replacement: "[REDACTED:ssn]"
-  },
-  {
-    name: "email",
-    pattern: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z]{2,}\b/gi,
-    replacement: "[REDACTED:email]"
-  },
-  {
-    name: "bearer_token",
-    pattern: /Bearer\s+[A-Za-z0-9._~+/=-]+/gi,
-    replacement: "Bearer [REDACTED]"
-  },
-  {
-    name: "api_key_param",
-    pattern: /(?:api[_-]?key|apikey|secret|token|password|passwd|authorization)=[^&\s"']+/gi,
-    replacement: "[REDACTED:param]"
-  }
-];
-var DEFAULT_SENSITIVE_KEYS = [
-  "password",
-  "passwd",
-  "secret",
-  "token",
-  "accessToken",
-  "refreshToken",
-  "apiKey",
-  "api_key",
-  "authorization",
-  "credit_card",
-  "creditCard",
-  "ssn",
-  "socialSecurity"
-];
-var Redactor = class {
-  rules;
-  sensitiveKeyPattern;
-  enabled;
-  constructor(config = {}) {
-    this.enabled = config.enabled ?? true;
-    this.rules = [];
-    if (config.useBuiltIn !== false) {
-      this.rules.push(...BUILT_IN_RULES);
-    }
-    if (config.rules) {
-      this.rules.push(...config.rules);
-    }
-    const keys = config.sensitiveKeys ?? DEFAULT_SENSITIVE_KEYS;
-    this.sensitiveKeyPattern = keys.length > 0 ? new RegExp(`^(${keys.join("|")})$`, "i") : null;
-  }
-  isEnabled() {
-    return this.enabled;
-  }
-  /** Apply all redaction rules to a string value. */
-  redactString(value) {
-    let result = value;
-    for (const rule of this.rules) {
-      rule.pattern.lastIndex = 0;
-      result = result.replace(rule.pattern, rule.replacement);
-    }
-    return result;
-  }
-  /**
-   * Deep-walk an event and redact all string fields.
-   * Returns a new event object (does not mutate the original).
-   */
-  redactEvent(event) {
-    if (!this.enabled) return event;
-    return this.deepRedact(event);
-  }
-  deepRedact(value, key) {
-    if (value === null || value === void 0) return value;
-    if (key && this.sensitiveKeyPattern?.test(key)) {
-      return "[REDACTED]";
-    }
-    if (typeof value === "string") {
-      return this.redactString(value);
-    }
-    if (Array.isArray(value)) {
-      return value.map((item) => this.deepRedact(item));
-    }
-    if (typeof value === "object") {
-      const result = {};
-      for (const [k, v] of Object.entries(value)) {
-        result[k] = this.deepRedact(v, k);
-      }
-      return result;
-    }
-    return value;
-  }
-};
-
 // src/engines/api-discovery.ts
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var NUMERIC_RE = /^\d+$/;
@@ -3228,126 +1981,6 @@ var InfraConnector = class {
   }
 };
 
-// src/session-manager.ts
-var SessionManager = class {
-  projectManager;
-  sqliteStores;
-  store;
-  constructor(projectManager, sqliteStores, store) {
-    this.projectManager = projectManager;
-    this.sqliteStores = sqliteStores;
-    this.store = store;
-  }
-  computeMetrics(sessionId, project, events) {
-    const sessionEvents = events.filter((e) => e.sessionId === sessionId);
-    const networkEvents = sessionEvents.filter((e) => e.eventType === "network");
-    const renderEvents = sessionEvents.filter((e) => e.eventType === "render");
-    const stateEvents = sessionEvents.filter((e) => e.eventType === "state");
-    const performanceEvents = sessionEvents.filter((e) => e.eventType === "performance");
-    const databaseEvents = sessionEvents.filter((e) => e.eventType === "database");
-    const consoleEvents = sessionEvents.filter((e) => e.eventType === "console");
-    const endpoints = {};
-    const endpointGroups = /* @__PURE__ */ new Map();
-    for (const e of networkEvents) {
-      const key = `${e.method} ${e.url}`;
-      const group = endpointGroups.get(key) ?? [];
-      group.push(e);
-      endpointGroups.set(key, group);
-    }
-    for (const [key, group] of endpointGroups) {
-      const avgLatency = group.reduce((s, e) => s + e.duration, 0) / group.length;
-      const errorCount2 = group.filter((e) => e.status >= 400).length;
-      endpoints[key] = { avgLatency, errorRate: errorCount2 / group.length, callCount: group.length };
-    }
-    const components = {};
-    for (const re of renderEvents) {
-      for (const p of re.profiles) {
-        const existing = components[p.componentName];
-        if (existing) {
-          existing.renderCount += p.renderCount;
-          existing.avgDuration = (existing.avgDuration + p.avgDuration) / 2;
-        } else {
-          components[p.componentName] = { renderCount: p.renderCount, avgDuration: p.avgDuration };
-        }
-      }
-    }
-    const stores = {};
-    for (const se of stateEvents) {
-      const existing = stores[se.storeId];
-      if (existing) {
-        existing.updateCount++;
-      } else {
-        stores[se.storeId] = { updateCount: 1 };
-      }
-    }
-    const webVitals = {};
-    for (const pe of performanceEvents) {
-      if (pe.rating) {
-        webVitals[pe.metricName] = { value: pe.value, rating: pe.rating };
-      }
-    }
-    const queries = {};
-    const queryGroups = /* @__PURE__ */ new Map();
-    for (const de of databaseEvents) {
-      const group = queryGroups.get(de.normalizedQuery) ?? [];
-      group.push(de);
-      queryGroups.set(de.normalizedQuery, group);
-    }
-    for (const [key, group] of queryGroups) {
-      const avgDuration = group.reduce((s, e) => s + e.duration, 0) / group.length;
-      queries[key] = { avgDuration, callCount: group.length };
-    }
-    const timestamps = sessionEvents.map((e) => e.timestamp);
-    const errorCount = consoleEvents.filter((e) => e.level === "error").length + networkEvents.filter((e) => e.status >= 400).length;
-    return {
-      sessionId,
-      project,
-      connectedAt: timestamps.length > 0 ? Math.min(...timestamps) : Date.now(),
-      disconnectedAt: timestamps.length > 0 ? Math.max(...timestamps) : Date.now(),
-      totalEvents: sessionEvents.length,
-      errorCount,
-      endpoints,
-      components,
-      stores,
-      webVitals,
-      queries
-    };
-  }
-  createSnapshot(sessionId, project) {
-    const events = this.store.getAllEvents();
-    const metrics = this.computeMetrics(sessionId, project, events);
-    const sqliteStore = this.sqliteStores.get(project);
-    if (sqliteStore) {
-      sqliteStore.saveSessionMetrics(sessionId, project, metrics);
-    }
-    return {
-      sessionId,
-      project,
-      metrics,
-      createdAt: Date.now()
-    };
-  }
-  getSessionHistory(project, limit = 20) {
-    const sqliteStore = this.sqliteStores.get(project);
-    if (!sqliteStore) return [];
-    const sessions = sqliteStore.getSessions(project, limit);
-    const snapshots = [];
-    for (const session of sessions) {
-      const metricsData = sqliteStore.getSessionMetrics(session.sessionId);
-      if (metricsData) {
-        snapshots.push({
-          sessionId: session.sessionId,
-          project,
-          metrics: metricsData,
-          buildMeta: session.buildMeta,
-          createdAt: session.disconnectedAt ?? session.connectedAt
-        });
-      }
-    }
-    return snapshots;
-  }
-};
-
 // src/session-differ.ts
 var CHANGE_THRESHOLD = 0.1;
 function classifyDelta(percentChange) {
@@ -3429,352 +2062,6 @@ function compareSessions(metricsA, metricsB) {
     }
   };
 }
-
-// src/http-server.ts
-import { createServer } from "http";
-import { createServer as createHttpsServer2 } from "https";
-import { readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
-import { resolve, dirname } from "path";
-import { fileURLToPath } from "url";
-import { WebSocketServer as WebSocketServer2 } from "ws";
-var HttpServer = class {
-  server = null;
-  wss = null;
-  store;
-  processMonitor;
-  authManager;
-  allowedOrigins;
-  dashboardClients = /* @__PURE__ */ new Set();
-  eventListener = null;
-  routes = /* @__PURE__ */ new Map();
-  sdkBundlePath = null;
-  activePort = 9091;
-  startedAt = Date.now();
-  constructor(store, processMonitor, options) {
-    this.store = store;
-    this.processMonitor = processMonitor ?? null;
-    this.authManager = options?.authManager ?? null;
-    this.allowedOrigins = options?.allowedOrigins ?? null;
-    this.registerRoutes();
-  }
-  registerRoutes() {
-    this.routes.set("GET /api/health", (_req, res) => {
-      this.json(res, {
-        status: "ok",
-        timestamp: Date.now(),
-        uptime: Math.floor((Date.now() - this.startedAt) / 1e3),
-        sessions: this.store.getSessionInfo().filter((s) => s.isConnected).length,
-        authEnabled: this.authManager?.isEnabled() ?? false
-      });
-    });
-    this.routes.set("GET /api/sessions", (_req, res) => {
-      const sessions = this.store.getSessionInfo();
-      this.json(res, { data: sessions, count: sessions.length });
-    });
-    this.routes.set("GET /api/projects", (_req, res) => {
-      const sessions = this.store.getSessionInfo();
-      const projectMap = /* @__PURE__ */ new Map();
-      for (const s of sessions) {
-        const existing = projectMap.get(s.appName);
-        if (existing) {
-          existing.sessions.push(s.sessionId);
-          existing.eventCount += s.eventCount;
-          if (s.isConnected) existing.isConnected = true;
-        } else {
-          projectMap.set(s.appName, {
-            appName: s.appName,
-            sessions: [s.sessionId],
-            isConnected: s.isConnected,
-            eventCount: s.eventCount
-          });
-        }
-      }
-      const projects = Array.from(projectMap.values());
-      this.json(res, { data: projects, count: projects.length });
-    });
-    this.routes.set("GET /api/processes", (_req, res, params) => {
-      if (!this.processMonitor) {
-        this.json(res, { data: [], count: 0 });
-        return;
-      }
-      const type = params.get("type") ?? void 0;
-      const project = params.get("project") ?? void 0;
-      const processes = this.processMonitor.getProcesses({ type, project });
-      this.json(res, { data: processes, count: processes.length });
-    });
-    this.routes.set("GET /api/ports", (_req, res, params) => {
-      if (!this.processMonitor) {
-        this.json(res, { data: [], count: 0 });
-        return;
-      }
-      const port = numParam(params, "port");
-      const ports = this.processMonitor.getPortUsage(port);
-      this.json(res, { data: ports, count: ports.length });
-    });
-    this.routes.set("GET /api/events/network", (_req, res, params) => {
-      const events = this.store.getNetworkRequests({
-        sinceSeconds: numParam(params, "since_seconds"),
-        urlPattern: params.get("url_pattern") ?? void 0,
-        method: params.get("method") ?? void 0,
-        sessionId: params.get("session_id") ?? void 0
-      });
-      this.json(res, { data: events, count: events.length });
-    });
-    this.routes.set("GET /api/events/console", (_req, res, params) => {
-      const events = this.store.getConsoleMessages({
-        sinceSeconds: numParam(params, "since_seconds"),
-        level: params.get("level") ?? void 0,
-        search: params.get("search") ?? void 0,
-        sessionId: params.get("session_id") ?? void 0
-      });
-      this.json(res, { data: events, count: events.length });
-    });
-    this.routes.set("GET /api/events/state", (_req, res, params) => {
-      const events = this.store.getStateEvents({
-        sinceSeconds: numParam(params, "since_seconds"),
-        storeId: params.get("store_id") ?? void 0,
-        sessionId: params.get("session_id") ?? void 0
-      });
-      this.json(res, { data: events, count: events.length });
-    });
-    this.routes.set("GET /api/events/renders", (_req, res, params) => {
-      const events = this.store.getRenderEvents({
-        sinceSeconds: numParam(params, "since_seconds"),
-        componentName: params.get("component") ?? void 0,
-        sessionId: params.get("session_id") ?? void 0
-      });
-      this.json(res, { data: events, count: events.length });
-    });
-    this.routes.set("GET /api/events/performance", (_req, res, params) => {
-      const events = this.store.getPerformanceMetrics({
-        sinceSeconds: numParam(params, "since_seconds"),
-        metricName: params.get("metric") ?? void 0,
-        sessionId: params.get("session_id") ?? void 0
-      });
-      this.json(res, { data: events, count: events.length });
-    });
-    this.routes.set("GET /api/events/database", (_req, res, params) => {
-      const events = this.store.getDatabaseEvents({
-        sinceSeconds: numParam(params, "since_seconds"),
-        table: params.get("table") ?? void 0,
-        minDurationMs: numParam(params, "min_duration_ms"),
-        search: params.get("search") ?? void 0,
-        sessionId: params.get("session_id") ?? void 0
-      });
-      this.json(res, { data: events, count: events.length });
-    });
-    this.routes.set("GET /api/events/timeline", (_req, res, params) => {
-      const eventTypes = params.get("event_types")?.split(",") ?? void 0;
-      const events = this.store.getEventTimeline({
-        sinceSeconds: numParam(params, "since_seconds"),
-        eventTypes,
-        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);
-    });
-  }
-  /**
-   * Resolve the SDK IIFE bundle path.
-   * Tries multiple locations for monorepo and installed-package scenarios.
-   */
-  resolveSdkPath() {
-    if (this.sdkBundlePath) return this.sdkBundlePath;
-    const __dir = dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-      resolve(__dir, "../../sdk/dist/index.global.js"),
-      // monorepo: packages/collector/dist -> packages/sdk/dist
-      resolve(__dir, "../../../node_modules/@runtimescope/sdk/dist/index.global.js")
-      // npm installed
-    ];
-    for (const p of candidates) {
-      if (existsSync2(p)) {
-        this.sdkBundlePath = p;
-        return p;
-      }
-    }
-    return null;
-  }
-  async start(options = {}) {
-    const basePort = options.port ?? parseInt(process.env.RUNTIMESCOPE_HTTP_PORT ?? "9091", 10);
-    const host = options.host ?? "127.0.0.1";
-    const tls = options.tls;
-    const maxRetries = 5;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      const port = basePort + attempt;
-      try {
-        await this.tryStart(port, host, tls);
-        return;
-      } catch (err) {
-        const isAddrInUse = err.code === "EADDRINUSE";
-        if (isAddrInUse && attempt < maxRetries) {
-          console.error(`[RuntimeScope] HTTP port ${port} in use, trying ${port + 1}...`);
-          continue;
-        }
-        throw err;
-      }
-    }
-  }
-  tryStart(port, host, tls) {
-    return new Promise((resolve2, reject) => {
-      const handler = (req, res) => this.handleRequest(req, res);
-      const server = tls ? createHttpsServer2(loadTlsOptions(tls), handler) : createServer(handler);
-      this.wss = new WebSocketServer2({ server, path: "/api/ws/events" });
-      this.wss.on("connection", (ws) => {
-        this.dashboardClients.add(ws);
-        ws.on("close", () => this.dashboardClients.delete(ws));
-        ws.on("error", () => this.dashboardClients.delete(ws));
-      });
-      this.eventListener = (event) => this.broadcastEvent(event);
-      this.store.onEvent(this.eventListener);
-      server.on("listening", () => {
-        this.server = server;
-        this.activePort = port;
-        this.startedAt = Date.now();
-        const proto = tls ? "https" : "http";
-        console.error(`[RuntimeScope] HTTP API listening on ${proto}://${host}:${port}`);
-        resolve2();
-      });
-      server.on("error", (err) => {
-        this.wss?.close();
-        this.wss = null;
-        if (this.eventListener) {
-          this.store.removeEventListener(this.eventListener);
-          this.eventListener = null;
-        }
-        reject(err);
-      });
-      server.listen(port, host);
-    });
-  }
-  async stop() {
-    if (this.eventListener) {
-      this.store.removeEventListener(this.eventListener);
-      this.eventListener = null;
-    }
-    for (const ws of this.dashboardClients) {
-      ws.close();
-    }
-    this.dashboardClients.clear();
-    if (this.wss) {
-      this.wss.close();
-      this.wss = null;
-    }
-    if (this.server) {
-      return new Promise((resolve2) => {
-        this.server.close(() => {
-          this.server = null;
-          console.error("[RuntimeScope] HTTP API stopped");
-          resolve2();
-        });
-      });
-    }
-  }
-  broadcastEvent(event) {
-    if (this.dashboardClients.size === 0) return;
-    const message = JSON.stringify({ type: "event", data: event });
-    for (const ws of this.dashboardClients) {
-      if (ws.readyState === 1) {
-        try {
-          ws.send(message);
-        } catch {
-          this.dashboardClients.delete(ws);
-        }
-      }
-    }
-  }
-  handleRequest(req, res) {
-    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
-    this.setCorsHeaders(req, res);
-    if (req.method === "OPTIONS") {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-    const isPublic = url.pathname === "/api/health" || url.pathname === "/runtimescope.js" || url.pathname === "/snippet";
-    if (!isPublic && this.authManager?.isEnabled()) {
-      const token = AuthManager.extractBearer(req.headers.authorization);
-      if (!this.authManager.isAuthorized(token)) {
-        this.json(res, { error: "Unauthorized", code: "AUTH_FAILED" }, 401);
-        return;
-      }
-    }
-    if (req.method === "GET" && url.pathname === "/runtimescope.js") {
-      const sdkPath = this.resolveSdkPath();
-      if (sdkPath) {
-        const bundle = readFileSync3(sdkPath, "utf-8");
-        res.writeHead(200, {
-          "Content-Type": "application/javascript",
-          "Cache-Control": "no-cache"
-        });
-        res.end(bundle);
-      } else {
-        res.writeHead(404, { "Content-Type": "text/plain" });
-        res.end("SDK bundle not found. Run: npm run build -w packages/sdk");
-      }
-      return;
-    }
-    if (req.method === "GET" && url.pathname === "/snippet") {
-      const appName = url.searchParams.get("app") || "my-app";
-      const wsPort = process.env.RUNTIMESCOPE_PORT ?? "9090";
-      const snippet = `<!-- RuntimeScope SDK \u2014 paste before </body> -->
-<script src="http://localhost:${this.activePort}/runtimescope.js"></script>
-<script>
-  RuntimeScope.init({
-    appName: '${appName}',
-    endpoint: 'ws://localhost:${wsPort}',
-  });
-</script>`;
-      res.writeHead(200, {
-        "Content-Type": "text/plain"
-      });
-      res.end(snippet);
-      return;
-    }
-    const routeKey = `${req.method} ${url.pathname}`;
-    const handler = this.routes.get(routeKey);
-    if (handler) {
-      try {
-        const result = handler(req, res, url.searchParams);
-        if (result instanceof Promise) {
-          result.catch((err) => {
-            this.json(res, { error: err.message }, 500);
-          });
-        }
-      } catch (err) {
-        this.json(res, { error: err.message }, 500);
-      }
-    } else {
-      this.json(res, { error: "Not found", path: url.pathname }, 404);
-    }
-  }
-  setCorsHeaders(req, res) {
-    const origin = req.headers.origin;
-    if (this.allowedOrigins && this.allowedOrigins.length > 0) {
-      if (origin && this.allowedOrigins.includes(origin)) {
-        res.setHeader("Access-Control-Allow-Origin", origin);
-        res.setHeader("Vary", "Origin");
-      }
-    } else {
-      res.setHeader("Access-Control-Allow-Origin", "*");
-    }
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
-  }
-  json(res, data, status = 200) {
-    res.writeHead(status, { "Content-Type": "application/json" });
-    res.end(JSON.stringify(data));
-  }
-};
-function numParam(params, key) {
-  const val = params.get(key);
-  if (!val) return void 0;
-  const num = parseInt(val, 10);
-  return isNaN(num) ? void 0 : num;
-}
 export {
   ApiDiscoveryEngine,
   AuthManager,
@@ -3785,7 +2072,9 @@ export {
   EventStore,
   HttpServer,
   InfraConnector,
+  PmStore,
   ProcessMonitor,
+  ProjectDiscovery,
   ProjectManager,
   Redactor,
   RingBuffer,
@@ -3794,6 +2083,8 @@ export {
   SessionRateLimiter,
   SqliteStore,
   aggregateQueryStats,
+  calculateActiveMinutes,
+  calculateCostMicrodollars,
   compareSessions,
   detectIssues,
   detectN1Queries,
@@ -3801,6 +2092,7 @@ export {
   detectSlowQueries,
   generateApiKey,
   loadTlsOptions,
+  parseSessionJsonl,
   resolveTlsConfig,
   suggestIndexes
 };