@wingman-ai/gateway 0.1.0

package/dist/tests/gateway.test.cjs

@@ -0,0 +1,319 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const index_cjs_namespaceObject = require("../gateway/index.cjs");
+const isBun = void 0 !== globalThis.Bun;
+const describeIfBun = isBun ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
+external_vitest_namespaceObject.vi.mock("@/cli/core/agentInvoker.js", ()=>({
+        AgentInvoker: class {
+            async invokeAgent() {
+                return {
+                    streaming: true
+                };
+            }
+        }
+    }));
+describeIfBun("Gateway", ()=>{
+    let server;
+    let port = 0;
+    (0, external_vitest_namespaceObject.beforeAll)(async ()=>{
+        const startPort = 23000;
+        const attempts = 50;
+        let lastError = null;
+        for(let i = 0; i < attempts; i += 1){
+            const candidate = startPort + i;
+            try {
+                const instance = new index_cjs_namespaceObject.GatewayServer({
+                    port: candidate,
+                    host: "localhost",
+                    requireAuth: false,
+                    logLevel: "silent"
+                });
+                await instance.start();
+                server = instance;
+                port = candidate;
+                lastError = null;
+                break;
+            } catch (error) {
+                lastError = error;
+            }
+        }
+        if (!server || !port) throw lastError ?? new Error("Unable to start gateway server for tests");
+        await new Promise((resolve)=>setTimeout(resolve, 500));
+    });
+    (0, external_vitest_namespaceObject.afterAll)(async ()=>{
+        if (server) await server.stop();
+    });
+    const connectClient = (instanceId, clientType = "test")=>new Promise((resolve, reject)=>{
+            const ws = new WebSocket(`ws://localhost:${port}/ws`);
+            const connectId = `connect-${instanceId}-${Date.now()}`;
+            const timeout = setTimeout(()=>reject(new Error("Connect timeout")), 5000);
+            ws.addEventListener("open", ()=>{
+                const message = {
+                    type: "connect",
+                    id: connectId,
+                    client: {
+                        instanceId,
+                        clientType
+                    },
+                    timestamp: Date.now()
+                };
+                ws.send(JSON.stringify(message));
+            });
+            ws.addEventListener("message", (event)=>{
+                const msg = JSON.parse(event.data);
+                if ("res" === msg.type && msg.id === connectId && msg.ok) {
+                    clearTimeout(timeout);
+                    resolve(ws);
+                }
+            });
+            ws.addEventListener("error", ()=>{
+                clearTimeout(timeout);
+                reject(new Error("WebSocket error"));
+            });
+        });
+    const waitForMessage = (ws, predicate, timeoutMs = 5000)=>new Promise((resolve, reject)=>{
+            const timeout = setTimeout(()=>reject(new Error("Message timeout")), timeoutMs);
+            const handler = (event)=>{
+                let msg;
+                try {
+                    msg = JSON.parse(event.data);
+                } catch  {
+                    return;
+                }
+                if (!predicate(msg)) return;
+                clearTimeout(timeout);
+                ws.removeEventListener("message", handler);
+                resolve(msg);
+            };
+            ws.addEventListener("message", handler);
+        });
+    (0, external_vitest_namespaceObject.it)("should start the gateway server", async ()=>{
+        const response = await fetch(`http://localhost:${port}/health`);
+        (0, external_vitest_namespaceObject.expect)(response.ok).toBe(true);
+        const health = await response.json();
+        (0, external_vitest_namespaceObject.expect)(health.status).toBe("healthy");
+    });
+    (0, external_vitest_namespaceObject.it)("should connect a client", async ()=>new Promise((resolve, reject)=>{
+            const client = new index_cjs_namespaceObject.GatewayClient(`ws://localhost:${port}/ws`, "test-client", {
+                events: {
+                    connected: ()=>{
+                        client.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Connection timeout")), 5000);
+        }));
+    (0, external_vitest_namespaceObject.it)("should register a client and receive node ID", async ()=>new Promise((resolve, reject)=>{
+            const client = new index_cjs_namespaceObject.GatewayClient(`ws://localhost:${port}/ws`, "test-client-2", {
+                events: {
+                    registered: (nodeId, name)=>{
+                        (0, external_vitest_namespaceObject.expect)(nodeId).toBeTruthy();
+                        (0, external_vitest_namespaceObject.expect)(name).toBe("test-client-2");
+                        client.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Registration timeout")), 5000);
+        }));
+    (0, external_vitest_namespaceObject.it)("should join a broadcast group", async ()=>new Promise((resolve, reject)=>{
+            const client = new index_cjs_namespaceObject.GatewayClient(`ws://localhost:${port}/ws`, "test-client-3", {
+                events: {
+                    registered: async ()=>{
+                        await client.joinGroup("test-group");
+                    },
+                    joinedGroup: (groupId, groupName)=>{
+                        (0, external_vitest_namespaceObject.expect)(groupName).toBe("test-group");
+                        client.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Join group timeout")), 5000);
+        }));
+    (0, external_vitest_namespaceObject.it)("should broadcast messages to group members", async ()=>new Promise((resolve, reject)=>{
+            let client1NodeId = null;
+            let messagesReceived = 0;
+            const client1 = new index_cjs_namespaceObject.GatewayClient(`ws://localhost:${port}/ws`, "broadcaster", {
+                events: {
+                    registered: async (nodeId)=>{
+                        client1NodeId = nodeId;
+                        await client1.joinGroup("broadcast-test");
+                    },
+                    joinedGroup: ()=>{
+                        client2.connect().catch(reject);
+                    }
+                }
+            });
+            const client2 = new index_cjs_namespaceObject.GatewayClient(`ws://localhost:${port}/ws`, "receiver", {
+                events: {
+                    registered: async ()=>{
+                        await client2.joinGroup("broadcast-test");
+                    },
+                    joinedGroup: ()=>{
+                        client1.broadcast("broadcast-test", {
+                            message: "Hello from client 1"
+                        });
+                    },
+                    broadcast: (message, fromNodeId)=>{
+                        (0, external_vitest_namespaceObject.expect)(fromNodeId).toBe(client1NodeId);
+                        (0, external_vitest_namespaceObject.expect)(message.message).toBe("Hello from client 1");
+                        messagesReceived++;
+                        client1.disconnect();
+                        client2.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client1.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Broadcast test timeout")), 10000);
+        }));
+    (0, external_vitest_namespaceObject.it)("should handle ping/pong", async ()=>new Promise((resolve, reject)=>{
+            const client = new index_cjs_namespaceObject.GatewayClient(`ws://localhost:${port}/ws`, "ping-test", {
+                events: {
+                    registered: ()=>{
+                        client.ping();
+                    },
+                    pong: ()=>{
+                        client.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Ping/pong timeout")), 5000);
+        }));
+    (0, external_vitest_namespaceObject.it)("should stream agent events to session subscribers", async ()=>{
+        const subscriber = await connectClient("session-subscriber");
+        const sessionId = "session-test";
+        subscriber.send(JSON.stringify({
+            type: "session_subscribe",
+            payload: {
+                sessionId
+            },
+            timestamp: Date.now()
+        }));
+        await waitForMessage(subscriber, (msg)=>"ack" === msg.type && msg.payload?.action === "session_subscribe" && msg.payload?.sessionId === sessionId);
+        const eventPromise = waitForMessage(subscriber, (msg)=>"event:agent" === msg.type && "req-session" === msg.id);
+        const sent = server.broadcastSessionEvent(sessionId, {
+            type: "event:agent",
+            id: "req-session",
+            payload: {
+                type: "agent-stream",
+                sessionId,
+                agentId: "main",
+                chunk: {
+                    content: "hello"
+                }
+            },
+            timestamp: Date.now()
+        });
+        (0, external_vitest_namespaceObject.expect)(sent).toBe(1);
+        const eventMsg = await eventPromise;
+        (0, external_vitest_namespaceObject.expect)(eventMsg.payload?.sessionId).toBe(sessionId);
+        subscriber.close();
+    });
+    (0, external_vitest_namespaceObject.it)("should broadcast user messages to session subscribers", async ()=>{
+        const subscriber = await connectClient("session-input-subscriber");
+        const requester = await connectClient("session-input-requester");
+        const sessionId = "session-input-test";
+        subscriber.send(JSON.stringify({
+            type: "session_subscribe",
+            payload: {
+                sessionId
+            },
+            timestamp: Date.now()
+        }));
+        await waitForMessage(subscriber, (msg)=>"ack" === msg.type && msg.payload?.action === "session_subscribe" && msg.payload?.sessionId === sessionId);
+        const eventPromise = waitForMessage(subscriber, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user");
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: "req-session-input",
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "Hello from test"
+            },
+            timestamp: Date.now()
+        }));
+        const eventMsg = await eventPromise;
+        (0, external_vitest_namespaceObject.expect)(eventMsg.payload?.content).toBe("Hello from test");
+        (0, external_vitest_namespaceObject.expect)(eventMsg.payload?.sessionId).toBe(sessionId);
+        (0, external_vitest_namespaceObject.expect)(eventMsg.payload?.agentId).toBe("main");
+        subscriber.close();
+        requester.close();
+    });
+    (0, external_vitest_namespaceObject.it)("should broadcast user messages to webui clients without session subscribe", async ()=>{
+        const webuiClient = await connectClient("session-webui-listener", "webui");
+        const requester = await connectClient("session-webui-requester");
+        const sessionId = "session-webui-test";
+        const eventPromise = waitForMessage(webuiClient, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user" && msg.payload?.sessionId === sessionId);
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: "req-session-webui",
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "Hello webui"
+            },
+            timestamp: Date.now()
+        }));
+        const eventMsg = await eventPromise;
+        (0, external_vitest_namespaceObject.expect)(eventMsg.payload?.content).toBe("Hello webui");
+        (0, external_vitest_namespaceObject.expect)(eventMsg.payload?.agentId).toBe("main");
+        webuiClient.close();
+        requester.close();
+    });
+    (0, external_vitest_namespaceObject.it)("should clear session messages via API", async ()=>{
+        const createRes = await fetch(`http://localhost:${port}/api/sessions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                agentId: "main",
+                name: "Clear Test"
+            })
+        });
+        (0, external_vitest_namespaceObject.expect)(createRes.ok).toBe(true);
+        const session = await createRes.json();
+        const manager = await server.getSessionManager("main");
+        manager.updateSession(session.id, {
+            messageCount: 3,
+            lastMessagePreview: "Hello"
+        });
+        const clearRes = await fetch(`http://localhost:${port}/api/sessions/${encodeURIComponent(session.id)}/messages?agentId=main`, {
+            method: "DELETE"
+        });
+        (0, external_vitest_namespaceObject.expect)(clearRes.ok).toBe(true);
+        const cleared = await clearRes.json();
+        (0, external_vitest_namespaceObject.expect)(cleared.messageCount).toBe(0);
+        const updated = manager.getSession(session.id);
+        (0, external_vitest_namespaceObject.expect)(updated?.messageCount).toBe(0);
+        (0, external_vitest_namespaceObject.expect)(updated?.lastMessagePreview).toBeNull();
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/gateway.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/gateway.test.js

@@ -0,0 +1,313 @@
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { GatewayClient, GatewayServer } from "../gateway/index.js";
+const isBun = void 0 !== globalThis.Bun;
+const describeIfBun = isBun ? describe : describe.skip;
+vi.mock("@/cli/core/agentInvoker.js", ()=>({
+        AgentInvoker: class {
+            async invokeAgent() {
+                return {
+                    streaming: true
+                };
+            }
+        }
+    }));
+describeIfBun("Gateway", ()=>{
+    let server;
+    let port = 0;
+    beforeAll(async ()=>{
+        const startPort = 23000;
+        const attempts = 50;
+        let lastError = null;
+        for(let i = 0; i < attempts; i += 1){
+            const candidate = startPort + i;
+            try {
+                const instance = new GatewayServer({
+                    port: candidate,
+                    host: "localhost",
+                    requireAuth: false,
+                    logLevel: "silent"
+                });
+                await instance.start();
+                server = instance;
+                port = candidate;
+                lastError = null;
+                break;
+            } catch (error) {
+                lastError = error;
+            }
+        }
+        if (!server || !port) throw lastError ?? new Error("Unable to start gateway server for tests");
+        await new Promise((resolve)=>setTimeout(resolve, 500));
+    });
+    afterAll(async ()=>{
+        if (server) await server.stop();
+    });
+    const connectClient = (instanceId, clientType = "test")=>new Promise((resolve, reject)=>{
+            const ws = new WebSocket(`ws://localhost:${port}/ws`);
+            const connectId = `connect-${instanceId}-${Date.now()}`;
+            const timeout = setTimeout(()=>reject(new Error("Connect timeout")), 5000);
+            ws.addEventListener("open", ()=>{
+                const message = {
+                    type: "connect",
+                    id: connectId,
+                    client: {
+                        instanceId,
+                        clientType
+                    },
+                    timestamp: Date.now()
+                };
+                ws.send(JSON.stringify(message));
+            });
+            ws.addEventListener("message", (event)=>{
+                const msg = JSON.parse(event.data);
+                if ("res" === msg.type && msg.id === connectId && msg.ok) {
+                    clearTimeout(timeout);
+                    resolve(ws);
+                }
+            });
+            ws.addEventListener("error", ()=>{
+                clearTimeout(timeout);
+                reject(new Error("WebSocket error"));
+            });
+        });
+    const waitForMessage = (ws, predicate, timeoutMs = 5000)=>new Promise((resolve, reject)=>{
+            const timeout = setTimeout(()=>reject(new Error("Message timeout")), timeoutMs);
+            const handler = (event)=>{
+                let msg;
+                try {
+                    msg = JSON.parse(event.data);
+                } catch  {
+                    return;
+                }
+                if (!predicate(msg)) return;
+                clearTimeout(timeout);
+                ws.removeEventListener("message", handler);
+                resolve(msg);
+            };
+            ws.addEventListener("message", handler);
+        });
+    it("should start the gateway server", async ()=>{
+        const response = await fetch(`http://localhost:${port}/health`);
+        expect(response.ok).toBe(true);
+        const health = await response.json();
+        expect(health.status).toBe("healthy");
+    });
+    it("should connect a client", async ()=>new Promise((resolve, reject)=>{
+            const client = new GatewayClient(`ws://localhost:${port}/ws`, "test-client", {
+                events: {
+                    connected: ()=>{
+                        client.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Connection timeout")), 5000);
+        }));
+    it("should register a client and receive node ID", async ()=>new Promise((resolve, reject)=>{
+            const client = new GatewayClient(`ws://localhost:${port}/ws`, "test-client-2", {
+                events: {
+                    registered: (nodeId, name)=>{
+                        expect(nodeId).toBeTruthy();
+                        expect(name).toBe("test-client-2");
+                        client.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Registration timeout")), 5000);
+        }));
+    it("should join a broadcast group", async ()=>new Promise((resolve, reject)=>{
+            const client = new GatewayClient(`ws://localhost:${port}/ws`, "test-client-3", {
+                events: {
+                    registered: async ()=>{
+                        await client.joinGroup("test-group");
+                    },
+                    joinedGroup: (groupId, groupName)=>{
+                        expect(groupName).toBe("test-group");
+                        client.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Join group timeout")), 5000);
+        }));
+    it("should broadcast messages to group members", async ()=>new Promise((resolve, reject)=>{
+            let client1NodeId = null;
+            let messagesReceived = 0;
+            const client1 = new GatewayClient(`ws://localhost:${port}/ws`, "broadcaster", {
+                events: {
+                    registered: async (nodeId)=>{
+                        client1NodeId = nodeId;
+                        await client1.joinGroup("broadcast-test");
+                    },
+                    joinedGroup: ()=>{
+                        client2.connect().catch(reject);
+                    }
+                }
+            });
+            const client2 = new GatewayClient(`ws://localhost:${port}/ws`, "receiver", {
+                events: {
+                    registered: async ()=>{
+                        await client2.joinGroup("broadcast-test");
+                    },
+                    joinedGroup: ()=>{
+                        client1.broadcast("broadcast-test", {
+                            message: "Hello from client 1"
+                        });
+                    },
+                    broadcast: (message, fromNodeId)=>{
+                        expect(fromNodeId).toBe(client1NodeId);
+                        expect(message.message).toBe("Hello from client 1");
+                        messagesReceived++;
+                        client1.disconnect();
+                        client2.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client1.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Broadcast test timeout")), 10000);
+        }));
+    it("should handle ping/pong", async ()=>new Promise((resolve, reject)=>{
+            const client = new GatewayClient(`ws://localhost:${port}/ws`, "ping-test", {
+                events: {
+                    registered: ()=>{
+                        client.ping();
+                    },
+                    pong: ()=>{
+                        client.disconnect();
+                        resolve();
+                    },
+                    error: (error)=>{
+                        reject(new Error(error.message));
+                    }
+                }
+            });
+            client.connect().catch(reject);
+            setTimeout(()=>reject(new Error("Ping/pong timeout")), 5000);
+        }));
+    it("should stream agent events to session subscribers", async ()=>{
+        const subscriber = await connectClient("session-subscriber");
+        const sessionId = "session-test";
+        subscriber.send(JSON.stringify({
+            type: "session_subscribe",
+            payload: {
+                sessionId
+            },
+            timestamp: Date.now()
+        }));
+        await waitForMessage(subscriber, (msg)=>"ack" === msg.type && msg.payload?.action === "session_subscribe" && msg.payload?.sessionId === sessionId);
+        const eventPromise = waitForMessage(subscriber, (msg)=>"event:agent" === msg.type && "req-session" === msg.id);
+        const sent = server.broadcastSessionEvent(sessionId, {
+            type: "event:agent",
+            id: "req-session",
+            payload: {
+                type: "agent-stream",
+                sessionId,
+                agentId: "main",
+                chunk: {
+                    content: "hello"
+                }
+            },
+            timestamp: Date.now()
+        });
+        expect(sent).toBe(1);
+        const eventMsg = await eventPromise;
+        expect(eventMsg.payload?.sessionId).toBe(sessionId);
+        subscriber.close();
+    });
+    it("should broadcast user messages to session subscribers", async ()=>{
+        const subscriber = await connectClient("session-input-subscriber");
+        const requester = await connectClient("session-input-requester");
+        const sessionId = "session-input-test";
+        subscriber.send(JSON.stringify({
+            type: "session_subscribe",
+            payload: {
+                sessionId
+            },
+            timestamp: Date.now()
+        }));
+        await waitForMessage(subscriber, (msg)=>"ack" === msg.type && msg.payload?.action === "session_subscribe" && msg.payload?.sessionId === sessionId);
+        const eventPromise = waitForMessage(subscriber, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user");
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: "req-session-input",
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "Hello from test"
+            },
+            timestamp: Date.now()
+        }));
+        const eventMsg = await eventPromise;
+        expect(eventMsg.payload?.content).toBe("Hello from test");
+        expect(eventMsg.payload?.sessionId).toBe(sessionId);
+        expect(eventMsg.payload?.agentId).toBe("main");
+        subscriber.close();
+        requester.close();
+    });
+    it("should broadcast user messages to webui clients without session subscribe", async ()=>{
+        const webuiClient = await connectClient("session-webui-listener", "webui");
+        const requester = await connectClient("session-webui-requester");
+        const sessionId = "session-webui-test";
+        const eventPromise = waitForMessage(webuiClient, (msg)=>"event:agent" === msg.type && msg.payload?.type === "session-message" && msg.payload?.role === "user" && msg.payload?.sessionId === sessionId);
+        requester.send(JSON.stringify({
+            type: "req:agent",
+            id: "req-session-webui",
+            payload: {
+                agentId: "main",
+                sessionKey: sessionId,
+                content: "Hello webui"
+            },
+            timestamp: Date.now()
+        }));
+        const eventMsg = await eventPromise;
+        expect(eventMsg.payload?.content).toBe("Hello webui");
+        expect(eventMsg.payload?.agentId).toBe("main");
+        webuiClient.close();
+        requester.close();
+    });
+    it("should clear session messages via API", async ()=>{
+        const createRes = await fetch(`http://localhost:${port}/api/sessions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                agentId: "main",
+                name: "Clear Test"
+            })
+        });
+        expect(createRes.ok).toBe(true);
+        const session = await createRes.json();
+        const manager = await server.getSessionManager("main");
+        manager.updateSession(session.id, {
+            messageCount: 3,
+            lastMessagePreview: "Hello"
+        });
+        const clearRes = await fetch(`http://localhost:${port}/api/sessions/${encodeURIComponent(session.id)}/messages?agentId=main`, {
+            method: "DELETE"
+        });
+        expect(clearRes.ok).toBe(true);
+        const cleared = await clearRes.json();
+        expect(cleared.messageCount).toBe(0);
+        const updated = manager.getSession(session.id);
+        expect(updated?.messageCount).toBe(0);
+        expect(updated?.lastMessagePreview).toBeNull();
+    });
+});