whale-code 6.4.0

package/dist/node/cli.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { loadConfig, saveConfig, requireConfig, getConfigPath } from "./config.js";
+import { NodeRuntime } from "./runtime.js";
+import { initErrorLogger, setErrorLoggerUser, captureError } from "../cli/services/error-logger.js";
+import { loadConfig as loadCliConfig } from "../cli/services/config-store.js";
+const args = process.argv.slice(2);
+const command = args[0];
+const subcommand = args[1];
+// Initialize error logging — uses ~/.swagmanager/config.json for Supabase credentials
+initErrorLogger({ serviceName: "whale-node" });
+const cliCfg = loadCliConfig();
+if (cliCfg.user_id || cliCfg.email || cliCfg.store_id) {
+    setErrorLoggerUser(cliCfg.user_id, cliCfg.email, cliCfg.store_id);
+}
+// Global error handlers — capture crashes to error_events
+process.on("uncaughtException", (err) => {
+    captureError({ error: err, severity: "fatal", tags: { source: "whale-node", handler: "uncaughtException" } });
+});
+process.on("unhandledRejection", (reason) => {
+    const err = reason instanceof Error ? reason : new Error(String(reason));
+    captureError({ error: err, severity: "error", tags: { source: "whale-node", handler: "unhandledRejection" } });
+});
+async function main() {
+    switch (command) {
+        case "node":
+            await handleNodeCommand(subcommand, args.slice(2));
+            break;
+        case "channel":
+            await handleChannelCommand(subcommand, args.slice(2));
+            break;
+        case "status":
+            await handleStatus();
+            break;
+        case "version":
+            console.log("WhaleNode CLI v1.1.0");
+            break;
+        case "help":
+        default:
+            printHelp();
+    }
+}
+async function handleNodeCommand(sub, args) {
+    switch (sub) {
+        case "register": {
+            const { values } = parseArgs({
+                args,
+                options: {
+                    name: { type: "string" },
+                    store: { type: "string" },
+                    server: { type: "string", default: "https://whale-agent.fly.dev" },
+                    token: { type: "string" },
+                },
+            });
+            if (!values.name || !values.store || !values.token) {
+                console.error("Usage: whale node register --name 'My Mac' --store STORE_ID --token JWT_TOKEN");
+                process.exit(1);
+            }
+            console.log(`Registering node "${values.name}"...`);
+            const res = await fetch(`${values.server}/nodes/register`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${values.token}`,
+                },
+                body: JSON.stringify({
+                    name: values.name,
+                    store_id: values.store,
+                }),
+            });
+            const data = await res.json();
+            if (!data.success) {
+                console.error(`Registration failed: ${data.error}`);
+                process.exit(1);
+            }
+            const config = {
+                node_id: data.node.id,
+                api_key: data.api_key,
+                store_id: values.store,
+                server_url: values.server,
+                channels: [],
+            };
+            saveConfig(config);
+            console.log(`\nNode registered successfully!`);
+            console.log(`  Node ID: ${data.node.id}`);
+            console.log(`  API Key: ${data.api_key}`);
+            console.log(`  Config:  ${getConfigPath()}`);
+            console.log(`\nSave your API key -- it cannot be retrieved later.`);
+            console.log(`\nNext: whale channel add imessage|telegram`);
+            break;
+        }
+        case "start": {
+            const config = requireConfig();
+            const runtime = new NodeRuntime(config);
+            await runtime.start();
+            // Keep process alive
+            await new Promise(() => { });
+            break;
+        }
+        case "status": {
+            await handleStatus();
+            break;
+        }
+        default:
+            console.log("Usage: whale node [register|start|status]");
+    }
+}
+async function handleChannelCommand(sub, args) {
+    switch (sub) {
+        case "add": {
+            const channelType = args[0];
+            const validTypes = ["imessage", "telegram", "discord", "slack", "whatsapp", "sms", "email"];
+            if (!channelType || !validTypes.includes(channelType)) {
+                console.error(`Usage: whale channel add [${validTypes.join("|")}]`);
+                process.exit(1);
+            }
+            const config = requireConfig();
+            const { values } = parseArgs({
+                args: args.slice(1),
+                options: {
+                    name: { type: "string" },
+                    token: { type: "string" }, // Bot token (Telegram, Discord, Slack bot)
+                    "app-token": { type: "string" }, // Slack app-level token
+                    groups: { type: "string" }, // iMessage group IDs (comma-separated)
+                    channels: { type: "string" }, // Discord/Slack channel IDs (comma-separated)
+                    guilds: { type: "string" }, // Discord guild IDs (comma-separated)
+                    mention: { type: "string", default: "" }, // Require @mention
+                    // WhatsApp Cloud API
+                    "phone-number-id": { type: "string" }, // WhatsApp phone number ID
+                    "access-token": { type: "string" }, // WhatsApp access token
+                    "verify-token": { type: "string" }, // WhatsApp webhook verify token
+                    "allowed-numbers": { type: "string" }, // Comma-separated allowed phone numbers
+                    // Twilio SMS
+                    "account-sid": { type: "string" }, // Twilio account SID
+                    "auth-token": { type: "string" }, // Twilio auth token
+                    "from-number": { type: "string" }, // Twilio sender phone number
+                    // Resend Email
+                    "api-key": { type: "string" }, // Resend API key
+                    "from-address": { type: "string" }, // Sender email address
+                    "webhook-secret": { type: "string" }, // Resend webhook signing secret
+                    // Shared
+                    "webhook-port": { type: "string" }, // Webhook server port
+                },
+            });
+            const channelName = values.name || `${channelType}-${Date.now()}`;
+            let channelConfig = {};
+            switch (channelType) {
+                case "imessage":
+                    channelConfig = {
+                        watch_groups: values.groups ? values.groups.split(",").map(Number) : [],
+                        mention_required: values.mention || null,
+                        max_message_length: 4000,
+                    };
+                    break;
+                case "telegram":
+                    if (!values.token) {
+                        console.error("Telegram requires --token BOT_TOKEN");
+                        process.exit(1);
+                    }
+                    channelConfig = {
+                        bot_token: values.token,
+                        allowed_chats: [],
+                    };
+                    break;
+                case "discord":
+                    if (!values.token) {
+                        console.error("Discord requires --token BOT_TOKEN");
+                        process.exit(1);
+                    }
+                    channelConfig = {
+                        bot_token: values.token,
+                        allowed_channels: values.channels ? values.channels.split(",") : [],
+                        allowed_guilds: values.guilds ? values.guilds.split(",") : [],
+                        mention_required: values.mention !== "" ? true : false,
+                    };
+                    break;
+                case "slack":
+                    if (!values.token || !values["app-token"]) {
+                        console.error("Slack requires --token BOT_TOKEN --app-token APP_TOKEN");
+                        process.exit(1);
+                    }
+                    channelConfig = {
+                        bot_token: values.token,
+                        app_token: values["app-token"],
+                        allowed_channels: values.channels ? values.channels.split(",") : [],
+                        mention_required: values.mention !== "" ? true : false,
+                    };
+                    break;
+                case "whatsapp":
+                    if (!values["phone-number-id"] || !values["access-token"] || !values["verify-token"]) {
+                        console.error("WhatsApp requires --phone-number-id ID --access-token TOKEN --verify-token SECRET");
+                        process.exit(1);
+                    }
+                    channelConfig = {
+                        phone_number_id: values["phone-number-id"],
+                        access_token: values["access-token"],
+                        verify_token: values["verify-token"],
+                        allowed_numbers: values["allowed-numbers"] ? values["allowed-numbers"].split(",") : [],
+                        ...(values["webhook-port"] ? { webhook_port: Number(values["webhook-port"]) } : {}),
+                    };
+                    break;
+                case "sms":
+                    if (!values["account-sid"] || !values["auth-token"] || !values["from-number"]) {
+                        console.error("SMS requires --account-sid SID --auth-token TOKEN --from-number +1234567890");
+                        process.exit(1);
+                    }
+                    channelConfig = {
+                        account_sid: values["account-sid"],
+                        auth_token: values["auth-token"],
+                        from_number: values["from-number"],
+                        ...(values["webhook-port"] ? { webhook_port: Number(values["webhook-port"]) } : {}),
+                    };
+                    break;
+                case "email":
+                    if (!values["api-key"] || !values["from-address"]) {
+                        console.error("Email requires --api-key KEY --from-address sender@example.com");
+                        process.exit(1);
+                    }
+                    channelConfig = {
+                        api_key: values["api-key"],
+                        from_address: values["from-address"],
+                        ...(values["webhook-secret"] ? { webhook_secret: values["webhook-secret"] } : {}),
+                        ...(values["webhook-port"] ? { webhook_port: Number(values["webhook-port"]) } : {}),
+                    };
+                    break;
+                default:
+                    console.error(`Unknown channel type: ${channelType}`);
+                    process.exit(1);
+            }
+            // Register channel with server
+            console.log(`Adding ${channelType} channel "${channelName}"...`);
+            const res = await fetch(`${config.server_url}/channels`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${config.api_key}`,
+                },
+                body: JSON.stringify({
+                    store_id: config.store_id,
+                    node_id: config.node_id,
+                    type: channelType,
+                    name: channelName,
+                    config: channelConfig,
+                }),
+            });
+            const data = await res.json();
+            if (!data.success) {
+                console.error(`Failed to add channel: ${data.error}`);
+                process.exit(1);
+            }
+            // Save to local config
+            config.channels.push({
+                id: data.channel.id,
+                type: channelType,
+                name: channelName,
+                config: channelConfig,
+            });
+            saveConfig(config);
+            console.log(`Channel added!`);
+            console.log(`  ID:   ${data.channel.id}`);
+            console.log(`  Type: ${channelType}`);
+            console.log(`  Name: ${channelName}`);
+            break;
+        }
+        case "list": {
+            const config = requireConfig();
+            if (!config.channels.length) {
+                console.log("No channels configured. Run: whale channel add [imessage|telegram|discord|slack|whatsapp|sms|email]");
+                return;
+            }
+            console.log("Configured channels:");
+            for (const ch of config.channels) {
+                console.log(`  ${ch.type.padEnd(10)} ${ch.name.padEnd(20)} ${ch.id}`);
+            }
+            break;
+        }
+        default:
+            console.log("Usage: whale channel [add|list]");
+    }
+}
+async function handleStatus() {
+    const config = loadConfig();
+    if (!config) {
+        console.log("Not configured. Run: whale node register --name 'My Mac' --store STORE_ID --token JWT");
+        return;
+    }
+    console.log("WhaleNode Status:");
+    console.log(`  Node ID:  ${config.node_id}`);
+    console.log(`  Store:    ${config.store_id}`);
+    console.log(`  Server:   ${config.server_url}`);
+    console.log(`  Channels: ${config.channels.length}`);
+    console.log(`  Config:   ${getConfigPath()}`);
+}
+function printHelp() {
+    console.log(`
+WhaleNode CLI v1.1.0 — Bridge local channels to WhaleTools AI agents
+
+Commands:
+  whale node register   Register this machine as a WhaleNode
+  whale node start      Start the node (heartbeat + channel adapters)
+  whale node status     Show node status
+
+  whale channel add     Add a channel adapter
+  whale channel list    List configured channels
+
+  whale status          Quick status check
+  whale version         Show version
+  whale help            Show this help
+
+Channel Types:
+  imessage   --groups 109,110 --mention @whale
+  telegram   --token BOT_TOKEN
+  discord    --token BOT_TOKEN [--channels ID1,ID2] [--guilds ID1] [--mention]
+  slack      --token BOT_TOKEN --app-token APP_TOKEN [--channels ID1,ID2] [--mention]
+  whatsapp   --phone-number-id ID --access-token TOKEN --verify-token SECRET [--allowed-numbers +1...,+2...]
+  sms        --account-sid SID --auth-token TOKEN --from-number +1234567890 [--webhook-port 3101]
+  email      --api-key KEY --from-address sender@example.com [--webhook-secret SECRET] [--webhook-port 3102]
+`);
+}
+main().catch(err => {
+    captureError({ error: err instanceof Error ? err : new Error(String(err)), severity: "fatal", tags: { source: "whale-node", handler: "main" } });
+    console.error("Error:", err.message);
+    // Give error logger a moment to flush before exit
+    setTimeout(() => process.exit(1), 500);
+});

