whale-code 6.4.0

package/dist/node/runtime.js

@@ -0,0 +1,351 @@
+import { cpus, totalmem, hostname } from "node:os";
+import { IMessageAdapter } from "./adapters/imessage.js";
+import { TelegramAdapter } from "./adapters/telegram.js";
+import { DiscordAdapter } from "./adapters/discord.js";
+import { SlackAdapter } from "./adapters/slack.js";
+import { WebchatAdapter } from "./adapters/webchat.js";
+import { WhatsAppAdapter } from "./adapters/whatsapp.js";
+import { SmsAdapter } from "./adapters/sms.js";
+import { EmailAdapter } from "./adapters/email.js";
+import { captureError, addBreadcrumb } from "../cli/services/error-logger.js";
+const HEARTBEAT_INTERVAL_MS = 60_000;
+const POLL_INTERVAL_MS = 2_000;
+const VERSION = "1.1.0";
+// Retry configuration
+const MAX_RELAY_RETRIES = 3;
+const INITIAL_RETRY_DELAY_MS = 1_000;
+const MAX_RETRY_DELAY_MS = 30_000;
+export class NodeRuntime {
+    config;
+    adapters = new Map();
+    heartbeatTimer = null;
+    pollTimers = new Map();
+    running = false;
+    startedAt = null;
+    // Connection health tracking
+    status = "starting";
+    consecutiveServerFailures = 0;
+    lastServerContact = null;
+    heartbeatsSent = 0;
+    heartbeatsFailed = 0;
+    messagesRelayed = 0;
+    messagesFailed = 0;
+    constructor(config) {
+        this.config = config;
+    }
+    getStats() {
+        const adapterStats = {};
+        for (const [id, adapter] of this.adapters) {
+            const s = adapter.getStats();
+            adapterStats[id] = {
+                type: adapter.type,
+                running: adapter.isRunning(),
+                messages_in: s.messages_in,
+                messages_out: s.messages_out,
+                errors: s.errors,
+            };
+        }
+        return {
+            status: this.status,
+            uptime_seconds: this.startedAt ? Math.floor((Date.now() - this.startedAt.getTime()) / 1000) : 0,
+            heartbeats_sent: this.heartbeatsSent,
+            heartbeats_failed: this.heartbeatsFailed,
+            messages_relayed: this.messagesRelayed,
+            messages_failed: this.messagesFailed,
+            consecutive_server_failures: this.consecutiveServerFailures,
+            last_server_contact: this.lastServerContact?.toISOString() || null,
+            adapters: adapterStats,
+        };
+    }
+    async start() {
+        this.running = true;
+        this.startedAt = new Date();
+        this.status = "starting";
+        addBreadcrumb("node", `Starting node ${this.config.node_id} v${VERSION}`, "info");
+        console.log(`[node] Starting WhaleNode "${this.config.node_id}" v${VERSION}...`);
+        // Start heartbeat — initial heartbeat validates server connectivity
+        const heartbeatOk = await this.sendHeartbeat();
+        this.status = heartbeatOk ? "connected" : "degraded";
+        this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), HEARTBEAT_INTERVAL_MS);
+        // Initialize adapters for each channel
+        for (const ch of this.config.channels) {
+            await this.startAdapter(ch);
+        }
+        // Handle graceful shutdown
+        process.on("SIGTERM", () => this.stop());
+        process.on("SIGINT", () => this.stop());
+        console.log(`[node] Running with ${this.adapters.size} channel adapter(s). Status: ${this.status}. Press Ctrl+C to stop.`);
+    }
+    async stop() {
+        console.log(`[node] Shutting down...`);
+        this.running = false;
+        this.status = "disconnected";
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        for (const [, timer] of this.pollTimers)
+            clearInterval(timer);
+        for (const [name, adapter] of this.adapters) {
+            console.log(`[node] Stopping adapter: ${name}`);
+            await adapter.stop();
+        }
+        console.log(`[node] Stopped.`);
+        process.exit(0);
+    }
+    async startAdapter(ch) {
+        let adapter;
+        switch (ch.type) {
+            case "imessage":
+                adapter = new IMessageAdapter(ch.name, ch.config);
+                break;
+            case "telegram":
+                adapter = new TelegramAdapter(ch.name, ch.config);
+                break;
+            case "discord":
+                adapter = new DiscordAdapter(ch.name, ch.config);
+                break;
+            case "slack":
+                adapter = new SlackAdapter(ch.name, ch.config);
+                break;
+            case "webchat":
+                adapter = new WebchatAdapter(ch.name, ch.config);
+                break;
+            case "whatsapp":
+                adapter = new WhatsAppAdapter(ch.name, ch.config);
+                break;
+            case "sms":
+                adapter = new SmsAdapter(ch.name, ch.config);
+                break;
+            case "email":
+                adapter = new EmailAdapter(ch.name, ch.config);
+                break;
+            default:
+                console.warn(`[node] Unknown channel type: ${ch.type}`);
+                return;
+        }
+        // Wire up inbound message handler — relay to server and deliver agent response
+        adapter.setMessageHandler(async (msg) => {
+            await this.relayAndDeliver(ch.id, msg);
+        });
+        await adapter.start();
+        this.adapters.set(ch.id, adapter);
+        // Start polling for queued outbound messages (async agent responses)
+        const pollTimer = setInterval(() => this.pollOutbound(ch.id, adapter), POLL_INTERVAL_MS);
+        this.pollTimers.set(ch.id, pollTimer);
+        console.log(`[node] Adapter started: ${ch.type} "${ch.name}"`);
+    }
+    /** Fetch with retry and exponential backoff */
+    async fetchWithRetry(url, options, maxRetries = MAX_RELAY_RETRIES) {
+        let lastError = null;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const res = await fetch(url, {
+                    ...options,
+                    signal: AbortSignal.timeout(30_000), // 30s timeout per attempt
+                });
+                // Retry on 5xx (server errors, including Cloudflare 520/522/524)
+                if (res.status >= 500 && attempt < maxRetries) {
+                    const delay = Math.min(INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt), MAX_RETRY_DELAY_MS);
+                    console.warn(`[fetch] ${res.status} from ${url}, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
+                    await sleep(delay);
+                    continue;
+                }
+                // Success or non-retryable error — update health tracking
+                this.recordServerContact(res.ok);
+                return res;
+            }
+            catch (err) {
+                lastError = err;
+                if (attempt < maxRetries) {
+                    const delay = Math.min(INITIAL_RETRY_DELAY_MS * Math.pow(2, attempt), MAX_RETRY_DELAY_MS);
+                    console.warn(`[fetch] Error: ${lastError.message}, retrying in ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
+                    await sleep(delay);
+                }
+            }
+        }
+        this.recordServerContact(false);
+        throw lastError || new Error("Fetch failed after retries");
+    }
+    /** Track server connectivity health */
+    recordServerContact(success) {
+        if (success) {
+            this.consecutiveServerFailures = 0;
+            this.lastServerContact = new Date();
+            if (this.status === "degraded" || this.status === "disconnected") {
+                console.log(`[node] Server connectivity restored`);
+                this.status = "connected";
+            }
+        }
+        else {
+            this.consecutiveServerFailures++;
+            if (this.consecutiveServerFailures >= 3 && this.status === "connected") {
+                console.warn(`[node] Server connectivity degraded (${this.consecutiveServerFailures} consecutive failures)`);
+                this.status = "degraded";
+            }
+            if (this.consecutiveServerFailures >= 10 && this.status !== "disconnected") {
+                console.error(`[node] Server appears unreachable (${this.consecutiveServerFailures} consecutive failures)`);
+                this.status = "disconnected";
+            }
+        }
+    }
+    /** Poll for undelivered outbound messages and deliver via adapter */
+    async pollOutbound(channelId, adapter) {
+        if (!this.running)
+            return;
+        try {
+            const url = `${this.config.server_url}/channels/${channelId}/messages?undelivered=true&limit=10`;
+            const res = await this.fetchWithRetry(url, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.config.api_key}`,
+                },
+            }, 1); // Only 1 retry for polling (runs every 2s anyway)
+            if (!res.ok)
+                return;
+            const data = await res.json();
+            if (!data.success || !data.messages?.length)
+                return;
+            for (const msg of data.messages) {
+                const outMsg = {
+                    id: msg.id,
+                    content: msg.content || "",
+                    sender_id: msg.sender_id || "agent",
+                    conversation_id: msg.conversation_id,
+                    metadata: msg.metadata,
+                };
+                const delivered = await adapter.sendMessage(outMsg);
+                if (delivered) {
+                    await this.markDelivered(channelId, msg.id);
+                    console.log(`[poll] Delivered queued message ${msg.id}`);
+                }
+            }
+        }
+        catch {
+            // Silent — polling errors are expected during connectivity blips
+        }
+    }
+    /** Relay inbound and deliver response synchronously with retry */
+    async relayAndDeliver(channelId, msg) {
+        try {
+            const res = await this.fetchWithRetry(`${this.config.server_url}/channels/${channelId}/messages`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.config.api_key}`,
+                },
+                body: JSON.stringify({
+                    direction: "inbound",
+                    ...msg,
+                }),
+            });
+            const data = await res.json();
+            this.messagesRelayed++;
+            if (data.success && data.agent_response) {
+                const adapter = this.adapters.get(channelId);
+                if (adapter) {
+                    const outMsg = {
+                        id: data.agent_response.id,
+                        content: data.agent_response.content,
+                        sender_id: "agent",
+                        conversation_id: data.conversation_id || data.agent_response.conversation_id,
+                        metadata: msg.metadata,
+                    };
+                    const delivered = await adapter.sendMessage(outMsg);
+                    if (delivered) {
+                        await this.markDelivered(channelId, data.agent_response.id);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            this.messagesFailed++;
+            console.error(`[relay] Failed after retries:`, err.message);
+            captureError({
+                error: err instanceof Error ? err : new Error(String(err)),
+                severity: "error",
+                tags: { source: "whale-node", operation: "relay", node_id: this.config.node_id, channel_id: channelId },
+            });
+        }
+    }
+    async markDelivered(channelId, messageId) {
+        try {
+            await this.fetchWithRetry(`${this.config.server_url}/channels/${channelId}/messages/${messageId}/delivered`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.config.api_key}`,
+                },
+            }, 1);
+        }
+        catch {
+            // Best effort — message was already delivered to user
+        }
+    }
+    async sendHeartbeat() {
+        try {
+            const channelStatuses = Array.from(this.adapters.entries()).map(([, adapter]) => ({
+                type: adapter.type,
+                name: adapter.name,
+                status: adapter.isRunning() ? "active" : "error",
+                stats: adapter.getStats(),
+            }));
+            const res = await this.fetchWithRetry(`${this.config.server_url}/nodes/heartbeat`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.config.api_key}`,
+                },
+                body: JSON.stringify({
+                    hardware: getHardwareInfo(),
+                    capabilities: getCapabilities(),
+                    version: VERSION,
+                    channels: channelStatuses,
+                    runtime_stats: {
+                        uptime_seconds: this.startedAt ? Math.floor((Date.now() - this.startedAt.getTime()) / 1000) : 0,
+                        messages_relayed: this.messagesRelayed,
+                        messages_failed: this.messagesFailed,
+                        status: this.status,
+                    },
+                }),
+            }, 2);
+            if (res.ok) {
+                this.heartbeatsSent++;
+                return true;
+            }
+            console.warn(`[heartbeat] Server returned ${res.status}`);
+            this.heartbeatsFailed++;
+            return false;
+        }
+        catch (err) {
+            console.warn(`[heartbeat] Failed:`, err.message);
+            this.heartbeatsFailed++;
+            // Only capture after multiple consecutive failures to avoid noise
+            if (this.consecutiveServerFailures >= 3) {
+                captureError({
+                    error: err instanceof Error ? err : new Error(String(err)),
+                    severity: "warning",
+                    tags: { source: "whale-node", operation: "heartbeat", node_id: this.config.node_id, failures: String(this.consecutiveServerFailures) },
+                });
+            }
+            return false;
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function getHardwareInfo() {
+    return {
+        os: process.platform === "darwin" ? "macOS" : process.platform,
+        arch: process.arch,
+        cpu: cpus()[0]?.model || "unknown",
+        cores: cpus().length,
+        ram_gb: Math.round(totalmem() / (1024 ** 3)),
+        hostname: hostname(),
+    };
+}
+function getCapabilities() {
+    const caps = ["messaging", "discord", "slack", "telegram", "webchat", "whatsapp", "sms", "email"];
+    if (process.platform === "darwin")
+        caps.push("imessage");
+    return caps;
+}

package/dist/server/handlers/__test-utils__/mock-supabase.d.ts

@@ -0,0 +1,11 @@
+/** Pre-populate a table with rows for the current test */
+export declare function setTableData(table: string, rows: unknown[]): void;
+/** Pre-configure the return value for an RPC call */
+export declare function setRpcResponse(name: string, data: unknown, error?: unknown): void;
+/** Force a table to return an error on any operation */
+export declare function setTableError(table: string, message: string, code?: string): void;
+/** Reset all in-memory state between tests */
+export declare function resetMock(): void;
+/** Get current in-memory rows for a table (for post-operation assertions) */
+export declare function getTableData(table: string): unknown[];
+export declare function createMockSupabase(): unknown;