@pellux/goodvibes-sdk 0.28.21 → 0.30.0

package/dist/platform/integrations/notifier.js

@@ -1 +1,176 @@
-export * from '../../_internal/platform/integrations/notifier.js';
+import { logger } from '../utils/logger.js';
+import { summarizeError } from '../utils/error-display.js';
+import { SlackIntegration } from './slack.js';
+import { DiscordIntegration } from './discord.js';
+import { DeliveryQueue } from './delivery.js';
+import { snapshotQueueStatus } from './delivery.js';
+import { ServiceRegistry } from '../config/service-registry.js';
+// ---------------------------------------------------------------------------
+// Notifier
+// ---------------------------------------------------------------------------
+/**
+ * Notifier — unified notification dispatcher.
+ *
+ * Reads configuration from environment variables:
+ *   SLACK_WEBHOOK_URL, SLACK_BOT_TOKEN
+ *   DISCORD_WEBHOOK_URL, DISCORD_BOT_TOKEN
+ *
+ * Attach to the RuntimeEventBus to automatically post notifications for key events.
+ */
+export class Notifier {
+    slack;
+    discord;
+    unsubscribers = [];
+    _queue;
+    constructor(options) {
+        this.slack = options?.slack;
+        this.discord = options?.discord;
+        this._queue = new DeliveryQueue({
+            ...(options?.delivery ?? {}),
+            featureFlags: options?.featureFlags,
+        });
+    }
+    /**
+     * Create a Notifier pre-wired from configured services and environment variables.
+     */
+    static async fromConfig(serviceRegistry, options = {}) {
+        const [slackWebhookFromService, slackTokenFromService, discordWebhookFromService, discordTokenFromService,] = await Promise.all([
+            serviceRegistry.resolveSecret('slack', 'webhookUrl'),
+            serviceRegistry.resolveSecret('slack', 'primary'),
+            serviceRegistry.resolveSecret('discord', 'webhookUrl'),
+            serviceRegistry.resolveSecret('discord', 'primary'),
+        ]);
+        const slackWebhook = slackWebhookFromService ?? process.env.SLACK_WEBHOOK_URL;
+        const slackToken = slackTokenFromService ?? process.env.SLACK_BOT_TOKEN;
+        const discordWebhook = discordWebhookFromService ?? process.env.DISCORD_WEBHOOK_URL;
+        const discordToken = discordTokenFromService ?? process.env.DISCORD_BOT_TOKEN;
+        const slack = slackWebhook || slackToken
+            ? new SlackIntegration(slackWebhook, slackToken)
+            : undefined;
+        const discord = discordWebhook || discordToken
+            ? new DiscordIntegration(discordWebhook, discordToken)
+            : undefined;
+        return new Notifier({ slack, discord, featureFlags: options.featureFlags });
+    }
+    // -------------------------------------------------------------------------
+    // Public API
+    // -------------------------------------------------------------------------
+    /**
+     * Send a notification to all configured channels.
+     *
+     * @param event  - Human-readable event name (used as message text)
+     * @param data   - Arbitrary key/value payload for formatting
+     */
+    async notify(event, data) {
+        const text = this.formatText(event, data);
+        if (this.slack) {
+            const slack = this.slack;
+            await this._queue.enqueue('slack', event, text, () => slack.postWebhook(text));
+        }
+        if (this.discord) {
+            const discord = this.discord;
+            await this._queue.enqueue('discord', event, text, () => discord.postWebhook(text));
+        }
+    }
+    /**
+     * Get delivery queue status snapshots for all active channels.
+     * Used by integration diagnostics to surface queue and DLQ state.
+     */
+    getQueueStatus() {
+        const sloEnforced = this._queue.sloEnforced;
+        const statuses = [];
+        if (this.slack) {
+            statuses.push(snapshotQueueStatus('slack', this._queue, sloEnforced));
+        }
+        if (this.discord) {
+            statuses.push(snapshotQueueStatus('discord', this._queue, sloEnforced));
+        }
+        return statuses;
+    }
+    /**
+     * Replay all dead-letter entries to their respective channels.
+     * Re-attempts delivery for each DLQ entry; results are returned per-entry.
+     */
+    async replayDeadLetters() {
+        return this._queue.replay(async (dlqEntry) => {
+            const text = dlqEntry.payload;
+            if (dlqEntry.channel === 'slack' && this.slack) {
+                await this.slack.postWebhook(text);
+            }
+            else if (dlqEntry.channel === 'discord' && this.discord) {
+                await this.discord.postWebhook(text);
+            }
+            else {
+                throw new Error(`No active integration for channel: ${dlqEntry.channel}`);
+            }
+        });
+    }
+    /** Dispose the delivery queue (cancel pending timers). Call on shutdown. */
+    dispose() {
+        this._queue.dispose();
+    }
+    attachToRuntimeBus(bus) {
+        this.detach();
+        this.unsubscribers.push(bus.on('AGENT_COMPLETED', ({ payload }) => {
+            void this.notify('AGENT_COMPLETED', {
+                event: 'AGENT_COMPLETED',
+                agentId: payload.agentId,
+                task: payload.output?.slice(0, 100) ?? payload.agentId,
+                result: payload.output,
+            }).catch((error) => {
+                logger.warn('[notifier] AGENT_COMPLETED notification failed', { error: summarizeError(error) });
+            });
+        }));
+        this.unsubscribers.push(bus.on('WORKFLOW_CHAIN_PASSED', ({ payload }) => {
+            void this.notify('WORKFLOW_CHAIN_PASSED', {
+                event: 'WORKFLOW_CHAIN_PASSED',
+                chainId: payload.chainId,
+            }).catch((error) => {
+                logger.warn('[notifier] WORKFLOW_CHAIN_PASSED notification failed', { error: summarizeError(error) });
+            });
+        }));
+        this.unsubscribers.push(bus.on('WORKFLOW_CHAIN_FAILED', ({ payload }) => {
+            void this.notify('WORKFLOW_CHAIN_FAILED', {
+                event: 'WORKFLOW_CHAIN_FAILED',
+                chainId: payload.chainId,
+                reason: payload.reason,
+            }).catch((error) => {
+                logger.warn('[notifier] WORKFLOW_CHAIN_FAILED notification failed', { error: summarizeError(error) });
+            });
+        }));
+        logger.info('Notifier: attached to RuntimeEventBus');
+    }
+    /** Remove all notification subscriptions. */
+    detach() {
+        for (const unsub of this.unsubscribers) {
+            unsub();
+        }
+        this.unsubscribers = [];
+    }
+    // -------------------------------------------------------------------------
+    // Private helpers
+    // -------------------------------------------------------------------------
+    formatText(event, data) {
+        switch (event) {
+            case 'AGENT_COMPLETED': {
+                const task = typeof data.task === 'string' ? data.task : String(data.agentId ?? '');
+                return `Agent completed: ${task}`;
+            }
+            case 'WORKFLOW_CHAIN_PASSED': {
+                const score = typeof data.score === 'number' ? `${data.score}/10` : 'passed';
+                return `Review passed: ${score}`;
+            }
+            case 'WORKFLOW_CHAIN_FAILED': {
+                const reason = typeof data.reason === 'string' ? data.reason : 'unknown reason';
+                return `Review chain failed: ${reason}`;
+            }
+            default: {
+                const extras = Object.entries(data)
+                    .filter(([k]) => k !== 'event')
+                    .map(([k, v]) => `${k}=${String(v)}`)
+                    .join(', ');
+                return extras ? `${event}: ${extras}` : event;
+            }
+        }
+    }
+}

