@futurewindai/wotchi 0.1.0-beta.1

package/dist/cjs/core/stack-frame.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeStackFrame = normalizeStackFrame;
+exports.selectApplicationFrame = selectApplicationFrame;
+const INTERNAL_MARKERS = ["node_modules/", "node:internal/", "internal/"];
+const isInternalFrame = (frame) => {
+    const lower = frame.toLowerCase();
+    return INTERNAL_MARKERS.some((marker) => lower.includes(marker));
+};
+function normalizeStackFrame(frame) {
+    return frame
+        .trim()
+        .replace(/^at\s+/, "")
+        .replace(/:\d+:\d+(?=\)?$)/, "")
+        .replace(/\s+/g, " ");
+}
+function selectApplicationFrame(stack) {
+    if (typeof stack !== "string" || stack.length === 0) {
+        return undefined;
+    }
+    for (const line of stack.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || /^\w*Error(?::|$)/.test(trimmed)) {
+            continue;
+        }
+        const frame = normalizeStackFrame(trimmed);
+        if (!frame || isInternalFrame(frame)) {
+            continue;
+        }
+        return frame;
+    }
+    return undefined;
+}

package/dist/cjs/core/types.js

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

package/dist/cjs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telegramNotifier = exports.registerWotchiProcessMonitor = exports.createWotchi = exports.consoleNotifier = exports.WotchiConfigurationError = void 0;
+const client_js_1 = require("./core/client.js");
+Object.defineProperty(exports, "createWotchi", { enumerable: true, get: function () { return client_js_1.createWotchi; } });
+const process_monitor_js_1 = require("./core/process-monitor.js");
+Object.defineProperty(exports, "registerWotchiProcessMonitor", { enumerable: true, get: function () { return process_monitor_js_1.registerWotchiProcessMonitor; } });
+const console_js_1 = require("./notifiers/console.js");
+Object.defineProperty(exports, "consoleNotifier", { enumerable: true, get: function () { return console_js_1.consoleNotifier; } });
+const telegram_js_1 = require("./notifiers/telegram.js");
+Object.defineProperty(exports, "telegramNotifier", { enumerable: true, get: function () { return telegram_js_1.telegramNotifier; } });
+var errors_js_1 = require("./core/errors.js");
+Object.defineProperty(exports, "WotchiConfigurationError", { enumerable: true, get: function () { return errors_js_1.WotchiConfigurationError; } });

package/dist/cjs/integrations/express/error-handler.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExpressErrorHandler = createExpressErrorHandler;
+const request_context_js_1 = require("./request-context.js");
+function createExpressErrorHandler(client, options) {
+    return (error, request, response, next) => {
+        try {
+            client.captureException(error, (0, request_context_js_1.getExpressRequestContext)(request, response, options));
+        }
+        catch {
+            // A capture failure must never change Express error handling.
+        }
+        next(error);
+    };
+}

package/dist/cjs/integrations/express/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telegramNotifier = exports.createWotchi = exports.consoleNotifier = void 0;
+exports.wotchiErrorHandler = wotchiErrorHandler;
+const error_handler_js_1 = require("./error-handler.js");
+var index_js_1 = require("../../index.js");
+Object.defineProperty(exports, "consoleNotifier", { enumerable: true, get: function () { return index_js_1.consoleNotifier; } });
+Object.defineProperty(exports, "createWotchi", { enumerable: true, get: function () { return index_js_1.createWotchi; } });
+Object.defineProperty(exports, "telegramNotifier", { enumerable: true, get: function () { return index_js_1.telegramNotifier; } });
+function wotchiErrorHandler(client, options) {
+    return (0, error_handler_js_1.createExpressErrorHandler)(client, options);
+}

