@wingman-ai/gateway 0.1.0

package/dist/gateway/router.cjs

@@ -0,0 +1,85 @@
+"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__, {
+    GatewayRouter: ()=>GatewayRouter
+});
+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 GatewayRouter {
+    selectAgent(explicitAgentId, routing) {
+        if (explicitAgentId) return explicitAgentId;
+        const bindings = this.config.agents?.bindings ?? [];
+        if (routing) {
+            for (const binding of bindings)if (this.matches(binding.match, routing)) return binding.agentId;
+        }
+        return this.config.defaultAgent || this.config.agents?.list?.find((agent)=>agent.default)?.id || this.config.agents?.list?.[0]?.id;
+    }
+    buildSessionKey(agentId, routing) {
+        if (!routing) return `agent:${agentId}:main`;
+        if (routing.peer?.kind === "dm") return `agent:${agentId}:main`;
+        const parts = [
+            "agent",
+            agentId,
+            routing.channel
+        ];
+        if (routing.accountId) parts.push("account", routing.accountId);
+        if (routing.peer) parts.push(routing.peer.kind, routing.peer.id);
+        if (routing.threadId) parts.push("thread", routing.threadId);
+        if (3 === parts.length) parts.push("main");
+        return parts.join(":");
+    }
+    matches(match, routing) {
+        if (match.channel !== routing.channel) return false;
+        if (match.accountId && match.accountId !== routing.accountId) return false;
+        if (match.guildId && match.guildId !== routing.guildId) return false;
+        if (match.teamId && match.teamId !== routing.teamId) return false;
+        if (match.peer) {
+            if (!routing.peer) return false;
+            if (match.peer.kind !== routing.peer.kind) return false;
+            if (match.peer.id !== routing.peer.id) return false;
+        }
+        return true;
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        this.config = config;
+    }
+}
+exports.GatewayRouter = __webpack_exports__.GatewayRouter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GatewayRouter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/router.d.ts

@@ -0,0 +1,9 @@
+import type { WingmanConfigType } from "../cli/config/schema.js";
+import type { RoutingInfo } from "./types.js";
+export declare class GatewayRouter {
+    private config;
+    constructor(config: WingmanConfigType);
+    selectAgent(explicitAgentId?: string, routing?: RoutingInfo): string | undefined;
+    buildSessionKey(agentId: string, routing?: RoutingInfo): string;
+    private matches;
+}

package/dist/gateway/router.js

@@ -0,0 +1,51 @@
+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 GatewayRouter {
+    selectAgent(explicitAgentId, routing) {
+        if (explicitAgentId) return explicitAgentId;
+        const bindings = this.config.agents?.bindings ?? [];
+        if (routing) {
+            for (const binding of bindings)if (this.matches(binding.match, routing)) return binding.agentId;
+        }
+        return this.config.defaultAgent || this.config.agents?.list?.find((agent)=>agent.default)?.id || this.config.agents?.list?.[0]?.id;
+    }
+    buildSessionKey(agentId, routing) {
+        if (!routing) return `agent:${agentId}:main`;
+        if (routing.peer?.kind === "dm") return `agent:${agentId}:main`;
+        const parts = [
+            "agent",
+            agentId,
+            routing.channel
+        ];
+        if (routing.accountId) parts.push("account", routing.accountId);
+        if (routing.peer) parts.push(routing.peer.kind, routing.peer.id);
+        if (routing.threadId) parts.push("thread", routing.threadId);
+        if (3 === parts.length) parts.push("main");
+        return parts.join(":");
+    }
+    matches(match, routing) {
+        if (match.channel !== routing.channel) return false;
+        if (match.accountId && match.accountId !== routing.accountId) return false;
+        if (match.guildId && match.guildId !== routing.guildId) return false;
+        if (match.teamId && match.teamId !== routing.teamId) return false;
+        if (match.peer) {
+            if (!routing.peer) return false;
+            if (match.peer.kind !== routing.peer.kind) return false;
+            if (match.peer.id !== routing.peer.id) return false;
+        }
+        return true;
+    }
+    constructor(config){
+        _define_property(this, "config", void 0);
+        this.config = config;
+    }
+}
+export { GatewayRouter };

