@wingman-ai/gateway 0.1.0

package/dist/gateway/http/agents.js

@@ -0,0 +1,246 @@
+import { AgentLoader } from "../../agent/config/agentLoader.js";
+import { getAvailableTools } from "../../agent/config/toolRegistry.js";
+import { GatewayRouter } from "../router.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dump, load } from "js-yaml";
+import { AgentVoiceConfigSchema } from "../../types/voice.js";
+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 = load(rawFrontmatter) || {};
+    return {
+        metadata,
+        prompt: prompt?.trim() || ""
+    };
+};
+const serializeAgentMarkdown = (metadata, prompt)=>{
+    const frontmatter = 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(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: 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 = 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)=>getAvailableTools().includes(tool)) : [];
+            const agentsDir = join(ctx.resolveConfigDirPath(), "agents", id);
+            if (existsSync(agentsDir)) return new Response("Agent already exists", {
+                status: 409
+            });
+            mkdirSync(agentsDir, {
+                recursive: true
+            });
+            const agentMarkdown = buildAgentMarkdown({
+                id,
+                description: body.description,
+                tools,
+                model: body.model,
+                prompt: body.prompt,
+                voice: parsedVoice
+            });
+            writeFileSync(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 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(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 = 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)=>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 = join(ctx.resolveConfigDirPath(), "agents", agentId);
+        const agentJsonPath = join(agentsDir, "agent.json");
+        const agentMarkdownPath = join(agentsDir, "agent.md");
+        const hasJson = existsSync(agentJsonPath);
+        const hasMarkdown = existsSync(agentMarkdownPath);
+        if (!hasJson && !hasMarkdown) return new Response("Agent not found", {
+            status: 404
+        });
+        if (hasJson) {
+            const raw = 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;
+            writeFileSync(agentJsonPath, JSON.stringify(parsed, null, 2));
+        } else if (hasMarkdown) {
+            const raw = 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);
+            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 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
+    });
+};
+export { handleAgentsApi };

package/dist/gateway/http/fs.cjs