package/dist/cjs/integrations/express/request-context.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpressRequestContext = getExpressRequestContext;
+const request_context_js_1 = require("../request-context.js");
+function getExpressRequestContext(request, response, options) {
+    try {
+        const route = request.route?.path;
+        return (0, request_context_js_1.buildRequestContext)({
+            request,
+            method: request.method,
+            route: route ?? request.path,
+            statusCode: response.statusCode,
+            ...(options === undefined ? {} : { options }),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/cjs/integrations/nest/exception-filter.js

@@ -0,0 +1,36 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WotchiNestExceptionFilter = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const request_context_js_1 = require("./request-context.js");
+let WotchiNestExceptionFilter = class WotchiNestExceptionFilter extends core_1.BaseExceptionFilter {
+    constructor(client, applicationRef, options) {
+        super(applicationRef);
+        this.client = client;
+        this.options = options;
+    }
+    catch(exception, host) {
+        try {
+            this.client.captureException(exception, (0, request_context_js_1.getNestRequestContext)(host, exception, this.options));
+        }
+        catch {
+            // A capture failure must never change NestJS exception handling.
+        }
+        super.catch(exception, host);
+    }
+};
+exports.WotchiNestExceptionFilter = WotchiNestExceptionFilter;
+exports.WotchiNestExceptionFilter = WotchiNestExceptionFilter = __decorate([
+    (0, common_1.Catch)(),
+    __metadata("design:paramtypes", [Object, Object, Object])
+], WotchiNestExceptionFilter);

package/dist/cjs/integrations/nest/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWotchiNest = exports.telegramNotifier = exports.createWotchi = exports.consoleNotifier = void 0;
+var index_js_1 = require("../../index.js");
+Object.defineProperty(exports, "consoleNotifier", { enumerable: true, get: function () { return index_js_1.consoleNotifier; } });
+Object.defineProperty(exports, "createWotchi", { enumerable: true, get: function () { return index_js_1.createWotchi; } });
+Object.defineProperty(exports, "telegramNotifier", { enumerable: true, get: function () { return index_js_1.telegramNotifier; } });
+var register_js_1 = require("./register.js");
+Object.defineProperty(exports, "registerWotchiNest", { enumerable: true, get: function () { return register_js_1.registerWotchiNest; } });

package/dist/cjs/integrations/nest/register.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerWotchiNest = registerWotchiNest;
+const core_1 = require("@nestjs/core");
+const exception_filter_js_1 = require("./exception-filter.js");
+function registerWotchiNest(app, client, options) {
+    const application = app;
+    const directAdapter = application.getHttpAdapter?.();
+    const httpAdapter = directAdapter === undefined
+        ? application.get(core_1.HttpAdapterHost).httpAdapter
+        : directAdapter;
+    application.useGlobalFilters(new exception_filter_js_1.WotchiNestExceptionFilter(client, httpAdapter, options));
+}

package/dist/cjs/integrations/nest/request-context.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNestRequestContext = getNestRequestContext;
+const request_context_js_1 = require("../request-context.js");
+const isHttpException = (exception) => typeof exception === "object" &&
+    exception !== null &&
+    typeof exception.getStatus === "function";
+const getStatusCode = (exception, response) => {
+    if (isHttpException(exception)) {
+        try {
+            const status = exception.getStatus();
+            return Number.isSafeInteger(status) ? status : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return typeof response.statusCode === "number" &&
+        Number.isSafeInteger(response.statusCode) &&
+        response.statusCode >= 400
+        ? response.statusCode
+        : 500;
+};
+function getNestRequestContext(host, exception, options) {
+    try {
+        const httpHost = host.switchToHttp();
+        const request = httpHost.getRequest();
+        const response = httpHost.getResponse();
+        const route = request.route?.path ?? request.path ?? request.url;
+        return (0, request_context_js_1.buildRequestContext)({
+            request,
+            method: request.method,
+            route,
+            statusCode: getStatusCode(exception, response),
+            ...(options === undefined ? {} : { options }),
+        });
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/cjs/integrations/request-context.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRoutePath = normalizeRoutePath;
+exports.buildRequestContext = buildRequestContext;
+const MAX_ROUTE_LENGTH = 500;
+const MAX_REQUEST_ID_LENGTH = 200;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const HEX_PATTERN = /^[0-9a-f]{8,}$/i;
+const isRecord = (value) => typeof value === "object" && value !== null;
+const dynamicSegment = (segment) => /^\d+$/.test(segment) ||
+    UUID_PATTERN.test(segment) ||
+    HEX_PATTERN.test(segment) ||
+    segment.length >= 24
+    ? ":id"
+    : segment;
+function normalizeRoutePath(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const path = value.split("?", 1)[0]?.trim();
+    if (path === undefined || path.length === 0) {
+        return undefined;
+    }
+    return path.split("/").map(dynamicSegment).join("/").slice(0, MAX_ROUTE_LENGTH);
+}
+const normalizeRequestIdProperty = (property) => {
+    if (property === undefined) {
+        return undefined;
+    }
+    if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(property)) {
+        throw new TypeError("requestIdProperty must be a simple property name");
+    }
+    return property;
+};
+const readRequestId = (request, property) => {
+    if (property === undefined || !isRecord(request)) {
+        return undefined;
+    }
+    try {
+        if (!Object.prototype.hasOwnProperty.call(request, property)) {
+            return undefined;
+        }
+        const value = request[property];
+        return typeof value === "string" ? value.slice(0, MAX_REQUEST_ID_LENGTH) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+function buildRequestContext(input) {
+    const requestIdProperty = normalizeRequestIdProperty(input.options?.requestIdProperty);
+    let requestId;
+    try {
+        requestId = readRequestId(input.request, requestIdProperty);
+    }
+    catch {
+        requestId = undefined;
+    }
+    const method = typeof input.method === "string" ? input.method.slice(0, 16) : undefined;
+    const route = normalizeRoutePath(input.route);
+    const statusCode = typeof input.statusCode === "number" && Number.isSafeInteger(input.statusCode)
+        ? input.statusCode
+        : undefined;
+    if (method === undefined &&
+        route === undefined &&
+        statusCode === undefined &&
+        requestId === undefined) {
+        return undefined;
+    }
+    return {
+        ...(method === undefined ? {} : { method }),
+        ...(route === undefined ? {} : { route }),
+        ...(statusCode === undefined ? {} : { statusCode }),
+        ...(requestId === undefined ? {} : { requestId }),
+    };
+}

package/dist/cjs/notifiers/console.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatConsoleAlert = formatConsoleAlert;
+exports.consoleNotifier = consoleNotifier;
+const MAX_FIELD_LENGTH = 1_000;
+const MAX_ACTIONS = 5;
+const limit = (value, maxLength = MAX_FIELD_LENGTH) => value.slice(0, maxLength);
+function formatConsoleAlert(alert) {
+    const actions = alert.suggestedActions
+        .slice(0, MAX_ACTIONS)
+        .map((action) => `- ${limit(action, 300)}`)
+        .join("\n");
+    return [
+        limit(alert.title),
+        `Service: ${limit(alert.service, 300)}`,
+        `Environment: ${limit(alert.environment, 300)}`,
+        `Summary: ${limit(alert.summary)}`,
+        `Occurrences: ${alert.occurrences}`,
+        `First seen: ${limit(alert.firstSeenAt, 100)}`,
+        `Last seen: ${limit(alert.lastSeenAt, 100)}`,
+        "Suggested checks:",
+        actions,
+    ].join("\n");
+}
+function consoleNotifier(options) {
+    const write = options?.write ?? ((line) => console.error(line));
+    return {
+        name: "console",
+        async send(alert) {
+            write(formatConsoleAlert(alert));
+        },
+    };
+}

package/dist/cjs/notifiers/telegram-format.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTelegramAlert = formatTelegramAlert;
+const MAX_MESSAGE_LENGTH = 4_096;
+const MAX_ACTIONS = 5;
+const MAX_TITLE_LENGTH = 300;
+const MAX_SERVICE_LENGTH = 300;
+const MAX_ENVIRONMENT_LENGTH = 300;
+const MAX_SUMMARY_LENGTH = 2_000;
+const MAX_ACTION_LENGTH = 600;
+const escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const limit = (value, maxLength) => value.slice(0, maxLength);
+const render = (title, service, environment, summary, actions, firstSeenAt, lastSeenAt, occurrences) => {
+    const actionText = actions.length === 0
+        ? "- No suggested checks."
+        : actions.map((action) => `- ${escapeHtml(action)}`).join("\n");
+    return [
+        `<b>${escapeHtml(title)}</b>`,
+        `Service: ${escapeHtml(service)}`,
+        `Environment: ${escapeHtml(environment)}`,
+        `Summary: ${escapeHtml(summary)}`,
+        `Occurrences: ${occurrences}`,
+        `First seen: ${escapeHtml(firstSeenAt)}`,
+        `Last seen: ${escapeHtml(lastSeenAt)}`,
+        "Suggested checks:",
+        actionText,
+    ].join("\n");
+};
+function formatTelegramAlert(alert) {
+    const title = limit(alert.title, MAX_TITLE_LENGTH);
+    const service = limit(alert.service, MAX_SERVICE_LENGTH);
+    const environment = limit(alert.environment, MAX_ENVIRONMENT_LENGTH);
+    const firstSeenAt = limit(alert.firstSeenAt, 100);
+    const lastSeenAt = limit(alert.lastSeenAt, 100);
+    let summary = limit(alert.summary, MAX_SUMMARY_LENGTH);
+    let actions = alert.suggestedActions
+        .slice(0, MAX_ACTIONS)
+        .map((action) => limit(action, MAX_ACTION_LENGTH));
+    let formatted = render(title, service, environment, summary, actions, firstSeenAt, lastSeenAt, alert.occurrences);
+    while (formatted.length > MAX_MESSAGE_LENGTH && actions.length > 0) {
+        actions = actions.slice(0, -1);
+        formatted = render(title, service, environment, summary, actions, firstSeenAt, lastSeenAt, alert.occurrences);
+    }
+    while (formatted.length > MAX_MESSAGE_LENGTH && summary.length > 0) {
+        summary = summary.slice(0, Math.max(0, summary.length - 200));
+        formatted = render(title, service, environment, summary, actions, firstSeenAt, lastSeenAt, alert.occurrences);
+    }
+    if (formatted.length > MAX_MESSAGE_LENGTH) {
+        formatted = render(limit(title, 100), limit(service, 100), limit(environment, 100), "Incident details were truncated.", [], firstSeenAt, lastSeenAt, alert.occurrences);
+    }
+    return formatted;
+}

package/dist/cjs/notifiers/telegram-http.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendTelegramMessage = sendTelegramMessage;
+const node_https_1 = __importDefault(require("node:https"));
+const DEFAULT_TIMEOUT_MS = 3_000;
+const MAX_RESPONSE_BYTES = 8_192;
+const MAX_RETRY_DELAY_MS = 1_000;
+const wait = (delayMs) => new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+});
+const failRequest = () => {
+    throw new Error("Telegram request failed");
+};
+const parseRetryAfter = (body) => {
+    try {
+        const parsed = JSON.parse(body);
+        if (typeof parsed !== "object" || parsed === null) {
+            return 0;
+        }
+        const parameters = parsed.parameters;
+        if (typeof parameters !== "object" || parameters === null) {
+            return 0;
+        }
+        const retryAfter = parameters.retry_after;
+        return typeof retryAfter === "number" && Number.isSafeInteger(retryAfter) && retryAfter > 0
+            ? Math.min(retryAfter * 1_000, MAX_RETRY_DELAY_MS)
+            : 0;
+    }
+    catch {
+        return 0;
+    }
+};
+const isSuccessResponse = (response) => {
+    if (response.statusCode < 200 || response.statusCode >= 300) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(response.body);
+        return (typeof parsed === "object" && parsed !== null && parsed.ok === true);
+    }
+    catch {
+        return false;
+    }
+};
+const createRequestOptions = (botToken) => ({
+    protocol: "https:",
+    hostname: "api.telegram.org",
+    method: "POST",
+    path: `/bot${botToken}/sendMessage`,
+    headers: {},
+});
+const httpsRequest = (options, body, timeoutMs) => new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        callback();
+    };
+    const request = node_https_1.default.request(options, (response) => {
+        const chunks = [];
+        let size = 0;
+        response.on("data", (chunk) => {
+            size += Buffer.byteLength(chunk);
+            if (size > MAX_RESPONSE_BYTES) {
+                request.destroy();
+                finish(() => reject(new Error("Telegram response body exceeded limit")));
+                return;
+            }
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        response.once("error", (error) => finish(() => reject(error)));
+        response.once("end", () => finish(() => resolve({
+            statusCode: response.statusCode ?? 0,
+            headers: response.headers,
+            body: Buffer.concat(chunks).toString("utf8"),
+        })));
+    });
+    request.once("error", (error) => finish(() => reject(error)));
+    request.setTimeout(timeoutMs, () => {
+        request.destroy();
+        finish(() => reject(new Error("Telegram request timed out")));
+    });
+    request.end(body);
+});
+const requestWithTimeout = async (request, options, body, timeoutMs) => {
+    let timer;
+    try {
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("Telegram request timed out")), timeoutMs);
+        });
+        return await Promise.race([request(options, body, timeoutMs), timeout]);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "Telegram request timed out") {
+            throw error;
+        }
+        if (error instanceof Error && error.message === "Telegram response body exceeded limit") {
+            throw error;
+        }
+        return failRequest();
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+};
+async function sendTelegramMessage(options, request = httpsRequest) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 30_000) {
+        throw new TypeError("timeoutMs is invalid");
+    }
+    const body = JSON.stringify({
+        chat_id: options.chatId,
+        text: options.text,
+        parse_mode: "HTML",
+        disable_web_page_preview: true,
+    });
+    const requestOptions = createRequestOptions(options.botToken);
+    requestOptions.headers = {
+        "content-type": "application/json",
+        "content-length": Buffer.byteLength(body, "utf8"),
+    };
+    let rateLimitRetries = 0;
+    let serverRetries = 0;
+    while (true) {
+        const response = await requestWithTimeout(request, requestOptions, body, timeoutMs);
+        if (Buffer.byteLength(response.body, "utf8") > MAX_RESPONSE_BYTES) {
+            throw new Error("Telegram response body exceeded limit");
+        }
+        if (isSuccessResponse(response)) {
+            return;
+        }
+        if (response.statusCode === 429 && rateLimitRetries === 0) {
+            rateLimitRetries += 1;
+            await wait(parseRetryAfter(response.body));
+            continue;
+        }
+        if (response.statusCode >= 500 && response.statusCode <= 599 && serverRetries === 0) {
+            serverRetries += 1;
+            continue;
+        }
+        throw new Error(`Telegram API request failed with status ${response.statusCode}`);
+    }
+}