package/dist/platform/integrations/ntfy.d.ts

@@ -1,2 +1,67 @@
-export * from '../../_internal/platform/integrations/ntfy.js';
+export declare const GOODVIBES_NTFY_ORIGIN = "goodvibes-sdk";
+export declare const GOODVIBES_NTFY_ORIGIN_HEADER = "X-Goodvibes-Origin";
+export declare const GOODVIBES_NTFY_OUTBOUND_TAG = "goodvibes-sdk-outbound";
+export declare const GOODVIBES_NTFY_CHAT_TOPIC = "goodvibes-chat";
+export declare const GOODVIBES_NTFY_AGENT_TOPIC = "goodvibes-agent";
+export declare const GOODVIBES_NTFY_REMOTE_TOPIC = "goodvibes-ntfy";
+export declare const GOODVIBES_NTFY_DEFAULT_TOPICS: readonly ["goodvibes-chat", "goodvibes-agent", "goodvibes-ntfy"];
+export interface GoodVibesNtfyTopicConfig {
+    readonly chatTopic?: string | null;
+    readonly agentTopic?: string | null;
+    readonly remoteTopic?: string | null;
+}
+export interface GoodVibesNtfyTopics {
+    readonly chatTopic: string;
+    readonly agentTopic: string;
+    readonly remoteTopic: string;
+    readonly all: readonly string[];
+}
+export declare function resolveGoodVibesNtfyTopics(config?: GoodVibesNtfyTopicConfig): GoodVibesNtfyTopics;
+export declare function createNtfyLiveSubscriptionSince(nowMs?: number): string;
+export interface NtfyPublishOptions {
+    readonly title?: string;
+    readonly priority?: 1 | 2 | 3 | 4 | 5;
+    readonly tags?: readonly string[];
+    readonly click?: string;
+    readonly attach?: string;
+    readonly actions?: readonly string[];
+    readonly markGoodVibesOrigin?: boolean;
+}
+export interface NtfyMessage {
+    readonly id?: string;
+    readonly time?: number;
+    readonly event: 'open' | 'keepalive' | 'message' | 'message_delete' | 'message_clear' | 'poll_request' | string;
+    readonly topic?: string;
+    readonly message?: string;
+    readonly title?: string;
+    readonly priority?: number;
+    readonly tags?: readonly string[];
+    readonly click?: string;
+    readonly actions?: readonly unknown[];
+    readonly [key: string]: unknown;
+}
+export interface NtfySubscribeOptions {
+    readonly since?: string;
+    readonly scheduled?: boolean;
+    readonly poll?: boolean;
+    readonly filters?: Record<string, string | number | boolean | readonly string[]>;
+    readonly signal?: AbortSignal;
+    readonly reconnect?: boolean;
+    readonly reconnectDelayMs?: number;
+}
+export interface NtfyWebSocketOptions extends NtfySubscribeOptions {
+    readonly WebSocketImpl?: typeof WebSocket;
+}
+export declare class NtfyIntegration {
+    private readonly baseUrl;
+    private readonly token?;
+    constructor(baseUrl?: string, token?: string | undefined);
+    publish(topic: string, message: string, options?: NtfyPublishOptions): Promise<void>;
+    buildSubscribeUrl(topic: string, mode?: 'json' | 'sse' | 'raw' | 'ws', options?: NtfySubscribeOptions): string;
+    poll(topic: string, options?: Omit<NtfySubscribeOptions, 'poll'>): Promise<NtfyMessage[]>;
+    subscribeJsonStream(topic: string, onMessage: (message: NtfyMessage) => void | Promise<void>, options?: NtfySubscribeOptions): Promise<void>;
+    connectWebSocket(topic: string, onMessage: (message: NtfyMessage) => void | Promise<void>, options?: NtfyWebSocketOptions): WebSocket;
+    private buildAuthHeaders;
+}
+export declare function isGoodVibesNtfyDeliveryEcho(message: Record<string, unknown>): boolean;
 //# sourceMappingURL=ntfy.d.ts.map

