@wingman-ai/gateway 0.1.0

package/dist/gateway/http/routines.cjs

@@ -0,0 +1,196 @@
+"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__, {
+    createRoutineStore: ()=>createRoutineStore,
+    handleRoutinesApi: ()=>handleRoutinesApi
+});
+const agentLoader_cjs_namespaceObject = require("../../agent/config/agentLoader.cjs");
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const CRON_FIELD_PATTERN = /^[0-9*/,\-]+$/;
+const isValidCron = (cron)=>{
+    const parts = cron.trim().split(/\s+/);
+    if (5 !== parts.length) return false;
+    return parts.every((part)=>CRON_FIELD_PATTERN.test(part));
+};
+const createRoutineStore = (resolveConfigDirPath)=>{
+    const resolvePath = ()=>{
+        const configDir = resolveConfigDirPath();
+        (0, external_node_fs_namespaceObject.mkdirSync)(configDir, {
+            recursive: true
+        });
+        return (0, external_node_path_namespaceObject.join)(configDir, "routines.json");
+    };
+    return {
+        load: ()=>{
+            const path = resolvePath();
+            if (!(0, external_node_fs_namespaceObject.existsSync)(path)) return [];
+            try {
+                const raw = (0, external_node_fs_namespaceObject.readFileSync)(path, "utf-8");
+                const parsed = JSON.parse(raw);
+                return Array.isArray(parsed) ? parsed : [];
+            } catch  {
+                return [];
+            }
+        },
+        save: (routines)=>{
+            const path = resolvePath();
+            (0, external_node_fs_namespaceObject.writeFileSync)(path, JSON.stringify(routines, null, 2));
+        },
+        generateId: ()=>`routine-${(0, external_node_crypto_namespaceObject.randomUUID)()}`
+    };
+};
+const agentExists = (ctx, agentId)=>{
+    const loader = new agentLoader_cjs_namespaceObject.AgentLoader(ctx.configDir, ctx.workspace, ctx.getWingmanConfig());
+    const configs = loader.loadAllAgentConfigs();
+    return Boolean(configs.find((config)=>config.name === agentId));
+};
+const sessionExists = async (ctx, agentId, sessionId)=>{
+    const manager = await ctx.getSessionManager(agentId);
+    return Boolean(manager.getSession(sessionId));
+};
+const handleRoutinesApi = async (ctx, store, req, url)=>{
+    if ("/api/routines" === url.pathname) {
+        if ("GET" === req.method) {
+            const routines = store.load();
+            return new Response(JSON.stringify(routines, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("POST" === req.method) {
+            let body;
+            try {
+                body = await req.json();
+            } catch  {
+                return new Response("Invalid JSON body", {
+                    status: 400
+                });
+            }
+            const name = body?.name?.trim();
+            const agentId = body?.agentId?.trim();
+            const cron = body?.cron?.trim();
+            const prompt = body?.prompt?.trim();
+            if (!name) return new Response("Routine name required", {
+                status: 400
+            });
+            if (!agentId) return new Response("agentId required", {
+                status: 400
+            });
+            if (!cron) return new Response("cron required", {
+                status: 400
+            });
+            if (!prompt) return new Response("prompt required", {
+                status: 400
+            });
+            if (!isValidCron(cron)) return new Response("Invalid cron expression", {
+                status: 400
+            });
+            if (!agentExists(ctx, agentId)) return new Response("Invalid agentId", {
+                status: 400
+            });
+            const sessionId = body?.sessionId?.trim();
+            if (sessionId) {
+                const exists = await sessionExists(ctx, agentId, sessionId);
+                if (!exists) return new Response("Invalid sessionId", {
+                    status: 400
+                });
+            }
+            const routines = store.load();
+            const providedId = body?.id?.trim();
+            if (providedId && !/^[a-zA-Z0-9_-]+$/.test(providedId)) return new Response("Invalid routine id", {
+                status: 400
+            });
+            const id = providedId || store.generateId();
+            if (routines.some((routine)=>routine.id === id)) return new Response("Routine already exists", {
+                status: 409
+            });
+            const routine = {
+                id,
+                name,
+                agentId,
+                cron,
+                prompt,
+                sessionId: sessionId || void 0,
+                createdAt: Date.now(),
+                enabled: body?.enabled ?? true
+            };
+            routines.unshift(routine);
+            store.save(routines);
+            return new Response(JSON.stringify(routine, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    const routineMatch = url.pathname.match(/^\/api\/routines\/([^/]+)$/);
+    if (!routineMatch) return null;
+    const routineId = decodeURIComponent(routineMatch[1]);
+    const routines = store.load();
+    const routine = routines.find((item)=>item.id === routineId);
+    if ("GET" === req.method) {
+        if (!routine) return new Response("Routine not found", {
+            status: 404
+        });
+        return new Response(JSON.stringify(routine, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("DELETE" === req.method) {
+        if (!routine) return new Response("Routine not found", {
+            status: 404
+        });
+        const nextRoutines = routines.filter((item)=>item.id !== routineId);
+        store.save(nextRoutines);
+        return new Response(JSON.stringify({
+            ok: true
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return new Response("Method Not Allowed", {
+        status: 405
+    });
+};
+exports.createRoutineStore = __webpack_exports__.createRoutineStore;
+exports.handleRoutinesApi = __webpack_exports__.handleRoutinesApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createRoutineStore",
+    "handleRoutinesApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,20 @@
+import type { GatewayHttpContext } from "./types.js";
+export type RoutineConfig = {
+    id: string;
+    name: string;
+    agentId: string;
+    cron: string;
+    prompt: string;
+    sessionId?: string;
+    createdAt: number;
+    lastRunAt?: number;
+    enabled: boolean;
+};
+type RoutineStore = {
+    load: () => RoutineConfig[];
+    save: (routines: RoutineConfig[]) => void;
+    generateId: () => string;
+};
+export declare const createRoutineStore: (resolveConfigDirPath: () => string) => RoutineStore;
+export declare const handleRoutinesApi: (ctx: GatewayHttpContext, store: RoutineStore, req: Request, url: URL) => Promise<Response | null>;
+export {};

package/dist/gateway/http/routines.js

@@ -0,0 +1,159 @@
+import { AgentLoader } from "../../agent/config/agentLoader.js";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const CRON_FIELD_PATTERN = /^[0-9*/,\-]+$/;
+const isValidCron = (cron)=>{
+    const parts = cron.trim().split(/\s+/);
+    if (5 !== parts.length) return false;
+    return parts.every((part)=>CRON_FIELD_PATTERN.test(part));
+};
+const createRoutineStore = (resolveConfigDirPath)=>{
+    const resolvePath = ()=>{
+        const configDir = resolveConfigDirPath();
+        mkdirSync(configDir, {
+            recursive: true
+        });
+        return join(configDir, "routines.json");
+    };
+    return {
+        load: ()=>{
+            const path = resolvePath();
+            if (!existsSync(path)) return [];
+            try {
+                const raw = readFileSync(path, "utf-8");
+                const parsed = JSON.parse(raw);
+                return Array.isArray(parsed) ? parsed : [];
+            } catch  {
+                return [];
+            }
+        },
+        save: (routines)=>{
+            const path = resolvePath();
+            writeFileSync(path, JSON.stringify(routines, null, 2));
+        },
+        generateId: ()=>`routine-${randomUUID()}`
+    };
+};
+const agentExists = (ctx, agentId)=>{
+    const loader = new AgentLoader(ctx.configDir, ctx.workspace, ctx.getWingmanConfig());
+    const configs = loader.loadAllAgentConfigs();
+    return Boolean(configs.find((config)=>config.name === agentId));
+};
+const sessionExists = async (ctx, agentId, sessionId)=>{
+    const manager = await ctx.getSessionManager(agentId);
+    return Boolean(manager.getSession(sessionId));
+};
+const handleRoutinesApi = async (ctx, store, req, url)=>{
+    if ("/api/routines" === url.pathname) {
+        if ("GET" === req.method) {
+            const routines = store.load();
+            return new Response(JSON.stringify(routines, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        if ("POST" === req.method) {
+            let body;
+            try {
+                body = await req.json();
+            } catch  {
+                return new Response("Invalid JSON body", {
+                    status: 400
+                });
+            }
+            const name = body?.name?.trim();
+            const agentId = body?.agentId?.trim();
+            const cron = body?.cron?.trim();
+            const prompt = body?.prompt?.trim();
+            if (!name) return new Response("Routine name required", {
+                status: 400
+            });
+            if (!agentId) return new Response("agentId required", {
+                status: 400
+            });
+            if (!cron) return new Response("cron required", {
+                status: 400
+            });
+            if (!prompt) return new Response("prompt required", {
+                status: 400
+            });
+            if (!isValidCron(cron)) return new Response("Invalid cron expression", {
+                status: 400
+            });
+            if (!agentExists(ctx, agentId)) return new Response("Invalid agentId", {
+                status: 400
+            });
+            const sessionId = body?.sessionId?.trim();
+            if (sessionId) {
+                const exists = await sessionExists(ctx, agentId, sessionId);
+                if (!exists) return new Response("Invalid sessionId", {
+                    status: 400
+                });
+            }
+            const routines = store.load();
+            const providedId = body?.id?.trim();
+            if (providedId && !/^[a-zA-Z0-9_-]+$/.test(providedId)) return new Response("Invalid routine id", {
+                status: 400
+            });
+            const id = providedId || store.generateId();
+            if (routines.some((routine)=>routine.id === id)) return new Response("Routine already exists", {
+                status: 409
+            });
+            const routine = {
+                id,
+                name,
+                agentId,
+                cron,
+                prompt,
+                sessionId: sessionId || void 0,
+                createdAt: Date.now(),
+                enabled: body?.enabled ?? true
+            };
+            routines.unshift(routine);
+            store.save(routines);
+            return new Response(JSON.stringify(routine, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        return new Response("Method Not Allowed", {
+            status: 405
+        });
+    }
+    const routineMatch = url.pathname.match(/^\/api\/routines\/([^/]+)$/);
+    if (!routineMatch) return null;
+    const routineId = decodeURIComponent(routineMatch[1]);
+    const routines = store.load();
+    const routine = routines.find((item)=>item.id === routineId);
+    if ("GET" === req.method) {
+        if (!routine) return new Response("Routine not found", {
+            status: 404
+        });
+        return new Response(JSON.stringify(routine, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("DELETE" === req.method) {
+        if (!routine) return new Response("Routine not found", {
+            status: 404
+        });
+        const nextRoutines = routines.filter((item)=>item.id !== routineId);
+        store.save(nextRoutines);
+        return new Response(JSON.stringify({
+            ok: true
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    return new Response("Method Not Allowed", {
+        status: 405
+    });
+};
+export { createRoutineStore, handleRoutinesApi };

package/dist/gateway/http/sessions.cjs

@@ -0,0 +1,241 @@
+"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__, {
+    handleSessionsApi: ()=>handleSessionsApi
+});
+const external_node_crypto_namespaceObject = require("node:crypto");
+const external_node_fs_namespaceObject = require("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:${(0, external_node_crypto_namespaceObject.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 (!(0, external_node_fs_namespaceObject.existsSync)(resolved) || !(0, external_node_fs_namespaceObject.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;
+};
+exports.handleSessionsApi = __webpack_exports__.handleSessionsApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleSessionsApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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