@wingman-ai/gateway 0.3.0 → 0.3.2

package/dist/gateway/browserRelayServer.cjs

@@ -0,0 +1,338 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    BrowserRelayServer: ()=>BrowserRelayServer,
+    isLoopbackHost: ()=>isLoopbackHost
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const RELAY_INFO = {
+    product: "Wingman Browser Relay",
+    protocolVersion: "1.3",
+    userAgent: "WingmanRelay/0.2.0",
+    jsVersion: "wingman-relay"
+};
+const SESSION_OPTIONAL_METHODS = new Set([
+    "Browser.getVersion",
+    "Target.setDiscoverTargets",
+    "Target.setAutoAttach",
+    "Target.getTargets",
+    "Target.attachToTarget",
+    "Target.detachFromTarget",
+    "Target.activateTarget"
+]);
+function isLoopbackHost(host) {
+    const normalized = host.trim().toLowerCase();
+    return "127.0.0.1" === normalized || "localhost" === normalized || "::1" === normalized;
+}
+function parseJsonMessage(raw) {
+    try {
+        return JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+}
+function safeErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+class BrowserRelayServer {
+    get running() {
+        return null !== this.server;
+    }
+    get wsEndpoint() {
+        return this.buildWsUrl("/cdp");
+    }
+    get healthEndpoint() {
+        return `http://${this.config.host}:${this.config.port}/health`;
+    }
+    buildWsUrl(pathname) {
+        const tokenParam = this.config.requireAuth ? `?token=${encodeURIComponent(this.config.authToken || "")}` : "";
+        return `ws://${this.config.host}:${this.config.port}${pathname}${tokenParam}`;
+    }
+    validateStartupConfig() {
+        if (!this.config.enabled) return;
+        if (!isLoopbackHost(this.config.host)) throw new Error(`Browser relay host must be loopback for security. Received "${this.config.host}".`);
+        if (this.config.requireAuth && !(this.config.authToken || "").trim()) throw new Error("Browser relay auth is enabled but no token is configured. Run `wingman browser extension pair`.");
+    }
+    start() {
+        if (!this.config.enabled || this.server) return;
+        this.validateStartupConfig();
+        this.server = Bun.serve({
+            hostname: this.config.host,
+            port: this.config.port,
+            fetch: (req, server)=>this.handleFetch(req, server),
+            websocket: {
+                open: (ws)=>this.handleOpen(ws),
+                message: (ws, message)=>this.handleMessage(ws, message),
+                close: (ws)=>this.handleClose(ws)
+            }
+        });
+        this.logger.info(`Browser relay started on ${this.config.host}:${this.config.port}`);
+    }
+    stop() {
+        if (!this.server) return;
+        this.server.stop();
+        this.server = null;
+        this.extensionSocket = null;
+        this.cdpSockets.clear();
+        this.latestSessionId = null;
+        this.sessionByTargetId.clear();
+        this.targetBySessionId.clear();
+        this.logger.info("Browser relay stopped");
+    }
+    handleFetch(req, server) {
+        const url = new URL(req.url);
+        const token = url.searchParams.get("token") || void 0;
+        if ("/" === url.pathname || "/health" === url.pathname) return new Response("ok");
+        if ("/json/version" === url.pathname) return Response.json({
+            Browser: RELAY_INFO.product,
+            "Protocol-Version": RELAY_INFO.protocolVersion,
+            "User-Agent": RELAY_INFO.userAgent,
+            "V8-Version": RELAY_INFO.jsVersion,
+            webSocketDebuggerUrl: this.buildWsUrl("/cdp")
+        });
+        if ("/extension" === url.pathname || "/cdp" === url.pathname) {
+            const kind = "/extension" === url.pathname ? "extension" : "cdp";
+            const upgraded = server.upgrade(req, {
+                data: {
+                    kind,
+                    token,
+                    authenticated: false,
+                    helloComplete: "cdp" === kind
+                }
+            });
+            if (!upgraded) return new Response("Relay upgrade failed", {
+                status: 400
+            });
+            return;
+        }
+        return new Response("Not Found", {
+            status: 404
+        });
+    }
+    authenticateSocket(socket) {
+        if (!this.config.requireAuth) {
+            socket.data.authenticated = true;
+            return true;
+        }
+        const configured = (this.config.authToken || "").trim();
+        if (!configured || socket.data.token !== configured) {
+            socket.close(4401, "Unauthorized");
+            return false;
+        }
+        socket.data.authenticated = true;
+        return true;
+    }
+    handleOpen(socket) {
+        if (!this.authenticateSocket(socket)) return;
+        if ("extension" === socket.data.kind) {
+            if (this.extensionSocket && this.extensionSocket !== socket) this.extensionSocket.close(4409, "Extension replaced");
+            this.extensionSocket = socket;
+            return;
+        }
+        this.cdpSockets.add(socket);
+    }
+    handleClose(socket) {
+        if ("extension" === socket.data.kind) {
+            if (this.extensionSocket === socket) this.extensionSocket = null;
+            this.latestSessionId = null;
+            this.sessionByTargetId.clear();
+            this.targetBySessionId.clear();
+            return;
+        }
+        this.cdpSockets.delete(socket);
+    }
+    handleMessage(socket, message) {
+        const raw = message.toString();
+        if (Buffer.byteLength(raw, "utf8") > this.config.maxMessageBytes) return void socket.close(1009, "Message too large");
+        const parsed = parseJsonMessage(raw);
+        if (!parsed || "object" != typeof parsed) return;
+        if ("extension" === socket.data.kind) return void this.handleExtensionMessage(socket, parsed);
+        this.handleCdpMessage(socket, parsed);
+    }
+    handleExtensionMessage(socket, message) {
+        if (!socket.data.helloComplete) {
+            const method = "string" == typeof message.method ? message.method : "";
+            const token = message.params?.token;
+            if ("hello" !== method) return void socket.close(4403, "Expected hello handshake");
+            if (this.config.requireAuth && ("string" != typeof token || token !== this.config.authToken)) return void socket.close(4401, "Invalid extension token");
+            socket.data.helloComplete = true;
+            this.sendJson(socket, {
+                method: "hello_ack",
+                params: {
+                    ok: true
+                }
+            });
+            return;
+        }
+        if ("number" == typeof message.id && ("result" in message || "error" in message)) return void this.broadcastToCdp(message);
+        if ("forwardCDPEvent" === message.method && message.params) {
+            const event = message.params;
+            const method = "string" == typeof event.method ? event.method : "";
+            const params = event.params || {};
+            this.trackTargetSessions(method, params);
+            this.broadcastToCdp(event);
+        }
+    }
+    handleCdpMessage(socket, message) {
+        const id = message.id;
+        const method = message.method;
+        if ("number" != typeof id || "string" != typeof method) return;
+        if ("Browser.getVersion" === method) return void this.sendJson(socket, {
+            id,
+            result: {
+                product: RELAY_INFO.product,
+                protocolVersion: RELAY_INFO.protocolVersion,
+                userAgent: RELAY_INFO.userAgent,
+                jsVersion: RELAY_INFO.jsVersion,
+                revision: "wingman"
+            }
+        });
+        if ("Target.setDiscoverTargets" === method || "Target.setAutoAttach" === method) return void this.sendJson(socket, {
+            id,
+            result: {}
+        });
+        if ("Target.getTargets" === method) {
+            const targetInfos = Array.from(this.sessionByTargetId.keys()).map((targetId)=>({
+                    targetId,
+                    type: "page",
+                    attached: true
+                }));
+            this.sendJson(socket, {
+                id,
+                result: {
+                    targetInfos
+                }
+            });
+            return;
+        }
+        if ("Target.attachToTarget" === method) {
+            const targetId = String((message.params || {}).targetId || "");
+            const sessionId = this.sessionByTargetId.get(targetId) || this.latestSessionId;
+            if (!sessionId) return void this.sendJson(socket, {
+                id,
+                error: {
+                    message: "No attached target is available"
+                }
+            });
+            this.sendJson(socket, {
+                id,
+                result: {
+                    sessionId
+                }
+            });
+            return;
+        }
+        if ("Target.detachFromTarget" === method || "Target.activateTarget" === method) return void this.sendJson(socket, {
+            id,
+            result: {}
+        });
+        const extension = this.extensionSocket;
+        if (!extension || !extension.data.helloComplete) return void this.sendJson(socket, {
+            id,
+            error: {
+                message: "No extension is connected to browser relay"
+            }
+        });
+        const sessionId = "string" == typeof message.sessionId && message.sessionId || ("string" == typeof (message.params || {}).sessionId ? String((message.params || {}).sessionId) : void 0) || this.latestSessionId || void 0;
+        if (!sessionId && !SESSION_OPTIONAL_METHODS.has(method)) return void this.sendJson(socket, {
+            id,
+            error: {
+                message: `No active tab session for method "${method}"`
+            }
+        });
+        this.sendJson(extension, {
+            id,
+            method: "forwardCDPCommand",
+            params: {
+                sessionId,
+                method,
+                params: message.params || {}
+            }
+        });
+    }
+    trackTargetSessions(method, params) {
+        if ("Target.attachedToTarget" === method) {
+            const sessionId = "string" == typeof params.sessionId ? params.sessionId : null;
+            const targetId = "string" == typeof params.targetInfo?.targetId ? String(params.targetInfo?.targetId) : null;
+            if (sessionId) this.latestSessionId = sessionId;
+            if (sessionId && targetId) {
+                this.sessionByTargetId.set(targetId, sessionId);
+                this.targetBySessionId.set(sessionId, targetId);
+            }
+            return;
+        }
+        if ("Target.detachedFromTarget" === method) {
+            const sessionId = "string" == typeof params.sessionId ? params.sessionId : null;
+            if (!sessionId) return;
+            const targetId = this.targetBySessionId.get(sessionId);
+            if (targetId) {
+                this.sessionByTargetId.delete(targetId);
+                this.targetBySessionId.delete(sessionId);
+            }
+            if (this.latestSessionId === sessionId) this.latestSessionId = this.targetBySessionId.size > 0 ? Array.from(this.targetBySessionId.keys())[0] : null;
+        }
+    }
+    broadcastToCdp(payload) {
+        for (const socket of this.cdpSockets)this.sendJson(socket, payload);
+    }
+    sendJson(socket, payload) {
+        try {
+            socket.send(JSON.stringify(payload));
+        } catch (error) {
+            this.logger.debug(`Browser relay send failed: ${safeErrorMessage(error)}`);
+        }
+    }
+    constructor(config, logger){
+        _define_property(this, "config", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "server", null);
+        _define_property(this, "extensionSocket", null);
+        _define_property(this, "cdpSockets", new Set());
+        _define_property(this, "latestSessionId", null);
+        _define_property(this, "sessionByTargetId", new Map());
+        _define_property(this, "targetBySessionId", new Map());
+        this.config = config;
+        this.logger = logger;
+    }
+}
+exports.BrowserRelayServer = __webpack_exports__.BrowserRelayServer;
+exports.isLoopbackHost = __webpack_exports__.isLoopbackHost;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BrowserRelayServer",
+    "isLoopbackHost"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/browserRelayServer.d.ts

@@ -0,0 +1,38 @@
+import type { Logger } from "@/logger.js";
+export interface BrowserRelayConfig {
+    enabled: boolean;
+    host: string;
+    port: number;
+    requireAuth: boolean;
+    authToken?: string;
+    maxMessageBytes: number;
+}
+export declare function isLoopbackHost(host: string): boolean;
+export declare class BrowserRelayServer {
+    private readonly config;
+    private readonly logger;
+    private server;
+    private extensionSocket;
+    private cdpSockets;
+    private latestSessionId;
+    private sessionByTargetId;
+    private targetBySessionId;
+    constructor(config: BrowserRelayConfig, logger: Logger);
+    get running(): boolean;
+    get wsEndpoint(): string;
+    get healthEndpoint(): string;
+    private buildWsUrl;
+    private validateStartupConfig;
+    start(): void;
+    stop(): void;
+    private handleFetch;
+    private authenticateSocket;
+    private handleOpen;
+    private handleClose;
+    private handleMessage;
+    private handleExtensionMessage;
+    private handleCdpMessage;
+    private trackTargetSessions;
+    private broadcastToCdp;
+    private sendJson;
+}

package/dist/gateway/browserRelayServer.js

@@ -0,0 +1,301 @@
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const RELAY_INFO = {
+    product: "Wingman Browser Relay",
+    protocolVersion: "1.3",
+    userAgent: "WingmanRelay/0.2.0",
+    jsVersion: "wingman-relay"
+};
+const SESSION_OPTIONAL_METHODS = new Set([
+    "Browser.getVersion",
+    "Target.setDiscoverTargets",
+    "Target.setAutoAttach",
+    "Target.getTargets",
+    "Target.attachToTarget",
+    "Target.detachFromTarget",
+    "Target.activateTarget"
+]);
+function isLoopbackHost(host) {
+    const normalized = host.trim().toLowerCase();
+    return "127.0.0.1" === normalized || "localhost" === normalized || "::1" === normalized;
+}
+function parseJsonMessage(raw) {
+    try {
+        return JSON.parse(raw);
+    } catch  {
+        return null;
+    }
+}
+function safeErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+class BrowserRelayServer {
+    get running() {
+        return null !== this.server;
+    }
+    get wsEndpoint() {
+        return this.buildWsUrl("/cdp");
+    }
+    get healthEndpoint() {
+        return `http://${this.config.host}:${this.config.port}/health`;
+    }
+    buildWsUrl(pathname) {
+        const tokenParam = this.config.requireAuth ? `?token=${encodeURIComponent(this.config.authToken || "")}` : "";
+        return `ws://${this.config.host}:${this.config.port}${pathname}${tokenParam}`;
+    }
+    validateStartupConfig() {
+        if (!this.config.enabled) return;
+        if (!isLoopbackHost(this.config.host)) throw new Error(`Browser relay host must be loopback for security. Received "${this.config.host}".`);
+        if (this.config.requireAuth && !(this.config.authToken || "").trim()) throw new Error("Browser relay auth is enabled but no token is configured. Run `wingman browser extension pair`.");
+    }
+    start() {
+        if (!this.config.enabled || this.server) return;
+        this.validateStartupConfig();
+        this.server = Bun.serve({
+            hostname: this.config.host,
+            port: this.config.port,
+            fetch: (req, server)=>this.handleFetch(req, server),
+            websocket: {
+                open: (ws)=>this.handleOpen(ws),
+                message: (ws, message)=>this.handleMessage(ws, message),
+                close: (ws)=>this.handleClose(ws)
+            }
+        });
+        this.logger.info(`Browser relay started on ${this.config.host}:${this.config.port}`);
+    }
+    stop() {
+        if (!this.server) return;
+        this.server.stop();
+        this.server = null;
+        this.extensionSocket = null;
+        this.cdpSockets.clear();
+        this.latestSessionId = null;
+        this.sessionByTargetId.clear();
+        this.targetBySessionId.clear();
+        this.logger.info("Browser relay stopped");
+    }
+    handleFetch(req, server) {
+        const url = new URL(req.url);
+        const token = url.searchParams.get("token") || void 0;
+        if ("/" === url.pathname || "/health" === url.pathname) return new Response("ok");
+        if ("/json/version" === url.pathname) return Response.json({
+            Browser: RELAY_INFO.product,
+            "Protocol-Version": RELAY_INFO.protocolVersion,
+            "User-Agent": RELAY_INFO.userAgent,
+            "V8-Version": RELAY_INFO.jsVersion,
+            webSocketDebuggerUrl: this.buildWsUrl("/cdp")
+        });
+        if ("/extension" === url.pathname || "/cdp" === url.pathname) {
+            const kind = "/extension" === url.pathname ? "extension" : "cdp";
+            const upgraded = server.upgrade(req, {
+                data: {
+                    kind,
+                    token,
+                    authenticated: false,
+                    helloComplete: "cdp" === kind
+                }
+            });
+            if (!upgraded) return new Response("Relay upgrade failed", {
+                status: 400
+            });
+            return;
+        }
+        return new Response("Not Found", {
+            status: 404
+        });
+    }
+    authenticateSocket(socket) {
+        if (!this.config.requireAuth) {
+            socket.data.authenticated = true;
+            return true;
+        }
+        const configured = (this.config.authToken || "").trim();
+        if (!configured || socket.data.token !== configured) {
+            socket.close(4401, "Unauthorized");
+            return false;
+        }
+        socket.data.authenticated = true;
+        return true;
+    }
+    handleOpen(socket) {
+        if (!this.authenticateSocket(socket)) return;
+        if ("extension" === socket.data.kind) {
+            if (this.extensionSocket && this.extensionSocket !== socket) this.extensionSocket.close(4409, "Extension replaced");
+            this.extensionSocket = socket;
+            return;
+        }
+        this.cdpSockets.add(socket);
+    }
+    handleClose(socket) {
+        if ("extension" === socket.data.kind) {
+            if (this.extensionSocket === socket) this.extensionSocket = null;
+            this.latestSessionId = null;
+            this.sessionByTargetId.clear();
+            this.targetBySessionId.clear();
+            return;
+        }
+        this.cdpSockets.delete(socket);
+    }
+    handleMessage(socket, message) {
+        const raw = message.toString();
+        if (Buffer.byteLength(raw, "utf8") > this.config.maxMessageBytes) return void socket.close(1009, "Message too large");
+        const parsed = parseJsonMessage(raw);
+        if (!parsed || "object" != typeof parsed) return;
+        if ("extension" === socket.data.kind) return void this.handleExtensionMessage(socket, parsed);
+        this.handleCdpMessage(socket, parsed);
+    }
+    handleExtensionMessage(socket, message) {
+        if (!socket.data.helloComplete) {
+            const method = "string" == typeof message.method ? message.method : "";
+            const token = message.params?.token;
+            if ("hello" !== method) return void socket.close(4403, "Expected hello handshake");
+            if (this.config.requireAuth && ("string" != typeof token || token !== this.config.authToken)) return void socket.close(4401, "Invalid extension token");
+            socket.data.helloComplete = true;
+            this.sendJson(socket, {
+                method: "hello_ack",
+                params: {
+                    ok: true
+                }
+            });
+            return;
+        }
+        if ("number" == typeof message.id && ("result" in message || "error" in message)) return void this.broadcastToCdp(message);
+        if ("forwardCDPEvent" === message.method && message.params) {
+            const event = message.params;
+            const method = "string" == typeof event.method ? event.method : "";
+            const params = event.params || {};
+            this.trackTargetSessions(method, params);
+            this.broadcastToCdp(event);
+        }
+    }
+    handleCdpMessage(socket, message) {
+        const id = message.id;
+        const method = message.method;
+        if ("number" != typeof id || "string" != typeof method) return;
+        if ("Browser.getVersion" === method) return void this.sendJson(socket, {
+            id,
+            result: {
+                product: RELAY_INFO.product,
+                protocolVersion: RELAY_INFO.protocolVersion,
+                userAgent: RELAY_INFO.userAgent,
+                jsVersion: RELAY_INFO.jsVersion,
+                revision: "wingman"
+            }
+        });
+        if ("Target.setDiscoverTargets" === method || "Target.setAutoAttach" === method) return void this.sendJson(socket, {
+            id,
+            result: {}
+        });
+        if ("Target.getTargets" === method) {
+            const targetInfos = Array.from(this.sessionByTargetId.keys()).map((targetId)=>({
+                    targetId,
+                    type: "page",
+                    attached: true
+                }));
+            this.sendJson(socket, {
+                id,
+                result: {
+                    targetInfos
+                }
+            });
+            return;
+        }
+        if ("Target.attachToTarget" === method) {
+            const targetId = String((message.params || {}).targetId || "");
+            const sessionId = this.sessionByTargetId.get(targetId) || this.latestSessionId;
+            if (!sessionId) return void this.sendJson(socket, {
+                id,
+                error: {
+                    message: "No attached target is available"
+                }
+            });
+            this.sendJson(socket, {
+                id,
+                result: {
+                    sessionId
+                }
+            });
+            return;
+        }
+        if ("Target.detachFromTarget" === method || "Target.activateTarget" === method) return void this.sendJson(socket, {
+            id,
+            result: {}
+        });
+        const extension = this.extensionSocket;
+        if (!extension || !extension.data.helloComplete) return void this.sendJson(socket, {
+            id,
+            error: {
+                message: "No extension is connected to browser relay"
+            }
+        });
+        const sessionId = "string" == typeof message.sessionId && message.sessionId || ("string" == typeof (message.params || {}).sessionId ? String((message.params || {}).sessionId) : void 0) || this.latestSessionId || void 0;
+        if (!sessionId && !SESSION_OPTIONAL_METHODS.has(method)) return void this.sendJson(socket, {
+            id,
+            error: {
+                message: `No active tab session for method "${method}"`
+            }
+        });
+        this.sendJson(extension, {
+            id,
+            method: "forwardCDPCommand",
+            params: {
+                sessionId,
+                method,
+                params: message.params || {}
+            }
+        });
+    }
+    trackTargetSessions(method, params) {
+        if ("Target.attachedToTarget" === method) {
+            const sessionId = "string" == typeof params.sessionId ? params.sessionId : null;
+            const targetId = "string" == typeof params.targetInfo?.targetId ? String(params.targetInfo?.targetId) : null;
+            if (sessionId) this.latestSessionId = sessionId;
+            if (sessionId && targetId) {
+                this.sessionByTargetId.set(targetId, sessionId);
+                this.targetBySessionId.set(sessionId, targetId);
+            }
+            return;
+        }
+        if ("Target.detachedFromTarget" === method) {
+            const sessionId = "string" == typeof params.sessionId ? params.sessionId : null;
+            if (!sessionId) return;
+            const targetId = this.targetBySessionId.get(sessionId);
+            if (targetId) {
+                this.sessionByTargetId.delete(targetId);
+                this.targetBySessionId.delete(sessionId);
+            }
+            if (this.latestSessionId === sessionId) this.latestSessionId = this.targetBySessionId.size > 0 ? Array.from(this.targetBySessionId.keys())[0] : null;
+        }
+    }
+    broadcastToCdp(payload) {
+        for (const socket of this.cdpSockets)this.sendJson(socket, payload);
+    }
+    sendJson(socket, payload) {
+        try {
+            socket.send(JSON.stringify(payload));
+        } catch (error) {
+            this.logger.debug(`Browser relay send failed: ${safeErrorMessage(error)}`);
+        }
+    }
+    constructor(config, logger){
+        _define_property(this, "config", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "server", null);
+        _define_property(this, "extensionSocket", null);
+        _define_property(this, "cdpSockets", new Set());
+        _define_property(this, "latestSessionId", null);
+        _define_property(this, "sessionByTargetId", new Map());
+        _define_property(this, "targetBySessionId", new Map());
+        this.config = config;
+        this.logger = logger;
+    }
+}
+export { BrowserRelayServer, isLoopbackHost };