@wingman-ai/gateway 0.1.0

package/dist/gateway/adapters/discord.js

@@ -0,0 +1,246 @@
+import { ChannelType, Client, GatewayIntentBits, Partials } from "discord.js";
+import { createLogger } from "../../logger.js";
+import { GatewayRpcClient } from "../rpcClient.js";
+import { parseStreamChunk } from "../../cli/core/streamParser.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;
+}
+const DEFAULT_DISCORD_RESPONSE_CHUNK = 1900;
+function splitDiscordMessage(text, maxLength = DEFAULT_DISCORD_RESPONSE_CHUNK) {
+    const normalized = text.trim();
+    if (!normalized) return [];
+    const chunks = [];
+    let current = "";
+    for (const char of normalized){
+        if (current.length + 1 > maxLength) {
+            chunks.push(current);
+            current = "";
+        }
+        current += char;
+    }
+    if (current) chunks.push(current);
+    return chunks;
+}
+function stripDiscordBotMention(content, botId) {
+    if (!content) return content;
+    const mention = new RegExp(`<@!?${botId}>`, "g");
+    return content.replace(mention, "").trim();
+}
+function extractSessionOverride(content, command) {
+    const trimmed = content.trim();
+    if (!command || !trimmed.toLowerCase().startsWith(command.toLowerCase())) return {
+        content,
+        matched: false
+    };
+    const withoutCommand = trimmed.slice(command.length).trim();
+    if (!withoutCommand) return {
+        content: "",
+        matched: true
+    };
+    const [sessionKey, ...rest] = withoutCommand.split(/\s+/);
+    return {
+        sessionKey,
+        content: rest.join(" "),
+        matched: true
+    };
+}
+function resolveDiscordChannelSessionKey(channelId, channelSessions, parentChannelId) {
+    if (!channelSessions) return;
+    const direct = channelSessions[channelId];
+    if (direct) return direct;
+    if (parentChannelId) return channelSessions[parentChannelId];
+}
+function parseAgentIdFromSessionKey(sessionKey) {
+    if (!sessionKey) return;
+    const match = sessionKey.match(/^agent:([^:]+):/);
+    return match?.[1];
+}
+function buildRoutingInfo(message, botUserId) {
+    const routing = {
+        channel: "discord",
+        accountId: botUserId
+    };
+    if (message.guildId) routing.guildId = message.guildId;
+    const channel = message.channel;
+    if (channel.isDMBased()) {
+        if (channel.type === ChannelType.DM) routing.peer = {
+            kind: "dm",
+            id: message.author.id
+        };
+        else routing.peer = {
+            kind: "group",
+            id: channel.id
+        };
+        return routing;
+    }
+    if (channel.isThread()) {
+        routing.threadId = channel.id;
+        routing.peer = {
+            kind: "channel",
+            id: channel.parentId || channel.id
+        };
+        return routing;
+    }
+    routing.peer = {
+        kind: "channel",
+        id: channel.id
+    };
+    return routing;
+}
+class DiscordGatewayAdapter {
+    async start() {
+        if (this.started) return;
+        if (!this.config.enabled) return;
+        if (!this.config.token) return void this.logger.warn("Discord adapter enabled but no token configured.");
+        this.gatewayClient = new GatewayRpcClient(this.gateway.url, {
+            token: this.gateway.token,
+            password: this.gateway.password,
+            clientType: "discord"
+        });
+        await this.gatewayClient.connect();
+        this.client = new Client({
+            intents: [
+                GatewayIntentBits.Guilds,
+                GatewayIntentBits.GuildMessages,
+                GatewayIntentBits.DirectMessages,
+                GatewayIntentBits.MessageContent
+            ],
+            partials: [
+                Partials.Channel
+            ]
+        });
+        this.client.on("clientReady", ()=>{
+            this.logger.info("Discord adapter connected.");
+        });
+        this.client.on("error", (error)=>{
+            this.logger.error("Discord adapter error", error);
+        });
+        this.client.on("messageCreate", (message)=>{
+            this.handleMessage(message);
+        });
+        await this.client.login(this.config.token);
+        this.started = true;
+    }
+    async stop() {
+        if (!this.started) return;
+        this.started = false;
+        if (this.client) {
+            await this.client.destroy();
+            this.client = null;
+        }
+        if (this.gatewayClient) {
+            this.gatewayClient.disconnect();
+            this.gatewayClient = null;
+        }
+    }
+    async handleMessage(message) {
+        if (!this.client || !this.gatewayClient) return;
+        if (!message.content && 0 === message.attachments.size) return;
+        if (message.author.bot) {
+            if (!this.config.allowBots) return;
+            if (message.author.id === this.client.user?.id) return;
+        }
+        const botUserId = this.client.user?.id;
+        if (!botUserId) return;
+        if (!message.channel.isTextBased()) return;
+        const channel = message.channel;
+        if (!("send" in channel)) return;
+        const sendChannel = channel;
+        if (this.config.allowedGuilds.length > 0 && message.guildId) {
+            if (!this.config.allowedGuilds.includes(message.guildId)) return;
+        }
+        if (this.config.allowedChannels.length > 0) {
+            if (!this.config.allowedChannels.includes(message.channelId)) return;
+        }
+        const isDm = message.channel.isDMBased();
+        const mentioned = message.mentions.has(botUserId);
+        if (this.config.mentionOnly && !isDm && !mentioned) return;
+        const cleaned = stripDiscordBotMention(message.content || "", botUserId);
+        const attachments = Array.from(message.attachments.values()).map((attachment)=>attachment.url);
+        const attachmentText = attachments.length > 0 ? `\n\nAttachments:\n${attachments.map((url)=>`- ${url}`).join("\n")}` : "";
+        let content = `${cleaned}${attachmentText}`.trim();
+        const { sessionKey, content: nextContent, matched } = extractSessionOverride(content, this.config.sessionCommand);
+        let resolvedSessionKey = sessionKey;
+        let usedChannelMapping = false;
+        if (matched) {
+            content = nextContent.trim();
+            if (!sessionKey) return void await sendChannel.send(`Provide a session key after \`${this.config.sessionCommand}\`.`);
+        }
+        if (!matched) {
+            const parentChannelId = message.channel.isThread() ? message.channel.parentId ?? void 0 : void 0;
+            resolvedSessionKey = resolveDiscordChannelSessionKey(message.channelId, this.config.channelSessions, parentChannelId);
+            usedChannelMapping = Boolean(resolvedSessionKey);
+        }
+        const inferredAgentId = parseAgentIdFromSessionKey(resolvedSessionKey);
+        if (usedChannelMapping && !inferredAgentId) this.logger.warn(`Discord channel session mapping for channel ${message.channelId} does not include an agent prefix. Use "agent:<id>:..." to auto-select an agent.`, {
+            sessionKey: resolvedSessionKey
+        });
+        if (!content) return;
+        const payload = {
+            agentId: inferredAgentId,
+            content,
+            routing: buildRoutingInfo(message, botUserId),
+            sessionKey: resolvedSessionKey
+        };
+        try {
+            if (sendChannel.sendTyping) await sendChannel.sendTyping();
+            let fallbackText = "";
+            const textByMessageId = new Map();
+            const messageOrder = [];
+            await this.gatewayClient.requestAgent(payload, (event)=>{
+                if (!event || "object" != typeof event) return;
+                if ("agent-error" === event.type) {
+                    fallbackText += `\n${event.error || "Agent error"}`;
+                    return;
+                }
+                if ("agent-stream" !== event.type) return;
+                const parsedChunks = parseStreamChunk(event.chunk);
+                for (const chunk of parsedChunks)if ("text" === chunk.type && chunk.text) {
+                    if (chunk.messageId) {
+                        if (!textByMessageId.has(chunk.messageId)) {
+                            messageOrder.push(chunk.messageId);
+                            textByMessageId.set(chunk.messageId, chunk.text);
+                            continue;
+                        }
+                        const current = textByMessageId.get(chunk.messageId) || "";
+                        textByMessageId.set(chunk.messageId, chunk.isDelta ? current + chunk.text : chunk.text);
+                        continue;
+                    }
+                    fallbackText += chunk.text;
+                }
+            });
+            const orderedText = messageOrder.map((id)=>textByMessageId.get(id)).filter((value)=>Boolean(value)).join("\n\n");
+            const responseText = `${fallbackText}${fallbackText && orderedText ? "\n\n" : ""}${orderedText}`.trim();
+            if (!responseText) return;
+            const chunks = splitDiscordMessage(responseText, this.config.responseChunkSize);
+            for (const chunk of chunks)await sendChannel.send(chunk);
+        } catch (error) {
+            this.logger.error("Discord adapter failed to handle message", error);
+            try {
+                await sendChannel.send("Sorry, I hit an error running that request.");
+            } catch  {}
+        }
+    }
+    constructor(config, gateway, logger){
+        _define_property(this, "config", void 0);
+        _define_property(this, "gateway", void 0);
+        _define_property(this, "client", void 0);
+        _define_property(this, "gatewayClient", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "started", void 0);
+        this.config = config;
+        this.gateway = gateway;
+        this.client = null;
+        this.gatewayClient = null;
+        this.started = false;
+        this.logger = logger || createLogger();
+    }
+}
+export { DEFAULT_DISCORD_RESPONSE_CHUNK, DiscordGatewayAdapter, extractSessionOverride, parseAgentIdFromSessionKey, resolveDiscordChannelSessionKey, splitDiscordMessage, stripDiscordBotMention };

