@devkitio/faultlens 0.1.5 → 1.0.1

package/dist/cli/index.d.ts

@@ -1 +1,15 @@
 #!/usr/bin/env node
+interface CliOptions {
+    endpoint: string;
+    token: string | undefined;
+    root: string;
+    release: string;
+    environment: string;
+    dist: string;
+    dryRun: boolean;
+    deleteAfterVerify: boolean;
+}
+declare function resolveCliOptions(args: string[], env: NodeJS.ProcessEnv): CliOptions;
+declare function runFaultLensCli(args: string[], env?: NodeJS.ProcessEnv): Promise<void>;
+
+export { resolveCliOptions, runFaultLensCli };

package/dist/cli/index.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
+import { realpathSync } from 'fs';
 import { lstat, readdir, readFile, writeFile, unlink } from 'fs/promises';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { randomUUID, createHash } from 'crypto';
 
 var DEBUG_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
@@ -95,30 +97,48 @@ async function removeUploadedSourceMaps(artifacts) {
 }
 
 // src/cli/index.ts
-function argument(name) {
-  const index = process.argv.indexOf(name);
-  return index >= 0 ? process.argv[index + 1] : void 0;
+function argument(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : void 0;
 }
 function required(value, label) {
   if (!value) throw new Error(`\u7F3A\u5C11 ${label}`);
   return value;
 }
-function environment(name, legacyName) {
-  return process.env[name] ?? process.env[legacyName];
+function environment(env, name, legacyName) {
+  return env[name] ?? env[legacyName];
 }
-function options() {
+function endpoint(value) {
+  const parsed = new URL(required(value, "--endpoint"));
+  if (parsed.protocol !== "https:" && parsed.hostname !== "localhost") {
+    throw new Error("\u670D\u52A1\u5730\u5740\u5FC5\u987B\u4F7F\u7528 HTTPS");
+  }
+  if (parsed.username || parsed.password || parsed.pathname !== "/" || parsed.search || parsed.hash) {
+    throw new Error("\u670D\u52A1\u5730\u5740\u5FC5\u987B\u662F\u65E0\u51ED\u636E\u3001\u8DEF\u5F84\u3001\u67E5\u8BE2\u53C2\u6570\u548C\u7247\u6BB5\u7684\u7AD9\u70B9\u6839\u5730\u5740");
+  }
+  return parsed.origin;
+}
+function resolveCliOptions(args, env) {
   return {
-    endpoint: required(argument("--endpoint") ?? environment("FAULTLENS_SOURCEMAP_ENDPOINT", "MOQU_SOURCEMAP_ENDPOINT"), "--endpoint"),
-    token: required(argument("--token") ?? environment("FAULTLENS_SOURCEMAP_TOKEN", "MOQU_SOURCEMAP_TOKEN"), "--token \u6216 FAULTLENS_SOURCEMAP_TOKEN"),
-    root: path.resolve(required(argument("--root") ?? environment("FAULTLENS_SOURCEMAP_ROOT", "MOQU_SOURCEMAP_ROOT"), "--root \u6216 FAULTLENS_SOURCEMAP_ROOT")),
-    release: required(argument("--release") ?? environment("FAULTLENS_RELEASE", "MOQU_RELEASE"), "--release \u6216 FAULTLENS_RELEASE"),
+    endpoint: endpoint(
+      argument(args, "--endpoint") ?? environment(env, "FAULTLENS_SOURCEMAP_ENDPOINT", "MOQU_SOURCEMAP_ENDPOINT")
+    ),
+    token: argument(args, "--token") ?? environment(env, "FAULTLENS_SOURCEMAP_TOKEN", "MOQU_SOURCEMAP_TOKEN"),
+    root: path.resolve(required(
+      argument(args, "--root") ?? environment(env, "FAULTLENS_SOURCEMAP_ROOT", "MOQU_SOURCEMAP_ROOT"),
+      "--root \u6216 FAULTLENS_SOURCEMAP_ROOT"
+    )),
+    release: required(
+      argument(args, "--release") ?? environment(env, "FAULTLENS_RELEASE", "MOQU_RELEASE"),
+      "--release \u6216 FAULTLENS_RELEASE"
+    ),
     environment: required(
-      argument("--environment") ?? environment("FAULTLENS_ENVIRONMENT", "MOQU_ENVIRONMENT"),
+      argument(args, "--environment") ?? environment(env, "FAULTLENS_ENVIRONMENT", "MOQU_ENVIRONMENT"),
       "--environment \u6216 FAULTLENS_ENVIRONMENT"
     ),
-    dist: argument("--dist") ?? environment("FAULTLENS_DIST", "MOQU_DIST") ?? "default",
-    dryRun: process.argv.includes("--dry-run"),
-    deleteAfterVerify: process.argv.includes("--delete-after-verify")
+    dist: argument(args, "--dist") ?? environment(env, "FAULTLENS_DIST", "MOQU_DIST") ?? "default",
+    dryRun: args.includes("--dry-run"),
+    deleteAfterVerify: args.includes("--delete-after-verify")
   };
 }
 async function upload(config, artifacts) {
@@ -126,11 +146,12 @@ async function upload(config, artifacts) {
     console.info(`\u6F14\u7EC3\u5B8C\u6210\uFF1A\u5C06\u4E0A\u4F20 ${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
     return;
   }
+  const token = required(config.token, "--token \u6216 FAULTLENS_SOURCEMAP_TOKEN");
   for (const current of artifacts) {
     const response = await fetch(`${config.endpoint.replace(/\/$/, "")}/v1/admin/source-maps/artifacts`, {
       method: "PUT",
       headers: {
-        authorization: `Bearer ${config.token}`,
+        authorization: `Bearer ${token}`,
         "content-type": "application/octet-stream",
         "x-faultlens-release": config.release,
         "x-faultlens-environment": config.environment,
@@ -151,10 +172,11 @@ async function upload(config, artifacts) {
   console.info(`\u4E0A\u4F20\u5B8C\u6210\uFF1A${artifacts.length} \u4E2A Source Map \u6587\u4EF6`);
 }
 async function verify(config, artifacts) {
+  const token = required(config.token, "--token \u6216 FAULTLENS_SOURCEMAP_TOKEN");
   const response = await fetch(`${config.endpoint.replace(/\/$/, "")}/v1/admin/source-maps/verify`, {
     method: "POST",
     headers: {
-      authorization: `Bearer ${config.token}`,
+      authorization: `Bearer ${token}`,
       "content-type": "application/json"
     },
     body: JSON.stringify({
@@ -175,18 +197,16 @@ async function verify(config, artifacts) {
   console.info("Source Map \u5236\u54C1\u6E05\u5355\u4E0E\u670D\u52A1\u7AEF\u4E00\u81F4");
 }
 async function doctor(config) {
-  const url = new URL(config.endpoint);
-  if (url.protocol !== "https:" && url.hostname !== "localhost") throw new Error("\u670D\u52A1\u5730\u5740\u5FC5\u987B\u4F7F\u7528 HTTPS");
   if (process.versions.node.split(".")[0] !== "22") {
     console.warn(`\u5F53\u524D Node.js \u4E3A ${process.version}\uFF0C\u751F\u4EA7 CI \u5E94\u4F7F\u7528 Node.js 22`);
   }
   await lstat(config.root);
   console.info("CLI \u914D\u7F6E\u68C0\u67E5\u901A\u8FC7");
 }
-async function main() {
-  const command = process.argv[2];
-  const subcommand = process.argv[3];
-  const config = options();
+async function runFaultLensCli(args, env = process.env) {
+  const command = args[0];
+  const subcommand = args[1];
+  const config = resolveCliOptions(args, env);
   if (command === "doctor") return doctor(config);
   if (command !== "sourcemaps" || !["upload", "verify"].includes(subcommand ?? "")) {
     throw new Error("\u7528\u6CD5\uFF1Afaultlens sourcemaps <upload|verify> [\u53C2\u6570]\uFF0C\u6216 faultlens doctor [\u53C2\u6570]");
@@ -199,7 +219,18 @@ async function main() {
   }
   return verify(config, artifacts);
 }
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : "CLI \u6267\u884C\u5931\u8D25");
-  process.exitCode = 1;
-});
+var currentFile = fileURLToPath(import.meta.url);
+var invokedFile = "";
+try {
+  invokedFile = process.argv[1] ? realpathSync(process.argv[1]) : "";
+} catch {
+  invokedFile = process.argv[1] ? path.resolve(process.argv[1]) : "";
+}
+if (invokedFile === realpathSync(currentFile)) {
+  runFaultLensCli(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : "CLI \u6267\u884C\u5931\u8D25");
+    process.exitCode = 1;
+  });
+}
+
+export { resolveCliOptions, runFaultLensCli };

package/dist/express/index.d.ts

@@ -1,4 +1,4 @@
-import { E as ErrorMonitor } from '../types-DxONWOH8.js';
+import { E as ErrorMonitor } from '../types-hWS-GSV1.js';
 
 interface ExpressRequestLike {
     method?: unknown;

package/dist/fastify/index.d.ts

@@ -1,4 +1,4 @@
-import { E as ErrorMonitor } from '../types-DxONWOH8.js';
+import { E as ErrorMonitor } from '../types-hWS-GSV1.js';
 
 interface FaultLensFastifyPluginOptions {
     monitor: ErrorMonitor;

package/dist/index.d.ts

@@ -1,6 +1,33 @@
-import { M as MonitorOptions, E as ErrorMonitor } from './types-DxONWOH8.js';
-export { B as Breadcrumb, C as CaptureOptions, a as ContextMode, I as IngestConfig, b as MonitorStatus } from './types-DxONWOH8.js';
+import { T as TelemetryTransport, I as IngestConfig, a as TelemetryEnvelope, b as TelemetryTransportOutcome, E as ErrorMonitor, M as MonitorOptions } from './types-hWS-GSV1.js';
+export { B as Breadcrumb, C as CaptureOptions, c as ContextMode, d as MonitorStatus, S as Span, e as SpanOptions, f as TelemetryOptions, g as TraceContext, W as WebVitalInput, h as formatTraceParent, p as parseTraceParent, t as traceContextHeaders } from './types-hWS-GSV1.js';
+
+declare class FetchTelemetryTransport implements TelemetryTransport {
+    private readonly ingest;
+    private readonly fetcher;
+    private readonly now;
+    constructor(ingest: IngestConfig, fetcher?: typeof fetch, now?: () => number);
+    send(envelope: TelemetryEnvelope): Promise<TelemetryTransportOutcome>;
+}
+
+interface FetchInstrumentationTarget {
+    fetch: typeof fetch;
+}
+interface FetchInstrumentationOptions {
+    target?: FetchInstrumentationTarget;
+    shouldTrace?: (input: RequestInfo | URL, init?: RequestInit) => boolean;
+    shouldPropagateTraceContext?: (url: URL) => boolean;
+}
+interface XhrInstrumentationTarget {
+    XMLHttpRequest: typeof XMLHttpRequest;
+}
+interface XhrInstrumentationOptions {
+    target?: XhrInstrumentationTarget;
+    shouldTrace?: (method: string, url: URL | undefined) => boolean;
+    shouldPropagateTraceContext?: (url: URL) => boolean;
+}
+declare function installFetchInstrumentation(monitor: ErrorMonitor, options?: FetchInstrumentationOptions): () => void;
+declare function installXhrInstrumentation(monitor: ErrorMonitor, options?: XhrInstrumentationOptions): () => void;
 
 declare function createErrorMonitor(options: MonitorOptions): ErrorMonitor;
 
-export { ErrorMonitor, MonitorOptions, createErrorMonitor };
+export { ErrorMonitor, type FetchInstrumentationOptions, type FetchInstrumentationTarget, FetchTelemetryTransport, IngestConfig, MonitorOptions, type XhrInstrumentationOptions, type XhrInstrumentationTarget, createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation };

package/dist/index.js

@@ -1,2 +1,2 @@
-export { createErrorMonitor } from './chunk-K63I3OJT.js';
-import './chunk-LRHXSFK2.js';
+export { createErrorMonitor, installFetchInstrumentation, installXhrInstrumentation } from './chunk-DQD732MN.js';
+export { FetchTelemetryTransport, formatTraceParent, parseTraceParent, traceContextHeaders } from './chunk-YQKZEUXA.js';

package/dist/node/index.d.ts

@@ -1,4 +1,52 @@
-import { M as MonitorOptions, c as EventTransport, d as EventEnvelope, T as TransportOutcome, R as RuntimeDependencies, E as ErrorMonitor } from '../types-DxONWOH8.js';
+import { P as PersistentEventQueue, i as PersistedQueueItem, E as ErrorMonitor, M as MonitorOptions, T as TelemetryTransport, a as TelemetryEnvelope, b as TelemetryTransportOutcome, j as EventTransport, k as EventEnvelope, l as TransportOutcome, R as RemoteSdkConfig, m as RemoteConfigLoadResult, n as RuntimeDependencies } from '../types-hWS-GSV1.js';
+import { ClientRequest } from 'node:http';
+
+interface NodeQueueEncryptionKey {
+    id: string;
+    key: Uint8Array;
+}
+interface NodeEncryptedFileQueueOptions {
+    directory: string;
+    encryptionKeys: NodeQueueEncryptionKey[];
+    maxItems?: number;
+    maxBytes?: number;
+    maxAgeMs?: number;
+    lockTimeoutMs?: number;
+    staleLockMs?: number;
+}
+declare class NodeEncryptedFileQueue implements PersistentEventQueue {
+    private readonly directory;
+    private readonly keys;
+    private readonly maxItems;
+    private readonly maxBytes;
+    private readonly maxAgeMs;
+    private readonly lockTimeoutMs;
+    private readonly staleLockMs;
+    private serial;
+    constructor(options: NodeEncryptedFileQueueOptions);
+    load(now: number): Promise<PersistedQueueItem[]>;
+    put(item: PersistedQueueItem): Promise<void>;
+    remove(ids: string[]): Promise<void>;
+    clear(): Promise<void>;
+    private runExclusive;
+    private ensureDirectory;
+    private withLock;
+    private statePath;
+    private readItems;
+    private writeItems;
+}
+
+type NodeHttpRequest = (...args: unknown[]) => ClientRequest;
+interface NodeHttpInstrumentationModule {
+    request: NodeHttpRequest;
+    get: NodeHttpRequest;
+}
+interface NodeHttpInstrumentationOptions {
+    modules?: NodeHttpInstrumentationModule[];
+    shouldTrace?: (method: string, url: URL | undefined) => boolean;
+    shouldPropagateTraceContext?: (url: URL | undefined) => boolean;
+}
+declare function installNodeHttpInstrumentation(monitor: ErrorMonitor, options?: NodeHttpInstrumentationOptions): () => void;
 
 interface NodeRelayIngestConfig {
     mode: "relay";
@@ -10,6 +58,7 @@ interface NodeRelayIngestConfig {
 interface NodeMonitorOptions extends Omit<MonitorOptions, "ingest"> {
     ingest: NodeRelayIngestConfig;
     captureGlobalErrors?: boolean;
+    persistentQueue?: NodeEncryptedFileQueueOptions;
 }
 interface NodeRelayTransportOptions {
     fetcher?: typeof fetch;
@@ -26,9 +75,19 @@ declare class NodeRelayTransport implements EventTransport {
     private readonly endpoint;
     constructor(ingest: NodeRelayIngestConfig, options?: NodeRelayTransportOptions);
     send(envelope: EventEnvelope): Promise<TransportOutcome>;
+    loadRemoteConfig(): Promise<RemoteSdkConfig | undefined>;
+    loadRemoteConfigResult(): Promise<RemoteConfigLoadResult>;
+}
+declare class NodeRelayTelemetryTransport implements TelemetryTransport {
+    private readonly ingest;
+    private readonly fetcher;
+    private readonly requestTimeoutMs;
+    private readonly endpoint;
+    constructor(ingest: NodeRelayIngestConfig, options?: Pick<NodeRelayTransportOptions, "fetcher" | "requestTimeoutMs">);
+    send(envelope: TelemetryEnvelope): Promise<TelemetryTransportOutcome>;
 }
 declare function createNodeErrorMonitor(options: NodeMonitorOptions, overrides?: {
     transport?: EventTransport;
 } & Partial<RuntimeDependencies>): ErrorMonitor;
 
-export { type NodeMonitorOptions, type NodeRelayIngestConfig, NodeRelayTransport, type NodeRelayTransportOptions, createNodeErrorMonitor };
+export { NodeEncryptedFileQueue, type NodeEncryptedFileQueueOptions, type NodeHttpInstrumentationModule, type NodeHttpInstrumentationOptions, type NodeMonitorOptions, type NodeQueueEncryptionKey, type NodeRelayIngestConfig, NodeRelayTelemetryTransport, NodeRelayTransport, type NodeRelayTransportOptions, createNodeErrorMonitor, installNodeHttpInstrumentation };