@wingman-ai/gateway 0.1.0

package/dist/gateway/transport/http.cjs

@@ -0,0 +1,153 @@
+"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__, {
+    HTTPBridgeTransport: ()=>HTTPBridgeTransport
+});
+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 HTTPBridgeTransport {
+    async connect() {
+        if (this.connected) throw new Error("Already connected");
+        this.connected = true;
+        this.startPolling();
+    }
+    disconnect() {
+        this.connected = false;
+        this.stopPolling();
+        if (this.nodeId) this.send({
+            type: "unregister",
+            nodeId: this.nodeId,
+            timestamp: Date.now()
+        }).catch(()=>{});
+        this.nodeId = null;
+    }
+    async send(message) {
+        if (!this.connected) throw new Error("Not connected");
+        const response = await fetch(`${this.baseUrl}/bridge/send`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.options.token && {
+                    Authorization: `Bearer ${this.options.token}`
+                }
+            },
+            body: JSON.stringify(message),
+            signal: AbortSignal.timeout(this.options.connectionTimeout || 10000)
+        });
+        if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        if ("register" === message.type) {
+            const data = await response.json();
+            if ("registered" === data.type && "nodeId" in data) {
+                this.nodeId = data.nodeId;
+                if (this.messageHandler) this.messageHandler(data);
+            }
+        }
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getType() {
+        return "http";
+    }
+    startPolling() {
+        if (this.polling) return;
+        this.polling = true;
+        this.poll();
+    }
+    stopPolling() {
+        this.polling = false;
+        if (this.pollAbortController) {
+            this.pollAbortController.abort();
+            this.pollAbortController = null;
+        }
+    }
+    async poll() {
+        while(this.polling && this.connected)try {
+            this.pollAbortController = new AbortController();
+            const response = await fetch(`${this.baseUrl}/bridge/poll`, {
+                method: "GET",
+                headers: {
+                    ...this.options.token && {
+                        Authorization: `Bearer ${this.options.token}`
+                    },
+                    ...this.nodeId && {
+                        "X-Node-ID": this.nodeId
+                    }
+                },
+                signal: this.pollAbortController.signal
+            });
+            if (!response.ok) {
+                if (401 === response.status) throw new Error("Authentication failed");
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const messages = await response.json();
+            if (this.messageHandler && messages.length > 0) for (const message of messages)this.messageHandler(message);
+        } catch (error) {
+            if (error instanceof Error && "AbortError" === error.name) break;
+            logger.error("Polling error", error);
+            if (this.polling && this.connected) await new Promise((resolve)=>setTimeout(resolve, this.options.reconnectDelay || 5000));
+        }
+        this.pollAbortController = null;
+    }
+    constructor(url, options = {}){
+        _define_property(this, "baseUrl", void 0);
+        _define_property(this, "options", void 0);
+        _define_property(this, "messageHandler", null);
+        _define_property(this, "nodeId", null);
+        _define_property(this, "connected", false);
+        _define_property(this, "polling", false);
+        _define_property(this, "pollAbortController", null);
+        this.baseUrl = url.replace(/^ws:/, "http:").replace(/^wss:/, "https:");
+        this.baseUrl = this.baseUrl.replace(/\/ws$/, "");
+        this.options = {
+            autoReconnect: true,
+            maxReconnectAttempts: 5,
+            reconnectDelay: 5000,
+            connectionTimeout: 10000,
+            ...options
+        };
+    }
+}
+exports.HTTPBridgeTransport = __webpack_exports__.HTTPBridgeTransport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HTTPBridgeTransport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/transport/http.d.ts

@@ -0,0 +1,25 @@
+import type { GatewayMessage } from "../types.js";
+import type { TransportClient, TransportOptions } from "./types.js";
+/**
+ * HTTP bridge transport client
+ * Uses long-polling for receiving messages and POST for sending
+ */
+export declare class HTTPBridgeTransport implements TransportClient {
+    private baseUrl;
+    private options;
+    private messageHandler;
+    private nodeId;
+    private connected;
+    private polling;
+    private pollAbortController;
+    constructor(url: string, options?: TransportOptions);
+    connect(): Promise<void>;
+    disconnect(): void;
+    send(message: GatewayMessage): Promise<void>;
+    onMessage(handler: (message: GatewayMessage) => void): void;
+    isConnected(): boolean;
+    getType(): "http";
+    private startPolling;
+    private stopPolling;
+    private poll;
+}