package/dist/gateway/auth.cjs

@@ -0,0 +1,94 @@
+"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__, {
+    GatewayAuth: ()=>GatewayAuth
+});
+const external_crypto_namespaceObject = require("crypto");
+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 GatewayAuth {
+    generateToken() {
+        const token = (0, external_crypto_namespaceObject.randomBytes)(32).toString("hex");
+        this.tokens.add(token);
+        return token;
+    }
+    validate(auth, tailscaleUser) {
+        if ("none" === this.mode) return true;
+        if (this.allowTailscale && tailscaleUser) return true;
+        if ("token" === this.mode) {
+            if (!auth?.token) return false;
+            return this.tokens.has(auth.token);
+        }
+        if ("password" === this.mode) {
+            if (!auth?.password || !this.password) return false;
+            return auth.password === this.password;
+        }
+        return false;
+    }
+    addToken(token) {
+        this.tokens.add(token);
+    }
+    revokeToken(token) {
+        return this.tokens.delete(token);
+    }
+    getTokens() {
+        return Array.from(this.tokens);
+    }
+    isAuthRequired() {
+        return "none" !== this.mode;
+    }
+    setAuthRequired(required) {
+        this.mode = required ? "token" : "none";
+    }
+    constructor(config = {
+        mode: "none"
+    }, initialTokens = []){
+        _define_property(this, "tokens", void 0);
+        _define_property(this, "mode", void 0);
+        _define_property(this, "password", void 0);
+        _define_property(this, "allowTailscale", void 0);
+        this.mode = config.mode;
+        this.password = config.password;
+        this.allowTailscale = config.allowTailscale ?? false;
+        this.tokens = new Set(initialTokens);
+        if (config.token) this.tokens.add(config.token);
+    }
+}
+exports.GatewayAuth = __webpack_exports__.GatewayAuth;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GatewayAuth"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/auth.d.ts

