@wingman-ai/gateway 0.1.0

package/dist/gateway/discovery/tailscale.js

@@ -0,0 +1,106 @@
+import { exec } from "child_process";
+import { promisify } from "util";
+import { createLogger } from "../../logger.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 execAsync = promisify(exec);
+const logger = createLogger();
+class TailscaleDiscoveryService {
+    async announce(config) {
+        this.isAnnouncing = true;
+        this.config = config;
+    }
+    async stopAnnouncing() {
+        this.isAnnouncing = false;
+        this.config = null;
+    }
+    async discover(timeout = 5000) {
+        try {
+            const devices = await this.getTailscaleDevices();
+            const gateways = [];
+            for (const device of devices){
+                if (!device.online) continue;
+                const isGateway = device.tags?.some((tag)=>tag.toLowerCase().includes("wingman-gateway")) || device.hostname.toLowerCase().includes("gateway");
+                if (!isGateway) continue;
+                const gatewayInfo = await this.probeGateway(device.ip, 3000);
+                if (gatewayInfo) gateways.push(gatewayInfo);
+            }
+            return gateways;
+        } catch (error) {
+            logger.error("Tailscale discovery failed", error);
+            return [];
+        }
+    }
+    async getTailscaleDevices() {
+        try {
+            const { stdout } = await execAsync("tailscale status --json");
+            const status = JSON.parse(stdout);
+            const devices = [];
+            if (status.Peer) for (const [id, peerData] of Object.entries(status.Peer)){
+                const peer = peerData;
+                devices.push({
+                    id,
+                    hostname: peer.HostName || peer.DNSName?.split(".")[0] || id,
+                    ip: peer.TailscaleIPs?.[0] || peer.Addrs?.[0]?.split(":")[0] || "",
+                    online: peer.Online ?? false,
+                    tags: peer.Tags || []
+                });
+            }
+            return devices;
+        } catch (error) {
+            logger.error("Failed to get Tailscale devices", error);
+            return [];
+        }
+    }
+    async probeGateway(ip, port) {
+        try {
+            const response = await fetch(`http://${ip}:${port}/health`, {
+                signal: AbortSignal.timeout(2000)
+            });
+            if (!response.ok) return null;
+            const health = await response.json();
+            if ("wingman-gateway" !== health.service) return null;
+            let capabilities = [
+                "broadcast",
+                "direct",
+                "groups"
+            ];
+            let version = "1.0.0";
+            try {
+                const statsResponse = await fetch(`http://${ip}:${port}/stats`, {
+                    signal: AbortSignal.timeout(2000)
+                });
+                if (statsResponse.ok) {
+                    const stats = await statsResponse.json();
+                    if (stats.capabilities) capabilities = stats.capabilities;
+                    if (stats.version) version = stats.version;
+                }
+            } catch  {}
+            return {
+                name: health.name || `Gateway-${ip}`,
+                url: `ws://${ip}:${port}/ws`,
+                host: ip,
+                port,
+                requireAuth: health.requireAuth ?? false,
+                capabilities,
+                version,
+                transport: "ws"
+            };
+        } catch (error) {
+            return null;
+        }
+    }
+    constructor(){
+        _define_property(this, "isAnnouncing", false);
+        _define_property(this, "config", null);
+    }
+}
+export { TailscaleDiscoveryService };

package/dist/gateway/discovery/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/discovery/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Discovered gateway information
+ */
+export interface DiscoveredGateway {
+    name: string;
+    url: string;
+    host: string;
+    port: number;
+    requireAuth: boolean;
+    capabilities: string[];
+    version: string;
+    transport: "ws" | "wss";
+}
+/**
+ * Discovery service interface
+ */
+export interface DiscoveryService {
+    /**
+     * Start announcing this gateway
+     */
+    announce(config: DiscoveryConfig): Promise<void>;
+    /**
+     * Stop announcing this gateway
+     */
+    stopAnnouncing(): Promise<void>;
+    /**
+     * Discover available gateways
+     */
+    discover(timeout?: number): Promise<DiscoveredGateway[]>;
+}
+/**
+ * Discovery configuration
+ */
+export interface DiscoveryConfig {
+    name: string;
+    port: number;
+    requireAuth: boolean;
+    capabilities: string[];
+    version: string;
+    transport: "ws" | "wss";
+}

package/dist/gateway/env.cjs