package/dist/gateway/transport/http.js

@@ -0,0 +1,119 @@
+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 HTTPBridgeTransport {
+    async connect() {
+        if (this.connected) throw new Error("Already connected");
+        this.connected = true;
+        this.startPolling();
+    }
+    disconnect() {
+        this.connected = false;
+        this.stopPolling();
+        if (this.nodeId) this.send({
+            type: "unregister",
+            nodeId: this.nodeId,
+            timestamp: Date.now()
+        }).catch(()=>{});
+        this.nodeId = null;
+    }
+    async send(message) {
+        if (!this.connected) throw new Error("Not connected");
+        const response = await fetch(`${this.baseUrl}/bridge/send`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                ...this.options.token && {
+                    Authorization: `Bearer ${this.options.token}`
+                }
+            },
+            body: JSON.stringify(message),
+            signal: AbortSignal.timeout(this.options.connectionTimeout || 10000)
+        });
+        if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        if ("register" === message.type) {
+            const data = await response.json();
+            if ("registered" === data.type && "nodeId" in data) {
+                this.nodeId = data.nodeId;
+                if (this.messageHandler) this.messageHandler(data);
+            }
+        }
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getType() {
+        return "http";
+    }
+    startPolling() {
+        if (this.polling) return;
+        this.polling = true;
+        this.poll();
+    }
+    stopPolling() {
+        this.polling = false;
+        if (this.pollAbortController) {
+            this.pollAbortController.abort();
+            this.pollAbortController = null;
+        }
+    }
+    async poll() {
+        while(this.polling && this.connected)try {
+            this.pollAbortController = new AbortController();
+            const response = await fetch(`${this.baseUrl}/bridge/poll`, {
+                method: "GET",
+                headers: {
+                    ...this.options.token && {
+                        Authorization: `Bearer ${this.options.token}`
+                    },
+                    ...this.nodeId && {
+                        "X-Node-ID": this.nodeId
+                    }
+                },
+                signal: this.pollAbortController.signal
+            });
+            if (!response.ok) {
+                if (401 === response.status) throw new Error("Authentication failed");
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const messages = await response.json();
+            if (this.messageHandler && messages.length > 0) for (const message of messages)this.messageHandler(message);
+        } catch (error) {
+            if (error instanceof Error && "AbortError" === error.name) break;
+            logger.error("Polling error", error);
+            if (this.polling && this.connected) await new Promise((resolve)=>setTimeout(resolve, this.options.reconnectDelay || 5000));
+        }
+        this.pollAbortController = null;
+    }
+    constructor(url, options = {}){
+        _define_property(this, "baseUrl", void 0);
+        _define_property(this, "options", void 0);
+        _define_property(this, "messageHandler", null);
+        _define_property(this, "nodeId", null);
+        _define_property(this, "connected", false);
+        _define_property(this, "polling", false);
+        _define_property(this, "pollAbortController", null);
+        this.baseUrl = url.replace(/^ws:/, "http:").replace(/^wss:/, "https:");
+        this.baseUrl = this.baseUrl.replace(/\/ws$/, "");
+        this.options = {
+            autoReconnect: true,
+            maxReconnectAttempts: 5,
+            reconnectDelay: 5000,
+            connectionTimeout: 10000,
+            ...options
+        };
+    }
+}
+export { HTTPBridgeTransport };

package/dist/gateway/transport/index.cjs

