@codmir/sdk 0.1.1

package/dist/nextjs/index.cjs

@@ -0,0 +1,371 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/nextjs/index.ts
+var nextjs_exports = {};
+__export(nextjs_exports, {
+  addBreadcrumb: () => addBreadcrumb2,
+  captureException: () => captureException2,
+  captureMessage: () => captureMessage2,
+  captureRequestError: () => captureRequestError,
+  captureRouterError: () => captureRouterError,
+  captureRouterTransitionStart: () => captureRouterTransitionStart,
+  close: () => close2,
+  flush: () => flush2,
+  getClient: () => getClient,
+  init: () => init2,
+  isOverseerInitialized: () => isOverseerInitialized,
+  setTag: () => setTag2,
+  setTags: () => setTags2,
+  setUser: () => setUser2
+});
+module.exports = __toCommonJS(nextjs_exports);
+
+// src/overseer/index.ts
+var import_nanoid = require("nanoid");
+var OverseerClient = class {
+  config;
+  user = null;
+  tags = {};
+  breadcrumbs = [];
+  eventQueue = [];
+  flushTimer = null;
+  isInitialized = false;
+  constructor(config = {}) {
+    this.config = {
+      dsn: config.dsn || "",
+      environment: config.environment || "development",
+      release: config.release || "unknown",
+      enabled: config.enabled ?? true,
+      debug: config.debug ?? false,
+      sampleRate: config.sampleRate ?? 1,
+      tracesSampleRate: config.tracesSampleRate ?? 0,
+      replaysSessionSampleRate: config.replaysSessionSampleRate ?? 0,
+      replaysOnErrorSampleRate: config.replaysOnErrorSampleRate ?? 1,
+      beforeSend: config.beforeSend || ((e) => e),
+      initialUser: config.initialUser,
+      initialTags: config.initialTags || {}
+    };
+    if (this.config.initialUser) {
+      this.user = this.config.initialUser;
+    }
+    if (this.config.initialTags) {
+      this.tags = { ...this.config.initialTags };
+    }
+  }
+  init() {
+    if (this.isInitialized) return;
+    this.isInitialized = true;
+    if (this.config.debug) {
+      console.log("[Overseer] Initialized", {
+        dsn: this.config.dsn,
+        environment: this.config.environment
+      });
+    }
+  }
+  captureException(error, context) {
+    if (!this.config.enabled) return "";
+    if (!this.shouldSample(this.config.sampleRate)) return "";
+    const eventId = (0, import_nanoid.nanoid)();
+    const err = error instanceof Error ? error : new Error(String(error));
+    const event = {
+      id: eventId,
+      type: "error",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level: "error",
+      message: err.message,
+      exception: {
+        type: err.name,
+        value: err.message,
+        stacktrace: this.parseStackTrace(err.stack),
+        mechanism: { type: "generic", handled: true }
+      },
+      user: this.user || void 0,
+      tags: { ...this.tags },
+      extra: context,
+      breadcrumbs: [...this.breadcrumbs],
+      environment: this.config.environment,
+      release: this.config.release,
+      sdk: { name: "@codmir/sdk", version: "1.0.0" }
+    };
+    this.sendEvent(event);
+    return eventId;
+  }
+  captureMessage(message, level = "info") {
+    if (!this.config.enabled) return "";
+    if (!this.shouldSample(this.config.sampleRate)) return "";
+    const eventId = (0, import_nanoid.nanoid)();
+    const event = {
+      id: eventId,
+      type: "message",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      user: this.user || void 0,
+      tags: { ...this.tags },
+      breadcrumbs: [...this.breadcrumbs],
+      environment: this.config.environment,
+      release: this.config.release,
+      sdk: { name: "@codmir/sdk", version: "1.0.0" }
+    };
+    this.sendEvent(event);
+    return eventId;
+  }
+  setUser(user) {
+    this.user = user;
+  }
+  setTag(key, value) {
+    this.tags[key] = value;
+  }
+  setTags(tags) {
+    this.tags = { ...this.tags, ...tags };
+  }
+  setExtra(key, value) {
+  }
+  addBreadcrumb(breadcrumb) {
+    this.breadcrumbs.push({
+      ...breadcrumb,
+      timestamp: breadcrumb.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.breadcrumbs.length > 100) {
+      this.breadcrumbs = this.breadcrumbs.slice(-100);
+    }
+  }
+  async flush(timeout) {
+    if (this.eventQueue.length === 0) return true;
+    const events = [...this.eventQueue];
+    this.eventQueue = [];
+    try {
+      await this.sendBatch(events);
+      return true;
+    } catch {
+      this.eventQueue.unshift(...events);
+      return false;
+    }
+  }
+  close() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+    }
+    this.flush();
+  }
+  // Private methods
+  shouldSample(rate) {
+    return Math.random() < rate;
+  }
+  parseStackTrace(stack) {
+    if (!stack) return [];
+    return stack.split("\n").slice(1).map((line) => {
+      const match = line.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/);
+      if (match) {
+        return {
+          function: match[1],
+          filename: match[2],
+          lineno: parseInt(match[3], 10),
+          colno: parseInt(match[4], 10),
+          in_app: !match[2].includes("node_modules")
+        };
+      }
+      return { function: line.trim() };
+    }).filter((f) => f.function);
+  }
+  sendEvent(event) {
+    const processed = this.config.beforeSend(event);
+    if (!processed) return;
+    this.eventQueue.push(processed);
+    if (this.flushTimer) clearTimeout(this.flushTimer);
+    this.flushTimer = setTimeout(() => this.flush(), 1e3);
+  }
+  async sendBatch(events) {
+    if (!this.config.dsn) {
+      if (this.config.debug) {
+        console.log("[Overseer] No DSN configured, events:", events);
+      }
+      return;
+    }
+    const endpoint = this.config.dsn.endsWith("/ingest") ? this.config.dsn : `${this.config.dsn}/ingest`;
+    await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ events })
+    });
+  }
+};
+var client = null;
+function init(config = {}) {
+  client = new OverseerClient(config);
+  client.init();
+}
+function getClient() {
+  return client;
+}
+function captureException(error, context) {
+  return client?.captureException(error, context) || "";
+}
+function captureMessage(message, level) {
+  return client?.captureMessage(message, level) || "";
+}
+function setUser(user) {
+  client?.setUser(user);
+}
+function setTag(key, value) {
+  client?.setTag(key, value);
+}
+function setTags(tags) {
+  client?.setTags(tags);
+}
+function addBreadcrumb(breadcrumb) {
+  client?.addBreadcrumb(breadcrumb);
+}
+function flush(timeout) {
+  return client?.flush(timeout) || Promise.resolve(true);
+}
+function close() {
+  client?.close();
+}
+
+// src/nextjs/index.ts
+var isInitialized = false;
+function init2(config = {}) {
+  if (isInitialized) return;
+  const {
+    captureUnhandledErrors = true,
+    captureUnhandledRejections = true,
+    trackRouteChanges = true,
+    enableReplay = false,
+    ...coreConfig
+  } = config;
+  init(coreConfig);
+  isInitialized = true;
+  if (typeof window !== "undefined") {
+    if (captureUnhandledErrors) {
+      window.addEventListener("error", (event) => {
+        captureException(event.error || event.message, {
+          handled: false,
+          mechanism: "onerror"
+        });
+      });
+    }
+    if (captureUnhandledRejections) {
+      window.addEventListener("unhandledrejection", (event) => {
+        captureException(event.reason, {
+          handled: false,
+          mechanism: "onunhandledrejection"
+        });
+      });
+    }
+    if (trackRouteChanges) {
+      setupRouteTracking();
+    }
+  }
+}
+function setupRouteTracking() {
+  if (typeof window === "undefined") return;
+  addBreadcrumb({
+    category: "navigation",
+    message: window.location.pathname,
+    data: {
+      from: document.referrer || void 0,
+      to: window.location.href
+    }
+  });
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  history.pushState = function(...args) {
+    const result = originalPushState.apply(this, args);
+    addBreadcrumb({
+      category: "navigation",
+      message: "pushState",
+      data: { to: args[2] }
+    });
+    return result;
+  };
+  history.replaceState = function(...args) {
+    const result = originalReplaceState.apply(this, args);
+    addBreadcrumb({
+      category: "navigation",
+      message: "replaceState",
+      data: { to: args[2] }
+    });
+    return result;
+  };
+  window.addEventListener("popstate", () => {
+    addBreadcrumb({
+      category: "navigation",
+      message: "popstate",
+      data: { to: window.location.href }
+    });
+  });
+}
+function captureRequestError(error, errorContext, request) {
+  const eventId = captureException(error, {
+    mechanism: "server",
+    ...errorContext,
+    request: request ? {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers)
+    } : void 0
+  });
+  return eventId;
+}
+async function captureRouterError(error, request, context) {
+  captureException(error, {
+    mechanism: "nextjs-router",
+    routerKind: context.routerKind,
+    routePath: context.routePath,
+    routeType: context.routeType,
+    request
+  });
+}
+function captureRouterTransitionStart(route) {
+  addBreadcrumb({
+    category: "navigation",
+    message: `Navigating to ${route}`,
+    data: { route }
+  });
+}
+var captureException2 = captureException;
+var captureMessage2 = captureMessage;
+var setUser2 = setUser;
+var setTag2 = setTag;
+var setTags2 = setTags;
+var addBreadcrumb2 = addBreadcrumb;
+var flush2 = flush;
+var close2 = close;
+function isOverseerInitialized() {
+  return isInitialized && getClient() !== null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addBreadcrumb,
+  captureException,
+  captureMessage,
+  captureRequestError,
+  captureRouterError,
+  captureRouterTransitionStart,
+  close,
+  flush,
+  getClient,
+  init,
+  isOverseerInitialized,
+  setTag,
+  setTags,
+  setUser
+});

