@wingman-ai/gateway 0.2.5 → 0.3.1

package/dist/gateway/server.cjs

@@ -27,7 +27,9 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    GatewayServer: ()=>GatewayServer
+    resolveExecutionWorkspaceOverride: ()=>resolveExecutionWorkspaceOverride,
+    GatewayServer: ()=>GatewayServer,
+    resolveExecutionConfigDirOverride: ()=>resolveExecutionConfigDirOverride
 });
 const external_node_fs_namespaceObject = require("node:fs");
 const external_node_os_namespaceObject = require("node:os");
@@ -41,6 +43,7 @@ const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.c
 const external_logger_cjs_namespaceObject = require("../logger.cjs");
 const discord_cjs_namespaceObject = require("./adapters/discord.cjs");
 const external_auth_cjs_namespaceObject = require("./auth.cjs");
+const external_browserRelayServer_cjs_namespaceObject = require("./browserRelayServer.cjs");
 const external_broadcast_cjs_namespaceObject = require("./broadcast.cjs");
 const index_cjs_namespaceObject = require("./discovery/index.cjs");
 const external_env_cjs_namespaceObject = require("./env.cjs");
@@ -80,6 +83,19 @@ function withApiCors(response) {
         headers
     });
 }
+function resolveExecutionWorkspaceOverride(payload) {
+    const rawWorkspace = payload?.execution?.workspace;
+    if ("string" != typeof rawWorkspace) return null;
+    const trimmed = rawWorkspace.trim();
+    if (!trimmed || !(0, external_node_path_namespaceObject.isAbsolute)(trimmed)) return null;
+    return (0, external_node_path_namespaceObject.normalize)(trimmed);
+}
+function resolveExecutionConfigDirOverride(payload) {
+    const rawConfigDir = payload?.execution?.configDir;
+    if ("string" != typeof rawConfigDir) return null;
+    const trimmed = rawConfigDir.trim();
+    return trimmed || null;
+}
 class GatewayServer {
     async start() {
         if (void 0 === globalThis.Bun) throw new Error("Gateway server requires Bun runtime. Start with `bun ./bin/wingman gateway start`.");
@@ -137,6 +153,7 @@ class GatewayServer {
             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}`);
         }
+        this.browserRelayServer?.start();
         if (this.config.discovery?.enabled) await this.startDiscovery();
         await this.startAdapters();
         this.log("info", `Gateway started on ${this.config.host}:${this.config.port}`);
@@ -165,6 +182,7 @@ class GatewayServer {
             this.uiServer.stop();
             this.uiServer = null;
         }
+        if (this.browserRelayServer) this.browserRelayServer.stop();
         this.terminalSessionManager.dispose();
         this.log("info", "Gateway stopped");
     }
@@ -357,6 +375,8 @@ class GatewayServer {
         const payload = msg.payload;
         const content = "string" == typeof payload?.content ? payload.content : "";
         const attachments = Array.isArray(payload?.attachments) ? payload.attachments : [];
+        const workspaceOverride = resolveExecutionWorkspaceOverride(payload);
+        const configDirOverride = resolveExecutionConfigDirOverride(payload);
         const hasContent = content.trim().length > 0;
         const hasAttachments = attachments.length > 0;
         if (!hasContent && !hasAttachments) return void this.sendAgentError(ws, msg.id, "Missing agent content");
@@ -367,12 +387,29 @@ class GatewayServer {
         const sessionManager = await this.getSessionManager(agentId);
         const existingSession = sessionManager.getSession(sessionKey);
         const session = existingSession || sessionManager.getOrCreateSession(sessionKey, agentId);
+        const requestId = msg.id || `req-${Date.now()}`;
         const workdir = session.metadata?.workdir ?? null;
         const defaultOutputDir = this.resolveDefaultOutputDir(agentId);
         const preview = hasContent ? content.trim() : buildAttachmentPreview(attachments);
         sessionManager.updateSession(session.id, {
+            messageCount: (session.messageCount ?? 0) + 1,
             lastMessagePreview: preview.substring(0, 200)
         });
+        try {
+            sessionManager.persistPendingMessage({
+                sessionId: sessionKey,
+                requestId,
+                message: {
+                    id: `user-${requestId}`,
+                    role: "user",
+                    content,
+                    attachments: attachments.length > 0 ? mapAttachmentsForPendingMessage(attachments) : void 0,
+                    createdAt: Date.now()
+                }
+            });
+        } catch (error) {
+            this.logger.warn("Failed to persist pending user message", error);
+        }
         if (!existingSession) this.internalHooks?.emit({
             type: "session",
             action: "start",
@@ -425,7 +462,9 @@ class GatewayServer {
             attachments,
             sessionManager,
             workdir,
-            defaultOutputDir
+            defaultOutputDir,
+            workspaceOverride,
+            configDirOverride
         };
         this.requestSessionKeys.set(msg.id, sessionQueueKey);
         const queueIfBusy = false !== payload.queueIfBusy;
@@ -471,13 +510,19 @@ class GatewayServer {
         this.executeAgentRequest(request);
     }
     async executeAgentRequest(request) {
-        const { ws, msg, agentId, sessionKey, sessionQueueKey, content, attachments, sessionManager, workdir, defaultOutputDir } = request;
+        const { ws, msg, agentId, sessionKey, sessionQueueKey, content, attachments, sessionManager, workdir, defaultOutputDir, workspaceOverride, configDirOverride } = request;
         this.activeSessionRequests.set(sessionQueueKey, msg.id);
         const outputManager = new outputManager_cjs_namespaceObject.OutputManager("interactive");
         let emittedAgentError = false;
+        let streamedCompletionResult;
         const outputHandler = (event)=>{
             const payloadWithSession = this.attachSessionContext(event, sessionKey, agentId);
-            if (payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession) && "agent-error" === payloadWithSession.type) emittedAgentError = true;
+            const payloadType = payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession) && "string" == typeof payloadWithSession.type ? payloadWithSession.type : "";
+            if ("agent-complete" === payloadType) {
+                if (payloadWithSession && "object" == typeof payloadWithSession && !Array.isArray(payloadWithSession)) streamedCompletionResult = payloadWithSession.result;
+                return;
+            }
+            if ("agent-error" === payloadType) emittedAgentError = true;
             const baseMessage = {
                 type: "event:agent",
                 id: msg.id,
@@ -491,10 +536,11 @@ class GatewayServer {
             this.broadcastSessionEvent(sessionKey, baseMessage, ws);
         };
         outputManager.on("output-event", outputHandler);
-        const workspace = this.resolveAgentWorkspace(agentId);
+        const workspace = workspaceOverride || this.resolveAgentWorkspace(agentId);
+        const configDir = configDirOverride || this.configDir;
         const invoker = new agentInvoker_cjs_namespaceObject.AgentInvoker({
             workspace,
-            configDir: this.configDir,
+            configDir,
             outputManager,
             logger: this.logger,
             sessionManager,
@@ -508,17 +554,43 @@ class GatewayServer {
             abortController
         });
         try {
-            await invoker.invokeAgent(agentId, content, sessionKey, attachments, {
+            const invocationResult = await invoker.invokeAgent(agentId, content, sessionKey, attachments, {
                 signal: abortController.signal
             });
-            const updated = sessionManager.getSession(sessionKey);
-            if (updated) sessionManager.updateSession(sessionKey, {
-                messageCount: updated.messageCount + 1
+            if (msg.id) sessionManager.clearPendingMessagesForRequest(sessionKey, msg.id);
+            if (emittedAgentError) return;
+            const invocationCancelled = abortController.signal.aborted || "object" == typeof invocationResult && null !== invocationResult && !Array.isArray(invocationResult) && true === invocationResult.cancelled;
+            if (invocationCancelled) return void this.sendAgentError(ws, msg.id, "Request cancelled", {
+                sessionId: sessionKey,
+                agentId,
+                broadcastToSession: true,
+                exclude: ws
+            });
+            const completionResult = void 0 === streamedCompletionResult ? invocationResult : streamedCompletionResult;
+            this.sendAgentComplete(ws, msg.id, completionResult, {
+                sessionId: sessionKey,
+                agentId,
+                broadcastToSession: true,
+                exclude: ws
             });
         } catch (error) {
             this.logger.error("Agent invocation failed", error);
+            const message = error instanceof Error ? error.message : String(error);
+            if (msg.id) try {
+                sessionManager.persistPendingMessage({
+                    sessionId: sessionKey,
+                    requestId: msg.id,
+                    message: {
+                        id: msg.id,
+                        role: "assistant",
+                        content: message,
+                        createdAt: Date.now()
+                    }
+                });
+            } catch (persistError) {
+                this.logger.warn("Failed to persist pending assistant error message", persistError);
+            }
             if (!emittedAgentError) {
-                const message = error instanceof Error ? error.message : String(error);
                 const stack = error instanceof Error ? error.stack : void 0;
                 this.sendAgentError(ws, msg.id, message, {
                     sessionId: sessionKey,
@@ -594,6 +666,12 @@ class GatewayServer {
                 },
                 timestamp: Date.now()
             });
+            this.sendAgentError(ws, requestId, "Request cancelled", {
+                sessionId: queued.sessionKey,
+                agentId: queued.agentId,
+                broadcastToSession: true,
+                exclude: ws
+            });
             return;
         }
         this.sendMessage(ws, {
@@ -768,11 +846,25 @@ class GatewayServer {
     }
     sendMessage(ws, message) {
         try {
-            ws.send(JSON.stringify(message));
+            const result = ws.send(JSON.stringify(message));
+            if ("number" == typeof result && result <= 0) return false;
+            return true;
         } catch (error) {
             this.log("error", "Failed to send message", error);
+            return false;
         }
     }
+    sendMessageWithRetry(ws, message, attempt = 0) {
+        if (this.sendMessage(ws, message)) return;
+        if (attempt >= 2) return void this.log("warn", "Dropping websocket message after retry attempts", {
+            type: message.type,
+            id: message.id
+        });
+        const delayMs = 25 * (attempt + 1);
+        setTimeout(()=>{
+            this.sendMessageWithRetry(ws, message, attempt + 1);
+        }, delayMs);
+    }
     sendError(ws, code, message) {
         const errorPayload = {
             code,
@@ -784,6 +876,25 @@ class GatewayServer {
             timestamp: Date.now()
         });
     }
+    sendAgentComplete(ws, requestId, result, options) {
+        let payload = {
+            type: "agent-complete",
+            result: result ?? null,
+            timestamp: new Date().toISOString()
+        };
+        if (options?.sessionId && options?.agentId) payload = this.attachSessionContext(payload, options.sessionId, options.agentId);
+        const baseMessage = {
+            type: "event:agent",
+            id: requestId,
+            payload,
+            timestamp: Date.now()
+        };
+        this.sendMessageWithRetry(ws, {
+            ...baseMessage,
+            clientId: ws.data.clientId
+        });
+        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude, true);
+    }
     sendAgentError(ws, requestId, message, options) {
         let payload = {
             type: "agent-error",
@@ -798,11 +909,11 @@ class GatewayServer {
             payload,
             timestamp: Date.now()
         };
-        this.sendMessage(ws, {
+        this.sendMessageWithRetry(ws, {
             ...baseMessage,
             clientId: ws.data.clientId
         });
-        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude);
+        if (options?.broadcastToSession && options.sessionId) this.broadcastSessionEvent(options.sessionId, baseMessage, options.exclude, true);
     }
     cancelSocketAgentRequests(ws) {
         for (const [requestId, active] of this.activeAgentRequests)if (active.socket === ws) {
@@ -831,12 +942,13 @@ class GatewayServer {
             agentId
         };
     }
-    broadcastSessionEvent(sessionId, message, exclude) {
+    broadcastSessionEvent(sessionId, message, exclude, reliable = false) {
         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);
+            if (reliable) this.sendMessageWithRetry(ws, message);
+            else this.sendMessage(ws, message);
             sent++;
         }
         return sent;
@@ -1325,6 +1437,7 @@ class GatewayServer {
         _define_property(this, "controlUiPort", 18790);
         _define_property(this, "controlUiSamePort", false);
         _define_property(this, "uiDistDir", null);
+        _define_property(this, "browserRelayServer", null);
         _define_property(this, "webhookStore", void 0);
         _define_property(this, "routineStore", void 0);
         _define_property(this, "internalHooks", null);
@@ -1387,6 +1500,15 @@ class GatewayServer {
         this.controlUiPort = controlUi?.port || 18790;
         this.controlUiSamePort = this.controlUiEnabled && this.controlUiPort === this.config.port;
         this.uiDistDir = this.controlUiEnabled ? this.resolveControlUiDir() : null;
+        const relayConfig = this.wingmanConfig.browser?.relay;
+        if (relayConfig?.enabled) this.browserRelayServer = new external_browserRelayServer_cjs_namespaceObject.BrowserRelayServer({
+            enabled: relayConfig.enabled,
+            host: relayConfig.host || "127.0.0.1",
+            port: relayConfig.port || 18792,
+            requireAuth: relayConfig.requireAuth ?? true,
+            authToken: relayConfig.authToken,
+            maxMessageBytes: relayConfig.maxMessageBytes || 262144
+        }, this.logger);
         this.terminalSessionManager = new terminal_session_manager_cjs_namespaceObject.TerminalSessionManager();
     }
 }
@@ -1410,6 +1532,18 @@ function buildAttachmentPreview(attachments) {
     if (hasAudio) return count > 1 ? "Audio attachments" : "Audio attachment";
     return count > 1 ? "Image attachments" : "Image attachment";
 }
+function mapAttachmentsForPendingMessage(attachments) {
+    return attachments.map((attachment)=>{
+        const kind = isFileAttachment(attachment) ? "file" : isAudioAttachment(attachment) ? "audio" : "image";
+        return {
+            kind,
+            dataUrl: attachment.dataUrl,
+            name: attachment.name,
+            mimeType: attachment.mimeType,
+            size: attachment.size
+        };
+    });
+}
 function isAudioAttachment(attachment) {
     if ("audio" === attachment.kind) return true;
     if (attachment.mimeType?.startsWith("audio/")) return true;
@@ -1421,8 +1555,12 @@ function isFileAttachment(attachment) {
     return "string" == typeof attachment.textContent;
 }
 exports.GatewayServer = __webpack_exports__.GatewayServer;
+exports.resolveExecutionConfigDirOverride = __webpack_exports__.resolveExecutionConfigDirOverride;
+exports.resolveExecutionWorkspaceOverride = __webpack_exports__.resolveExecutionWorkspaceOverride;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "GatewayServer"
+    "GatewayServer",
+    "resolveExecutionConfigDirOverride",
+    "resolveExecutionWorkspaceOverride"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/gateway/server.d.ts

@@ -1,5 +1,7 @@
 import { GatewayAuth } from "./auth.js";
-import type { GatewayConfig } from "./types.js";
+import type { AgentRequestPayload, GatewayConfig } from "./types.js";
+export declare function resolveExecutionWorkspaceOverride(payload: AgentRequestPayload | undefined): string | null;
+export declare function resolveExecutionConfigDirOverride(payload: AgentRequestPayload | undefined): string | null;
 /**
  * Wingman Gateway Server
  * Manages WebSocket connections for AI agent swarming
@@ -26,6 +28,7 @@ export declare class GatewayServer {
     private controlUiPort;
     private controlUiSamePort;
     private uiDistDir;
+    private browserRelayServer;
     private webhookStore;
     private routineStore;
     private internalHooks;
@@ -129,10 +132,12 @@ export declare class GatewayServer {
      * Send a message to a WebSocket
      */
     private sendMessage;
+    private sendMessageWithRetry;
     /**
      * Send an error message
      */
     private sendError;
+    private sendAgentComplete;
     private sendAgentError;
     private cancelSocketAgentRequests;
     private attachSessionContext;