@devkitio/faultlens 0.1.5

package/dist/nuxt/runtime/nitro-plugin.js

@@ -0,0 +1,51 @@
+import { clientRedact, SDK_VERSION, parseErrorStack } from '../../chunk-LRHXSFK2.js';
+import { createSignedRelayHeaders } from '../../chunk-RXQF7F2E.js';
+import { randomUUID } from 'crypto';
+
+var nitro_plugin_default = defineNitroPlugin((nitroApp) => {
+  nitroApp.hooks.hook("error", async (error, context) => {
+    if (error.stack?.includes("/__faultlens/envelope")) return;
+    const runtime = useRuntimeConfig(context.event).faultLens;
+    if (!runtime.upstream || !runtime.relayKeyId || !runtime.relayKeyVersion || !runtime.relaySecret) return;
+    const id = randomUUID();
+    const requestId = context.event?.node.req.headers["x-request-id"];
+    const envelope = clientRedact({
+      protocolVersion: "1.0",
+      sdkName: "@devkitio/faultlens",
+      sdkVersion: SDK_VERSION,
+      clientType: "nitro",
+      expectedEnvironment: runtime.environment,
+      release: runtime.release,
+      dist: runtime.dist ?? "server",
+      buildId: runtime.release,
+      clientBatchId: randomUUID(),
+      events: [
+        {
+          eventId: id,
+          occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+          type: error.name || "Error",
+          message: error.message.slice(0, 32768),
+          handled: false,
+          mechanism: "nitro.error",
+          level: "error",
+          stack: parseErrorStack(error),
+          tags: typeof requestId === "string" ? { requestId } : {},
+          context: {}
+        }
+      ]
+    });
+    const body = JSON.stringify(envelope);
+    try {
+      await fetch(runtime.upstream, {
+        method: "POST",
+        headers: createSignedRelayHeaders(runtime, body, id),
+        body,
+        redirect: "error",
+        cache: "no-store"
+      });
+    } catch {
+    }
+  });
+});
+
+export { nitro_plugin_default as default };

package/dist/nuxt/runtime/plugin.d.ts

@@ -0,0 +1,3 @@
+declare const _default: any;
+
+export { _default as default };

package/dist/nuxt/runtime/plugin.js

@@ -0,0 +1,22 @@
+import { createErrorMonitor } from '../../chunk-K63I3OJT.js';
+import { installVueErrorMonitor } from '../../chunk-P6Q63P6L.js';
+import '../../chunk-LRHXSFK2.js';
+import { defineNuxtPlugin, useRuntimeConfig } from '#app';
+
+var plugin_default = defineNuxtPlugin({
+  name: "faultlens",
+  enforce: "pre",
+  setup(nuxtApp) {
+    const runtime = useRuntimeConfig().public.faultLens;
+    const monitor = createErrorMonitor({
+      ingest: { mode: "relay", endpoint: runtime.relayEndpoint },
+      expectedEnvironment: runtime.environment,
+      release: runtime.release,
+      ...runtime.dist ? { dist: runtime.dist } : {}
+    });
+    installVueErrorMonitor(nuxtApp.vueApp, monitor);
+    nuxtApp.provide("faultLens", monitor);
+  }
+});
+
+export { plugin_default as default };

package/dist/nuxt/runtime/server-handler.d.ts

@@ -0,0 +1,5 @@
+import * as h3 from 'h3';
+
+declare const _default: h3.EventHandler<h3.EventHandlerRequest, Promise<unknown>>;
+
+export { _default as default };

package/dist/nuxt/runtime/server-handler.js

