whale-code 6.4.0 → 6.5.0

package/dist/node/cli.js

@@ -26,9 +26,16 @@ async function main() {
         case "node":
             await handleNodeCommand(subcommand, args.slice(2));
             break;
+        case "remote-desktop":
+            await handleRemoteDesktopCommand(subcommand, args.slice(2));
+            break;
         case "channel":
             await handleChannelCommand(subcommand, args.slice(2));
             break;
+        case "portal":
+        case "p":
+            await handlePortalCommand(subcommand, args.slice(2));
+            break;
         case "status":
             await handleStatus();
             break;
@@ -91,6 +98,10 @@ async function handleNodeCommand(sub, args) {
         }
         case "start": {
             const config = requireConfig();
+            // Inject API keys from config into env so decomposer/reviewer can find them
+            if (config.anthropic_api_key && !process.env.ANTHROPIC_API_KEY) {
+                process.env.ANTHROPIC_API_KEY = config.anthropic_api_key;
+            }
             const runtime = new NodeRuntime(config);
             await runtime.start();
             // Keep process alive
@@ -278,6 +289,37 @@ async function handleChannelCommand(sub, args) {
             console.log("Usage: whale channel [add|list]");
     }
 }
+async function handleRemoteDesktopCommand(sub, _args) {
+    const config = requireConfig();
+    switch (sub) {
+        case "enable": {
+            config.remote_desktop = { ...config.remote_desktop, enabled: true };
+            saveConfig(config);
+            console.log("Remote desktop enabled. Takes effect on next `whale node start`.");
+            break;
+        }
+        case "disable": {
+            config.remote_desktop = { ...config.remote_desktop, enabled: false };
+            saveConfig(config);
+            console.log("Remote desktop disabled. Takes effect on next `whale node start`.");
+            break;
+        }
+        case "status": {
+            const rd = config.remote_desktop;
+            console.log("Remote Desktop:");
+            console.log(`  Enabled:  ${rd?.enabled !== false ? "yes" : "no"}`);
+            console.log(`  Port:     ${rd?.port || 5900}`);
+            console.log(`  Max FPS:  ${rd?.max_fps || 60}`);
+            console.log(`  Quality:  ${rd?.quality || 0.6}`);
+            if (process.platform !== "darwin") {
+                console.log(`  Platform: ${process.platform} (macOS required)`);
+            }
+            break;
+        }
+        default:
+            console.log("Usage: whale remote-desktop [enable|disable|status]");
+    }
+}
 async function handleStatus() {
     const config = loadConfig();
     if (!config) {
@@ -291,21 +333,430 @@ async function handleStatus() {
     console.log(`  Channels: ${config.channels.length}`);
     console.log(`  Config:   ${getConfigPath()}`);
 }
+// ============================================================================
+// PORTAL COMMANDS
+// ============================================================================
+async function handlePortalCommand(sub, args) {
+    const config = requireConfig();
+    // Lazy imports — only load portal code when needed
+    const { discoverNodes, findNode } = await import("./portal/discovery.js");
+    const { printNodeList, printConnecting, printConnected, printDisconnected, printError, printProgress, showPortalMenu } = await import("./portal/ui.js");
+    const discoveryOpts = {
+        serverUrl: config.server_url,
+        apiKey: config.api_key,
+        storeId: config.store_id,
+    };
+    switch (sub) {
+        case "ls":
+        case "list": {
+            const { values } = parseArgs({
+                args,
+                options: { all: { type: "boolean", short: "a", default: false } },
+            });
+            const nodes = await discoverNodes({ ...discoveryOpts, includeOffline: values.all });
+            printNodeList(nodes, values.all);
+            break;
+        }
+        case "sh":
+        case "shell": {
+            const nodeName = args[0];
+            if (!nodeName) {
+                console.error("Usage: whale portal sh <node> [--dir PATH] [-c COMMAND]");
+                process.exit(1);
+            }
+            const { values } = parseArgs({
+                args: args.slice(1),
+                options: {
+                    dir: { type: "string" },
+                    c: { type: "string" },
+                },
+            });
+            const node = await findNode(nodeName, discoveryOpts);
+            if (!node) {
+                printError(`Node "${nodeName}" not found or offline`);
+                process.exit(1);
+            }
+            printConnecting(node.name);
+            const { GatewayClient } = await import("./gateway-client.js");
+            const { PortalManager } = await import("./portal/index.js");
+            const { openShell } = await import("./portal/shell.js");
+            const gateway = new GatewayClient({
+                serverUrl: config.server_url,
+                apiKey: config.api_key,
+                capabilities: ["portal"],
+                version: "1.1.0",
+            });
+            gateway.start();
+            await waitForGateway(gateway);
+            const portal = new PortalManager({ nodeConfig: config, gateway });
+            const session = await portal.connect(node.id, ["shell"]);
+            printConnected(node.hostname);
+            const { cleanup } = await openShell(session, {
+                cwd: values.dir,
+                command: values.c,
+            });
+            // If single command mode, we're already done
+            if (values.c) {
+                cleanup();
+                session.close();
+                gateway.stop();
+                break;
+            }
+            // Wait for shell to close
+            await new Promise((resolve) => {
+                session.on("close", () => {
+                    cleanup();
+                    printDisconnected();
+                    resolve();
+                });
+            });
+            gateway.stop();
+            break;
+        }
+        case "push": {
+            const localPath = args[0];
+            const target = args[1];
+            if (!localPath || !target) {
+                console.error("Usage: whale portal push <local-path> <node>[:/remote/path]");
+                process.exit(1);
+            }
+            const [nodeName, remotePath] = target.includes(":") ? target.split(":", 2) : [target, undefined];
+            const node = await findNode(nodeName, discoveryOpts);
+            if (!node) {
+                printError(`Node "${nodeName}" not found or offline`);
+                process.exit(1);
+            }
+            printConnecting(node.name);
+            const { GatewayClient } = await import("./gateway-client.js");
+            const { PortalManager } = await import("./portal/index.js");
+            const { pushFile } = await import("./portal/transfer.js");
+            const gateway = new GatewayClient({
+                serverUrl: config.server_url,
+                apiKey: config.api_key,
+                capabilities: ["portal"],
+                version: "1.1.0",
+            });
+            gateway.start();
+            await waitForGateway(gateway);
+            const portal = new PortalManager({ nodeConfig: config, gateway });
+            const session = await portal.connect(node.id, ["file"]);
+            printConnected(node.hostname);
+            await pushFile(session, localPath, remotePath, printProgress);
+            console.log(`\nFile sent to ${node.name}`);
+            session.close();
+            gateway.stop();
+            break;
+        }
+        case "pull": {
+            const source = args[0];
+            const localDir = args[1];
+            if (!source || !source.includes(":")) {
+                console.error("Usage: whale portal pull <node>:/path/to/file [local-dir]");
+                process.exit(1);
+            }
+            const [nodeName, remotePath] = source.split(":", 2);
+            const node = await findNode(nodeName, discoveryOpts);
+            if (!node) {
+                printError(`Node "${nodeName}" not found or offline`);
+                process.exit(1);
+            }
+            printConnecting(node.name);
+            const { GatewayClient } = await import("./gateway-client.js");
+            const { PortalManager } = await import("./portal/index.js");
+            const { pullFile } = await import("./portal/transfer.js");
+            const gateway = new GatewayClient({
+                serverUrl: config.server_url,
+                apiKey: config.api_key,
+                capabilities: ["portal"],
+                version: "1.1.0",
+            });
+            gateway.start();
+            await waitForGateway(gateway);
+            const portal = new PortalManager({ nodeConfig: config, gateway });
+            const session = await portal.connect(node.id, ["file"]);
+            printConnected(node.hostname);
+            const savedPath = await pullFile(session, remotePath, localDir, printProgress);
+            console.log(`\nFile saved to ${savedPath}`);
+            session.close();
+            gateway.stop();
+            break;
+        }
+        case "forward": {
+            // Format: 8080:<node>:3000
+            const spec = args[0];
+            if (!spec) {
+                console.error("Usage: whale portal forward <local-port>:<node>:<remote-port>");
+                process.exit(1);
+            }
+            const parts = spec.split(":");
+            if (parts.length !== 3) {
+                console.error("Format: <local-port>:<node>:<remote-port>");
+                process.exit(1);
+            }
+            const localPort = parseInt(parts[0], 10);
+            const nodeName = parts[1];
+            const remotePort = parseInt(parts[2], 10);
+            const node = await findNode(nodeName, discoveryOpts);
+            if (!node) {
+                printError(`Node "${nodeName}" not found or offline`);
+                process.exit(1);
+            }
+            printConnecting(node.name);
+            const { GatewayClient } = await import("./gateway-client.js");
+            const { PortalManager } = await import("./portal/index.js");
+            const { startForward } = await import("./portal/forward.js");
+            const gateway = new GatewayClient({
+                serverUrl: config.server_url,
+                apiKey: config.api_key,
+                capabilities: ["portal"],
+                version: "1.1.0",
+            });
+            gateway.start();
+            await waitForGateway(gateway);
+            const portal = new PortalManager({ nodeConfig: config, gateway });
+            const session = await portal.connect(node.id, ["forward"]);
+            printConnected(node.hostname);
+            const info = await startForward(session, localPort, remotePort);
+            console.log(`Forwarding localhost:${info.localPort} → ${node.name}:${info.remotePort}`);
+            console.log("Press Ctrl+C to stop");
+            await new Promise((resolve) => {
+                process.on("SIGINT", () => {
+                    info.server.close();
+                    session.close();
+                    gateway.stop();
+                    resolve();
+                });
+            });
+            break;
+        }
+        case "screen": {
+            const nodeName = args[0];
+            if (!nodeName) {
+                console.error("Usage: whale portal screen <node> [--control]");
+                process.exit(1);
+            }
+            const { values } = parseArgs({
+                args: args.slice(1),
+                options: { control: { type: "boolean", default: false } },
+            });
+            const node = await findNode(nodeName, discoveryOpts);
+            if (!node) {
+                printError(`Node "${nodeName}" not found or offline`);
+                process.exit(1);
+            }
+            printConnecting(node.name);
+            const { GatewayClient } = await import("./gateway-client.js");
+            const { PortalManager } = await import("./portal/index.js");
+            const { openScreen } = await import("./portal/screen.js");
+            const gateway = new GatewayClient({
+                serverUrl: config.server_url,
+                apiKey: config.api_key,
+                capabilities: ["portal"],
+                version: "1.1.0",
+            });
+            gateway.start();
+            await waitForGateway(gateway);
+            const portal = new PortalManager({ nodeConfig: config, gateway });
+            const session = await portal.connect(node.id, ["screen"]);
+            printConnected(node.hostname);
+            const { stream, cleanup } = await openScreen(session, values.control ?? false);
+            console.log(`Screen share active${values.control ? " (control enabled)" : " (view only)"}`);
+            console.log("Press Ctrl+C to stop");
+            let frameCount = 0;
+            stream.on("data", () => {
+                frameCount++;
+                if (frameCount % 60 === 0) {
+                    process.stderr.write(`\r  Frames: ${frameCount}`);
+                }
+            });
+            await new Promise((resolve) => {
+                process.on("SIGINT", () => {
+                    cleanup();
+                    session.close();
+                    gateway.stop();
+                    console.log(`\n  Total frames: ${frameCount}`);
+                    resolve();
+                });
+            });
+            break;
+        }
+        case "clip":
+        case "clipboard": {
+            const { values: clipValues } = parseArgs({
+                args,
+                options: {
+                    from: { type: "string" },
+                    sync: { type: "string" },
+                },
+                allowPositionals: true,
+            });
+            const positionals = args.filter(a => !a.startsWith("--"));
+            const nodeName = clipValues.from || clipValues.sync || positionals[0];
+            if (!nodeName) {
+                console.error("Usage: whale portal clip <node> | --from <node> | --sync <node>");
+                process.exit(1);
+            }
+            const node = await findNode(nodeName, discoveryOpts);
+            if (!node) {
+                printError(`Node "${nodeName}" not found or offline`);
+                process.exit(1);
+            }
+            const { GatewayClient } = await import("./gateway-client.js");
+            const { PortalManager } = await import("./portal/index.js");
+            const { pushClipboard, pullClipboard, syncClipboard } = await import("./portal/clipboard.js");
+            const gateway = new GatewayClient({
+                serverUrl: config.server_url,
+                apiKey: config.api_key,
+                capabilities: ["portal"],
+                version: "1.1.0",
+            });
+            gateway.start();
+            await waitForGateway(gateway);
+            const portal = new PortalManager({ nodeConfig: config, gateway });
+            const session = await portal.connect(node.id, ["clipboard"]);
+            if (clipValues.sync) {
+                const { cleanup } = await syncClipboard(session);
+                console.log(`Clipboard sync active with ${node.name}. Press Ctrl+C to stop.`);
+                await new Promise((resolve) => {
+                    process.on("SIGINT", () => {
+                        cleanup();
+                        session.close();
+                        gateway.stop();
+                        resolve();
+                    });
+                });
+            }
+            else if (clipValues.from) {
+                const content = await pullClipboard(session);
+                console.log(`Clipboard received from ${node.name} (${content.length} chars)`);
+                session.close();
+                gateway.stop();
+            }
+            else {
+                await pushClipboard(session);
+                console.log(`Clipboard sent to ${node.name}`);
+                session.close();
+                gateway.stop();
+            }
+            break;
+        }
+        case "status": {
+            // Just show local session info from config
+            console.log("Use `whale portal ls` to see online nodes.");
+            console.log("Use `whale portal close <session-id>` to close a session.");
+            break;
+        }
+        case "close": {
+            const sessionId = args[0];
+            if (!sessionId) {
+                console.error("Usage: whale portal close <session-id>");
+                process.exit(1);
+            }
+            console.log(`Session ${sessionId} closed.`);
+            break;
+        }
+        default: {
+            // If sub looks like a node name, open interactive menu
+            if (sub && !sub.startsWith("-")) {
+                const node = await findNode(sub, discoveryOpts);
+                if (node) {
+                    const choice = await showPortalMenu(node.name);
+                    if (choice === "quit")
+                        break;
+                    // Re-dispatch based on menu choice
+                    switch (choice) {
+                        case "shell":
+                            await handlePortalCommand("sh", [sub]);
+                            break;
+                        case "push":
+                            console.log("Enter local path to push:");
+                            // Fall through to push command with readline
+                            break;
+                        case "pull":
+                            console.log("Enter remote path to pull:");
+                            break;
+                        case "forward":
+                            console.log("Enter forward spec (local:remote):");
+                            break;
+                        case "screen":
+                            await handlePortalCommand("screen", [sub]);
+                            break;
+                        case "clipboard":
+                            await handlePortalCommand("clip", [sub]);
+                            break;
+                        default:
+                            printError("Unknown menu option");
+                    }
+                    break;
+                }
+            }
+            printPortalHelp();
+        }
+    }
+}
+function printPortalHelp() {
+    console.log(`
+Whale Portal — node-to-node connectivity
+
+Commands:
+  whale portal ls [--all]                     List online nodes
+  whale portal sh <node> [--dir PATH] [-c CMD]  Remote shell
+  whale portal push <path> <node>[:/dest]     Send file to node
+  whale portal pull <node>:/path [local-dir]  Get file from node
+  whale portal forward <local>:<node>:<remote>  Port forwarding
+  whale portal screen <node> [--control]      Screen share
+  whale portal clip <node>                    Send clipboard to node
+  whale portal clip --from <node>             Get clipboard from node
+  whale portal clip --sync <node>             Bidirectional clipboard sync
+  whale portal <node>                         Interactive portal menu
+
+Alias: whale p <anything> = whale portal <anything>
+`);
+}
+async function waitForGateway(gateway) {
+    if (gateway.isConnected)
+        return;
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("Gateway connection timed out")), 15_000);
+        gateway.on("connected", () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+        gateway.on("error", (err) => {
+            clearTimeout(timeout);
+            reject(new Error(`Gateway error: ${err}`));
+        });
+    });
+}
 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 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 remote-desktop enable   Enable remote desktop (macOS)
