@wingman-ai/gateway 0.1.0

package/dist/gateway/hooks/registry.js

@@ -0,0 +1,94 @@
+import { InternalHookLoader } from "./loader.js";
+import { AgentInvoker } from "../../cli/core/agentInvoker.js";
+import { OutputManager } from "../../cli/core/outputManager.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 InternalHookRegistry {
+    async load() {
+        if (!this.config?.enabled) return;
+        const loader = new 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("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({
+                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();
+    }
+}
+export { InternalHookRegistry };

package/dist/gateway/hooks/types.cjs

@@ -0,0 +1,58 @@
+"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__, {
+    HookDeliverSchema: ()=>HookDeliverSchema,
+    HookEntrySchema: ()=>HookEntrySchema,
+    InternalHooksConfigSchema: ()=>InternalHooksConfigSchema
+});
+const external_zod_namespaceObject = require("zod");
+const HookDeliverSchema = external_zod_namespaceObject.z.object({
+    agentId: external_zod_namespaceObject.z.string().min(1),
+    sessionKey: external_zod_namespaceObject.z.string().optional(),
+    message: external_zod_namespaceObject.z.string().optional()
+});
+const HookEntrySchema = external_zod_namespaceObject.z.object({
+    enabled: external_zod_namespaceObject.z.boolean().default(true),
+    deliver: HookDeliverSchema.optional()
+});
+const InternalHooksConfigSchema = external_zod_namespaceObject.z.object({
+    enabled: external_zod_namespaceObject.z.boolean().default(false),
+    entries: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), HookEntrySchema).optional(),
+    load: external_zod_namespaceObject.z.object({
+        extraDirs: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional()
+    }).optional()
+});
+exports.HookDeliverSchema = __webpack_exports__.HookDeliverSchema;
+exports.HookEntrySchema = __webpack_exports__.HookEntrySchema;
+exports.InternalHooksConfigSchema = __webpack_exports__.InternalHooksConfigSchema;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HookDeliverSchema",
+    "HookEntrySchema",
+    "InternalHooksConfigSchema"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { RoutingInfo } from "../types.js";
+export declare const HookDeliverSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    sessionKey: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const HookEntrySchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    deliver: z.ZodOptional<z.ZodObject<{
+        agentId: z.ZodString;
+        sessionKey: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const InternalHooksConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    entries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        deliver: z.ZodOptional<z.ZodObject<{
+            agentId: z.ZodString;
+            sessionKey: z.ZodOptional<z.ZodString>;
+            message: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    load: z.ZodOptional<z.ZodObject<{
+        extraDirs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type InternalHooksConfig = z.infer<typeof InternalHooksConfigSchema>;
+export type HookEntryConfig = z.infer<typeof HookEntrySchema>;
+export type HookDeliverConfig = z.infer<typeof HookDeliverSchema>;
+export type HookEvent = {
+    type: "gateway" | "session" | "message" | "command";
+    action: string;
+    timestamp: Date;
+    agentId?: string;
+    sessionKey?: string;
+    routing?: RoutingInfo;
+    payload?: Record<string, any>;
+    messages: string[];
+};
+export type HookHandler = (event: HookEvent) => Promise<void> | void;
+export type HookDefinition = {
+    name: string;
+    description?: string;
+    events: string[];
+    handler: HookHandler;
+    entry?: HookEntryConfig;
+};

package/dist/gateway/hooks/types.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+const HookDeliverSchema = z.object({
+    agentId: z.string().min(1),
+    sessionKey: z.string().optional(),
+    message: z.string().optional()
+});
+const HookEntrySchema = z.object({
+    enabled: z.boolean().default(true),
+    deliver: HookDeliverSchema.optional()
+});
+const InternalHooksConfigSchema = z.object({
+    enabled: z.boolean().default(false),
+    entries: z.record(z.string(), HookEntrySchema).optional(),
+    load: z.object({
+        extraDirs: z.array(z.string()).optional()
+    }).optional()
+});
+export { HookDeliverSchema, HookEntrySchema, InternalHooksConfigSchema };

package/dist/gateway/http/agents.cjs

@@ -0,0 +1,280 @@
+"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__, {
+    handleAgentsApi: ()=>handleAgentsApi
+});
+const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
+const toolRegistry_cjs_namespaceObject = require("../../agent/config/toolRegistry.cjs");
+const external_router_cjs_namespaceObject = require("../router.cjs");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_js_yaml_namespaceObject = require("js-yaml");
+const voice_cjs_namespaceObject = require("../../types/voice.cjs");
+const buildAgentMarkdown = (params)=>{
+    const { id, description, tools, model, prompt, voice } = params;
+    const metadata = {
+        name: id,
+        description: description || "New Wingman agent",
+        tools: tools || []
+    };
+    if (model) metadata.model = model;
+    if (voice) metadata.voice = voice;
+    return serializeAgentMarkdown(metadata, prompt || "You are a Wingman agent.");
+};
+const parseAgentMarkdown = (content)=>{
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) throw new Error("Invalid agent.md format: missing frontmatter");
+    const [, rawFrontmatter, prompt] = match;
+    const metadata = external_js_yaml_namespaceObject.load(rawFrontmatter) || {};
+    return {
+        metadata,
+        prompt: prompt?.trim() || ""
+    };
+};
+const serializeAgentMarkdown = (metadata, prompt)=>{
+    const frontmatter = external_js_yaml_namespaceObject.dump(metadata, {
+        lineWidth: 120
+    });
+    const safePrompt = prompt?.trim() || "You are a Wingman agent.";
+    return `---\n${frontmatter}---\n\n${safePrompt}\n`;
+};
+const handleAgentsApi = async (ctx, req, url)=>{
+    const config = ctx.getWingmanConfig();
+    if ("/api/agents" === url.pathname) {
+        if ("GET" === req.method) {
+            const loader = new agentLoader_cjs_namespaceObject.AgentLoader(ctx.configDir, ctx.workspace, config);
+            const configs = loader.loadAllAgentConfigs();
+            const displayNames = config.agents?.list?.reduce((acc, agent)=>{
+                if (agent.name) acc[agent.id] = agent.name;
+                return acc;
+            }, {}) || {};
+            const agents = configs.map((agent)=>({
+                    id: agent.name,
+                    displayName: displayNames[agent.name] || agent.name,
+                    description: agent.description,
+                    tools: agent.tools || [],
+                    model: agent.model,
+                    voice: agent.voice,
+                    subAgents: agent.subAgents?.map((sub)=>({
+                            id: sub.name,
+                            displayName: sub.name,
+                            description: sub.description,
+                            tools: sub.tools || [],
+                            model: sub.model
+                        })) || []
+                }));
+            return new Response(JSON.stringify({
+                agents,
+                tools: (0, toolRegistry_cjs_namespaceObject.getAvailableTools)(),
+                builtInTools: ctx.getBuiltInTools()
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("POST" === req.method) {
+            const body = await req.json();
+            let parsedVoice;
+            if (body?.voice !== void 0 && null !== body.voice) {
+                const voiceResult = voice_cjs_namespaceObject.AgentVoiceConfigSchema.safeParse(body.voice);
+                if (!voiceResult.success) return new Response("Invalid voice configuration", {
+                    status: 400
+                });
+                parsedVoice = voiceResult.data;
+            }
+            const id = body?.id?.trim();
+            if (!id || !/^[a-zA-Z0-9_-]+$/.test(id)) return new Response("Invalid agent id", {
+                status: 400
+            });
+            const tools = Array.isArray(body.tools) ? body.tools.filter((tool)=>(0, toolRegistry_cjs_namespaceObject.getAvailableTools)().includes(tool)) : [];
+            const agentsDir = (0, external_node_path_namespaceObject.join)(ctx.resolveConfigDirPath(), "agents", id);
+            if ((0, external_node_fs_namespaceObject.existsSync)(agentsDir)) return new Response("Agent already exists", {
+                status: 409
+            });
+            (0, external_node_fs_namespaceObject.mkdirSync)(agentsDir, {
+                recursive: true
+            });
+            const agentMarkdown = buildAgentMarkdown({
+                id,
+                description: body.description,
+                tools,
+                model: body.model,
+                prompt: body.prompt,
+                voice: parsedVoice
+            });
+            (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(agentsDir, "agent.md"), agentMarkdown);
+            const agentList = config.agents?.list || [];
+            agentList.push({
+                id,
+                name: body.displayName || id
+            });
+            const nextConfig = {
+                ...config,
+                agents: {
+                    list: agentList,
+                    bindings: config.agents?.bindings || []
+                }
+            };
+            ctx.setWingmanConfig(nextConfig);
+            ctx.setRouter(new external_router_cjs_namespaceObject.GatewayRouter(nextConfig));
+            ctx.persistWingmanConfig();
+            return new Response(JSON.stringify({
+                id,
+                displayName: body.displayName || id,
+                description: body.description,
+                tools,
+                model: body.model,
+                voice: parsedVoice
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    const agentDetailMatch = url.pathname.match(/^\/api\/agents\/([^/]+)$/);
+    if (!agentDetailMatch) return null;
+    const agentId = decodeURIComponent(agentDetailMatch[1]);
+    const loader = new agentLoader_cjs_namespaceObject.AgentLoader(ctx.configDir, ctx.workspace, config);
+    const configs = loader.loadAllAgentConfigs();
+    const agentConfig = configs.find((item)=>item.name === agentId);
+    const displayName = config.agents?.list?.find((agent)=>agent.id === agentId)?.name || agentId;
+    if ("GET" === req.method) {
+        if (!agentConfig) return new Response("Agent not found", {
+            status: 404
+        });
+        return new Response(JSON.stringify({
+            id: agentConfig.name,
+            displayName,
+            description: agentConfig.description,
+            tools: agentConfig.tools || [],
+            model: agentConfig.model,
+            voice: agentConfig.voice,
+            prompt: agentConfig.systemPrompt
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("PUT" === req.method) {
+        if (!agentConfig) return new Response("Agent not found", {
+            status: 404
+        });
+        const body = await req.json();
+        let parsedVoice;
+        if (body?.voice === null) parsedVoice = null;
+        else if (body?.voice !== void 0) {
+            const voiceResult = voice_cjs_namespaceObject.AgentVoiceConfigSchema.safeParse(body.voice);
+            if (!voiceResult.success) return new Response("Invalid voice configuration", {
+                status: 400
+            });
+            parsedVoice = voiceResult.data;
+        }
+        const tools = Array.isArray(body.tools) ? body.tools.filter((tool)=>(0, toolRegistry_cjs_namespaceObject.getAvailableTools)().includes(tool)) : agentConfig.tools || [];
+        const nextDescription = body.description ?? agentConfig.description;
+        const nextModel = body.model ?? agentConfig.model;
+        const nextPrompt = body.prompt ?? agentConfig.systemPrompt;
+        const nextVoice = void 0 === parsedVoice ? agentConfig.voice : parsedVoice;
+        const agentsDir = (0, external_node_path_namespaceObject.join)(ctx.resolveConfigDirPath(), "agents", agentId);
+        const agentJsonPath = (0, external_node_path_namespaceObject.join)(agentsDir, "agent.json");
+        const agentMarkdownPath = (0, external_node_path_namespaceObject.join)(agentsDir, "agent.md");
+        const hasJson = (0, external_node_fs_namespaceObject.existsSync)(agentJsonPath);
+        const hasMarkdown = (0, external_node_fs_namespaceObject.existsSync)(agentMarkdownPath);
+        if (!hasJson && !hasMarkdown) return new Response("Agent not found", {
+            status: 404
+        });
+        if (hasJson) {
+            const raw = (0, external_node_fs_namespaceObject.readFileSync)(agentJsonPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            parsed.name = agentId;
+            parsed.description = nextDescription;
+            parsed.tools = tools;
+            if (nextModel) parsed.model = nextModel;
+            else delete parsed.model;
+            parsed.systemPrompt = nextPrompt;
+            if (nextVoice) parsed.voice = nextVoice;
+            else delete parsed.voice;
+            (0, external_node_fs_namespaceObject.writeFileSync)(agentJsonPath, JSON.stringify(parsed, null, 2));
+        } else if (hasMarkdown) {
+            const raw = (0, external_node_fs_namespaceObject.readFileSync)(agentMarkdownPath, "utf-8");
+            const { metadata } = parseAgentMarkdown(raw);
+            metadata.name = agentId;
+            metadata.description = nextDescription;
+            metadata.tools = tools;
+            if (nextModel) metadata.model = nextModel;
+            else delete metadata.model;
+            if (nextVoice) metadata.voice = nextVoice;
+            else delete metadata.voice;
+            const updatedMarkdown = serializeAgentMarkdown(metadata, nextPrompt);
+            (0, external_node_fs_namespaceObject.writeFileSync)(agentMarkdownPath, updatedMarkdown);
+        }
+        if (config.agents?.list) {
+            const nextList = config.agents.list.map((agent)=>agent.id === agentId ? {
+                    ...agent,
+                    name: body.displayName || agent.name || agentId
+                } : agent);
+            const nextConfig = {
+                ...config,
+                agents: {
+                    list: nextList,
+                    bindings: config.agents?.bindings || []
+                }
+            };
+            ctx.setWingmanConfig(nextConfig);
+            ctx.setRouter(new external_router_cjs_namespaceObject.GatewayRouter(nextConfig));
+            ctx.persistWingmanConfig();
+        }
+        return new Response(JSON.stringify({
+            id: agentId,
+            displayName: body.displayName || displayName || agentId,
+            description: nextDescription,
+            tools,
+            model: nextModel,
+            voice: nextVoice,
+            prompt: nextPrompt
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return new Response("Method Not Allowed", {
+        status: 405
+    });
+};
+exports.handleAgentsApi = __webpack_exports__.handleAgentsApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleAgentsApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/http/agents.d.ts

@@ -0,0 +1,2 @@
+import type { GatewayHttpContext } from "./types.js";
+export declare const handleAgentsApi: (ctx: GatewayHttpContext, req: Request, url: URL) => Promise<Response | null>;