@wingman-ai/gateway 0.1.0

package/dist/gateway/index.cjs

@@ -0,0 +1,119 @@
+"use strict";
+var __webpack_modules__ = {
+    "./auth.js" (module) {
+        module.exports = require("./auth.cjs");
+    },
+    "./broadcast.js" (module) {
+        module.exports = require("./broadcast.cjs");
+    },
+    "./client.js" (module) {
+        module.exports = require("./client.cjs");
+    },
+    "./daemon.js" (module) {
+        module.exports = require("./daemon.cjs");
+    },
+    "./node.js" (module) {
+        module.exports = require("./node.cjs");
+    },
+    "./rpcClient.js" (module) {
+        module.exports = require("./rpcClient.cjs");
+    },
+    "./server.js" (module) {
+        module.exports = require("./server.cjs");
+    },
+    "./types.js" (module) {
+        module.exports = require("./types.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+        BroadcastGroupManager: ()=>_broadcast_js__rspack_import_6.BroadcastGroupManager,
+        GatewayAuth: ()=>_auth_js__rspack_import_3.GatewayAuth,
+        GatewayClient: ()=>_client_js__rspack_import_1.GatewayClient,
+        GatewayDaemon: ()=>_daemon_js__rspack_import_4.GatewayDaemon,
+        GatewayRpcClient: ()=>_rpcClient_js__rspack_import_2.GatewayRpcClient,
+        GatewayServer: ()=>_server_js__rspack_import_0.GatewayServer,
+        NodeManager: ()=>_node_js__rspack_import_5.NodeManager
+    });
+    var _server_js__rspack_import_0 = __webpack_require__("./server.js");
+    var _client_js__rspack_import_1 = __webpack_require__("./client.js");
+    var _rpcClient_js__rspack_import_2 = __webpack_require__("./rpcClient.js");
+    var _auth_js__rspack_import_3 = __webpack_require__("./auth.js");
+    var _daemon_js__rspack_import_4 = __webpack_require__("./daemon.js");
+    var _node_js__rspack_import_5 = __webpack_require__("./node.js");
+    var _broadcast_js__rspack_import_6 = __webpack_require__("./broadcast.js");
+    var _types_js__rspack_import_7 = __webpack_require__("./types.js");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types_js__rspack_import_7)if ([
+        "GatewayClient",
+        "GatewayDaemon",
+        "default",
+        "NodeManager",
+        "GatewayRpcClient",
+        "BroadcastGroupManager",
+        "GatewayAuth",
+        "GatewayServer"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types_js__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+exports.BroadcastGroupManager = __webpack_exports__.BroadcastGroupManager;
+exports.GatewayAuth = __webpack_exports__.GatewayAuth;
+exports.GatewayClient = __webpack_exports__.GatewayClient;
+exports.GatewayDaemon = __webpack_exports__.GatewayDaemon;
+exports.GatewayRpcClient = __webpack_exports__.GatewayRpcClient;
+exports.GatewayServer = __webpack_exports__.GatewayServer;
+exports.NodeManager = __webpack_exports__.NodeManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BroadcastGroupManager",
+    "GatewayAuth",
+    "GatewayClient",
+    "GatewayDaemon",
+    "GatewayRpcClient",
+    "GatewayServer",
+    "NodeManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/index.d.ts

@@ -0,0 +1,8 @@
+export { GatewayServer } from "./server.js";
+export { GatewayClient } from "./client.js";
+export { GatewayRpcClient } from "./rpcClient.js";
+export { GatewayAuth } from "./auth.js";
+export { GatewayDaemon } from "./daemon.js";
+export { NodeManager } from "./node.js";
+export { BroadcastGroupManager } from "./broadcast.js";
+export * from "./types.js";

package/dist/gateway/index.js

@@ -0,0 +1,9 @@
+import { GatewayServer } from "./server.js";
+import { GatewayClient } from "./client.js";
+import { GatewayRpcClient } from "./rpcClient.js";
+import { GatewayAuth } from "./auth.js";
+import { GatewayDaemon } from "./daemon.js";
+import { NodeManager } from "./node.js";
+import { BroadcastGroupManager } from "./broadcast.js";
+export * from "./types.js";
+export { BroadcastGroupManager, GatewayAuth, GatewayClient, GatewayDaemon, GatewayRpcClient, GatewayServer, NodeManager };

package/dist/gateway/node.cjs

@@ -0,0 +1,218 @@
+"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__, {
+    NodeManager: ()=>NodeManager
+});
+const external_crypto_namespaceObject = require("crypto");
+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;
+}
+const logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+class NodeManager {
+    registerNode(ws, name, capabilities, sessionId, agentName) {
+        if (this.nodes.size >= this.maxNodes) return null;
+        const id = this.generateNodeId();
+        const node = {
+            id,
+            name,
+            capabilities,
+            groups: new Set(),
+            connectedAt: Date.now(),
+            ws,
+            sessionId,
+            agentName
+        };
+        ws.data = {
+            nodeId: id
+        };
+        this.nodes.set(id, node);
+        return node;
+    }
+    unregisterNode(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        try {
+            node.ws.close();
+        } catch (error) {}
+        return this.nodes.delete(nodeId);
+    }
+    getNode(nodeId) {
+        return this.nodes.get(nodeId);
+    }
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    getNodeMetadata(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return;
+        return {
+            id: node.id,
+            name: node.name,
+            capabilities: node.capabilities,
+            groups: node.groups,
+            connectedAt: node.connectedAt,
+            lastPing: node.lastPing,
+            sessionId: node.sessionId,
+            agentName: node.agentName
+        };
+    }
+    updatePing(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (node) node.lastPing = Date.now();
+    }
+    isRateLimited(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        const now = Date.now();
+        const messageCount = node.messageCount || 0;
+        const lastMessageTime = node.lastMessageTime || 0;
+        if (now - lastMessageTime > this.messageWindow) {
+            node.messageCount = 0;
+            return false;
+        }
+        return messageCount >= this.messageRateLimit;
+    }
+    recordMessage(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return;
+        const now = Date.now();
+        const lastMessageTime = node.lastMessageTime || 0;
+        if (now - lastMessageTime > this.messageWindow) node.messageCount = 1;
+        else node.messageCount = (node.messageCount || 0) + 1;
+        node.lastMessageTime = now;
+    }
+    addNodeToGroup(nodeId, groupId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        node.groups.add(groupId);
+        return true;
+    }
+    removeNodeFromGroup(nodeId, groupId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        return node.groups.delete(groupId);
+    }
+    sendToNode(nodeId, message) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        try {
+            node.ws.send(JSON.stringify(message));
+            return true;
+        } catch (error) {
+            logger.error(`Failed to send message to node ${nodeId}`, error);
+            return false;
+        }
+    }
+    broadcastToNodes(nodeIds, message) {
+        let successCount = 0;
+        for (const nodeId of nodeIds)if (this.sendToNode(nodeId, message)) successCount++;
+        return successCount;
+    }
+    broadcastToAll(message) {
+        const nodeIds = Array.from(this.nodes.keys());
+        return this.broadcastToNodes(nodeIds, message);
+    }
+    getNodesByGroup(groupId) {
+        const nodes = [];
+        for (const node of this.nodes.values())if (node.groups.has(groupId)) nodes.push(node);
+        return nodes;
+    }
+    getStaleNodes(timeoutMs) {
+        const now = Date.now();
+        const staleNodes = [];
+        for (const node of this.nodes.values())if (node.lastPing && now - node.lastPing > timeoutMs) staleNodes.push(node);
+        return staleNodes;
+    }
+    removeStaleNodes(timeoutMs) {
+        const staleNodes = this.getStaleNodes(timeoutMs);
+        let removed = 0;
+        for (const node of staleNodes)if (this.unregisterNode(node.id)) removed++;
+        return removed;
+    }
+    generateNodeId() {
+        return (0, external_crypto_namespaceObject.randomBytes)(16).toString("hex");
+    }
+    getNodesBySession(sessionId) {
+        const nodes = [];
+        for (const node of this.nodes.values())if (node.sessionId === sessionId) nodes.push(node);
+        return nodes;
+    }
+    getSessionNodes() {
+        const sessionMap = new Map();
+        for (const node of this.nodes.values())if (node.sessionId) {
+            if (!sessionMap.has(node.sessionId)) sessionMap.set(node.sessionId, []);
+            sessionMap.get(node.sessionId).push(node);
+        }
+        return sessionMap;
+    }
+    getStats() {
+        const sessionMap = this.getSessionNodes();
+        return {
+            totalNodes: this.nodes.size,
+            maxNodes: this.maxNodes,
+            activeSessions: sessionMap.size,
+            sessionNodes: Array.from(sessionMap.entries()).map(([sessionId, nodes])=>({
+                    sessionId,
+                    agentName: nodes[0]?.agentName,
+                    nodeIds: nodes.map((n)=>n.id)
+                })),
+            nodes: Array.from(this.nodes.values()).map((n)=>({
+                    id: n.id,
+                    name: n.name,
+                    groupCount: n.groups.size,
+                    connectedAt: n.connectedAt,
+                    lastPing: n.lastPing,
+                    sessionId: n.sessionId,
+                    agentName: n.agentName
+                }))
+        };
+    }
+    constructor(maxNodes = 1000, messageRateLimit = 100, messageWindow = 60000){
+        _define_property(this, "nodes", void 0);
+        _define_property(this, "maxNodes", void 0);
+        _define_property(this, "messageRateLimit", void 0);
+        _define_property(this, "messageWindow", void 0);
+        this.nodes = new Map();
+        this.maxNodes = maxNodes;
+        this.messageRateLimit = messageRateLimit;
+        this.messageWindow = messageWindow;
+    }
+}
+exports.NodeManager = __webpack_exports__.NodeManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "NodeManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/node.d.ts