package/dist/cjs/notifiers/telegram.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTelegramNotifier = createTelegramNotifier;
+exports.telegramNotifier = telegramNotifier;
+const telegram_format_js_1 = require("./telegram-format.js");
+const telegram_http_js_1 = require("./telegram-http.js");
+const validateValue = (value, field) => {
+    if (typeof value !== "string" ||
+        value.trim().length === 0 ||
+        value.length > 200 ||
+        /[\s/?#]/.test(value)) {
+        throw new TypeError(`${field} is invalid`);
+    }
+    return value.trim();
+};
+function createTelegramNotifier(options, request) {
+    const botToken = validateValue(options.botToken, "botToken");
+    const chatId = validateValue(options.chatId, "chatId");
+    const sendOptions = {
+        botToken,
+        chatId,
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+    };
+    return {
+        name: "telegram",
+        async send(alert) {
+            const message = { ...sendOptions, text: (0, telegram_format_js_1.formatTelegramAlert)(alert) };
+            if (request === undefined) {
+                await (0, telegram_http_js_1.sendTelegramMessage)(message);
+                return;
+            }
+            await (0, telegram_http_js_1.sendTelegramMessage)(message, request);
+        },
+    };
+}
+function telegramNotifier(options) {
+    return createTelegramNotifier(options);
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}