@kenkaiiii/error-mom 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ken Kai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @kenkaiiii/error-mom
+
+Automatic browser and Node.js error capture for a self-hosted Error Mom deployment.
+
+```ts
+import { initErrorMom } from "@kenkaiiii/error-mom";
+
+initErrorMom({
+  server: "https://errors.example.com",
+  projectKey: "em_ingest_...",
+  release: "1.0.0",
+});
+```
+
+Use `@kenkaiiii/error-mom/node` for Node.js. The browser adapter retries through local storage; the Node adapter writes a private JSONL spool before upload.
+
+See the repository README for framework setup, privacy controls, and deployment instructions.

package/dist/chunk-ORM4B33R.js

@@ -0,0 +1,86 @@
+// src/shared.ts
+var SDK_NAME = "@kenkaiiii/error-mom";
+var SDK_VERSION = "0.1.0";
+var MAX_BREADCRUMBS = 50;
+var SECRET_KEY = /authorization|cookie|password|passwd|secret|token|api[-_]?key|session/i;
+var URL_CREDENTIAL = /([?&](?:token|key|secret|password|code)=)[^&\s]*/gi;
+var EMAIL = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+function redactString(value) {
+  return value.replace(URL_CREDENTIAL, "$1[REDACTED]").replace(EMAIL, "[REDACTED_EMAIL]");
+}
+function sanitize(value, depth = 0) {
+  if (depth > 5) return "[TRUNCATED]";
+  if (typeof value === "string") return redactString(value).slice(0, 1e4);
+  if (typeof value === "number" || typeof value === "boolean" || value === null) return value;
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: redactString(value.message),
+      stack: value.stack ? redactString(value.stack) : void 0
+    };
+  }
+  if (Array.isArray(value)) return value.slice(0, 50).map((item) => sanitize(item, depth + 1));
+  if (typeof value === "object" && value) {
+    return Object.fromEntries(
+      Object.entries(value).slice(0, 100).map(([key, item]) => [
+        key,
+        SECRET_KEY.test(key) ? "[REDACTED]" : sanitize(item, depth + 1)
+      ])
+    );
+  }
+  return String(value).slice(0, 2e3);
+}
+function printable(value) {
+  if (typeof value === "string") return redactString(value);
+  try {
+    return JSON.stringify(sanitize(value));
+  } catch {
+    return String(value);
+  }
+}
+function toError(value) {
+  if (value instanceof Error) return value;
+  if (typeof value === "string") return new Error(value);
+  return new Error(printable(value));
+}
+function platformName() {
+  if (typeof navigator !== "undefined") return navigator.platform || "browser";
+  return typeof process !== "undefined" ? process.platform : "unknown";
+}
+function createEvent(value, options, breadcrumbs, runtime, captureContext = {}) {
+  const error = toError(value);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    eventId: crypto.randomUUID(),
+    timestamp: now,
+    level: captureContext.level ?? "error",
+    error: {
+      name: redactString(error.name || "Error").slice(0, 500),
+      message: redactString(error.message || "Unknown error").slice(0, 1e4),
+      ...error.stack ? { stack: redactString(error.stack).slice(0, 1e5) } : {}
+    },
+    environment: options.environment ?? "production",
+    ...options.release ? { release: options.release } : {},
+    platform: platformName(),
+    runtime,
+    ...typeof location !== "undefined" ? { url: redactString(location.href) } : {},
+    ...captureContext.culprit ? { culprit: redactString(captureContext.culprit) } : {},
+    ...options.installationId ? { installationId: options.installationId } : {},
+    breadcrumbs: breadcrumbs.slice(-MAX_BREADCRUMBS),
+    tags: { ...options.tags, ...captureContext.tags },
+    context: sanitize(captureContext.context ?? {}) ?? {}
+  };
+}
+function endpoint(server) {
+  return `${server.replace(/\/$/, "")}/api/v1/events`;
+}
+
+export {
+  SDK_NAME,
+  SDK_VERSION,
+  MAX_BREADCRUMBS,
+  redactString,
+  printable,
+  createEvent,
+  endpoint
+};

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { Breadcrumb } from '@kenkaiiii/error-mom-protocol';
+export { Breadcrumb, ErrorEvent } from '@kenkaiiii/error-mom-protocol';
+import { C as CommonOptions, a as CaptureContext } from './shared-idwux7-h.js';
+
+interface BrowserOptions extends CommonOptions {
+    captureFailedRequests?: boolean;
+    flushIntervalMs?: number;
+    maxQueueSize?: number;
+}
+interface ErrorMomBrowser {
+    captureError(error: unknown, context?: CaptureContext): string;
+    addBreadcrumb(breadcrumb: Omit<Breadcrumb, "timestamp"> & {
+        timestamp?: string;
+    }): void;
+    flush(): Promise<void>;
+    dispose(): void;
+}
+declare function initErrorMom(options: BrowserOptions): ErrorMomBrowser;
+
+export { type BrowserOptions, CaptureContext, type ErrorMomBrowser, initErrorMom };