package/dist/platform/integrations/ntfy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ntfy.d.ts","sourceRoot":"","sources":["../../../src/platform/integrations/ntfy.ts"],"names":[],"mappings":"AAAA,cAAc,+CAA+C,CAAC"}
+{"version":3,"file":"ntfy.d.ts","sourceRoot":"","sources":["../../../src/platform/integrations/ntfy.ts"],"names":[],"mappings":"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"}

package/dist/platform/integrations/ntfy.js

@@ -1 +1,427 @@
-export * from '../../_internal/platform/integrations/ntfy.js';
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+import { request as httpRequest } from 'node:http';
+import { connect as http2Connect } from 'node:http2';
+import { request as httpsRequest } from 'node:https';
+import { fetchWithTimeout } from '../utils/fetch-with-timeout.js';
+import { instrumentedFetch } from '../utils/fetch-with-timeout.js';
+import { summarizeError } from '../utils/error-display.js';
+import { logger } from '../utils/logger.js';
+export const GOODVIBES_NTFY_ORIGIN = 'goodvibes-sdk';
+export const GOODVIBES_NTFY_ORIGIN_HEADER = 'X-Goodvibes-Origin';
+export const GOODVIBES_NTFY_OUTBOUND_TAG = 'goodvibes-sdk-outbound';
+export const GOODVIBES_NTFY_CHAT_TOPIC = 'goodvibes-chat';
+export const GOODVIBES_NTFY_AGENT_TOPIC = 'goodvibes-agent';
+export const GOODVIBES_NTFY_REMOTE_TOPIC = 'goodvibes-ntfy';
+export const GOODVIBES_NTFY_DEFAULT_TOPICS = [
+    GOODVIBES_NTFY_CHAT_TOPIC,
+    GOODVIBES_NTFY_AGENT_TOPIC,
+    GOODVIBES_NTFY_REMOTE_TOPIC,
+];
+export function resolveGoodVibesNtfyTopics(config = {}) {
+    const chatTopic = normalizeNtfyTopic(config.chatTopic, GOODVIBES_NTFY_CHAT_TOPIC);
+    const agentTopic = normalizeNtfyTopic(config.agentTopic, GOODVIBES_NTFY_AGENT_TOPIC);
+    const remoteTopic = normalizeNtfyTopic(config.remoteTopic, GOODVIBES_NTFY_REMOTE_TOPIC);
+    return {
+        chatTopic,
+        agentTopic,
+        remoteTopic,
+        all: [...new Set([chatTopic, agentTopic, remoteTopic])],
+    };
+}
+export function createNtfyLiveSubscriptionSince(nowMs = Date.now()) {
+    return String(Math.floor(nowMs / 1000));
+}
+export class NtfyIntegration {
+    baseUrl;
+    token;
+    constructor(baseUrl = 'https://ntfy.sh', token) {
+        this.baseUrl = baseUrl;
+        this.token = token;
+    }
+    async publish(topic, message, options = {}) {
+        const target = `${this.baseUrl.replace(/\/+$/, '')}/${encodeURIComponent(topic)}`;
+        const headers = new Headers({
+            'Content-Type': 'text/plain; charset=utf-8',
+        });
+        if (options.title)
+            headers.set('Title', options.title);
+        if (options.priority)
+            headers.set('Priority', String(options.priority));
+        const tags = options.markGoodVibesOrigin
+            ? [...new Set([...(options.tags ?? []), GOODVIBES_NTFY_OUTBOUND_TAG])]
+            : options.tags ?? [];
+        if (tags.length)
+            headers.set('Tags', tags.join(','));
+        if (options.click)
+            headers.set('Click', options.click);
+        if (options.attach)
+            headers.set('Attach', options.attach);
+        if (options.actions?.length)
+            headers.set('Actions', options.actions.join(';'));
+        if (options.markGoodVibesOrigin)
+            headers.set(GOODVIBES_NTFY_ORIGIN_HEADER, GOODVIBES_NTFY_ORIGIN);
+        if (this.token)
+            headers.set('Authorization', `Bearer ${this.token}`);
+        const response = await fetchWithTimeout(target, {
+            method: 'POST',
+            headers,
+            body: message,
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`NtfyIntegration.publish failed (${response.status}): ${body}`);
+        }
+    }
+    buildSubscribeUrl(topic, mode = 'json', options = {}) {
+        const pathTopic = topic.split(',').map((entry) => encodeURIComponent(entry.trim())).filter(Boolean).join(',');
+        const url = new URL(`${this.baseUrl.replace(/\/+$/, '')}/${pathTopic}/${mode}`);
+        if (options.poll)
+            url.searchParams.set('poll', '1');
+        if (options.since)
+            url.searchParams.set('since', options.since);
+        if (options.scheduled)
+            url.searchParams.set('scheduled', '1');
+        for (const [key, value] of Object.entries(options.filters ?? {})) {
+            url.searchParams.set(key, Array.isArray(value) ? value.join(',') : String(value));
+        }
+        if (mode === 'ws') {
+            url.protocol = url.protocol === 'http:' ? 'ws:' : 'wss:';
+        }
+        return url.toString();
+    }
+    async poll(topic, options = {}) {
+        const url = this.buildSubscribeUrl(topic, 'json', { ...options, poll: true });
+        const headers = this.buildAuthHeaders();
+        const response = await instrumentedFetch(url, {
+            method: 'GET',
+            headers,
+            signal: options.signal,
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`NtfyIntegration.poll failed (${response.status}): ${body}`);
+        }
+        const raw = await response.text();
+        return raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    async subscribeJsonStream(topic, onMessage, options = {}) {
+        const reconnect = options.reconnect ?? !options.poll;
+        let resumeSince = options.since;
+        const seenMessageIds = new NtfySeenMessageIds();
+        while (!options.signal?.aborted) {
+            const url = this.buildSubscribeUrl(topic, 'json', { ...options, since: resumeSince });
+            try {
+                await readNtfyJsonStreamWithNodeTransport(url, this.buildAuthHeaders(), async (message) => {
+                    const messageId = readNtfyMessageId(message);
+                    if (messageId && seenMessageIds.has(messageId))
+                        return;
+                    await onMessage(message);
+                    if (messageId) {
+                        seenMessageIds.add(messageId);
+                        resumeSince = messageId;
+                    }
+                    else if (message.event === 'message' && typeof message.time === 'number' && Number.isFinite(message.time)) {
+                        resumeSince = String(Math.floor(message.time));
+                    }
+                }, options.signal);
+            }
+            catch (error) {
+                if (options.signal?.aborted)
+                    return;
+                if (!reconnect || isFatalNtfyStreamError(error))
+                    throw error;
+            }
+            if (!reconnect || options.signal?.aborted)
+                return;
+            await waitForNtfyReconnectDelay(options.signal, options.reconnectDelayMs ?? 1_000);
+        }
+    }
+    connectWebSocket(topic, onMessage, options = {}) {
+        const WebSocketImpl = options.WebSocketImpl ?? WebSocket;
+        const socket = new WebSocketImpl(this.buildSubscribeUrl(topic, 'ws', options));
+        socket.addEventListener('message', (event) => {
+            void (async () => {
+                const raw = typeof event.data === 'string'
+                    ? event.data
+                    : event.data instanceof Buffer
+                        ? event.data.toString('utf-8')
+                        : String(event.data);
+                if (!raw.trim())
+                    return;
+                await onMessage(JSON.parse(raw));
+            })().catch((error) => {
+                logger.warn('[ntfy] websocket message handling failed', { error: summarizeError(error) });
+            });
+        });
+        return socket;
+    }
+    buildAuthHeaders() {
+        const headers = new Headers();
+        if (this.token)
+            headers.set('Authorization', `Bearer ${this.token}`);
+        return headers;
+    }
+}
+class NtfySeenMessageIds {
+    ids = new Set();
+    order = [];
+    has(id) {
+        return this.ids.has(id);
+    }
+    add(id) {
+        if (this.ids.has(id))
+            return;
+        this.ids.add(id);
+        this.order.push(id);
+        if (this.order.length <= 1_024)
+            return;
+        const expired = this.order.shift();
+        if (expired)
+            this.ids.delete(expired);
+    }
+}
+function readNtfyMessageId(message) {
+    return message.event === 'message' && typeof message.id === 'string' && message.id.trim()
+        ? message.id
+        : null;
+}
+export function isGoodVibesNtfyDeliveryEcho(message) {
+    if (message.event !== 'message')
+        return false;
+    const tags = message.tags;
+    if (Array.isArray(tags) && tags.includes(GOODVIBES_NTFY_OUTBOUND_TAG))
+        return true;
+    const headers = readRecord(message.headers);
+    const originHeader = headers ? readCaseInsensitiveHeader(headers, GOODVIBES_NTFY_ORIGIN_HEADER) : undefined;
+    return originHeader === GOODVIBES_NTFY_ORIGIN;
+}
+function normalizeNtfyTopic(value, fallback) {
+    const topic = typeof value === 'string' ? value.trim() : '';
+    return topic || fallback;
+}
+class NtfyStreamHttpError extends Error {
+    status;
+    constructor(status, body) {
+        super(`NtfyIntegration.subscribeJsonStream failed (${status}): ${body}`);
+        this.status = status;
+        this.name = 'NtfyStreamHttpError';
+    }
+}
+async function readNtfyJsonStreamWithNodeTransport(url, headers, onMessage, signal) {
+    const parsed = new URL(url);
+    if (parsed.protocol === 'http:') {
+        return readNtfyJsonStreamWithHttp1(url, headers, onMessage, signal, httpRequest);
+    }
+    if (parsed.protocol === 'https:') {
+        try {
+            await readNtfyJsonStreamWithHttp2(url, headers, onMessage, signal);
+            return;
+        }
+        catch (error) {
+            if (signal?.aborted || error instanceof NtfyStreamHttpError)
+                throw error;
+            return readNtfyJsonStreamWithHttp1(url, headers, onMessage, signal, httpsRequest);
+        }
+    }
+    throw new Error(`Unsupported ntfy stream protocol: ${parsed.protocol}`);
+}
+function readNtfyJsonStreamWithHttp1(url, headers, onMessage, signal, requestImpl) {
+    if (signal?.aborted)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let aborted = false;
+        const state = { buffer: '', queue: Promise.resolve() };
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener('abort', abort);
+            callback();
+        };
+        const fail = (error) => settle(() => reject(error));
+        const finish = () => settle(resolve);
+        const abort = () => {
+            aborted = true;
+            req.destroy();
+            finish();
+        };
+        const req = requestImpl(url, {
+            method: 'GET',
+            headers: headersToRecord(headers),
+        }, (res) => {
+            res.setEncoding('utf8');
+            const status = res.statusCode ?? 0;
+            if (status < 200 || status >= 300) {
+                let body = '';
+                res.on('data', (chunk) => {
+                    if (body.length < 4096)
+                        body += chunk;
+                });
+                res.on('end', () => fail(new NtfyStreamHttpError(status, body)));
+                res.on('error', fail);
+                return;
+            }
+            res.on('data', (chunk) => {
+                state.queue = state.queue
+                    .then(() => consumeNtfyJsonChunk(state, chunk, onMessage))
+                    .catch(fail);
+            });
+            res.on('end', () => {
+                state.queue
+                    .then(() => flushNtfyJsonBuffer(state, onMessage))
+                    .then(finish, fail);
+            });
+            res.on('error', (error) => {
+                if (aborted)
+                    finish();
+                else
+                    fail(error);
+            });
+        });
+        signal?.addEventListener('abort', abort, { once: true });
+        req.on('error', (error) => {
+            if (aborted)
+                finish();
+            else
+                fail(error);
+        });
+        req.end();
+    });
+}
+function readNtfyJsonStreamWithHttp2(url, headers, onMessage, signal) {
+    if (signal?.aborted)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const client = http2Connect(parsed.origin);
+        const path = `${parsed.pathname}${parsed.search}`;
+        const state = { buffer: '', queue: Promise.resolve() };
+        let settled = false;
+        let aborted = false;
+        let status = 0;
+        let errorBody = '';
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener('abort', abort);
+            client.close();
+            callback();
+        };
+        const fail = (error) => settle(() => reject(error));
+        const finish = () => settle(resolve);
+        const abort = () => {
+            aborted = true;
+            stream.close();
+            finish();
+        };
+        const stream = client.request({
+            ':method': 'GET',
+            ':path': path,
+            ...headersToRecord(headers),
+        });
+        signal?.addEventListener('abort', abort, { once: true });
+        stream.setEncoding('utf8');
+        stream.on('response', (responseHeaders) => {
+            status = Number(responseHeaders[':status'] ?? 0);
+        });
+        stream.on('data', (chunk) => {
+            if (status !== 0 && (status < 200 || status >= 300)) {
+                if (errorBody.length < 4096)
+                    errorBody += chunk;
+                return;
+            }
+            state.queue = state.queue
+                .then(() => consumeNtfyJsonChunk(state, chunk, onMessage))
+                .catch(fail);
+        });
+        stream.on('end', () => {
+            if (status < 200 || status >= 300) {
+                fail(new NtfyStreamHttpError(status, errorBody));
+                return;
+            }
+            state.queue
+                .then(() => flushNtfyJsonBuffer(state, onMessage))
+                .then(finish, fail);
+        });
+        stream.on('error', (error) => {
+            if (aborted)
+                finish();
+            else
+                fail(error);
+        });
+        client.on('error', (error) => {
+            if (aborted)
+                finish();
+            else
+                fail(error);
+        });
+        stream.end();
+    });
+}
+function headersToRecord(headers) {
+    const record = {};
+    headers.forEach((value, key) => {
+        record[key.toLowerCase()] = value;
+    });
+    return record;
+}
+async function consumeNtfyJsonChunk(state, chunk, onMessage) {
+    state.buffer += chunk;
+    const lines = state.buffer.split(/\r?\n/);
+    state.buffer = lines.pop() ?? '';
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        await onMessage(JSON.parse(trimmed));
+    }
+}
+async function flushNtfyJsonBuffer(state, onMessage) {
+    const trimmed = state.buffer.trim();
+    state.buffer = '';
+    if (trimmed)
+        await onMessage(JSON.parse(trimmed));
+}
+function isFatalNtfyStreamError(error) {
+    return error instanceof NtfyStreamHttpError
+        && error.status >= 400
+        && error.status < 500
+        && error.status !== 408
+        && error.status !== 429;
+}
+function waitForNtfyReconnectDelay(signal, delayMs) {
+    if (signal?.aborted || delayMs <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        let timeout;
+        const done = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', abort);
+            resolve();
+        };
+        const abort = () => done();
+        timeout = setTimeout(done, delayMs);
+        timeout.unref?.();
+        signal?.addEventListener('abort', abort, { once: true });
+    });
+}
+function readRecord(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    return value;
+}
+function readCaseInsensitiveHeader(headers, name) {
+    const wanted = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() !== wanted)
+            continue;
+        return typeof value === 'string' ? value : undefined;
+    }
+    return undefined;
+}