browsertrack 0.2.0 → 0.2.2

package/dist/chunk-7OCOQGDN.js

@@ -1,635 +0,0 @@
-import {
-  computeFingerprint,
-  extractSourceFromStack,
-  normalizeSourceFile,
-  redactSensitiveData
-} from "./chunk-6VA7GBAO.js";
-import {
-  NoteVerificationEngine,
-  NotesEngine,
-  ScreenshotStore,
-  SessionManager,
-  StorageDB,
-  VerificationEngine,
-  getDaemonConfig
-} from "./chunk-3HOXPTM2.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,
-            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}]` : ""}`
-            );
-          }
-          ws.send(
-            JSON.stringify({
-              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 });
-            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-7OCOQGDN.js.map