@@ -0,0 +1,86 @@
+import { createSignedRelayHeaders } from '../../chunk-RXQF7F2E.js';
+import { defineEventHandler, getRequestHeader, setResponseStatus, setResponseHeader } from 'h3';
+
+var MAX_RELAY_BODY_BYTES = 1024 * 1024;
+async function readLimitedBody(event) {
+  const contentLength = Number(getRequestHeader(event, "content-length") ?? "0");
+  if (Number.isFinite(contentLength) && contentLength > MAX_RELAY_BODY_BYTES) {
+    throw new Error("payload_too_large");
+  }
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    let exceeded = false;
+    event.node.req.on("data", (chunk) => {
+      if (exceeded) return;
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      size += buffer.length;
+      if (size > MAX_RELAY_BODY_BYTES) {
+        exceeded = true;
+        chunks.length = 0;
+        event.node.req.resume();
+        reject(new Error("payload_too_large"));
+        return;
+      }
+      chunks.push(buffer);
+    });
+    event.node.req.once("error", reject);
+    event.node.req.once("end", () => {
+      if (!exceeded) resolve(chunks.length > 0 ? Buffer.concat(chunks).toString("utf8") : void 0);
+    });
+  });
+}
+var server_handler_default = defineEventHandler(async (event) => {
+  if (getRequestHeader(event, "content-encoding")) {
+    setResponseStatus(event, 415);
+    return { code: "unsupported_encoding", retryable: false };
+  }
+  let body;
+  try {
+    body = await readLimitedBody(event);
+  } catch (error) {
+    if (error instanceof Error && error.message === "payload_too_large") {
+      setResponseStatus(event, 413);
+      return { code: "payload_too_large", retryable: false };
+    }
+    throw error;
+  }
+  if (!body) {
+    setResponseStatus(event, 400);
+    return { code: "invalid_envelope", retryable: false };
+  }
+  const runtime = useRuntimeConfig(event).faultLens;
+  if (!runtime.upstream || !runtime.relayKeyId || !runtime.relayKeyVersion || !runtime.relaySecret) {
+    setResponseStatus(event, 503);
+    return { code: "relay_not_configured", retryable: true };
+  }
+  let eventId;
+  try {
+    const envelope = JSON.parse(body);
+    const firstEventId = envelope.events?.[0]?.eventId;
+    if (typeof firstEventId !== "string") throw new Error("\u7F3A\u5C11\u4E8B\u4EF6 ID");
+    eventId = firstEventId;
+    body = JSON.stringify({ ...envelope, clientType: "browser" });
+  } catch {
+    setResponseStatus(event, 400);
+    return { code: "invalid_envelope", retryable: false };
+  }
+  try {
+    const response = await fetch(runtime.upstream, {
+      method: "POST",
+      headers: createSignedRelayHeaders(runtime, body, eventId),
+      body,
+      redirect: "error",
+      cache: "no-store"
+    });
+    setResponseStatus(event, response.status);
+    setResponseHeader(event, "cache-control", "no-store");
+    const text = await response.text();
+    return text ? JSON.parse(text) : void 0;
+  } catch {
+    setResponseStatus(event, 503);
+    return { code: "relay_unavailable", retryable: true, retryAfterMs: 1e3 };
+  }
+});
+
+export { server_handler_default as default };

package/dist/react/index.d.ts

@@ -0,0 +1,26 @@
+import { Component, ReactNode, ErrorInfo } from 'react';
+import { E as ErrorMonitor, M as MonitorOptions } from '../types-DxONWOH8.js';
+
+interface ReactMonitorOptions extends Omit<MonitorOptions, "ingest"> {
+    ingest: {
+        mode: "direct";
+        dsn: string;
+    };
+}
+declare function createReactErrorMonitor(options: ReactMonitorOptions): ErrorMonitor;
+interface FaultLensErrorBoundaryProps {
+    monitor: ErrorMonitor;
+    children?: ReactNode;
+    fallback?: ReactNode | ((error: Error) => ReactNode);
+}
+interface FaultLensErrorBoundaryState {
+    error: Error | null;
+}
+declare class FaultLensErrorBoundary extends Component<FaultLensErrorBoundaryProps, FaultLensErrorBoundaryState> {
+    state: FaultLensErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): FaultLensErrorBoundaryState;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    render(): ReactNode;
+}
+
+export { FaultLensErrorBoundary, type FaultLensErrorBoundaryProps, type ReactMonitorOptions, createReactErrorMonitor };

package/dist/react/index.js

@@ -0,0 +1,33 @@
+import { createErrorMonitor } from '../chunk-K63I3OJT.js';
+import '../chunk-LRHXSFK2.js';
+import { Component, createElement } from 'react';
+
+function createReactErrorMonitor(options) {
+  if (options.ingest.mode !== "direct") {
+    throw new Error("React \u6D4F\u89C8\u5668\u96C6\u6210\u53EA\u5141\u8BB8\u4F7F\u7528 Direct DSN");
+  }
+  return createErrorMonitor(options);
+}
+var FaultLensErrorBoundary = class extends Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    this.props.monitor.captureException(error, {
+      handled: true,
+      mechanism: "react.error_boundary",
+      context: { componentStack: info.componentStack }
+    });
+  }
+  render() {
+    const { error } = this.state;
+    if (!error) return this.props.children ?? null;
+    const { fallback } = this.props;
+    if (typeof fallback === "function") return fallback(error);
+    if (fallback !== void 0) return fallback;
+    return createElement("div", { role: "alert" }, "\u9875\u9762\u53D1\u751F\u9519\u8BEF");
+  }
+};
+
+export { FaultLensErrorBoundary, createReactErrorMonitor };

