@wingman-ai/gateway 0.1.0

package/dist/gateway/server.js

@@ -0,0 +1,1138 @@
+import { NodeManager } from "./node.js";
+import { BroadcastGroupManager } from "./broadcast.js";
+import { GatewayAuth } from "./auth.js";
+import { validateGatewayMessage } from "./validation.js";
+import { getGatewayTokenFromEnv } from "./env.js";
+import { MDNSDiscoveryService, TailscaleDiscoveryService } from "./discovery/index.js";
+import { createLogger } from "../logger.js";
+import { WingmanConfigLoader } from "../cli/config/loader.js";
+import { GatewayRouter } from "./router.js";
+import { OutputManager } from "../cli/core/outputManager.js";
+import { AgentInvoker } from "../cli/core/agentInvoker.js";
+import { SessionManager } from "../cli/core/sessionManager.js";
+import { handleAgentsApi } from "./http/agents.js";
+import { handleFsApi } from "./http/fs.js";
+import { handleProvidersApi } from "./http/providers.js";
+import { handleVoiceApi } from "./http/voice.js";
+import { handleSessionsApi } from "./http/sessions.js";
+import { createWebhookStore, handleWebhookInvoke, handleWebhooksApi } from "./http/webhooks.js";
+import { createRoutineStore, handleRoutinesApi } from "./http/routines.js";
+import { DiscordGatewayAdapter } from "./adapters/discord.js";
+import { InternalHookRegistry } from "./hooks/registry.js";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, normalize, sep } from "node:path";
+import { existsSync, mkdirSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+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 GatewayServer {
+    async start() {
+        if (void 0 === globalThis.Bun) throw new Error("Gateway server requires Bun runtime. Start with `bun ./bin/wingman gateway start`.");
+        this.startedAt = Date.now();
+        this.internalHooks = new InternalHookRegistry(this.getHttpContext(), this.wingmanConfig.hooks);
+        await this.internalHooks.load();
+        this.server = Bun.serve({
+            port: this.config.port,
+            hostname: this.config.host,
+            fetch: async (req, server)=>{
+                const url = new URL(req.url);
+                if ("/health" === url.pathname) return this.handleHealthCheck();
+                if ("/stats" === url.pathname) return this.handleStats();
+                if ("/bridge/send" === url.pathname) return this.handleBridgeSend(req);
+                if ("/bridge/poll" === url.pathname) return this.handleBridgePoll(req);
+                if ("/ws" === url.pathname) {
+                    const tailscaleUser = req.headers.get("tailscale-user-login") || req.headers.get("ts-user-login") || void 0;
+                    const upgraded = server.upgrade(req, {
+                        data: {
+                            nodeId: "",
+                            tailscaleUser
+                        }
+                    });
+                    if (!upgraded) return new Response("WebSocket upgrade failed", {
+                        status: 400
+                    });
+                    return;
+                }
+                const webhookResponse = await handleWebhookInvoke(this.getHttpContext(), this.webhookStore, req, url);
+                if (webhookResponse) return webhookResponse;
+                if (this.controlUiSamePort) return this.handleUiRequest(req);
+                return new Response("Not Found", {
+                    status: 404
+                });
+            },
+            websocket: {
+                open: (ws)=>this.handleOpen(ws),
+                message: (ws, message)=>this.handleMessage(ws, message),
+                close: (ws)=>this.handleClose(ws),
+                drain: (ws)=>this.handleDrain(ws)
+            }
+        });
+        this.startPingInterval();
+        if (this.controlUiEnabled && !this.controlUiSamePort) {
+            if (!this.uiDistDir) this.log("warn", "Control UI is enabled but build assets were not found. Run `bun run webui:build`.");
+            this.uiServer = Bun.serve({
+                port: this.controlUiPort,
+                hostname: this.config.host,
+                fetch: (req)=>this.handleUiRequest(req)
+            });
+            this.log("info", `Control UI started on ${this.config.host}:${this.controlUiPort}`);
+        } else if (this.controlUiEnabled) {
+            if (!this.uiDistDir) this.log("warn", "Control UI is enabled but build assets were not found. Run `bun run webui:build`.");
+            this.log("info", `Control UI available on ${this.config.host}:${this.config.port}`);
+        }
+        if (this.config.discovery?.enabled) await this.startDiscovery();
+        await this.startAdapters();
+        this.log("info", `Gateway started on ${this.config.host}:${this.config.port}`);
+        this.internalHooks?.emit({
+            type: "gateway",
+            action: "startup",
+            timestamp: new Date()
+        });
+    }
+    async stop() {
+        await this.stopAdapters();
+        if (this.discoveryService) {
+            await this.discoveryService.stopAnnouncing();
+            this.discoveryService = null;
+        }
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+        if (this.server) {
+            this.server.stop();
+            this.server = null;
+        }
+        if (this.uiServer) {
+            this.uiServer.stop();
+            this.uiServer = null;
+        }
+        this.log("info", "Gateway stopped");
+    }
+    async startAdapters() {
+        const discordConfig = this.wingmanConfig.gateway?.adapters?.discord;
+        if (discordConfig?.enabled) {
+            const resolvedHost = "0.0.0.0" === this.config.host || "::" === this.config.host ? "127.0.0.1" : this.config.host;
+            const url = discordConfig.gatewayUrl || `ws://${resolvedHost}:${this.config.port}/ws`;
+            const token = discordConfig.gatewayToken || (this.config.auth?.mode === "token" ? this.config.authToken : void 0);
+            const password = discordConfig.gatewayPassword || (this.config.auth?.mode === "password" ? this.config.auth?.password : void 0);
+            this.discordAdapter = new DiscordGatewayAdapter({
+                enabled: discordConfig.enabled,
+                token: discordConfig.token,
+                mentionOnly: discordConfig.mentionOnly ?? true,
+                allowBots: discordConfig.allowBots ?? false,
+                allowedGuilds: discordConfig.allowedGuilds ?? [],
+                allowedChannels: discordConfig.allowedChannels ?? [],
+                channelSessions: discordConfig.channelSessions ?? {},
+                sessionCommand: discordConfig.sessionCommand || "!session",
+                gatewayUrl: discordConfig.gatewayUrl,
+                gatewayToken: discordConfig.gatewayToken,
+                gatewayPassword: discordConfig.gatewayPassword,
+                responseChunkSize: discordConfig.responseChunkSize || 1900
+            }, {
+                url,
+                token,
+                password
+            }, this.logger);
+            try {
+                await this.discordAdapter.start();
+                this.log("info", "Discord adapter started");
+            } catch (error) {
+                this.log("error", "Failed to start Discord adapter", error);
+                this.discordAdapter = null;
+            }
+        }
+    }
+    async stopAdapters() {
+        if (this.discordAdapter) {
+            await this.discordAdapter.stop();
+            this.discordAdapter = null;
+        }
+    }
+    async startDiscovery() {
+        const discovery = this.config.discovery;
+        if (!discovery) return;
+        const discoveryConfig = {
+            name: discovery.name,
+            port: this.config.port,
+            requireAuth: this.auth.isAuthRequired(),
+            capabilities: [
+                "broadcast",
+                "direct",
+                "groups"
+            ],
+            version: "1.0.0",
+            transport: "0.0.0.0" === this.config.host ? "ws" : "wss"
+        };
+        if ("mdns" === discovery.method) {
+            this.discoveryService = new MDNSDiscoveryService();
+            await this.discoveryService.announce(discoveryConfig);
+            this.log("info", `mDNS discovery started: ${discovery.name}`);
+        } else if ("tailscale" === discovery.method) {
+            this.discoveryService = new TailscaleDiscoveryService();
+            await this.discoveryService.announce(discoveryConfig);
+            this.log("info", `Tailscale discovery started: ${discovery.name}`);
+        }
+    }
+    handleOpen(ws) {
+        this.log("debug", "New WebSocket connection");
+    }
+    handleMessage(ws, message) {
+        try {
+            const parsed = JSON.parse(message.toString());
+            const validation = validateGatewayMessage(parsed);
+            if (!validation.success) {
+                this.log("warn", "Invalid message format", validation.error);
+                this.sendError(ws, "INVALID_MESSAGE", validation.error);
+                return;
+            }
+            const msg = validation.data;
+            const nodeId = ws.data.nodeId;
+            if ("connect" === msg.type) return void this.handleConnect(ws, msg);
+            if ("req:agent" === msg.type) return void this.handleAgentRequest(ws, msg);
+            if (nodeId && "register" !== msg.type && "ping" !== msg.type && "pong" !== msg.type) {
+                if (this.nodeManager.isRateLimited(nodeId)) return void this.sendError(ws, "RATE_LIMITED", "Too many messages. Please slow down.");
+                this.nodeManager.recordMessage(nodeId);
+            }
+            this.messagesProcessed++;
+            this.log("debug", `Received message: ${msg.type}`, msg);
+            switch(msg.type){
+                case "register":
+                    this.handleRegister(ws, msg);
+                    break;
+                case "session_subscribe":
+                    this.handleSessionSubscribe(ws, msg);
+                    break;
+                case "session_unsubscribe":
+                    this.handleSessionUnsubscribe(ws, msg);
+                    break;
+                case "unregister":
+                    this.handleUnregister(ws, msg);
+                    break;
+                case "join_group":
+                    this.handleJoinGroup(ws, msg);
+                    break;
+                case "leave_group":
+                    this.handleLeaveGroup(ws, msg);
+                    break;
+                case "broadcast":
+                    this.handleBroadcast(ws, msg);
+                    break;
+                case "direct":
+                    this.handleDirect(ws, msg);
+                    break;
+                case "ping":
+                    this.handlePing(ws, msg);
+                    break;
+                case "pong":
+                    this.handlePong(ws, msg);
+                    break;
+                default:
+                    this.sendError(ws, "UNKNOWN_MESSAGE_TYPE", "Unknown message type");
+            }
+        } catch (error) {
+            this.log("error", "Failed to process message", error);
+            this.sendError(ws, "INVALID_MESSAGE", "Invalid message format");
+        }
+    }
+    handleClose(ws) {
+        const nodeId = ws.data.nodeId;
+        if (nodeId) {
+            this.groupManager.removeNodeFromAllGroups(nodeId);
+            this.nodeManager.unregisterNode(nodeId);
+            this.log("info", `Node disconnected: ${nodeId}`);
+        }
+        this.connectedClients.delete(ws);
+        this.clearSessionSubscriptions(ws);
+    }
+    handleDrain(ws) {
+        this.log("debug", "WebSocket drained");
+    }
+    handleConnect(ws, msg) {
+        if (!msg.id) return void this.sendError(ws, "INVALID_CONNECT", "Missing connect request id");
+        if (!msg.client) return void this.sendMessage(ws, {
+            type: "res",
+            id: msg.id,
+            ok: false,
+            payload: "missing client info",
+            timestamp: Date.now()
+        });
+        const allowed = this.auth.validate(msg.auth, ws.data.tailscaleUser);
+        if (!allowed) {
+            this.sendMessage(ws, {
+                type: "res",
+                id: msg.id,
+                ok: false,
+                payload: "authentication failed",
+                timestamp: Date.now()
+            });
+            ws.close();
+            return;
+        }
+        ws.data.clientId = msg.client.instanceId;
+        ws.data.clientType = msg.client.clientType;
+        ws.data.authenticated = true;
+        this.connectedClients.add(ws);
+        this.sendMessage(ws, {
+            type: "res",
+            id: msg.id,
+            ok: true,
+            payload: "gateway-ready",
+            timestamp: Date.now()
+        });
+    }
+    async handleAgentRequest(ws, msg) {
+        if (!msg.id) return void this.sendError(ws, "INVALID_REQUEST", "Missing request id");
+        if (!ws.data.authenticated) return void this.sendAgentError(ws, msg.id, "Client is not authenticated");
+        const payload = msg.payload;
+        const content = "string" == typeof payload?.content ? payload.content : "";
+        const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
+        const hasContent = content.trim().length > 0;
+        const hasAttachments = attachments.length > 0;
+        if (!hasContent && !hasAttachments) return void this.sendAgentError(ws, msg.id, "Missing agent content");
+        const agentId = this.router.selectAgent(payload.agentId, payload.routing);
+        if (!agentId) return void this.sendAgentError(ws, msg.id, "No agent matched the request");
+        const sessionKey = payload.sessionKey || this.router.buildSessionKey(agentId, payload.routing);
+        const sessionManager = await this.getSessionManager(agentId);
+        const existingSession = sessionManager.getSession(sessionKey);
+        const session = existingSession || sessionManager.getOrCreateSession(sessionKey, agentId);
+        const workdir = session.metadata?.workdir ?? null;
+        const defaultOutputDir = this.resolveDefaultOutputDir(agentId);
+        const preview = hasContent ? content.trim() : buildAttachmentPreview(attachments);
+        sessionManager.updateSession(session.id, {
+            lastMessagePreview: preview.substring(0, 200)
+        });
+        if (!existingSession) this.internalHooks?.emit({
+            type: "session",
+            action: "start",
+            timestamp: new Date(),
+            agentId,
+            sessionKey,
+            routing: payload.routing
+        });
+        this.internalHooks?.emit({
+            type: "message",
+            action: "received",
+            timestamp: new Date(),
+            agentId,
+            sessionKey,
+            routing: payload.routing,
+            payload: {
+                content,
+                attachments
+            }
+        });
+        const sessionMessage = {
+            type: "event:agent",
+            id: msg.id,
+            payload: this.attachSessionContext({
+                type: "session-message",
+                role: "user",
+                content,
+                attachments,
+                routing: payload.routing
+            }, sessionKey, agentId),
+            timestamp: Date.now()
+        };
+        this.broadcastSessionEvent(sessionKey, sessionMessage, ws);
+        this.broadcastToClients(sessionMessage, {
+            exclude: ws,
+            clientType: "webui",
+            skipSessionId: sessionKey
+        });
+        const outputManager = new OutputManager("interactive");
+        const outputHandler = (event)=>{
+            const payloadWithSession = this.attachSessionContext(event, sessionKey, agentId);
+            const baseMessage = {
+                type: "event:agent",
+                id: msg.id,
+                payload: payloadWithSession,
+                timestamp: Date.now()
+            };
+            this.sendMessage(ws, {
+                ...baseMessage,
+                clientId: ws.data.clientId
+            });
+            this.broadcastSessionEvent(sessionKey, baseMessage, ws);
+        };
+        outputManager.on("output-event", outputHandler);
+        const workspace = this.resolveAgentWorkspace(agentId);
+        const invoker = new AgentInvoker({
+            workspace,
+            configDir: this.configDir,
+            outputManager,
+            logger: this.logger,
+            sessionManager,
+            workdir,
+            defaultOutputDir
+        });
+        try {
+            await invoker.invokeAgent(agentId, content, sessionKey, attachments);
+            const updated = sessionManager.getSession(sessionKey);
+            if (updated) sessionManager.updateSession(sessionKey, {
+                messageCount: updated.messageCount + 1
+            });
+        } catch (error) {
+            this.logger.error("Agent invocation failed", error);
+        } finally{
+            outputManager.off("output-event", outputHandler);
+        }
+    }
+    handleRegister(ws, msg) {
+        const payload = msg.payload;
+        if (!this.auth.validate({
+            token: payload.token
+        }, ws.data.tailscaleUser)) {
+            this.sendError(ws, "AUTH_FAILED", "Authentication failed");
+            ws.close();
+            return;
+        }
+        const node = this.nodeManager.registerNode(ws, payload.name, payload.capabilities, payload.sessionId, payload.agentName);
+        if (!node) {
+            this.sendError(ws, "MAX_NODES_REACHED", "Maximum nodes reached");
+            ws.close();
+            return;
+        }
+        this.sendMessage(ws, {
+            type: "ack",
+            nodeId: node.id,
+            payload: {
+                nodeId: node.id,
+                name: node.name,
+                sessionId: node.sessionId,
+                agentName: node.agentName
+            },
+            timestamp: Date.now()
+        });
+        const sessionInfo = node.sessionId ? ` (session: ${node.sessionId})` : "";
+        this.log("info", `Node registered: ${node.id} (${node.name})${sessionInfo}`);
+    }
+    handleSessionSubscribe(ws, msg) {
+        if (!ws.data.authenticated) return void this.sendError(ws, "AUTH_REQUIRED", "Client is not authenticated");
+        const payload = msg.payload;
+        const sessionId = "string" == typeof payload?.sessionId ? payload.sessionId.trim() : "";
+        if (!sessionId) return void this.sendError(ws, "INVALID_REQUEST", "Missing sessionId");
+        this.addSessionSubscription(ws, sessionId);
+        this.sendMessage(ws, {
+            type: "ack",
+            payload: {
+                action: "session_subscribe",
+                sessionId
+            },
+            timestamp: Date.now()
+        });
+    }
+    handleSessionUnsubscribe(ws, msg) {
+        if (!ws.data.authenticated) return void this.sendError(ws, "AUTH_REQUIRED", "Client is not authenticated");
+        const payload = msg.payload;
+        const sessionId = "string" == typeof payload?.sessionId ? payload.sessionId.trim() : "";
+        if (!sessionId) return void this.sendError(ws, "INVALID_REQUEST", "Missing sessionId");
+        this.removeSessionSubscription(ws, sessionId);
+        this.sendMessage(ws, {
+            type: "ack",
+            payload: {
+                action: "session_unsubscribe",
+                sessionId
+            },
+            timestamp: Date.now()
+        });
+    }
+    handleUnregister(ws, msg) {
+        const nodeId = ws.data.nodeId;
+        if (nodeId) {
+            this.groupManager.removeNodeFromAllGroups(nodeId);
+            this.nodeManager.unregisterNode(nodeId);
+            this.log("info", `Node unregistered: ${nodeId}`);
+        }
+    }
+    handleJoinGroup(ws, msg) {
+        const nodeId = ws.data.nodeId;
+        if (!nodeId) return void this.sendError(ws, "NOT_REGISTERED", "Node not registered");
+        const payload = msg.payload;
+        let group;
+        if (payload.groupId) group = this.groupManager.getGroup(payload.groupId);
+        else if (payload.groupName) group = payload.createIfNotExists ? this.groupManager.getOrCreateGroup(payload.groupName, nodeId, payload.description) : this.groupManager.getGroupByName(payload.groupName);
+        if (!group) return void this.sendError(ws, "GROUP_NOT_FOUND", "Group not found");
+        this.groupManager.addNodeToGroup(group.id, nodeId);
+        this.nodeManager.addNodeToGroup(nodeId, group.id);
+        this.sendMessage(ws, {
+            type: "ack",
+            nodeId,
+            groupId: group.id,
+            payload: {
+                groupId: group.id,
+                groupName: group.name
+            },
+            timestamp: Date.now()
+        });
+        this.log("info", `Node ${nodeId} joined group ${group.name}`);
+    }
+    handleLeaveGroup(ws, msg) {
+        const nodeId = ws.data.nodeId;
+        if (!nodeId || !msg.groupId) return void this.sendError(ws, "INVALID_REQUEST", "Invalid leave group request");
+        this.groupManager.removeNodeFromGroup(msg.groupId, nodeId);
+        this.nodeManager.removeNodeFromGroup(nodeId, msg.groupId);
+        this.sendMessage(ws, {
+            type: "ack",
+            nodeId,
+            groupId: msg.groupId,
+            timestamp: Date.now()
+        });
+        this.log("info", `Node ${nodeId} left group ${msg.groupId}`);
+    }
+    handleBroadcast(ws, msg) {
+        const nodeId = ws.data.nodeId;
+        if (!nodeId) return void this.sendError(ws, "NOT_REGISTERED", "Node not registered");
+        const payload = msg.payload;
+        const members = this.groupManager.getGroupMembers(payload.groupId);
+        const recipients = members.filter((id)=>id !== nodeId);
+        const broadcastMsg = {
+            type: "broadcast",
+            nodeId,
+            groupId: payload.groupId,
+            payload: payload.message,
+            timestamp: Date.now()
+        };
+        const sent = this.nodeManager.broadcastToNodes(recipients, broadcastMsg);
+        this.log("debug", `Broadcast to ${sent}/${recipients.length} nodes in group ${payload.groupId}`);
+    }
+    handleDirect(ws, msg) {
+        const nodeId = ws.data.nodeId;
+        if (!nodeId) return void this.sendError(ws, "NOT_REGISTERED", "Node not registered");
+        const payload = msg.payload;
+        const directMsg = {
+            type: "direct",
+            nodeId,
+            targetNodeId: payload.targetNodeId,
+            payload: payload.message,
+            timestamp: Date.now()
+        };
+        const sent = this.nodeManager.sendToNode(payload.targetNodeId, directMsg);
+        if (!sent) this.sendError(ws, "NODE_NOT_FOUND", "Target node not found");
+    }
+    handlePing(ws, msg) {
+        const nodeId = ws.data.nodeId;
+        if (nodeId) this.nodeManager.updatePing(nodeId);
+        this.sendMessage(ws, {
+            type: "pong",
+            timestamp: Date.now()
+        });
+    }
+    handlePong(ws, msg) {
+        const nodeId = ws.data.nodeId;
+        if (nodeId) this.nodeManager.updatePing(nodeId);
+    }
+    sendMessage(ws, message) {
+        try {
+            ws.send(JSON.stringify(message));
+        } catch (error) {
+            this.log("error", "Failed to send message", error);
+        }
+    }
+    sendError(ws, code, message) {
+        const errorPayload = {
+            code,
+            message
+        };
+        this.sendMessage(ws, {
+            type: "error",
+            payload: errorPayload,
+            timestamp: Date.now()
+        });
+    }
+    sendAgentError(ws, requestId, message) {
+        this.sendMessage(ws, {
+            type: "event:agent",
+            id: requestId,
+            payload: {
+                type: "agent-error",
+                error: message,
+                timestamp: new Date().toISOString()
+            },
+            timestamp: Date.now()
+        });
+    }
+    attachSessionContext(event, sessionId, agentId) {
+        if (event && "object" == typeof event && !Array.isArray(event)) return {
+            ...event,
+            sessionId,
+            agentId
+        };
+        return {
+            type: "agent-event",
+            data: event,
+            sessionId,
+            agentId
+        };
+    }
+    broadcastSessionEvent(sessionId, message, exclude) {
+        const subscribers = this.sessionSubscriptions.get(sessionId);
+        if (!subscribers || 0 === subscribers.size) return 0;
+        let sent = 0;
+        for (const ws of subscribers)if (!exclude || ws !== exclude) {
+            this.sendMessage(ws, message);
+            sent++;
+        }
+        return sent;
+    }
+    broadcastToClients(message, options) {
+        let sent = 0;
+        for (const ws of this.connectedClients)if (!options?.exclude || ws !== options.exclude) {
+            if (!options?.clientType || ws.data.clientType === options.clientType) {
+                if (options?.skipSessionId) {
+                    const subscribers = this.sessionSubscriptions.get(options.skipSessionId);
+                    if (subscribers?.has(ws)) continue;
+                }
+                this.sendMessage(ws, message);
+                sent++;
+            }
+        }
+        return sent;
+    }
+    addSessionSubscription(ws, sessionId) {
+        let subscribers = this.sessionSubscriptions.get(sessionId);
+        if (!subscribers) {
+            subscribers = new Set();
+            this.sessionSubscriptions.set(sessionId, subscribers);
+        }
+        subscribers.add(ws);
+        let socketSessions = this.socketSubscriptions.get(ws);
+        if (!socketSessions) {
+            socketSessions = new Set();
+            this.socketSubscriptions.set(ws, socketSessions);
+        }
+        socketSessions.add(sessionId);
+    }
+    removeSessionSubscription(ws, sessionId) {
+        const subscribers = this.sessionSubscriptions.get(sessionId);
+        if (subscribers) {
+            subscribers.delete(ws);
+            if (0 === subscribers.size) this.sessionSubscriptions.delete(sessionId);
+        }
+        const socketSessions = this.socketSubscriptions.get(ws);
+        if (socketSessions) {
+            socketSessions.delete(sessionId);
+            if (0 === socketSessions.size) this.socketSubscriptions.delete(ws);
+        }
+    }
+    clearSessionSubscriptions(ws) {
+        const sessions = this.socketSubscriptions.get(ws);
+        if (!sessions) return;
+        for (const sessionId of sessions){
+            const subscribers = this.sessionSubscriptions.get(sessionId);
+            if (subscribers) {
+                subscribers.delete(ws);
+                if (0 === subscribers.size) this.sessionSubscriptions.delete(sessionId);
+            }
+        }
+        this.socketSubscriptions.delete(ws);
+    }
+    resolveStateDir() {
+        const configured = this.config.stateDir || this.wingmanConfig.gateway?.stateDir;
+        const fallback = join(homedir(), ".wingman");
+        const raw = configured || fallback;
+        if (raw.startsWith("~/")) return join(homedir(), raw.slice(2));
+        if (isAbsolute(raw)) return raw;
+        return join(this.workspace, raw);
+    }
+    resolveAgentWorkspace(agentId) {
+        const agents = this.wingmanConfig.agents?.list || [];
+        const match = agents.find((agent)=>agent.id === agentId);
+        return match?.workspace || this.workspace;
+    }
+    resolveConfigDirPath() {
+        return isAbsolute(this.configDir) ? this.configDir : join(this.workspace, this.configDir);
+    }
+    getHttpContext() {
+        return {
+            workspace: this.workspace,
+            configDir: this.configDir,
+            getWingmanConfig: ()=>this.wingmanConfig,
+            setWingmanConfig: (config)=>{
+                this.wingmanConfig = config;
+            },
+            persistWingmanConfig: ()=>this.persistWingmanConfig(),
+            router: this.router,
+            setRouter: (router)=>{
+                this.router = router;
+            },
+            auth: this.auth,
+            logger: this.logger,
+            getSessionManager: (agentId)=>this.getSessionManager(agentId),
+            resolveConfigDirPath: ()=>this.resolveConfigDirPath(),
+            resolveOutputRoot: ()=>this.resolveOutputRoot(),
+            resolveDefaultOutputDir: (agentId)=>this.resolveDefaultOutputDir(agentId),
+            resolveAgentWorkspace: (agentId)=>this.resolveAgentWorkspace(agentId),
+            resolveFsRoots: ()=>this.resolveFsRoots(),
+            resolveFsPath: (path)=>this.resolveFsPath(path),
+            isPathWithinRoots: (path, roots)=>this.isPathWithinRoots(path, roots),
+            getBuiltInTools: ()=>this.getBuiltInTools()
+        };
+    }
+    persistWingmanConfig() {
+        const configDir = this.resolveConfigDirPath();
+        mkdirSync(configDir, {
+            recursive: true
+        });
+        const configPath = join(configDir, "wingman.config.json");
+        writeFileSync(configPath, JSON.stringify(this.wingmanConfig, null, 2));
+    }
+    getBuiltInTools() {
+        return [
+            "ls",
+            "read_file",
+            "write_file",
+            "edit_file",
+            "glob",
+            "grep"
+        ];
+    }
+    resolveOutputRoot() {
+        const root = join(this.resolveStateDir(), "outputs");
+        mkdirSync(root, {
+            recursive: true
+        });
+        return root;
+    }
+    resolveDefaultOutputDir(agentId) {
+        const root = this.resolveOutputRoot();
+        const dir = join(root, agentId);
+        mkdirSync(dir, {
+            recursive: true
+        });
+        return dir;
+    }
+    resolveFsRoots() {
+        const configured = this.wingmanConfig.gateway?.fsRoots || [];
+        const candidates = configured.length > 0 ? configured : [
+            this.resolveOutputRoot()
+        ];
+        const resolved = candidates.map((entry)=>this.resolveFsPath(entry)).filter((entry)=>{
+            try {
+                return existsSync(entry) && statSync(entry).isDirectory();
+            } catch  {
+                return false;
+            }
+        });
+        return Array.from(new Set(resolved));
+    }
+    resolveFsPath(raw) {
+        if ("~" === raw) return normalize(homedir());
+        if (raw.startsWith("~/")) return normalize(join(homedir(), raw.slice(2)));
+        if (isAbsolute(raw)) return normalize(raw);
+        return normalize(join(this.workspace, raw));
+    }
+    isPathWithinRoots(pathname, roots) {
+        const normalized = normalize(pathname);
+        return roots.some((root)=>{
+            const normalizedRoot = normalize(root);
+            return normalized === normalizedRoot || normalized.startsWith(normalizedRoot + sep);
+        });
+    }
+    resolveControlUiDir() {
+        const moduleDir = dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            join(this.workspace, "dist", "webui"),
+            join(moduleDir, "..", "webui"),
+            join(moduleDir, "..", "..", "dist", "webui")
+        ];
+        for (const candidate of candidates)try {
+            if (existsSync(candidate) && statSync(candidate).isDirectory() && existsSync(join(candidate, "index.html"))) return candidate;
+        } catch  {
+            continue;
+        }
+        return null;
+    }
+    async getSessionManager(agentId) {
+        const existing = this.sessionManagers.get(agentId);
+        if (existing) return existing;
+        const stateDir = this.resolveStateDir();
+        const sessionsDir = join(stateDir, "agents", agentId, "sessions");
+        mkdirSync(sessionsDir, {
+            recursive: true
+        });
+        const dbPath = join(sessionsDir, "wingman.db");
+        const manager = new SessionManager(dbPath);
+        await manager.initialize();
+        this.sessionManagers.set(agentId, manager);
+        return manager;
+    }
+    handleHealthCheck() {
+        const stats = this.getStats();
+        const health = {
+            status: "healthy",
+            version: "1.0.0",
+            stats,
+            timestamp: Date.now()
+        };
+        return new Response(JSON.stringify(health, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    handleStats() {
+        const stats = {
+            gateway: this.getStats(),
+            nodes: this.nodeManager.getStats(),
+            groups: this.groupManager.getStats()
+        };
+        return new Response(JSON.stringify(stats, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    getStats() {
+        const nodeStats = this.nodeManager.getStats();
+        return {
+            uptime: Date.now() - this.startedAt,
+            totalNodes: nodeStats.totalNodes,
+            totalGroups: this.groupManager.getStats().totalGroups,
+            messagesProcessed: this.messagesProcessed,
+            startedAt: this.startedAt,
+            activeSessions: nodeStats.activeSessions,
+            sessionNodes: nodeStats.sessionNodes
+        };
+    }
+    startPingInterval() {
+        if (this.pingInterval) clearInterval(this.pingInterval);
+        this.pingInterval = setInterval(()=>{
+            const nodes = this.nodeManager.getAllNodes();
+            for (const node of nodes)this.sendMessage(node.ws, {
+                type: "ping",
+                timestamp: Date.now()
+            });
+            const removed = this.nodeManager.removeStaleNodes(this.config.pingTimeout);
+            if (removed > 0) this.log("info", `Removed ${removed} stale nodes`);
+        }, this.config.pingInterval);
+    }
+    log(level, message, data) {
+        if ("silent" === level) return;
+        const args = void 0 === data ? [] : [
+            data
+        ];
+        switch(level){
+            case "debug":
+                this.logger.debug(message, ...args);
+                break;
+            case "info":
+                this.logger.info(message, ...args);
+                break;
+            case "warn":
+                this.logger.warn(message, ...args);
+                break;
+            case "error":
+                this.logger.error(message, ...args);
+                break;
+        }
+    }
+    async handleUiRequest(req) {
+        const url = new URL(req.url);
+        const ctx = this.getHttpContext();
+        const webhookResponse = await handleWebhookInvoke(ctx, this.webhookStore, req, url);
+        if (webhookResponse) return webhookResponse;
+        if (url.pathname.startsWith("/api/")) {
+            if ("/api/config" === url.pathname) {
+                const agents = this.wingmanConfig.agents?.list?.map((agent)=>({
+                        id: agent.id,
+                        name: agent.name,
+                        default: agent.default
+                    })) || [];
+                const defaultAgentId = this.router.selectAgent();
+                return new Response(JSON.stringify({
+                    gatewayHost: this.config.host,
+                    gatewayPort: this.config.port,
+                    requireAuth: this.auth.isAuthRequired(),
+                    defaultAgentId,
+                    outputRoot: this.resolveOutputRoot(),
+                    voice: this.wingmanConfig.voice,
+                    agents
+                }, null, 2), {
+                    headers: {
+                        "Content-Type": "application/json"
+                    }
+                });
+            }
+            const apiResponse = await handleWebhooksApi(ctx, this.webhookStore, req, url) || await handleRoutinesApi(ctx, this.routineStore, req, url) || await handleAgentsApi(ctx, req, url) || await handleProvidersApi(ctx, req, url) || await handleVoiceApi(ctx, req, url) || await handleFsApi(ctx, req, url) || await handleSessionsApi(ctx, req, url);
+            if (apiResponse) return apiResponse;
+            if ("/api/health" === url.pathname) return this.handleHealthCheck();
+            if ("/api/stats" === url.pathname) return this.handleStats();
+            return new Response("Not Found", {
+                status: 404
+            });
+        }
+        if ("GET" !== req.method) return new Response("Method Not Allowed", {
+            status: 405
+        });
+        if ("/ui" === url.pathname || "/ui/" === url.pathname) return new Response(null, {
+            status: 302,
+            headers: {
+                Location: "/"
+            }
+        });
+        if (!this.uiDistDir) return new Response("Control UI build not found", {
+            status: 404
+        });
+        const relativePath = "/" === url.pathname || "/index.html" === url.pathname ? "index.html" : url.pathname.replace(/^\/+/, "");
+        const candidate = normalize(join(this.uiDistDir, relativePath));
+        if (!candidate.startsWith(this.uiDistDir)) return new Response("Invalid path", {
+            status: 400
+        });
+        if (!existsSync(candidate) || !statSync(candidate).isFile()) {
+            const isAssetRequest = relativePath.startsWith("assets/") || relativePath.includes(".");
+            if (!isAssetRequest) {
+                const indexPath = normalize(join(this.uiDistDir, "index.html"));
+                if (existsSync(indexPath) && statSync(indexPath).isFile()) return new Response(Bun.file(indexPath), {
+                    headers: {
+                        "Cache-Control": "no-store",
+                        "Content-Type": "text/html; charset=utf-8"
+                    }
+                });
+            }
+            return new Response("Not Found", {
+                status: 404
+            });
+        }
+        const file = Bun.file(candidate);
+        const headers = {
+            "Cache-Control": "no-store"
+        };
+        if ("index.html" === relativePath) headers["Content-Type"] = "text/html; charset=utf-8";
+        return new Response(file, {
+            headers
+        });
+    }
+    getAuth() {
+        return this.auth;
+    }
+    getConfig() {
+        return this.config;
+    }
+    async handleBridgeSend(req) {
+        try {
+            const message = await req.json();
+            const validation = validateGatewayMessage(message);
+            if (!validation.success) return new Response(JSON.stringify({
+                error: validation.error
+            }), {
+                status: 400,
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+            const validatedMessage = validation.data;
+            if ("register" === validatedMessage.type) {
+                const payload = validatedMessage.payload;
+                const nodeId = this.generateNodeId();
+                this.bridgeQueues.set(nodeId, []);
+                const response = {
+                    type: "registered",
+                    nodeId,
+                    timestamp: Date.now()
+                };
+                this.log("info", `HTTP bridge node registered: ${payload.name}`);
+                return new Response(JSON.stringify(response), {
+                    status: 200,
+                    headers: {
+                        "Content-Type": "application/json"
+                    }
+                });
+            }
+            const nodeId = validatedMessage.nodeId;
+            if (!nodeId) return new Response(JSON.stringify({
+                error: "nodeId required"
+            }), {
+                status: 400,
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+            this.messagesProcessed++;
+            return new Response(JSON.stringify({
+                success: true
+            }), {
+                status: 200,
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        } catch (error) {
+            return new Response(JSON.stringify({
+                error: error instanceof Error ? error.message : "Unknown error"
+            }), {
+                status: 500,
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+    }
+    async handleBridgePoll(req) {
+        try {
+            const nodeId = req.headers.get("X-Node-ID");
+            if (!nodeId) return new Response(JSON.stringify({
+                error: "X-Node-ID header required"
+            }), {
+                status: 400,
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+            const queue = this.bridgeQueues.get(nodeId);
+            if (!queue) return new Response(JSON.stringify({
+                error: "Node not registered"
+            }), {
+                status: 404,
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+            if (queue.length > 0) {
+                const messages = [
+                    ...queue
+                ];
+                queue.length = 0;
+                return new Response(JSON.stringify(messages), {
+                    status: 200,
+                    headers: {
+                        "Content-Type": "application/json"
+                    }
+                });
+            }
+            const messages = await new Promise((resolve)=>{
+                const timeout = setTimeout(()=>{
+                    this.bridgePollWaiters.delete(nodeId);
+                    resolve([]);
+                }, 30000);
+                this.bridgePollWaiters.set(nodeId, (msgs)=>{
+                    clearTimeout(timeout);
+                    resolve(msgs);
+                });
+            });
+            return new Response(JSON.stringify(messages), {
+                status: 200,
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        } catch (error) {
+            return new Response(JSON.stringify({
+                error: error instanceof Error ? error.message : "Unknown error"
+            }), {
+                status: 500,
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+    }
+    generateNodeId() {
+        return `node-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+    }
+    constructor(config = {}){
+        _define_property(this, "config", void 0);
+        _define_property(this, "nodeManager", void 0);
+        _define_property(this, "groupManager", void 0);
+        _define_property(this, "auth", void 0);
+        _define_property(this, "server", null);
+        _define_property(this, "startedAt", 0);
+        _define_property(this, "messagesProcessed", 0);
+        _define_property(this, "pingInterval", null);
+        _define_property(this, "discoveryService", null);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "wingmanConfig", void 0);
+        _define_property(this, "router", void 0);
+        _define_property(this, "sessionManagers", new Map());
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "uiServer", null);
+        _define_property(this, "controlUiEnabled", false);
+        _define_property(this, "controlUiPort", 18790);
+        _define_property(this, "controlUiSamePort", false);
+        _define_property(this, "uiDistDir", null);
+        _define_property(this, "webhookStore", void 0);
+        _define_property(this, "routineStore", void 0);
+        _define_property(this, "internalHooks", null);
+        _define_property(this, "discordAdapter", null);
+        _define_property(this, "sessionSubscriptions", new Map());
+        _define_property(this, "socketSubscriptions", new Map());
+        _define_property(this, "connectedClients", new Set());
+        _define_property(this, "bridgeQueues", new Map());
+        _define_property(this, "bridgePollWaiters", new Map());
+        this.workspace = config.workspace || process.cwd();
+        this.configDir = config.configDir || ".wingman";
+        const configLoader = new WingmanConfigLoader(this.configDir, this.workspace);
+        this.wingmanConfig = configLoader.loadConfig();
+        this.router = new GatewayRouter(this.wingmanConfig);
+        this.webhookStore = createWebhookStore(()=>this.resolveConfigDirPath());
+        this.routineStore = createRoutineStore(()=>this.resolveConfigDirPath());
+        const gatewayDefaults = this.wingmanConfig.gateway;
+        const envToken = getGatewayTokenFromEnv();
+        const authFromConfig = config.auth?.mode === "token" ? {
+            ...config.auth,
+            token: config.auth.token ?? envToken
+        } : config.auth;
+        const legacyToken = config.authToken ?? envToken;
+        const authConfig = authFromConfig ? authFromConfig : config.requireAuth || config.authToken ? {
+            mode: "token",
+            token: legacyToken
+        } : gatewayDefaults.auth;
+        const resolvedAuthToken = authConfig?.mode === "token" ? authConfig.token ?? legacyToken : void 0;
+        this.config = {
+            port: config.port ?? gatewayDefaults.port ?? 18789,
+            host: config.host || gatewayDefaults.host || "127.0.0.1",
+            authToken: resolvedAuthToken,
+            requireAuth: config.requireAuth ?? false,
+            auth: authConfig,
+            stateDir: config.stateDir || gatewayDefaults.stateDir,
+            workspace: this.workspace,
+            configDir: this.configDir,
+            maxNodes: config.maxNodes || 1000,
+            pingInterval: config.pingInterval || 30000,
+            pingTimeout: config.pingTimeout || 60000,
+            logLevel: config.logLevel || "info",
+            discovery: config.discovery
+        };
+        this.nodeManager = new NodeManager(this.config.maxNodes);
+        this.groupManager = new BroadcastGroupManager();
+        this.logger = createLogger(this.config.logLevel);
+        const initialTokens = this.config.authToken ? [
+            this.config.authToken
+        ] : [];
+        this.auth = new GatewayAuth(this.config.auth || {
+            mode: "none"
+        }, initialTokens);
+        const controlUi = this.wingmanConfig.gateway?.controlUi;
+        this.controlUiEnabled = controlUi?.enabled ?? false;
+        this.controlUiPort = controlUi?.port || 18790;
+        this.controlUiSamePort = this.controlUiEnabled && this.controlUiPort === this.config.port;
+        this.uiDistDir = this.controlUiEnabled ? this.resolveControlUiDir() : null;
+    }
+}
+function buildAttachmentPreview(attachments) {
+    if (!attachments || 0 === attachments.length) return "Attachment";
+    let hasAudio = false;
+    let hasImage = false;
+    for (const attachment of attachments)if (isAudioAttachment(attachment)) hasAudio = true;
+    else hasImage = true;
+    const count = attachments.length;
+    if (hasAudio && hasImage) return count > 1 ? "Media attachments" : "Media attachment";
+    if (hasAudio) return count > 1 ? "Audio attachments" : "Audio attachment";
+    return count > 1 ? "Image attachments" : "Image attachment";
+}
+function isAudioAttachment(attachment) {
+    if ("audio" === attachment.kind) return true;
+    if (attachment.mimeType?.startsWith("audio/")) return true;
+    if (attachment.dataUrl?.startsWith("data:audio/")) return true;
+    return false;
+}
+export { GatewayServer };