package/dist/gateway/rpcClient.cjs

@@ -0,0 +1,152 @@
+"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__, {
+    GatewayRpcClient: ()=>GatewayRpcClient
+});
+const external_uuid_namespaceObject = require("uuid");
+const external_logger_cjs_namespaceObject = require("../logger.cjs");
+const websocket_cjs_namespaceObject = require("./transport/websocket.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class GatewayRpcClient {
+    async connect() {
+        this.transport = new websocket_cjs_namespaceObject.WebSocketTransport(this.url, {
+            autoReconnect: false
+        });
+        this.transport.onMessage((message)=>this.handleMessage(message));
+        await this.transport.connect();
+        const connectId = (0, external_uuid_namespaceObject.v4)();
+        const connectMessage = {
+            type: "connect",
+            id: connectId,
+            client: this.clientInfo,
+            auth: this.auth,
+            timestamp: Date.now()
+        };
+        const response = await this.sendRequest(connectId, connectMessage);
+        if (!response.ok) throw new Error("string" == typeof response.payload ? response.payload : "Gateway authentication failed");
+    }
+    async requestAgent(payload, onEvent) {
+        const requestId = (0, external_uuid_namespaceObject.v4)();
+        const message = {
+            type: "req:agent",
+            id: requestId,
+            payload,
+            timestamp: Date.now()
+        };
+        const completion = new Promise((resolve, reject)=>{
+            this.pendingAgentRequests.set(requestId, {
+                resolve,
+                reject,
+                onEvent
+            });
+        });
+        this.send(message);
+        return completion;
+    }
+    disconnect() {
+        if (this.transport) {
+            this.transport.disconnect();
+            this.transport = null;
+        }
+    }
+    handleMessage(msg) {
+        if ("res" === msg.type && msg.id) {
+            const pending = this.pendingResponses.get(msg.id);
+            if (pending) {
+                this.pendingResponses.delete(msg.id);
+                pending.resolve(msg);
+                return;
+            }
+        }
+        if ("event:agent" === msg.type && msg.id) {
+            const pending = this.pendingAgentRequests.get(msg.id);
+            if (!pending) return;
+            pending.onEvent?.(msg.payload);
+            const payload = msg.payload;
+            if (payload?.type === "agent-complete") {
+                this.pendingAgentRequests.delete(msg.id);
+                pending.resolve();
+            }
+            if (payload?.type === "agent-error") {
+                this.pendingAgentRequests.delete(msg.id);
+                const error = new Error(payload.error || "Agent failed");
+                error.isAgentError = true;
+                pending.reject(error);
+            }
+            return;
+        }
+        if ("error" === msg.type) this.logger.error("Gateway error", msg.payload);
+    }
+    sendRequest(id, message) {
+        return new Promise((resolve, reject)=>{
+            this.pendingResponses.set(id, {
+                resolve,
+                reject
+            });
+            this.send(message);
+        });
+    }
+    send(message) {
+        if (!this.transport) throw new Error("Gateway transport not connected");
+        this.transport.send(message);
+    }
+    constructor(url, options = {}){
+        _define_property(this, "url", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "transport", null);
+        _define_property(this, "pendingResponses", new Map());
+        _define_property(this, "pendingAgentRequests", new Map());
+        _define_property(this, "clientInfo", void 0);
+        _define_property(this, "auth", void 0);
+        this.url = url;
+        this.logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+        this.clientInfo = {
+            instanceId: options.instanceId || `cli-${Date.now()}`,
+            clientType: options.clientType || "cli",
+            version: options.version
+        };
+        this.auth = {
+            token: options.token,
+            password: options.password
+        };
+    }
+}
+exports.GatewayRpcClient = __webpack_exports__.GatewayRpcClient;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GatewayRpcClient"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/rpcClient.d.ts

