@wingman-ai/gateway 0.1.0

package/dist/gateway/http/sessions.js

@@ -0,0 +1,207 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, statSync } from "node:fs";
+const handleSessionsApi = async (ctx, req, url)=>{
+    if ("/api/sessions" === url.pathname) {
+        if ("GET" === req.method) {
+            const limit = Number(url.searchParams.get("limit") || "100");
+            const status = url.searchParams.get("status") || "active";
+            const agentId = url.searchParams.get("agentId") || void 0;
+            const agents = agentId ? [
+                agentId
+            ] : ctx.getWingmanConfig().agents?.list?.map((agent)=>agent.id) || [
+                "main"
+            ];
+            const sessions = [];
+            for (const agent of agents){
+                const manager = await ctx.getSessionManager(agent);
+                const list = manager.listSessions({
+                    status,
+                    limit,
+                    agentName: agent
+                });
+                for (const session of list)sessions.push({
+                    id: session.id,
+                    name: session.name,
+                    agentId: session.agentName,
+                    createdAt: session.createdAt.getTime(),
+                    updatedAt: session.updatedAt.getTime(),
+                    messageCount: session.messageCount,
+                    lastMessagePreview: session.lastMessagePreview,
+                    workdir: session.metadata?.workdir ?? null
+                });
+            }
+            const sorted = sessions.sort((a, b)=>{
+                const aUpdated = "number" == typeof a.updatedAt ? a.updatedAt : 0;
+                const bUpdated = "number" == typeof b.updatedAt ? b.updatedAt : 0;
+                return bUpdated - aUpdated;
+            });
+            return new Response(JSON.stringify(sorted.slice(0, limit), null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("POST" === req.method) {
+            const body = await req.json();
+            const selectedAgent = ctx.router.selectAgent(body.agentId);
+            if (!selectedAgent) return new Response("Invalid agent", {
+                status: 400
+            });
+            const sessionId = body.sessionId || `agent:${selectedAgent}:webui:thread:${randomUUID()}`;
+            const manager = await ctx.getSessionManager(selectedAgent);
+            const session = manager.getOrCreateSession(sessionId, selectedAgent, body.name);
+            return new Response(JSON.stringify({
+                id: session.id,
+                name: session.name,
+                agentId: session.agentName,
+                createdAt: session.createdAt.getTime(),
+                updatedAt: session.updatedAt.getTime(),
+                messageCount: session.messageCount,
+                lastMessagePreview: session.lastMessagePreview,
+                workdir: session.metadata?.workdir ?? null
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    const sessionMessagesMatch = url.pathname.match(/^\/api\/sessions\/(.+)\/messages$/);
+    if (sessionMessagesMatch) {
+        const sessionId = decodeURIComponent(sessionMessagesMatch[1]);
+        const agentId = url.searchParams.get("agentId");
+        if (!agentId) return new Response("agentId required", {
+            status: 400
+        });
+        const manager = await ctx.getSessionManager(agentId);
+        if ("GET" === req.method) {
+            const messages = await manager.listMessages(sessionId);
+            return new Response(JSON.stringify(messages, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("DELETE" === req.method) {
+            const session = manager.getSession(sessionId);
+            if (!session) return new Response("session not found", {
+                status: 404
+            });
+            manager.clearSessionMessages(sessionId);
+            const updated = manager.getSession(sessionId);
+            return new Response(JSON.stringify({
+                id: sessionId,
+                messageCount: updated?.messageCount ?? 0,
+                lastMessagePreview: updated?.lastMessagePreview ?? null
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+    }
+    const sessionWorkdirMatch = url.pathname.match(/^\/api\/sessions\/(.+)\/workdir$/);
+    if (sessionWorkdirMatch && "POST" === req.method) {
+        const sessionId = decodeURIComponent(sessionWorkdirMatch[1]);
+        const agentId = url.searchParams.get("agentId");
+        if (!agentId) return new Response("agentId required", {
+            status: 400
+        });
+        const body = await req.json();
+        const manager = await ctx.getSessionManager(agentId);
+        const session = manager.getSession(sessionId);
+        if (!session) return new Response("session not found", {
+            status: 404
+        });
+        const rawWorkdir = body?.workdir;
+        if (!rawWorkdir) {
+            manager.updateSessionMetadata(sessionId, {
+                workdir: null
+            });
+            return new Response(JSON.stringify({
+                id: session.id,
+                workdir: null
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        const resolved = ctx.resolveFsPath(rawWorkdir);
+        const roots = ctx.resolveFsRoots();
+        if (!ctx.isPathWithinRoots(resolved, roots)) return new Response("workdir not allowed", {
+            status: 403
+        });
+        if (!existsSync(resolved) || !statSync(resolved).isDirectory()) return new Response("workdir not found", {
+            status: 404
+        });
+        manager.updateSessionMetadata(sessionId, {
+            workdir: resolved
+        });
+        return new Response(JSON.stringify({
+            id: session.id,
+            workdir: resolved
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    const sessionDeleteMatch = url.pathname.match(/^\/api\/sessions\/(.+)$/);
+    if (sessionDeleteMatch && "PUT" === req.method) {
+        const sessionId = decodeURIComponent(sessionDeleteMatch[1]);
+        const agentId = url.searchParams.get("agentId");
+        if (!agentId) return new Response("agentId required", {
+            status: 400
+        });
+        const body = await req.json();
+        const name = body?.name?.trim();
+        if (!name) return new Response("name required", {
+            status: 400
+        });
+        const manager = await ctx.getSessionManager(agentId);
+        const session = manager.getSession(sessionId);
+        if (!session) return new Response("session not found", {
+            status: 404
+        });
+        manager.updateSession(sessionId, {
+            name
+        });
+        const updated = manager.getSession(sessionId);
+        return new Response(JSON.stringify({
+            id: updated?.id || sessionId,
+            name: updated?.name || name,
+            agentId: updated?.agentName || agentId,
+            createdAt: updated?.createdAt.getTime() || session.createdAt.getTime(),
+            updatedAt: updated?.updatedAt.getTime() || Date.now(),
+            messageCount: updated?.messageCount ?? session.messageCount,
+            lastMessagePreview: updated?.lastMessagePreview ?? session.lastMessagePreview,
+            workdir: updated?.metadata?.workdir ?? session.metadata?.workdir ?? null
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if (sessionDeleteMatch && "DELETE" === req.method) {
+        const sessionId = decodeURIComponent(sessionDeleteMatch[1]);
+        const agentId = url.searchParams.get("agentId");
+        if (!agentId) return new Response("agentId required", {
+            status: 400
+        });
+        const manager = await ctx.getSessionManager(agentId);
+        manager.deleteSession(sessionId);
+        return new Response(JSON.stringify({
+            ok: true
+        }), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return null;
+};
+export { handleSessionsApi };

package/dist/gateway/http/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/http/types.d.ts

@@ -0,0 +1,25 @@
+import type { GatewayRouter } from "../router.js";
+import type { GatewayAuth } from "../auth.js";
+import type { Logger } from "@/logger.js";
+import type { WingmanConfigType } from "@/cli/config/schema.js";
+import type { SessionManager } from "@/cli/core/sessionManager.js";
+export type GatewayHttpContext = {
+    workspace: string;
+    configDir: string;
+    getWingmanConfig: () => WingmanConfigType;
+    setWingmanConfig: (config: WingmanConfigType) => void;
+    persistWingmanConfig: () => void;
+    router: GatewayRouter;
+    setRouter: (router: GatewayRouter) => void;
+    auth: GatewayAuth;
+    logger: Logger;
+    getSessionManager: (agentId: string) => Promise<SessionManager>;
+    resolveConfigDirPath: () => string;
+    resolveOutputRoot: () => string;
+    resolveDefaultOutputDir: (agentId: string) => string;
+    resolveAgentWorkspace: (agentId: string) => string;
+    resolveFsRoots: () => string[];
+    resolveFsPath: (path: string) => string;
+    isPathWithinRoots: (path: string, roots: string[]) => boolean;
+    getBuiltInTools: () => string[];
+};

package/dist/gateway/http/voice.cjs

@@ -0,0 +1,167 @@
+"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__, {
+    handleVoiceApi: ()=>handleVoiceApi
+});
+const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
+const credentials_cjs_namespaceObject = require("../../providers/credentials.cjs");
+const config_cjs_namespaceObject = require("../../voice/config.cjs");
+const voice_cjs_namespaceObject = require("../../types/voice.cjs");
+const schema_cjs_namespaceObject = require("../../cli/config/schema.cjs");
+const ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
+const buildElevenLabsPayload = (text, options)=>{
+    const payload = {
+        text
+    };
+    if (options.modelId) payload.model_id = options.modelId;
+    const voiceSettings = {};
+    if ("number" == typeof options.stability) voiceSettings.stability = options.stability;
+    if ("number" == typeof options.similarityBoost) voiceSettings.similarity_boost = options.similarityBoost;
+    if ("number" == typeof options.style) voiceSettings.style = options.style;
+    if ("boolean" == typeof options.speakerBoost) voiceSettings.use_speaker_boost = options.speakerBoost;
+    if ("number" == typeof options.speed) voiceSettings.speed = options.speed;
+    if (Object.keys(voiceSettings).length > 0) payload.voice_settings = voiceSettings;
+    return payload;
+};
+const resolveAgentVoiceConfig = (ctx, agentId)=>{
+    if (!agentId) return;
+    const loader = new agentLoader_cjs_namespaceObject.AgentLoader(ctx.configDir, ctx.workspace, ctx.getWingmanConfig());
+    const configs = loader.loadAllAgentConfigs();
+    const match = configs.find((agent)=>agent.name === agentId);
+    return match?.voice;
+};
+const handleVoiceApi = async (ctx, req, url)=>{
+    if ("/api/voice" === url.pathname) {
+        if ("GET" === req.method) {
+            const config = ctx.getWingmanConfig();
+            return new Response(JSON.stringify({
+                voice: config.voice
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("PUT" === req.method) {
+            const payload = await req.json();
+            const updateResult = voice_cjs_namespaceObject.VoiceConfigUpdateSchema.safeParse(payload);
+            if (!updateResult.success) return new Response("Invalid voice configuration", {
+                status: 400
+            });
+            const update = updateResult.data;
+            const current = ctx.getWingmanConfig();
+            const nextVoice = {
+                ...current.voice || {},
+                ...update,
+                webSpeech: {
+                    ...current.voice?.webSpeech || {},
+                    ...update.webSpeech || {}
+                },
+                elevenlabs: {
+                    ...current.voice?.elevenlabs || {},
+                    ...update.elevenlabs || {}
+                }
+            };
+            const nextConfig = schema_cjs_namespaceObject.WingmanConfigSchema.parse({
+                ...current,
+                voice: nextVoice
+            });
+            ctx.setWingmanConfig(nextConfig);
+            ctx.persistWingmanConfig();
+            return new Response(JSON.stringify({
+                voice: nextConfig.voice
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    if ("/api/voice/speak" === url.pathname) {
+        if ("POST" !== req.method) return new Response("Method Not Allowed", {
+            status: 405
+        });
+        const body = await req.json();
+        const text = String(body?.text ?? "").trim();
+        if (!text) return new Response("Text is required", {
+            status: 400
+        });
+        const agentId = "string" == typeof body?.agentId && body.agentId.trim() ? body.agentId.trim() : void 0;
+        const config = ctx.getWingmanConfig();
+        const agentVoice = resolveAgentVoiceConfig(ctx, agentId);
+        const resolved = (0, config_cjs_namespaceObject.resolveVoiceConfig)(config.voice, agentVoice);
+        if ("elevenlabs" !== resolved.provider) return new Response("Voice provider is not supported by the gateway", {
+            status: 400
+        });
+        const token = (0, credentials_cjs_namespaceObject.resolveProviderToken)("elevenlabs").token;
+        if (!token) return new Response("ElevenLabs API key is not configured", {
+            status: 400
+        });
+        const voiceId = resolved.elevenlabs.voiceId;
+        if (!voiceId) return new Response("ElevenLabs voiceId is required", {
+            status: 400
+        });
+        const query = new URLSearchParams();
+        if (resolved.elevenlabs.outputFormat) query.set("output_format", resolved.elevenlabs.outputFormat);
+        if ("number" == typeof resolved.elevenlabs.optimizeStreamingLatency) query.set("optimize_streaming_latency", String(resolved.elevenlabs.optimizeStreamingLatency));
+        const endpoint = `${ELEVENLABS_BASE_URL}/text-to-speech/${voiceId}${query.toString() ? `?${query.toString()}` : ""}`;
+        const elevenPayload = buildElevenLabsPayload(text, resolved.elevenlabs);
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "xi-api-key": token,
+                Accept: "audio/mpeg"
+            },
+            body: JSON.stringify(elevenPayload)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return new Response(errorText || "ElevenLabs request failed", {
+                status: response.status
+            });
+        }
+        const audioBuffer = await response.arrayBuffer();
+        const contentType = response.headers.get("content-type") || "audio/mpeg";
+        return new Response(audioBuffer, {
+            headers: {
+                "Content-Type": contentType,
+                "Cache-Control": "no-store"
+            }
+        });
+    }
+    return null;
+};
+exports.handleVoiceApi = __webpack_exports__.handleVoiceApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleVoiceApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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

package/dist/gateway/http/voice.js

@@ -0,0 +1,133 @@
+import { AgentLoader } from "../../agent/config/agentLoader.js";
+import { resolveProviderToken } from "../../providers/credentials.js";
+import { resolveVoiceConfig } from "../../voice/config.js";
+import { VoiceConfigUpdateSchema } from "../../types/voice.js";
+import { WingmanConfigSchema } from "../../cli/config/schema.js";
+const ELEVENLABS_BASE_URL = "https://api.elevenlabs.io/v1";
+const buildElevenLabsPayload = (text, options)=>{
+    const payload = {
+        text
+    };
+    if (options.modelId) payload.model_id = options.modelId;
+    const voiceSettings = {};
+    if ("number" == typeof options.stability) voiceSettings.stability = options.stability;
+    if ("number" == typeof options.similarityBoost) voiceSettings.similarity_boost = options.similarityBoost;
+    if ("number" == typeof options.style) voiceSettings.style = options.style;
+    if ("boolean" == typeof options.speakerBoost) voiceSettings.use_speaker_boost = options.speakerBoost;
+    if ("number" == typeof options.speed) voiceSettings.speed = options.speed;
+    if (Object.keys(voiceSettings).length > 0) payload.voice_settings = voiceSettings;
+    return payload;
+};
+const resolveAgentVoiceConfig = (ctx, agentId)=>{
+    if (!agentId) return;
+    const loader = new AgentLoader(ctx.configDir, ctx.workspace, ctx.getWingmanConfig());
+    const configs = loader.loadAllAgentConfigs();
+    const match = configs.find((agent)=>agent.name === agentId);
+    return match?.voice;
+};
+const handleVoiceApi = async (ctx, req, url)=>{
+    if ("/api/voice" === url.pathname) {
+        if ("GET" === req.method) {
+            const config = ctx.getWingmanConfig();
+            return new Response(JSON.stringify({
+                voice: config.voice
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("PUT" === req.method) {
+            const payload = await req.json();
+            const updateResult = VoiceConfigUpdateSchema.safeParse(payload);
+            if (!updateResult.success) return new Response("Invalid voice configuration", {
+                status: 400
+            });
+            const update = updateResult.data;
+            const current = ctx.getWingmanConfig();
+            const nextVoice = {
+                ...current.voice || {},
+                ...update,
+                webSpeech: {
+                    ...current.voice?.webSpeech || {},
+                    ...update.webSpeech || {}
+                },
+                elevenlabs: {
+                    ...current.voice?.elevenlabs || {},
+                    ...update.elevenlabs || {}
+                }
+            };
+            const nextConfig = WingmanConfigSchema.parse({
+                ...current,
+                voice: nextVoice
+            });
+            ctx.setWingmanConfig(nextConfig);
+            ctx.persistWingmanConfig();
+            return new Response(JSON.stringify({
+                voice: nextConfig.voice
+            }, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    if ("/api/voice/speak" === url.pathname) {
+        if ("POST" !== req.method) return new Response("Method Not Allowed", {
+            status: 405
+        });
+        const body = await req.json();
+        const text = String(body?.text ?? "").trim();
+        if (!text) return new Response("Text is required", {
+            status: 400
+        });
+        const agentId = "string" == typeof body?.agentId && body.agentId.trim() ? body.agentId.trim() : void 0;
+        const config = ctx.getWingmanConfig();
+        const agentVoice = resolveAgentVoiceConfig(ctx, agentId);
+        const resolved = resolveVoiceConfig(config.voice, agentVoice);
+        if ("elevenlabs" !== resolved.provider) return new Response("Voice provider is not supported by the gateway", {
+            status: 400
+        });
+        const token = resolveProviderToken("elevenlabs").token;
+        if (!token) return new Response("ElevenLabs API key is not configured", {
+            status: 400
+        });
+        const voiceId = resolved.elevenlabs.voiceId;
+        if (!voiceId) return new Response("ElevenLabs voiceId is required", {
+            status: 400
+        });
+        const query = new URLSearchParams();
+        if (resolved.elevenlabs.outputFormat) query.set("output_format", resolved.elevenlabs.outputFormat);
+        if ("number" == typeof resolved.elevenlabs.optimizeStreamingLatency) query.set("optimize_streaming_latency", String(resolved.elevenlabs.optimizeStreamingLatency));
+        const endpoint = `${ELEVENLABS_BASE_URL}/text-to-speech/${voiceId}${query.toString() ? `?${query.toString()}` : ""}`;
+        const elevenPayload = buildElevenLabsPayload(text, resolved.elevenlabs);
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "xi-api-key": token,
+                Accept: "audio/mpeg"
+            },
+            body: JSON.stringify(elevenPayload)
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return new Response(errorText || "ElevenLabs request failed", {
+                status: response.status
+            });
+        }
+        const audioBuffer = await response.arrayBuffer();
+        const contentType = response.headers.get("content-type") || "audio/mpeg";
+        return new Response(audioBuffer, {
+            headers: {
+                "Content-Type": contentType,
+                "Cache-Control": "no-store"
+            }
+        });
+    }
+    return null;
+};
+export { handleVoiceApi };