whale-code 6.4.0

package/dist/node/adapters/slack.d.ts

@@ -0,0 +1,26 @@
+import { BaseAdapter, type OutboundMessage } from "./base.js";
+export interface SlackConfig {
+    bot_token: string;
+    app_token: string;
+    allowed_channels?: string[];
+    mention_required?: boolean;
+    max_message_length?: number;
+}
+export declare class SlackAdapter extends BaseAdapter {
+    readonly type = "slack";
+    readonly name: string;
+    private config;
+    private ws;
+    private botUserId;
+    private reconnectAttempts;
+    private pingTimer;
+    constructor(name: string, config: SlackConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(msg: OutboundMessage): Promise<boolean>;
+    private fetchBotIdentity;
+    private connectSocketMode;
+    private handleSocketMessage;
+    private handleEvent;
+    private scheduleReconnect;
+}

package/dist/node/adapters/slack.js

@@ -0,0 +1,259 @@
+import { BaseAdapter } from "./base.js";
+const SLACK_API = "https://slack.com/api";
+const MAX_MESSAGE_LENGTH = 4000;
+export class SlackAdapter extends BaseAdapter {
+    type = "slack";
+    name;
+    config;
+    ws = null;
+    botUserId = null;
+    reconnectAttempts = 0;
+    pingTimer = null;
+    constructor(name, config) {
+        super();
+        this.name = name;
+        this.config = config;
+    }
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.reconnectAttempts = 0;
+        // Fetch bot user ID for mention filtering
+        await this.fetchBotIdentity();
+        // Connect via Socket Mode
+        console.log(`[slack] Connecting via Socket Mode...`);
+        await this.connectSocketMode();
+    }
+    async stop() {
+        this.running = false;
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer);
+            this.pingTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close(1000, "Shutting down");
+            this.ws = null;
+        }
+    }
+    async sendMessage(msg) {
+        try {
+            const channelId = msg.metadata?.channel_id || msg.conversation_id;
+            if (!channelId) {
+                console.error("[slack] No channel_id to send to");
+                return false;
+            }
+            const maxLen = this.config.max_message_length || MAX_MESSAGE_LENGTH;
+            let content = msg.content;
+            // Split long messages
+            const chunks = [];
+            while (content.length > 0) {
+                chunks.push(content.slice(0, maxLen));
+                content = content.slice(maxLen);
+            }
+            for (const chunk of chunks) {
+                const body = {
+                    channel: channelId,
+                    text: chunk,
+                };
+                // Thread reply if we have a thread_ts
+                if (msg.metadata?.thread_ts) {
+                    body.thread_ts = msg.metadata.thread_ts;
+                }
+                const res = await fetch(`${SLACK_API}/chat.postMessage`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json; charset=utf-8",
+                        Authorization: `Bearer ${this.config.bot_token}`,
+                    },
+                    body: JSON.stringify(body),
+                });
+                const data = await res.json();
+                if (!data.ok) {
+                    console.error(`[slack] Send failed:`, data.error);
+                    this.stats.errors++;
+                    return false;
+                }
+            }
+            this.stats.messages_out++;
+            this.stats.last_message_at = new Date().toISOString();
+            return true;
+        }
+        catch (err) {
+            console.error(`[slack] Send error:`, err.message);
+            this.stats.errors++;
+            return false;
+        }
+    }
+    async fetchBotIdentity() {
+        try {
+            const res = await fetch(`${SLACK_API}/auth.test`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.config.bot_token}`,
+                },
+            });
+            const data = await res.json();
+            if (data.ok) {
+                this.botUserId = data.user_id;
+                console.log(`[slack] Authenticated as ${data.user} (${data.user_id})`);
+            }
+            else {
+                console.error(`[slack] Auth failed:`, data.error);
+            }
+        }
+        catch (err) {
+            console.error(`[slack] Failed to fetch identity:`, err.message);
+        }
+    }
+    async connectSocketMode() {
+        if (!this.running)
+            return;
+        try {
+            // Request a WebSocket URL via apps.connections.open
+            const res = await fetch(`${SLACK_API}/apps.connections.open`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.config.app_token}`,
+                },
+            });
+            const data = await res.json();
+            if (!data.ok) {
+                console.error(`[slack] Socket Mode connection failed:`, data.error);
+                this.scheduleReconnect();
+                return;
+            }
+            const wsUrl = data.url;
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = () => {
+                console.log(`[slack] Socket Mode connected`);
+                this.reconnectAttempts = 0;
+                // Ping every 30s to keep connection alive
+                this.pingTimer = setInterval(() => {
+                    if (this.ws?.readyState === WebSocket.OPEN) {
+                        this.ws.send(JSON.stringify({ type: "ping" }));
+                    }
+                }, 30_000);
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(String(event.data));
+                    this.handleSocketMessage(data);
+                }
+                catch (err) {
+                    console.error(`[slack] Failed to parse message:`, err.message);
+                }
+            };
+            this.ws.onclose = (event) => {
+                console.log(`[slack] Socket closed: ${event.code} ${event.reason}`);
+                if (this.pingTimer) {
+                    clearInterval(this.pingTimer);
+                    this.pingTimer = null;
+                }
+                if (this.running)
+                    this.scheduleReconnect();
+            };
+            this.ws.onerror = () => {
+                console.error(`[slack] Socket error`);
+            };
+        }
+        catch (err) {
+            console.error(`[slack] Connection error:`, err.message);
+            this.scheduleReconnect();
+        }
+    }
+    handleSocketMessage(data) {
+        // Acknowledge envelope (required for Socket Mode)
+        if (data.envelope_id) {
+            this.ws?.send(JSON.stringify({ envelope_id: data.envelope_id }));
+        }
+        switch (data.type) {
+            case "hello":
+                console.log(`[slack] Socket Mode handshake complete`);
+                break;
+            case "disconnect":
+                console.log(`[slack] Server requested disconnect: ${data.reason}`);
+                this.ws?.close(1000, "Server disconnect");
+                break;
+            case "events_api": {
+                const event = data.payload?.event;
+                if (event) {
+                    this.handleEvent(event).catch(err => {
+                        console.error(`[slack] Error handling event:`, err.message);
+                        this.stats.errors++;
+                    });
+                }
+                break;
+            }
+        }
+    }
+    async handleEvent(event) {
+        // Only handle message events
+        if (event.type !== "message" && event.type !== "app_mention")
+            return;
+        // Ignore bot messages and message edits/deletions
+        if (event.bot_id || event.subtype)
+            return;
+        const channelId = event.channel;
+        // Filter by allowed channels
+        if (this.config.allowed_channels?.length) {
+            if (!this.config.allowed_channels.includes(channelId))
+                return;
+        }
+        // For regular messages, check mention requirement
+        if (event.type === "message" && this.config.mention_required && this.botUserId) {
+            const mentionPattern = `<@${this.botUserId}>`;
+            if (!event.text?.includes(mentionPattern))
+                return;
+        }
+        // Clean up content — remove bot mention
+        let content = event.text || "";
+        if (this.botUserId) {
+            content = content.replace(new RegExp(`<@${this.botUserId}>`, "g"), "").trim();
+        }
+        if (!content)
+            return;
+        const payload = {
+            sender_id: event.user || "unknown",
+            content,
+            metadata: {
+                channel_id: channelId,
+                thread_ts: event.thread_ts || event.ts, // Use thread_ts for threading, fallback to message ts
+                message_ts: event.ts,
+                team_id: event.team,
+            },
+        };
+        // Fetch user display name
+        if (event.user) {
+            try {
+                const res = await fetch(`${SLACK_API}/users.info?user=${event.user}`, {
+                    headers: { Authorization: `Bearer ${this.config.bot_token}` },
+                });
+                const data = await res.json();
+                if (data.ok) {
+                    payload.sender_name = data.user?.profile?.display_name || data.user?.real_name || data.user?.name;
+                }
+            }
+            catch {
+                // Non-critical — proceed without name
+            }
+        }
+        this.stats.messages_in++;
+        this.stats.last_message_at = new Date().toISOString();
+        if (this.onInboundMessage) {
+            await this.onInboundMessage(payload);
+        }
+    }
+    scheduleReconnect() {
+        if (!this.running)
+            return;
+        this.reconnectAttempts++;
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts - 1), 60_000);
+        console.log(`[slack] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+        setTimeout(() => {
+            if (!this.running)
+                return;
+            this.connectSocketMode();
+        }, delay);
+    }
+}

package/dist/node/adapters/sms.d.ts

@@ -0,0 +1,23 @@
+import { BaseAdapter, type OutboundMessage } from "./base.js";
+export interface SmsConfig {
+    account_sid: string;
+    auth_token: string;
+    from_number: string;
+    webhook_port?: number;
+}
+export declare class SmsAdapter extends BaseAdapter {
+    readonly type = "sms";
+    readonly name: string;
+    private config;
+    private server;
+    private reconnectAttempts;
+    constructor(name: string, config: SmsConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(msg: OutboundMessage): Promise<boolean>;
+    private startWebhookServer;
+    /** Handle inbound Twilio SMS webhook (POST with URL-encoded form data) */
+    private handleIncoming;
+    private processWebhookPayload;
+    private scheduleRestart;
+}

package/dist/node/adapters/sms.js

@@ -0,0 +1,161 @@
+import { createServer } from "node:http";
+import { BaseAdapter } from "./base.js";
+const DEFAULT_WEBHOOK_PORT = 3101;
+export class SmsAdapter extends BaseAdapter {
+    type = "sms";
+    name;
+    config;
+    server = null;
+    reconnectAttempts = 0;
+    constructor(name, config) {
+        super();
+        this.name = name;
+        this.config = config;
+    }
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        this.reconnectAttempts = 0;
+        console.log(`[sms] Starting Twilio webhook server...`);
+        this.startWebhookServer();
+    }
+    async stop() {
+        this.running = false;
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server.close(() => resolve());
+            });
+            this.server = null;
+        }
+        console.log(`[sms] Webhook server stopped`);
+    }
+    async sendMessage(msg) {
+        try {
+            const toNumber = msg.metadata?.from_number || msg.sender_id;
+            if (!toNumber) {
+                console.error("[sms] No recipient phone number");
+                return false;
+            }
+            const url = `https://api.twilio.com/2010-04-01/Accounts/${this.config.account_sid}/Messages.json`;
+            // Twilio API uses URL-encoded form data with Basic auth
+            const body = new URLSearchParams({
+                To: toNumber,
+                From: this.config.from_number,
+                Body: msg.content,
+            });
+            const credentials = Buffer.from(`${this.config.account_sid}:${this.config.auth_token}`).toString("base64");
+            const res = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/x-www-form-urlencoded",
+                    Authorization: `Basic ${credentials}`,
+                },
+                body: body.toString(),
+            });
+            if (res.ok) {
+                this.stats.messages_out++;
+                this.stats.last_message_at = new Date().toISOString();
+                return true;
+            }
+            const err = await res.text();
+            console.error(`[sms] Send failed (${res.status}):`, err);
+            this.stats.errors++;
+            return false;
+        }
+        catch (err) {
+            console.error(`[sms] Send error:`, err.message);
+            this.stats.errors++;
+            return false;
+        }
+    }
+    startWebhookServer() {
+        const port = this.config.webhook_port || DEFAULT_WEBHOOK_PORT;
+        this.server = createServer((req, res) => {
+            if (req.method === "POST") {
+                this.handleIncoming(req, res);
+            }
+            else {
+                // Health check endpoint
+                res.writeHead(200, { "Content-Type": "text/plain" });
+                res.end("WhaleNode SMS adapter running");
+            }
+        });
+        this.server.on("error", (err) => {
+            console.error(`[sms] Server error:`, err.message);
+            this.stats.errors++;
+            if (this.running)
+                this.scheduleRestart();
+        });
+        this.server.listen(port, () => {
+            console.log(`[sms] Twilio webhook server listening on port ${port}`);
+        });
+    }
+    /** Handle inbound Twilio SMS webhook (POST with URL-encoded form data) */
+    handleIncoming(req, res) {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+        });
+        req.on("end", () => {
+            // Respond with empty TwiML to acknowledge receipt
+            res.writeHead(200, { "Content-Type": "application/xml" });
+            res.end("<?xml version=\"1.0\" encoding=\"UTF-8\"?><Response></Response>");
+            this.processWebhookPayload(body).catch((err) => {
+                console.error(`[sms] Error processing webhook:`, err.message);
+                this.stats.errors++;
+            });
+        });
+    }
+    async processWebhookPayload(raw) {
+        // Twilio sends URL-encoded form data
+        const params = new URLSearchParams(raw);
+        const fromNumber = params.get("From");
+        const toNumber = params.get("To");
+        const messageBody = params.get("Body");
+        const messageSid = params.get("MessageSid");
+        if (!fromNumber || !messageBody) {
+            return;
+        }
+        const payload = {
+            sender_id: fromNumber,
+            content: messageBody,
+            metadata: {
+                from_number: fromNumber,
+                to_number: toNumber,
+                message_sid: messageSid,
+                num_media: params.get("NumMedia"),
+                from_city: params.get("FromCity"),
+                from_state: params.get("FromState"),
+                from_country: params.get("FromCountry"),
+            },
+        };
+        this.stats.messages_in++;
+        this.stats.last_message_at = new Date().toISOString();
+        if (this.onInboundMessage) {
+            await this.onInboundMessage(payload).catch((err) => {
+                console.error(`[sms] Error handling message:`, err.message);
+                this.stats.errors++;
+            });
+        }
+    }
+    scheduleRestart() {
+        if (!this.running)
+            return;
+        this.reconnectAttempts++;
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts - 1), 60_000);
+        console.log(`[sms] Restarting webhook server in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+        setTimeout(() => {
+            if (!this.running)
+                return;
+            if (this.server) {
+                this.server.close(() => {
+                    this.startWebhookServer();
+                });
+            }
+            else {
+                this.startWebhookServer();
+            }
+        }, delay);
+    }
+}

package/dist/node/adapters/telegram.d.ts

@@ -0,0 +1,17 @@
+import { BaseAdapter, type OutboundMessage } from "./base.js";
+export interface TelegramConfig {
+    bot_token: string;
+    allowed_chats?: number[];
+}
+export declare class TelegramAdapter extends BaseAdapter {
+    readonly type = "telegram";
+    readonly name: string;
+    private config;
+    private offset;
+    private pollTimer;
+    constructor(name: string, config: TelegramConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(msg: OutboundMessage): Promise<boolean>;
+    private poll;
+}

package/dist/node/adapters/telegram.js

@@ -0,0 +1,101 @@
+import { BaseAdapter } from "./base.js";
+export class TelegramAdapter extends BaseAdapter {
+    type = "telegram";
+    name;
+    config;
+    offset = 0;
+    pollTimer = null;
+    constructor(name, config) {
+        super();
+        this.name = name;
+        this.config = config;
+    }
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        console.log(`[telegram] Starting long-poll for bot...`);
+        this.poll();
+    }
+    async stop() {
+        this.running = false;
+        if (this.pollTimer) {
+            clearTimeout(this.pollTimer);
+            this.pollTimer = null;
+        }
+    }
+    async sendMessage(msg) {
+        try {
+            const chatId = msg.metadata?.chat_id || msg.conversation_id;
+            if (!chatId)
+                return false;
+            const res = await fetch(`https://api.telegram.org/bot${this.config.bot_token}/sendMessage`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    chat_id: chatId,
+                    text: msg.content,
+                    parse_mode: "Markdown",
+                }),
+            });
+            if (res.ok) {
+                this.stats.messages_out++;
+                this.stats.last_message_at = new Date().toISOString();
+                return true;
+            }
+            this.stats.errors++;
+            return false;
+        }
+        catch {
+            this.stats.errors++;
+            return false;
+        }
+    }
+    async poll() {
+        if (!this.running)
+            return;
+        try {
+            const res = await fetch(`https://api.telegram.org/bot${this.config.bot_token}/getUpdates?offset=${this.offset}&timeout=30`);
+            const data = await res.json();
+            if (data.ok && data.result?.length) {
+                for (const update of data.result) {
+                    this.offset = update.update_id + 1;
+                    const message = update.message;
+                    if (!message?.text)
+                        continue;
+                    // Filter by allowed chats
+                    if (this.config.allowed_chats?.length) {
+                        if (!this.config.allowed_chats.includes(message.chat.id))
+                            continue;
+                    }
+                    const payload = {
+                        sender_id: String(message.from?.id || "unknown"),
+                        sender_name: [message.from?.first_name, message.from?.last_name].filter(Boolean).join(" "),
+                        content: message.text,
+                        metadata: {
+                            chat_id: message.chat.id,
+                            chat_type: message.chat.type,
+                            message_id: message.message_id,
+                        },
+                    };
+                    this.stats.messages_in++;
+                    this.stats.last_message_at = new Date().toISOString();
+                    if (this.onInboundMessage) {
+                        await this.onInboundMessage(payload).catch(err => {
+                            console.error(`[telegram] Error handling message:`, err.message);
+                            this.stats.errors++;
+                        });
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error(`[telegram] Poll error:`, err.message);
+            this.stats.errors++;
+        }
+        // Schedule next poll (backoff on errors)
+        if (this.running) {
+            this.pollTimer = setTimeout(() => this.poll(), 1000);
+        }
+    }
+}

package/dist/node/adapters/webchat.d.ts

@@ -0,0 +1,27 @@
+import { BaseAdapter, type OutboundMessage } from "./base.js";
+export interface WebchatConfig {
+    port?: number;
+    allowed_origins?: string[];
+    max_message_length?: number;
+}
+/**
+ * WebChat adapter — runs a local HTTP server that serves a chat widget API.
+ * Customers connect via embedded JS widget on any website.
+ *
+ * Endpoints:
+ *   POST /message  — send a message (returns agent response)
+ *   GET  /health   — health check
+ *   OPTIONS *      — CORS preflight
+ */
+export declare class WebchatAdapter extends BaseAdapter {
+    readonly type = "webchat";
+    readonly name: string;
+    private config;
+    private server;
+    private port;
+    private outboundQueue;
+    constructor(name: string, config?: WebchatConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(msg: OutboundMessage): Promise<boolean>;
+}