@@ -0,0 +1,36 @@
+import type { GatewayAuthConfig, GatewayAuthPayload } from "./types.js";
+/**
+ * Simple token-based authentication for the gateway
+ */
+export declare class GatewayAuth {
+    private tokens;
+    private mode;
+    private password?;
+    private allowTailscale;
+    constructor(config?: GatewayAuthConfig, initialTokens?: string[]);
+    /**
+     * Generate a new authentication token
+     */
+    generateToken(): string;
+    /**
+     * Validate an authentication token
+     */
+    validate(auth?: GatewayAuthPayload, tailscaleUser?: string): boolean;
+    /**
+     * Add a token to the valid tokens set
+     */
+    addToken(token: string): void;
+    /**
+     * Remove a token from the valid tokens set
+     */
+    revokeToken(token: string): boolean;
+    /**
+     * Get all valid tokens
+     */
+    getTokens(): string[];
+    /**
+     * Check if authentication is required
+     */
+    isAuthRequired(): boolean;
+    setAuthRequired(required: boolean): void;
+}

package/dist/gateway/auth.js

@@ -0,0 +1,60 @@
+import { randomBytes } from "crypto";
+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 GatewayAuth {
+    generateToken() {
+        const token = randomBytes(32).toString("hex");
+        this.tokens.add(token);
+        return token;
+    }
+    validate(auth, tailscaleUser) {
+        if ("none" === this.mode) return true;
+        if (this.allowTailscale && tailscaleUser) return true;
+        if ("token" === this.mode) {
+            if (!auth?.token) return false;
+            return this.tokens.has(auth.token);
+        }
+        if ("password" === this.mode) {
+            if (!auth?.password || !this.password) return false;
+            return auth.password === this.password;
+        }
+        return false;
+    }
+    addToken(token) {
+        this.tokens.add(token);
+    }
+    revokeToken(token) {
+        return this.tokens.delete(token);
+    }
+    getTokens() {
+        return Array.from(this.tokens);
+    }
+    isAuthRequired() {
+        return "none" !== this.mode;
+    }
+    setAuthRequired(required) {
+        this.mode = required ? "token" : "none";
+    }
+    constructor(config = {
+        mode: "none"
+    }, initialTokens = []){
+        _define_property(this, "tokens", void 0);
+        _define_property(this, "mode", void 0);
+        _define_property(this, "password", void 0);
+        _define_property(this, "allowTailscale", void 0);
+        this.mode = config.mode;
+        this.password = config.password;
+        this.allowTailscale = config.allowTailscale ?? false;
+        this.tokens = new Set(initialTokens);
+        if (config.token) this.tokens.add(config.token);
+    }
+}
+export { GatewayAuth };

