@futurewindai/wotchi 0.1.0-beta.2 → 0.1.0-beta.6

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

@@ -0,0 +1,394 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeWebhookOptions = normalizeWebhookOptions;
+exports.sendWebhookAlert = sendWebhookAlert;
+const node_dns_1 = __importDefault(require("node:dns"));
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_net_1 = __importDefault(require("node:net"));
+const alert_payload_js_1 = require("./alert-payload.js");
+const DEFAULT_TIMEOUT_MS = 3_000;
+const MAX_TIMEOUT_MS = 30_000;
+const MAX_RESPONSE_BYTES = 8_192;
+const MAX_PAYLOAD_BYTES = 32_768;
+const MAX_URL_LENGTH = 2_048;
+const MAX_HEADER_COUNT = 20;
+const MAX_HEADER_VALUE_LENGTH = 2_000;
+const wait = (delayMs) => new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+});
+const normalizeHost = (value) => value
+    .toLowerCase()
+    .replace(/^\[|\]$/g, "")
+    .replace(/\.$/g, "");
+const parseIPv4 = (value) => {
+    const parts = value.split(".");
+    if (parts.length !== 4 || parts.some((part) => !/^\d+$/.test(part))) {
+        return undefined;
+    }
+    const numbers = parts.map(Number);
+    return numbers.every((part) => part >= 0 && part <= 255) ? numbers : undefined;
+};
+const isPrivateIPv4 = (value) => {
+    const parts = parseIPv4(value);
+    if (parts === undefined) {
+        return false;
+    }
+    const first = parts[0] ?? -1;
+    const second = parts[1] ?? -1;
+    return (first === 0 ||
+        first === 10 ||
+        first === 127 ||
+        (first === 100 && second >= 64 && second <= 127) ||
+        (first === 169 && second === 254) ||
+        (first === 172 && second >= 16 && second <= 31) ||
+        (first === 192 && second === 168) ||
+        (first === 198 && (second === 18 || second === 19)));
+};
+const parseIPv6 = (value) => {
+    const host = normalizeHost(value);
+    const halves = host.split("::");
+    if (halves.length > 2) {
+        return undefined;
+    }
+    const parseHalf = (half) => {
+        if (half === "") {
+            return [];
+        }
+        const groups = half.split(":");
+        const values = [];
+        for (const group of groups) {
+            if (group.includes(".")) {
+                const ipv4 = parseIPv4(group);
+                if (ipv4 === undefined) {
+                    return undefined;
+                }
+                values.push((ipv4[0] ?? 0) * 256 + (ipv4[1] ?? 0));
+                values.push((ipv4[2] ?? 0) * 256 + (ipv4[3] ?? 0));
+                continue;
+            }
+            if (!/^[0-9a-f]{1,4}$/i.test(group)) {
+                return undefined;
+            }
+            values.push(Number.parseInt(group, 16));
+        }
+        return values;
+    };
+    const left = parseHalf(halves[0] ?? "");
+    const right = parseHalf(halves[1] ?? "");
+    if (left === undefined || right === undefined) {
+        return undefined;
+    }
+    const missing = halves.length === 2 ? 8 - left.length - right.length : 0;
+    if (missing < 1 || left.length + right.length + missing !== 8) {
+        return undefined;
+    }
+    const groups = [...left, ...Array.from({ length: missing }, () => 0), ...right];
+    return groups.flatMap((group) => [(group >> 8) & 0xff, group & 0xff]);
+};
+const isPrivateIPv6 = (value) => {
+    const bytes = parseIPv6(value);
+    if (bytes === undefined) {
+        return false;
+    }
+    const allZero = bytes.every((byte) => byte === 0);
+    const loopback = allZero || (bytes.slice(0, 15).every((byte) => byte === 0) && bytes[15] === 1);
+    const first = bytes[0] ?? 0;
+    const second = bytes[1] ?? 0;
+    if (loopback ||
+        first === 0xfc ||
+        first === 0xfd ||
+        (first === 0xfe && (second & 0xc0) === 0x80)) {
+        return true;
+    }
+    const mapped = bytes.slice(0, 10).every((byte) => byte === 0) && bytes[10] === 0xff && bytes[11] === 0xff;
+    const compatible = bytes.slice(0, 12).every((byte) => byte === 0);
+    if (!mapped && !compatible) {
+        return false;
+    }
+    return isPrivateIPv4(bytes.slice(12).join("."));
+};
+const isPrivateDestination = (value) => {
+    const host = normalizeHost(value);
+    if (host === "localhost" ||
+        host.endsWith(".localhost") ||
+        host.endsWith(".local") ||
+        host === "metadata.google.internal" ||
+        host.endsWith(".internal")) {
+        return true;
+    }
+    const family = node_net_1.default.isIP(host);
+    return family === 4 ? isPrivateIPv4(host) : family === 6 && isPrivateIPv6(host);
+};
+const privateDestinationError = () => new TypeError("webhook private or internal destinations require allowPrivateDestinations");
+const normalizeUrl = (value, allowHttpLoopback = false, allowPrivateDestinations = false) => {
+    if (typeof value !== "string" || value.trim().length === 0 || value.length > MAX_URL_LENGTH) {
+        throw new TypeError("webhook url is invalid");
+    }
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new TypeError("webhook url is invalid");
+    }
+    if (url.username !== "" || url.password !== "" || url.hash !== "") {
+        throw new TypeError("webhook url must not contain credentials or a fragment");
+    }
+    if (url.protocol === "https:" &&
+        !allowPrivateDestinations &&
+        isPrivateDestination(url.hostname)) {
+        throw privateDestinationError();
+    }
+    if (url.protocol === "https:") {
+        return url;
+    }
+    const loopback = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+    if (url.protocol !== "http:" || !allowHttpLoopback || !loopback.has(url.hostname)) {
+        throw new TypeError("webhook url must be HTTPS or explicitly enabled loopback HTTP");
+    }
+    return url;
+};
+const normalizeHeaders = (headers) => {
+    if (headers === undefined) {
+        return undefined;
+    }
+    const entries = Object.entries(headers);
+    if (entries.length > MAX_HEADER_COUNT) {
+        throw new TypeError("webhook headers exceed the maximum count");
+    }
+    const normalized = {};
+    for (const [name, value] of entries) {
+        if (!/^[A-Za-z0-9-]+$/.test(name) || name.length > 100) {
+            throw new TypeError("webhook header name is invalid");
+        }
+        if (typeof value !== "string" ||
+            value.length > MAX_HEADER_VALUE_LENGTH ||
+            /[\r\n]/.test(value)) {
+            throw new TypeError("webhook header value is invalid");
+        }
+        const normalizedName = name.toLowerCase();
+        if (normalizedName === "content-length" || normalizedName === "host") {
+            throw new TypeError(`webhook header ${normalizedName} is reserved`);
+        }
+        normalized[normalizedName] = value;
+    }
+    return normalized;
+};
+function normalizeWebhookOptions(options) {
+    if (options.allowHttpLoopback !== undefined && typeof options.allowHttpLoopback !== "boolean") {
+        throw new TypeError("webhook allowHttpLoopback is invalid");
+    }
+    const allowHttpLoopback = options.allowHttpLoopback === true;
+    const allowPrivateDestinations = options.allowPrivateDestinations === true;
+    const url = normalizeUrl(options.url, allowHttpLoopback, allowPrivateDestinations);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMEOUT_MS) {
+        throw new TypeError("webhook timeoutMs is invalid");
+    }
+    const maxRetries = options.maxRetries ?? 1;
+    if (!Number.isSafeInteger(maxRetries) || maxRetries < 0 || maxRetries > 1) {
+        throw new TypeError("webhook maxRetries must be 0 or 1");
+    }
+    if (options.payloadBuilder !== undefined && typeof options.payloadBuilder !== "function") {
+        throw new TypeError("webhook payloadBuilder is invalid");
+    }
+    const headers = normalizeHeaders(options.headers);
+    return {
+        url,
+        ...(headers === undefined ? {} : { headers }),
+        timeoutMs,
+        maxRetries,
+        allowHttpLoopback,
+        allowPrivateDestinations: allowPrivateDestinations || (url.protocol === "http:" && allowHttpLoopback),
+        ...(options.payloadBuilder === undefined ? {} : { payloadBuilder: options.payloadBuilder }),
+    };
+}
+const resolveWebhookAddress = async (hostname, timeoutMs, signal) => {
+    let timer;
+    let removeAbortListener = () => undefined;
+    try {
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error("webhook destination lookup timed out")), timeoutMs);
+        });
+        const races = [node_dns_1.default.promises.lookup(hostname), timeout];
+        if (signal !== undefined) {
+            const aborted = new Promise((_, reject) => {
+                const onAbort = () => reject(new Error("webhook request timed out"));
+                if (signal.aborted) {
+                    onAbort();
+                    return;
+                }
+                signal.addEventListener("abort", onAbort, { once: true });
+                removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+            });
+            races.push(aborted);
+        }
+        return await Promise.race(races);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+        removeAbortListener();
+    }
+};
+const defaultRequest = async (options, body, timeoutMs) => {
+    const resolvedAddress = await resolveWebhookAddress(options.hostname, timeoutMs, options.signal);
+    if (!options.allowPrivateDestinations && isPrivateDestination(resolvedAddress.address)) {
+        throw privateDestinationError();
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let removeAbortListener = () => undefined;
+        const finish = (callback) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            removeAbortListener();
+            callback();
+        };
+        const { allowPrivateDestinations: _allowPrivateDestinations, ...nodeOptions } = options;
+        const request = (options.protocol === "http:" ? node_http_1.default : node_https_1.default).request({
+            ...nodeOptions,
+            lookup: (_hostname, _lookupOptions, callback) => callback(null, resolvedAddress.address, resolvedAddress.family),
+        }, (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("webhook 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"),
+            })));
+        });
+        const onAbort = () => {
+            request.destroy();
+        };
+        if (options.signal !== undefined) {
+            options.signal.addEventListener("abort", onAbort, { once: true });
+            removeAbortListener = () => options.signal?.removeEventListener("abort", onAbort);
+            if (options.signal.aborted) {
+                onAbort();
+            }
+        }
+        request.once("error", (error) => finish(() => reject(error)));
+        request.setTimeout(timeoutMs, () => {
+            request.destroy();
+            finish(() => reject(new Error("webhook request timed out")));
+        });
+        request.end(body);
+    });
+};
+const requestWithTimeout = async (request, options, body, timeoutMs) => {
+    let timer;
+    const controller = new AbortController();
+    try {
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                controller.abort();
+                reject(new Error("webhook request timed out"));
+            }, timeoutMs);
+        });
+        return await Promise.race([
+            request({ ...options, signal: controller.signal }, body, timeoutMs),
+            timeout,
+        ]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+};
+const deepFreeze = (value) => {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value)) {
+        return value;
+    }
+    Object.freeze(value);
+    for (const child of Object.values(value)) {
+        deepFreeze(child);
+    }
+    return value;
+};
+const serializeAlert = (alert, payloadBuilder) => {
+    const sanitizedAlert = deepFreeze((0, alert_payload_js_1.toBoundedAlertPayload)(alert));
+    let payload;
+    try {
+        const custom = payloadBuilder === undefined ? sanitizedAlert : payloadBuilder(sanitizedAlert);
+        payload = (0, alert_payload_js_1.toBoundedPayload)(custom);
+    }
+    catch {
+        throw new Error("webhook payload builder failed");
+    }
+    const envelope = {
+        version: 1,
+        type: "incident.alert",
+        sentAt: new Date().toISOString(),
+        alert: payload,
+    };
+    const serialized = JSON.stringify(envelope);
+    if (Buffer.byteLength(serialized, "utf8") <= MAX_PAYLOAD_BYTES) {
+        return serialized;
+    }
+    const fallback = JSON.stringify({
+        version: 1,
+        type: "incident.alert",
+        sentAt: new Date().toISOString(),
+        alert: {
+            title: alert.title.slice(0, 300),
+            fingerprint: alert.fingerprint.slice(0, 200),
+            severity: alert.severity,
+            summary: alert.summary.slice(0, 2_000),
+            service: alert.service.slice(0, 200),
+            environment: alert.environment.slice(0, 200),
+            occurrences: alert.occurrences,
+            truncated: true,
+        },
+    });
+    return fallback;
+};
+async function sendWebhookAlert(options, request = defaultRequest) {
+    const normalized = normalizeWebhookOptions(options);
+    const body = serializeAlert(options.alert, normalized.payloadBuilder);
+    const requestOptions = {
+        protocol: normalized.url.protocol,
+        hostname: normalized.url.hostname.replace(/^\[|\]$/g, ""),
+        ...(normalized.url.port === "" ? {} : { port: normalized.url.port }),
+        method: "POST",
+        path: `${normalized.url.pathname || "/"}${normalized.url.search}`,
+        headers: {
+            ...(normalized.headers ?? {}),
+            "content-type": "application/json",
+            "content-length": Buffer.byteLength(body, "utf8"),
+        },
+        allowPrivateDestinations: normalized.allowPrivateDestinations,
+    };
+    let attempt = 0;
+    while (true) {
+        const response = await requestWithTimeout(request, requestOptions, body, normalized.timeoutMs);
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+            return;
+        }
+        if (attempt < normalized.maxRetries &&
+            (response.statusCode === 429 || response.statusCode >= 500)) {
+            attempt += 1;
+            await wait(50);
+            continue;
+        }
+        throw new Error(`Webhook request failed with status ${response.statusCode}`);
+    }
+}