@@ -0,0 +1,45 @@
+"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__, {
+    GATEWAY_TOKEN_ENV: ()=>GATEWAY_TOKEN_ENV,
+    getGatewayTokenFromEnv: ()=>getGatewayTokenFromEnv
+});
+const GATEWAY_TOKEN_ENV = "WINGMAN_GATEWAY_TOKEN";
+function getGatewayTokenFromEnv() {
+    const raw = process.env[GATEWAY_TOKEN_ENV];
+    if (!raw) return;
+    const token = raw.trim();
+    return token.length > 0 ? token : void 0;
+}
+exports.GATEWAY_TOKEN_ENV = __webpack_exports__.GATEWAY_TOKEN_ENV;
+exports.getGatewayTokenFromEnv = __webpack_exports__.getGatewayTokenFromEnv;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "GATEWAY_TOKEN_ENV",
+    "getGatewayTokenFromEnv"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/env.d.ts

@@ -0,0 +1,2 @@
+export declare const GATEWAY_TOKEN_ENV = "WINGMAN_GATEWAY_TOKEN";
+export declare function getGatewayTokenFromEnv(): string | undefined;

package/dist/gateway/env.js

@@ -0,0 +1,8 @@
+const GATEWAY_TOKEN_ENV = "WINGMAN_GATEWAY_TOKEN";
+function getGatewayTokenFromEnv() {
+    const raw = process.env[GATEWAY_TOKEN_ENV];
+    if (!raw) return;
+    const token = raw.trim();
+    return token.length > 0 ? token : void 0;
+}
+export { GATEWAY_TOKEN_ENV, getGatewayTokenFromEnv };

package/dist/gateway/hooks/loader.cjs