package/dist/gateway/broadcast.cjs

@@ -0,0 +1,131 @@
+"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__, {
+    BroadcastGroupManager: ()=>BroadcastGroupManager
+});
+const external_crypto_namespaceObject = require("crypto");
+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 BroadcastGroupManager {
+    createGroup(name, createdBy, description, strategy = "parallel") {
+        const id = this.generateGroupId();
+        const group = {
+            id,
+            name,
+            description,
+            createdAt: Date.now(),
+            createdBy,
+            members: new Set(),
+            strategy
+        };
+        this.groups.set(id, group);
+        return group;
+    }
+    getGroup(groupId) {
+        return this.groups.get(groupId);
+    }
+    getGroupByName(name) {
+        for (const group of this.groups.values())if (group.name === name) return group;
+    }
+    getOrCreateGroup(name, createdBy, description, strategy = "parallel") {
+        const existing = this.getGroupByName(name);
+        if (existing) return existing;
+        return this.createGroup(name, createdBy, description, strategy);
+    }
+    setGroupStrategy(groupId, strategy) {
+        const group = this.groups.get(groupId);
+        if (!group) return false;
+        group.strategy = strategy;
+        return true;
+    }
+    getGroupStrategy(groupId) {
+        const group = this.groups.get(groupId);
+        return group?.strategy;
+    }
+    deleteGroup(groupId) {
+        return this.groups.delete(groupId);
+    }
+    addNodeToGroup(groupId, nodeId) {
+        const group = this.groups.get(groupId);
+        if (!group) return false;
+        group.members.add(nodeId);
+        return true;
+    }
+    removeNodeFromGroup(groupId, nodeId) {
+        const group = this.groups.get(groupId);
+        if (!group) return false;
+        return group.members.delete(nodeId);
+    }
+    removeNodeFromAllGroups(nodeId) {
+        for (const group of this.groups.values())group.members.delete(nodeId);
+    }
+    getNodeGroups(nodeId) {
+        const nodeGroups = [];
+        for (const group of this.groups.values())if (group.members.has(nodeId)) nodeGroups.push(group);
+        return nodeGroups;
+    }
+    getAllGroups() {
+        return Array.from(this.groups.values());
+    }
+    getGroupMembers(groupId) {
+        const group = this.groups.get(groupId);
+        if (!group) return [];
+        return Array.from(group.members);
+    }
+    generateGroupId() {
+        return (0, external_crypto_namespaceObject.randomBytes)(16).toString("hex");
+    }
+    getStats() {
+        return {
+            totalGroups: this.groups.size,
+            groups: Array.from(this.groups.values()).map((g)=>({
+                    id: g.id,
+                    name: g.name,
+                    memberCount: g.members.size,
+                    createdAt: g.createdAt
+                }))
+        };
+    }
+    constructor(){
+        _define_property(this, "groups", void 0);
+        this.groups = new Map();
+    }
+}
+exports.BroadcastGroupManager = __webpack_exports__.BroadcastGroupManager;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BroadcastGroupManager"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/broadcast.d.ts