@@ -0,0 +1,40 @@
+"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__, {
+    WebSocketTransport: ()=>external_websocket_cjs_namespaceObject.WebSocketTransport,
+    HTTPBridgeTransport: ()=>external_http_cjs_namespaceObject.HTTPBridgeTransport
+});
+const external_websocket_cjs_namespaceObject = require("./websocket.cjs");
+const external_http_cjs_namespaceObject = require("./http.cjs");
+exports.HTTPBridgeTransport = __webpack_exports__.HTTPBridgeTransport;
+exports.WebSocketTransport = __webpack_exports__.WebSocketTransport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HTTPBridgeTransport",
+    "WebSocketTransport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/transport/index.d.ts

@@ -0,0 +1,3 @@
+export { WebSocketTransport } from "./websocket.js";
+export { HTTPBridgeTransport } from "./http.js";
+export type { TransportClient, TransportOptions, TransportType, } from "./types.js";

package/dist/gateway/transport/index.js

@@ -0,0 +1,3 @@
+import { WebSocketTransport } from "./websocket.js";
+import { HTTPBridgeTransport } from "./http.js";
+export { HTTPBridgeTransport, WebSocketTransport };

package/dist/gateway/transport/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/transport/types.d.ts

@@ -0,0 +1,59 @@
+import type { GatewayMessage } from "../types.js";
+/**
+ * Transport types
+ */
+export type TransportType = "websocket" | "http";
+/**
+ * Transport client interface
+ */
+export interface TransportClient {
+    /**
+     * Connect to the gateway
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the gateway
+     */
+    disconnect(): void;
+    /**
+     * Send a message to the gateway
+     */
+    send(message: GatewayMessage): void;
+    /**
+     * Register message handler
+     */
+    onMessage(handler: (message: GatewayMessage) => void): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get transport type
+     */
+    getType(): TransportType;
+}
+/**
+ * Transport client options
+ */
+export interface TransportOptions {
+    /**
+     * Authentication token
+     */
+    token?: string;
+    /**
+     * Reconnect automatically on disconnect
+     */
+    autoReconnect?: boolean;
+    /**
+     * Maximum reconnection attempts
+     */
+    maxReconnectAttempts?: number;
+    /**
+     * Reconnect delay in ms
+     */
+    reconnectDelay?: number;
+    /**
+     * Connection timeout in ms
+     */
+    connectionTimeout?: number;
+}

package/dist/gateway/transport/websocket.cjs