@@ -0,0 +1,112 @@
+import type { ServerWebSocket } from "bun";
+import type { Node, NodeMetadata, GatewayMessage } from "./types.js";
+/**
+ * Manages connected nodes in the gateway
+ */
+export declare class NodeManager {
+    private nodes;
+    private maxNodes;
+    private messageRateLimit;
+    private messageWindow;
+    constructor(maxNodes?: number, messageRateLimit?: number, messageWindow?: number);
+    /**
+     * Register a new node
+     */
+    registerNode(ws: ServerWebSocket<{
+        nodeId: string;
+    }>, name: string, capabilities?: string[], sessionId?: string, agentName?: string): Node | null;
+    /**
+     * Unregister a node
+     */
+    unregisterNode(nodeId: string): boolean;
+    /**
+     * Get a node by ID
+     */
+    getNode(nodeId: string): Node | undefined;
+    /**
+     * Get all nodes
+     */
+    getAllNodes(): Node[];
+    /**
+     * Get node metadata (without WebSocket)
+     */
+    getNodeMetadata(nodeId: string): NodeMetadata | undefined;
+    /**
+     * Update node's last ping time
+     */
+    updatePing(nodeId: string): void;
+    /**
+     * Check if node is rate limited
+     */
+    isRateLimited(nodeId: string): boolean;
+    /**
+     * Record a message from a node
+     */
+    recordMessage(nodeId: string): void;
+    /**
+     * Add a node to a group
+     */
+    addNodeToGroup(nodeId: string, groupId: string): boolean;
+    /**
+     * Remove a node from a group
+     */
+    removeNodeFromGroup(nodeId: string, groupId: string): boolean;
+    /**
+     * Send a message to a specific node
+     */
+    sendToNode(nodeId: string, message: GatewayMessage): boolean;
+    /**
+     * Broadcast a message to multiple nodes
+     */
+    broadcastToNodes(nodeIds: string[], message: GatewayMessage): number;
+    /**
+     * Broadcast a message to all nodes
+     */
+    broadcastToAll(message: GatewayMessage): number;
+    /**
+     * Get nodes by group
+     */
+    getNodesByGroup(groupId: string): Node[];
+    /**
+     * Check for stale nodes (no ping in timeout period)
+     */
+    getStaleNodes(timeoutMs: number): Node[];
+    /**
+     * Remove stale nodes
+     */
+    removeStaleNodes(timeoutMs: number): number;
+    /**
+     * Generate a unique node ID
+     */
+    private generateNodeId;
+    /**
+     * Get nodes by session ID
+     */
+    getNodesBySession(sessionId: string): Node[];
+    /**
+     * Get all active sessions with their nodes
+     */
+    getSessionNodes(): Map<string, Node[]>;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalNodes: number;
+        maxNodes: number;
+        activeSessions: number;
+        sessionNodes: {
+            sessionId: string;
+            agentName: string | undefined;
+            nodeIds: string[];
+        }[];
+        nodes: {
+            id: string;
+            name: string;
+            groupCount: number;
+            connectedAt: number;
+            lastPing: number | undefined;
+            sessionId: string | undefined;
+            agentName: string | undefined;
+        }[];
+    };
+}