package/dist/node/config.d.ts

@@ -0,0 +1,17 @@
+export interface ChannelConfig {
+    id: string;
+    type: string;
+    name: string;
+    config: Record<string, unknown>;
+}
+export interface NodeConfig {
+    node_id: string;
+    api_key: string;
+    store_id: string;
+    server_url: string;
+    channels: ChannelConfig[];
+}
+export declare function getConfigPath(): string;
+export declare function loadConfig(): NodeConfig | null;
+export declare function saveConfig(config: NodeConfig): void;
+export declare function requireConfig(): NodeConfig;

package/dist/node/config.js

@@ -0,0 +1,31 @@
+// Config stored at ~/.whaletools/config.json
+// Fields: node_id, api_key, store_id, server_url, channels[]
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_DIR = join(homedir(), ".whaletools");
+const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+export function getConfigPath() { return CONFIG_FILE; }
+export function loadConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return null;
+    try {
+        return JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    if (!existsSync(CONFIG_DIR))
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+export function requireConfig() {
+    const config = loadConfig();
+    if (!config) {
+        console.error("Not configured. Run: whale node register --name 'My Node' --store STORE_ID --server URL");
+        process.exit(1);
+    }
+    return config;
+}

package/dist/node/runtime.d.ts

@@ -0,0 +1,50 @@
+import type { NodeConfig } from "./config.js";
+import type { MessagePayload } from "./adapters/base.js";
+export type NodeStatus = "starting" | "connected" | "degraded" | "disconnected";
+export interface NodeRuntimeStats {
+    status: NodeStatus;
+    uptime_seconds: number;
+    heartbeats_sent: number;
+    heartbeats_failed: number;
+    messages_relayed: number;
+    messages_failed: number;
+    consecutive_server_failures: number;
+    last_server_contact: string | null;
+    adapters: Record<string, {
+        type: string;
+        running: boolean;
+        messages_in: number;
+        messages_out: number;
+        errors: number;
+    }>;
+}
+export declare class NodeRuntime {
+    private config;
+    private adapters;
+    private heartbeatTimer;
+    private pollTimers;
+    private running;
+    private startedAt;
+    private status;
+    private consecutiveServerFailures;
+    private lastServerContact;
+    private heartbeatsSent;
+    private heartbeatsFailed;
+    private messagesRelayed;
+    private messagesFailed;
+    constructor(config: NodeConfig);
+    getStats(): NodeRuntimeStats;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private startAdapter;
+    /** Fetch with retry and exponential backoff */
+    private fetchWithRetry;
+    /** Track server connectivity health */
+    private recordServerContact;
+    /** Poll for undelivered outbound messages and deliver via adapter */
+    private pollOutbound;
+    /** Relay inbound and deliver response synchronously with retry */
+    relayAndDeliver(channelId: string, msg: MessagePayload): Promise<void>;
+    private markDelivered;
+    private sendHeartbeat;
+}