package/dist/cjs/notifiers/webhook.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebhookNotifier = createWebhookNotifier;
+exports.webhookNotifier = webhookNotifier;
+const webhook_http_js_1 = require("./webhook-http.js");
+function createWebhookNotifier(options, request) {
+    const normalized = (0, webhook_http_js_1.normalizeWebhookOptions)(options);
+    const sendOptions = {
+        url: normalized.url.toString(),
+        ...(normalized.headers === undefined ? {} : { headers: normalized.headers }),
+        timeoutMs: normalized.timeoutMs,
+        maxRetries: normalized.maxRetries,
+        allowHttpLoopback: normalized.allowHttpLoopback,
+        allowPrivateDestinations: normalized.allowPrivateDestinations,
+        ...(normalized.payloadBuilder === undefined
+            ? {}
+            : { payloadBuilder: normalized.payloadBuilder }),
+    };
+    return {
+        name: "webhook",
+        async send(alert) {
+            await (0, webhook_http_js_1.sendWebhookAlert)({ ...sendOptions, alert }, request);
+        },
+    };
+}
+function webhookNotifier(options) {
+    return createWebhookNotifier(options);
+}

package/dist/esm/core/admission.js

@@ -0,0 +1,19 @@
+/** A small token bucket used before normalization to bound overload work. */
+export function createCaptureAdmission(options) {
+    const now = options.now ?? Date.now;
+    let tokens = options.burst;
+    let lastRefill = now();
+    return {
+        tryAcquire: () => {
+            const timestamp = now();
+            const elapsedMs = Math.max(0, timestamp - lastRefill);
+            tokens = Math.min(options.burst, tokens + (elapsedMs * options.maxEventsPerSecond) / 1_000);
+            lastRefill = timestamp;
+            if (tokens < 1) {
+                return false;
+            }
+            tokens -= 1;
+            return true;
+        },
+    };
+}