@mushi-mushi/web 0.9.0 → 1.0.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { createLogger, noopLogger, createApiClient, createPreFilter, createOfflineQueue, createRateLimiter, createPiiScrubber, getReporterToken, getDeviceFingerprintHash, getSessionId, captureEnvironment, DEFAULT_API_ENDPOINT, MUSHI_INTERNAL_INIT_MARKER, MUSHI_INTERNAL_HEADER } from '@mushi-mushi/core';
+import { createLogger, noopLogger, createApiClient, createPreFilter, createOfflineQueue, createRateLimiter, createPiiScrubber, createBreadcrumbBuffer, getReporterToken, getDeviceFingerprintHash, getSessionId, captureEnvironment, DEFAULT_API_ENDPOINT, MUSHI_INTERNAL_INIT_MARKER, MUSHI_INTERNAL_HEADER, normaliseThrown } from '@mushi-mushi/core';
 
 // src/mushi.ts
 
@@ -2466,42 +2466,211 @@ function createDiscoveryCapture(opts) {
 // src/sentry.ts
 function getSentryGlobal() {
   try {
-    const win = globalThis;
-    if (win.__SENTRY__) {
-      const sentry = win.__SENTRY__;
-      const hub = sentry.hub;
-      return hub;
+    const w = globalThis;
+    if (w.Sentry) return w.Sentry;
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getSentryReplayGlobal() {
+  try {
+    const w = globalThis;
+    return w.__SENTRY_REPLAY__;
+  } catch {
+    return void 0;
+  }
+}
+function detectSentrySdkFamily() {
+  try {
+    const w = globalThis;
+    const meta = w.__SENTRY__;
+    const sentry = w.Sentry;
+    if (meta?.version === "9" || sentry && typeof sentry.lastEventId === "function") {
+      return meta?.version === "9" ? "v9" : "v8";
+    }
+    if (meta?.version === "8") return "v8";
+    if (sentry && typeof sentry.getCurrentHub === "function") return "v7";
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function captureSentryContext(_config, options = {}) {
+  const limit = Math.max(0, options.breadcrumbsLimit ?? 30);
+  const out = {};
+  const sentry = getSentryGlobal();
+  if (!sentry) return out;
+  out.sdk = detectSentrySdkFamily();
+  try {
+    const v8 = sentry;
+    if (typeof v8.lastEventId === "function") {
+      out.eventId = v8.lastEventId() ?? void 0;
+    } else {
+      const v7 = sentry;
+      const scope2 = v7.getCurrentHub?.()?.getScope?.();
+      out.eventId = scope2?.getLastEventId?.() ?? void 0;
     }
-    if (win.Sentry) {
-      return win.Sentry;
+  } catch {
+  }
+  let scope;
+  try {
+    const v8 = sentry;
+    if (typeof v8.getCurrentScope === "function") {
+      scope = v8.getCurrentScope();
+    } else {
+      const v7 = sentry;
+      scope = v7.getCurrentHub?.()?.getScope?.();
     }
   } catch {
   }
-  return void 0;
+  if (scope) {
+    try {
+      const user = scope.getUser?.();
+      if (user) {
+        out.user = {
+          id: typeof user.id === "string" ? user.id : void 0,
+          email: typeof user.email === "string" ? user.email : void 0,
+          username: typeof user.username === "string" ? user.username : void 0,
+          ip_address: typeof user.ip_address === "string" ? user.ip_address : void 0
+        };
+      }
+    } catch {
+    }
+    try {
+      const tags = scope.getTags?.();
+      if (tags && typeof tags === "object") {
+        const pruned = {};
+        for (const [k, v] of Object.entries(tags)) {
+          if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+            pruned[k] = v;
+          }
+        }
+        if (Object.keys(pruned).length > 0) out.tags = pruned;
+      }
+    } catch {
+    }
+    try {
+      out.transactionName = scope.getTransactionName?.() ?? scope.getTransaction?.()?.name ?? void 0;
+    } catch {
+    }
+    try {
+      out.sessionId = scope.getSession?.()?.sid ?? void 0;
+    } catch {
+    }
+    try {
+      const raw = scope.getBreadcrumbs?.() ?? scope._breadcrumbs ?? [];
+      if (Array.isArray(raw) && raw.length > 0) {
+        const sliced = raw.slice(-limit);
+        out.breadcrumbs = sliced.map((b) => {
+          const r = b;
+          return {
+            timestamp: typeof r.timestamp === "number" ? (
+              // Sentry stores breadcrumb timestamps in seconds; convert
+              // to ms so the field is comparable to Mushi's own.
+              r.timestamp < 1e12 ? Math.round(r.timestamp * 1e3) : r.timestamp
+            ) : void 0,
+            category: typeof r.category === "string" ? r.category : void 0,
+            level: typeof r.level === "string" ? r.level : void 0,
+            message: typeof r.message === "string" ? r.message : void 0,
+            type: typeof r.type === "string" ? r.type : void 0,
+            data: r.data && typeof r.data === "object" ? r.data : void 0
+          };
+        });
+      }
+    } catch {
+    }
+  }
+  try {
+    const v8 = sentry;
+    let span;
+    if (typeof v8.getActiveSpan === "function") {
+      span = v8.getActiveSpan();
+    } else if (scope?.getSpan) {
+      span = scope.getSpan();
+    }
+    if (span) {
+      const ctx = span.spanContext?.();
+      out.traceId = ctx?.traceId ?? span.traceId ?? void 0;
+      out.spanId = ctx?.spanId ?? span.spanId ?? void 0;
+    }
+  } catch {
+  }
+  let client;
+  try {
+    const v8 = sentry;
+    if (typeof v8.getClient === "function") {
+      client = v8.getClient();
+    } else {
+      const v7 = sentry;
+      client = v7.getCurrentHub?.()?.getClient?.();
+    }
+  } catch {
+  }
+  if (client) {
+    try {
+      const opts = client.getOptions?.();
+      if (opts?.release) out.release = opts.release;
+      if (opts?.environment) out.environment = opts.environment;
+    } catch {
+    }
+    try {
+      const dsn = client.getDsn?.();
+      if (dsn?.host && dsn?.projectId && out.eventId) {
+        const orgHost = dsn.host.replace(/^o\d+\./, "");
+        out.issueUrl = `https://${orgHost}/issues/?query=${encodeURIComponent(out.eventId)}`;
+      }
+    } catch {
+    }
+  }
+  try {
+    const v8 = sentry;
+    const replay = v8.getReplay?.() ?? getSentryReplayGlobal();
+    out.replayId = replay?.getReplayId?.() ?? void 0;
+  } catch {
+  }
+  return out;
 }
-function captureSentryContext(_config) {
-  const context = {};
+function tagSentryScope(reportId, options = {}) {
+  const sentry = getSentryGlobal();
+  if (!sentry) return;
   try {
-    const hub = getSentryGlobal();
-    if (!hub) return context;
-    const scope = hub.getScope?.();
-    if (scope) {
-      context.eventId = scope.getLastEventId?.() ?? void 0;
+    const v8 = sentry;
+    if (typeof v8.setTag === "function") {
+      v8.setTag("mushi.report_id", reportId);
+      if (options.reportUrl) v8.setTag("mushi.report_url", options.reportUrl);
+    }
+    if (typeof v8.setContext === "function") {
+      v8.setContext("mushi_report", {
+        id: reportId,
+        ...options.reportUrl ? { url: options.reportUrl } : {},
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      });
     }
-    const client = hub.getClient?.();
-    if (client) {
-      const options = client.getOptions?.();
-      context.release = options?.release;
-      context.environment = options?.environment;
+    if (typeof v8.addBreadcrumb === "function") {
+      v8.addBreadcrumb({
+        category: "mushi",
+        type: "info",
+        level: "info",
+        message: `Mushi report submitted (${reportId})`,
+        data: { report_id: reportId, ...options.reportUrl ? { url: options.reportUrl } : {} }
+      });
     }
-    const win = globalThis;
-    if (win.__SENTRY_REPLAY__) {
-      const replay = win.__SENTRY_REPLAY__;
-      context.replayId = replay.getReplayId?.() ?? void 0;
+  } catch {
+  }
+  try {
+    const v7 = sentry;
+    const scope = v7.getCurrentHub?.()?.getScope?.();
+    if (scope) {
+      scope.setTag?.("mushi.report_id", reportId);
+      if (options.reportUrl) scope.setTag?.("mushi.report_url", options.reportUrl);
+      scope.setContext?.("mushi_report", {
+        id: reportId,
+        ...options.reportUrl ? { url: options.reportUrl } : {}
+      });
     }
   } catch {
   }
-  return context;
 }
 
 // src/proactive-triggers.ts
@@ -2678,7 +2847,7 @@ function createProactiveManager(config = {}) {
 
 // src/version.ts
 var MUSHI_SDK_PACKAGE = "@mushi-mushi/web";
-var MUSHI_SDK_VERSION = "0.9.0" ;
+var MUSHI_SDK_VERSION = "1.0.0" ;
 
 // src/mushi.ts
 var instance = null;
@@ -2726,6 +2895,30 @@ function createInstance(config) {
   const offlineQueue = createOfflineQueue(bootstrapConfig.offline);
   const rateLimiter = createRateLimiter({ maxBurst: 10, refillRate: 1, refillIntervalMs: 5e3 });
   const piiScrubber = createPiiScrubber();
+  function scrubBreadcrumbsForWire(crumbs) {
+    return crumbs.map((c) => {
+      const next = { ...c };
+      if (typeof c.message === "string") {
+        next.message = piiScrubber.scrub(c.message);
+      }
+      if (c.data && typeof c.data === "object") {
+        const cleaned = {};
+        for (const [k, v] of Object.entries(c.data)) {
+          cleaned[k] = typeof v === "string" ? piiScrubber.scrub(v) : v;
+        }
+        next.data = cleaned;
+      }
+      return next;
+    });
+  }
+  function scrubTagsForWire(tags) {
+    if (!tags) return void 0;
+    const out = {};
+    for (const [k, v] of Object.entries(tags)) {
+      out[k] = typeof v === "string" ? piiScrubber.scrub(v) : v;
+    }
+    return out;
+  }
   let consoleCap = null;
   let networkCap = null;
   let perfCap = null;
@@ -2825,6 +3018,16 @@ function createInstance(config) {
   let runtimeConfigLoaded = false;
   let userInfo = null;
   const customMetadata = {};
+  const stickyTags = {};
+  const breadcrumbs = createBreadcrumbBuffer({ max: 50 });
+  breadcrumbs.add({
+    category: "lifecycle",
+    level: "info",
+    message: "Mushi SDK init",
+    data: { projectId: bootstrapConfig.projectId, sdkVersion: MUSHI_SDK_VERSION }
+  });
+  let detachAutoBreadcrumbs = null;
+  detachAutoBreadcrumbs = installAutoBreadcrumbs(breadcrumbs);
   widget = new MushiWidget(bootstrapConfig.widget, {
     onSubmit: async ({ category, description, intent }) => {
       log.info("Report submitted", { category, intent });
@@ -3034,6 +3237,15 @@ function createInstance(config) {
     const fingerprintHash = await getDeviceFingerprintHash().catch(() => null);
     const consoleLogs = activeConfig.capture?.console === false ? void 0 : consoleCap?.getEntries();
     const networkLogs = activeConfig.capture?.network === false ? void 0 : networkCap?.getEntries();
+    const reportBreadcrumbs = scrubBreadcrumbsForWire(breadcrumbs.getAll());
+    const stickyTagSnapshot = scrubTagsForWire(
+      Object.keys(stickyTags).length > 0 ? { ...stickyTags } : void 0
+    );
+    const sentryCtxScrubbed = sentryCtx ? {
+      ...sentryCtx,
+      ...sentryCtx.breadcrumbs ? { breadcrumbs: scrubBreadcrumbsForWire(sentryCtx.breadcrumbs) } : {},
+      ...sentryCtx.tags ? { tags: scrubTagsForWire(sentryCtx.tags) } : {}
+    } : void 0;
     const report = {
       id: crypto.randomUUID?.() ?? `mushi_${Date.now()}_${Math.random().toString(36).slice(2)}`,
       projectId: config.projectId,
@@ -3059,10 +3271,24 @@ function createInstance(config) {
       sdkPackage: MUSHI_SDK_PACKAGE,
       sdkVersion: MUSHI_SDK_VERSION,
       proactiveTrigger: pendingProactiveTrigger ?? void 0,
+      // Top-level Sentry-grade observability fields. Breadcrumbs are
+      // surfaced separately from `consoleLogs` because they're the
+      // higher-signal "what just happened" trail (vs. the high-volume
+      // raw console mirror), and the admin /reports drawer shows them
+      // in different panes.
+      ...reportBreadcrumbs.length > 0 ? { breadcrumbs: reportBreadcrumbs } : {},
+      ...stickyTagSnapshot ? { tags: stickyTagSnapshot } : {},
+      ...sentryCtxScrubbed ? { sentryContext: sentryCtxScrubbed } : {},
       sentryEventId: sentryCtx?.eventId,
       sentryReplayId: sentryCtx?.replayId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
+    breadcrumbs.add({
+      category: "lifecycle",
+      level: "info",
+      message: `Mushi report submitting (${category})`,
+      data: { reportId: report.id, category }
+    });
     if (config.integrations?.custom) {
       const builder = {
         addMetadata(key, value) {
@@ -3088,10 +3314,26 @@ function createInstance(config) {
     if (result.ok) {
       log.info("Report sent", { reportId: result.data?.reportId });
       emit("report:sent", { reportId: result.data?.reportId });
+      breadcrumbs.add({
+        category: "lifecycle",
+        level: "info",
+        message: `Mushi report sent (${result.data?.reportId ?? report.id})`
+      });
+      try {
+        if (config.sentry && result.data?.reportId) {
+          tagSentryScope(result.data.reportId);
+        }
+      } catch {
+      }
     } else {
       log.warn("Report failed, queuing for retry", { reportId: report.id, error: result.error });
       await offlineQueue.enqueue(report);
       emit("report:failed", { reportId: report.id, error: result.error });
+      breadcrumbs.add({
+        category: "lifecycle",
+        level: "warning",
+        message: `Mushi report queued for retry (${report.id})`
+      });
     }
     pendingScreenshot = null;
     pendingElement = null;
@@ -3163,6 +3405,9 @@ function createInstance(config) {
       discoveryCap?.destroy();
       discoveryCap = null;
       offlineQueue.stopAutoSync();
+      detachAutoBreadcrumbs?.();
+      detachAutoBreadcrumbs = null;
+      breadcrumbs.clear();
       listeners.clear();
       instance = null;
       log.debug("Destroyed");
@@ -3177,6 +3422,16 @@ function createInstance(config) {
       }
       const description = piiScrubber.scrub(preFilter.truncate(input.description));
       const category = input.category ?? "bug";
+      const sentryCtx = config.sentry ? captureSentryContext(config.sentry) : void 0;
+      const captureBreadcrumbs = scrubBreadcrumbsForWire(breadcrumbs.getAll());
+      const mergedTags = scrubTagsForWire(
+        Object.keys(stickyTags).length === 0 && !input.tags ? void 0 : { ...stickyTags, ...input.tags ?? {} }
+      );
+      const sentryCtxScrubbed = sentryCtx ? {
+        ...sentryCtx,
+        ...sentryCtx.breadcrumbs ? { breadcrumbs: scrubBreadcrumbsForWire(sentryCtx.breadcrumbs) } : {},
+        ...sentryCtx.tags ? { tags: scrubTagsForWire(sentryCtx.tags) } : {}
+      } : void 0;
       const report = {
         id: crypto.randomUUID?.() ?? `mushi_${Date.now()}_${Math.random().toString(36).slice(2)}`,
         projectId: config.projectId,
@@ -3187,16 +3442,20 @@ function createInstance(config) {
         metadata: {
           ...input.metadata ?? {},
           ...userInfo ? { user: userInfo } : {},
-          ...input.tags ? { tags: input.tags } : {},
           ...input.error ? { error: input.error } : {},
           ...input.severity ? { severity: input.severity } : {},
           ...input.component ? { component: input.component } : {},
           ...input.source ? { source: input.source } : { source: "captureEvent" }
         },
+        ...captureBreadcrumbs.length > 0 ? { breadcrumbs: captureBreadcrumbs } : {},
+        ...mergedTags && Object.keys(mergedTags).length > 0 ? { tags: mergedTags } : {},
+        ...sentryCtxScrubbed ? { sentryContext: sentryCtxScrubbed } : {},
         sessionId: getSessionId(),
         reporterToken: getReporterToken(),
         sdkPackage: MUSHI_SDK_PACKAGE,
         sdkVersion: MUSHI_SDK_VERSION,
+        sentryEventId: sentryCtx?.eventId,
+        sentryReplayId: sentryCtx?.replayId,
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       emit("report:submitted", { reportId: report.id });
@@ -3208,12 +3467,43 @@ function createInstance(config) {
       const res = await apiClient.submitReport(report);
       if (res.ok) {
         emit("report:sent", { reportId: res.data?.reportId });
+        try {
+          if (config.sentry && res.data?.reportId) tagSentryScope(res.data.reportId);
+        } catch {
+        }
         return res.data?.reportId ?? null;
       }
       await offlineQueue.enqueue(report);
       emit("report:failed", { reportId: report.id, error: res.error });
       return null;
     },
+    async captureException(error, options) {
+      const normalised = normaliseThrown(error);
+      breadcrumbs.add({
+        category: "lifecycle",
+        level: "error",
+        message: `Mushi.captureException(${normalised.name}): ${normalised.message}`,
+        ...normalised.stack ? { data: { stack: normalised.stack.slice(0, 500) } } : {}
+      });
+      const description = options?.description?.trim() || `${normalised.name}: ${normalised.message}` || "Uncaught exception";
+      return sdk.captureEvent({
+        description,
+        category: options?.category ?? "bug",
+        severity: options?.severity ?? "high",
+        ...options?.component ? { component: options.component } : {},
+        ...options?.tags ? { tags: options.tags } : {},
+        source: options?.source ?? "captureException",
+        error: {
+          name: normalised.name,
+          message: normalised.message,
+          ...normalised.stack ? { stack: normalised.stack } : {}
+        },
+        metadata: {
+          ...options?.metadata ?? {},
+          ...normalised.cause ? { cause: normalised.cause } : {}
+        }
+      });
+    },
     identify(userId, traits) {
       userInfo = { id: userId, ...traits?.email ? { email: traits.email } : {}, ...traits?.name ? { name: traits.name } : {} };
       if (traits) {
@@ -3221,6 +3511,36 @@ function createInstance(config) {
           if (k !== "email" && k !== "name") customMetadata[`user.${k}`] = v;
         }
       }
+      breadcrumbs.add({
+        category: "lifecycle",
+        level: "info",
+        message: `Mushi.identify(${userId})`
+      });
+    },
+    addBreadcrumb(crumb) {
+      breadcrumbs.add(crumb);
+    },
+    getBreadcrumbs() {
+      return breadcrumbs.getAll();
+    },
+    setTag(key, value) {
+      if (typeof key !== "string" || key.length === 0) return;
+      stickyTags[key] = value;
+    },
+    setTags(tags) {
+      if (!tags || typeof tags !== "object") return;
+      for (const [k, v] of Object.entries(tags)) {
+        if (typeof k === "string" && k.length > 0) {
+          stickyTags[k] = v;
+        }
+      }
+    },
+    clearTag(key) {
+      if (typeof key === "string" && key.length > 0) {
+        delete stickyTags[key];
+        return;
+      }
+      for (const k of Object.keys(stickyTags)) delete stickyTags[k];
     }
   };
   return sdk;
@@ -3458,10 +3778,144 @@ function createNoopInstance() {
       instance = null;
     },
     captureEvent: async () => null,
+    captureException: async () => null,
     identify: () => {
+    },
+    addBreadcrumb: () => {
+    },
+    getBreadcrumbs: () => [],
+    setTag: () => {
+    },
+    setTags: () => {
+    },
+    clearTag: () => {
+    }
+  };
+}
+function installAutoBreadcrumbs(buffer) {
+  if (typeof window === "undefined") return () => {
+  };
+  const cleanups = [];
+  try {
+    const dispatchRouteChange = (kind) => {
+      buffer.add({
+        category: "navigation",
+        level: "info",
+        message: `${kind}: ${window.location.pathname}`,
+        data: { url: window.location.href, kind }
+      });
+    };
+    const onPop = () => dispatchRouteChange("popstate");
+    window.addEventListener("popstate", onPop, { passive: true });
+    cleanups.push(() => window.removeEventListener("popstate", onPop));
+    const origPush = window.history.pushState;
+    const origReplace = window.history.replaceState;
+    window.history.pushState = function patched(...args) {
+      const ret = origPush.apply(this, args);
+      try {
+        dispatchRouteChange("pushState");
+      } catch {
+      }
+      return ret;
+    };
+    window.history.replaceState = function patched(...args) {
+      const ret = origReplace.apply(this, args);
+      try {
+        dispatchRouteChange("replaceState");
+      } catch {
+      }
+      return ret;
+    };
+    cleanups.push(() => {
+      window.history.pushState = origPush;
+      window.history.replaceState = origReplace;
+    });
+  } catch {
+  }
+  try {
+    const origError = console.error;
+    const origWarn = console.warn;
+    console.error = function(...args) {
+      try {
+        buffer.add({
+          category: "console",
+          level: "error",
+          message: args.map(stringifyConsoleArg).join(" ")
+        });
+      } catch {
+      }
+      return origError.apply(this, args);
+    };
+    console.warn = function(...args) {
+      try {
+        buffer.add({
+          category: "console",
+          level: "warning",
+          message: args.map(stringifyConsoleArg).join(" ")
+        });
+      } catch {
+      }
+      return origWarn.apply(this, args);
+    };
+    cleanups.push(() => {
+      console.error = origError;
+      console.warn = origWarn;
+    });
+  } catch {
+  }
+  try {
+    const onClick = (ev) => {
+      try {
+        const target = ev.target;
+        if (!(target instanceof Element)) return;
+        let cur = target;
+        let hops = 0;
+        while (cur && hops < 10) {
+          const tid = cur.getAttribute("data-testid");
+          if (tid) {
+            const text = (cur.textContent ?? "").trim().slice(0, 80);
+            buffer.add({
+              category: "ui.click",
+              level: "info",
+              message: `clicked ${tid}${text ? ` \u2014 ${text}` : ""}`,
+              data: { testid: tid, tag: cur.tagName.toLowerCase() }
+            });
+            return;
+          }
+          cur = cur.parentElement;
+          hops++;
+        }
+      } catch {
+      }
+    };
+    document.addEventListener("click", onClick, { passive: true, capture: true });
+    cleanups.push(() => document.removeEventListener("click", onClick, true));
+  } catch {
+  }
+  return () => {
+    for (const c of cleanups) {
+      try {
+        c();
+      } catch {
+      }
     }
   };
 }
+function stringifyConsoleArg(arg) {
+  try {
+    if (arg instanceof Error) {
+      return `${arg.name}: ${arg.message}`;
+    }
+    if (typeof arg === "object" && arg !== null) {
+      const json = JSON.stringify(arg);
+      return json.length > 200 ? `${json.slice(0, 200)}\u2026` : json;
+    }
+    const s = String(arg);
+    return s.length > 200 ? `${s.slice(0, 200)}\u2026` : s;
+  } catch {
+    return `[${typeof arg}]`;
+  }
+}
 
 export { Mushi, MushiWidget, createConsoleCapture, createElementSelector, createNetworkCapture, createPerformanceCapture, createProactiveManager, createScreenshotCapture, createTimelineCapture, getAvailableLocales, getLocale, setupProactiveTriggers };
 //# sourceMappingURL=index.js.map