whale-code 6.4.0

package/dist/node/adapters/webchat.js

@@ -0,0 +1,160 @@
+import http from "node:http";
+import { BaseAdapter } from "./base.js";
+const DEFAULT_PORT = 3100;
+const MAX_MESSAGE_LENGTH = 8000;
+/**
+ * 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 class WebchatAdapter extends BaseAdapter {
+    type = "webchat";
+    name;
+    config;
+    server = null;
+    port;
+    // Queue for outbound messages (agent responses pushed from server polling)
+    outboundQueue = new Map();
+    constructor(name, config = {}) {
+        super();
+        this.name = name;
+        this.config = config;
+        this.port = config.port || DEFAULT_PORT;
+    }
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        const origins = this.config.allowed_origins || ["*"];
+        this.server = http.createServer(async (req, res) => {
+            // CORS headers
+            const origin = req.headers.origin || "*";
+            const allowedOrigin = origins.includes("*") ? "*" : (origins.includes(origin) ? origin : "");
+            res.setHeader("Access-Control-Allow-Origin", allowedOrigin);
+            res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Session-Id");
+            if (req.method === "OPTIONS") {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            if (req.method === "GET" && req.url === "/health") {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status: "ok", adapter: this.name, stats: this.getStats() }));
+                return;
+            }
+            // GET /messages?session_id=xxx — poll for queued outbound messages
+            if (req.method === "GET" && req.url?.startsWith("/messages")) {
+                const url = new URL(req.url, `http://localhost:${this.port}`);
+                const sessionId = url.searchParams.get("session_id");
+                if (!sessionId) {
+                    res.writeHead(400, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "session_id required" }));
+                    return;
+                }
+                const messages = this.outboundQueue.get(sessionId) || [];
+                this.outboundQueue.delete(sessionId);
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ messages }));
+                return;
+            }
+            if (req.method === "POST" && req.url === "/message") {
+                try {
+                    const body = await readBody(req);
+                    const data = JSON.parse(body);
+                    if (!data.content || !data.session_id) {
+                        res.writeHead(400, { "Content-Type": "application/json" });
+                        res.end(JSON.stringify({ error: "content and session_id required" }));
+                        return;
+                    }
+                    const maxLen = this.config.max_message_length || MAX_MESSAGE_LENGTH;
+                    const content = data.content.substring(0, maxLen);
+                    const payload = {
+                        sender_id: data.session_id,
+                        sender_name: data.sender_name || "Visitor",
+                        content,
+                        metadata: {
+                            session_id: data.session_id,
+                            page_url: data.page_url,
+                            user_agent: req.headers["user-agent"],
+                        },
+                    };
+                    this.stats.messages_in++;
+                    this.stats.last_message_at = new Date().toISOString();
+                    if (this.onInboundMessage) {
+                        await this.onInboundMessage(payload);
+                    }
+                    res.writeHead(200, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ success: true }));
+                }
+                catch (err) {
+                    this.stats.errors++;
+                    res.writeHead(500, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "Internal error" }));
+                }
+                return;
+            }
+            res.writeHead(404);
+            res.end("Not found");
+        });
+        this.server.listen(this.port, () => {
+            console.log(`[webchat] Server listening on port ${this.port}`);
+        });
+        this.server.on("error", (err) => {
+            console.error(`[webchat] Server error:`, err.message);
+            this.stats.errors++;
+        });
+    }
+    async stop() {
+        this.running = false;
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+    async sendMessage(msg) {
+        try {
+            // Queue message for polling by the web client
+            const sessionId = msg.metadata?.session_id || msg.conversation_id || "default";
+            if (!this.outboundQueue.has(sessionId)) {
+                this.outboundQueue.set(sessionId, []);
+            }
+            this.outboundQueue.get(sessionId).push(msg);
+            this.stats.messages_out++;
+            this.stats.last_message_at = new Date().toISOString();
+            // Auto-cleanup old queued messages (> 5 min old)
+            // Simple TTL: clear queue entries older than 5 minutes
+            if (this.outboundQueue.size > 1000) {
+                const oldest = Array.from(this.outboundQueue.keys()).slice(0, 500);
+                for (const key of oldest)
+                    this.outboundQueue.delete(key);
+            }
+            return true;
+        }
+        catch {
+            this.stats.errors++;
+            return false;
+        }
+    }
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > 1_048_576) { // 1MB limit
+                req.destroy();
+                reject(new Error("Body too large"));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}

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

@@ -0,0 +1,28 @@
+import { BaseAdapter, type OutboundMessage } from "./base.js";
+export interface WhatsAppConfig {
+    phone_number_id: string;
+    access_token: string;
+    verify_token: string;
+    webhook_port?: number;
+    allowed_numbers?: string[];
+}
+export declare class WhatsAppAdapter extends BaseAdapter {
+    readonly type = "whatsapp";
+    readonly name: string;
+    private config;
+    private server;
+    private reconnectAttempts;
+    constructor(name: string, config: WhatsAppConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(msg: OutboundMessage): Promise<boolean>;
+    private startWebhookServer;
+    /** Handle WhatsApp webhook verification (GET request) */
+    private handleVerification;
+    /** Handle inbound WhatsApp webhook events (POST request) */
+    private handleIncoming;
+    private processWebhookPayload;
+    /** Mark a WhatsApp message as read */
+    private markAsRead;
+    private scheduleRestart;
+}

package/dist/node/adapters/whatsapp.js