package/dist/nextjs/index.d.cts

@@ -0,0 +1,77 @@
+import { O as OverseerConfig, c as captureException$1, a as captureMessage$1, s as setUser$1, h as setTag$1, b as setTags$1, d as addBreadcrumb$1, f as flush$1, e as close$1 } from '../index-BlgYnCLd.cjs';
+export { B as Breadcrumb, j as OverseerEvent, S as SeverityLevel, U as UserContext, g as getClient } from '../index-BlgYnCLd.cjs';
+
+/**
+ * @codmir/sdk/nextjs - Next.js Integration
+ *
+ * Automatic error tracking, session replay, and performance
+ * monitoring for Next.js applications.
+ *
+ * @example
+ * ```typescript
+ * // instrumentation.ts
+ * import * as Codmir from '@codmir/sdk/nextjs';
+ *
+ * Codmir.init({
+ *   dsn: process.env.NEXT_PUBLIC_CODMIR_DSN,
+ *   environment: process.env.NODE_ENV,
+ * });
+ * ```
+ */
+
+interface NextjsConfig extends OverseerConfig {
+    /** Automatically capture unhandled errors */
+    captureUnhandledErrors?: boolean;
+    /** Automatically capture unhandled promise rejections */
+    captureUnhandledRejections?: boolean;
+    /** Track route changes as breadcrumbs */
+    trackRouteChanges?: boolean;
+    /** Enable session replay */
+    enableReplay?: boolean;
+}
+interface RequestError {
+    digest?: string;
+    message?: string;
+    name?: string;
+    stack?: string;
+}
+interface ErrorContext {
+    routerKind: string;
+    routePath: string;
+    routeType: string;
+    renderSource?: string;
+    revalidateReason?: string;
+}
+declare function init(config?: NextjsConfig): void;
+/**
+ * Capture a server-side request error (App Router)
+ */
+declare function captureRequestError(error: RequestError, errorContext: Partial<ErrorContext>, request?: Request): string;
+/**
+ * Handler for Next.js App Router errors
+ * Use in instrumentation.ts: export const onRequestError = captureRouterError
+ */
+declare function captureRouterError(error: RequestError, request: {
+    path: string;
+    method: string;
+    headers: Record<string, string>;
+}, context: ErrorContext): Promise<void>;
+/**
+ * Track router transition start (for performance)
+ */
+declare function captureRouterTransitionStart(route: string): void;
+
+declare const captureException: typeof captureException$1;
+declare const captureMessage: typeof captureMessage$1;
+declare const setUser: typeof setUser$1;
+declare const setTag: typeof setTag$1;
+declare const setTags: typeof setTags$1;
+declare const addBreadcrumb: typeof addBreadcrumb$1;
+declare const flush: typeof flush$1;
+declare const close: typeof close$1;
+/**
+ * Check if Overseer is initialized
+ */
+declare function isOverseerInitialized(): boolean;
+
+export { type ErrorContext, type NextjsConfig, OverseerConfig, type RequestError, addBreadcrumb, captureException, captureMessage, captureRequestError, captureRouterError, captureRouterTransitionStart, close, flush, init, isOverseerInitialized, setTag, setTags, setUser };