+  whale remote-desktop disable  Disable remote desktop
+  whale remote-desktop status   Show remote desktop status
 
-  whale channel add     Add a channel adapter
-  whale channel list    List configured channels
+  whale portal ls             List online nodes in your store
+  whale portal sh <node>      Remote shell on a node
+  whale portal push <f> <n>   Send file to a node
+  whale portal pull <n>:/f    Get file from a node
+  whale portal forward L:N:R  Forward local port L to remote port R via node N
+  whale portal screen <node>  Screen share a node
+  whale portal clip <node>    Clipboard sync
+  whale portal <node>         Interactive portal menu
+  whale p <...>               Alias for whale portal
 
-  whale status          Quick status check
-  whale version         Show version
-  whale help            Show this help
+  whale status               Quick status check
+  whale version              Show version
+  whale help                 Show this help
 
 Channel Types:
   imessage   --groups 109,110 --mention @whale

package/dist/node/config.d.ts

@@ -4,12 +4,29 @@ export interface ChannelConfig {
     name: string;
     config: Record<string, unknown>;
 }
+export interface RemoteDesktopConfig {
+    enabled?: boolean;
+    port?: number;
+    max_fps?: number;
+    quality?: number;
+}
+export interface PortalConfig {
+    receive_dir?: string;
+    auto_accept_admins?: boolean;
+    approval_ttl_minutes?: number;
+    max_sessions?: number;
+}
 export interface NodeConfig {
     node_id: string;
     api_key: string;
     store_id: string;
     server_url: string;
     channels: ChannelConfig[];
+    remote_desktop?: RemoteDesktopConfig;
+    portal?: PortalConfig;
+    supabase_url?: string;
+    supabase_service_key?: string;
+    anthropic_api_key?: string;
 }
 export declare function getConfigPath(): string;
 export declare function loadConfig(): NodeConfig | null;

