@wingman-ai/gateway 0.1.0

package/dist/tests/routines-api.test.js

@@ -0,0 +1,101 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createRoutineStore, handleRoutinesApi } from "../gateway/http/routines.js";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const isBunRuntime = void 0 !== globalThis.Bun;
+const describeIfBun = isBunRuntime ? describe : describe.skip;
+describeIfBun("routines API", ()=>{
+    let tempDir;
+    beforeEach(()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-routines-"));
+        const agentDir = join(tempDir, "agents", "main");
+        mkdirSync(agentDir, {
+            recursive: true
+        });
+        writeFileSync(join(agentDir, "agent.json"), JSON.stringify({
+            name: "main",
+            description: "Main agent",
+            systemPrompt: "You are the main agent"
+        }, null, 2));
+    });
+    afterEach(()=>{
+        rmSync(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("creates, lists, and deletes routines", async ()=>{
+        const ctx = {
+            configDir: tempDir,
+            workspace: tempDir,
+            getWingmanConfig: ()=>({}),
+            getSessionManager: async ()=>{
+                throw new Error("SessionManager not used in this test");
+            }
+        };
+        const store = createRoutineStore(()=>tempDir);
+        const createReq = new Request("http://localhost/api/routines", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                name: "Daily Check-in",
+                agentId: "main",
+                cron: "0 9 * * *",
+                prompt: "Summarize today's tasks.",
+                enabled: true
+            })
+        });
+        const createRes = await handleRoutinesApi(ctx, store, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        expect(created.id).toMatch(/^routine-/);
+        const listReq = new Request("http://localhost/api/routines", {
+            method: "GET"
+        });
+        const listRes = await handleRoutinesApi(ctx, store, listReq, new URL(listReq.url));
+        expect(listRes).not.toBeNull();
+        const list = await listRes.json();
+        expect(list).toHaveLength(1);
+        expect(list[0].id).toBe(created.id);
+        const deleteReq = new Request(`http://localhost/api/routines/${encodeURIComponent(created.id)}`, {
+            method: "DELETE"
+        });
+        const deleteRes = await handleRoutinesApi(ctx, store, deleteReq, new URL(deleteReq.url));
+        expect(deleteRes).not.toBeNull();
+        expect(deleteRes?.ok).toBe(true);
+        const listResAfter = await handleRoutinesApi(ctx, store, listReq, new URL(listReq.url));
+        const listAfter = await listResAfter.json();
+        expect(listAfter).toHaveLength(0);
+    });
+    it("rejects invalid cron expressions", async ()=>{
+        const ctx = {
+            configDir: tempDir,
+            workspace: tempDir,
+            getWingmanConfig: ()=>({}),
+            getSessionManager: async ()=>{
+                throw new Error("SessionManager not used in this test");
+            }
+        };
+        const store = createRoutineStore(()=>tempDir);
+        const createReq = new Request("http://localhost/api/routines", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                name: "Invalid Cron",
+                agentId: "main",
+                cron: "bad cron",
+                prompt: "Hello",
+                enabled: true
+            })
+        });
+        const createRes = await handleRoutinesApi(ctx, store, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.status).toBe(400);
+    });
+});

