browsertrack 0.2.0 → 0.2.2

package/dist/{chunk-3HOXPTM2.js → chunk-AYSVE6NG.js}

@@ -1,3 +1,12 @@
+import {
+  computeFingerprint,
+  extractSourceFromStack,
+  normalizeSourceFile,
+  redactSensitiveData,
+  safeJsonParse,
+  safeJsonStringify
+} from "./chunk-QRZ57ME3.js";
+
 // packages/daemon/src/config.ts
 import os from "os";
 import path from "path";
@@ -29,6 +38,7 @@ var StorageDB = class {
     this.db = new Database(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("synchronous = NORMAL");
+    this.db.pragma("busy_timeout = 5000");
     this.initTables();
   }
   initTables() {
@@ -160,18 +170,36 @@ var StorageDB = class {
       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);
-      CREATE INDEX IF NOT EXISTS idx_notes_scenario ON notes(scenario_id, step_number);
     `);
     try {
-      this.db.exec("ALTER TABLE notes ADD COLUMN scenario_id TEXT;");
-    } catch {
-    }
-    try {
-      this.db.exec("ALTER TABLE notes ADD COLUMN step_number INTEGER;");
+      const columns = this.db.prepare("PRAGMA table_info(notes)").all().map(
+        (c) => c.name
+      );
+      if (!columns.includes("scenario_id")) {
+        this.db.exec("ALTER TABLE notes ADD COLUMN scenario_id TEXT;");
+      }
+      if (!columns.includes("step_number")) {
+        this.db.exec("ALTER TABLE notes ADD COLUMN step_number INTEGER;");
+      }
+      if (!columns.includes("scenario_title")) {
+        this.db.exec("ALTER TABLE notes ADD COLUMN scenario_title TEXT;");
+      }
     } catch {
+      try {
+        this.db.exec("ALTER TABLE notes ADD COLUMN scenario_id TEXT;");
+      } catch {
+      }
+      try {
+        this.db.exec("ALTER TABLE notes ADD COLUMN step_number INTEGER;");
+      } catch {
+      }
+      try {
+        this.db.exec("ALTER TABLE notes ADD COLUMN scenario_title TEXT;");
+      } catch {
+      }
     }
     try {
-      this.db.exec("ALTER TABLE notes ADD COLUMN scenario_title TEXT;");
+      this.db.exec("CREATE INDEX IF NOT EXISTS idx_notes_scenario ON notes(scenario_id, step_number);");
     } catch {
     }
   }
@@ -336,7 +364,7 @@ var StorageDB = class {
       id: r.id,
       sessionId: r.session_id,
       eventType: r.event_type,
-      payload: JSON.parse(r.payload),
+      payload: safeJsonParse(r.payload, {}),
       timestamp: r.timestamp,
       route: r.route,
       url: r.url
@@ -397,9 +425,9 @@ var StorageDB = class {
       incident.occurrences,
       incident.status,
       incident.stack || null,
-      JSON.stringify(incident.breadcrumbs || []),
-      JSON.stringify(incident.networkFailures || []),
-      incident.lastElement ? JSON.stringify(incident.lastElement) : null,
+      safeJsonStringify(incident.breadcrumbs || []),
+      safeJsonStringify(incident.networkFailures || []),
+      incident.lastElement ? safeJsonStringify(incident.lastElement) : null,
       incident.screenshots?.error || null
     );
   }
@@ -413,8 +441,8 @@ var StorageDB = class {
       update.lastSeen,
       update.occurrences,
       update.route,
-      JSON.stringify(update.breadcrumbs || []),
-      update.lastElement ? JSON.stringify(update.lastElement) : null,
+      safeJsonStringify(update.breadcrumbs || []),
+      update.lastElement ? safeJsonStringify(update.lastElement) : null,
       update.stack || null,
       incidentId
     );
@@ -434,8 +462,8 @@ var StorageDB = class {
       occurrence.route,
       occurrence.url,
       occurrence.stack || null,
-      JSON.stringify(occurrence.breadcrumbs || []),
-      occurrence.lastElement ? JSON.stringify(occurrence.lastElement) : null
+      safeJsonStringify(occurrence.breadcrumbs || []),
+      occurrence.lastElement ? safeJsonStringify(occurrence.lastElement) : null
     );
   }
   // --- VERIFICATIONS ---
@@ -447,7 +475,7 @@ var StorageDB = class {
       v.id,
       v.incidentId,
       v.status,
-      JSON.stringify(v.checks),
+      safeJsonStringify(v.checks),
       v.beforeScreenshot || null,
       v.afterScreenshot || null,
       v.message || null,
@@ -460,7 +488,7 @@ var StorageDB = class {
     return {
       incidentId: row.incident_id,
       status: row.status,
-      checks: JSON.parse(row.checks || "[]"),
+      checks: safeJsonParse(row.checks, []),
       screenshots: {
         before: row.before_screenshot || void 0,
         after: row.after_screenshot || void 0
@@ -485,11 +513,11 @@ var StorageDB = class {
       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,
+      safeJsonStringify(note.viewport),
+      safeJsonStringify(note.scroll),
+      note.target ? safeJsonStringify(note.target) : null,
+      note.elementContext ? safeJsonStringify(note.elementContext) : null,
+      note.region ? safeJsonStringify(note.region) : null,
       note.screenshots?.original || null,
       note.incidentId || null,
       note.scenarioId || null,
@@ -630,8 +658,8 @@ var StorageDB = class {
       `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,
+      safeJsonStringify(v.checks),
+      v.geometryDiff ? safeJsonStringify(v.geometryDiff) : null,
       v.screenshots?.before || null,
       v.screenshots?.after || null,
       v.message || null,
@@ -644,8 +672,8 @@ var StorageDB = class {
     return {
       noteId: row.note_id,
       status: row.status,
-      checks: JSON.parse(row.checks || "[]"),
-      geometryDiff: row.geometry_diff ? JSON.parse(row.geometry_diff) : void 0,
+      checks: safeJsonParse(row.checks, []),
+      geometryDiff: safeJsonParse(row.geometry_diff, void 0),
       screenshots: {
         before: row.before_screenshot || void 0,
         after: row.after_screenshot || void 0
@@ -686,9 +714,9 @@ var StorageDB = class {
       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,
+      breadcrumbs: safeJsonParse(row.breadcrumbs, []),
+      networkFailures: safeJsonParse(row.network_failures, []),
+      lastElement: safeJsonParse(row.last_element, void 0),
       screenshots: row.screenshot_path ? {
         error: row.screenshot_path
       } : void 0
@@ -703,11 +731,11 @@ var StorageDB = class {
       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,
+      viewport: safeJsonParse(row.viewport_json, { width: 0, height: 0, devicePixelRatio: 1 }),
+      scroll: safeJsonParse(row.scroll_json, { scrollX: 0, scrollY: 0 }),
+      target: safeJsonParse(row.target_json, void 0),
+      elementContext: safeJsonParse(row.element_context_json, void 0),
+      region: safeJsonParse(row.region_json, void 0),
       status: row.status,
       incidentId: row.incident_id || void 0,
       scenarioId: row.scenario_id || void 0,
@@ -884,8 +912,167 @@ var SessionManager = class {
   }
 };
 
-// packages/daemon/src/notes/engine.ts
+// packages/daemon/src/incidents/engine.ts
 import crypto from "crypto";
+var IncidentEngine = class {
+  db;
+  screenshotStore;
+  constructor(db, screenshotStore) {
+    this.db = db;
+    this.screenshotStore = screenshotStore;
+  }
+  processClientEvent(message) {
+    const session = this.db.getSession(message.sessionId);
+    const projectId = session?.projectId || "default";
+    const sanitizedBreadcrumbs = (message.breadcrumbs || []).map((b) => redactSensitiveData(b));
+    const sanitizedLastElement = message.lastElement ? redactSensitiveData(message.lastElement) : void 0;
+    const networkFailures = sanitizedBreadcrumbs.filter((b) => (b.type === "fetch" || b.type === "xhr") && b.level === "error" && b.data).map((b) => ({
+      url: b.message.split(" ")[1] || "",
+      method: b.message.split(" ")[0] || "GET",
+      status: b.data?.status,
+      durationMs: b.data?.durationMs || 0,
+      error: b.data?.error,
+      aborted: b.data?.aborted,
+      timestamp: b.timestamp
+    }));
+    if (message.eventType === "runtime_error" || message.eventType === "unhandled_rejection") {
+      const payload = message.payload;
+      return this.handleErrorEvent({
+        projectId,
+        sessionId: message.sessionId,
+        type: payload.errorType || "runtime_exception",
+        severity: "error",
+        message: payload.message || "Unknown runtime error",
+        stack: payload.stack,
+        sourceFile: payload.filename,
+        line: payload.lineno,
+        column: payload.colno,
+        route: message.route || "/",
+        url: message.url,
+        breadcrumbs: sanitizedBreadcrumbs,
+        networkFailures,
+        lastElement: sanitizedLastElement,
+        screenshotDataUrl: message.screenshot
+      });
+    }
+    if (message.eventType === "console") {
+      const payload = message.payload;
+      if (payload.level === "error") {
+        return this.handleErrorEvent({
+          projectId,
+          sessionId: message.sessionId,
+          type: "console_error",
+          severity: "error",
+          message: payload.message,
+          stack: payload.stack,
+          route: message.route || "/",
+          url: message.url,
+          breadcrumbs: sanitizedBreadcrumbs,
+          networkFailures,
+          lastElement: sanitizedLastElement,
+          screenshotDataUrl: message.screenshot
+        });
+      }
+    }
+    return null;
+  }
+  handleErrorEvent(input) {
+    const extracted = (!input.sourceFile || !input.line) && input.stack ? extractSourceFromStack(input.stack) : null;
+    const rawSource = input.sourceFile || extracted?.file || "unknown_source";
+    const sourceFile = normalizeSourceFile(rawSource);
+    const line = input.line || extracted?.line || 0;
+    const column = input.column || extracted?.column;
+    const fingerprint = computeFingerprint({
+      type: input.type,
+      message: input.message,
+      sourceFile,
+      line,
+      column,
+      stack: input.stack
+    });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.db.findIncidentByFingerprint(fingerprint);
+    if (existing) {
+      const updatedOccurrences = existing.occurrences + 1;
+      this.db.updateIncidentOccurrence(existing.id, {
+        sessionId: input.sessionId,
+        lastSeen: now,
+        occurrences: updatedOccurrences,
+        route: input.route,
+        breadcrumbs: input.breadcrumbs,
+        lastElement: input.lastElement,
+        stack: input.stack
+      });
+      const occurrenceId = `occ_${crypto.randomUUID().slice(0, 8)}`;
+      this.db.insertIncidentOccurrence({
+        id: occurrenceId,
+        incidentId: existing.id,
+        sessionId: input.sessionId,
+        timestamp: now,
+        route: input.route,
+        url: input.url,
+        stack: input.stack,
+        breadcrumbs: input.breadcrumbs,
+        lastElement: input.lastElement
+      });
+      return {
+        ...existing,
+        occurrences: updatedOccurrences,
+        lastSeen: now,
+        breadcrumbs: input.breadcrumbs,
+        lastElement: input.lastElement || existing.lastElement
+      };
+    }
+    const incidentId = `inc_${crypto.randomUUID().slice(0, 8)}`;
+    let screenshotPath;
+    if (input.screenshotDataUrl) {
+      const saved = this.screenshotStore.saveScreenshot(input.projectId, incidentId, "error", input.screenshotDataUrl);
+      if (saved) {
+        screenshotPath = saved.filePath;
+      }
+    }
+    const newIncident = {
+      id: incidentId,
+      projectId: input.projectId,
+      sessionId: input.sessionId,
+      type: input.type,
+      severity: input.severity,
+      message: input.message,
+      source: {
+        file: sourceFile,
+        line,
+        column
+      },
+      fingerprint,
+      route: input.route,
+      firstSeen: now,
+      lastSeen: now,
+      occurrences: 1,
+      status: "OPEN",
+      stack: input.stack,
+      breadcrumbs: input.breadcrumbs,
+      networkFailures: input.networkFailures,
+      lastElement: input.lastElement,
+      screenshots: screenshotPath ? { error: screenshotPath } : void 0
+    };
+    this.db.insertIncident(newIncident);
+    this.db.insertIncidentOccurrence({
+      id: `occ_${crypto.randomUUID().slice(0, 8)}`,
+      incidentId,
+      sessionId: input.sessionId,
+      timestamp: now,
+      route: input.route,
+      url: input.url,
+      stack: input.stack,
+      breadcrumbs: input.breadcrumbs,
+      lastElement: input.lastElement
+    });
+    return newIncident;
+  }
+};
+
+// packages/daemon/src/notes/engine.ts
+import crypto2 from "crypto";
 import path4 from "path";
 import fs3 from "fs";
 var NotesEngine = class {
@@ -898,7 +1085,7 @@ var NotesEngine = class {
   createNoteFromClient(payload) {
     const session = this.db.getSession(payload.sessionId);
     const projectId = session?.projectId || "default";
-    const noteId = `note_${crypto.randomUUID().slice(0, 8)}`;
+    const noteId = `note_${crypto2.randomUUID().slice(0, 8)}`;
     const now = (/* @__PURE__ */ new Date()).toISOString();
     let screenshotPath;
     if (payload.screenshot) {
@@ -954,7 +1141,7 @@ var NotesEngine = class {
 };
 
 // packages/daemon/src/notes/verification.ts
-import crypto2 from "crypto";
+import crypto3 from "crypto";
 var NoteVerificationEngine = class {
   db;
   sessionManager;
@@ -992,14 +1179,14 @@ var NoteVerificationEngine = class {
     }
     this.db.updateNoteStatus(noteId, "VERIFYING");
     const pageStateCmd = await this.sessionManager.sendCommand(session.id, {
-      id: `cmd_${crypto2.randomUUID().slice(0, 8)}`,
+      id: `cmd_${crypto3.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)}`,
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
         type: "navigate",
         params: { url: note.route }
       });
@@ -1018,7 +1205,7 @@ var NoteVerificationEngine = class {
     let overflowResult;
     if (note.type === "element" && targetSelector) {
       const queryCmd = await this.sessionManager.sendCommand(session.id, {
-        id: `cmd_${crypto2.randomUUID().slice(0, 8)}`,
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
         type: "query_element",
         params: { selector: targetSelector }
       });
@@ -1036,7 +1223,7 @@ var NoteVerificationEngine = class {
         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)}`,
+        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
         type: "check_overflow",
         params: { selector: targetSelector }
       });
@@ -1053,7 +1240,7 @@ var NoteVerificationEngine = class {
     }
     let afterScreenshotPath;
     const captureCmd = await this.sessionManager.sendCommand(session.id, {
-      id: `cmd_${crypto2.randomUUID().slice(0, 8)}`,
+      id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
       type: "capture_element",
       params: { selector: targetSelector }
     });
@@ -1101,7 +1288,7 @@ var NoteVerificationEngine = class {
 };
 
 // packages/daemon/src/verification/engine.ts
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 var VerificationEngine = class {
   db;
   sessionManager;
@@ -1143,13 +1330,13 @@ var VerificationEngine = class {
     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)}`,
+        id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
         type: "navigate",
         params: { url: recipe.route }
       });
     } else {
       await this.sessionManager.sendCommand(session.id, {
-        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+        id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
         type: "reload",
         params: { force: true }
       });
@@ -1172,7 +1359,7 @@ var VerificationEngine = class {
     const targetSelector = recipe?.targetSelector || incident.lastElement?.selector;
     if (targetSelector) {
       const captureCmd = await this.sessionManager.sendCommand(session.id, {
-        id: `cmd_${crypto3.randomUUID().slice(0, 8)}`,
+        id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
         type: "capture_element",
         params: { selector: targetSelector }
       });
@@ -1220,7 +1407,7 @@ var VerificationEngine = class {
             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)}`,
+            id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
             type: "query_element",
             params: { selector: probe.selector }
           });
@@ -1236,7 +1423,7 @@ var VerificationEngine = class {
             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)}`,
+            id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
             type: "query_element",
             params: { selector: probe.selector }
           });
@@ -1252,7 +1439,7 @@ var VerificationEngine = class {
             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)}`,
+            id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
             type: "query_element",
             params: { selector: probe.selector }
           });
@@ -1269,7 +1456,7 @@ var VerificationEngine = class {
             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)}`,
+            id: `cmd_${crypto4.randomUUID().slice(0, 8)}`,
             type: "get_page_state"
           });
           const currentRoute = res.result?.route || "";
@@ -1298,7 +1485,7 @@ var VerificationEngine = class {
   recordVerification(result, incident) {
     this.db.updateIncidentStatus(incident.id, result.status);
     this.db.insertVerification({
-      id: `ver_${crypto3.randomUUID().slice(0, 8)}`,
+      id: `ver_${crypto4.randomUUID().slice(0, 8)}`,
       incidentId: incident.id,
       status: result.status,
       checks: result.checks,
@@ -1310,13 +1497,581 @@ var VerificationEngine = class {
   }
 };
 
+// packages/daemon/src/server/http.ts
+import fs4 from "fs";
+import path5 from "path";
+import { fileURLToPath } from "url";
+function readJsonBody(req, res, maxSizeBytes = 10 * 1024 * 1024) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    let isTooLarge = false;
+    req.on("data", (chunk) => {
+      if (isTooLarge) return;
+      body += chunk;
+      if (body.length > maxSizeBytes) {
+        isTooLarge = true;
+        if (!res.headersSent) {
+          res.writeHead(413, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Payload too large" }));
+        }
+        req.destroy();
+        reject(new Error("Payload too large"));
+      }
+    });
+    req.on("end", () => {
+      if (isTooLarge) return;
+      try {
+        const parsed = body ? JSON.parse(body) : {};
+        resolve(parsed);
+      } catch (err) {
+        if (!res.headersSent) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Malformed JSON payload" }));
+        }
+        reject(err);
+      }
+    });
+    req.on("error", (err) => {
+      reject(err);
+    });
+  });
+}
+function createHttpHandler(db, sessionManager, baseScreenshotsDir, verificationEngine, noteVerificationEngine) {
+  return async (req, res) => {
+    try {
+      const parsedUrl = new URL(req.url || "/", `http://${req.headers.host || "127.0.0.1"}`);
+      const pathname = parsedUrl.pathname;
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+      if (pathname === "/health" || pathname === "/") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            status: "ok",
+            name: "browsertrack",
+            version: "0.1.0",
+            activeSessions: sessionManager.getActiveCount(),
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+        return;
+      }
+      if (pathname === "/client.js" || pathname === "/browserdiag.js") {
+        let scriptContent = "";
+        try {
+          const __filename = fileURLToPath(import.meta.url);
+          const __dirname = path5.dirname(__filename);
+          const candidatePaths = [
+            path5.resolve(__dirname, "../client.iife.js"),
+            path5.resolve(__dirname, "../../dist/client.iife.js"),
+            path5.resolve(__dirname, "../../../dist/client.iife.js")
+          ];
+          for (const p of candidatePaths) {
+            if (fs4.existsSync(p)) {
+              scriptContent = fs4.readFileSync(p, "utf-8");
+              break;
+            }
+          }
+        } catch {
+        }
+        if (!scriptContent) {
+          scriptContent = `console.warn("[BrowserTrack] Standalone client bundle not built yet. Run 'npm run build'.");`;
+        }
+        res.writeHead(200, {
+          "Content-Type": "application/javascript; charset=utf-8",
+          "Cache-Control": "no-cache"
+        });
+        res.end(scriptContent);
+        return;
+      }
+      if (pathname === "/api/projects") {
+        const projects = db.listProjects();
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, projects }));
+        return;
+      }
+      if (pathname === "/api/sessions") {
+        const projectId = parsedUrl.searchParams.get("project") || void 0;
+        const activeOnly = parsedUrl.searchParams.get("active") === "true";
+        const sessions = db.listSessions(projectId, activeOnly);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, sessions }));
+        return;
+      }
+      if (pathname === "/api/incidents") {
+        const projectId = parsedUrl.searchParams.get("project") || void 0;
+        const status = parsedUrl.searchParams.get("status") || void 0;
+        const limit = parseInt(parsedUrl.searchParams.get("limit") || "50", 10);
+        const incidents = db.listIncidents({ projectId, status, limit });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, incidents }));
+        return;
+      }
+      if (pathname.startsWith("/api/incidents/")) {
+        const incidentId = pathname.replace("/api/incidents/", "");
+        const incident = db.getIncident(incidentId);
+        if (!incident) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Incident not found" }));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, incident }));
+        return;
+      }
+      if (pathname === "/api/notes") {
+        const projectId = parsedUrl.searchParams.get("project") || void 0;
+        const status = parsedUrl.searchParams.get("status") || void 0;
+        const limit = parseInt(parsedUrl.searchParams.get("limit") || "50", 10);
+        const notes = db.listNotes({ projectId, status, limit });
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, notes }));
+        return;
+      }
+      if (pathname.startsWith("/api/notes/")) {
+        const noteId = pathname.replace("/api/notes/", "");
+        const note = db.getNote(noteId);
+        if (!note) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: "Note not found" }));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, note }));
+        return;
+      }
+      if (pathname.startsWith("/screenshots/")) {
+        const relativePath = pathname.replace("/screenshots/", "");
+        const filePath = path5.join(baseScreenshotsDir, relativePath);
+        if (fs4.existsSync(filePath) && fs4.statSync(filePath).isFile()) {
+          const ext = path5.extname(filePath).toLowerCase();
+          const mimeTypes = {
+            ".webp": "image/webp",
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg"
+          };
+          res.writeHead(200, { "Content-Type": mimeTypes[ext] || "application/octet-stream" });
+          fs4.createReadStream(filePath).pipe(res);
+          return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Screenshot not found" }));
+        return;
+      }
+      if (pathname === "/api/command" && req.method === "POST") {
+        try {
+          const data = await readJsonBody(req, res);
+          const sessionId = data.sessionId || sessionManager.getAnyActiveSession()?.id;
+          if (!sessionId) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: "No active browser session connected" }));
+            return;
+          }
+          const cmdRes = await sessionManager.sendCommand(sessionId, data.command, data.timeoutMs || 5e3);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(cmdRes));
+        } catch (err) {
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: err?.message || String(err) }));
+          }
+        }
+        return;
+      }
+      if (pathname === "/api/verify/incident" && req.method === "POST") {
+        try {
+          if (!verificationEngine) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: "Verification engine not attached to daemon" }));
+            return;
+          }
+          const data = await readJsonBody(req, res);
+          const result = await verificationEngine.verifyIncident(data.incidentId, data.options);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true, result }));
+        } catch (err) {
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: err?.message || String(err) }));
+          }
+        }
+        return;
+      }
+      if (pathname === "/api/verify/note" && req.method === "POST") {
+        try {
+          if (!noteVerificationEngine) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: "Note verification engine not attached to daemon" }));
+            return;
+          }
+          const data = await readJsonBody(req, res);
+          const result = await noteVerificationEngine.verifyNote(data.noteId, data.options);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true, result }));
+        } catch (err) {
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: err?.message || String(err) }));
+          }
+        }
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: false, error: "Not found" }));
+    } catch (err) {
+      if (!res.headersSent) {
+        try {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: false, error: err?.message || "Internal Server Error" }));
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// packages/daemon/src/server/ws.ts
+import crypto5 from "crypto";
+function safeWsSend(ws, payload) {
+  if (ws.readyState !== 1) return false;
+  try {
+    const raw = typeof payload === "string" ? payload : safeJsonStringify(payload);
+    ws.send(raw);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function setupWebSocketServer(wss, db, sessionManager, incidentEngine, notesEngine, maxEventsPerSession = 1e3, verbose = false) {
+  wss.on("connection", (ws) => {
+    let currentSessionId = null;
+    ws.on("message", (raw) => {
+      try {
+        const text = typeof raw === "string" ? raw : raw.toString("utf-8");
+        const data = JSON.parse(text);
+        if (data.type === "hello") {
+          const hello = data;
+          const sessionId = `sess_${crypto5.randomUUID().slice(0, 8)}`;
+          currentSessionId = sessionId;
+          let project = hello.projectId ? db.getProject(hello.projectId) : null;
+          if (!project && hello.origin) {
+            project = db.getProjectByOrigin(hello.origin);
+          }
+          if (!project) {
+            let projName = "default";
+            try {
+              const url = new URL(hello.origin || "http://localhost");
+              projName = url.port ? `app-${url.port}` : url.hostname;
+            } catch {
+              projName = "app";
+            }
+            project = db.upsertProject({
+              id: `proj_${crypto5.randomUUID().slice(0, 8)}`,
+              name: projName,
+              origin: hello.origin || "http://localhost"
+            });
+          }
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          db.upsertSession({
+            id: sessionId,
+            projectId: project.id,
+            origin: hello.origin || "",
+            url: hello.url || "",
+            title: hello.title || "",
+            userAgent: hello.userAgent || "",
+            connectedAt: now,
+            lastSeenAt: now,
+            active: true
+          });
+          sessionManager.registerSocket(sessionId, ws, hello.origin || "", project.id);
+          safeWsSend(ws, {
+            type: "hello_ack",
+            sessionId,
+            projectId: project.id,
+            projectName: project.name
+          });
+          const existingNotes = db.listNotes({ projectId: project.id, limit: 100 });
+          safeWsSend(ws, {
+            type: "notes_sync",
+            notes: existingNotes
+          });
+          if (verbose) {
+            console.log(`[BrowserTrack] New session connected: ${sessionId} (${project.name} @ ${hello.origin})`);
+          }
+          return;
+        }
+        if (data.type === "event") {
+          const eventMsg = data;
+          const sessionId = eventMsg.sessionId || currentSessionId;
+          if (!sessionId) return;
+          const eventId = `evt_${crypto5.randomUUID().slice(0, 8)}`;
+          db.insertEvent({
+            id: eventId,
+            sessionId,
+            eventType: eventMsg.eventType,
+            payload: eventMsg.payload,
+            timestamp: eventMsg.timestamp || Date.now(),
+            route: eventMsg.route,
+            url: eventMsg.url
+          });
+          db.pruneSessionEvents(sessionId, maxEventsPerSession);
+          const incident = incidentEngine.processClientEvent(eventMsg);
+          if (incident && verbose) {
+            console.log(
+              `[BrowserTrack] Incident recorded: ${incident.id} (${incident.type}: ${incident.message}) [${incident.occurrences}x]`
+            );
+          }
+          return;
+        }
+        if (data.type === "create_note" && notesEngine) {
+          const note = notesEngine.createNoteFromClient({
+            sessionId: data.sessionId || currentSessionId || "",
+            noteType: data.noteType,
+            message: data.message,
+            route: data.route,
+            url: data.url,
+            viewport: data.viewport,
+            scroll: data.scroll,
+            target: data.target,
+            elementContext: data.elementContext,
+            region: data.region,
+            screenshot: data.screenshot,
+            incidentId: data.incidentId,
+            scenarioId: data.scenarioId,
+            stepNumber: data.stepNumber,
+            scenarioTitle: data.scenarioTitle
+          });
+          if (verbose) {
+            console.log(
+              `[BrowserTrack] Visual note created: ${note.id} on ${note.route} ("${note.message}")${note.scenarioId ? ` [Scenario: ${note.scenarioTitle || note.scenarioId} Step ${note.stepNumber}]` : ""}`
+            );
+          }
+          safeWsSend(ws, {
+            type: "note_created_ack",
+            noteId: note.id,
+            status: note.status,
+            scenarioId: note.scenarioId,
+            stepNumber: note.stepNumber
+          });
+          const allNotes = db.listNotes({ projectId: note.projectId, limit: 100 });
+          sessionManager.broadcastToProject(note.projectId, {
+            type: "notes_sync",
+            notes: allNotes
+          });
+          return;
+        }
+        if (data.type === "resolve_note" && data.noteId) {
+          const note = db.getNote(data.noteId);
+          if (note) {
+            db.updateNoteStatus(data.noteId, "RESOLVED");
+            const allNotes = db.listNotes({ projectId: note.projectId, limit: 100 });
+            sessionManager.broadcastToProject(note.projectId, {
+              type: "notes_sync",
+              notes: allNotes
+            });
+          }
+          return;
+        }
+        if (data.type === "reopen_note" && data.noteId) {
+          const note = db.getNote(data.noteId);
+          if (note) {
+            db.updateNoteStatus(data.noteId, "OPEN");
+            const allNotes = db.listNotes({ projectId: note.projectId, limit: 100 });
+            sessionManager.broadcastToProject(note.projectId, {
+              type: "notes_sync",
+              notes: allNotes
+            });
+          }
+          return;
+        }
+        if (data.type === "delete_note" && data.noteId) {
+          const note = db.getNote(data.noteId);
+          if (note) {
+            db.deleteNote(data.noteId);
+            const allNotes = db.listNotes({ projectId: note.projectId, limit: 100 });
+            sessionManager.broadcastToProject(note.projectId, {
+              type: "notes_sync",
+              notes: allNotes
+            });
+          }
+          return;
+        }
+        if (data.type === "delete_scenario" && data.scenarioId) {
+          const scenario = db.getScenario(data.scenarioId);
+          if (scenario) {
+            db.deleteScenario(data.scenarioId);
+            const allNotes = db.listNotes({ projectId: scenario.projectId, limit: 100 });
+            sessionManager.broadcastToProject(scenario.projectId, {
+              type: "notes_sync",
+              notes: allNotes
+            });
+          }
+          return;
+        }
+        if (data.type === "get_notes") {
+          const session = currentSessionId ? db.getSession(currentSessionId) : null;
+          const projectId = data.projectId || session?.projectId;
+          if (projectId) {
+            const allNotes = db.listNotes({ projectId, limit: 100 });
+            safeWsSend(ws, {
+              type: "notes_sync",
+              notes: allNotes
+            });
+          }
+          return;
+        }
+        if (data.type === "command_response") {
+          const res = data.response;
+          const sessionId = data.sessionId || currentSessionId;
+          if (sessionId && res) {
+            sessionManager.handleCommandResponse(sessionId, res);
+          }
+          return;
+        }
+      } catch (err) {
+        if (verbose) {
+          console.error("[BrowserTrack] WebSocket message error:", err?.message);
+        }
+      }
+    });
+    ws.on("close", () => {
+      if (currentSessionId) {
+        sessionManager.unregisterSocket(currentSessionId);
+        if (verbose) {
+          console.log(`[BrowserTrack] Session disconnected: ${currentSessionId}`);
+        }
+      }
+    });
+    ws.on("error", () => {
+      if (currentSessionId) {
+        sessionManager.unregisterSocket(currentSessionId);
+      }
+    });
+  });
+}
+
+// packages/daemon/src/server/daemon.ts
+import http from "http";
+import { WebSocketServer } from "ws";
+var BrowserTrackDaemon = class {
+  config;
+  db;
+  screenshotStore;
+  sessionManager;
+  incidentEngine;
+  notesEngine;
+  verificationEngine;
+  noteVerificationEngine;
+  httpServer = null;
+  wss = null;
+  isRunning = false;
+  constructor(config = {}) {
+    this.config = getDaemonConfig(config);
+    this.db = new StorageDB(this.config.dbPath);
+    this.screenshotStore = new ScreenshotStore(this.config.screenshotsDir);
+    this.sessionManager = new SessionManager(this.db);
+    this.incidentEngine = new IncidentEngine(this.db, this.screenshotStore);
+    this.notesEngine = new NotesEngine(this.db, this.screenshotStore);
+    this.verificationEngine = new VerificationEngine(this.db, this.sessionManager, this.screenshotStore);
+    this.noteVerificationEngine = new NoteVerificationEngine(this.db, this.sessionManager, this.notesEngine);
+  }
+  async start() {
+    if (this.isRunning) return;
+    const httpHandler = createHttpHandler(
+      this.db,
+      this.sessionManager,
+      this.config.screenshotsDir,
+      this.verificationEngine,
+      this.noteVerificationEngine
+    );
+    this.httpServer = http.createServer(httpHandler);
+    this.wss = new WebSocketServer({ server: this.httpServer });
+    setupWebSocketServer(
+      this.wss,
+      this.db,
+      this.sessionManager,
+      this.incidentEngine,
+      this.notesEngine,
+      this.config.maxEventsPerSession,
+      this.config.verbose
+    );
+    await new Promise((resolve, reject) => {
+      this.httpServer.listen(this.config.port, this.config.host, () => {
+        this.isRunning = true;
+        if (this.config.verbose) {
+          console.log(`[BrowserTrack] Daemon running at http://${this.config.host}:${this.config.port}`);
+        }
+        resolve();
+      });
+      this.httpServer.once("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  async stop() {
+    if (!this.isRunning) return;
+    if (this.wss) {
+      for (const client of this.wss.clients) {
+        try {
+          client.terminate();
+        } catch {
+        }
+      }
+      await new Promise((resolve) => {
+        this.wss.close(() => resolve());
+      });
+      this.wss = null;
+    }
+    if (this.httpServer) {
+      if (typeof this.httpServer.closeAllConnections === "function") {
+        this.httpServer.closeAllConnections();
+      }
+      await new Promise((resolve) => {
+        this.httpServer.close(() => resolve());
+      });
+      this.httpServer = null;
+    }
+    try {
+      this.db.close();
+    } catch {
+    }
+    this.isRunning = false;
+  }
+  getStatus() {
+    return {
+      isRunning: this.isRunning,
+      host: this.config.host,
+      port: this.config.port,
+      activeSessions: this.sessionManager.getActiveCount(),
+      dbPath: this.config.dbPath
+    };
+  }
+};
+
+// packages/daemon/src/index.ts
+function createDaemon(config = {}) {
+  return new BrowserTrackDaemon(config);
+}
+
 export {
   getDaemonConfig,
   StorageDB,
   ScreenshotStore,
   SessionManager,
+  IncidentEngine,
   NotesEngine,
   NoteVerificationEngine,
-  VerificationEngine
+  VerificationEngine,
+  createHttpHandler,
+  setupWebSocketServer,
+  BrowserTrackDaemon,
+  createDaemon
 };
-//# sourceMappingURL=chunk-3HOXPTM2.js.map
+//# sourceMappingURL=chunk-AYSVE6NG.js.map