@wingman-ai/gateway 0.1.0

package/dist/gateway/client.js

@@ -0,0 +1,248 @@
+import { HTTPBridgeTransport, WebSocketTransport } from "./transport/index.js";
+import { createLogger } from "../logger.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class GatewayClient {
+    async connect() {
+        const transportType = this.selectTransport();
+        this.transport = this.createTransport(transportType);
+        this.transport.onMessage((message)=>{
+            this.handleMessage(message);
+        });
+        try {
+            await this.transport.connect();
+            this.reconnectAttempts = 0;
+            this.events.connected?.();
+            this.register();
+        } catch (error) {
+            this.logger.error("Transport connection failed", error);
+            throw error;
+        }
+    }
+    selectTransport() {
+        if ("auto" === this.transportType) {
+            if (this.url.startsWith("ws://") || this.url.startsWith("wss://")) return "websocket";
+            return "http";
+        }
+        return this.transportType;
+    }
+    createTransport(type) {
+        const transportOptions = {
+            token: this.token,
+            autoReconnect: true,
+            maxReconnectAttempts: this.maxReconnectAttempts,
+            reconnectDelay: this.reconnectDelay
+        };
+        if ("http" === type) return new HTTPBridgeTransport(this.url, transportOptions);
+        return new WebSocketTransport(this.url, transportOptions);
+    }
+    disconnect() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        if (this.transport) {
+            this.transport.disconnect();
+            this.transport = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.nodeId = null;
+    }
+    register() {
+        const payload = {
+            name: this.nodeName,
+            capabilities: this.capabilities,
+            token: this.token
+        };
+        this.send({
+            type: "register",
+            payload,
+            timestamp: Date.now()
+        });
+    }
+    async joinGroup(groupName, options = {}) {
+        const payload = {
+            groupName,
+            createIfNotExists: options.createIfNotExists ?? true,
+            description: options.description
+        };
+        this.send({
+            type: "join_group",
+            nodeId: this.nodeId || void 0,
+            payload,
+            timestamp: Date.now()
+        });
+    }
+    async leaveGroup(groupId) {
+        this.send({
+            type: "leave_group",
+            nodeId: this.nodeId || void 0,
+            groupId,
+            timestamp: Date.now()
+        });
+    }
+    broadcast(groupId, message) {
+        const payload = {
+            groupId,
+            message
+        };
+        this.send({
+            type: "broadcast",
+            nodeId: this.nodeId || void 0,
+            payload,
+            timestamp: Date.now()
+        });
+    }
+    sendDirect(targetNodeId, message) {
+        const payload = {
+            targetNodeId,
+            message
+        };
+        this.send({
+            type: "direct",
+            nodeId: this.nodeId || void 0,
+            payload,
+            timestamp: Date.now()
+        });
+    }
+    ping() {
+        this.send({
+            type: "ping",
+            nodeId: this.nodeId || void 0,
+            timestamp: Date.now()
+        });
+    }
+    handleMessage(msg) {
+        try {
+            switch(msg.type){
+                case "registered":
+                    if ("nodeId" in msg && msg.nodeId) {
+                        this.nodeId = msg.nodeId;
+                        this.events.registered?.(msg.nodeId, this.nodeName);
+                        this.startPingInterval();
+                    }
+                    break;
+                case "ack":
+                    this.handleAck(msg);
+                    break;
+                case "broadcast":
+                    this.handleBroadcast(msg);
+                    break;
+                case "direct":
+                    this.handleDirect(msg);
+                    break;
+                case "ping":
+                    this.handlePing(msg);
+                    break;
+                case "pong":
+                    this.handlePong(msg);
+                    break;
+                case "error":
+                    this.handleError(msg);
+                    break;
+            }
+        } catch (error) {
+            this.logger.error("Failed to handle message", error);
+        }
+    }
+    handleAck(msg) {
+        const payload = msg.payload;
+        if (payload.nodeId && !this.nodeId) {
+            this.nodeId = payload.nodeId;
+            this.events.registered?.(payload.nodeId, payload.name);
+            this.startPingInterval();
+        }
+        if (payload.groupId && payload.groupName) this.events.joinedGroup?.(payload.groupId, payload.groupName);
+        if (msg.groupId && !payload.groupName) this.events.leftGroup?.(msg.groupId);
+    }
+    handleBroadcast(msg) {
+        if (msg.nodeId && msg.groupId) this.events.broadcast?.(msg.payload, msg.nodeId, msg.groupId);
+    }
+    handleDirect(msg) {
+        if (msg.nodeId) this.events.direct?.(msg.payload, msg.nodeId);
+    }
+    handlePing(msg) {
+        this.send({
+            type: "pong",
+            nodeId: this.nodeId || void 0,
+            timestamp: Date.now()
+        });
+        this.events.ping?.();
+    }
+    handlePong(msg) {
+        this.events.pong?.();
+    }
+    handleError(msg) {
+        const error = msg.payload;
+        this.events.error?.(error);
+        this.logger.error(`Gateway error: ${error.code} - ${error.message}`);
+    }
+    handleDisconnect() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        this.events.disconnected?.();
+        if (this.reconnectAttempts < this.maxReconnectAttempts) {
+            this.reconnectAttempts++;
+            const delay = this.reconnectDelay * this.reconnectAttempts;
+            this.logger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+            setTimeout(()=>this.connect(), delay);
+        } else this.logger.error("Max reconnection attempts reached");
+    }
+    startPingInterval() {
+        if (this.pingInterval) clearInterval(this.pingInterval);
+        this.pingInterval = setInterval(()=>{
+            this.ping();
+        }, 30000);
+    }
+    send(message) {
+        if (this.transport && this.transport.isConnected()) return void this.transport.send(message);
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) return void this.ws.send(JSON.stringify(message));
+        this.logger.error("No transport is connected");
+    }
+    getNodeId() {
+        return this.nodeId;
+    }
+    getNodeName() {
+        return this.nodeName;
+    }
+    isConnected() {
+        return null !== this.ws && this.ws.readyState === WebSocket.OPEN;
+    }
+    constructor(url, name, options = {}){
+        _define_property(this, "url", void 0);
+        _define_property(this, "transport", null);
+        _define_property(this, "nodeId", null);
+        _define_property(this, "nodeName", void 0);
+        _define_property(this, "token", void 0);
+        _define_property(this, "capabilities", void 0);
+        _define_property(this, "events", void 0);
+        _define_property(this, "reconnectAttempts", 0);
+        _define_property(this, "maxReconnectAttempts", 5);
+        _define_property(this, "reconnectDelay", 1000);
+        _define_property(this, "pingInterval", null);
+        _define_property(this, "transportType", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "ws", null);
+        this.url = url;
+        this.nodeName = name;
+        this.token = options.token;
+        this.capabilities = options.capabilities;
+        this.events = options.events || {};
+        this.transportType = options.transport || "auto";
+        this.logger = createLogger();
+    }
+}
+export { GatewayClient };

