@wingman-ai/gateway 0.1.0

package/dist/gateway/broadcast.js

@@ -0,0 +1,97 @@
+import { randomBytes } from "crypto";
+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 BroadcastGroupManager {
+    createGroup(name, createdBy, description, strategy = "parallel") {
+        const id = this.generateGroupId();
+        const group = {
+            id,
+            name,
+            description,
+            createdAt: Date.now(),
+            createdBy,
+            members: new Set(),
+            strategy
+        };
+        this.groups.set(id, group);
+        return group;
+    }
+    getGroup(groupId) {
+        return this.groups.get(groupId);
+    }
+    getGroupByName(name) {
+        for (const group of this.groups.values())if (group.name === name) return group;
+    }
+    getOrCreateGroup(name, createdBy, description, strategy = "parallel") {
+        const existing = this.getGroupByName(name);
+        if (existing) return existing;
+        return this.createGroup(name, createdBy, description, strategy);
+    }
+    setGroupStrategy(groupId, strategy) {
+        const group = this.groups.get(groupId);
+        if (!group) return false;
+        group.strategy = strategy;
+        return true;
+    }
+    getGroupStrategy(groupId) {
+        const group = this.groups.get(groupId);
+        return group?.strategy;
+    }
+    deleteGroup(groupId) {
+        return this.groups.delete(groupId);
+    }
+    addNodeToGroup(groupId, nodeId) {
+        const group = this.groups.get(groupId);
+        if (!group) return false;
+        group.members.add(nodeId);
+        return true;
+    }
+    removeNodeFromGroup(groupId, nodeId) {
+        const group = this.groups.get(groupId);
+        if (!group) return false;
+        return group.members.delete(nodeId);
+    }
+    removeNodeFromAllGroups(nodeId) {
+        for (const group of this.groups.values())group.members.delete(nodeId);
+    }
+    getNodeGroups(nodeId) {
+        const nodeGroups = [];
+        for (const group of this.groups.values())if (group.members.has(nodeId)) nodeGroups.push(group);
+        return nodeGroups;
+    }
+    getAllGroups() {
+        return Array.from(this.groups.values());
+    }
+    getGroupMembers(groupId) {
+        const group = this.groups.get(groupId);
+        if (!group) return [];
+        return Array.from(group.members);
+    }
+    generateGroupId() {
+        return randomBytes(16).toString("hex");
+    }
+    getStats() {
+        return {
+            totalGroups: this.groups.size,
+            groups: Array.from(this.groups.values()).map((g)=>({
+                    id: g.id,
+                    name: g.name,
+                    memberCount: g.members.size,
+                    createdAt: g.createdAt
+                }))
+        };
+    }
+    constructor(){
+        _define_property(this, "groups", void 0);
+        this.groups = new Map();
+    }
+}
+export { BroadcastGroupManager };

package/dist/gateway/client.cjs

@@ -0,0 +1,282 @@
+"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__, {
+    GatewayClient: ()=>GatewayClient
+});
+const index_cjs_namespaceObject = require("./transport/index.cjs");
+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 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 index_cjs_namespaceObject.HTTPBridgeTransport(this.url, transportOptions);
+        return new index_cjs_namespaceObject.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 = (0, external_logger_cjs_namespaceObject.createLogger)();
+    }
+}
+exports.GatewayClient = __webpack_exports__.GatewayClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GatewayClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/client.d.ts

@@ -0,0 +1,141 @@
+import type { ErrorPayload } from "./types.js";
+import { type TransportType } from "./transport/index.js";
+/**
+ * Event handlers for the gateway client
+ */
+export interface GatewayClientEvents {
+    connected?: () => void;
+    disconnected?: () => void;
+    registered?: (nodeId: string, name: string) => void;
+    joinedGroup?: (groupId: string, groupName: string) => void;
+    leftGroup?: (groupId: string) => void;
+    broadcast?: (message: unknown, fromNodeId: string, groupId: string) => void;
+    direct?: (message: unknown, fromNodeId: string) => void;
+    error?: (error: ErrorPayload) => void;
+    ping?: () => void;
+    pong?: () => void;
+}
+/**
+ * Gateway client options
+ */
+export interface GatewayClientOptions {
+    token?: string;
+    capabilities?: string[];
+    events?: GatewayClientEvents;
+    transport?: TransportType | "auto";
+}
+/**
+ * Gateway client for connecting nodes to the gateway
+ */
+export declare class GatewayClient {
+    private url;
+    private transport;
+    private nodeId;
+    private nodeName;
+    private token?;
+    private capabilities?;
+    private events;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectDelay;
+    private pingInterval;
+    private transportType;
+    private logger;
+    private ws;
+    constructor(url: string, name: string, options?: GatewayClientOptions);
+    /**
+     * Connect to the gateway
+     */
+    connect(): Promise<void>;
+    /**
+     * Select appropriate transport type
+     */
+    private selectTransport;
+    /**
+     * Create transport instance
+     */
+    private createTransport;
+    /**
+     * Disconnect from the gateway
+     */
+    disconnect(): void;
+    /**
+     * Register with the gateway
+     */
+    private register;
+    /**
+     * Join a broadcast group
+     */
+    joinGroup(groupName: string, options?: {
+        createIfNotExists?: boolean;
+        description?: string;
+    }): Promise<void>;
+    /**
+     * Leave a broadcast group
+     */
+    leaveGroup(groupId: string): Promise<void>;
+    /**
+     * Broadcast a message to a group
+     */
+    broadcast(groupId: string, message: unknown): void;
+    /**
+     * Send a direct message to another node
+     */
+    sendDirect(targetNodeId: string, message: unknown): void;
+    /**
+     * Send a ping to the gateway
+     */
+    ping(): void;
+    /**
+     * Handle incoming messages
+     */
+    private handleMessage;
+    /**
+     * Handle acknowledgment message
+     */
+    private handleAck;
+    /**
+     * Handle broadcast message
+     */
+    private handleBroadcast;
+    /**
+     * Handle direct message
+     */
+    private handleDirect;
+    /**
+     * Handle ping message
+     */
+    private handlePing;
+    /**
+     * Handle pong message
+     */
+    private handlePong;
+    /**
+     * Handle error message
+     */
+    private handleError;
+    /**
+     * Handle disconnect
+     */
+    private handleDisconnect;
+    /**
+     * Start ping interval
+     */
+    private startPingInterval;
+    /**
+     * Send a message to the gateway
+     */
+    private send;
+    /**
+     * Get the node ID
+     */
+    getNodeId(): string | null;
+    /**
+     * Get the node name
+     */
+    getNodeName(): string;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+}