package/dist/tests/sessionMessageAttachments.test.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.cjs");
+(0, external_vitest_namespaceObject.describe)("extractImageAttachments", ()=>{
+    (0, external_vitest_namespaceObject.it)("extracts image_url blocks", ()=>{
+        const blocks = [
+            {
+                type: "image_url",
+                image_url: {
+                    url: "data:image/png;base64,abc"
+                }
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractImageAttachments)(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "data:image/png;base64,abc"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("extracts input_image blocks", ()=>{
+        const blocks = [
+            {
+                type: "input_image",
+                image_url: "data:image/jpeg;base64,xyz"
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractImageAttachments)(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "data:image/jpeg;base64,xyz"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("extracts base64 image blocks", ()=>{
+        const blocks = [
+            {
+                type: "image",
+                source: {
+                    media_type: "image/png",
+                    data: "zzz"
+                }
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractImageAttachments)(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "data:image/png;base64,zzz"
+            }
+        ]);
+    });
+});
+(0, external_vitest_namespaceObject.describe)("extractAttachments", ()=>{
+    (0, external_vitest_namespaceObject.it)("extracts input_audio blocks", ()=>{
+        const blocks = [
+            {
+                type: "input_audio",
+                input_audio: {
+                    data: "abc",
+                    format: "wav"
+                }
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractAttachments)(blocks)).toEqual([
+            {
+                kind: "audio",
+                dataUrl: "data:audio/wav;base64,abc"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("extracts audio_url blocks", ()=>{
+        const blocks = [
+            {
+                type: "audio_url",
+                audio_url: {
+                    url: "https://cdn.example/audio.mp3"
+                }
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractAttachments)(blocks)).toEqual([
+            {
+                kind: "audio",
+                dataUrl: "https://cdn.example/audio.mp3"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("extracts base64 audio blocks", ()=>{
+        const blocks = [
+            {
+                type: "audio",
+                source_type: "base64",
+                data: "abc",
+                mime_type: "audio/wav"
+            }
+        ];
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.extractAttachments)(blocks)).toEqual([
+            {
+                kind: "audio",
+                dataUrl: "data:audio/wav;base64,abc"
+            }
+        ]);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/sessionMessageAttachments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/sessionMessageAttachments.test.js

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+import { extractAttachments, extractImageAttachments } from "../cli/core/sessionManager.js";
+describe("extractImageAttachments", ()=>{
+    it("extracts image_url blocks", ()=>{
+        const blocks = [
+            {
+                type: "image_url",
+                image_url: {
+                    url: "data:image/png;base64,abc"
+                }
+            }
+        ];
+        expect(extractImageAttachments(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "data:image/png;base64,abc"
+            }
+        ]);
+    });
+    it("extracts input_image blocks", ()=>{
+        const blocks = [
+            {
+                type: "input_image",
+                image_url: "data:image/jpeg;base64,xyz"
+            }
+        ];
+        expect(extractImageAttachments(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "data:image/jpeg;base64,xyz"
+            }
+        ]);
+    });
+    it("extracts base64 image blocks", ()=>{
+        const blocks = [
+            {
+                type: "image",
+                source: {
+                    media_type: "image/png",
+                    data: "zzz"
+                }
+            }
+        ];
+        expect(extractImageAttachments(blocks)).toEqual([
+            {
+                kind: "image",
+                dataUrl: "data:image/png;base64,zzz"
+            }
+        ]);
+    });
+});
+describe("extractAttachments", ()=>{
+    it("extracts input_audio blocks", ()=>{
+        const blocks = [
+            {
+                type: "input_audio",
+                input_audio: {
+                    data: "abc",
+                    format: "wav"
+                }
+            }
+        ];
+        expect(extractAttachments(blocks)).toEqual([
+            {
+                kind: "audio",
+                dataUrl: "data:audio/wav;base64,abc"
+            }
+        ]);
+    });
+    it("extracts audio_url blocks", ()=>{
+        const blocks = [
+            {
+                type: "audio_url",
+                audio_url: {
+                    url: "https://cdn.example/audio.mp3"
+                }
+            }
+        ];
+        expect(extractAttachments(blocks)).toEqual([
+            {
+                kind: "audio",
+                dataUrl: "https://cdn.example/audio.mp3"
+            }
+        ]);
+    });
+    it("extracts base64 audio blocks", ()=>{
+        const blocks = [
+            {
+                type: "audio",
+                source_type: "base64",
+                data: "abc",
+                mime_type: "audio/wav"
+            }
+        ];
+        expect(extractAttachments(blocks)).toEqual([
+            {
+                kind: "audio",
+                dataUrl: "data:audio/wav;base64,abc"
+            }
+        ]);
+    });
+});

package/dist/tests/sessionMessageRole.test.cjs

@@ -0,0 +1,44 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.cjs");
+(0, external_vitest_namespaceObject.describe)("resolveMessageRole", ()=>{
+    (0, external_vitest_namespaceObject.it)("resolves role from langchain id arrays", ()=>{
+        const human = {
+            type: "constructor",
+            id: [
+                "langchain_core",
+                "messages",
+                "HumanMessage"
+            ],
+            kwargs: {
+                content: "hi"
+            }
+        };
+        const ai = {
+            type: "constructor",
+            id: [
+                "langchain_core",
+                "messages",
+                "AIMessageChunk"
+            ],
+            kwargs: {
+                content: "hello"
+            }
+        };
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.resolveMessageRole)(human)).toBe("user");
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.resolveMessageRole)(ai)).toBe("assistant");
+    });
+    (0, external_vitest_namespaceObject.it)("resolves role from explicit types", ()=>{
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.resolveMessageRole)({
+            type: "human"
+        })).toBe("user");
+        (0, external_vitest_namespaceObject.expect)((0, sessionManager_cjs_namespaceObject.resolveMessageRole)({
+            type: "ai"
+        })).toBe("assistant");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/sessionMessageRole.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/sessionMessageRole.test.js

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { resolveMessageRole } from "../cli/core/sessionManager.js";
+describe("resolveMessageRole", ()=>{
+    it("resolves role from langchain id arrays", ()=>{
+        const human = {
+            type: "constructor",
+            id: [
+                "langchain_core",
+                "messages",
+                "HumanMessage"
+            ],
+            kwargs: {
+                content: "hi"
+            }
+        };
+        const ai = {
+            type: "constructor",
+            id: [
+                "langchain_core",
+                "messages",
+                "AIMessageChunk"
+            ],
+            kwargs: {
+                content: "hello"
+            }
+        };
+        expect(resolveMessageRole(human)).toBe("user");
+        expect(resolveMessageRole(ai)).toBe("assistant");
+    });
+    it("resolves role from explicit types", ()=>{
+        expect(resolveMessageRole({
+            type: "human"
+        })).toBe("user");
+        expect(resolveMessageRole({
+            type: "ai"
+        })).toBe("assistant");
+    });
+});

package/dist/tests/sessionStateMessages.test.cjs

@@ -0,0 +1,72 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.cjs");
+(0, external_vitest_namespaceObject.describe)("extractMessagesFromState", ()=>{
+    (0, external_vitest_namespaceObject.it)("maps state messages using createdAt", ()=>{
+        const state = {
+            createdAt: "2025-01-01T00:00:00.000Z",
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "hi"
+                    },
+                    {
+                        role: "assistant",
+                        content: "hello"
+                    }
+                ]
+            }
+        };
+        const result = (0, sessionManager_cjs_namespaceObject.extractMessagesFromState)(state);
+        (0, external_vitest_namespaceObject.expect)(result).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(result).toHaveLength(2);
+        (0, external_vitest_namespaceObject.expect)(result?.[0]).toMatchObject({
+            role: "user",
+            content: "hi"
+        });
+        (0, external_vitest_namespaceObject.expect)(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "hello"
+        });
+        const baseTime = new Date("2025-01-01T00:00:00.000Z").getTime();
+        (0, external_vitest_namespaceObject.expect)(result?.[0]?.createdAt).toBe(baseTime);
+        (0, external_vitest_namespaceObject.expect)(result?.[1]?.createdAt).toBe(baseTime + 1);
+    });
+    (0, external_vitest_namespaceObject.it)("filters non-user messages and ui_hidden entries", ()=>{
+        const state = {
+            createdAt: 1000,
+            values: {
+                messages: [
+                    {
+                        role: "tool",
+                        content: "skip"
+                    },
+                    {
+                        role: "assistant",
+                        content: "",
+                        additional_kwargs: {
+                            ui_hidden: true
+                        }
+                    },
+                    {
+                        role: "assistant",
+                        content: "keep"
+                    }
+                ]
+            }
+        };
+        const result = (0, sessionManager_cjs_namespaceObject.extractMessagesFromState)(state);
+        (0, external_vitest_namespaceObject.expect)(result).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(result).toHaveLength(1);
+        (0, external_vitest_namespaceObject.expect)(result?.[0]).toMatchObject({
+            role: "assistant",
+            content: "keep"
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/sessionStateMessages.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/sessionStateMessages.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { extractMessagesFromState } from "../cli/core/sessionManager.js";
+describe("extractMessagesFromState", ()=>{
+    it("maps state messages using createdAt", ()=>{
+        const state = {
+            createdAt: "2025-01-01T00:00:00.000Z",
+            values: {
+                messages: [
+                    {
+                        role: "user",
+                        content: "hi"
+                    },
+                    {
+                        role: "assistant",
+                        content: "hello"
+                    }
+                ]
+            }
+        };
+        const result = extractMessagesFromState(state);
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(2);
+        expect(result?.[0]).toMatchObject({
+            role: "user",
+            content: "hi"
+        });
+        expect(result?.[1]).toMatchObject({
+            role: "assistant",
+            content: "hello"
+        });
+        const baseTime = new Date("2025-01-01T00:00:00.000Z").getTime();
+        expect(result?.[0]?.createdAt).toBe(baseTime);
+        expect(result?.[1]?.createdAt).toBe(baseTime + 1);
+    });
+    it("filters non-user messages and ui_hidden entries", ()=>{
+        const state = {
+            createdAt: 1000,
+            values: {
+                messages: [
+                    {
+                        role: "tool",
+                        content: "skip"
+                    },
+                    {
+                        role: "assistant",
+                        content: "",
+                        additional_kwargs: {
+                            ui_hidden: true
+                        }
+                    },
+                    {
+                        role: "assistant",
+                        content: "keep"
+                    }
+                ]
+            }
+        };
+        const result = extractMessagesFromState(state);
+        expect(result).not.toBeNull();
+        expect(result).toHaveLength(1);
+        expect(result?.[0]).toMatchObject({
+            role: "assistant",
+            content: "keep"
+        });
+    });
+});

package/dist/tests/sessions-api.test.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const sessions_cjs_namespaceObject = require("../gateway/http/sessions.cjs");
+const sessionManager_cjs_namespaceObject = require("../cli/core/sessionManager.cjs");
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const isBunRuntime = void 0 !== globalThis.Bun;
+const describeIfBun = isBunRuntime ? external_vitest_namespaceObject.describe : external_vitest_namespaceObject.describe.skip;
+describeIfBun("sessions API", ()=>{
+    let manager;
+    let tempDir;
+    (0, external_vitest_namespaceObject.beforeEach)(async ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sessions-"));
+        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "sessions.db");
+        manager = new sessionManager_cjs_namespaceObject.SessionManager(dbPath);
+        await manager.initialize();
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        manager.close();
+        (0, external_node_fs_namespaceObject.rmSync)(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("clears persisted session messages", async ()=>{
+        const ctx = {
+            getSessionManager: async ()=>manager,
+            router: {
+                selectAgent: (agentId)=>agentId || "main"
+            }
+        };
+        const createReq = new Request("http://localhost/api/sessions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                agentId: "main",
+                name: "Clear Test"
+            })
+        });
+        const createRes = await (0, sessions_cjs_namespaceObject.handleSessionsApi)(ctx, createReq, new URL(createReq.url));
+        (0, external_vitest_namespaceObject.expect)(createRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        manager.updateSession(created.id, {
+            messageCount: 2,
+            lastMessagePreview: "Hello"
+        });
+        const deleteReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}/messages?agentId=main`, {
+            method: "DELETE"
+        });
+        const deleteRes = await (0, sessions_cjs_namespaceObject.handleSessionsApi)(ctx, deleteReq, new URL(deleteReq.url));
+        (0, external_vitest_namespaceObject.expect)(deleteRes).not.toBeNull();
+        (0, external_vitest_namespaceObject.expect)(deleteRes?.ok).toBe(true);
+        const payload = await deleteRes.json();
+        (0, external_vitest_namespaceObject.expect)(payload.messageCount).toBe(0);
+        const updated = manager.getSession(created.id);
+        (0, external_vitest_namespaceObject.expect)(updated?.messageCount).toBe(0);
+        (0, external_vitest_namespaceObject.expect)(updated?.lastMessagePreview).toBeNull();
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/sessions-api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/sessions-api.test.js

@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { handleSessionsApi } from "../gateway/http/sessions.js";
+import { SessionManager } from "../cli/core/sessionManager.js";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+const isBunRuntime = void 0 !== globalThis.Bun;
+const describeIfBun = isBunRuntime ? describe : describe.skip;
+describeIfBun("sessions API", ()=>{
+    let manager;
+    let tempDir;
+    beforeEach(async ()=>{
+        tempDir = mkdtempSync(join(tmpdir(), "wingman-sessions-"));
+        const dbPath = join(tempDir, "sessions.db");
+        manager = new SessionManager(dbPath);
+        await manager.initialize();
+    });
+    afterEach(()=>{
+        manager.close();
+        rmSync(tempDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    it("clears persisted session messages", async ()=>{
+        const ctx = {
+            getSessionManager: async ()=>manager,
+            router: {
+                selectAgent: (agentId)=>agentId || "main"
+            }
+        };
+        const createReq = new Request("http://localhost/api/sessions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                agentId: "main",
+                name: "Clear Test"
+            })
+        });
+        const createRes = await handleSessionsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        manager.updateSession(created.id, {
+            messageCount: 2,
+            lastMessagePreview: "Hello"
+        });
+        const deleteReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}/messages?agentId=main`, {
+            method: "DELETE"
+        });
+        const deleteRes = await handleSessionsApi(ctx, deleteReq, new URL(deleteReq.url));
+        expect(deleteRes).not.toBeNull();
+        expect(deleteRes?.ok).toBe(true);
+        const payload = await deleteRes.json();
+        expect(payload.messageCount).toBe(0);
+        const updated = manager.getSession(created.id);
+        expect(updated?.messageCount).toBe(0);
+        expect(updated?.lastMessagePreview).toBeNull();
+    });
+});