whale-code 6.5.5 → 6.5.6

package/dist/node/runtime.js

@@ -1,4 +1,5 @@
-import { cpus, totalmem, hostname } from "node:os";
+import { cpus, totalmem, freemem, hostname, loadavg } from "node:os";
+import { execSync } from "node:child_process";
 import { IMessageAdapter } from "./adapters/imessage.js";
 import { TelegramAdapter } from "./adapters/telegram.js";
 import { DiscordAdapter } from "./adapters/discord.js";
@@ -14,446 +15,528 @@ import { PortalManager } from "./portal/index.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;
-    // Server gateway connection
-    gatewayClient = null;
-    // Screen capture service (macOS only)
-    screenCapture = null;
-    // Portal manager (node-to-node connectivity)
-    portalManager = null;
-    constructor(config) {
-        this.config = 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;
+
+  // Server gateway connection
+  gatewayClient = null;
+
+  // Screen capture service (macOS only)
+  screenCapture = null;
+
+  // Portal manager (node-to-node connectivity)
+  portalManager = null;
+  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
+      };
     }
-    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);
+    }
+
+    // Connect to server gateway for receiving commands
+    this.gatewayClient = new GatewayClient({
+      serverUrl: this.config.server_url,
+      apiKey: this.config.api_key,
+      version: VERSION
+    });
+
+    // Register exec command handler
+    this.gatewayClient.onCommand("exec", async msg => {
+      const {
+        execSync
+      } = await import("node:child_process");
+      try {
+        const stdout = execSync(msg.command, {
+          timeout: msg.timeout || 30_000,
+          cwd: process.env.HOME,
+          encoding: "utf-8",
+          maxBuffer: 512 * 1024
+        });
         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,
+          stdout,
+          exit_code: 0
+        };
+      } catch (err) {
+        return {
+          stdout: err.stdout || "",
+          stderr: err.stderr || err.message,
+          exit_code: err.status || 1
+        };
+      }
+    });
+
+    // Register remote desktop command handler on gateway — forward input events
+    this.gatewayClient.onCommand("remote_desktop", async msg => {
+      if (!this.screenCapture) {
+        return {
+          error: "Screen capture not enabled"
         };
+      }
+      if (msg.type === "input") {
+        this.screenCapture.injectInput(msg);
+        return null;
+      }
+      // Return capture status for session requests
+      return {
+        type: "remote_desktop_response",
+        success: true,
+        ...this.screenCapture.getStatus()
+      };
+    });
+    this.gatewayClient.start();
+
+    // Start screen capture service (macOS only)
+    if (process.platform === "darwin" && this.config.remote_desktop?.enabled !== false) {
+      try {
+        this.screenCapture = new ScreenCaptureService(this.config.remote_desktop || {});
+        await this.screenCapture.start();
+      } catch (err) {
+        console.warn("[node] Screen capture failed to start:", err.message);
+      }
     }