@@ -0,0 +1,76 @@
+import type { BroadcastGroup, BroadcastStrategy } from "./types.js";
+/**
+ * Manages broadcast groups for the gateway
+ */
+export declare class BroadcastGroupManager {
+    private groups;
+    constructor();
+    /**
+     * Create a new broadcast group
+     */
+    createGroup(name: string, createdBy: string, description?: string, strategy?: BroadcastStrategy): BroadcastGroup;
+    /**
+     * Get a group by ID
+     */
+    getGroup(groupId: string): BroadcastGroup | undefined;
+    /**
+     * Get a group by name
+     */
+    getGroupByName(name: string): BroadcastGroup | undefined;
+    /**
+     * Get or create a group by name
+     */
+    getOrCreateGroup(name: string, createdBy: string, description?: string, strategy?: BroadcastStrategy): BroadcastGroup;
+    /**
+     * Update group strategy
+     */
+    setGroupStrategy(groupId: string, strategy: BroadcastStrategy): boolean;
+    /**
+     * Get group strategy
+     */
+    getGroupStrategy(groupId: string): BroadcastStrategy | undefined;
+    /**
+     * Delete a group
+     */
+    deleteGroup(groupId: string): boolean;
+    /**
+     * Add a node to a group
+     */
+    addNodeToGroup(groupId: string, nodeId: string): boolean;
+    /**
+     * Remove a node from a group
+     */
+    removeNodeFromGroup(groupId: string, nodeId: string): boolean;
+    /**
+     * Remove a node from all groups
+     */
+    removeNodeFromAllGroups(nodeId: string): void;
+    /**
+     * Get all groups a node is a member of
+     */
+    getNodeGroups(nodeId: string): BroadcastGroup[];
+    /**
+     * Get all groups
+     */
+    getAllGroups(): BroadcastGroup[];
+    /**
+     * Get group member IDs
+     */
+    getGroupMembers(groupId: string): string[];
+    /**
+     * Generate a unique group ID
+     */
+    private generateGroupId;
+    /**
+     * Get statistics
+     */
+    getStats(): {
+        totalGroups: number;
+        groups: {
+            id: string;
+            name: string;
+            memberCount: number;
+            createdAt: number;
+        }[];
+    };
+}