@@ -0,0 +1,230 @@
+import { createServer } from "node:http";
+import { BaseAdapter } from "./base.js";
+const GRAPH_API = "https://graph.facebook.com/v21.0";
+const DEFAULT_WEBHOOK_PORT = 3100;
+export class WhatsAppAdapter extends BaseAdapter {
+    type = "whatsapp";
+    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(`[whatsapp] Starting 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(`[whatsapp] Webhook server stopped`);
+    }
+    async sendMessage(msg) {
+        try {
+            const recipientPhone = msg.metadata?.from_number || msg.sender_id;
+            if (!recipientPhone) {
+                console.error("[whatsapp] No recipient phone number");
+                return false;
+            }
+            const res = await fetch(`${GRAPH_API}/${this.config.phone_number_id}/messages`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.config.access_token}`,
+                },
+                body: JSON.stringify({
+                    messaging_product: "whatsapp",
+                    recipient_type: "individual",
+                    to: recipientPhone,
+                    type: "text",
+                    text: { body: msg.content },
+                }),
+            });
+            if (res.ok) {
+                this.stats.messages_out++;
+                this.stats.last_message_at = new Date().toISOString();
+                return true;
+            }
+            const err = await res.text();
+            console.error(`[whatsapp] Send failed (${res.status}):`, err);
+            this.stats.errors++;
+            return false;
+        }
+        catch (err) {
+            console.error(`[whatsapp] 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 === "GET") {
+                this.handleVerification(req, res);
+            }
+            else if (req.method === "POST") {
+                this.handleIncoming(req, res);
+            }
+            else {
+                res.writeHead(405);
+                res.end();
+            }
+        });
+        this.server.on("error", (err) => {
+            console.error(`[whatsapp] Server error:`, err.message);
+            this.stats.errors++;
+            if (this.running)
+                this.scheduleRestart();
+        });
+        this.server.listen(port, () => {
+            console.log(`[whatsapp] Webhook server listening on port ${port}`);
+        });
+    }
+    /** Handle WhatsApp webhook verification (GET request) */
+    handleVerification(req, res) {
+        const url = new URL(req.url || "/", `http://localhost`);
+        const mode = url.searchParams.get("hub.mode");
+        const token = url.searchParams.get("hub.verify_token");
+        const challenge = url.searchParams.get("hub.challenge");
+        if (mode === "subscribe" && token === this.config.verify_token) {
+            console.log(`[whatsapp] Webhook verified`);
+            res.writeHead(200, { "Content-Type": "text/plain" });
+            res.end(challenge || "");
+        }
+        else {
+            console.warn(`[whatsapp] Webhook verification failed`);
+            res.writeHead(403);
+            res.end("Forbidden");
+        }
+    }
+    /** Handle inbound WhatsApp webhook events (POST request) */
+    handleIncoming(req, res) {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+        });
+        req.on("end", () => {
+            // Respond immediately to avoid WhatsApp retries
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok" }));
+            this.processWebhookPayload(body).catch((err) => {
+                console.error(`[whatsapp] Error processing webhook:`, err.message);
+                this.stats.errors++;
+            });
+        });
+    }
+    async processWebhookPayload(raw) {
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            console.error(`[whatsapp] Invalid JSON in webhook payload`);
+            return;
+        }
+        // WhatsApp Cloud API webhook structure
+        const entries = data.entry;
+        if (!Array.isArray(entries))
+            return;
+        for (const entry of entries) {
+            const changes = entry.changes;
+            if (!Array.isArray(changes))
+                continue;
+            for (const change of changes) {
+                if (change.field !== "messages")
+                    continue;
+                const value = change.value;
+                if (!value?.messages)
+                    continue;
+                for (const message of value.messages) {
+                    // Only handle text messages
+                    if (message.type !== "text")
+                        continue;
+                    const fromNumber = message.from;
+                    // Filter by allowed numbers if configured
+                    if (this.config.allowed_numbers?.length) {
+                        if (!this.config.allowed_numbers.includes(fromNumber))
+                            continue;
+                    }
+                    // Extract sender name from contacts
+                    const contact = value.contacts?.find((c) => c.wa_id === fromNumber);
+                    const senderName = contact?.profile?.name;
+                    const payload = {
+                        sender_id: fromNumber,
+                        sender_name: senderName,
+                        content: message.text?.body || "",
+                        metadata: {
+                            from_number: fromNumber,
+                            message_id: message.id,
+                            timestamp: message.timestamp,
+                            phone_number_id: value.metadata?.phone_number_id,
+                        },
+                    };
+                    this.stats.messages_in++;
+                    this.stats.last_message_at = new Date().toISOString();
+                    // Mark message as read
+                    this.markAsRead(message.id).catch(() => {
+                        // Best effort — non-critical
+                    });
+                    if (this.onInboundMessage) {
+                        await this.onInboundMessage(payload).catch((err) => {
+                            console.error(`[whatsapp] Error handling message:`, err.message);
+                            this.stats.errors++;
+                        });
+                    }
+                }
+            }
+        }
+    }
+    /** Mark a WhatsApp message as read */
+    async markAsRead(messageId) {
+        try {
+            await fetch(`${GRAPH_API}/${this.config.phone_number_id}/messages`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.config.access_token}`,
+                },
+                body: JSON.stringify({
+                    messaging_product: "whatsapp",
+                    status: "read",
+                    message_id: messageId,
+                }),
+            });
+        }
+        catch {
+            // Silently ignore read receipt failures
+        }
+    }
+    scheduleRestart() {
+        if (!this.running)
+            return;
+        this.reconnectAttempts++;
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts - 1), 60_000);
+        console.log(`[whatsapp] 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/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};