browsertrack 0.0.1 → 0.1.0

package/dist/chunk-BSKNG4V7.js

@@ -0,0 +1,1199 @@
+// packages/daemon/src/config.ts
+import os from "os";
+import path from "path";
+function getDaemonConfig(overrides = {}) {
+  const homeDir = os.homedir();
+  const dataDir = overrides.dataDir || path.join(homeDir, ".browsertrack");
+  const dbPath = overrides.dbPath || path.join(dataDir, "browsertrack.db");
+  const screenshotsDir = overrides.screenshotsDir || path.join(dataDir, "projects");
+  return {
+    host: overrides.host || "127.0.0.1",
+    port: overrides.port || 7331,
+    dataDir,
+    dbPath,
+    screenshotsDir,
+    maxEventsPerSession: overrides.maxEventsPerSession || 1e3,
+    verbose: !!overrides.verbose
+  };
+}
+
+// packages/daemon/src/storage/db.ts
+import Database from "better-sqlite3";
+import fs from "fs";
+import path2 from "path";
+var StorageDB = class {
+  db;
+  constructor(dbPath) {
+    const dir = path2.dirname(dbPath);
+    fs.mkdirSync(dir, { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("synchronous = NORMAL");
+    this.initTables();
+  }
+  initTables() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS projects (
+        id TEXT PRIMARY KEY,
+        name TEXT UNIQUE,
+        origin TEXT,
+        path TEXT,
+        created_at TEXT,
+        updated_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        origin TEXT,
+        url TEXT,
+        title TEXT,
+        user_agent TEXT,
+        connected_at TEXT,
+        last_seen_at TEXT,
+        active INTEGER DEFAULT 1
+      );
+
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        session_id TEXT,
+        event_type TEXT,
+        payload TEXT,
+        timestamp INTEGER,
+        route TEXT,
+        url TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS incidents (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        session_id TEXT,
+        type TEXT,
+        severity TEXT,
+        message TEXT,
+        source_file TEXT,
+        source_line INTEGER,
+        source_col INTEGER,
+        fingerprint TEXT UNIQUE,
+        route TEXT,
+        first_seen TEXT,
+        last_seen TEXT,
+        occurrences INTEGER DEFAULT 1,
+        status TEXT DEFAULT 'OPEN',
+        stack TEXT,
+        breadcrumbs TEXT,
+        network_failures TEXT,
+        last_element TEXT,
+        screenshot_path TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS incident_occurrences (
+        id TEXT PRIMARY KEY,
+        incident_id TEXT,
+        session_id TEXT,
+        timestamp TEXT,
+        route TEXT,
+        url TEXT,
+        stack TEXT,
+        breadcrumbs TEXT,
+        last_element TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS screenshots (
+        id TEXT PRIMARY KEY,
+        incident_id TEXT,
+        file_path TEXT,
+        format TEXT,
+        width INTEGER,
+        height INTEGER,
+        created_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS verifications (
+        id TEXT PRIMARY KEY,
+        incident_id TEXT,
+        status TEXT,
+        checks TEXT,
+        before_screenshot TEXT,
+        after_screenshot TEXT,
+        message TEXT,
+        created_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS notes (
+        id TEXT PRIMARY KEY,
+        project_id TEXT,
+        session_id TEXT,
+        type TEXT,
+        message TEXT,
+        route TEXT,
+        url TEXT,
+        viewport_json TEXT,
+        scroll_json TEXT,
+        target_json TEXT,
+        element_context_json TEXT,
+        region_json TEXT,
+        screenshot_path TEXT,
+        incident_id TEXT,
+        status TEXT DEFAULT 'OPEN',
+        created_at TEXT,
+        updated_at TEXT,
+        resolved_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS note_verifications (
+        id TEXT PRIMARY KEY,
+        note_id TEXT,
+        status TEXT,
+        checks TEXT,
+        geometry_diff TEXT,
+        before_screenshot TEXT,
+        after_screenshot TEXT,
+        message TEXT,
+        created_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_events_session ON events(session_id, timestamp);
+      CREATE INDEX IF NOT EXISTS idx_incidents_project ON incidents(project_id, status);
+      CREATE INDEX IF NOT EXISTS idx_incidents_fp ON incidents(fingerprint);
+      CREATE INDEX IF NOT EXISTS idx_notes_project ON notes(project_id, status);
+    `);
+  }
+  // --- PROJECTS ---
+  upsertProject(project) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.db.prepare("SELECT * FROM projects WHERE name = ? OR origin = ?").get(project.name, project.origin);
+    if (existing) {
+      this.db.prepare("UPDATE projects SET name = ?, origin = ?, path = COALESCE(?, path), updated_at = ? WHERE id = ?").run(project.name, project.origin, project.path || null, now, existing.id);
+      return {
+        id: existing.id,
+        name: project.name,
+        origin: project.origin,
+        path: project.path || existing.path,
+        createdAt: existing.created_at,
+        updatedAt: now
+      };
+    }
+    this.db.prepare("INSERT INTO projects (id, name, origin, path, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)").run(project.id, project.name, project.origin, project.path || null, now, now);
+    return {
+      id: project.id,
+      name: project.name,
+      origin: project.origin,
+      path: project.path,
+      createdAt: now,
+      updatedAt: now
+    };
+  }
+  getProject(idOrName) {
+    const row = this.db.prepare("SELECT * FROM projects WHERE id = ? OR name = ?").get(idOrName, idOrName);
+    if (!row) return null;
+    return {
+      id: row.id,
+      name: row.name,
+      origin: row.origin,
+      path: row.path,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  getProjectByOrigin(origin) {
+    const row = this.db.prepare("SELECT * FROM projects WHERE origin = ?").get(origin);
+    if (!row) return null;
+    return {
+      id: row.id,
+      name: row.name,
+      origin: row.origin,
+      path: row.path,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    };
+  }
+  listProjects() {
+    const rows = this.db.prepare("SELECT * FROM projects ORDER BY updated_at DESC").all();
+    return rows.map((row) => ({
+      id: row.id,
+      name: row.name,
+      origin: row.origin,
+      path: row.path,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at
+    }));
+  }
+  // --- SESSIONS ---
+  upsertSession(session) {
+    const existing = this.db.prepare("SELECT id FROM sessions WHERE id = ?").get(session.id);
+    if (existing) {
+      this.db.prepare("UPDATE sessions SET url = ?, title = ?, last_seen_at = ?, active = ? WHERE id = ?").run(session.url, session.title, session.lastSeenAt, session.active ? 1 : 0, session.id);
+    } else {
+      this.db.prepare(
+        "INSERT INTO sessions (id, project_id, origin, url, title, user_agent, connected_at, last_seen_at, active) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+      ).run(
+        session.id,
+        session.projectId,
+        session.origin,
+        session.url,
+        session.title,
+        session.userAgent,
+        session.connectedAt,
+        session.lastSeenAt,
+        session.active ? 1 : 0
+      );
+    }
+  }
+  getSession(id) {
+    const row = this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);
+    if (!row) return null;
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      origin: row.origin,
+      url: row.url,
+      title: row.title,
+      userAgent: row.user_agent,
+      connectedAt: row.connected_at,
+      lastSeenAt: row.last_seen_at,
+      active: row.active === 1
+    };
+  }
+  listSessions(projectId, activeOnly = false) {
+    let sql = "SELECT * FROM sessions WHERE 1=1";
+    const params = [];
+    if (projectId) {
+      sql += " AND project_id = ?";
+      params.push(projectId);
+    }
+    if (activeOnly) {
+      sql += " AND active = 1";
+    }
+    sql += " ORDER BY last_seen_at DESC";
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      id: row.id,
+      projectId: row.project_id,
+      origin: row.origin,
+      url: row.url,
+      title: row.title,
+      userAgent: row.user_agent,
+      connectedAt: row.connected_at,
+      lastSeenAt: row.last_seen_at,
+      active: row.active === 1
+    }));
+  }
+  deactivateSession(id) {
+    this.db.prepare("UPDATE sessions SET active = 0, last_seen_at = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), id);
+  }
+  // --- EVENTS & RETENTION ---
+  insertEvent(event) {
+    this.db.prepare("INSERT INTO events (id, session_id, event_type, payload, timestamp, route, url) VALUES (?, ?, ?, ?, ?, ?, ?)").run(
+      event.id,
+      event.sessionId,
+      event.eventType,
+      JSON.stringify(event.payload),
+      event.timestamp,
+      event.route || "",
+      event.url || ""
+    );
+  }
+  pruneSessionEvents(sessionId, maxEvents = 1e3) {
+    this.db.prepare(
+      `DELETE FROM events 
+         WHERE session_id = ? AND id NOT IN (
+           SELECT id FROM events WHERE session_id = ? ORDER BY timestamp DESC LIMIT ?
+         )`
+    ).run(sessionId, sessionId, maxEvents);
+  }
+  getEvents(options) {
+    let sql = "SELECT * FROM events WHERE 1=1";
+    const params = [];
+    if (options.sessionId) {
+      sql += " AND session_id = ?";
+      params.push(options.sessionId);
+    }
+    if (options.eventType) {
+      sql += " AND event_type = ?";
+      params.push(options.eventType);
+    }
+    sql += " ORDER BY timestamp DESC LIMIT ?";
+    params.push(options.limit || 50);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => ({
+      id: r.id,
+      sessionId: r.session_id,
+      eventType: r.event_type,
+      payload: JSON.parse(r.payload),
+      timestamp: r.timestamp,
+      route: r.route,
+      url: r.url
+    }));
+  }
+  // --- INCIDENTS ---
+  findIncidentByFingerprint(fingerprint) {
+    const row = this.db.prepare("SELECT * FROM incidents WHERE fingerprint = ?").get(fingerprint);
+    if (!row) return null;
+    return this.mapIncidentRow(row);
+  }
+  getIncident(id) {
+    const row = this.db.prepare("SELECT * FROM incidents WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.mapIncidentRow(row);
+  }
+  listIncidents(options = {}) {
+    let sql = "SELECT * FROM incidents WHERE 1=1";
+    const params = [];
+    if (options.projectId) {
+      sql += " AND project_id = ?";
+      params.push(options.projectId);
+    }
+    if (options.status) {
+      sql += " AND status = ?";
+      params.push(options.status);
+    }
+    if (options.severity) {
+      sql += " AND severity = ?";
+      params.push(options.severity);
+    }
+    sql += " ORDER BY last_seen DESC LIMIT ?";
+    params.push(options.limit || 50);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => this.mapIncidentRow(r));
+  }
+  insertIncident(incident) {
+    this.db.prepare(
+      `INSERT INTO incidents (
+          id, project_id, session_id, type, severity, message, source_file, source_line, source_col,
+          fingerprint, route, first_seen, last_seen, occurrences, status, stack, breadcrumbs,
+          network_failures, last_element, screenshot_path
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      incident.id,
+      incident.projectId,
+      incident.sessionId,
+      incident.type,
+      incident.severity,
+      incident.message,
+      incident.source.file,
+      incident.source.line,
+      incident.source.column || null,
+      incident.fingerprint,
+      incident.route,
+      incident.firstSeen,
+      incident.lastSeen,
+      incident.occurrences,
+      incident.status,
+      incident.stack || null,
+      JSON.stringify(incident.breadcrumbs || []),
+      JSON.stringify(incident.networkFailures || []),
+      incident.lastElement ? JSON.stringify(incident.lastElement) : null,
+      incident.screenshots?.error || null
+    );
+  }
+  updateIncidentOccurrence(incidentId, update) {
+    this.db.prepare(
+      `UPDATE incidents 
+         SET session_id = ?, last_seen = ?, occurrences = ?, route = ?, breadcrumbs = ?, last_element = COALESCE(?, last_element), stack = COALESCE(?, stack)
+         WHERE id = ?`
+    ).run(
+      update.sessionId,
+      update.lastSeen,
+      update.occurrences,
+      update.route,
+      JSON.stringify(update.breadcrumbs || []),
+      update.lastElement ? JSON.stringify(update.lastElement) : null,
+      update.stack || null,
+      incidentId
+    );
+  }
+  updateIncidentStatus(id, status) {
+    this.db.prepare("UPDATE incidents SET status = ? WHERE id = ?").run(status, id);
+  }
+  insertIncidentOccurrence(occurrence) {
+    this.db.prepare(
+      `INSERT INTO incident_occurrences (id, incident_id, session_id, timestamp, route, url, stack, breadcrumbs, last_element)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      occurrence.id,
+      occurrence.incidentId,
+      occurrence.sessionId,
+      occurrence.timestamp,
+      occurrence.route,
+      occurrence.url,
+      occurrence.stack || null,
+      JSON.stringify(occurrence.breadcrumbs || []),
+      occurrence.lastElement ? JSON.stringify(occurrence.lastElement) : null
+    );
+  }
+  // --- VERIFICATIONS ---
+  insertVerification(v) {
+    this.db.prepare(
+      `INSERT INTO verifications (id, incident_id, status, checks, before_screenshot, after_screenshot, message, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      v.id,
+      v.incidentId,
+      v.status,
+      JSON.stringify(v.checks),
+      v.beforeScreenshot || null,
+      v.afterScreenshot || null,
+      v.message || null,
+      v.createdAt
+    );
+  }
+  getLatestVerification(incidentId) {
+    const row = this.db.prepare("SELECT * FROM verifications WHERE incident_id = ? ORDER BY created_at DESC LIMIT 1").get(incidentId);
+    if (!row) return null;
+    return {
+      incidentId: row.incident_id,
+      status: row.status,
+      checks: JSON.parse(row.checks || "[]"),
+      screenshots: {
+        before: row.before_screenshot || void 0,
+        after: row.after_screenshot || void 0
+      },
+      timestamp: row.created_at,
+      message: row.message || void 0
+    };
+  }
+  // --- VISUAL NOTES ---
+  insertNote(note) {
+    this.db.prepare(
+      `INSERT INTO notes (
+          id, project_id, session_id, type, message, route, url,
+          viewport_json, scroll_json, target_json, element_context_json, region_json,
+          screenshot_path, incident_id, status, created_at, updated_at, resolved_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      note.id,
+      note.projectId,
+      note.sessionId,
+      note.type,
+      note.message,
+      note.route,
+      note.url,
+      JSON.stringify(note.viewport),
+      JSON.stringify(note.scroll),
+      note.target ? JSON.stringify(note.target) : null,
+      note.elementContext ? JSON.stringify(note.elementContext) : null,
+      note.region ? JSON.stringify(note.region) : null,
+      note.screenshots?.original || null,
+      note.incidentId || null,
+      note.status,
+      note.createdAt,
+      note.updatedAt,
+      note.resolvedAt || null
+    );
+  }
+  getNote(id) {
+    const row = this.db.prepare("SELECT * FROM notes WHERE id = ?").get(id);
+    if (!row) return null;
+    return this.mapNoteRow(row);
+  }
+  listNotes(options = {}) {
+    let sql = "SELECT * FROM notes WHERE 1=1";
+    const params = [];
+    if (options.projectId) {
+      sql += " AND project_id = ?";
+      params.push(options.projectId);
+    }
+    if (options.status) {
+      sql += " AND status = ?";
+      params.push(options.status);
+    }
+    sql += " ORDER BY created_at DESC LIMIT ?";
+    params.push(options.limit || 50);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((r) => this.mapNoteRow(r));
+  }
+  updateNoteStatus(id, status) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const resolvedAt = status === "RESOLVED" ? now : null;
+    this.db.prepare("UPDATE notes SET status = ?, updated_at = ?, resolved_at = COALESCE(?, resolved_at) WHERE id = ?").run(status, now, resolvedAt, id);
+  }
+  updateNote(id, updates) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const current = this.getNote(id);
+    if (!current) return;
+    this.db.prepare(
+      `UPDATE notes 
+         SET message = COALESCE(?, message), status = COALESCE(?, status),
+             screenshot_path = COALESCE(?, screenshot_path), updated_at = ?
+         WHERE id = ?`
+    ).run(
+      updates.message || null,
+      updates.status || null,
+      updates.screenshots?.original || updates.screenshots?.after || null,
+      now,
+      id
+    );
+  }
+  insertNoteVerification(v) {
+    this.db.prepare(
+      `INSERT INTO note_verifications (
+          id, note_id, status, checks, geometry_diff, before_screenshot, after_screenshot, message, created_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      `nver_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+      v.noteId,
+      v.status,
+      JSON.stringify(v.checks),
+      v.geometryDiff ? JSON.stringify(v.geometryDiff) : null,
+      v.screenshots?.before || null,
+      v.screenshots?.after || null,
+      v.message || null,
+      v.timestamp
+    );
+  }
+  getLatestNoteVerification(noteId) {
+    const row = this.db.prepare("SELECT * FROM note_verifications WHERE note_id = ? ORDER BY created_at DESC LIMIT 1").get(noteId);
+    if (!row) return null;
+    return {
+      noteId: row.note_id,
+      status: row.status,
+      checks: JSON.parse(row.checks || "[]"),
+      geometryDiff: row.geometry_diff ? JSON.parse(row.geometry_diff) : void 0,
+      screenshots: {
+        before: row.before_screenshot || void 0,
+        after: row.after_screenshot || void 0
+      },
+      timestamp: row.created_at,
+      message: row.message || void 0
+    };
+  }
+  clearAll() {
+    this.db.exec(`
+      DELETE FROM events;
+      DELETE FROM incident_occurrences;
+      DELETE FROM incidents;
+      DELETE FROM screenshots;
+      DELETE FROM verifications;
+      DELETE FROM notes;
+      DELETE FROM note_verifications;
+      DELETE FROM sessions;
+    `);
+  }
+  mapIncidentRow(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      sessionId: row.session_id,
+      type: row.type,
+      severity: row.severity,
+      message: row.message,
+      source: {
+        file: row.source_file,
+        line: row.source_line,
+        column: row.source_col || void 0
+      },
+      fingerprint: row.fingerprint,
+      route: row.route,
+      firstSeen: row.first_seen,
+      lastSeen: row.last_seen,
+      occurrences: row.occurrences,
+      status: row.status,
+      stack: row.stack || void 0,
+      breadcrumbs: JSON.parse(row.breadcrumbs || "[]"),
+      networkFailures: JSON.parse(row.network_failures || "[]"),
+      lastElement: row.last_element ? JSON.parse(row.last_element) : void 0,
+      screenshots: row.screenshot_path ? {
+        error: row.screenshot_path
+      } : void 0
+    };
+  }
+  mapNoteRow(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      sessionId: row.session_id,
+      type: row.type,
+      message: row.message,
+      route: row.route,
+      url: row.url,
+      viewport: JSON.parse(row.viewport_json || "{}"),
+      scroll: JSON.parse(row.scroll_json || "{}"),
+      target: row.target_json ? JSON.parse(row.target_json) : void 0,
+      elementContext: row.element_context_json ? JSON.parse(row.element_context_json) : void 0,
+      region: row.region_json ? JSON.parse(row.region_json) : void 0,
+      status: row.status,
+      incidentId: row.incident_id || void 0,
+      screenshots: row.screenshot_path ? {
+        original: row.screenshot_path
+      } : void 0,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      resolvedAt: row.resolved_at || void 0
+    };
+  }
+  close() {
+    this.db.close();
+  }
+};
+
+// packages/daemon/src/storage/screenshot-store.ts
+import fs2 from "fs";
+import path3 from "path";
+var ScreenshotStore = class {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+    fs2.mkdirSync(this.baseDir, { recursive: true });
+  }
+  saveScreenshot(projectId, incidentId, name, dataUrl) {
+    try {
+      if (!dataUrl || !dataUrl.startsWith("data:image/")) return null;
+      const match = dataUrl.match(/^data:image\/([a-zA-Z0-9+]+);base64,(.+)$/);
+      if (!match) return null;
+      let format = match[1].toLowerCase();
+      if (format === "jpeg") format = "jpg";
+      const base64Data = match[2];
+      const buffer = Buffer.from(base64Data, "base64");
+      const targetDir = path3.join(this.baseDir, projectId || "default", "incidents", incidentId);
+      fs2.mkdirSync(targetDir, { recursive: true });
+      const fileName = `${name}.${format}`;
+      const filePath = path3.join(targetDir, fileName);
+      fs2.writeFileSync(filePath, buffer);
+      return { filePath, format };
+    } catch {
+      return null;
+    }
+  }
+  getScreenshotPath(projectId, incidentId, name) {
+    const targetDir = path3.join(this.baseDir, projectId || "default", "incidents", incidentId);
+    if (!fs2.existsSync(targetDir)) return null;
+    const files = fs2.readdirSync(targetDir);
+    const match = files.find((f) => f.startsWith(`${name}.`));
+    if (match) {
+      return path3.join(targetDir, match);
+    }
+    return null;
+  }
+};
+
+// packages/daemon/src/session/manager.ts
+var SessionManager = class {
+  activeSockets = /* @__PURE__ */ new Map();
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  registerSocket(sessionId, ws, origin, projectId) {
+    this.activeSockets.set(sessionId, {
+      sessionId,
+      ws,
+      origin,
+      projectId,
+      pendingCommands: /* @__PURE__ */ new Map()
+    });
+  }
+  unregisterSocket(sessionId) {
+    const active = this.activeSockets.get(sessionId);
+    if (active) {
+      for (const pending of active.pendingCommands.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("Session disconnected before command completed"));
+      }
+      active.pendingCommands.clear();
+      this.activeSockets.delete(sessionId);
+      this.db.deactivateSession(sessionId);
+    }
+  }
+  handleCommandResponse(sessionId, response) {
+    const active = this.activeSockets.get(sessionId);
+    if (!active) return;
+    const pending = active.pendingCommands.get(response.id);
+    if (pending) {
+      clearTimeout(pending.timer);
+      active.pendingCommands.delete(response.id);
+      pending.resolve(response);
+    }
+  }
+  async sendCommand(sessionId, command, timeoutMs = 5e3) {
+    const active = this.activeSockets.get(sessionId);
+    if (!active || active.ws.readyState !== 1) {
+      return {
+        id: command.id,
+        ok: false,
+        error: `Session ${sessionId} is not actively connected`
+      };
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        active.pendingCommands.delete(command.id);
+        resolve({
+          id: command.id,
+          ok: false,
+          error: `Command ${command.type} timed out after ${timeoutMs}ms`
+        });
+      }, timeoutMs);
+      active.pendingCommands.set(command.id, {
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        active.ws.send(
+          JSON.stringify({
+            type: "command",
+            command
+          })
+        );
+      } catch (err) {
+        clearTimeout(timer);
+        active.pendingCommands.delete(command.id);
+        resolve({
+          id: command.id,
+          ok: false,
+          error: err?.message || "Failed to send command over WebSocket"
+        });
+      }
+    });
+  }
+  getActiveSessionForProject(projectId) {
+    for (const active of this.activeSockets.values()) {
+      if (active.projectId === projectId) {
+        return this.db.getSession(active.sessionId);
+      }
+    }
+    return null;
+  }
+  getAnyActiveSession() {
+    const first = this.activeSockets.keys().next().value;
+    if (!first) return null;
+    return this.db.getSession(first);
+  }
+  getActiveCount() {
+    return this.activeSockets.size;
+  }
+};
+
+// packages/daemon/src/notes/engine.ts
+import crypto from "crypto";
+import path4 from "path";
+import fs3 from "fs";
+var NotesEngine = class {
+  db;
+  screenshotStore;
+  constructor(db, screenshotStore) {
+    this.db = db;
+    this.screenshotStore = screenshotStore;
+  }
+  createNoteFromClient(payload) {
+    const session = this.db.getSession(payload.sessionId);
+    const projectId = session?.projectId || "default";
+    const noteId = `note_${crypto.randomUUID().slice(0, 8)}`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    let screenshotPath;
+    if (payload.screenshot) {
+      const saved = this.saveNoteScreenshot(projectId, noteId, "original", payload.screenshot);
+      if (saved) {
+        screenshotPath = saved;
+      }
+    }
+    const note = {
+      id: noteId,
+      projectId,
+      sessionId: payload.sessionId,
+      type: payload.noteType || "element",
+      message: payload.message,
+      route: payload.route || "/",
+      url: payload.url || "",
+      viewport: payload.viewport || { width: 1280, height: 800, devicePixelRatio: 1 },
+      scroll: payload.scroll || { scrollX: 0, scrollY: 0 },
+      target: payload.target,
+      elementContext: payload.elementContext,
+      region: payload.region,
+      status: "OPEN",
+      incidentId: payload.incidentId,
+      screenshots: screenshotPath ? { original: screenshotPath } : void 0,
+      createdAt: now,
+      updatedAt: now
+    };
+    this.db.insertNote(note);
+    return note;
+  }
+  saveNoteScreenshot(projectId, noteId, name, dataUrl) {
+    try {
+      if (!dataUrl || !dataUrl.startsWith("data:image/")) return null;
+      const match = dataUrl.match(/^data:image\/([a-zA-Z0-9+]+);base64,(.+)$/);
+      if (!match) return null;
+      let format = match[1].toLowerCase();
+      if (format === "jpeg") format = "jpg";
+      const base64Data = match[2];
+      const buffer = Buffer.from(base64Data, "base64");
+      const targetDir = path4.join(this.screenshotStore.baseDir, projectId || "default", "notes", noteId);
+      fs3.mkdirSync(targetDir, { recursive: true });
+      const fileName = `${name}.${format}`;
+      const filePath = path4.join(targetDir, fileName);
+      fs3.writeFileSync(filePath, buffer);
+      return filePath;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// packages/daemon/src/notes/verification.ts
+import crypto2 from "crypto";
+var NoteVerificationEngine = class {
+  db;
+  sessionManager;
+  notesEngine;
+  constructor(db, sessionManager, notesEngine) {
+    this.db = db;
+    this.sessionManager = sessionManager;
+    this.notesEngine = notesEngine;
+  }
+  async verifyNote(noteId, options = {}) {
+    const note = this.db.getNote(noteId);
+    if (!note) {
+      return {
+        noteId,
+        status: "FAILED",
+        checks: [{ type: "note_exists", passed: false, details: `Note ${noteId} not found` }],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: `Note ${noteId} not found in database`
+      };
+    }
+    let session = this.sessionManager.getActiveSessionForProject(note.projectId);
+    if (!session) {
+      session = this.sessionManager.getAnyActiveSession();
+    }
+    if (!session) {
+      const result = {
+        noteId,
+        status: "INCONCLUSIVE",
+        checks: [],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: "No active browser session currently connected to verify visual note."
+      };
+      this.recordNoteVerification(result, note);
+      return result;
+    }
+    this.db.updateNoteStatus(noteId, "VERIFYING");
+    const pageStateCmd = await this.sessionManager.sendCommand(session.id, {
+      id: `cmd_${crypto2.randomUUID().slice(0, 8)}`,
+      type: "get_page_state"
+    });
+    const currentRoute = pageStateCmd.result?.route || "/";
+    const isRouteMatch = currentRoute === note.route || currentRoute.startsWith(note.route);
+    if (!isRouteMatch && note.route) {
+      await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto2.randomUUID().slice(0, 8)}`,
+        type: "navigate",
+        params: { url: note.route }
+      });
+      await new Promise((r) => setTimeout(r, options.observationWindowMs || 1e3));
+    }
+    const checks = [];
+    checks.push({
+      type: "route_loaded",
+      passed: true,
+      details: `Route ${note.route || "/"} loaded`
+    });
+    const targetSelector = note.target?.selector || (note.type === "page" ? "body" : "body");
+    let elementExists = true;
+    let elementVisible = true;
+    let currentRect;
+    let overflowResult;
+    if (note.type === "element" && targetSelector) {
+      const queryCmd = await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto2.randomUUID().slice(0, 8)}`,
+        type: "query_element",
+        params: { selector: targetSelector }
+      });
+      elementExists = queryCmd.ok && !!queryCmd.result?.exists;
+      elementVisible = queryCmd.ok && !!queryCmd.result?.visible;
+      currentRect = queryCmd.result?.boundingRect;
+      checks.push({
+        type: "element_exists",
+        passed: elementExists,
+        details: elementExists ? `Element ${targetSelector} exists in DOM` : `Element ${targetSelector} not found`
+      });
+      checks.push({
+        type: "element_visible",
+        passed: elementVisible,
+        details: elementVisible ? `Element ${targetSelector} is visible` : `Element ${targetSelector} is hidden`
+      });
+      const overflowCmd = await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto2.randomUUID().slice(0, 8)}`,
+        type: "check_overflow",
+        params: { selector: targetSelector }
+      });
+      if (overflowCmd.ok && overflowCmd.result) {
+        const ovf = overflowCmd.result;
+        overflowResult = ovf;
+        const isOverflowingNow = !!ovf.overflow;
+        checks.push({
+          type: "no_viewport_overflow",
+          passed: !isOverflowingNow,
+          details: !isOverflowingNow ? `Element fits within viewport (width: ${ovf.viewportWidth}px, rect right: ${ovf.rect?.right}px)` : `Element overflows viewport by ${ovf.overflowRightPx}px (rect right: ${ovf.rect?.right}px, viewport: ${ovf.viewportWidth}px)`
+        });
+      }
+    }
+    let afterScreenshotPath;
+    const captureCmd = await this.sessionManager.sendCommand(session.id, {
+      id: `cmd_${crypto2.randomUUID().slice(0, 8)}`,
+      type: "capture_element",
+      params: { selector: targetSelector }
+    });
+    if (captureCmd.ok && captureCmd.result?.dataUrl) {
+      const saved = this.notesEngine.saveNoteScreenshot(note.projectId, note.id, "after", captureCmd.result.dataUrl);
+      if (saved) {
+        afterScreenshotPath = saved;
+      }
+    }
+    const beforeRect = note.target?.boundingRect;
+    const overflowFixed = overflowResult ? !overflowResult.overflow : void 0;
+    const geometryDiff = {
+      before: beforeRect,
+      current: currentRect || overflowResult?.rect,
+      viewportWidth: overflowResult?.viewportWidth || note.viewport.width,
+      overflowFixed,
+      overflowPx: overflowResult?.overflowRightPx || 0
+    };
+    const anyFailed = checks.some((c) => !c.passed);
+    let status = "VERIFIED";
+    if (anyFailed) {
+      status = "FAILED";
+    } else {
+      status = "VERIFIED";
+    }
+    const verificationResult = {
+      noteId,
+      status,
+      checks,
+      geometryDiff,
+      screenshots: {
+        before: note.screenshots?.original,
+        after: afterScreenshotPath
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message: status === "VERIFIED" ? "Visual note verified: target element is present, visible, and layout checks (including viewport overflow) passed." : "Visual note verification failed: target element missing, hidden, or still overflowing."
+    };
+    this.recordNoteVerification(verificationResult, note);
+    return verificationResult;
+  }
+  recordNoteVerification(result, note) {
+    this.db.updateNoteStatus(note.id, result.status);
+    this.db.insertNoteVerification(result);
+  }
+};
+
+// packages/daemon/src/verification/engine.ts
+import crypto3 from "crypto";
+var VerificationEngine = class {
+  db;
+  sessionManager;
+  screenshotStore;
+  constructor(db, sessionManager, screenshotStore) {
+    this.db = db;
+    this.sessionManager = sessionManager;
+    this.screenshotStore = screenshotStore;
+  }
+  async verifyIncident(incidentId, recipe) {
+    const incident = this.db.getIncident(incidentId);
+    if (!incident) {
+      return {
+        incidentId,
+        status: "FAILED",
+        checks: [{ type: "no_incident", passed: false, details: `Incident ${incidentId} not found` }],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: `Incident ${incidentId} not found in database`
+      };
+    }
+    let session = this.sessionManager.getActiveSessionForProject(incident.projectId);
+    if (!session) {
+      session = this.sessionManager.getAnyActiveSession();
+    }
+    if (!session) {
+      const result = {
+        incidentId,
+        status: "INCONCLUSIVE",
+        checks: [],
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: "No active browser session currently connected to verify the fix."
+      };
+      this.recordVerification(result, incident);
+      return result;
+    }
+    this.db.updateIncidentStatus(incidentId, "VERIFYING");
+    const baselineOccurrences = incident.occurrences;
+    const targetRoute = recipe?.route || incident.route;
+    const observationMs = recipe?.observationWindowMs || 2e3;
+    if (recipe?.route && recipe.route !== incident.route) {
+      await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+        type: "navigate",
+        params: { url: recipe.route }
+      });
+    } else {
+      await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+        type: "reload",
+        params: { force: true }
+      });
+    }
+    await new Promise((resolve) => setTimeout(resolve, observationMs));
+    const freshIncident = this.db.getIncident(incidentId);
+    const hasReoccurred = freshIncident ? freshIncident.occurrences > baselineOccurrences : false;
+    const checks = [];
+    checks.push({
+      type: "no_incident",
+      passed: !hasReoccurred,
+      details: hasReoccurred ? `Incident reoccurred (${freshIncident?.occurrences} occurrences vs baseline ${baselineOccurrences})` : "No recurring error observed during verification window"
+    });
+    const probes = recipe?.expect || [];
+    for (const probe of probes) {
+      const probeRes = await this.evaluateProbe(session.id, probe);
+      checks.push(probeRes);
+    }
+    let afterScreenshotPath;
+    const targetSelector = recipe?.targetSelector || incident.lastElement?.selector;
+    if (targetSelector) {
+      const captureCmd = await this.sessionManager.sendCommand(session.id, {
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+        type: "capture_element",
+        params: { selector: targetSelector }
+      });
+      if (captureCmd.ok && captureCmd.result?.dataUrl) {
+        const saved = this.screenshotStore.saveScreenshot(
+          incident.projectId,
+          incident.id,
+          "verified",
+          captureCmd.result.dataUrl
+        );
+        if (saved) {
+          afterScreenshotPath = saved.filePath;
+        }
+      }
+    }
+    let verdict = "VERIFIED";
+    const anyCheckFailed = checks.some((c) => !c.passed);
+    if (anyCheckFailed || hasReoccurred) {
+      verdict = "FAILED";
+    } else {
+      const wasInteractionError = incident.breadcrumbs.some((b) => b.type === "click" || b.type === "submit");
+      if (wasInteractionError && probes.length === 0) {
+        verdict = "INCONCLUSIVE";
+      }
+    }
+    const verificationResult = {
+      incidentId,
+      status: verdict,
+      checks,
+      screenshots: {
+        before: incident.screenshots?.error,
+        after: afterScreenshotPath
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message: verdict === "VERIFIED" ? "Fix verified: Error did not reoccur and all checks passed." : verdict === "FAILED" ? "Verification failed: Error reoccurred or probe expectation was not met." : "Verification inconclusive: Error did not appear on reload, but specific interaction may need manual verification or custom probes."
+    };
+    this.recordVerification(verificationResult, incident);
+    return verificationResult;
+  }
+  async evaluateProbe(sessionId, probe) {
+    try {
+      switch (probe.type) {
+        case "element_exists": {
+          if (!probe.selector) {
+            return { type: probe.type, passed: false, details: "Missing selector in probe" };
+          }
+          const res = await this.sessionManager.sendCommand(sessionId, {
+            id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+            type: "query_element",
+            params: { selector: probe.selector }
+          });
+          const exists = res.ok && !!res.result?.exists;
+          return {
+            type: probe.type,
+            passed: exists,
+            details: exists ? `Element ${probe.selector} exists in DOM` : `Element ${probe.selector} does not exist`
+          };
+        }
+        case "element_visible": {
+          if (!probe.selector) {
+            return { type: probe.type, passed: false, details: "Missing selector in probe" };
+          }
+          const res = await this.sessionManager.sendCommand(sessionId, {
+            id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+            type: "query_element",
+            params: { selector: probe.selector }
+          });
+          const visible = res.ok && !!res.result?.exists && !!res.result?.visible;
+          return {
+            type: probe.type,
+            passed: visible,
+            details: visible ? `Element ${probe.selector} is visible` : `Element ${probe.selector} is not visible`
+          };
+        }
+        case "text_contains": {
+          if (!probe.selector || !probe.text) {
+            return { type: probe.type, passed: false, details: "Missing selector or text in probe" };
+          }
+          const res = await this.sessionManager.sendCommand(sessionId, {
+            id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+            type: "query_element",
+            params: { selector: probe.selector }
+          });
+          const innerText = res.result?.innerText || "";
+          const contains = res.ok && innerText.includes(probe.text);
+          return {
+            type: probe.type,
+            passed: contains,
+            details: contains ? `Element ${probe.selector} contains text "${probe.text}"` : `Element text "${innerText}" did not contain "${probe.text}"`
+          };
+        }
+        case "route_is": {
+          if (!probe.route) {
+            return { type: probe.type, passed: false, details: "Missing route in probe" };
+          }
+          const res = await this.sessionManager.sendCommand(sessionId, {
+            id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+            type: "get_page_state"
+          });
+          const currentRoute = res.result?.route || "";
+          const matches = res.ok && (currentRoute === probe.route || currentRoute.startsWith(probe.route));
+          return {
+            type: probe.type,
+            passed: matches,
+            details: matches ? `Current route matches ${probe.route}` : `Current route is "${currentRoute}", expected "${probe.route}"`
+          };
+        }
+        default:
+          return {
+            type: probe.type,
+            passed: true,
+            details: `Probe ${probe.type} evaluated`
+          };
+      }
+    } catch (err) {
+      return {
+        type: probe.type,
+        passed: false,
+        details: err?.message || "Probe execution error"
+      };
+    }
+  }
+  recordVerification(result, incident) {
+    this.db.updateIncidentStatus(incident.id, result.status);
+    this.db.insertVerification({
+      id: `ver_${crypto3.randomUUID().slice(0, 8)}`,
+      incidentId: incident.id,
+      status: result.status,
+      checks: result.checks,
+      beforeScreenshot: result.screenshots?.before,
+      afterScreenshot: result.screenshots?.after,
+      message: result.message,
+      createdAt: result.timestamp
+    });
+  }
+};
+
+export {
+  getDaemonConfig,
+  StorageDB,
+  ScreenshotStore,
+  SessionManager,
+  NotesEngine,
+  NoteVerificationEngine,
+  VerificationEngine
+};
+//# sourceMappingURL=chunk-BSKNG4V7.js.map