package/dist/testing/index.d.ts

@@ -0,0 +1,11 @@
+import { c as EventTransport, d as EventEnvelope, T as TransportOutcome, M as MonitorOptions, E as ErrorMonitor } from '../types-DxONWOH8.js';
+
+declare class TestTransport implements EventTransport {
+    readonly envelopes: EventEnvelope[];
+    private readonly outcomes;
+    constructor(outcomes?: TransportOutcome[]);
+    send(envelope: EventEnvelope): Promise<TransportOutcome>;
+}
+declare function createTestMonitor(options: MonitorOptions, transport: EventTransport): ErrorMonitor;
+
+export { TestTransport, createTestMonitor };

package/dist/testing/index.js

@@ -0,0 +1,24 @@
+import { createMonitorRuntime } from '../chunk-LRHXSFK2.js';
+
+// src/testing/index.ts
+var TestTransport = class {
+  envelopes = [];
+  outcomes;
+  constructor(outcomes = [{ kind: "accepted" }]) {
+    this.outcomes = [...outcomes];
+  }
+  async send(envelope) {
+    this.envelopes.push(structuredClone(envelope));
+    return this.outcomes.shift() ?? { kind: "accepted" };
+  }
+};
+function createTestMonitor(options, transport) {
+  let sequence = 0;
+  return createMonitorRuntime(options, {
+    transport,
+    random: () => 0,
+    createEventId: () => `test-event-${++sequence}`
+  });
+}
+
+export { TestTransport, createTestMonitor };

package/dist/types-DxONWOH8.d.ts

@@ -0,0 +1,136 @@
+interface StackFrame {
+    filename: string;
+    function?: string;
+    line?: number;
+    column?: number;
+    inApp: boolean;
+    debugId?: string;
+}
+interface ErrorEvent {
+    eventId: string;
+    occurredAt: string;
+    type: string;
+    message: string;
+    handled: boolean;
+    mechanism: string;
+    level: "debug" | "info" | "warning" | "error" | "fatal";
+    stack: StackFrame[];
+    tags: Record<string, string>;
+    context?: unknown;
+    fingerprint?: string[];
+}
+interface EventEnvelope {
+    protocolVersion: string;
+    sdkName: string;
+    sdkVersion: string;
+    clientType: "browser" | "relay" | "nitro" | "testing";
+    expectedEnvironment?: string;
+    release: string;
+    dist?: string;
+    buildId: string;
+    clientBatchId: string;
+    events: ErrorEvent[];
+}
+
+type ContextMode = "minimal" | "full";
+type IngestConfig = {
+    mode: "direct";
+    dsn: string;
+} | {
+    mode: "relay";
+    endpoint: string;
+};
+interface CaptureOptions {
+    handled?: boolean;
+    mechanism?: string;
+    context?: unknown;
+    level?: ErrorEvent["level"];
+    tags?: Record<string, string>;
+}
+interface Breadcrumb {
+    category: string;
+    message: string;
+    level?: "debug" | "info" | "warning" | "error";
+    timestamp?: string;
+    data?: unknown;
+}
+interface MonitorOptions {
+    ingest: IngestConfig;
+    expectedEnvironment: string;
+    release: string;
+    dist?: string;
+    buildId?: string;
+    contextMode?: ContextMode;
+    ignoreError?: (error: unknown) => boolean;
+    beforeSend?: (event: ErrorEvent) => ErrorEvent | null | Promise<ErrorEvent | null>;
+    sampleRate?: number;
+    queueLimit?: number;
+}
+interface MonitorStatus {
+    queueLength: number;
+    recentSendStatus: "idle" | "sending" | "accepted" | "retryable" | "permanent_error";
+    droppedReasons: Readonly<Record<string, number>>;
+    protocolVersion: string;
+    sdkVersion: string;
+    lastRateLimitedAt: string | null;
+    remotelyDisabled: boolean;
+}
+interface ErrorMonitor {
+    captureException(error: unknown, options?: CaptureOptions): string;
+    captureMessage(message: string, options?: CaptureOptions): string;
+    addBreadcrumb(breadcrumb: Breadcrumb): void;
+    setUser(user: Record<string, unknown> | null): void;
+    setContext(name: string, value: unknown): void;
+    getStatus(): MonitorStatus;
+    flush(timeout: number): Promise<boolean>;
+    close(): Promise<boolean>;
+}
+type TransportOutcome = {
+    kind: "accepted";
+} | {
+    kind: "retryable";
+    retryAfterMs: number;
+} | {
+    kind: "permanent_error";
+    code: string;
+} | {
+    kind: "network_error";
+};
+interface EventTransport {
+    send(envelope: EventEnvelope): Promise<TransportOutcome>;
+    loadRemoteConfig?(): Promise<RemoteSdkConfig | undefined>;
+}
+interface RemoteSdkConfig {
+    enabled?: boolean;
+    sampleRate?: number;
+    errorTypeAllowlist?: string[];
+    queueLimit?: number;
+    retryBaseMs?: number;
+}
+interface RuntimeDependencies {
+    transport: EventTransport;
+    now: () => Date;
+    random: () => number;
+    createEventId: () => string;
+    persistentQueue: PersistentEventQueue;
+    sendLease: SendLease;
+    installGlobalHandlers: (monitor: ErrorMonitor, transportPath: string) => () => void;
+}
+interface PersistentEventQueue {
+    load(now: number): Promise<PersistedQueueItem[]>;
+    put(item: PersistedQueueItem): Promise<void>;
+    remove(ids: string[]): Promise<void>;
+    clear(): Promise<void>;
+}
+interface PersistedQueueItem {
+    id: string;
+    event: ErrorEvent;
+    enqueuedAt: number;
+    bytes: number;
+}
+interface SendLease {
+    acquire(now: number): boolean;
+    release(): void;
+}
+
+export type { Breadcrumb as B, CaptureOptions as C, ErrorMonitor as E, IngestConfig as I, MonitorOptions as M, RuntimeDependencies as R, TransportOutcome as T, ContextMode as a, MonitorStatus as b, EventTransport as c, EventEnvelope as d };