package/dist/nextjs/index.d.ts

@@ -0,0 +1,77 @@
+import { O as OverseerConfig, c as captureException$1, a as captureMessage$1, s as setUser$1, h as setTag$1, b as setTags$1, d as addBreadcrumb$1, f as flush$1, e as close$1 } from '../index-BlgYnCLd.js';
+export { B as Breadcrumb, j as OverseerEvent, S as SeverityLevel, U as UserContext, g as getClient } from '../index-BlgYnCLd.js';
+
+/**
+ * @codmir/sdk/nextjs - Next.js Integration
+ *
+ * Automatic error tracking, session replay, and performance
+ * monitoring for Next.js applications.
+ *
+ * @example
+ * ```typescript
+ * // instrumentation.ts
+ * import * as Codmir from '@codmir/sdk/nextjs';
+ *
+ * Codmir.init({
+ *   dsn: process.env.NEXT_PUBLIC_CODMIR_DSN,
+ *   environment: process.env.NODE_ENV,
+ * });
+ * ```
+ */
+
+interface NextjsConfig extends OverseerConfig {
+    /** Automatically capture unhandled errors */
+    captureUnhandledErrors?: boolean;
+    /** Automatically capture unhandled promise rejections */
+    captureUnhandledRejections?: boolean;
+    /** Track route changes as breadcrumbs */
+    trackRouteChanges?: boolean;
+    /** Enable session replay */
+    enableReplay?: boolean;
+}
+interface RequestError {
+    digest?: string;
+    message?: string;
+    name?: string;
+    stack?: string;
+}
+interface ErrorContext {
+    routerKind: string;
+    routePath: string;
+    routeType: string;
+    renderSource?: string;
+    revalidateReason?: string;
+}
+declare function init(config?: NextjsConfig): void;
+/**
+ * Capture a server-side request error (App Router)
+ */
+declare function captureRequestError(error: RequestError, errorContext: Partial<ErrorContext>, request?: Request): string;
+/**
+ * Handler for Next.js App Router errors
+ * Use in instrumentation.ts: export const onRequestError = captureRouterError
+ */
+declare function captureRouterError(error: RequestError, request: {
+    path: string;
+    method: string;
+    headers: Record<string, string>;
+}, context: ErrorContext): Promise<void>;
+/**
+ * Track router transition start (for performance)
+ */
+declare function captureRouterTransitionStart(route: string): void;
+
+declare const captureException: typeof captureException$1;
+declare const captureMessage: typeof captureMessage$1;
+declare const setUser: typeof setUser$1;
+declare const setTag: typeof setTag$1;
+declare const setTags: typeof setTags$1;
+declare const addBreadcrumb: typeof addBreadcrumb$1;
+declare const flush: typeof flush$1;
+declare const close: typeof close$1;
+/**
+ * Check if Overseer is initialized
+ */
+declare function isOverseerInitialized(): boolean;
+
+export { type ErrorContext, type NextjsConfig, OverseerConfig, type RequestError, addBreadcrumb, captureException, captureMessage, captureRequestError, captureRouterError, captureRouterTransitionStart, close, flush, init, isOverseerInitialized, setTag, setTags, setUser };