package/dist/gateway/node.js

@@ -0,0 +1,184 @@
+import { randomBytes } from "crypto";
+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;
+}
+const logger = createLogger();
+class NodeManager {
+    registerNode(ws, name, capabilities, sessionId, agentName) {
+        if (this.nodes.size >= this.maxNodes) return null;
+        const id = this.generateNodeId();
+        const node = {
+            id,
+            name,
+            capabilities,
+            groups: new Set(),
+            connectedAt: Date.now(),
+            ws,
+            sessionId,
+            agentName
+        };
+        ws.data = {
+            nodeId: id
+        };
+        this.nodes.set(id, node);
+        return node;
+    }
+    unregisterNode(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        try {
+            node.ws.close();
+        } catch (error) {}
+        return this.nodes.delete(nodeId);
+    }
+    getNode(nodeId) {
+        return this.nodes.get(nodeId);
+    }
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    getNodeMetadata(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return;
+        return {
+            id: node.id,
+            name: node.name,
+            capabilities: node.capabilities,
+            groups: node.groups,
+            connectedAt: node.connectedAt,
+            lastPing: node.lastPing,
+            sessionId: node.sessionId,
+            agentName: node.agentName
+        };
+    }
+    updatePing(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (node) node.lastPing = Date.now();
+    }
+    isRateLimited(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        const now = Date.now();
+        const messageCount = node.messageCount || 0;
+        const lastMessageTime = node.lastMessageTime || 0;
+        if (now - lastMessageTime > this.messageWindow) {
+            node.messageCount = 0;
+            return false;
+        }
+        return messageCount >= this.messageRateLimit;
+    }
+    recordMessage(nodeId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return;
+        const now = Date.now();
+        const lastMessageTime = node.lastMessageTime || 0;
+        if (now - lastMessageTime > this.messageWindow) node.messageCount = 1;
+        else node.messageCount = (node.messageCount || 0) + 1;
+        node.lastMessageTime = now;
+    }
+    addNodeToGroup(nodeId, groupId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        node.groups.add(groupId);
+        return true;
+    }
+    removeNodeFromGroup(nodeId, groupId) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        return node.groups.delete(groupId);
+    }
+    sendToNode(nodeId, message) {
+        const node = this.nodes.get(nodeId);
+        if (!node) return false;
+        try {
+            node.ws.send(JSON.stringify(message));
+            return true;
+        } catch (error) {
+            logger.error(`Failed to send message to node ${nodeId}`, error);
+            return false;
+        }
+    }
+    broadcastToNodes(nodeIds, message) {
+        let successCount = 0;
+        for (const nodeId of nodeIds)if (this.sendToNode(nodeId, message)) successCount++;
+        return successCount;
+    }
+    broadcastToAll(message) {
+        const nodeIds = Array.from(this.nodes.keys());
+        return this.broadcastToNodes(nodeIds, message);
+    }
+    getNodesByGroup(groupId) {
+        const nodes = [];
+        for (const node of this.nodes.values())if (node.groups.has(groupId)) nodes.push(node);
+        return nodes;
+    }
+    getStaleNodes(timeoutMs) {
+        const now = Date.now();
+        const staleNodes = [];
+        for (const node of this.nodes.values())if (node.lastPing && now - node.lastPing > timeoutMs) staleNodes.push(node);
+        return staleNodes;
+    }
+    removeStaleNodes(timeoutMs) {
+        const staleNodes = this.getStaleNodes(timeoutMs);
+        let removed = 0;
+        for (const node of staleNodes)if (this.unregisterNode(node.id)) removed++;
+        return removed;
+    }
+    generateNodeId() {
+        return randomBytes(16).toString("hex");
+    }
+    getNodesBySession(sessionId) {
+        const nodes = [];
+        for (const node of this.nodes.values())if (node.sessionId === sessionId) nodes.push(node);
+        return nodes;
+    }
+    getSessionNodes() {
+        const sessionMap = new Map();
+        for (const node of this.nodes.values())if (node.sessionId) {
+            if (!sessionMap.has(node.sessionId)) sessionMap.set(node.sessionId, []);
+            sessionMap.get(node.sessionId).push(node);
+        }
+        return sessionMap;
+    }
+    getStats() {
+        const sessionMap = this.getSessionNodes();
+        return {
+            totalNodes: this.nodes.size,
+            maxNodes: this.maxNodes,
+            activeSessions: sessionMap.size,
+            sessionNodes: Array.from(sessionMap.entries()).map(([sessionId, nodes])=>({
+                    sessionId,
+                    agentName: nodes[0]?.agentName,
+                    nodeIds: nodes.map((n)=>n.id)
+                })),
+            nodes: Array.from(this.nodes.values()).map((n)=>({
+                    id: n.id,
+                    name: n.name,
+                    groupCount: n.groups.size,
+                    connectedAt: n.connectedAt,
+                    lastPing: n.lastPing,
+                    sessionId: n.sessionId,
+                    agentName: n.agentName
+                }))
+        };
+    }
+    constructor(maxNodes = 1000, messageRateLimit = 100, messageWindow = 60000){
+        _define_property(this, "nodes", void 0);
+        _define_property(this, "maxNodes", void 0);
+        _define_property(this, "messageRateLimit", void 0);
+        _define_property(this, "messageWindow", void 0);
+        this.nodes = new Map();
+        this.maxNodes = maxNodes;
+        this.messageRateLimit = messageRateLimit;
+        this.messageWindow = messageWindow;
+    }
+}
+export { NodeManager };