@@ -0,0 +1,137 @@
+"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__, {
+    InternalHookLoader: ()=>InternalHookLoader
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_url_namespaceObject = require("node:url");
+const external_js_yaml_namespaceObject = require("js-yaml");
+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 parseFrontmatter = (content)=>{
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) throw new Error("Invalid HOOK.md format: missing frontmatter");
+    const [, frontmatter] = match;
+    const meta = external_js_yaml_namespaceObject.load(frontmatter) || {};
+    return {
+        meta
+    };
+};
+const resolveHandlerPath = (dir)=>{
+    const candidates = [
+        "handler.ts",
+        "handler.js",
+        "index.ts",
+        "index.js"
+    ];
+    for (const candidate of candidates){
+        const path = (0, external_node_path_namespaceObject.join)(dir, candidate);
+        if ((0, external_node_fs_namespaceObject.existsSync)(path)) return path;
+    }
+    return null;
+};
+class InternalHookLoader {
+    async load() {
+        if (!this.config?.enabled) return [];
+        const entries = this.config.entries || {};
+        const enabledEntries = Object.entries(entries).filter(([, entry])=>entry?.enabled !== false);
+        const enabledNames = new Set(enabledEntries.map(([name])=>name));
+        const dirs = [
+            (0, external_node_path_namespaceObject.join)(this.baseDir, "hooks"),
+            ...this.config.load?.extraDirs || []
+        ];
+        const hooks = [];
+        for (const dir of dirs){
+            if (!(0, external_node_fs_namespaceObject.existsSync)(dir) || !(0, external_node_fs_namespaceObject.statSync)(dir).isDirectory()) continue;
+            const hookDirs = (0, external_node_fs_namespaceObject.readdirSync)(dir, {
+                withFileTypes: true
+            }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
+            for (const hookDirName of hookDirs){
+                const hookDir = (0, external_node_path_namespaceObject.join)(dir, hookDirName);
+                const hookDoc = (0, external_node_path_namespaceObject.join)(hookDir, "HOOK.md");
+                if ((0, external_node_fs_namespaceObject.existsSync)(hookDoc)) try {
+                    const hookDocContent = await Bun.file(hookDoc).text();
+                    const { meta } = parseFrontmatter(hookDocContent);
+                    const name = meta.name || hookDirName;
+                    if (!enabledNames.has(name)) continue;
+                    const handlerPath = resolveHandlerPath(hookDir);
+                    if (!handlerPath) {
+                        this.logger.warn(`Hook ${name} missing handler file`);
+                        continue;
+                    }
+                    const mod = await import((0, external_node_url_namespaceObject.pathToFileURL)(handlerPath).href);
+                    const exportName = meta.export || "default";
+                    const handler = mod[exportName];
+                    if (!handler) {
+                        this.logger.warn(`Hook ${name} missing export: ${exportName}`);
+                        continue;
+                    }
+                    const events = Array.isArray(meta.events) ? meta.events : [];
+                    if (0 === events.length) {
+                        this.logger.warn(`Hook ${name} missing events`);
+                        continue;
+                    }
+                    const entry = entries[name];
+                    hooks.push({
+                        name,
+                        description: meta.description,
+                        events,
+                        handler,
+                        entry
+                    });
+                } catch (error) {
+                    this.logger.error(`Failed to load hook from ${hookDir}: ${error}`);
+                }
+            }
+        }
+        return hooks;
+    }
+    constructor(baseDir, config, logger){
+        _define_property(this, "baseDir", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "logger", void 0);
+        this.baseDir = baseDir;
+        this.config = config;
+        this.logger = logger;
+    }
+}
+exports.InternalHookLoader = __webpack_exports__.InternalHookLoader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "InternalHookLoader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/hooks/loader.d.ts

@@ -0,0 +1,10 @@
+import type { HookDefinition } from "./types.js";
+import type { InternalHooksConfig } from "./types.js";
+import type { Logger } from "@/logger.js";
+export declare class InternalHookLoader {
+    private baseDir;
+    private config;
+    private logger;
+    constructor(baseDir: string, config: InternalHooksConfig | undefined, logger: Logger);
+    load(): Promise<HookDefinition[]>;
+}

package/dist/gateway/hooks/loader.js

@@ -0,0 +1,103 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { load } from "js-yaml";
+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 parseFrontmatter = (content)=>{
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) throw new Error("Invalid HOOK.md format: missing frontmatter");
+    const [, frontmatter] = match;
+    const meta = load(frontmatter) || {};
+    return {
+        meta
+    };
+};
+const resolveHandlerPath = (dir)=>{
+    const candidates = [
+        "handler.ts",
+        "handler.js",
+        "index.ts",
+        "index.js"
+    ];
+    for (const candidate of candidates){
+        const path = join(dir, candidate);
+        if (existsSync(path)) return path;
+    }
+    return null;
+};
+class InternalHookLoader {
+    async load() {
+        if (!this.config?.enabled) return [];
+        const entries = this.config.entries || {};
+        const enabledEntries = Object.entries(entries).filter(([, entry])=>entry?.enabled !== false);
+        const enabledNames = new Set(enabledEntries.map(([name])=>name));
+        const dirs = [
+            join(this.baseDir, "hooks"),
+            ...this.config.load?.extraDirs || []
+        ];
+        const hooks = [];
+        for (const dir of dirs){
+            if (!existsSync(dir) || !statSync(dir).isDirectory()) continue;
+            const hookDirs = readdirSync(dir, {
+                withFileTypes: true
+            }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name);
+            for (const hookDirName of hookDirs){
+                const hookDir = join(dir, hookDirName);
+                const hookDoc = join(hookDir, "HOOK.md");
+                if (existsSync(hookDoc)) try {
+                    const hookDocContent = await Bun.file(hookDoc).text();
+                    const { meta } = parseFrontmatter(hookDocContent);
+                    const name = meta.name || hookDirName;
+                    if (!enabledNames.has(name)) continue;
+                    const handlerPath = resolveHandlerPath(hookDir);
+                    if (!handlerPath) {
+                        this.logger.warn(`Hook ${name} missing handler file`);
+                        continue;
+                    }
+                    const mod = await import(pathToFileURL(handlerPath).href);
+                    const exportName = meta.export || "default";
+                    const handler = mod[exportName];
+                    if (!handler) {
+                        this.logger.warn(`Hook ${name} missing export: ${exportName}`);
+                        continue;
+                    }
+                    const events = Array.isArray(meta.events) ? meta.events : [];
+                    if (0 === events.length) {
+                        this.logger.warn(`Hook ${name} missing events`);
+                        continue;
+                    }
+                    const entry = entries[name];
+                    hooks.push({
+                        name,
+                        description: meta.description,
+                        events,
+                        handler,
+                        entry
+                    });
+                } catch (error) {
+                    this.logger.error(`Failed to load hook from ${hookDir}: ${error}`);
+                }
+            }
+        }
+        return hooks;
+    }
+    constructor(baseDir, config, logger){
+        _define_property(this, "baseDir", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "logger", void 0);
+        this.baseDir = baseDir;
+        this.config = config;
+        this.logger = logger;
+    }
+}
+export { InternalHookLoader };

package/dist/gateway/hooks/registry.cjs