package/dist/nextjs/index.js

@@ -0,0 +1,142 @@
+import {
+  addBreadcrumb,
+  captureException,
+  captureMessage,
+  close,
+  flush,
+  getClient,
+  init,
+  setTag,
+  setTags,
+  setUser
+} from "../chunk-T7OAAOG2.js";
+import "../chunk-MLKGABMK.js";
+
+// src/nextjs/index.ts
+var isInitialized = false;
+function init2(config = {}) {
+  if (isInitialized) return;
+  const {
+    captureUnhandledErrors = true,
+    captureUnhandledRejections = true,
+    trackRouteChanges = true,
+    enableReplay = false,
+    ...coreConfig
+  } = config;
+  init(coreConfig);
+  isInitialized = true;
+  if (typeof window !== "undefined") {
+    if (captureUnhandledErrors) {
+      window.addEventListener("error", (event) => {
+        captureException(event.error || event.message, {
+          handled: false,
+          mechanism: "onerror"
+        });
+      });
+    }
+    if (captureUnhandledRejections) {
+      window.addEventListener("unhandledrejection", (event) => {
+        captureException(event.reason, {
+          handled: false,
+          mechanism: "onunhandledrejection"
+        });
+      });
+    }
+    if (trackRouteChanges) {
+      setupRouteTracking();
+    }
+  }
+}
+function setupRouteTracking() {
+  if (typeof window === "undefined") return;
+  addBreadcrumb({
+    category: "navigation",
+    message: window.location.pathname,
+    data: {
+      from: document.referrer || void 0,
+      to: window.location.href
+    }
+  });
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  history.pushState = function(...args) {
+    const result = originalPushState.apply(this, args);
+    addBreadcrumb({
+      category: "navigation",
+      message: "pushState",
+      data: { to: args[2] }
+    });
+    return result;
+  };
+  history.replaceState = function(...args) {
+    const result = originalReplaceState.apply(this, args);
+    addBreadcrumb({
+      category: "navigation",
+      message: "replaceState",
+      data: { to: args[2] }
+    });
+    return result;
+  };
+  window.addEventListener("popstate", () => {
+    addBreadcrumb({
+      category: "navigation",
+      message: "popstate",
+      data: { to: window.location.href }
+    });
+  });
+}
+function captureRequestError(error, errorContext, request) {
+  const eventId = captureException(error, {
+    mechanism: "server",
+    ...errorContext,
+    request: request ? {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers)
+    } : void 0
+  });
+  return eventId;
+}
+async function captureRouterError(error, request, context) {
+  captureException(error, {
+    mechanism: "nextjs-router",
+    routerKind: context.routerKind,
+    routePath: context.routePath,
+    routeType: context.routeType,
+    request
+  });
+}
+function captureRouterTransitionStart(route) {
+  addBreadcrumb({
+    category: "navigation",
+    message: `Navigating to ${route}`,
+    data: { route }
+  });
+}
+var captureException2 = captureException;
+var captureMessage2 = captureMessage;
+var setUser2 = setUser;
+var setTag2 = setTag;
+var setTags2 = setTags;
+var addBreadcrumb2 = addBreadcrumb;
+var flush2 = flush;
+var close2 = close;
+function isOverseerInitialized() {
+  return isInitialized && getClient() !== null;
+}
+export {
+  addBreadcrumb2 as addBreadcrumb,
+  captureException2 as captureException,
+  captureMessage2 as captureMessage,
+  captureRequestError,
+  captureRouterError,
+  captureRouterTransitionStart,
+  close2 as close,
+  flush2 as flush,
+  getClient,
+  init2 as init,
+  isOverseerInitialized,
+  setTag2 as setTag,
+  setTags2 as setTags,
+  setUser2 as setUser
+};