@solenai/monitor 0.1.0

package/README.md

@@ -0,0 +1,94 @@
+# @solen/monitor
+
+Report runtime errors to Solen MetaShift incident webhooks. Payloads use a Sentry-compatible shape so MetaShift normalizes them automatically. No runtime dependencies—Node 18+ built-in `fetch` only.
+
+## Install
+
+```bash
+npm install @solen/monitor
+```
+
+## Quick setup
+
+```ts
+import { monitor } from '@solen/monitor';
+
+const { captureError } = monitor({
+  webhookUrl: process.env.SOLEN_WEBHOOK_URL!,
+  secret: process.env.SOLEN_WEBHOOK_SECRET!,
+  environment: 'production',
+});
+```
+
+Calling `monitor()` registers `uncaughtException` and `unhandledRejection` handlers and returns manual capture helpers.
+
+## Express middleware
+
+```ts
+import express from 'express';
+import { monitor } from '@solen/monitor';
+import { solenErrorHandler } from '@solen/monitor/express';
+
+const { captureError } = monitor({
+  webhookUrl: process.env.SOLEN_WEBHOOK_URL!,
+  secret: process.env.SOLEN_WEBHOOK_SECRET!,
+});
+
+const app = express();
+app.use(solenErrorHandler({ captureError }));
+```
+
+`solenErrorHandler` captures the error with route, method, and status, then calls `next(err)` so your existing error handlers still run.
+
+## Manual capture
+
+```ts
+import { monitor } from '@solen/monitor';
+
+const { captureError, captureMessage } = monitor({
+  webhookUrl: process.env.SOLEN_WEBHOOK_URL!,
+  secret: process.env.SOLEN_WEBHOOK_SECRET!,
+});
+
+try {
+  await chargeCustomer(orderId);
+} catch (err) {
+  await captureError(err, {
+    extra: { orderId },
+    tags: { service: 'billing' },
+  });
+  throw err;
+}
+
+await captureMessage('Stripe webhook replay detected', { level: 'warning' });
+```
+
+## Webhook URL and secret
+
+Create an incident webhook endpoint in the Solen dashboard:
+
+**https://solenai.ca/integrations/webhooks**
+
+Each endpoint provides:
+
+- **Webhook URL** — MetaShift ingest URL (`/api/webhooks/incident/{endpointId}`)
+- **Secret** — sent as the `X-Solen-Secret` header on every request
+
+Store both in environment variables (for example `SOLEN_WEBHOOK_URL` and `SOLEN_WEBHOOK_SECRET`) and pass them to `monitor()`.
+
+## Fastify
+
+```ts
+import Fastify from 'fastify';
+import { monitor } from '@solen/monitor';
+import { solenFastifyPlugin } from '@solen/monitor/fastify';
+
+const { captureError } = monitor({ webhookUrl, secret });
+const app = Fastify();
+await app.register(solenFastifyPlugin, { captureError });
+```
+
+## Requirements
+
+- Node.js 18+
+- Optional peers: `express` (for `@solen/monitor/express`), `fastify` (for `@solen/monitor/fastify`)

package/dist/client.d.ts

