reportli 1.0.1 → 1.0.3

package/src/index.ts

@@ -1,32 +1,104 @@
-/**
- * Reportli SDK v1.0.1
- * Your AI agent that never sleeps.
- * Watches your SaaS, catches every error, files the GitHub issue — automatically.
- */
+// src/index.ts — Reportli SDK v1.0.3
 
-const ENDPOINT = "https://fahikyfmgdyzejdfftox.supabase.co/functions/v1/rapid-processor";
+const ENDPOINT =
+  "https://fahikyfmgdyzejdfftox.supabase.co/functions/v1/rapid-processor";
 
-const isBrowser = typeof window !== "undefined";
-const isNode = typeof process !== "undefined" && !!(process.versions?.node);
+// ─── Types ────────────────────────────────────────────────────────────────────
 
-let _apiKey = "";
+type Config = {
+  apiKey: string;
+  environment?: string;
+};
 
-// ─── Helpers ──────────────────────────────────────────────────────────────────
+type QueueItem = Record<string, unknown>;
 
-function getEnvironment(): string {
-  return isBrowser ? "browser" : "server";
+// ─── State ────────────────────────────────────────────────────────────────────
+
+let initialized = false;
+let _config: Config;
+const queue: QueueItem[] = [];
+let flushTimer: ReturnType<typeof setTimeout> | null = null;
+let isFlushing = false;
+
+// ─── Queue & Batch Send ───────────────────────────────────────────────────────
+
+function scheduleFlush() {
+  if (flushTimer) return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flush();
+  }, 2000); // batch every 2 seconds
+}
+
+async function flush() {
+  if (isFlushing || queue.length === 0) return;
+  isFlushing = true;
+
+  const batch = queue.splice(0, 10); // send max 10 at a time
+
+  for (const payload of batch) {
+    await sendNow(payload);
+  }
+
+  isFlushing = false;
+
+  if (queue.length > 0) flush(); // flush remaining
 }
 
+async function sendNow(payload: QueueItem, attempts = 3): Promise<void> {
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const res = await fetch(ENDPOINT, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": _config?.apiKey ?? "",
+        },
+        body: JSON.stringify(payload),
+      });
+      if (res.ok) return; // success — stop retrying
+    } catch {
+      // network error — wait before retry
+    }
+    await sleep(1000 * (i + 1)); // 1s, 2s, 3s
+  }
+  // give up silently after 3 attempts — never crash user app
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// ─── Enqueue ──────────────────────────────────────────────────────────────────
+
+function enqueue(payload: QueueItem) {
+  if (queue.length >= 100) return; // cap queue to prevent memory issues
+  queue.push(payload);
+  scheduleFlush();
+}
+
+// ─── Send immediately (for critical messages) ─────────────────────────────────
+
+function sendImmediate(payload: QueueItem) {
+  sendNow(payload).catch(() => {}); // fire and forget
+}
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
 function getUrl(): string {
-  if (isBrowser) return window.location.href;
+  if (typeof window !== "undefined") return window.location.href;
   try { return require("os").hostname(); } catch { return "server"; }
 }
 
 function getBrowser(): string {
-  if (isBrowser) return navigator.userAgent;
+  if (typeof navigator !== "undefined") return navigator.userAgent;
   return `Node.js ${typeof process !== "undefined" ? process.version : "unknown"}`;
 }
 
