browsertrack 0.0.1 → 0.1.1

package/dist/chunk-SPCIROIU.js

@@ -0,0 +1,616 @@
+import {
+  computeFingerprint,
+  extractSourceFromStack,
+  normalizeSourceFile,
+  redactSensitiveData
+} from "./chunk-6VA7GBAO.js";
+import {
+  NoteVerificationEngine,
+  NotesEngine,
+  ScreenshotStore,
+  SessionManager,
+  StorageDB,
+  VerificationEngine,
+  getDaemonConfig
+} from "./chunk-ILRYKMME.js";
+
+// 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/server/http.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function createHttpHandler(db, sessionManager, baseScreenshotsDir) {
+  return (req, res) => {
+    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 = path.dirname(__filename);
+        const candidatePaths = [
+          path.resolve(__dirname, "../client.iife.js"),
+          path.resolve(__dirname, "../../dist/client.iife.js"),
+          path.resolve(__dirname, "../../../dist/client.iife.js")
+        ];
+        for (const p of candidatePaths) {
+          if (fs.existsSync(p)) {
+            scriptContent = fs.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 = path.join(baseScreenshotsDir, relativePath);
+      if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+        const ext = path.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" });
+        fs.createReadStream(filePath).pipe(res);
+        return;
+      }
+      res.writeHead(404, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: false, error: "Screenshot not found" }));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ok: false, error: "Not found" }));
+  };
+}
+
+// packages/daemon/src/server/ws.ts
+import crypto2 from "crypto";
+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_${crypto2.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_${crypto2.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);
+          ws.send(
+            JSON.stringify({
+              type: "hello_ack",
+              sessionId,
+              projectId: project.id,
+              projectName: project.name
+            })
+          );
+          const existingNotes = db.listNotes({ projectId: project.id, limit: 100 });
+          ws.send(
+            JSON.stringify({
+              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_${crypto2.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
+          });
+          if (verbose) {
+            console.log(`[BrowserTrack] Visual note created: ${note.id} on ${note.route} ("${note.message}")`);
+          }
+          ws.send(
+            JSON.stringify({
+              type: "note_created_ack",
+              noteId: note.id,
+              status: note.status
+            })
+          );
+          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 === "get_notes") {
+          const session = currentSessionId ? db.getSession(currentSessionId) : null;
+          const projectId = data.projectId || session?.projectId;
+          if (projectId) {
+            const allNotes = db.listNotes({ projectId, limit: 100 });
+            ws.send(
+              JSON.stringify({
+                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.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 {
+  IncidentEngine,
+  createHttpHandler,
+  setupWebSocketServer,
+  BrowserTrackDaemon,
+  createDaemon
+};
+//# sourceMappingURL=chunk-SPCIROIU.js.map