@@ -0,0 +1,24 @@
+import type { AgentRequestPayload } from "./types.js";
+export interface GatewayRpcClientOptions {
+    token?: string;
+    password?: string;
+    clientType?: string;
+    instanceId?: string;
+    version?: string;
+}
+export declare class GatewayRpcClient {
+    private url;
+    private logger;
+    private transport;
+    private pendingResponses;
+    private pendingAgentRequests;
+    private clientInfo;
+    private auth;
+    constructor(url: string, options?: GatewayRpcClientOptions);
+    connect(): Promise<void>;
+    requestAgent(payload: AgentRequestPayload, onEvent?: (event: unknown) => void): Promise<void>;
+    disconnect(): void;
+    private handleMessage;
+    private sendRequest;
+    private send;
+}

package/dist/gateway/rpcClient.js

@@ -0,0 +1,118 @@
+import { v4 } from "uuid";
+import { createLogger } from "../logger.js";
+import { WebSocketTransport } from "./transport/websocket.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class GatewayRpcClient {
+    async connect() {
+        this.transport = new WebSocketTransport(this.url, {
+            autoReconnect: false
+        });
+        this.transport.onMessage((message)=>this.handleMessage(message));
+        await this.transport.connect();
+        const connectId = v4();
+        const connectMessage = {
+            type: "connect",
+            id: connectId,
+            client: this.clientInfo,
+            auth: this.auth,
+            timestamp: Date.now()
+        };
+        const response = await this.sendRequest(connectId, connectMessage);
+        if (!response.ok) throw new Error("string" == typeof response.payload ? response.payload : "Gateway authentication failed");
+    }
+    async requestAgent(payload, onEvent) {
+        const requestId = v4();
+        const message = {
+            type: "req:agent",
+            id: requestId,
+            payload,
+            timestamp: Date.now()
+        };
+        const completion = new Promise((resolve, reject)=>{
+            this.pendingAgentRequests.set(requestId, {
+                resolve,
+                reject,
+                onEvent
+            });
+        });
+        this.send(message);
+        return completion;
+    }
+    disconnect() {
+        if (this.transport) {
+            this.transport.disconnect();
+            this.transport = null;
+        }
+    }
+    handleMessage(msg) {
+        if ("res" === msg.type && msg.id) {
+            const pending = this.pendingResponses.get(msg.id);
+            if (pending) {
+                this.pendingResponses.delete(msg.id);
+                pending.resolve(msg);
+                return;
+            }
+        }
+        if ("event:agent" === msg.type && msg.id) {
+            const pending = this.pendingAgentRequests.get(msg.id);
+            if (!pending) return;
+            pending.onEvent?.(msg.payload);
+            const payload = msg.payload;
+            if (payload?.type === "agent-complete") {
+                this.pendingAgentRequests.delete(msg.id);
+                pending.resolve();
+            }
+            if (payload?.type === "agent-error") {
+                this.pendingAgentRequests.delete(msg.id);
+                const error = new Error(payload.error || "Agent failed");
+                error.isAgentError = true;
+                pending.reject(error);
+            }
+            return;
+        }
+        if ("error" === msg.type) this.logger.error("Gateway error", msg.payload);
+    }
+    sendRequest(id, message) {
+        return new Promise((resolve, reject)=>{
+            this.pendingResponses.set(id, {
+                resolve,
+                reject
+            });
+            this.send(message);
+        });
+    }
+    send(message) {
+        if (!this.transport) throw new Error("Gateway transport not connected");
+        this.transport.send(message);
+    }
+    constructor(url, options = {}){
+        _define_property(this, "url", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "transport", null);
+        _define_property(this, "pendingResponses", new Map());
+        _define_property(this, "pendingAgentRequests", new Map());
+        _define_property(this, "clientInfo", void 0);
+        _define_property(this, "auth", void 0);
+        this.url = url;
+        this.logger = createLogger();
+        this.clientInfo = {
+            instanceId: options.instanceId || `cli-${Date.now()}`,
+            clientType: options.clientType || "cli",
+            version: options.version
+        };
+        this.auth = {
+            token: options.token,
+            password: options.password
+        };
+    }
+}
+export { GatewayRpcClient };