package/dist/vue/index.d.ts

@@ -0,0 +1,13 @@
+import { E as ErrorMonitor } from '../types-DxONWOH8.js';
+
+interface VueLikeApp {
+    config: {
+        errorHandler?: (error: unknown, instance: unknown, info: string) => unknown;
+    };
+}
+declare function installVueErrorMonitor(app: VueLikeApp, monitor: ErrorMonitor): () => void;
+declare function createVueErrorMonitorPlugin(monitor: ErrorMonitor): {
+    install(app: VueLikeApp): void;
+};
+
+export { type VueLikeApp, createVueErrorMonitorPlugin, installVueErrorMonitor };

package/dist/vue/index.js

@@ -0,0 +1 @@
+export { createVueErrorMonitorPlugin, installVueErrorMonitor } from '../chunk-P6Q63P6L.js';

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@devkitio/faultlens",
+  "version": "0.1.5",
+  "description": "FaultLens 的 Browser、Node、Vue、Nuxt、React 与 Web 框架错误采集 SDK",
+  "license": "UNLICENSED",
+  "private": false,
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22 <25"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./vue": {
+      "types": "./dist/vue/index.d.ts",
+      "import": "./dist/vue/index.js"
+    },
+    "./nuxt": {
+      "types": "./dist/nuxt/index.d.ts",
+      "import": "./dist/nuxt/index.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.js"
+    },
+    "./express": {
+      "types": "./dist/express/index.d.ts",
+      "import": "./dist/express/index.js"
+    },
+    "./fastify": {
+      "types": "./dist/fastify/index.d.ts",
+      "import": "./dist/fastify/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js"
+    }
+  },
+  "bin": {
+    "faultlens": "dist/cli/index.js"
+  },
+  "files": ["dist"],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "prepack": "pnpm build"
+  },
+  "peerDependencies": {
+    "@nuxt/kit": ">=4.1.0 <5",
+    "@nuxt/schema": ">=4.1.0 <5",
+    "express": ">=4.18.0 <6",
+    "fastify": ">=4.0.0 <6",
+    "h3": ">=1.15.0 <2",
+    "react": ">=18.0.0 <20",
+    "vue": ">=3.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@nuxt/kit": {
+      "optional": true
+    },
+    "@nuxt/schema": {
+      "optional": true
+    },
+    "express": {
+      "optional": true
+    },
+    "fastify": {
+      "optional": true
+    },
+    "h3": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@faultlens/security": "workspace:*",
+    "@nuxt/kit": "4.1.0",
+    "@nuxt/schema": "4.1.0",
+    "@types/react": "19.1.11",
+    "h3": "1.15.9",
+    "react": "19.1.1",
+    "tsup": "8.5.0",
+    "vue": "3.5.20"
+  }
+}