@wingman-ai/gateway 0.1.0

package/dist/cli/commands/gateway.cjs

@@ -0,0 +1,601 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    executeGatewayCommand: ()=>executeGatewayCommand
+});
+const index_cjs_namespaceObject = require("../../gateway/index.cjs");
+const external_fs_namespaceObject = require("fs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const loader_cjs_namespaceObject = require("../config/loader.cjs");
+const env_cjs_namespaceObject = require("../../gateway/env.cjs");
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+const logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+function reportGatewayError(context, error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    logger.error(context, errorMsg);
+    console.error(`✗ ${context}: ${errorMsg}`);
+    console.error(`Logs: ${logFile}`);
+}
+async function executeGatewayCommand(args) {
+    const { subcommand, options } = args;
+    switch(subcommand){
+        case "start":
+            await handleStart(options);
+            break;
+        case "stop":
+            await handleStop();
+            break;
+        case "restart":
+            await handleRestart();
+            break;
+        case "status":
+            await handleStatus();
+            break;
+        case "run":
+            await handleRun(options);
+            break;
+        case "join":
+            await handleJoin(args.args, options);
+            break;
+        case "discover":
+            await handleDiscover(options);
+            break;
+        case "token":
+            await handleToken(options);
+            break;
+        case "health":
+            await handleHealth(options);
+            break;
+        case "tunnel":
+            await handleTunnel(args.args, options);
+            break;
+        default:
+            showGatewayHelp();
+            process.exit(1);
+    }
+}
+async function handleStart(options) {
+    const configLoader = new loader_cjs_namespaceObject.WingmanConfigLoader();
+    const wingmanConfig = configLoader.loadConfig();
+    const gatewayDefaults = wingmanConfig.gateway;
+    const envToken = (0, env_cjs_namespaceObject.getGatewayTokenFromEnv)();
+    const authFlag = Boolean(options.auth);
+    const authMode = options["auth-mode"] || options.authMode || (authFlag ? "token" : void 0);
+    const resolvedToken = "token" === authMode ? options.token || envToken : void 0;
+    const auth = authMode ? {
+        mode: authMode,
+        token: resolvedToken,
+        password: options.password
+    } : gatewayDefaults.auth;
+    const config = {
+        port: options.port || gatewayDefaults.port || 18789,
+        host: options.host || gatewayDefaults.host || "127.0.0.1",
+        requireAuth: auth?.mode !== "none",
+        authToken: auth?.token,
+        auth,
+        maxNodes: options.maxNodes || 1000,
+        pingInterval: options.pingInterval || 30000,
+        pingTimeout: options.pingTimeout || 60000,
+        logLevel: options.logLevel || "info"
+    };
+    if (options.discovery) config.discovery = {
+        enabled: true,
+        method: options.discovery,
+        name: options.name || `Gateway-${Date.now()}`
+    };
+    const daemon = new index_cjs_namespaceObject.GatewayDaemon();
+    try {
+        await daemon.start(config);
+        console.log("✓ Gateway started successfully");
+        console.log(`  URL: ws://${config.host}:${config.port}/ws`);
+        console.log(`  Health: http://${config.host}:${config.port}/health`);
+        const controlUi = wingmanConfig.gateway?.controlUi;
+        if (controlUi?.enabled) {
+            const uiPort = controlUi.port || 18790;
+            console.log(`  Control UI: http://${config.host}:${uiPort}/`);
+        }
+        console.log(`  Logs: ${daemon.getLogFile()}`);
+        if (config.auth?.mode === "token" && !config.auth.token) {
+            console.log("\n⚠ Token auth is enabled but no token was provided.");
+            console.log('  Run "wingman gateway token --generate" to create a token.');
+        }
+    } catch (error) {
+        reportGatewayError("Failed to start gateway", error);
+        process.exit(1);
+    }
+}
+async function handleStop() {
+    const daemon = new index_cjs_namespaceObject.GatewayDaemon();
+    try {
+        await daemon.stop();
+        console.log("✓ Gateway stopped successfully");
+    } catch (error) {
+        reportGatewayError("Failed to stop gateway", error);
+        process.exit(1);
+    }
+}
+async function handleRestart() {
+    const daemon = new index_cjs_namespaceObject.GatewayDaemon();
+    try {
+        await daemon.restart();
+        console.log("✓ Gateway restarted successfully");
+    } catch (error) {
+        reportGatewayError("Failed to restart gateway", error);
+        process.exit(1);
+    }
+}
+async function handleStatus() {
+    const daemon = new index_cjs_namespaceObject.GatewayDaemon();
+    const status = daemon.getStatus();
+    if (!status.running) return void console.log("Gateway Status: Not Running");
+    console.log("Gateway Status: Running");
+    console.log(`  PID: ${status.pid}`);
+    if (status.uptime) {
+        const uptimeSeconds = Math.floor(status.uptime / 1000);
+        const hours = Math.floor(uptimeSeconds / 3600);
+        const minutes = Math.floor(uptimeSeconds % 3600 / 60);
+        const seconds = uptimeSeconds % 60;
+        console.log(`  Uptime: ${hours}h ${minutes}m ${seconds}s`);
+    }
+    if (status.config) {
+        console.log(`  Host: ${status.config.host}`);
+        console.log(`  Port: ${status.config.port}`);
+        const authMode = status.config.auth?.mode || "none";
+        console.log(`  Auth Mode: ${authMode}`);
+        console.log(`  Max Nodes: ${status.config.maxNodes}`);
+    }
+    console.log(`  Log File: ${daemon.getLogFile()}`);
+}
+async function handleRun(options) {
+    let config;
+    if (options.daemon && process.env.WINGMAN_GATEWAY_CONFIG) {
+        const configStr = (0, external_fs_namespaceObject.readFileSync)(process.env.WINGMAN_GATEWAY_CONFIG, "utf-8");
+        config = JSON.parse(configStr);
+    } else {
+        const configLoader = new loader_cjs_namespaceObject.WingmanConfigLoader();
+        const wingmanConfig = configLoader.loadConfig();
+        const gatewayDefaults = wingmanConfig.gateway;
+        const envToken = (0, env_cjs_namespaceObject.getGatewayTokenFromEnv)();
+        const authFlag = Boolean(options.auth);
+        const authMode = options["auth-mode"] || options.authMode || (authFlag ? "token" : void 0);
+        const resolvedToken = "token" === authMode ? options.token || envToken : void 0;
+        const auth = authMode ? {
+            mode: authMode,
+            token: resolvedToken,
+            password: options.password
+        } : gatewayDefaults.auth;
+        config = {
+            port: options.port || gatewayDefaults.port || 18789,
+            host: options.host || gatewayDefaults.host || "127.0.0.1",
+            requireAuth: auth?.mode !== "none",
+            authToken: auth?.token,
+            auth,
+            maxNodes: options.maxNodes || 1000,
+            pingInterval: options.pingInterval || 30000,
+            pingTimeout: options.pingTimeout || 60000,
+            logLevel: options.logLevel || "info"
+        };
+    }
+    const server = new index_cjs_namespaceObject.GatewayServer(config);
+    process.on("SIGTERM", async ()=>{
+        console.log("Received SIGTERM, shutting down gracefully...");
+        await server.stop();
+        process.exit(0);
+    });
+    process.on("SIGINT", async ()=>{
+        console.log("Received SIGINT, shutting down gracefully...");
+        await server.stop();
+        process.exit(0);
+    });
+    try {
+        await server.start();
+        console.log("✓ Gateway running");
+        console.log(`  URL: ws://${config.host}:${config.port}/ws`);
+        console.log(`  Health: http://${config.host}:${config.port}/health`);
+        console.log(`  Logs: ${(0, external_logger_cjs_namespaceObject.getLogFilePath)()}`);
+        if (config.auth?.mode === "token" && config.auth.token) console.log(`  Auth Token: ${config.auth.token}`);
+        await new Promise(()=>{});
+    } catch (error) {
+        reportGatewayError("Failed to start gateway", error);
+        process.exit(1);
+    }
+}
+async function handleJoin(args, options) {
+    const url = args[0] || "ws://localhost:18789/ws";
+    const name = options.name || `node-${Date.now()}`;
+    const token = options.token || (0, env_cjs_namespaceObject.getGatewayTokenFromEnv)();
+    const group = options.group;
+    const transport = options.transport || "auto";
+    console.log(`Connecting to gateway: ${url}`);
+    console.log(`Node name: ${name}`);
+    if ("auto" !== transport) console.log(`Transport: ${transport}`);
+    const client = new index_cjs_namespaceObject.GatewayClient(url, name, {
+        token,
+        transport,
+        events: {
+            connected: ()=>{
+                console.log("✓ Connected to gateway");
+            },
+            registered: (nodeId, nodeName)=>{
+                console.log(`✓ Registered as ${nodeName} (${nodeId})`);
+                if (group) client.joinGroup(group);
+            },
+            joinedGroup: (groupId, groupName)=>{
+                console.log(`✓ Joined group: ${groupName} (${groupId})`);
+                console.log("\nReady to receive messages. Press Ctrl+C to exit.");
+            },
+            broadcast: (message, fromNodeId, groupId)=>{
+                console.log(`\n[Broadcast from ${fromNodeId}]:`);
+                console.log(JSON.stringify(message, null, 2));
+            },
+            direct: (message, fromNodeId)=>{
+                console.log(`\n[Direct from ${fromNodeId}]:`);
+                console.log(JSON.stringify(message, null, 2));
+            },
+            error: (error)=>{
+                logger.error("Gateway error event", error.message);
+                console.error(`\n✗ Error: ${error.message}`);
+                console.error(`Logs: ${logFile}`);
+            },
+            disconnected: ()=>{
+                console.log("\n✗ Disconnected from gateway");
+            }
+        }
+    });
+    try {
+        await client.connect();
+        process.on("SIGINT", ()=>{
+            console.log("\nDisconnecting...");
+            client.disconnect();
+            process.exit(0);
+        });
+        await new Promise(()=>{});
+    } catch (error) {
+        reportGatewayError("Failed to connect", error);
+        process.exit(1);
+    }
+}
+async function handleDiscover(options) {
+    const timeout = options.timeout || 5000;
+    const verbose = options.verbose;
+    const tailscale = options.tailscale;
+    if (tailscale) {
+        console.log("Discovering gateways on Tailscale network...");
+        const { TailscaleDiscoveryService } = await import("../../gateway/discovery/tailscale.cjs");
+        const ts = new TailscaleDiscoveryService();
+        try {
+            const gateways = await ts.discover(timeout);
+            if (0 === gateways.length) {
+                console.log("\nNo gateways found on Tailscale network");
+                console.log("\nTo start a Tailscale-discoverable gateway:");
+                console.log('  wingman gateway start --discovery tailscale --name "My Gateway"');
+                console.log('\nNote: Ensure your gateway has the "wingman-gateway" tag in Tailscale');
+                return;
+            }
+            console.log(`\n✓ Found ${gateways.length} gateway(s):\n`);
+            for (const gw of gateways){
+                console.log(`  ${gw.name}`);
+                console.log(`    URL: ${gw.url}`);
+                console.log(`    Auth: ${gw.requireAuth ? "Required" : "Optional"}`);
+                if (verbose) {
+                    console.log(`    Host: ${gw.host}`);
+                    console.log(`    Port: ${gw.port}`);
+                    console.log(`    Transport: ${gw.transport}`);
+                    console.log(`    Capabilities: ${gw.capabilities.join(", ")}`);
+                    console.log(`    Version: ${gw.version}`);
+                }
+                console.log();
+            }
+            console.log("To connect to a gateway:");
+            console.log('  wingman gateway join <url> --name "my-node"');
+        } catch (error) {
+            reportGatewayError("Discovery failed", error);
+            process.exit(1);
+        }
+        return;
+    }
+    console.log(`Discovering gateways on local network (${timeout}ms timeout)...`);
+    const { MDNSDiscoveryService } = await import("../../gateway/discovery/mdns.cjs");
+    const mdns = new MDNSDiscoveryService();
+    try {
+        const gateways = await mdns.discover(timeout);
+        if (0 === gateways.length) {
+            console.log("\nNo gateways found on local network");
+            console.log("\nTo start a discoverable gateway:");
+            console.log('  wingman gateway start --discovery mdns --name "My Gateway"');
+            return;
+        }
+        console.log(`\n✓ Found ${gateways.length} gateway(s):\n`);
+        for (const gw of gateways){
+            console.log(`  ${gw.name}`);
+            console.log(`    URL: ${gw.url}`);
+            console.log(`    Auth: ${gw.requireAuth ? "Required" : "Optional"}`);
+            if (verbose) {
+                console.log(`    Host: ${gw.host}`);
+                console.log(`    Port: ${gw.port}`);
+                console.log(`    Transport: ${gw.transport}`);
+                console.log(`    Capabilities: ${gw.capabilities.join(", ")}`);
+                console.log(`    Version: ${gw.version}`);
+            }
+            console.log();
+        }
+        console.log("To connect to a gateway:");
+        console.log('  wingman gateway join <url> --name "my-node"');
+    } catch (error) {
+        reportGatewayError("Discovery failed", error);
+        process.exit(1);
+    }
+}
+async function handleToken(options) {
+    if (options.generate) {
+        const { GatewayAuth } = await import("../../gateway/auth.cjs");
+        const auth = new GatewayAuth();
+        const token = auth.generateToken();
+        console.log("Generated token:");
+        console.log(token);
+        console.log('\nUse this token with: wingman gateway start --auth --token="<token>"');
+    } else console.log("Usage: wingman gateway token --generate");
+}
+async function handleHealth(options) {
+    const host = options.host || "localhost";
+    const port = options.port || 18789;
+    const url = `http://${host}:${port}/health`;
+    try {
+        const response = await fetch(url);
+        if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        const health = await response.json();
+        console.log("Gateway Health:");
+        console.log(JSON.stringify(health, null, 2));
+    } catch (error) {
+        reportGatewayError("Failed to check health", error);
+        process.exit(1);
+    }
+}
+async function handleTunnel(args, options) {
+    const sshHost = args[0];
+    if (!sshHost) {
+        logger.error("SSH host required");
+        console.error("✗ SSH host required");
+        console.error(`Logs: ${logFile}`);
+        console.log("\nUsage:");
+        console.log("  wingman gateway tunnel user@host [options]");
+        console.log("\nOptions:");
+        console.log("  --port <number>       Gateway port on remote host (default: 3000)");
+        console.log("  --local-port <number> Local port for tunnel (default: random)");
+        console.log("  --name <string>       Node name after connecting");
+        console.log("  --group <string>      Auto-join broadcast group");
+        process.exit(1);
+    }
+    const remotePort = options.port || 18789;
+    const localPort = options.localPort || 0;
+    const name = options.name || `tunnel-node-${Date.now()}`;
+    const group = options.group;
+    const actualLocalPort = localPort || await findAvailablePort();
+    console.log("Creating SSH tunnel to gateway...");
+    console.log(`  SSH Host: ${sshHost}`);
+    console.log(`  Remote Port: ${remotePort}`);
+    console.log(`  Local Port: ${actualLocalPort}`);
+    console.log();
+    const { spawn } = await import("child_process");
+    const sshArgs = [
+        "-L",
+        `${actualLocalPort}:localhost:${remotePort}`,
+        "-N",
+        "-o",
+        "ExitOnForwardFailure=yes",
+        sshHost
+    ];
+    const sshProcess = spawn("ssh", sshArgs, {
+        stdio: "inherit"
+    });
+    await new Promise((resolve)=>setTimeout(resolve, 2000));
+    if (null !== sshProcess.exitCode) {
+        logger.error("Failed to create SSH tunnel");
+        console.error("✗ Failed to create SSH tunnel");
+        console.error(`Logs: ${logFile}`);
+        process.exit(1);
+    }
+    console.log("✓ SSH tunnel established");
+    console.log();
+    console.log("Connecting to gateway through tunnel...");
+    const { GatewayClient } = await import("../../gateway/client.cjs");
+    const client = new GatewayClient(`ws://localhost:${actualLocalPort}/ws`, name, {
+        events: {
+            connected: ()=>{
+                console.log("✓ Connected to gateway");
+            },
+            registered: (nodeId, nodeName)=>{
+                console.log(`✓ Registered as ${nodeName} (${nodeId})`);
+                if (group) client.joinGroup(group);
+            },
+            joinedGroup: (groupId, groupName)=>{
+                console.log(`✓ Joined group: ${groupName} (${groupId})`);
+                console.log("\nReady to receive messages. Press Ctrl+C to exit.");
+            },
+            broadcast: (message, fromNodeId, groupId)=>{
+                console.log(`\n[Broadcast from ${fromNodeId}]:`);
+                console.log(JSON.stringify(message, null, 2));
+            },
+            direct: (message, fromNodeId)=>{
+                console.log(`\n[Direct from ${fromNodeId}]:`);
+                console.log(JSON.stringify(message, null, 2));
+            },
+            error: (error)=>{
+                logger.error("Gateway error event", error.message);
+                console.error(`\n✗ Error: ${error.message}`);
+                console.error(`Logs: ${logFile}`);
+            },
+            disconnected: ()=>{
+                console.log("\n✗ Disconnected from gateway");
+            }
+        }
+    });
+    try {
+        await client.connect();
+        process.on("SIGINT", ()=>{
+            console.log("\nClosing tunnel and disconnecting...");
+            client.disconnect();
+            sshProcess.kill();
+            process.exit(0);
+        });
+        sshProcess.on("exit", (code)=>{
+            console.log(`\n✗ SSH tunnel closed (exit code: ${code})`);
+            client.disconnect();
+            process.exit(code || 0);
+        });
+        await new Promise(()=>{});
+    } catch (error) {
+        reportGatewayError("Failed to connect", error);
+        sshProcess.kill();
+        process.exit(1);
+    }
+}
+async function findAvailablePort() {
+    const net = await import("net");
+    return new Promise((resolve, reject)=>{
+        const server = net.createServer();
+        server.listen(0, ()=>{
+            const address = server.address();
+            const port = address.port;
+            server.close(()=>{
+                resolve(port);
+            });
+        });
+        server.on("error", reject);
+    });
+}
+function showGatewayHelp() {
+    console.log(`
+Wingman Gateway - AI Agent Swarming Gateway
+
+Usage:
+  wingman gateway <subcommand> [options]
+
+Subcommands:
+  start                Start the gateway as a daemon
+  stop                 Stop the gateway daemon
+  restart              Restart the gateway daemon
+  status               Show gateway status
+  run                  Run the gateway in foreground
+  join <url>           Join a gateway as a node
+  discover             Discover gateways on local network
+  tunnel <ssh-host>    Create SSH tunnel and connect to gateway
+  token                Generate authentication token
+  health               Check gateway health
+
+Start Options:
+  --port <number>      Port to listen on (default: 18789)
+  --host <string>      Host to bind to (default: 127.0.0.1)
+  --auth               Enable token authentication (legacy shortcut)
+  --auth-mode <mode>   token | password | none
+  --token <string>     Authentication token (token mode)
+  --password <string>  Authentication password (password mode)
+  --max-nodes <number> Maximum number of nodes (default: 1000)
+  --log-level <level>  Log level (debug|info|warn|error|silent)
+  --discovery <method> Discovery method: mdns, tailscale
+  --name <string>      Gateway name for discovery
+
+Join Options:
+  --name <string>      Node name
+  --token <string>     Authentication token
+  --group <string>     Auto-join broadcast group
+  --transport <type>   Transport type: websocket, http, auto (default: auto)
+
+Discover Options:
+  --timeout <ms>       Discovery timeout (default: 5000)
+  --verbose            Show detailed gateway info
+  --tailscale          Discover on Tailscale network instead of LAN
+
+Tunnel Options:
+  --port <number>      Gateway port on remote host (default: 18789)
+  --local-port <number> Local port for tunnel (default: random)
+  --name <string>      Node name after connecting
+  --group <string>     Auto-join broadcast group
+
+Token Options:
+  --generate           Generate a new token
+
+Health Options:
+  --host <string>      Gateway host (default: localhost)
+  --port <number>      Gateway port (default: 18789)
+
+Examples:
+  # Start gateway locally
+  wingman gateway start
+
+  # Start with mDNS discovery (LAN)
+  wingman gateway start --discovery mdns --name "Home Gateway"
+
+  # Start with Tailscale discovery
+  wingman gateway start --discovery tailscale --name "Work Gateway"
+
+  # Start with authentication
+  wingman gateway token --generate
+  wingman gateway start --auth --token="<token>"
+
+  # Start on custom port
+  wingman gateway start --port 8080
+
+  # Discover gateways on local network
+  wingman gateway discover
+  wingman gateway discover --verbose
+
+  # Discover gateways on Tailscale
+  wingman gateway discover --tailscale
+  wingman gateway discover --tailscale --verbose
+
+  # Join a gateway
+  wingman gateway join ws://localhost:18789/ws --name="agent-1" --group="swarm"
+
+  # Join via HTTP bridge (firewall traversal)
+  wingman gateway join http://localhost:18789 --transport http --name="agent-1"
+
+  # Auto-select transport
+  wingman gateway join http://localhost:18789 --transport auto --name="agent-1"
+
+  # Connect via SSH tunnel
+  wingman gateway tunnel user@remote-host --name="tunnel-node"
+  wingman gateway tunnel user@remote-host --port 18789 --group="swarm"
+
+  # Check status
+  wingman gateway status
+
+  # Check health
+  wingman gateway health
+
+Deployment:
+  Local:      Run on localhost or LAN
+  Tailscale:  Accessible over Tailscale network
+  Cloudflare: Deploy to Cloudflare Workers (see cloudflare/README.md)
+  `);
+}
+exports.executeGatewayCommand = __webpack_exports__.executeGatewayCommand;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "executeGatewayCommand"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/commands/gateway.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Gateway command arguments
+ */
+export interface GatewayCommandArgs {
+    subcommand: string;
+    args: string[];
+    options: Record<string, unknown>;
+}
+/**
+ * Execute gateway command
+ */
+export declare function executeGatewayCommand(args: GatewayCommandArgs): Promise<void>;