@@ -0,0 +1,27 @@
+import type { CaptureContext, CaptureLevel, SentryWebhookPayload, SolenMonitorOptions } from './types.js';
+export declare class SolenMonitorError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export declare function buildSentryWebhookPayload(params: {
+    title: string;
+    message?: string;
+    level?: CaptureLevel;
+    environment?: string;
+    url?: string;
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+}): SentryWebhookPayload;
+export declare class SolenMonitor {
+    private readonly webhookUrl;
+    private readonly secret;
+    constructor(options: SolenMonitorOptions);
+    /** Report an exception using a Sentry-compatible webhook payload. */
+    captureException(error: unknown, context?: CaptureContext): Promise<void>;
+    /** Report a message using a Sentry-compatible webhook payload. */
+    captureMessage(message: string, context?: CaptureContext): Promise<void>;
+    /** POST the payload to the configured webhook. */
+    send(payload: SentryWebhookPayload): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,YAAY,EACZ,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAEpB,qBAAa,iBAAkB,SAAQ,KAAK;IAGxC,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,IAAI,EAAE,OAAO;gBAFtB,OAAO,EAAE,MAAM,EACN,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,OAAO;CAKzB;AAgCD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,GAAG,oBAAoB,CAkCvB;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAEpB,OAAO,EAAE,mBAAmB;IAKxC,qEAAqE;IAC/D,gBAAgB,CACpB,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,IAAI,CAAC;IAgBhB,kEAAkE;IAC5D,cAAc,CAClB,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,IAAI,CAAC;IAkBhB,kDAAkD;IAC5C,IAAI,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;CA8BzD"}

package/dist/client.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolenMonitor = exports.SolenMonitorError = void 0;
+exports.buildSentryWebhookPayload = buildSentryWebhookPayload;
+class SolenMonitorError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.status = status;
+        this.body = body;
+        this.name = 'SolenMonitorError';
+    }
+}
+exports.SolenMonitorError = SolenMonitorError;
+function requireNonEmpty(value, field) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error(`SolenMonitor: ${field} is required`);
+    }
+    return trimmed;
+}
+function errorTitle(error) {
+    if (error instanceof Error) {
+        return error.message.trim() || error.name || 'Error';
+    }
+    const text = String(error).trim();
+    return text || 'Unknown error';
+}
+function errorDetail(error) {
+    if (error instanceof Error && error.stack) {
+        return error.stack;
+    }
+    return undefined;
+}
+function eventTags(tags) {
+    if (!tags)
+        return undefined;
+    const entries = Object.entries(tags).filter(([, v]) => v.trim().length > 0);
+    if (entries.length === 0)
+        return undefined;
+    return entries.map(([k, v]) => `${k}:${v}`);
+}
+function buildSentryWebhookPayload(params) {
+    const level = params.level ?? 'error';
+    const title = params.title.trim() || 'Incident';
+    const message = params.message?.trim() || title;
+    const tags = eventTags(params.tags);
+    const event = {
+        message,
+        title,
+        level,
+        environment: params.environment,
+        web_url: params.url,
+        url: params.url,
+        ...(tags ? { tags } : {}),
+        ...(params.extra && Object.keys(params.extra).length > 0
+            ? { extra: params.extra }
+            : {}),
+    };
+    return {
+        action: 'created',
+        installation: { uuid: 'solen-monitor' },
+        data: {
+            issue: {
+                title,
+                level,
+                permalink: params.url,
+                web_url: params.url,
+            },
+            event,
+        },
+        level,
+        message,
+    };
+}
+class SolenMonitor {
+    webhookUrl;
+    secret;
+    constructor(options) {
+        this.webhookUrl = requireNonEmpty(options.webhookUrl, 'webhookUrl');
+        this.secret = requireNonEmpty(options.secret, 'secret');
+    }
+    /** Report an exception using a Sentry-compatible webhook payload. */
+    async captureException(error, context) {
+        const title = errorTitle(error);
+        const stack = errorDetail(error);
+        await this.send(buildSentryWebhookPayload({
+            title,
+            message: stack ? `${title}\n\n${stack}` : title,
+            level: context?.level ?? 'error',
+            environment: context?.environment,
+            url: context?.url,
+            tags: context?.tags,
+            extra: context?.extra,
+        }));
+    }
+    /** Report a message using a Sentry-compatible webhook payload. */
+    async captureMessage(message, context) {
+        const text = message.trim();
+        if (!text) {
+            throw new Error('SolenMonitor: message must be non-empty');
+        }
+        await this.send(buildSentryWebhookPayload({
+            title: text,
+            message: text,
+            level: context?.level ?? 'info',
+            environment: context?.environment,
+            url: context?.url,
+            tags: context?.tags,
+            extra: context?.extra,
+        }));
+    }
+    /** POST the payload to the configured webhook. */
+    async send(payload) {
+        const res = await fetch(this.webhookUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Solen-Secret': this.secret,
+            },
+            body: JSON.stringify(payload),
+        });
+        const text = await res.text();
+        let body = text;
+        if (text.length > 0) {
+            try {
+                body = JSON.parse(text);
+            }
+            catch {
+                body = text;
+            }
+        }
+        else {
+            body = {};
+        }
+        if (!res.ok) {
+            const msg = typeof body === 'object' && body && 'error' in body
+                ? String(body.error)
+                : `HTTP ${res.status}`;
+            throw new SolenMonitorError(msg, res.status, body);
+        }
+    }
+}
+exports.SolenMonitor = SolenMonitor;

package/dist/handlers.d.ts

