@theowlops/boombot 0.0.0-stage → 1.1.1

package/dist/node_modules/@boombot/channels/transports/messenger/transport.js

@@ -0,0 +1,180 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import { MessageDeduplicator, } from '../common/index.js';
+const GRAPH_API_BASE = 'https://graph.facebook.com/v19.0';
+export class MessengerTransport {
+    kind = 'messenger';
+    displayName = 'Messenger';
+    enabled;
+    pageAccessToken;
+    appSecret;
+    verifyToken;
+    allowlist;
+    deduplicator = new MessageDeduplicator();
+    pendingReplies = new Map();
+    log;
+    status = 'disconnected';
+    statusDetail = 'NOT_CONFIGURED';
+    turnService;
+    unsubscribeTurnDone;
+    constructor(config, log) {
+        this.enabled = config.enabled !== false;
+        this.pageAccessToken = config.pageAccessToken?.trim() || undefined;
+        this.appSecret = config.appSecret?.trim() || undefined;
+        this.verifyToken = config.verifyToken?.trim() || undefined;
+        this.allowlist = new Set((config.allowlistChatIds ?? []).map((id) => id.trim()).filter(Boolean));
+        this.turnService = config.turnService;
+        this.log = log;
+        if (config.subscribeTurnDone) {
+            this.unsubscribeTurnDone = config.subscribeTurnDone((payload) => {
+                const recipientId = this.pendingReplies.get(payload.turnId);
+                if (recipientId === undefined || payload.output === undefined)
+                    return;
+                this.pendingReplies.delete(payload.turnId);
+                void this.send(recipientId, payload.output).catch((error) => {
+                    this.log.error('messenger: failed to send turn reply', {
+                        recipientId,
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                });
+            });
+        }
+    }
+    async start() {
+        if (!this.enabled) {
+            this.statusDetail = 'DISABLED';
+            return;
+        }
+        if (this.pageAccessToken === undefined) {
+            this.statusDetail = 'NOT_CONFIGURED';
+            this.log.info('messenger: missing pageAccessToken');
+            return;
+        }
+        try {
+            const response = await fetch(`${GRAPH_API_BASE}/me`, {
+                headers: { authorization: `Bearer ${this.pageAccessToken}` },
+                signal: AbortSignal.timeout(15_000),
+            });
+            if (!response.ok)
+                throw new Error(`HTTP ${response.status}`);
+            this.status = 'connected';
+            this.statusDetail = undefined;
+            this.log.info('messenger: connected (outbound only)');
+        }
+        catch (error) {
+            this.status = 'error';
+            this.statusDetail =
+                error instanceof Error ? error.message : 'CONNECT_FAILED';
+            this.log.error('messenger: credential check failed', {
+                detail: this.statusDetail,
+            });
+        }
+    }
+    async stop() {
+        this.unsubscribeTurnDone?.();
+        this.unsubscribeTurnDone = undefined;
+        this.pendingReplies.clear();
+        if (this.status === 'connected') {
+            this.status = 'disconnected';
+            this.statusDetail = 'STOPPED';
+        }
+        this.log.info('messenger: stopped');
+    }
+    async handleWebhook(request) {
+        if (!this.enabled)
+            return { status: 503 };
+        if (request.method === 'GET') {
+            const valid = request.query.get('hub.mode') === 'subscribe' &&
+                this.verifyToken !== undefined &&
+                request.query.get('hub.verify_token') === this.verifyToken;
+            return valid
+                ? { status: 200, contentType: 'text/plain; charset=utf-8', body: request.query.get('hub.challenge') ?? '' }
+                : { status: 401 };
+        }
+        if (this.appSecret !== undefined) {
+            const signatureValue = request.headers['x-hub-signature-256'];
+            const signature = typeof signatureValue === 'string' ? signatureValue : (signatureValue?.[0] ?? '');
+            const expected = `sha256=${createHmac('sha256', this.appSecret).update(request.rawBody).digest('hex')}`;
+            const actualBytes = Buffer.from(signature);
+            const expectedBytes = Buffer.from(expected);
+            if (actualBytes.length !== expectedBytes.length || !timingSafeEqual(actualBytes, expectedBytes)) {
+                return { status: 401 };
+            }
+        }
+        let payload;
+        try {
+            payload = JSON.parse(request.rawBody.toString('utf8'));
+        }
+        catch {
+            return { status: 400 };
+        }
+        if (!Array.isArray(payload.entry)) {
+            return { status: 200, body: 'EVENT_RECEIVED' };
+        }
+        for (const entry of payload.entry) {
+            if (!Array.isArray(entry.messaging))
+                continue;
+            for (const msg of entry.messaging) {
+                if (msg.message?.is_echo)
+                    continue;
+                const senderId = msg.sender?.id;
+                const text = msg.message?.text?.trim();
+                const mid = msg.message?.mid;
+                if (!senderId || !text || !mid)
+                    continue;
+                if (this.allowlist.size > 0 && !this.allowlist.has(senderId)) {
+                    this.log.info('messenger: dropped message from sender outside allowlist', { senderId });
+                    continue;
+                }
+                if (!this.deduplicator.checkAndRecord(mid))
+                    continue;
+                if (this.turnService === undefined) {
+                    this.log.error('messenger: turnService not set, cannot process message');
+                    continue;
+                }
+                try {
+                    const result = await this.turnService.submit({
+                        input: text,
+                        channel: 'messenger',
+                        replyTo: senderId,
+                    });
+                    this.pendingReplies.set(result.turnId, senderId);
+                }
+                catch (error) {
+                    this.log.error('messenger: turn submit failed', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+        }
+        return { status: 200, body: 'EVENT_RECEIVED' };
+    }
+    async send(target, text) {
+        if (!this.enabled)
+            throw new Error('DISABLED: messenger is disabled');
+        if (this.pageAccessToken === undefined) {
+            throw new Error('NOT_CONFIGURED: messenger missing pageAccessToken');
+        }
+        const recipient = target.trim();
+        if (recipient === '' || text.trim() === '') {
+            throw new Error('INVALID_ARGUMENT: target/text must not be empty');
+        }
+        const response = await fetch(`${GRAPH_API_BASE}/me/messages`, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${this.pageAccessToken}`,
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({ recipient: { id: recipient }, message: { text } }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        const data = (await response.json().catch(() => undefined));
+        if (!response.ok || data?.error !== undefined) {
+            throw new Error(`SEND_FAILED: ${data?.error?.message ?? `HTTP ${response.status}`}`);
+        }
+    }
+    getStatus() {
+        return this.statusDetail === undefined
+            ? { status: this.status }
+            : { status: this.status, detail: this.statusDetail };
+    }
+}

package/dist/node_modules/@boombot/channels/transports/messenger.d.ts

@@ -0,0 +1,2 @@
+/** Re-export from modular messenger package */
+export * from './messenger/index.js';

package/dist/node_modules/@boombot/channels/transports/messenger.js

@@ -0,0 +1,2 @@
+/** Re-export from modular messenger package */
+export * from './messenger/index.js';

package/dist/node_modules/@boombot/channels/transports/slack/index.d.ts

@@ -0,0 +1 @@
+export * from './transport.js';

package/dist/node_modules/@boombot/channels/transports/slack/index.js

@@ -0,0 +1 @@
+export * from './transport.js';

package/dist/node_modules/@boombot/channels/transports/slack/transport.d.ts

@@ -0,0 +1,35 @@
+import type { ChannelKind } from '@boombot/protocol';
+import { type ChannelLogger, type ChannelRuntimeStatus, type ChannelTransport, type ChannelWebhookRequest, type ChannelWebhookResponse, type InboundTransportOptions } from '../common/index.js';
+export interface SlackTransportConfig {
+    readonly enabled?: boolean;
+    readonly botToken?: string;
+    readonly signingSecret?: string;
+    readonly allowlistChatIds?: readonly string[];
+}
+export declare class SlackTransport implements ChannelTransport {
+    readonly kind: ChannelKind;
+    readonly displayName = "Slack";
+    private readonly enabled;
+    private readonly botToken;
+    private readonly signingSecret;
+    private readonly allowlist;
+    private readonly log;
+    private readonly turnService;
+    private readonly subscribeTurnDone;
+    private readonly pendingReplies;
+    private readonly deduplicator;
+    private unsubscribeTurnDone;
+    private status;
+    private statusDetail;
+    constructor(config: SlackTransportConfig, log: ChannelLogger, inbound?: InboundTransportOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getStatus(): {
+        status: ChannelRuntimeStatus;
+        detail?: string;
+    };
+    handleWebhook(request: ChannelWebhookRequest): Promise<ChannelWebhookResponse>;
+    send(target: string, text: string): Promise<void>;
+    private onTurnDone;
+    private callApi;
+}

package/dist/node_modules/@boombot/channels/transports/slack/transport.js

@@ -0,0 +1,183 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+import {} from '../common/index.js';
+import { MessageDeduplicator } from '../common/index.js';
+const SLACK_API_BASE = 'https://slack.com/api';
+const MAX_TEXT_LENGTH = 4000;
+const SIGNATURE_AGE_SECONDS = 300;
+function header(request, name) {
+    const value = request.headers[name] ?? request.headers[name.toLowerCase()];
+    return typeof value === 'string' ? value : (value?.[0] ?? '');
+}
+export class SlackTransport {
+    kind = 'slack';
+    displayName = 'Slack';
+    enabled;
+    botToken;
+    signingSecret;
+    allowlist;
+    log;
+    turnService;
+    subscribeTurnDone;
+    pendingReplies = new Map();
+    deduplicator = new MessageDeduplicator();
+    unsubscribeTurnDone;
+    status = 'disconnected';
+    statusDetail = 'NOT_CONFIGURED';
+    constructor(config, log, inbound = {}) {
+        this.enabled = config.enabled !== false;
+        this.botToken = config.botToken?.trim() || undefined;
+        this.signingSecret = config.signingSecret?.trim() || undefined;
+        this.allowlist = new Set(config.allowlistChatIds ?? []);
+        this.log = log;
+        this.turnService = inbound.turnService;
+        this.subscribeTurnDone = inbound.subscribeTurnDone;
+    }
+    async start() {
+        if (!this.enabled) {
+            this.statusDetail = 'DISABLED';
+            return;
+        }
+        this.unsubscribeTurnDone ??= this.subscribeTurnDone?.((payload) => this.onTurnDone(payload));
+        if (this.botToken === undefined) {
+            this.statusDetail = 'NOT_CONFIGURED';
+            return;
+        }
+        try {
+            const data = await this.callApi('auth.test', {});
+            if (!data.ok)
+                throw new Error(data.error ?? 'auth.test failed');
+            this.status = 'connected';
+            this.statusDetail = undefined;
+            this.log.info('slack: connected');
+        }
+        catch (error) {
+            this.status = 'error';
+            this.statusDetail = error instanceof Error ? error.message : 'CONNECT_FAILED';
+            this.log.error('slack: credential check failed', { detail: this.statusDetail });
+        }
+    }
+    async stop() {
+        this.unsubscribeTurnDone?.();
+        this.unsubscribeTurnDone = undefined;
+        this.pendingReplies.clear();
+        if (this.status === 'connected') {
+            this.status = 'disconnected';
+            this.statusDetail = 'STOPPED';
+        }
+    }
+    getStatus() {
+        return this.statusDetail === undefined
+            ? { status: this.status }
+            : { status: this.status, detail: this.statusDetail };
+    }
+    async handleWebhook(request) {
+        if (request.method !== 'POST')
+            return { status: 405 };
+        if (!this.enabled || this.signingSecret === undefined || this.botToken === undefined)
+            return { status: 503 };
+        const timestamp = header(request, 'x-slack-request-timestamp');
+        const signature = header(request, 'x-slack-signature');
+        const seconds = Number(timestamp);
+        if (!Number.isFinite(seconds) || Math.abs(Date.now() / 1000 - seconds) > SIGNATURE_AGE_SECONDS) {
+            return { status: 401 };
+        }
+        const expected = `v0=${createHmac('sha256', this.signingSecret)
+            .update(`v0:${timestamp}:`)
+            .update(request.rawBody)
+            .digest('hex')}`;
+        const actualBytes = Buffer.from(signature);
+        const expectedBytes = Buffer.from(expected);
+        if (actualBytes.length !== expectedBytes.length || !timingSafeEqual(actualBytes, expectedBytes)) {
+            return { status: 401 };
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(request.rawBody.toString('utf8'));
+        }
+        catch {
+            return { status: 400 };
+        }
+        if (!isRecord(parsed))
+            return { status: 400 };
+        const body = parsed;
+        if (body['type'] === 'url_verification' && typeof body['challenge'] === 'string') {
+            return { status: 200, contentType: 'text/plain; charset=utf-8', body: body['challenge'] };
+        }
+        const event = body['event'];
+        if (body['type'] !== 'event_callback' ||
+            !isRecord(event) ||
+            event['type'] !== 'message' ||
+            event['subtype'] !== undefined ||
+            event['bot_id'] !== undefined ||
+            typeof event['channel'] !== 'string' ||
+            typeof event['text'] !== 'string' ||
+            event['text'].trim() === '')
+            return { status: 200 };
+        const eventId = typeof body['event_id'] === 'string' ? body['event_id'] : '';
+        if (eventId === '' || !this.deduplicator.checkAndRecord(eventId))
+            return { status: 200 };
+        if (!this.allowlist.has(event['channel']) || this.turnService === undefined)
+            return { status: 200 };
+        try {
+            const result = await this.turnService.submit({
+                input: event['text'],
+                channel: 'slack',
+                replyTo: event['channel'],
+            });
+            this.pendingReplies.set(result.turnId, event['channel']);
+        }
+        catch (error) {
+            this.log.error('slack: submit failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return { status: 500 };
+        }
+        return { status: 200 };
+    }
+    async send(target, text) {
+        if (this.botToken === undefined)
+            throw new Error('NOT_CONFIGURED: slack botToken missing');
+        const channel = target.trim();
+        if (channel === '' || text.trim() === '')
+            throw new Error('INVALID_ARGUMENT: target/text empty');
+        const points = Array.from(text);
+        for (let index = 0; index < points.length; index += MAX_TEXT_LENGTH) {
+            const data = await this.callApi('chat.postMessage', {
+                channel,
+                text: points.slice(index, index + MAX_TEXT_LENGTH).join(''),
+            });
+            if (!data.ok)
+                throw new Error(`SEND_FAILED: ${data.error ?? 'unknown error'}`);
+        }
+    }
+    onTurnDone(payload) {
+        const target = this.pendingReplies.get(payload.turnId)
+            ?? (payload.channel === 'slack' ? payload.replyTo : undefined);
+        if (target === undefined)
+            return;
+        this.pendingReplies.delete(payload.turnId);
+        void this.send(target, payload.status === 'completed'
+            ? (payload.output?.trim() || '(empty response)')
+            : `Turn failed${payload.error ? `: ${payload.error}` : ''}.`).catch((error) => this.log.error('slack: reply failed', {
+            error: error instanceof Error ? error.message : String(error),
+        }));
+    }
+    async callApi(method, body) {
+        if (this.botToken === undefined)
+            throw new Error('NOT_CONFIGURED');
+        const response = await fetch(`${SLACK_API_BASE}/${method}`, {
+            method: 'POST',
+            headers: { authorization: `Bearer ${this.botToken}`, 'content-type': 'application/json' },
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15_000),
+        });
+        const data = await response.json();
+        if (!isRecord(data) || typeof data['ok'] !== 'boolean') {
+            throw new Error(`Slack API returned an invalid response (${method})`);
+        }
+        return data;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/node_modules/@boombot/channels/transports/slack.d.ts

@@ -0,0 +1,2 @@
+/** Re-export from modular slack package */
+export * from './slack/index.js';

package/dist/node_modules/@boombot/channels/transports/slack.js

@@ -0,0 +1,2 @@
+/** Re-export from modular slack package */
+export * from './slack/index.js';

package/dist/node_modules/@boombot/channels/transports/streamer/index.d.ts

@@ -0,0 +1 @@
+export * from './streamer.js';

package/dist/node_modules/@boombot/channels/transports/streamer/index.js

@@ -0,0 +1 @@
+export * from './streamer.js';

package/dist/node_modules/@boombot/channels/transports/streamer/streamer.d.ts

@@ -0,0 +1,31 @@
+/**
+ * SmartStreamer — ported directly from ChannelHub concepts.
+ *
+ * Converts real-time LLM token streams into messaging platform updates:
+ * - When the transport supports in-place edits (Telegram, Discord):
+ *   sends an initial placeholder, then debounces edits (e.g. every 1-2s).
+ * - When the transport does NOT support editing (Zalo, TikTok, WhatsApp, Messenger):
+ *   accumulates tokens until a sentence boundary (., !, ?, \n) reaches
+ *   minSentenceLength, then emits discrete messages.
+ */
+export interface StreamableTransport {
+    send(target: string, text: string): Promise<{
+        messageId?: string;
+    } | undefined>;
+    edit?(target: string, messageId: string, text: string): Promise<void>;
+    sendTyping?(target: string): Promise<void>;
+}
+export interface SmartStreamerOptions {
+    editDebounceMs?: number;
+    typingIntervalMs?: number;
+    minSentenceLength?: number;
+    initialPlaceholder?: string;
+}
+export declare class SmartStreamer {
+    private readonly transport;
+    private readonly options;
+    constructor(transport: StreamableTransport, options?: SmartStreamerOptions);
+    stream(target: string, tokenStream: AsyncIterable<string>): Promise<string[]>;
+    private streamWithEdit;
+    private streamWithoutEdit;
+}

package/dist/node_modules/@boombot/channels/transports/streamer/streamer.js

@@ -0,0 +1,141 @@
+export class SmartStreamer {
+    transport;
+    options;
+    constructor(transport, options = {}) {
+        this.transport = transport;
+        this.options = {
+            editDebounceMs: 1200,
+            typingIntervalMs: 4000,
+            minSentenceLength: 60,
+            initialPlaceholder: '...',
+            ...options,
+        };
+    }
+    async stream(target, tokenStream) {
+        let typingActive = true;
+        const triggerTyping = async () => {
+            if (typeof this.transport.sendTyping === 'function') {
+                try {
+                    await this.transport.sendTyping(target);
+                }
+                catch {
+                    // ignore typing errors
+                }
+            }
+        };
+        void triggerTyping();
+        const typingTimer = setInterval(() => {
+            if (typingActive)
+                void triggerTyping();
+        }, this.options.typingIntervalMs);
+        try {
+            if (typeof this.transport.edit === 'function') {
+                return await this.streamWithEdit(target, tokenStream);
+            }
+            else {
+                return await this.streamWithoutEdit(target, tokenStream);
+            }
+        }
+        finally {
+            typingActive = false;
+            clearInterval(typingTimer);
+        }
+    }
+    async streamWithEdit(target, tokenStream) {
+        let accumulated = '';
+        let messageId;
+        let lastEditTime = 0;
+        let pendingTimeout = null;
+        let editQueue = Promise.resolve();
+        let editFailure;
+        const performEdit = async (text) => {
+            if (messageId && this.transport.edit) {
+                await this.transport.edit(target, messageId, text);
+                lastEditTime = Date.now();
+            }
+        };
+        const queueEdit = (text) => {
+            editQueue = editQueue
+                .then(async () => {
+                if (editFailure === undefined)
+                    await performEdit(text);
+            })
+                .catch((error) => {
+                editFailure = { error };
+            });
+            return editQueue;
+        };
+        const throwEditFailure = () => {
+            if (editFailure !== undefined)
+                throw editFailure.error;
+        };
+        for await (const chunk of tokenStream) {
+            accumulated += chunk;
+            if (!messageId) {
+                const initial = accumulated.trim() || this.options.initialPlaceholder;
+                const res = await this.transport.send(target, initial);
+                messageId = res && typeof res === 'object' ? res.messageId : undefined;
+                lastEditTime = Date.now();
+                continue;
+            }
+            const elapsed = Date.now() - lastEditTime;
+            if (elapsed >= this.options.editDebounceMs) {
+                if (pendingTimeout) {
+                    clearTimeout(pendingTimeout);
+                    pendingTimeout = null;
+                }
+                await queueEdit(accumulated);
+                throwEditFailure();
+            }
+            else if (!pendingTimeout) {
+                pendingTimeout = setTimeout(() => {
+                    pendingTimeout = null;
+                    void queueEdit(accumulated);
+                }, this.options.editDebounceMs - elapsed);
+            }
+        }
+        if (pendingTimeout) {
+            clearTimeout(pendingTimeout);
+        }
+        await editQueue;
+        throwEditFailure();
+        if (messageId && this.transport.edit) {
+            await this.transport.edit(target, messageId, accumulated);
+        }
+        return messageId ? [messageId] : [];
+    }
+    async streamWithoutEdit(target, tokenStream) {
+        let buffer = '';
+        const sentIds = [];
+        const sentenceDelimiters = ['. ', '! ', '? ', '.\n', '!\n', '?\n', '\n\n'];
+        for await (const chunk of tokenStream) {
+            buffer += chunk;
+            if (buffer.length >= this.options.minSentenceLength) {
+                let splitIndex = -1;
+                for (const delim of sentenceDelimiters) {
+                    const idx = buffer.indexOf(delim);
+                    if (idx !== -1 && (splitIndex === -1 || idx < splitIndex)) {
+                        splitIndex = idx + delim.length;
+                    }
+                }
+                if (splitIndex !== -1) {
+                    const toSend = buffer.slice(0, splitIndex).trim();
+                    buffer = buffer.slice(splitIndex);
+                    if (toSend) {
+                        const res = await this.transport.send(target, toSend);
+                        if (res && typeof res === 'object' && res.messageId) {
+                            sentIds.push(res.messageId);
+                        }
+                    }
+                }
+            }
+        }
+        if (buffer.trim()) {
+            const res = await this.transport.send(target, buffer.trim());
+            if (res && typeof res === 'object' && res.messageId) {
+                sentIds.push(res.messageId);
+            }
+        }
+        return sentIds;
+    }
+}

package/dist/node_modules/@boombot/channels/transports/streamer.d.ts

@@ -0,0 +1,2 @@
+/** Re-export from modular streamer package */
+export * from './streamer/index.js';

package/dist/node_modules/@boombot/channels/transports/streamer.js

@@ -0,0 +1,2 @@
+/** Re-export from modular streamer package */
+export * from './streamer/index.js';

package/dist/node_modules/@boombot/channels/transports/telegram/index.d.ts

@@ -0,0 +1 @@
+export * from './transport.js';

package/dist/node_modules/@boombot/channels/transports/telegram/index.js

@@ -0,0 +1 @@
+export * from './transport.js';