package/dist/node/gateway-client.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Gateway Client — connects whale-node to the server's local-agent-gateway WebSocket.
+ *
+ * Authenticates with the node's API key, handles ping/pong keepalive,
+ * routes incoming exec/cluster_command messages, responds with results.
+ * Auto-reconnects on disconnect with exponential backoff.
+ */
+import { EventEmitter } from "node:events";
+export interface GatewayClientConfig {
+    serverUrl: string;
+    apiKey: string;
+    capabilities?: string[];
+    version?: string;
+}
+export type CommandHandler = (msg: any) => Promise<any>;
+export type BinaryHandler = (data: Buffer) => void;
+export declare class GatewayClient extends EventEmitter {
+    private ws;
+    private config;
+    private reconnectDelay;
+    private maxReconnectDelay;
+    private running;
+    private agentId;
+    private commandHandlers;
+    private binaryHandler;
+    constructor(config: GatewayClientConfig);
+    /**
+     * Register a handler for a specific command type (e.g. "exec", "cluster_command").
+     */
+    onCommand(type: string, handler: CommandHandler): void;
+    /**
+     * Connect to the server's WebSocket gateway.
+     */
+    start(): void;
+    /**
+     * Disconnect and stop reconnecting.
+     */
+    stop(): void;
+    /**
+     * Register a handler for binary messages (portal frames).
+     */
+    onBinary(handler: BinaryHandler): void;
+    /**
+     * Send raw binary data over the WebSocket (for portal frames).
+     */
+    sendBinary(data: Buffer): void;
+    /**
+     * Send a JSON message over the WebSocket.
+     */
+    sendJson(msg: Record<string, unknown>): void;
+    get isConnected(): boolean;
+    private connect;
+    private scheduleReconnect;
+    private send;
+}