@@ -0,0 +1,132 @@
+"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__, {
+    WebSocketTransport: ()=>WebSocketTransport
+});
+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 WebSocketTransport {
+    async connect() {
+        return new Promise((resolve, reject)=>{
+            const timeout = setTimeout(()=>{
+                if (this.ws) this.ws.close();
+                reject(new Error("Connection timeout"));
+            }, this.options.connectionTimeout);
+            try {
+                this.ws = new WebSocket(this.url);
+                this.ws.onopen = ()=>{
+                    clearTimeout(timeout);
+                    this.reconnectAttempts = 0;
+                    resolve();
+                };
+                this.ws.onmessage = (event)=>{
+                    try {
+                        const message = JSON.parse(event.data);
+                        if (this.messageHandler) this.messageHandler(message);
+                    } catch (error) {
+                        logger.error("Failed to parse message", error);
+                    }
+                };
+                this.ws.onerror = (error)=>{
+                    clearTimeout(timeout);
+                    reject(error);
+                };
+                this.ws.onclose = ()=>{
+                    this.ws = null;
+                    if (this.options.autoReconnect && this.reconnectAttempts < (this.options.maxReconnectAttempts || 5)) this.scheduleReconnect();
+                };
+            } catch (error) {
+                clearTimeout(timeout);
+                reject(error);
+            }
+        });
+    }
+    disconnect() {
+        this.options.autoReconnect = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    send(message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error("WebSocket not connected");
+        this.ws.send(JSON.stringify(message));
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    isConnected() {
+        return null !== this.ws && this.ws.readyState === WebSocket.OPEN;
+    }
+    getType() {
+        return "websocket";
+    }
+    scheduleReconnect() {
+        this.reconnectAttempts++;
+        this.reconnectTimer = setTimeout(()=>{
+            this.connect().catch((error)=>{
+                logger.error("Reconnect failed", error);
+            });
+        }, this.options.reconnectDelay);
+    }
+    constructor(url, options = {}){
+        _define_property(this, "ws", null);
+        _define_property(this, "url", void 0);
+        _define_property(this, "options", void 0);
+        _define_property(this, "messageHandler", null);
+        _define_property(this, "reconnectAttempts", 0);
+        _define_property(this, "reconnectTimer", null);
+        this.url = url;
+        this.options = {
+            autoReconnect: true,
+            maxReconnectAttempts: 5,
+            reconnectDelay: 5000,
+            connectionTimeout: 10000,
+            ...options
+        };
+    }
+}
+exports.WebSocketTransport = __webpack_exports__.WebSocketTransport;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WebSocketTransport"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/transport/websocket.d.ts

@@ -0,0 +1,21 @@
+import type { GatewayMessage } from "../types.js";
+import type { TransportClient, TransportOptions } from "./types.js";
+/**
+ * WebSocket transport client
+ */
+export declare class WebSocketTransport implements TransportClient {
+    private ws;
+    private url;
+    private options;
+    private messageHandler;
+    private reconnectAttempts;
+    private reconnectTimer;
+    constructor(url: string, options?: TransportOptions);
+    connect(): Promise<void>;
+    disconnect(): void;
+    send(message: GatewayMessage): void;
+    onMessage(handler: (message: GatewayMessage) => void): void;
+    isConnected(): boolean;
+    getType(): "websocket";
+    private scheduleReconnect;
+}

package/dist/gateway/transport/websocket.js

@@ -0,0 +1,98 @@
+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 WebSocketTransport {
+    async connect() {
+        return new Promise((resolve, reject)=>{
+            const timeout = setTimeout(()=>{
+                if (this.ws) this.ws.close();
+                reject(new Error("Connection timeout"));
+            }, this.options.connectionTimeout);
+            try {
+                this.ws = new WebSocket(this.url);
+                this.ws.onopen = ()=>{
+                    clearTimeout(timeout);
+                    this.reconnectAttempts = 0;
+                    resolve();
+                };
+                this.ws.onmessage = (event)=>{
+                    try {
+                        const message = JSON.parse(event.data);
+                        if (this.messageHandler) this.messageHandler(message);
+                    } catch (error) {
+                        logger.error("Failed to parse message", error);
+                    }
+                };
+                this.ws.onerror = (error)=>{
+                    clearTimeout(timeout);
+                    reject(error);
+                };
+                this.ws.onclose = ()=>{
+                    this.ws = null;
+                    if (this.options.autoReconnect && this.reconnectAttempts < (this.options.maxReconnectAttempts || 5)) this.scheduleReconnect();
+                };
+            } catch (error) {
+                clearTimeout(timeout);
+                reject(error);
+            }
+        });
+    }
+    disconnect() {
+        this.options.autoReconnect = false;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    send(message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) throw new Error("WebSocket not connected");
+        this.ws.send(JSON.stringify(message));
+    }
+    onMessage(handler) {
+        this.messageHandler = handler;
+    }
+    isConnected() {
+        return null !== this.ws && this.ws.readyState === WebSocket.OPEN;
+    }
+    getType() {
+        return "websocket";
+    }
+    scheduleReconnect() {
+        this.reconnectAttempts++;
+        this.reconnectTimer = setTimeout(()=>{
+            this.connect().catch((error)=>{
+                logger.error("Reconnect failed", error);
+            });
+        }, this.options.reconnectDelay);
+    }
+    constructor(url, options = {}){
+        _define_property(this, "ws", null);
+        _define_property(this, "url", void 0);
+        _define_property(this, "options", void 0);
+        _define_property(this, "messageHandler", null);
+        _define_property(this, "reconnectAttempts", 0);
+        _define_property(this, "reconnectTimer", null);
+        this.url = url;
+        this.options = {
+            autoReconnect: true,
+            maxReconnectAttempts: 5,
+            reconnectDelay: 5000,
+            connectionTimeout: 10000,
+            ...options
+        };
+    }
+}
+export { WebSocketTransport };