package/dist/index.js

@@ -0,0 +1,187 @@
+import {
+  MAX_BREADCRUMBS,
+  SDK_NAME,
+  SDK_VERSION,
+  createEvent,
+  endpoint,
+  printable,
+  redactString
+} from "./chunk-ORM4B33R.js";
+
+// src/index.ts
+var clients = /* @__PURE__ */ new Map();
+var BrowserClient = class {
+  options;
+  breadcrumbs = [];
+  queue = [];
+  flushPromise;
+  restore = [];
+  interval;
+  storageKey;
+  nativeFetch;
+  constructor(options) {
+    this.options = {
+      ...options,
+      captureConsoleErrors: options.captureConsoleErrors ?? true,
+      captureFailedRequests: options.captureFailedRequests ?? true,
+      flushIntervalMs: options.flushIntervalMs ?? 5e3,
+      maxQueueSize: options.maxQueueSize ?? 100
+    };
+    this.storageKey = `error-mom:${options.projectKey.slice(-12)}`;
+    this.restoreQueue();
+    this.installGlobalHandlers();
+    this.interval = setInterval(() => void this.flush(), this.options.flushIntervalMs);
+    void this.flush();
+  }
+  captureError(error, context = {}) {
+    const event = createEvent(error, this.options, this.breadcrumbs, "browser", context);
+    this.queue.push(event);
+    this.queue = this.queue.slice(-this.options.maxQueueSize);
+    this.persistQueue();
+    void this.flush();
+    return event.eventId;
+  }
+  addBreadcrumb(input) {
+    this.breadcrumbs.push({
+      ...input,
+      timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      message: redactString(input.message).slice(0, 2e3)
+    });
+    if (this.breadcrumbs.length > MAX_BREADCRUMBS) this.breadcrumbs.shift();
+  }
+  flush() {
+    if (this.flushPromise) return this.flushPromise;
+    if (this.queue.length === 0) return Promise.resolve();
+    this.flushPromise = this.sendBatch().finally(() => {
+      this.flushPromise = void 0;
+    });
+    return this.flushPromise;
+  }
+  async sendBatch() {
+    const batch = this.queue.slice(0, 20);
+    try {
+      const transport = this.nativeFetch ?? fetch;
+      const response = await transport(endpoint(this.options.server), {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-error-mom-key": this.options.projectKey
+        },
+        body: JSON.stringify({ events: batch, sdk: { name: SDK_NAME, version: SDK_VERSION } }),
+        keepalive: true
+      });
+      if (!response.ok) return;
+      const accepted = new Set(batch.map((event) => event.eventId));
+      this.queue = this.queue.filter((event) => !accepted.has(event.eventId));
+      this.persistQueue();
+    } catch {
+    }
+  }
+  dispose() {
+    if (this.interval) clearInterval(this.interval);
+    for (const callback of this.restore.reverse()) callback();
+    clients.delete(this.options.projectKey);
+  }
+  installGlobalHandlers() {
+    if (typeof window === "undefined") return;
+    const onError = (event) => {
+      this.captureError(event.error ?? new Error(event.message), {
+        level: "fatal",
+        ...event.filename ? { culprit: `${event.filename}:${event.lineno}:${event.colno}` } : {}
+      });
+    };
+    const onRejection = (event) => {
+      this.captureError(event.reason, { culprit: "unhandledrejection" });
+    };
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") void this.flush();
+    };
+    window.addEventListener("error", onError);
+    window.addEventListener("unhandledrejection", onRejection);
+    document.addEventListener("visibilitychange", onVisibility);
+    this.restore.push(() => window.removeEventListener("error", onError));
+    this.restore.push(() => window.removeEventListener("unhandledrejection", onRejection));
+    this.restore.push(() => document.removeEventListener("visibilitychange", onVisibility));
+    this.captureConsole();
+    this.captureFetchFailures();
+  }
+  captureConsole() {
+    const levels = ["debug", "info", "warn", "error"];
+    for (const level of levels) {
+      const original = console[level].bind(console);
+      console[level] = (...args) => {
+        original(...args);
+        const message = args.map(printable).join(" ").slice(0, 2e3);
+        this.addBreadcrumb({
+          category: "console",
+          level: level === "warn" ? "warning" : level,
+          message
+        });
+        if (level === "error" && this.options.captureConsoleErrors) {
+          this.captureError(args[0] instanceof Error ? args[0] : new Error(message), {
+            culprit: "console.error"
+          });
+        }
+      };
+      this.restore.push(() => {
+        console[level] = original;
+      });
+    }
+  }
+  captureFetchFailures() {
+    if (!this.options.captureFailedRequests || typeof fetch === "undefined") return;
+    const original = fetch.bind(globalThis);
+    this.nativeFetch = original;
+    globalThis.fetch = async (input, init) => {
+      const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      if (url.startsWith(this.options.server)) return original(input, init);
+      const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+      try {
+        const response = await original(input, init);
+        if (response.status >= 500) {
+          this.captureError(
+            new Error(`${method} ${redactString(url)} returned ${response.status}`),
+            {
+              culprit: "fetch",
+              tags: { statusCode: String(response.status), method }
+            }
+          );
+        }
+        return response;
+      } catch (error) {
+        this.captureError(error, { culprit: "fetch", tags: { method, url: redactString(url) } });
+        throw error;
+      }
+    };
+    this.restore.push(() => {
+      globalThis.fetch = original;
+    });
+  }
+  restoreQueue() {
+    try {
+      const stored = localStorage.getItem(this.storageKey);
+      if (stored) this.queue = JSON.parse(stored);
+    } catch {
+      this.queue = [];
+    }
+  }
+  persistQueue() {
+    try {
+      localStorage.setItem(this.storageKey, JSON.stringify(this.queue));
+    } catch {
+    }
+  }
+};
+function initErrorMom(options) {
+  if (!options.server || !options.projectKey) {
+    throw new Error("Error Mom requires both server and projectKey");
+  }
+  const existing = clients.get(options.projectKey);
+  if (existing) return existing;
+  const client = new BrowserClient(options);
+  clients.set(options.projectKey, client);
+  return client;
+}
+export {
+  initErrorMom
+};