+function getEnvironment(): string {
+  return _config?.environment ?? (typeof window !== "undefined" ? "browser" : "server");
+}
+
 function parseStack(stack: string | undefined): { file: string; line: number; column: number } {
   if (!stack) return { file: "unknown", line: 0, column: 0 };
   const match =
@@ -40,152 +112,113 @@ function parseStack(stack: string | undefined): { file: string; line: number; co
 }
 
 function getErrorCode(error: any): string {
-  return error?.code || error?.status?.toString() || error?.statusCode?.toString() || error?.name || "ERR_UNKNOWN";
+  return (
+    error?.code ||
+    error?.status?.toString() ||
+    error?.statusCode?.toString() ||
+    error?.name ||
+    "ERR_UNKNOWN"
+  );
 }
 
-function classifyError(error: any, context?: string): { errorType: string; severity: "low" | "medium" | "high" | "critical" } {
+function classifyError(error: any, context?: string): { category: string; severity: "low" | "medium" | "high" | "critical" } {
   const msg = String(error?.message || error || "").toLowerCase();
   const name = String(error?.name || "").toLowerCase();
 
-  if (name.includes("quotaexceeded") || msg.includes("quota exceeded") || msg.includes("localstorage") || msg.includes("indexeddb"))
-    return { errorType: "localStorage quota exceeded", severity: "medium" };
+  // Payment — always critical
+  if (msg.includes("stripe") || msg.includes("payment") || msg.includes("card declined") || msg.includes("checkout") || msg.includes("refund"))
+    return { category: "Payment Error", severity: "critical" };
+
+  // Auth
+  if (msg.includes("jwt") || msg.includes("token expired") || msg.includes("unauthorized") || msg.includes("session") || msg.includes("oauth") || msg.includes("login failed"))
+    return { category: "Auth Error", severity: "high" };
+
+  // Database
+  if (msg.includes("supabase") || msg.includes("database") || msg.includes("query") || msg.includes("connection lost") || msg.includes("transaction") || msg.includes("duplicate key") || msg.includes("foreign key"))
+    return { category: "Database Error", severity: "critical" };
+
+  // React/Next.js
   if (msg.includes("hydration") || msg.includes("does not match server"))
-    return { errorType: "React hydration error", severity: "high" };
-  if (msg.includes("invalid hook call") || msg.includes("rules of hooks"))
-    return { errorType: "Invalid hook call error", severity: "critical" };
-  if (msg.includes("failed prop type") || msg.includes("invalid prop"))
-    return { errorType: "Props type error", severity: "low" };
-  if (msg.includes("render") || msg.includes("react error boundary"))
-    return { errorType: "Component render error", severity: "critical" };
-  if (msg.includes("route not found") || msg.includes("404 route"))
-    return { errorType: "Route not found error", severity: "medium" };
-  if (msg.includes("failed to fetch dynamically imported") || msg.includes("dynamic import"))
-    return { errorType: "Dynamic import error", severity: "high" };
-  if (msg.includes("suspense"))
-    return { errorType: "Suspense boundary error", severity: "medium" };
-  if (name === "typeerror" || msg.startsWith("typeerror"))
-    return { errorType: "TypeError", severity: "high" };
-  if (name === "referenceerror")
-    return { errorType: "ReferenceError", severity: "critical" };
-  if (name === "rangeerror" || msg.includes("maximum call stack"))
-    return { errorType: "Stack overflow error", severity: "critical" };
-  if (name === "syntaxerror")
-    return { errorType: "SyntaxError", severity: "high" };
-  if (msg.includes("stripe") && (msg.includes("init") || msg.includes("key")))
-    return { errorType: "Stripe initialization error", severity: "critical" };
-  if (msg.includes("payment") || msg.includes("card declined"))
-    return { errorType: "Payment processing error", severity: "critical" };
-  if (msg.includes("checkout session"))
-    return { errorType: "Checkout session error", severity: "high" };
-  if (msg.includes("refund failed"))
-    return { errorType: "Refund failed error", severity: "high" };
-  if (msg.includes("supabase") || msg.includes("postgresterror"))
-    return { errorType: "Supabase query error", severity: "critical" };
-  if (msg.includes("unique constraint") || msg.includes("duplicate key"))
-    return { errorType: "Unique constraint error", severity: "high" };
-  if (msg.includes("foreign key"))
-    return { errorType: "Foreign key error", severity: "high" };
-  if (msg.includes("transaction failed") || msg.includes("rollback"))
-    return { errorType: "Transaction failed error", severity: "critical" };
-  if (msg.includes("connection lost") || msg.includes("econnrefused"))
-    return { errorType: "Connection lost error", severity: "critical" };
-  if (msg.includes("query timeout"))
-    return { errorType: "Query timeout error", severity: "high" };
-  if (msg.includes("jwt expired") || msg.includes("token expired"))
-    return { errorType: "JWT expired error", severity: "high" };
-  if (msg.includes("jwt") && msg.includes("invalid"))
-    return { errorType: "JWT verification error", severity: "high" };
-  if (msg.includes("firebase admin"))
-    return { errorType: "Firebase admin error", severity: "critical" };
-  if (msg.includes("unauthorized") || msg.includes("permission denied"))
-    return { errorType: "Unauthorized access error", severity: "high" };
-  if (msg.includes("login failed") || msg.includes("invalid credentials"))
-    return { errorType: "Login failed error", severity: "medium" };
-  if (msg.includes("session ended") || msg.includes("session expired"))
-    return { errorType: "Session ended error", severity: "medium" };
-  if (msg.includes("oauth"))
-    return { errorType: "OAuth callback error", severity: "high" };
-  if (msg.includes("cron job") || msg.includes("cron failed"))
-    return { errorType: "Cron job failed", severity: "high" };
-  if (msg.includes("queue processing") || msg.includes("bullmq"))
-    return { errorType: "Queue processing error", severity: "high" };
-  if (msg.includes("webhook"))
-    return { errorType: "Webhook delivery failed", severity: "high" };
-  if (msg.includes("retry limit"))
-    return { errorType: "Retry limit exceeded", severity: "high" };
-  if (msg.includes("out of memory") || msg.includes("heap limit"))
-    return { errorType: "Out of memory error", severity: "critical" };
-  if (msg.includes("cannot find module"))
-    return { errorType: "Module not found error", severity: "critical" };
-  if (msg.includes("email") || msg.includes("smtp") || msg.includes("sendgrid") || msg.includes("nodemailer"))
-    return { errorType: "Email sending failed", severity: "high" };
-  if (msg.includes("onesignal") || msg.includes("push notification"))
-    return { errorType: "OneSignal API error", severity: "high" };
-  if (msg.includes("file upload") || msg.includes("upload failed"))
-    return { errorType: "File upload failed", severity: "high" };
-  if (msg.includes("file size exceeded") || msg.includes("payload too large"))
-    return { errorType: "File size exceeded", severity: "medium" };
-  if (msg.includes("invalid file type") || msg.includes("mime type"))
-    return { errorType: "Invalid file type", severity: "medium" };
+    return { category: "Hydration Error", severity: "high" };
+  if (msg.includes("invalid hook") || msg.includes("rules of hooks"))
+    return { category: "Hook Error", severity: "critical" };
+  if (msg.includes("render") || msg.includes("error boundary"))
+    return { category: "Render Error", severity: "critical" };
+  if (msg.includes("dynamic import") || msg.includes("failed to fetch dynamically"))
+    return { category: "Import Error", severity: "high" };
+
+  // Network
   if (msg.includes("cors") || msg.includes("cross-origin"))
-    return { errorType: "CORS error", severity: "high" };
-  if (msg.includes("fetch failed") || msg.includes("failed to fetch"))
-    return { errorType: "Fetch failed error", severity: "high" };
+    return { category: "CORS Error", severity: "high" };
+  if (msg.includes("fetch failed") || msg.includes("failed to fetch") || name === "fetcherror")
+    return { category: "Network Error", severity: "high" };
   if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("etimedout"))
-    return { errorType: "Request timeout error", severity: "medium" };
+    return { category: "Timeout Error", severity: "medium" };
   if (msg.includes("websocket"))
-    return { errorType: "WebSocket connection error", severity: "high" };
-  if (context === "unhandledrejection")
-    return { errorType: "Unhandled promise rejection", severity: "medium" };
-  if (context === "uncaughtexception")
-    return { errorType: "Uncaught exception", severity: "high" };
-  if (context === "express")
-    return { errorType: "Route handler error", severity: "high" };
-  return { errorType: "Uncaught exception", severity: "medium" };
+    return { category: "WebSocket Error", severity: "high" };
+
+  // HTTP status codes
+  if (msg.includes("http 401") || msg.includes("xhr 401"))
+    return { category: "Auth Error", severity: "high" };
+  if (msg.includes("http 403") || msg.includes("xhr 403"))
+    return { category: "Auth Error", severity: "high" };
+  if (msg.includes("http 404") || msg.includes("xhr 404"))
+    return { category: "Not Found Error", severity: "medium" };
+  if (msg.includes("http 500") || msg.includes("xhr 500"))
+    return { category: "Server Error", severity: "critical" };
+  if (msg.includes("http 503") || msg.includes("xhr 503"))
+    return { category: "Server Error", severity: "critical" };
+
+  // Memory
+  if (msg.includes("maximum call stack") || msg.includes("out of memory") || msg.includes("heap limit"))
+    return { category: "Memory Error", severity: "critical" };
+
+  // Server
+  if (msg.includes("cannot find module") || msg.includes("module not found"))
+    return { category: "Module Error", severity: "critical" };
+  if (msg.includes("econnrefused") || msg.includes("connection refused"))
+    return { category: "Connection Error", severity: "critical" };
+
+  // Email & Jobs
+  if (msg.includes("email") || msg.includes("smtp") || msg.includes("sendgrid"))
+    return { category: "Email Error", severity: "high" };
+  if (msg.includes("cron") || msg.includes("webhook") || msg.includes("queue"))
+    return { category: "Job Error", severity: "high" };
+
+  // Files
+  if (msg.includes("upload") || msg.includes("file size") || msg.includes("invalid file"))
+    return { category: "File Error", severity: "medium" };
+
+  // Storage
+  if (msg.includes("quota exceeded") || msg.includes("localstorage") || msg.includes("indexeddb"))
+    return { category: "Storage Error", severity: "medium" };
+
+  // JS core
+  if (name === "typeerror") return { category: "TypeError", severity: "high" };
+  if (name === "referenceerror") return { category: "ReferenceError", severity: "critical" };
+  if (name === "rangeerror") return { category: "RangeError", severity: "high" };
+  if (name === "syntaxerror") return { category: "SyntaxError", severity: "high" };
+
+  // Context based
+  if (context === "unhandledrejection") return { category: "Promise Error", severity: "medium" };
+  if (context === "express") return { category: "Server Error", severity: "high" };
+  if (context === "resource") return { category: "Resource Error", severity: "low" };
+
+  return { category: "Unknown Error", severity: "medium" };
 }
 
-function normalizeError(err: any): { name: string; message: string; stack?: string } {
-  if (err instanceof Error) return { name: err.name, message: err.message, stack: err.stack };
-  if (typeof err === "string") return { name: "Error", message: err, stack: new Error(err).stack };
-  if (err && typeof err === "object") return {
-    name: err.name || err.code || "Error",
-    message: err.message || err.reason || JSON.stringify(err),
-    stack: err.stack || new Error(err.message).stack,
-  };
-  return { name: "Error", message: "Unknown error", stack: new Error().stack };
-}
-
-// ─── Send ─────────────────────────────────────────────────────────────────────
-
-async function send(payload: object): Promise<void> {
-  try {
-    if ((payload as any).message?.includes("rapid-processor")) return;
-    await fetch(ENDPOINT, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": _apiKey,
-      },
-      body: JSON.stringify(payload),
-    });
-  } catch {
-    // Fail silently — never break user app
-  }
-}
-
-// ─── Build error payload ──────────────────────────────────────────────────────
-
-function buildErrorPayload(error: any, context?: string): object {
-  const normalized = normalizeError(error);
-  const { file, line, column } = parseStack(normalized.stack);
-  const { errorType, severity } = classifyError(normalized, context);
+function buildErrorPayload(error: any, context?: string): QueueItem {
+  const message = error?.message || String(error) || "Unknown error";
+  const stack = error?.stack || "";
+  const { file, line, column } = parseStack(stack);
+  const { category, severity } = classifyError(error, context);
 
   return {
     type: "ERROR",
-    apiKey: _apiKey,
-    message: normalized.message,
+    apiKey: _config?.apiKey,
+    message,
     code: getErrorCode(error),
-    stack: normalized.stack || "",
+    stack,
     file,
     line,
     column,
@@ -193,70 +226,71 @@ function buildErrorPayload(error: any, context?: string): object {
     timestamp: new Date().toISOString(),
     environment: getEnvironment(),
     browser: getBrowser(),
-    error_category: errorType,
+    error_category: category,
     severity,
     status: "open",
+    context: context || "auto",
   };
 }
 
-// ─── Browser listeners ────────────────────────────────────────────────────────
+// ─── Browser Listeners ────────────────────────────────────────────────────────
 
-function activateBrowserListeners(): void {
-  // JS runtime errors + resource load errors
+function activateBrowserListeners() {
+  // JS errors + resource errors
   window.addEventListener("error", (event) => {
-    if ((event as any).filename?.includes("rapid-processor")) return;
-
+    // Resource load error (img, script, link, video)
     const target = event.target as HTMLElement;
-    if (target && target.tagName) {
-      const tag = target.tagName;
-      const src = (target as any).src || (target as any).href || "";
-      if (["IMG", "SCRIPT", "LINK", "VIDEO", "AUDIO", "SOURCE"].includes(tag)) {
-        send(buildErrorPayload({
-          name: "ResourceError",
-          message: `${tag} failed to load: ${src}`,
-          stack: `at ${window.location.href}`,
-        }));
-        return;
-      }
+    if (target && target.tagName && ["IMG", "SCRIPT", "LINK", "VIDEO", "AUDIO"].includes(target.tagName)) {
+      const src = (target as any).src || (target as any).href || "unknown";
+      enqueue(buildErrorPayload({ name: "ResourceError", message: `${target.tagName} failed to load: ${src}`, stack: "" }, "resource"));
+      return;
     }
 
     const err = (event as ErrorEvent).error || {
       name: "Error",
       message: (event as ErrorEvent).message,
-      stack: `${(event as ErrorEvent).message} at ${(event as ErrorEvent).filename}:${(event as ErrorEvent).lineno}:${(event as ErrorEvent).colno}`,
+      stack: `at ${(event as ErrorEvent).filename}:${(event as ErrorEvent).lineno}:${(event as ErrorEvent).colno}`,
     };
-    send(buildErrorPayload(err));
+    enqueue(buildErrorPayload(err, "window"));
   }, true);
 
   // Unhandled promise rejections
   window.addEventListener("unhandledrejection", (event) => {
-    send(buildErrorPayload(event.reason || { message: "Unhandled Promise Rejection" }, "unhandledrejection"));
+    const err = event.reason instanceof Error
+      ? event.reason
+      : { name: "UnhandledRejection", message: String(event.reason || "Unhandled Promise Rejection"), stack: "" };
+    enqueue(buildErrorPayload(err, "unhandledrejection"));
   });
 
-  // Intercept fetch
+  // Intercept fetch — catches all API errors automatically
   const originalFetch = window.fetch;
-  window.fetch = async function (input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
-    const url = typeof input === "string" ? input : (input instanceof URL ? input.toString() : (input as Request).url);
-    if (url.includes("rapid-processor") || url.includes("supabase.co/functions")) {
-      return originalFetch.apply(this, arguments as any);
-    }
+  window.fetch = async function (...args: Parameters<typeof fetch>): Promise<Response> {
+    const url = typeof args[0] === "string"
+      ? args[0]
+      : args[0] instanceof URL
+      ? args[0].toString()
+      : (args[0] as Request)?.url ?? "";
+
+    // Never intercept our own requests
+    if (url.includes("rapid-processor")) return originalFetch(...args);
+
     try {
-      const response = await originalFetch.apply(this, arguments as any);
+      const response = await originalFetch(...args);
       if (!response.ok) {
-        send(buildErrorPayload({
-          name: `API ${response.status} Error`,
-          message: `HTTP ${response.status}: ${init?.method || "GET"} ${url}`,
-          stack: `${init?.method || "GET"} ${url} → ${response.status} ${response.statusText}`,
+        enqueue(buildErrorPayload({
+          name: `HTTP_${response.status}`,
+          message: `HTTP ${response.status}: ${(args[1] as RequestInit)?.method || "GET"} ${url}`,
+          stack: `${(args[1] as RequestInit)?.method || "GET"} ${url} → ${response.status} ${response.statusText}`,
           status: response.status,
-        }));
+        }, "fetch"));
       }
       return response;
     } catch (err: any) {
-      send(buildErrorPayload({
+      enqueue(buildErrorPayload({
         name: "FetchError",
-        message: `Fetch failed: ${init?.method || "GET"} ${url} — ${err.message}`,
+        message: `Fetch failed: ${(args[1] as RequestInit)?.method || "GET"} ${url} — ${err.message}`,
         stack: err.stack,
-      }));
+      }, "fetch"));
       throw err;
     }
   };
@@ -265,123 +299,127 @@ function activateBrowserListeners(): void {
   const originalOpen = XMLHttpRequest.prototype.open;
   const originalSend = XMLHttpRequest.prototype.send;
 
-  XMLHttpRequest.prototype.open = function (method: string, url: string) {
+  XMLHttpRequest.prototype.open = function (method: string, url: string, ...rest: any[]) {
     (this as any)._r_method = method;
     (this as any)._r_url = url;
-    return originalOpen.apply(this, arguments as any);
+    return originalOpen.call(this, method, url, ...rest);
   } as any;
 
-  XMLHttpRequest.prototype.send = function () {
-    this.addEventListener("loadend", () => {
-      const url: string = (this as any)._r_url || "";
-      const method: string = (this as any)._r_method || "GET";
-      if (url.includes("rapid-processor")) return;
-      if (this.status >= 400 || this.status === 0) {
-        send(buildErrorPayload({
-          name: `XHR ${this.status} Error`,
-          message: `XHR ${this.status}: ${method} ${url}`,
-          stack: `${method} ${url} → ${this.status} ${this.statusText}`,
-          status: this.status,
-        }));
-      }
-    });
-    return originalSend.apply(this, arguments as any);
+  XMLHttpRequest.prototype.send = function (...args: any[]) {
+    const url: string = (this as any)._r_url || "";
+    const method: string = (this as any)._r_method || "GET";
+
+    if (!url.includes("rapid-processor")) {
+      this.addEventListener("loadend", () => {
+        if (this.status >= 400 || this.status === 0) {
+          enqueue(buildErrorPayload({
+            name: `XHR_${this.status}`,
+            message: `XHR ${this.status}: ${method} ${url}`,
+            stack: `${method} ${url} → ${this.status} ${this.statusText}`,
+            status: this.status,
+          }, "xhr"));
+        }
+      });
+    }
+
+    return originalSend.apply(this, args);
   } as any;
 
   // Disconnect when page closes
   window.addEventListener("beforeunload", () => {
     try {
-      navigator.sendBeacon(ENDPOINT, JSON.stringify({
-        type: "SDK_DISCONNECTED",
-        apiKey: _apiKey,
-        timestamp: new Date().toISOString(),
-        environment: "browser",
-        url: getUrl(),
-      }));
+      navigator.sendBeacon(
+        ENDPOINT,
+        JSON.stringify({
+          type: "SDK_DISCONNECTED",
+          apiKey: _config?.apiKey,
+          timestamp: new Date().toISOString(),
+          environment: getEnvironment(),
+          url: getUrl(),
+        })
+      );
     } catch { /* silent */ }
   });
 }
 
-// ─── Server listeners ─────────────────────────────────────────────────────────
+// ─── Server Listeners ─────────────────────────────────────────────────────────
 
-function activateServerListeners(): void {
+function activateServerListeners() {
   process.on("uncaughtException", (error: Error) => {
-    send(buildErrorPayload(error, "uncaughtexception"));
+    enqueue(buildErrorPayload(error, "uncaughtException"));
+    flush(); // flush immediately on crash
   });
 
   process.on("unhandledRejection", (reason: any) => {
-    send(buildErrorPayload(
+    enqueue(buildErrorPayload(
       reason instanceof Error ? reason : { name: "UnhandledRejection", message: String(reason), stack: "" },
       "unhandledrejection"
     ));
   });
 
-  const shutdown = async () => {
-    await send({
+  const shutdown = async (signal: string) => {
+    await sendNow({
       type: "SDK_DISCONNECTED",
-      apiKey: _apiKey,
+      apiKey: _config?.apiKey,
       timestamp: new Date().toISOString(),
-      environment: "server",
+      environment: getEnvironment(),
       url: getUrl(),
+      signal,
     });
     process.exit(0);
   };
 
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
 }
 
 // ─── Public API ───────────────────────────────────────────────────────────────
 
-const Reportli = {
-  init({ apiKey }: { apiKey: string }): void {
-    if (!apiKey || _apiKey) return;
-    _apiKey = apiKey;
-
-    // Send SDK_INITIALIZED once only
-    if (isBrowser && typeof localStorage !== "undefined") {
-      const key = `reportli_init_${apiKey}`;
-      if (!localStorage.getItem(key)) {
-        localStorage.setItem(key, "true");
-        send({
-          type: "SDK_INITIALIZED",
-          apiKey: _apiKey,
-          timestamp: new Date().toISOString(),
-          environment: getEnvironment(),
-          url: getUrl(),
-          browser: getBrowser(),
-        });
-      }
-    } else {
-      send({
-        type: "SDK_INITIALIZED",
-        apiKey: _apiKey,
-        timestamp: new Date().toISOString(),
-        environment: getEnvironment(),
-        url: getUrl(),
-        browser: getBrowser(),
-      });
-    }
+export const Reportli = {
+  init(cfg: Config) {
+    if (initialized) return;
+    if (!cfg?.apiKey) return;
+
+    _config = cfg;
+    initialized = true;
+
+    // Send SDK_INITIALIZED immediately — not queued
+    sendImmediate({
+      type: "SDK_INITIALIZED",
+      apiKey: cfg.apiKey,
+      timestamp: new Date().toISOString(),
+      environment: getEnvironment(),
+      url: getUrl(),
+      browser: getBrowser(),
+    });
 
-    if (isBrowser) {
+    // Activate listeners
+    if (typeof window !== "undefined") {
       activateBrowserListeners();
-    } else if (isNode) {
+    } else if (typeof process !== "undefined" && process.versions?.node) {
       activateServerListeners();
     }
   },
 
-  capture(error: any): void {
-    if (!_apiKey) return;
-    send(buildErrorPayload(error, "manual"));
+  capture(error: unknown) {
+    if (!initialized) return;
+    const err = error instanceof Error
+      ? error
+      : { name: "ManualCapture", message: String(error), stack: new Error().stack };
+    enqueue(buildErrorPayload(err, "manual"));
+  },
+
+  captureMessage(message: string) {
+    if (!initialized) return;
+    enqueue(buildErrorPayload({ name: "Message", message, stack: "" }, "manual"));
   },
 
   errorHandler() {
     return function (err: any, _req: any, _res: any, next: any) {
-      send(buildErrorPayload(err, "express"));
+      enqueue(buildErrorPayload(err, "express"));
       next(err);
     };
   },
 };
 
 export default Reportli;
-export { Reportli };