@@ -0,0 +1,81 @@
+"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__, {
+    handleFsApi: ()=>handleFsApi
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const handleFsApi = async (ctx, req, url)=>{
+    if ("/api/fs/roots" === url.pathname && "GET" === req.method) {
+        const roots = ctx.resolveFsRoots();
+        return new Response(JSON.stringify({
+            roots
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("/api/fs/list" === url.pathname && "GET" === req.method) {
+        const rawPath = url.searchParams.get("path");
+        if (!rawPath) return new Response("path required", {
+            status: 400
+        });
+        const resolved = ctx.resolveFsPath(rawPath);
+        const roots = ctx.resolveFsRoots();
+        if (!ctx.isPathWithinRoots(resolved, roots)) return new Response("path not allowed", {
+            status: 403
+        });
+        if (!(0, external_node_fs_namespaceObject.existsSync)(resolved) || !(0, external_node_fs_namespaceObject.statSync)(resolved).isDirectory()) return new Response("path not found", {
+            status: 404
+        });
+        const entries = (0, external_node_fs_namespaceObject.readdirSync)(resolved, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory()).map((entry)=>({
+                name: entry.name,
+                path: (0, external_node_path_namespaceObject.join)(resolved, entry.name)
+            })).sort((a, b)=>a.name.localeCompare(b.name));
+        const parent = (0, external_node_path_namespaceObject.normalize)((0, external_node_path_namespaceObject.join)(resolved, ".."));
+        const parentAllowed = parent !== resolved && ctx.isPathWithinRoots(parent, roots) ? parent : null;
+        return new Response(JSON.stringify({
+            path: resolved,
+            parent: parentAllowed,
+            entries
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return null;
+};
+exports.handleFsApi = __webpack_exports__.handleFsApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleFsApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/gateway/http/fs.js

@@ -0,0 +1,47 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join, normalize } from "node:path";
+const handleFsApi = async (ctx, req, url)=>{
+    if ("/api/fs/roots" === url.pathname && "GET" === req.method) {
+        const roots = ctx.resolveFsRoots();
+        return new Response(JSON.stringify({
+            roots
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("/api/fs/list" === url.pathname && "GET" === req.method) {
+        const rawPath = url.searchParams.get("path");
+        if (!rawPath) return new Response("path required", {
+            status: 400
+        });
+        const resolved = ctx.resolveFsPath(rawPath);
+        const roots = ctx.resolveFsRoots();
+        if (!ctx.isPathWithinRoots(resolved, roots)) return new Response("path not allowed", {
+            status: 403
+        });
+        if (!existsSync(resolved) || !statSync(resolved).isDirectory()) return new Response("path not found", {
+            status: 404
+        });
+        const entries = readdirSync(resolved, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory()).map((entry)=>({
+                name: entry.name,
+                path: join(resolved, entry.name)
+            })).sort((a, b)=>a.name.localeCompare(b.name));
+        const parent = normalize(join(resolved, ".."));
+        const parentAllowed = parent !== resolved && ctx.isPathWithinRoots(parent, roots) ? parent : null;
+        return new Response(JSON.stringify({
+            path: resolved,
+            parent: parentAllowed,
+            entries
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return null;
+};
+export { handleFsApi };

package/dist/gateway/http/providers.cjs

@@ -0,0 +1,120 @@
+"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__, {
+    handleProvidersApi: ()=>handleProvidersApi
+});
+const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs");
+const registry_cjs_namespaceObject = require("../../providers/registry.cjs");
+const handleProvidersApi = async (_ctx, req, url)=>{
+    if ("/api/providers" === url.pathname) {
+        if ("GET" === req.method) {
+            const credentials = (0, credentials_cjs_namespaceObject.readCredentialsFile)();
+            const providers = (0, registry_cjs_namespaceObject.listProviderSpecs)().map((provider)=>{
+                const resolved = (0, credentials_cjs_namespaceObject.resolveProviderToken)(provider.name);
+                return {
+                    name: provider.name,
+                    label: provider.label,
+                    type: provider.type,
+                    envVars: provider.envVars,
+                    category: provider.category,
+                    source: resolved.source,
+                    envVar: resolved.envVar,
+                    requiresAuth: provider.requiresAuth
+                };
+            });
+            return new Response(JSON.stringify({
+                providers,
+                credentialsPath: (0, credentials_cjs_namespaceObject.getCredentialsPath)(),
+                updatedAt: credentials?.updatedAt
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    const providerMatch = url.pathname.match(/^\/api\/providers\/([^/]+)$/);
+    if (!providerMatch) return null;
+    const providerName = decodeURIComponent(providerMatch[1]);
+    const provider = (0, registry_cjs_namespaceObject.getProviderSpec)(providerName);
+    if (!provider) return new Response("Unknown provider", {
+        status: 404
+    });
+    if ("POST" === req.method) {
+        const body = await req.json();
+        const token = (body?.token || body?.apiKey || "").trim();
+        if (!token) return new Response("Token required", {
+            status: 400
+        });
+        (0, credentials_cjs_namespaceObject.saveProviderToken)(provider.name, token);
+        const resolved = (0, credentials_cjs_namespaceObject.resolveProviderToken)(provider.name);
+        return new Response(JSON.stringify({
+            name: provider.name,
+            label: provider.label,
+            type: provider.type,
+            envVars: provider.envVars,
+            category: provider.category,
+            source: resolved.source,
+            envVar: resolved.envVar,
+            requiresAuth: provider.requiresAuth
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("DELETE" === req.method) {
+        (0, credentials_cjs_namespaceObject.deleteProviderCredentials)(provider.name);
+        const resolved = (0, credentials_cjs_namespaceObject.resolveProviderToken)(provider.name);
+        return new Response(JSON.stringify({
+            name: provider.name,
+            label: provider.label,
+            type: provider.type,
+            envVars: provider.envVars,
+            category: provider.category,
+            source: resolved.source,
+            envVar: resolved.envVar,
+            requiresAuth: provider.requiresAuth
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return new Response("Method Not Allowed", {
+        status: 405
+    });
+};
+exports.handleProvidersApi = __webpack_exports__.handleProvidersApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleProvidersApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/gateway/http/providers.js

@@ -0,0 +1,86 @@
+import { deleteProviderCredentials, getCredentialsPath, readCredentialsFile, resolveProviderToken, saveProviderToken } from "../../providers/credentials.js";
+import { getProviderSpec, listProviderSpecs } from "../../providers/registry.js";
+const handleProvidersApi = async (_ctx, req, url)=>{
+    if ("/api/providers" === url.pathname) {
+        if ("GET" === req.method) {
+            const credentials = readCredentialsFile();
+            const providers = listProviderSpecs().map((provider)=>{
+                const resolved = resolveProviderToken(provider.name);
+                return {
+                    name: provider.name,
+                    label: provider.label,
+                    type: provider.type,
+                    envVars: provider.envVars,
+                    category: provider.category,
+                    source: resolved.source,
+                    envVar: resolved.envVar,
+                    requiresAuth: provider.requiresAuth
+                };
+            });
+            return new Response(JSON.stringify({
+                providers,
+                credentialsPath: getCredentialsPath(),
+                updatedAt: credentials?.updatedAt
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    const providerMatch = url.pathname.match(/^\/api\/providers\/([^/]+)$/);
+    if (!providerMatch) return null;
+    const providerName = decodeURIComponent(providerMatch[1]);
+    const provider = getProviderSpec(providerName);
+    if (!provider) return new Response("Unknown provider", {
+        status: 404
+    });
+    if ("POST" === req.method) {
+        const body = await req.json();
+        const token = (body?.token || body?.apiKey || "").trim();
+        if (!token) return new Response("Token required", {
+            status: 400
+        });
+        saveProviderToken(provider.name, token);
+        const resolved = resolveProviderToken(provider.name);
+        return new Response(JSON.stringify({
+            name: provider.name,
+            label: provider.label,
+            type: provider.type,
+            envVars: provider.envVars,
+            category: provider.category,
+            source: resolved.source,
+            envVar: resolved.envVar,
+            requiresAuth: provider.requiresAuth
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("DELETE" === req.method) {
+        deleteProviderCredentials(provider.name);
+        const resolved = resolveProviderToken(provider.name);
+        return new Response(JSON.stringify({
+            name: provider.name,
+            label: provider.label,
+            type: provider.type,
+            envVars: provider.envVars,
+            category: provider.category,
+            source: resolved.source,
+            envVar: resolved.envVar,
+            requiresAuth: provider.requiresAuth
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return new Response("Method Not Allowed", {
+        status: 405
+    });
+};
+export { handleProvidersApi };