whale-code 6.4.0

package/dist/node/adapters/discord.js

@@ -0,0 +1,299 @@
+import { BaseAdapter } from "./base.js";
+const DISCORD_API = "https://discord.com/api/v10";
+const GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
+const MAX_MESSAGE_LENGTH = 2000;
+// Discord Gateway opcodes
+const OP = {
+    DISPATCH: 0,
+    HEARTBEAT: 1,
+    IDENTIFY: 2,
+    RESUME: 6,
+    RECONNECT: 7,
+    INVALID_SESSION: 9,
+    HELLO: 10,
+    HEARTBEAT_ACK: 11,
+};
+// Discord Gateway intents
+const INTENTS = {
+    GUILDS: 1 << 0,
+    GUILD_MESSAGES: 1 << 9,
+    MESSAGE_CONTENT: 1 << 15,
+    DIRECT_MESSAGES: 1 << 12,
+};
+export class DiscordAdapter extends BaseAdapter {
+    type = "discord";
+    name;
+    config;
+    ws = null;
+    heartbeatTimer = null;
+    sequence = null;
+    sessionId = null;
+    resumeUrl = null;
+    botUserId = 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(`[discord] Connecting to gateway...`);
+        this.connectGateway(GATEWAY_URL);
+    }
+    async stop() {
+        this.running = false;
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = 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("[discord] 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 into chunks (Discord 2000 char limit)
+            const chunks = [];
+            while (content.length > 0) {
+                chunks.push(content.slice(0, maxLen));
+                content = content.slice(maxLen);
+            }
+            for (const chunk of chunks) {
+                const res = await fetch(`${DISCORD_API}/channels/${channelId}/messages`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bot ${this.config.bot_token}`,
+                    },
+                    body: JSON.stringify({
+                        content: chunk,
+                        // Reply to the original message if we have a message_id
+                        ...(msg.metadata?.message_id ? {
+                            message_reference: { message_id: msg.metadata.message_id },
+                        } : {}),
+                    }),
+                });
+                if (!res.ok) {
+                    const err = await res.text();
+                    console.error(`[discord] Send failed (${res.status}):`, err);
+                    this.stats.errors++;
+                    return false;
+                }
+            }
+            this.stats.messages_out++;
+            this.stats.last_message_at = new Date().toISOString();
+            return true;
+        }
+        catch (err) {
+            console.error(`[discord] Send error:`, err.message);
+            this.stats.errors++;
+            return false;
+        }
+    }
+    connectGateway(url) {
+        if (!this.running)
+            return;
+        try {
+            this.ws = new WebSocket(url);
+        }
+        catch (err) {
+            console.error(`[discord] WebSocket creation failed:`, err.message);
+            this.scheduleReconnect();
+            return;
+        }
+        this.ws.onopen = () => {
+            console.log(`[discord] Gateway connected`);
+            this.reconnectAttempts = 0;
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const data = JSON.parse(String(event.data));
+                this.handleGatewayMessage(data);
+            }
+            catch (err) {
+                console.error(`[discord] Failed to parse gateway message:`, err.message);
+            }
+        };
+        this.ws.onclose = (event) => {
+            console.log(`[discord] Gateway closed: ${event.code} ${event.reason}`);
+            if (this.heartbeatTimer) {
+                clearInterval(this.heartbeatTimer);
+                this.heartbeatTimer = null;
+            }
+            // Non-resumable close codes
+            const fatalCodes = [4004, 4010, 4011, 4012, 4013, 4014];
+            if (fatalCodes.includes(event.code)) {
+                console.error(`[discord] Fatal close code ${event.code}, not reconnecting`);
+                this.running = false;
+                return;
+            }
+            if (this.running)
+                this.scheduleReconnect();
+        };
+        this.ws.onerror = () => {
+            console.error(`[discord] Gateway error`);
+        };
+    }
+    handleGatewayMessage(data) {
+        const { op, d, s, t } = data;
+        // Track sequence for resume
+        if (s !== null && s !== undefined)
+            this.sequence = s;
+        switch (op) {
+            case OP.HELLO: {
+                // Start heartbeating
+                const interval = d.heartbeat_interval;
+                this.heartbeatTimer = setInterval(() => {
+                    this.ws?.send(JSON.stringify({ op: OP.HEARTBEAT, d: this.sequence }));
+                }, interval);
+                // Send initial heartbeat after random jitter
+                setTimeout(() => {
+                    this.ws?.send(JSON.stringify({ op: OP.HEARTBEAT, d: this.sequence }));
+                }, Math.random() * interval);
+                // Identify or resume
+                if (this.sessionId && this.sequence !== null) {
+                    this.ws?.send(JSON.stringify({
+                        op: OP.RESUME,
+                        d: {
+                            token: this.config.bot_token,
+                            session_id: this.sessionId,
+                            seq: this.sequence,
+                        },
+                    }));
+                }
+                else {
+                    this.ws?.send(JSON.stringify({
+                        op: OP.IDENTIFY,
+                        d: {
+                            token: this.config.bot_token,
+                            intents: INTENTS.GUILDS | INTENTS.GUILD_MESSAGES | INTENTS.MESSAGE_CONTENT | INTENTS.DIRECT_MESSAGES,
+                            properties: {
+                                os: process.platform,
+                                browser: "whalenode",
+                                device: "whalenode",
+                            },
+                        },
+                    }));
+                }
+                break;
+            }
+            case OP.HEARTBEAT_ACK:
+                // Server acknowledged heartbeat — connection is healthy
+                break;
+            case OP.HEARTBEAT:
+                // Server requesting immediate heartbeat
+                this.ws?.send(JSON.stringify({ op: OP.HEARTBEAT, d: this.sequence }));
+                break;
+            case OP.RECONNECT:
+                console.log(`[discord] Server requested reconnect`);
+                this.ws?.close(4000, "Reconnecting");
+                break;
+            case OP.INVALID_SESSION:
+                console.log(`[discord] Invalid session, re-identifying...`);
+                this.sessionId = null;
+                this.sequence = null;
+                // Wait 1-5s before re-identifying (per Discord docs)
+                setTimeout(() => {
+                    this.ws?.close(4000, "Re-identifying");
+                }, 1000 + Math.random() * 4000);
+                break;
+            case OP.DISPATCH:
+                this.handleDispatch(t, d);
+                break;
+        }
+    }
+    handleDispatch(eventName, data) {
+        switch (eventName) {
+            case "READY":
+                this.sessionId = data.session_id;
+                this.resumeUrl = data.resume_gateway_url;
+                this.botUserId = data.user?.id;
+                console.log(`[discord] Ready as ${data.user?.username}#${data.user?.discriminator} (${data.guilds?.length || 0} guilds)`);
+                break;
+            case "RESUMED":
+                console.log(`[discord] Session resumed`);
+                break;
+            case "MESSAGE_CREATE":
+                this.handleMessage(data).catch(err => {
+                    console.error(`[discord] Error handling message:`, err.message);
+                    this.stats.errors++;
+                });
+                break;
+        }
+    }
+    async handleMessage(data) {
+        // Ignore bot's own messages
+        if (data.author?.id === this.botUserId)
+            return;
+        // Ignore other bots
+        if (data.author?.bot)
+            return;
+        const channelId = data.channel_id;
+        const guildId = data.guild_id;
+        // Filter by allowed channels
+        if (this.config.allowed_channels?.length) {
+            if (!this.config.allowed_channels.includes(channelId))
+                return;
+        }
+        // Filter by allowed guilds
+        if (this.config.allowed_guilds?.length && guildId) {
+            if (!this.config.allowed_guilds.includes(guildId))
+                return;
+        }
+        // Check mention requirement
+        if (this.config.mention_required && this.botUserId) {
+            const mentioned = data.mentions?.some((m) => m.id === this.botUserId);
+            if (!mentioned)
+                return;
+        }
+        // Strip bot mention from content
+        let content = data.content || "";
+        if (this.botUserId) {
+            content = content.replace(new RegExp(`<@!?${this.botUserId}>`, "g"), "").trim();
+        }
+        if (!content)
+            return;
+        const payload = {
+            sender_id: data.author?.id || "unknown",
+            sender_name: data.member?.nick || data.author?.global_name || data.author?.username,
+            content,
+            metadata: {
+                channel_id: channelId,
+                guild_id: guildId,
+                message_id: data.id,
+                is_dm: !guildId,
+            },
+        };
+        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(`[discord] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})...`);
+        setTimeout(() => {
+            if (!this.running)
+                return;
+            // Use resume URL if available, otherwise default gateway
+            const url = (this.sessionId && this.resumeUrl) ? this.resumeUrl : GATEWAY_URL;
+            this.connectGateway(url);
+        }, delay);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { BaseAdapter, type OutboundMessage } from "./base.js";
+export interface EmailConfig {
+    api_key: string;
+    from_address: string;
+    webhook_port?: number;
+    webhook_secret?: string;
+}
+export declare class EmailAdapter extends BaseAdapter {
+    readonly type = "email";
+    readonly name: string;
+    private config;
+    private server;
+    private reconnectAttempts;
+    constructor(name: string, config: EmailConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(msg: OutboundMessage): Promise<boolean>;
+    private startWebhookServer;
+    /** Handle inbound Resend webhook event (POST with JSON body) */
+    private handleIncoming;
+    private processWebhookPayload;
+    private scheduleRestart;
+}

package/dist/node/adapters/email.js

@@ -0,0 +1,218 @@
+import { createServer } from "node:http";
+import { createHmac } from "node:crypto";
+import { BaseAdapter } from "./base.js";
+const RESEND_API = "https://api.resend.com";
+const DEFAULT_WEBHOOK_PORT = 3102;
+export class EmailAdapter extends BaseAdapter {
+    type = "email";
+    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(`[email] Starting Resend 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(`[email] Webhook server stopped`);
+    }
+    async sendMessage(msg) {
+        try {
+            const toAddress = msg.metadata?.from_address || msg.sender_id;
+            if (!toAddress) {
+                console.error("[email] No recipient email address");
+                return false;
+            }
+            const subject = msg.metadata?.subject || "Re: Your message";
+            const res = await fetch(`${RESEND_API}/emails`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.config.api_key}`,
+                },
+                body: JSON.stringify({
+                    from: this.config.from_address,
+                    to: [toAddress],
+                    subject,
+                    text: 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(`[email] Send failed (${res.status}):`, err);
+            this.stats.errors++;
+            return false;
+        }
+        catch (err) {
+            console.error(`[email] 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 Email adapter running");
+            }
+        });
+        this.server.on("error", (err) => {
+            console.error(`[email] Server error:`, err.message);
+            this.stats.errors++;
+            if (this.running)
+                this.scheduleRestart();
+        });
+        this.server.listen(port, () => {
+            console.log(`[email] Resend webhook server listening on port ${port}`);
+        });
+    }
+    /** Handle inbound Resend webhook event (POST with JSON body) */
+    handleIncoming(req, res) {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+        });
+        req.on("end", () => {
+            // Verify webhook signature if secret is configured
+            if (this.config.webhook_secret) {
+                const signature = req.headers["svix-signature"];
+                const messageId = req.headers["svix-id"];
+                const timestamp = req.headers["svix-timestamp"];
+                if (!signature || !messageId || !timestamp) {
+                    res.writeHead(401);
+                    res.end("Missing signature headers");
+                    return;
+                }
+                const signedContent = `${messageId}.${timestamp}.${body}`;
+                const secretBytes = Buffer.from(this.config.webhook_secret.replace("whsec_", ""), "base64");
+                const expectedSignature = createHmac("sha256", secretBytes)
+                    .update(signedContent)
+                    .digest("base64");
+                // Svix sends multiple signatures separated by spaces, each prefixed with "v1,"
+                const signatures = signature.split(" ").map((s) => s.replace("v1,", ""));
+                const valid = signatures.some((s) => s === expectedSignature);
+                if (!valid) {
+                    console.warn(`[email] Invalid webhook signature`);
+                    res.writeHead(401);
+                    res.end("Invalid signature");
+                    return;
+                }
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "ok" }));
+            this.processWebhookPayload(body).catch((err) => {
+                console.error(`[email] Error processing webhook:`, err.message);
+                this.stats.errors++;
+            });
+        });
+    }
+    async processWebhookPayload(raw) {
+        let data;
+        try {
+            data = JSON.parse(raw);
+        }
+        catch {
+            console.error(`[email] Invalid JSON in webhook payload`);
+            return;
+        }
+        // Resend inbound email webhook structure
+        // The event type for inbound emails is "email.received"
+        const eventType = data.type;
+        if (eventType !== "email.received") {
+            // Ignore non-inbound events (delivery status, bounces, etc.)
+            return;
+        }
+        const emailData = data.data;
+        if (!emailData)
+            return;
+        const fromAddress = emailData.from;
+        const toAddress = emailData.to;
+        const subject = emailData.subject || "";
+        // Extract text content from the email body
+        // Resend provides text and/or html fields
+        let content = emailData.text || "";
+        if (!content && emailData.html) {
+            // Basic HTML-to-text: strip tags and decode common entities
+            content = emailData.html
+                .replace(/<br\s*\/?>/gi, "\n")
+                .replace(/<\/p>/gi, "\n\n")
+                .replace(/<[^>]+>/g, "")
+                .replace(/&amp;/g, "&")
+                .replace(/&lt;/g, "<")
+                .replace(/&gt;/g, ">")
+                .replace(/&quot;/g, "\"")
+                .replace(/&#39;/g, "'")
+                .replace(/&nbsp;/g, " ")
+                .trim();
+        }
+        if (!content && subject) {
+            content = subject;
+        }
+        if (!fromAddress || !content)
+            return;
+        const payload = {
+            sender_id: fromAddress,
+            content,
+            metadata: {
+                from_address: fromAddress,
+                to_address: toAddress,
+                subject,
+                email_id: emailData.id,
+                created_at: emailData.created_at,
+                attachments: emailData.attachments?.length || 0,
+            },
+        };
+        this.stats.messages_in++;
+        this.stats.last_message_at = new Date().toISOString();
+        if (this.onInboundMessage) {
+            await this.onInboundMessage(payload).catch((err) => {
+                console.error(`[email] 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(`[email] 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/imessage.d.ts

@@ -0,0 +1,17 @@
+import { BaseAdapter, type OutboundMessage } from "./base.js";
+export interface IMessageConfig {
+    watch_groups?: number[];
+    mention_required?: string;
+    max_message_length?: number;
+}
+export declare class IMessageAdapter extends BaseAdapter {
+    readonly type = "imessage";
+    readonly name: string;
+    private process;
+    private config;
+    constructor(name: string, config?: IMessageConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendMessage(msg: OutboundMessage): Promise<boolean>;
+    private handleLine;
+}

package/dist/node/adapters/imessage.js

@@ -0,0 +1,118 @@
+import { spawn } from "node:child_process";
+import { BaseAdapter } from "./base.js";
+export class IMessageAdapter extends BaseAdapter {
+    type = "imessage";
+    name;
+    process = null;
+    config;
+    constructor(name, config = {}) {
+        super();
+        this.name = name;
+        this.config = config;
+    }
+    async start() {
+        if (this.running)
+            return;
+        this.running = true;
+        // Spawn imsg watch as a child process
+        const args = ["watch", "--json"];
+        this.process = spawn("imsg", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let buffer = "";
+        this.process.stdout?.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                this.handleLine(line).catch(err => {
+                    console.error(`[imessage] Error handling message:`, err.message);
+                    this.stats.errors++;
+                });
+            }
+        });
+        this.process.stderr?.on("data", (chunk) => {
+            console.error(`[imessage] stderr:`, chunk.toString().trim());
+        });
+        this.process.on("exit", (code) => {
+            console.log(`[imessage] Process exited with code ${code}`);
+            const wasRunning = this.running;
+            this.running = false;
+            // Auto-restart after 5s if unexpected exit while we were supposed to be running
+            if (code !== 0 && wasRunning) {
+                console.log(`[imessage] Restarting in 5s...`);
+                setTimeout(() => this.start(), 5000);
+            }
+        });
+        console.log(`[imessage] Watching for messages...`);
+    }
+    async stop() {
+        this.running = false;
+        if (this.process) {
+            this.process.kill("SIGTERM");
+            this.process = null;
+        }
+    }
+    async sendMessage(msg) {
+        try {
+            const text = msg.content.substring(0, this.config.max_message_length || 4000);
+            const chatId = msg.metadata?.chat_id || msg.conversation_id;
+            if (!chatId) {
+                console.error("[imessage] No chat_id to send to");
+                return false;
+            }
+            const proc = spawn("imsg", ["send", "--chat", String(chatId), text]);
+            return new Promise((resolve) => {
+                proc.on("exit", (code) => {
+                    if (code === 0) {
+                        this.stats.messages_out++;
+                        this.stats.last_message_at = new Date().toISOString();
+                        resolve(true);
+                    }
+                    else {
+                        this.stats.errors++;
+                        resolve(false);
+                    }
+                });
+            });
+        }
+        catch (err) {
+            this.stats.errors++;
+            return false;
+        }
+    }
+    async handleLine(line) {
+        let data;
+        try {
+            data = JSON.parse(line);
+        }
+        catch {
+            return; // Not JSON
+        }
+        // Filter by watched groups
+        if (this.config.watch_groups?.length) {
+            if (!this.config.watch_groups.includes(data.chat_id))
+                return;
+        }
+        // Check mention requirement
+        if (this.config.mention_required) {
+            if (!data.text?.includes(this.config.mention_required))
+                return;
+        }
+        const payload = {
+            sender_id: data.sender || data.handle || "unknown",
+            sender_name: data.sender_name,
+            content: data.text || "",
+            metadata: {
+                chat_id: data.chat_id,
+                group: data.group,
+                attachments: data.attachments,
+            },
+        };
+        this.stats.messages_in++;
+        this.stats.last_message_at = new Date().toISOString();
+        if (this.onInboundMessage) {
+            await this.onInboundMessage(payload);
+        }
+    }
+}