-    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);
-        }
-        // Connect to server gateway for receiving commands
-        this.gatewayClient = new GatewayClient({
-            serverUrl: this.config.server_url,
-            apiKey: this.config.api_key,
-            version: VERSION,
-        });
-        // Register exec command handler
-        this.gatewayClient.onCommand("exec", async (msg) => {
-            const { execSync } = await import("node:child_process");
-            try {
-                const stdout = execSync(msg.command, {
-                    timeout: msg.timeout || 30_000,
-                    cwd: process.env.HOME,
-                    encoding: "utf-8",
-                    maxBuffer: 512 * 1024,
-                });
-                return { stdout, exit_code: 0 };
-            }
-            catch (err) {
-                return {
-                    stdout: err.stdout || "",
-                    stderr: err.stderr || err.message,
-                    exit_code: err.status || 1,
-                };
-            }
-        });
-        // Register remote desktop command handler on gateway — forward input events
-        this.gatewayClient.onCommand("remote_desktop", async (msg) => {
-            if (!this.screenCapture) {
-                return { error: "Screen capture not enabled" };
-            }
-            if (msg.type === "input") {
-                this.screenCapture.injectInput(msg);
-                return null;
-            }
-            // Return capture status for session requests
-            return {
-                type: "remote_desktop_response",
-                success: true,
-                ...this.screenCapture.getStatus(),
-            };
-        });
-        this.gatewayClient.start();
-        // Start screen capture service (macOS only)
-        if (process.platform === "darwin" && this.config.remote_desktop?.enabled !== false) {
-            try {
-                this.screenCapture = new ScreenCaptureService(this.config.remote_desktop || {});
-                await this.screenCapture.start();
-            }
-            catch (err) {
-                console.warn("[node] Screen capture failed to start:", err.message);
-            }
-        }
-        // Initialize portal manager
-        try {
-            const portalConfig = this.config.portal || {};
-            this.portalManager = new PortalManager({
-                nodeConfig: this.config,
-                gateway: this.gatewayClient,
-                screenCapture: this.screenCapture,
-                receiveDir: portalConfig.receive_dir,
-                autoAcceptAdmins: portalConfig.auto_accept_admins !== false,
-                maxSessions: portalConfig.max_sessions || 5,
-            });
-            console.log("[node] Portal handler registered");
-        }
-        catch (err) {
-            console.warn("[node] Portal handler failed to initialize:", err.message);
-        }
-        // Handle graceful shutdown
-        process.on("SIGTERM", () => this.stop());
-        process.on("SIGINT", () => this.stop());
-        console.log(`[node] Running with ${this.adapters.size} channel adapter(s). Gateway: connecting. Press Ctrl+C to stop.`);
+
+    // Initialize portal manager
+    try {
+      const portalConfig = this.config.portal || {};
+      this.portalManager = new PortalManager({
+        nodeConfig: this.config,
+        gateway: this.gatewayClient,
+        screenCapture: this.screenCapture,
+        receiveDir: portalConfig.receive_dir,
+        autoAcceptAdmins: portalConfig.auto_accept_admins !== false,
+        maxSessions: portalConfig.max_sessions || 5
+      });
+      console.log("[node] Portal handler registered");
+    } catch (err) {
+      console.warn("[node] Portal handler failed to initialize:", err.message);
     }
-    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);
-        // Stop portal sessions
-        if (this.portalManager) {
-            this.portalManager.closeAll();
-            this.portalManager = null;
-        }
-        // Stop screen capture
-        if (this.screenCapture) {
-            await this.screenCapture.stop();
-            this.screenCapture = null;
-        }
-        // Disconnect from server gateway
-        if (this.gatewayClient)
-            this.gatewayClient.stop();
-        for (const [name, adapter] of this.adapters) {
-            console.log(`[node] Stopping adapter: ${name}`);
-            await adapter.stop();
-        }
-        console.log(`[node] Stopped.`);
-        process.exit(0);
+
+    // Handle graceful shutdown
+    process.on("SIGTERM", () => this.stop());
+    process.on("SIGINT", () => this.stop());
+    console.log(`[node] Running with ${this.adapters.size} channel adapter(s). Gateway: connecting. 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);
+
+    // Stop portal sessions
+    if (this.portalManager) {
+      this.portalManager.closeAll();
+      this.portalManager = null;
     }
-    /**
-     * Get a channel adapter by ID.
-     */
-    getAdapter(channelId) {
-        return this.adapters.get(channelId);
+
+    // Stop screen capture
+    if (this.screenCapture) {
+      await this.screenCapture.stop();
+      this.screenCapture = null;
     }
-    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}"`);
+
+    // Disconnect from server gateway
+    if (this.gatewayClient) this.gatewayClient.stop();
+    for (const [name, adapter] of this.adapters) {
+      console.log(`[node] Stopping adapter: ${name}`);
+      await adapter.stop();
     }
-    /** 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");
+    console.log(`[node] Stopped.`);
+    process.exit(0);
+  }
+
+  /**
+   * Get a channel adapter by ID.
+   */
+  getAdapter(channelId) {
+    return this.adapters.get(channelId);
+  }
+  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;
     }