package/dist/gateway/daemon.cjs

@@ -0,0 +1,195 @@
+"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__, {
+    GatewayDaemon: ()=>GatewayDaemon
+});
+const external_child_process_namespaceObject = require("child_process");
+const external_fs_namespaceObject = require("fs");
+const external_path_namespaceObject = require("path");
+const external_os_namespaceObject = require("os");
+const external_logger_cjs_namespaceObject = require("../logger.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class GatewayDaemon {
+    resolveRuntime() {
+        const isBunRuntime = void 0 !== globalThis.Bun;
+        if (isBunRuntime) return process.execPath;
+        const probe = (0, external_child_process_namespaceObject.spawnSync)("bun", [
+            "--version"
+        ], {
+            stdio: "ignore"
+        });
+        if (probe.error || 0 !== probe.status) throw new Error("Bun runtime is required to start the gateway. Install Bun from https://bun.sh and retry.");
+        return "bun";
+    }
+    async start(config) {
+        if (this.isRunning()) throw new Error("Gateway is already running");
+        this.saveConfig(config);
+        const scriptPath = process.argv[1];
+        const runtime = this.resolveRuntime();
+        const child = (0, external_child_process_namespaceObject.spawn)(runtime, [
+            scriptPath,
+            "gateway",
+            "run",
+            "--daemon"
+        ], {
+            detached: true,
+            stdio: [
+                "ignore",
+                "pipe",
+                "pipe"
+            ],
+            env: {
+                ...process.env,
+                WINGMAN_GATEWAY_CONFIG: this.configFile
+            }
+        });
+        (0, external_fs_namespaceObject.writeFileSync)(this.pidFile, child.pid.toString());
+        child.stdout?.on("data", (data)=>{
+            (0, external_logger_cjs_namespaceObject.writeToLogFile)(data);
+        });
+        child.stderr?.on("data", (data)=>{
+            (0, external_logger_cjs_namespaceObject.writeToLogFile)(data);
+        });
+        child.unref();
+        console.log(`Gateway daemon started with PID ${child.pid}`);
+        console.log(`Logs: ${this.logFile}`);
+    }
+    async stop() {
+        if (!this.isRunning()) throw new Error("Gateway is not running");
+        const pid = this.getPid();
+        if (!pid) throw new Error("Could not read PID file");
+        try {
+            process.kill(pid, "SIGTERM");
+            await new Promise((resolve)=>setTimeout(resolve, 2000));
+            if (this.isProcessRunning(pid)) process.kill(pid, "SIGKILL");
+            this.removePidFile();
+            console.log("Gateway daemon stopped");
+        } catch (error) {
+            this.removePidFile();
+            throw error;
+        }
+    }
+    async restart() {
+        const config = this.loadConfig();
+        if (!config) throw new Error("No saved configuration found");
+        if (this.isRunning()) await this.stop();
+        await this.start(config);
+    }
+    getStatus() {
+        const running = this.isRunning();
+        const pid = this.getPid();
+        const config = this.loadConfig();
+        if (!running) return {
+            running: false
+        };
+        const uptime = pid ? this.getProcessUptime(pid) : void 0;
+        return {
+            running: true,
+            pid,
+            uptime,
+            config
+        };
+    }
+    isRunning() {
+        const pid = this.getPid();
+        if (!pid) return false;
+        return this.isProcessRunning(pid);
+    }
+    getPid() {
+        if (!(0, external_fs_namespaceObject.existsSync)(this.pidFile)) return;
+        try {
+            const pidStr = (0, external_fs_namespaceObject.readFileSync)(this.pidFile, "utf-8").trim();
+            return parseInt(pidStr, 10);
+        } catch (error) {
+            return;
+        }
+    }
+    isProcessRunning(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+    getProcessUptime(pid) {
+        try {
+            const pidFileStats = (0, external_fs_namespaceObject.statSync)(this.pidFile);
+            return Date.now() - pidFileStats.mtimeMs;
+        } catch (error) {
+            return;
+        }
+    }
+    removePidFile() {
+        if ((0, external_fs_namespaceObject.existsSync)(this.pidFile)) (0, external_fs_namespaceObject.unlinkSync)(this.pidFile);
+    }
+    saveConfig(config) {
+        (0, external_fs_namespaceObject.writeFileSync)(this.configFile, JSON.stringify(config, null, 2));
+    }
+    loadConfig() {
+        if (!(0, external_fs_namespaceObject.existsSync)(this.configFile)) return;
+        try {
+            const configStr = (0, external_fs_namespaceObject.readFileSync)(this.configFile, "utf-8");
+            return JSON.parse(configStr);
+        } catch (error) {
+            return;
+        }
+    }
+    getLogFile() {
+        return this.logFile;
+    }
+    getPidFile() {
+        return this.pidFile;
+    }
+    getConfigFile() {
+        return this.configFile;
+    }
+    constructor(){
+        _define_property(this, "pidFile", void 0);
+        _define_property(this, "logFile", void 0);
+        _define_property(this, "configFile", void 0);
+        const wingmanDir = (0, external_path_namespaceObject.join)((0, external_os_namespaceObject.homedir)(), ".wingman");
+        this.pidFile = (0, external_path_namespaceObject.join)(wingmanDir, "gateway.pid");
+        this.logFile = (0, external_logger_cjs_namespaceObject.getLogFilePath)();
+        this.configFile = (0, external_path_namespaceObject.join)(wingmanDir, "gateway.json");
+    }
+}
+exports.GatewayDaemon = __webpack_exports__.GatewayDaemon;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GatewayDaemon"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/daemon.d.ts

@@ -0,0 +1,67 @@
+import type { GatewayConfig, DaemonStatus } from "./types.js";
+/**
+ * Daemon manager for running the gateway in the background
+ */
+export declare class GatewayDaemon {
+    private pidFile;
+    private logFile;
+    private configFile;
+    constructor();
+    private resolveRuntime;
+    /**
+     * Start the gateway as a daemon
+     */
+    start(config: GatewayConfig): Promise<void>;
+    /**
+     * Stop the gateway daemon
+     */
+    stop(): Promise<void>;
+    /**
+     * Restart the gateway daemon
+     */
+    restart(): Promise<void>;
+    /**
+     * Get the status of the gateway daemon
+     */
+    getStatus(): DaemonStatus;
+    /**
+     * Check if the gateway is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get the PID from the PID file
+     */
+    private getPid;
+    /**
+     * Check if a process is running
+     */
+    private isProcessRunning;
+    /**
+     * Get process uptime in milliseconds
+     */
+    private getProcessUptime;
+    /**
+     * Remove the PID file
+     */
+    private removePidFile;
+    /**
+     * Save gateway configuration
+     */
+    private saveConfig;
+    /**
+     * Load gateway configuration
+     */
+    private loadConfig;
+    /**
+     * Get the log file path
+     */
+    getLogFile(): string;
+    /**
+     * Get the PID file path
+     */
+    getPidFile(): string;
+    /**
+     * Get the config file path
+     */
+    getConfigFile(): string;
+}

package/dist/gateway/daemon.js

@@ -0,0 +1,161 @@
+import { spawn, spawnSync } from "child_process";
+import { existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { getLogFilePath, writeToLogFile } from "../logger.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class GatewayDaemon {
+    resolveRuntime() {
+        const isBunRuntime = void 0 !== globalThis.Bun;
+        if (isBunRuntime) return process.execPath;
+        const probe = spawnSync("bun", [
+            "--version"
+        ], {
+            stdio: "ignore"
+        });
+        if (probe.error || 0 !== probe.status) throw new Error("Bun runtime is required to start the gateway. Install Bun from https://bun.sh and retry.");
+        return "bun";
+    }
+    async start(config) {
+        if (this.isRunning()) throw new Error("Gateway is already running");
+        this.saveConfig(config);
+        const scriptPath = process.argv[1];
+        const runtime = this.resolveRuntime();
+        const child = spawn(runtime, [
+            scriptPath,
+            "gateway",
+            "run",
+            "--daemon"
+        ], {
+            detached: true,
+            stdio: [
+                "ignore",
+                "pipe",
+                "pipe"
+            ],
+            env: {
+                ...process.env,
+                WINGMAN_GATEWAY_CONFIG: this.configFile
+            }
+        });
+        writeFileSync(this.pidFile, child.pid.toString());
+        child.stdout?.on("data", (data)=>{
+            writeToLogFile(data);
+        });
+        child.stderr?.on("data", (data)=>{
+            writeToLogFile(data);
+        });
+        child.unref();
+        console.log(`Gateway daemon started with PID ${child.pid}`);
+        console.log(`Logs: ${this.logFile}`);
+    }
+    async stop() {
+        if (!this.isRunning()) throw new Error("Gateway is not running");
+        const pid = this.getPid();
+        if (!pid) throw new Error("Could not read PID file");
+        try {
+            process.kill(pid, "SIGTERM");
+            await new Promise((resolve)=>setTimeout(resolve, 2000));
+            if (this.isProcessRunning(pid)) process.kill(pid, "SIGKILL");
+            this.removePidFile();
+            console.log("Gateway daemon stopped");
+        } catch (error) {
+            this.removePidFile();
+            throw error;
+        }
+    }
+    async restart() {
+        const config = this.loadConfig();
+        if (!config) throw new Error("No saved configuration found");
+        if (this.isRunning()) await this.stop();
+        await this.start(config);
+    }
+    getStatus() {
+        const running = this.isRunning();
+        const pid = this.getPid();
+        const config = this.loadConfig();
+        if (!running) return {
+            running: false
+        };
+        const uptime = pid ? this.getProcessUptime(pid) : void 0;
+        return {
+            running: true,
+            pid,
+            uptime,
+            config
+        };
+    }
+    isRunning() {
+        const pid = this.getPid();
+        if (!pid) return false;
+        return this.isProcessRunning(pid);
+    }
+    getPid() {
+        if (!existsSync(this.pidFile)) return;
+        try {
+            const pidStr = readFileSync(this.pidFile, "utf-8").trim();
+            return parseInt(pidStr, 10);
+        } catch (error) {
+            return;
+        }
+    }
+    isProcessRunning(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+    getProcessUptime(pid) {
+        try {
+            const pidFileStats = statSync(this.pidFile);
+            return Date.now() - pidFileStats.mtimeMs;
+        } catch (error) {
+            return;
+        }
+    }
+    removePidFile() {
+        if (existsSync(this.pidFile)) unlinkSync(this.pidFile);
+    }
+    saveConfig(config) {
+        writeFileSync(this.configFile, JSON.stringify(config, null, 2));
+    }
+    loadConfig() {
+        if (!existsSync(this.configFile)) return;
+        try {
+            const configStr = readFileSync(this.configFile, "utf-8");
+            return JSON.parse(configStr);
+        } catch (error) {
+            return;
+        }
+    }
+    getLogFile() {
+        return this.logFile;
+    }
+    getPidFile() {
+        return this.pidFile;
+    }
+    getConfigFile() {
+        return this.configFile;
+    }
+    constructor(){
+        _define_property(this, "pidFile", void 0);
+        _define_property(this, "logFile", void 0);
+        _define_property(this, "configFile", void 0);
+        const wingmanDir = join(homedir(), ".wingman");
+        this.pidFile = join(wingmanDir, "gateway.pid");
+        this.logFile = getLogFilePath();
+        this.configFile = join(wingmanDir, "gateway.json");
+    }
+}
+export { GatewayDaemon };