@@ -0,0 +1,11 @@
+import type { CaptureContext } from './types.js';
+export type ProcessCapture = {
+    captureError: (error: unknown, context?: CaptureContext) => Promise<void>;
+};
+export type RegisterProcessHandlersOptions = {
+    environment?: string;
+    appName?: string;
+};
+/** Register Node process error handlers that report via {@link ProcessCapture.captureError}. */
+export declare function registerProcessHandlers(capture: ProcessCapture, options?: RegisterProcessHandlersOptions): void;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../src/handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,MAAM,cAAc,GAAG;IAC3B,YAAY,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3E,CAAC;AAEF,MAAM,MAAM,8BAA8B,GAAG;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAoBF,gGAAgG;AAChG,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,8BAA8B,GACvC,IAAI,CAkBN"}

package/dist/handlers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerProcessHandlers = registerProcessHandlers;
+function baseTags(appName) {
+    const name = appName?.trim();
+    return name ? { app: name } : undefined;
+}
+function handlerContext(level, source, options) {
+    return {
+        level,
+        environment: options?.environment,
+        tags: baseTags(options?.appName),
+        extra: { source },
+    };
+}
+/** Register Node process error handlers that report via {@link ProcessCapture.captureError}. */
+function registerProcessHandlers(capture, options) {
+    process.on('uncaughtException', (error) => {
+        capture
+            .captureError(error, handlerContext('critical', 'uncaughtException', options))
+            .catch(() => {
+            /* reporting must not throw */
+        })
+            .finally(() => {
+            process.exit(1);
+        });
+    });
+    process.on('unhandledRejection', (reason) => {
+        void capture.captureError(reason, handlerContext('error', 'unhandledRejection', options));
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { CaptureContext, MonitorOptions } from './types.js';
+export type { CaptureContext, CaptureLevel, MonitorOptions, SentryWebhookData, SentryWebhookEvent, SentryWebhookIssue, SentryWebhookPayload, SolenMonitorOptions, } from './types.js';
+export { buildSentryWebhookPayload, SolenMonitor, SolenMonitorError, } from './client.js';
+export { registerProcessHandlers } from './handlers.js';
+export type { ProcessCapture, RegisterProcessHandlersOptions } from './handlers.js';
+export type MonitorHandle = {
+    captureError: (error: unknown, context?: CaptureContext) => Promise<void>;
+    captureMessage: (message: string, context?: CaptureContext) => Promise<void>;
+};
+/**
+ * Start monitoring: registers `uncaughtException` / `unhandledRejection` handlers
+ * and returns manual capture helpers.
+ */
+export declare function monitor(options: MonitorOptions): MonitorHandle;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjE,YAAY,EACV,cAAc,EACd,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,yBAAyB,EACzB,YAAY,EACZ,iBAAiB,GAClB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AACxD,YAAY,EAAE,cAAc,EAAE,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAEpF,MAAM,MAAM,aAAa,GAAG;IAC1B,YAAY,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,cAAc,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9E,CAAC;AAUF;;;GAGG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,aAAa,CAsC9D"}

package/dist/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerProcessHandlers = exports.SolenMonitorError = exports.SolenMonitor = exports.buildSentryWebhookPayload = void 0;
+exports.monitor = monitor;
+const client_js_1 = require("./client.js");
+const handlers_js_1 = require("./handlers.js");
+var client_js_2 = require("./client.js");
+Object.defineProperty(exports, "buildSentryWebhookPayload", { enumerable: true, get: function () { return client_js_2.buildSentryWebhookPayload; } });
+Object.defineProperty(exports, "SolenMonitor", { enumerable: true, get: function () { return client_js_2.SolenMonitor; } });
+Object.defineProperty(exports, "SolenMonitorError", { enumerable: true, get: function () { return client_js_2.SolenMonitorError; } });
+var handlers_js_2 = require("./handlers.js");
+Object.defineProperty(exports, "registerProcessHandlers", { enumerable: true, get: function () { return handlers_js_2.registerProcessHandlers; } });
+function mergeTags(base, extra) {
+    if (!base && !extra)
+        return undefined;
+    return { ...base, ...extra };
+}
+/**
+ * Start monitoring: registers `uncaughtException` / `unhandledRejection` handlers
+ * and returns manual capture helpers.
+ */
+function monitor(options) {
+    const client = new client_js_1.SolenMonitor({
+        webhookUrl: options.webhookUrl,
+        secret: options.secret,
+    });
+    const defaultTags = options.appName?.trim()
+        ? { app: options.appName.trim() }
+        : undefined;
+    const withDefaults = (context) => ({
+        environment: context?.environment ?? options.environment,
+        level: context?.level,
+        url: context?.url,
+        tags: mergeTags(defaultTags, context?.tags),
+        extra: context?.extra,
+    });
+    const captureError = async (error, context) => {
+        await client.captureException(error, withDefaults(context));
+    };
+    const captureMessage = async (message, context) => {
+        await client.captureMessage(message, withDefaults(context));
+    };
+    (0, handlers_js_1.registerProcessHandlers)({ captureError }, { environment: options.environment, appName: options.appName });
+    return { captureError, captureMessage };
+}

package/dist/integrations/context.d.ts

@@ -0,0 +1,10 @@
+import type { CaptureContext } from '../types.js';
+export type HttpFramework = 'express' | 'fastify';
+export declare function httpErrorCaptureContext(params: {
+    framework: HttpFramework;
+    route: string;
+    method: string;
+    status: number;
+}): CaptureContext;
+export declare function statusFromError(err: unknown, responseStatus?: number): number;
+//# sourceMappingURL=context.d.ts.map

package/dist/integrations/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/integrations/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,SAAS,CAAC;AAElD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,SAAS,EAAE,aAAa,CAAC;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,GAAG,cAAc,CAMjB;AAED,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,EACZ,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM,CAUR"}

package/dist/integrations/context.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpErrorCaptureContext = httpErrorCaptureContext;
+exports.statusFromError = statusFromError;
+function httpErrorCaptureContext(params) {
+    const { framework, route, method, status } = params;
+    return {
+        level: status >= 500 ? 'error' : 'warning',
+        extra: { framework, route, method, status },
+    };
+}
+function statusFromError(err, responseStatus) {
+    if (typeof responseStatus === 'number' && responseStatus >= 400) {
+        return responseStatus;
+    }
+    if (typeof err === 'object' && err !== null) {
+        const record = err;
+        if (typeof record.status === 'number')
+            return record.status;
+        if (typeof record.statusCode === 'number')
+            return record.statusCode;
+    }
+    return 500;
+}

package/dist/integrations/express.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorRequestHandler } from 'express';
+import type { CaptureContext } from '../types.js';
+export type SolenCapture = {
+    captureError: (error: unknown, context?: CaptureContext) => Promise<void>;
+};
+/**
+ * Express error middleware. Reports the error, then calls `next(err)` so
+ * downstream handlers can still run.
+ */
+export declare function solenErrorHandler(capture: SolenCapture): ErrorRequestHandler;
+//# sourceMappingURL=express.d.ts.map

package/dist/integrations/express.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../src/integrations/express.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3E,CAAC;AAQF;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,YAAY,GAAG,mBAAmB,CAmB5E"}

package/dist/integrations/express.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solenErrorHandler = solenErrorHandler;
+const context_js_1 = require("./context.js");
+function expressRoute(req) {
+    return req.route?.path ?? req.originalUrl ?? req.url ?? req.path ?? '/';
+}
+/**
+ * Express error middleware. Reports the error, then calls `next(err)` so
+ * downstream handlers can still run.
+ */
+function solenErrorHandler(capture) {
+    return (err, req, res, next) => {
+        const status = (0, context_js_1.statusFromError)(err, res.statusCode);
+        const context = (0, context_js_1.httpErrorCaptureContext)({
+            framework: 'express',
+            route: expressRoute(req),
+            method: req.method,
+            status,
+        });
+        void capture
+            .captureError(err, context)
+            .catch(() => {
+            /* reporting must not block downstream handlers */
+        })
+            .finally(() => {
+            next(err);
+        });
+    };
+}

package/dist/integrations/fastify.d.ts

@@ -0,0 +1,12 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { CaptureContext } from '../types.js';
+export type SolenCapture = {
+    captureError: (error: unknown, context?: CaptureContext) => Promise<void>;
+};
+export type SolenFastifyPluginOptions = SolenCapture;
+/**
+ * Fastify plugin that wraps `setErrorHandler`, reports errors, then delegates
+ * to any previously registered error handler.
+ */
+export declare const solenFastifyPlugin: FastifyPluginAsync<SolenFastifyPluginOptions>;
+//# sourceMappingURL=fastify.d.ts.map

package/dist/integrations/fastify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastify.d.ts","sourceRoot":"","sources":["../../src/integrations/fastify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,kBAAkB,EAGnB,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAGlD,MAAM,MAAM,YAAY,GAAG;IACzB,YAAY,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3E,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG,YAAY,CAAC;AAwBrD;;;GAGG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBAAkB,CAAC,yBAAyB,CA8B1E,CAAC"}

package/dist/integrations/fastify.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solenFastifyPlugin = void 0;
+const context_js_1 = require("./context.js");
+function fastifyRoute(request) {
+    return request.routeOptions?.url ?? request.url ?? '/';
+}
+function asFastifyError(error) {
+    if (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string') {
+        return error;
+    }
+    const wrapped = new Error(String(error));
+    wrapped.statusCode = 500;
+    return wrapped;
+}
+function fastifyStatus(error, reply) {
+    return (0, context_js_1.statusFromError)(error, reply.statusCode);
+}
+/**
+ * Fastify plugin that wraps `setErrorHandler`, reports errors, then delegates
+ * to any previously registered error handler.
+ */
+const solenFastifyPlugin = async (fastify, opts) => {
+    const previous = fastify.errorHandler;
+    fastify.setErrorHandler(async (error, request, reply) => {
+        const err = asFastifyError(error);
+        const status = fastifyStatus(err, reply);
+        const context = (0, context_js_1.httpErrorCaptureContext)({
+            framework: 'fastify',
+            route: fastifyRoute(request),
+            method: request.method,
+            status,
+        });
+        try {
+            await opts.captureError(err, context);
+        }
+        catch {
+            /* reporting must not block downstream handlers */
+        }
+        if (previous) {
+            return previous.call(fastify, err, request, reply);
+        }
+        reply.status(status).send({
+            statusCode: status,
+            error: err.name ?? 'Error',
+            message: err.message,
+        });
+    });
+};
+exports.solenFastifyPlugin = solenFastifyPlugin;

package/dist/types.d.ts

@@ -0,0 +1,57 @@
+/** Sentry issue webhook shape (subset) recognized by MetaShift `detectWebhookSource`. */
+export interface SentryWebhookIssue {
+    title?: string;
+    culprit?: string;
+    permalink?: string;
+    web_url?: string;
+    level?: string;
+}
+/** Sentry event webhook shape (subset) recognized by MetaShift `normalizeSentry`. */
+export interface SentryWebhookEvent {
+    message?: string;
+    title?: string;
+    level?: string;
+    environment?: string;
+    web_url?: string;
+    url?: string;
+    tags?: string[] | Record<string, string>;
+    extra?: Record<string, unknown>;
+}
+export interface SentryWebhookData {
+    issue?: SentryWebhookIssue;
+    event?: SentryWebhookEvent;
+    project?: string;
+}
+/** Outbound payload mimicking a Sentry integration webhook for MetaShift normalization. */
+export interface SentryWebhookPayload {
+    action: string;
+    installation?: {
+        uuid?: string;
+    };
+    data: SentryWebhookData;
+    level?: string;
+    message?: string;
+    event?: SentryWebhookEvent;
+}
+export type SolenMonitorOptions = {
+    /** MetaShift incident webhook URL (`/api/webhooks/incident/:endpointId`). */
+    webhookUrl: string;
+    /** Shared secret sent as `X-Solen-Secret`. */
+    secret: string;
+};
+export type CaptureLevel = 'fatal' | 'critical' | 'error' | 'warning' | 'info' | 'debug';
+export type MonitorOptions = {
+    webhookUrl: string;
+    secret: string;
+    environment?: string;
+    appName?: string;
+};
+export type CaptureContext = {
+    environment?: string;
+    level?: CaptureLevel;
+    /** Issue/event permalink shown on the incident. */
+    url?: string;
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,MAAM,WAAW,kBAAkB;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,2FAA2F;AAC3F,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,IAAI,EAAE,iBAAiB,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,YAAY,GACpB,OAAO,GACP,UAAU,GACV,OAAO,GACP,SAAS,GACT,MAAM,GACN,OAAO,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,mDAAmD;IACnD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACjC,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@solenai/monitor",
+  "version": "0.1.0",
+  "description": "Lightweight incident reporter for Solen MetaShift webhooks (Sentry-compatible payload)",
+  "license": "MIT",
+  "author": "Solen",
+  "keywords": [
+    "solen",
+    "monitor",
+    "webhook",
+    "sentry",
+    "incident"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./express": {
+      "types": "./dist/integrations/express.d.ts",
+      "default": "./dist/integrations/express.js"
+    },
+    "./fastify": {
+      "types": "./dist/integrations/fastify.d.ts",
+      "default": "./dist/integrations/fastify.js"
+    }
+  },
+  "peerDependencies": {
+    "express": ">=4.0.0",
+    "fastify": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "fastify": {
+      "optional": true
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.10.0",
+    "fastify": "^5.8.1",
+    "typescript": "^5.3.3"
+  }
+}