-    /** 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";
-            }
+
+    // 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;
         }
-        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";
-            }
+
+        // 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);
         }
+      }
     }
-    /** 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
-        }
+    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";
+      }
     }
-    /** 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);
-                    }
-                }
-            }
+  }
+
+  /** 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}`
         }
-        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 },
-            });
+      }, 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
     }
-    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);
+  }
+
+  /** 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 {
-            // Best effort — message was already delivered to user
+      }
+    } 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 sendHeartbeat() {
-        try {
-            const channelStatuses = Array.from(this.adapters.entries()).map(([, adapter]) => {
-                const base = {
-                    type: adapter.type,
-                    name: adapter.name,
-                    status: adapter.isRunning() ? "active" : "error",
-                    stats: adapter.getStats(),
-                };
-                // Include diagnostics for iMessage adapters
-                if (adapter.type === "imessage" && "getLastError" in adapter) {
-                    const imsg = adapter;
-                    base.last_error = imsg.getLastError();
-                    base.restart_attempts = imsg.getRestartAttempts();
-                }
-                return base;
-            });
-            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;
+  }
+  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}`
         }
-        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;
+      }, 1 // 1 retry for delivery confirmation
+      );
+    } catch {
+      // Best effort — message was already delivered to user
+    }
+  }
+  async sendHeartbeat() {
+    try {
+      const channelStatuses = Array.from(this.adapters.entries()).map(([, adapter]) => {
+        const base = {
+          type: adapter.type,
+          name: adapter.name,
+          status: adapter.isRunning() ? "active" : "error",
+          stats: adapter.getStats()
+        };
+        // Include diagnostics for iMessage adapters
+        if (adapter.type === "imessage" && "getLastError" in adapter) {
+          const imsg = adapter;
+          base.last_error = imsg.getLastError();
+          base.restart_attempts = imsg.getRestartAttempts();
         }
+        return base;
+      });
+      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 // 2 retries for heartbeat
+      );
+      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));
+  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(),
-    };
+  const totalMem = totalmem();
+  const freeMem = freemem();
+  const usedMem = totalMem - freeMem;
+  return {
+    // Static specs
+    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(),
+    // Live utilization
+    mem_used_gb: parseFloat((usedMem / 1024 ** 3).toFixed(1)),
+    mem_free_gb: parseFloat((freeMem / 1024 ** 3).toFixed(1)),
+    mem_usage_percent: Math.round(usedMem / totalMem * 100),
+    cpu_usage_percent: getCpuUsagePercent(),
+    load_avg_1m: parseFloat(loadavg()[0].toFixed(2)),
+    disk_usage_percent: getDiskUsagePercent()
+  };
 }
-function getCapabilities() {
-    const caps = ["messaging", "discord", "slack", "telegram", "webchat", "whatsapp", "sms", "email", "portal"];
-    if (process.platform === "darwin") {
-        caps.push("imessage");
-        caps.push("remote_desktop");
+
+/** Calculate CPU usage from per-core idle vs total ticks */
+function getCpuUsagePercent() {
+  const cores = cpus();
+  let totalIdle = 0;
+  let totalTick = 0;
+  for (const core of cores) {
+    const {
+      user,
+      nice,
+      sys,
+      idle,
+      irq
+    } = core.times;
+    totalTick += user + nice + sys + idle + irq;
+    totalIdle += idle;
+  }
+  return totalTick > 0 ? Math.round((totalTick - totalIdle) / totalTick * 100) : 0;
+}
+
+/** Get root disk usage percent (works on macOS + Linux) */
+function getDiskUsagePercent() {
+  try {
+    const output = execSync("df -k / | tail -1", {
+      timeout: 3000
+    }).toString().trim();
+    const parts = output.split(/\s+/);
+    // df output: Filesystem 1K-blocks Used Available Use% Mounted
+    const capacityStr = parts.find(p => p.endsWith("%"));
+    if (capacityStr) return parseInt(capacityStr, 10);
+    // Fallback: compute from used/available
+    if (parts.length >= 4) {
+      const used = parseInt(parts[2], 10);
+      const available = parseInt(parts[3], 10);
+      if (used + available > 0) return Math.round(used / (used + available) * 100);
     }
-    return caps;
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+function getCapabilities() {
+  const caps = ["messaging", "discord", "slack", "telegram", "webchat", "whatsapp", "sms", "email", "portal"];
+  if (process.platform === "darwin") {
+    caps.push("imessage");
+    caps.push("remote_desktop");
+  }
+  return caps;
 }
+//# sourceMappingURL=runtime.js.map