package/dist/node.d.ts

@@ -0,0 +1,20 @@
+import { Breadcrumb } from '@kenkaiiii/error-mom-protocol';
+export { Breadcrumb, ErrorEvent } from '@kenkaiiii/error-mom-protocol';
+import { a as CaptureContext, C as CommonOptions } from './shared-idwux7-h.js';
+
+interface NodeOptions extends CommonOptions {
+    spoolDirectory?: string;
+    flushIntervalMs?: number;
+    maxQueueSize?: number;
+}
+interface ErrorMomNode {
+    captureError(error: unknown, context?: CaptureContext): string;
+    addBreadcrumb(breadcrumb: Omit<Breadcrumb, "timestamp"> & {
+        timestamp?: string;
+    }): void;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+}
+declare function initErrorMom(options: NodeOptions): ErrorMomNode;
+
+export { CaptureContext, type ErrorMomNode, type NodeOptions, initErrorMom };

package/dist/node.js

@@ -0,0 +1,169 @@
+import {
+  MAX_BREADCRUMBS,
+  SDK_NAME,
+  SDK_VERSION,
+  createEvent,
+  endpoint,
+  printable
+} from "./chunk-ORM4B33R.js";
+
+// src/node.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, rename, writeFile, appendFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+var NodeClient = class {
+  options;
+  breadcrumbs = [];
+  queue = [];
+  operation = Promise.resolve();
+  interval;
+  spoolFile;
+  handlers = [];
+  flushPromise;
+  constructor(options) {
+    this.options = {
+      ...options,
+      captureConsoleErrors: options.captureConsoleErrors ?? true,
+      flushIntervalMs: options.flushIntervalMs ?? 5e3,
+      maxQueueSize: options.maxQueueSize ?? 1e3,
+      spoolDirectory: options.spoolDirectory ?? join(homedir(), ".error-mom", "spool")
+    };
+    this.spoolFile = join(this.options.spoolDirectory, `${safeFilePart(options.projectKey)}.jsonl`);
+    this.operation = this.restoreQueue();
+    this.installProcessHandlers();
+    this.captureConsole();
+    this.interval = setInterval(() => void this.flush(), this.options.flushIntervalMs);
+    void this.flush();
+  }
+  captureError(error, context = {}) {
+    const event = createEvent(
+      error,
+      this.options,
+      this.breadcrumbs,
+      `node ${process.version}`,
+      context
+    );
+    this.queue.push(event);
+    this.queue = this.queue.slice(-this.options.maxQueueSize);
+    this.operation = this.operation.then(async () => {
+      await mkdir(this.options.spoolDirectory, { recursive: true });
+      await appendFile(this.spoolFile, `${JSON.stringify(event)}
+`, { mode: 384 });
+    }).catch(() => void 0);
+    void this.flush();
+    return event.eventId;
+  }
+  addBreadcrumb(input) {
+    this.breadcrumbs.push({ ...input, timestamp: input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() });
+    if (this.breadcrumbs.length > MAX_BREADCRUMBS) this.breadcrumbs.shift();
+  }
+  flush() {
+    if (this.flushPromise) return this.flushPromise;
+    this.flushPromise = this.sendBatch().finally(() => {
+      this.flushPromise = void 0;
+    });
+    return this.flushPromise;
+  }
+  async sendBatch() {
+    await this.operation;
+    if (this.queue.length === 0) return;
+    const batch = this.queue.slice(0, 50);
+    try {
+      const response = await fetch(endpoint(this.options.server), {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "x-error-mom-key": this.options.projectKey
+        },
+        body: JSON.stringify({ events: batch, sdk: { name: SDK_NAME, version: SDK_VERSION } })
+      });
+      if (!response.ok) return;
+      const accepted = new Set(batch.map((event) => event.eventId));
+      this.queue = this.queue.filter((event) => !accepted.has(event.eventId));
+      this.operation = this.operation.then(() => this.rewriteSpool());
+      await this.operation;
+    } catch {
+    }
+  }
+  async dispose() {
+    if (this.interval) clearInterval(this.interval);
+    for (const remove of this.handlers.reverse()) remove();
+    await this.flush();
+    if (singleton === this) singleton = void 0;
+  }
+  installProcessHandlers() {
+    const onUncaught = (error) => {
+      this.captureError(error, { level: "fatal", culprit: "uncaughtException" });
+    };
+    const onRejection = (reason) => {
+      this.captureError(reason, { culprit: "unhandledRejection" });
+    };
+    process.on("uncaughtExceptionMonitor", onUncaught);
+    process.on("unhandledRejection", onRejection);
+    this.handlers.push(() => process.off("uncaughtExceptionMonitor", onUncaught));
+    this.handlers.push(() => process.off("unhandledRejection", onRejection));
+  }
+  captureConsole() {
+    const levels = ["debug", "info", "warn", "error"];
+    for (const level of levels) {
+      const original = console[level].bind(console);
+      console[level] = (...args) => {
+        original(...args);
+        const message = args.map(printable).join(" ").slice(0, 2e3);
+        this.addBreadcrumb({
+          category: "console",
+          level: level === "warn" ? "warning" : level,
+          message
+        });
+        if (level === "error" && this.options.captureConsoleErrors) {
+          this.captureError(args[0] instanceof Error ? args[0] : new Error(message), {
+            culprit: "console.error"
+          });
+        }
+      };
+      this.handlers.push(() => {
+        console[level] = original;
+      });
+    }
+  }
+  async restoreQueue() {
+    try {
+      const contents = await readFile(this.spoolFile, "utf8");
+      const restored = contents.split("\n").filter(Boolean).flatMap((line) => {
+        try {
+          return [JSON.parse(line)];
+        } catch {
+          return [];
+        }
+      });
+      const merged = new Map(
+        [...restored, ...this.queue].map((event) => [event.eventId, event])
+      );
+      this.queue = [...merged.values()].slice(-this.options.maxQueueSize);
+    } catch {
+    }
+  }
+  async rewriteSpool() {
+    await mkdir(this.options.spoolDirectory, { recursive: true });
+    const temporary = `${this.spoolFile}.${process.pid}.tmp`;
+    const contents = this.queue.map((event) => JSON.stringify(event)).join("\n");
+    await writeFile(temporary, contents ? `${contents}
+` : "", { mode: 384 });
+    await rename(temporary, this.spoolFile);
+  }
+};
+function safeFilePart(projectKey) {
+  return createHash("sha256").update(projectKey).digest("hex").slice(0, 32);
+}
+var singleton;
+function initErrorMom(options) {
+  if (!options.server || !options.projectKey) {
+    throw new Error("Error Mom requires both server and projectKey");
+  }
+  singleton ??= new NodeClient(options);
+  return singleton;
+}
+export {
+  initErrorMom
+};

package/dist/shared-idwux7-h.d.ts

@@ -0,0 +1,19 @@
+import { ErrorEvent } from '@kenkaiiii/error-mom-protocol';
+
+interface CommonOptions {
+    server: string;
+    projectKey: string;
+    environment?: string;
+    release?: string;
+    installationId?: string;
+    tags?: Record<string, string>;
+    captureConsoleErrors?: boolean;
+}
+interface CaptureContext {
+    level?: ErrorEvent["level"];
+    culprit?: string;
+    tags?: Record<string, string>;
+    context?: Record<string, unknown>;
+}
+
+export type { CommonOptions as C, CaptureContext as a };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@kenkaiiii/error-mom",
+  "version": "0.1.0",
+  "description": "Automatic browser and Node.js error capture for self-hosted Error Mom",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "@kenkaiiii/error-mom-protocol": "0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsup src/index.ts src/node.ts --format esm --dts --clean",
+    "check": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}