@@ -0,0 +1,128 @@
+"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__, {
+    InternalHookRegistry: ()=>InternalHookRegistry
+});
+const external_loader_cjs_namespaceObject = require("./loader.cjs");
+const agentInvoker_cjs_namespaceObject = require("../../cli/core/agentInvoker.cjs");
+const outputManager_cjs_namespaceObject = require("../../cli/core/outputManager.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 InternalHookRegistry {
+    async load() {
+        if (!this.config?.enabled) return;
+        const loader = new external_loader_cjs_namespaceObject.InternalHookLoader(this.ctx.resolveConfigDirPath(), this.config, this.ctx.logger);
+        this.hooks = await loader.load();
+        this.eventMap.clear();
+        for (const hook of this.hooks)for (const eventName of hook.events){
+            const list = this.eventMap.get(eventName) || [];
+            list.push(hook);
+            this.eventMap.set(eventName, list);
+        }
+    }
+    emit(event) {
+        if (!this.config?.enabled) return;
+        const key = `${event.type}:${event.action}`;
+        const hooks = [
+            ...this.eventMap.get(key) || [],
+            ...this.eventMap.get("*") || []
+        ];
+        if (0 === hooks.length) return;
+        for (const hook of hooks)this.runHook(hook, event);
+    }
+    async runHook(hook, baseEvent) {
+        const event = {
+            ...baseEvent,
+            messages: []
+        };
+        try {
+            await hook.handler(event);
+        } catch (error) {
+            this.ctx.logger.error(`Hook ${hook.name} failed`, error);
+        }
+        if (hook.entry?.deliver) await this.deliverToAgent(hook, event, hook.entry.deliver);
+    }
+    async deliverToAgent(hook, event, deliver) {
+        const agentId = "last" === deliver.agentId ? event.agentId || this.ctx.router.selectAgent() : deliver.agentId;
+        if (!agentId) return void this.ctx.logger.warn(`Hook ${hook.name} has no target agent`);
+        const sessionKey = deliver.sessionKey || event.sessionKey || `agent:${agentId}:hook:${hook.name}`;
+        const message = deliver.message || (event.messages.length > 0 ? event.messages.join("\n") : event.payload ? JSON.stringify(event.payload, null, 2) : `Hook "${hook.name}" triggered (${event.type}:${event.action}).`);
+        try {
+            const manager = await this.ctx.getSessionManager(agentId);
+            manager.getOrCreateSession(sessionKey, agentId, `Hook: ${hook.name}`);
+            manager.updateSession(sessionKey, {
+                lastMessagePreview: message.substring(0, 200)
+            });
+            manager.updateSessionMetadata(sessionKey, {
+                source: "hook",
+                hookName: hook.name,
+                action: `${event.type}:${event.action}`
+            });
+            const outputManager = new outputManager_cjs_namespaceObject.OutputManager("interactive");
+            const workspace = this.ctx.resolveAgentWorkspace(agentId);
+            const session = manager.getSession(sessionKey);
+            const workdir = session?.metadata?.workdir ?? null;
+            const defaultOutputDir = this.ctx.resolveDefaultOutputDir(agentId);
+            const invoker = new agentInvoker_cjs_namespaceObject.AgentInvoker({
+                workspace,
+                configDir: this.ctx.configDir,
+                outputManager,
+                logger: this.ctx.logger,
+                sessionManager: manager,
+                workdir,
+                defaultOutputDir
+            });
+            invoker.invokeAgent(agentId, message, sessionKey);
+        } catch (error) {
+            this.ctx.logger.error(`Hook ${hook.name} delivery failed`, error);
+        }
+    }
+    constructor(ctx, config){
+        _define_property(this, "ctx", void 0);
+        _define_property(this, "config", void 0);
+        _define_property(this, "hooks", void 0);
+        _define_property(this, "eventMap", void 0);
+        this.ctx = ctx;
+        this.config = config;
+        this.hooks = [];
+        this.eventMap = new Map();
+    }
+}
+exports.InternalHookRegistry = __webpack_exports__.InternalHookRegistry;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "InternalHookRegistry"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/hooks/registry.d.ts

@@ -0,0 +1,13 @@
+import type { HookEvent, InternalHooksConfig } from "./types.js";
+import type { GatewayHttpContext } from "../http/types.js";
+export declare class InternalHookRegistry {
+    private ctx;
+    private config;
+    private hooks;
+    private eventMap;
+    constructor(ctx: GatewayHttpContext, config: InternalHooksConfig | undefined);
+    load(): Promise<void>;
+    emit(event: Omit<HookEvent, "messages">): void;
+    private runHook;
+    private deliverToAgent;
+}