@wingman-ai/gateway 0.5.2 → 0.5.4

package/dist/tests/hooks-merger.test.js

@@ -1,522 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { mergeHooks } from "../agent/middleware/hooks/merger.js";
-describe("Hooks Configuration Merger", ()=>{
-    const mockHook1 = {
-        type: "command",
-        command: "echo 'global'",
-        timeout: 30
-    };
-    const mockHook2 = {
-        type: "command",
-        command: "echo 'agent'",
-        timeout: 60
-    };
-    const mockHook3 = {
-        type: "command",
-        command: "echo 'extra'"
-    };
-    describe("Empty configurations", ()=>{
-        it("should return undefined when both are undefined", ()=>{
-            const result = mergeHooks(void 0, void 0);
-            expect(result).toBeUndefined();
-        });
-        it("should return global hooks when agent hooks is undefined", ()=>{
-            const globalHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, void 0);
-            expect(result).toBe(globalHooks);
-        });
-        it("should return agent hooks when global hooks is undefined", ()=>{
-            const agentHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(void 0, agentHooks);
-            expect(result).toBe(agentHooks);
-        });
-    });
-    describe("PreToolUse hooks merging", ()=>{
-        it("should merge PreToolUse hooks from both configs", ()=>{
-            const globalHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "write_file",
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(2);
-            expect(result?.PreToolUse?.[0]).toBe(globalHooks.PreToolUse?.[0]);
-            expect(result?.PreToolUse?.[1]).toBe(agentHooks.PreToolUse?.[0]);
-        });
-        it("should include PreToolUse hooks from global only", ()=>{
-            const globalHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {};
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(1);
-            expect(result?.PreToolUse?.[0]).toBe(globalHooks.PreToolUse?.[0]);
-        });
-        it("should include PreToolUse hooks from agent only", ()=>{
-            const globalHooks = {};
-            const agentHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "write_file",
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(1);
-            expect(result?.PreToolUse?.[0]).toBe(agentHooks.PreToolUse?.[0]);
-        });
-        it("should preserve order: global hooks first, then agent hooks", ()=>{
-            const globalMatcher = {
-                matcher: "*",
-                hooks: [
-                    mockHook1
-                ]
-            };
-            const agentMatcher = {
-                matcher: "write_file",
-                hooks: [
-                    mockHook2
-                ]
-            };
-            const globalHooks = {
-                PreToolUse: [
-                    globalMatcher
-                ]
-            };
-            const agentHooks = {
-                PreToolUse: [
-                    agentMatcher
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse?.[0]).toBe(globalMatcher);
-            expect(result?.PreToolUse?.[1]).toBe(agentMatcher);
-        });
-    });
-    describe("PostToolUse hooks merging", ()=>{
-        it("should merge PostToolUse hooks from both configs", ()=>{
-            const globalHooks = {
-                PostToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {
-                PostToolUse: [
-                    {
-                        matcher: "write_file",
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PostToolUse).toHaveLength(2);
-            expect(result?.PostToolUse?.[0]).toBe(globalHooks.PostToolUse?.[0]);
-            expect(result?.PostToolUse?.[1]).toBe(agentHooks.PostToolUse?.[0]);
-        });
-        it("should include PostToolUse hooks from global only", ()=>{
-            const globalHooks = {
-                PostToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {};
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PostToolUse).toHaveLength(1);
-            expect(result?.PostToolUse?.[0]).toBe(globalHooks.PostToolUse?.[0]);
-        });
-        it("should include PostToolUse hooks from agent only", ()=>{
-            const globalHooks = {};
-            const agentHooks = {
-                PostToolUse: [
-                    {
-                        matcher: "write_file",
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PostToolUse).toHaveLength(1);
-            expect(result?.PostToolUse?.[0]).toBe(agentHooks.PostToolUse?.[0]);
-        });
-        it("should preserve order: global hooks first, then agent hooks", ()=>{
-            const globalMatcher = {
-                matcher: "*",
-                hooks: [
-                    mockHook1
-                ]
-            };
-            const agentMatcher = {
-                matcher: "write_file",
-                hooks: [
-                    mockHook2
-                ]
-            };
-            const globalHooks = {
-                PostToolUse: [
-                    globalMatcher
-                ]
-            };
-            const agentHooks = {
-                PostToolUse: [
-                    agentMatcher
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PostToolUse?.[0]).toBe(globalMatcher);
-            expect(result?.PostToolUse?.[1]).toBe(agentMatcher);
-        });
-    });
-    describe("Stop hooks merging", ()=>{
-        it("should merge Stop hooks from both configs", ()=>{
-            const globalHooks = {
-                Stop: [
-                    {
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {
-                Stop: [
-                    {
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.Stop).toHaveLength(2);
-            expect(result?.Stop?.[0]).toBe(globalHooks.Stop?.[0]);
-            expect(result?.Stop?.[1]).toBe(agentHooks.Stop?.[0]);
-        });
-        it("should include Stop hooks from global only", ()=>{
-            const globalHooks = {
-                Stop: [
-                    {
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {};
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.Stop).toHaveLength(1);
-            expect(result?.Stop?.[0]).toBe(globalHooks.Stop?.[0]);
-        });
-        it("should include Stop hooks from agent only", ()=>{
-            const globalHooks = {};
-            const agentHooks = {
-                Stop: [
-                    {
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.Stop).toHaveLength(1);
-            expect(result?.Stop?.[0]).toBe(agentHooks.Stop?.[0]);
-        });
-        it("should preserve order: global hooks first, then agent hooks", ()=>{
-            const globalStop = {
-                hooks: [
-                    mockHook1
-                ]
-            };
-            const agentStop = {
-                hooks: [
-                    mockHook2
-                ]
-            };
-            const globalHooks = {
-                Stop: [
-                    globalStop
-                ]
-            };
-            const agentHooks = {
-                Stop: [
-                    agentStop
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.Stop?.[0]).toBe(globalStop);
-            expect(result?.Stop?.[1]).toBe(agentStop);
-        });
-    });
-    describe("Multi-event merging", ()=>{
-        it("should merge all hook types when both have all types", ()=>{
-            const globalHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ],
-                PostToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ],
-                Stop: [
-                    {
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "write_file",
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ],
-                PostToolUse: [
-                    {
-                        matcher: "write_file",
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ],
-                Stop: [
-                    {
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(2);
-            expect(result?.PostToolUse).toHaveLength(2);
-            expect(result?.Stop).toHaveLength(2);
-        });
-        it("should merge only the hook types that are defined", ()=>{
-            const globalHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {
-                PostToolUse: [
-                    {
-                        matcher: "write_file",
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ],
-                Stop: [
-                    {
-                        hooks: [
-                            mockHook3
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(1);
-            expect(result?.PostToolUse).toHaveLength(1);
-            expect(result?.Stop).toHaveLength(1);
-        });
-        it("should handle complex multi-matcher scenario", ()=>{
-            const globalHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    },
-                    {
-                        matcher: ".*_file",
-                        hooks: [
-                            mockHook2
-                        ]
-                    }
-                ],
-                PostToolUse: [
-                    {
-                        matcher: "write_file|read_file",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "write_file",
-                        hooks: [
-                            mockHook3
-                        ]
-                    }
-                ],
-                Stop: [
-                    {
-                        hooks: [
-                            mockHook2,
-                            mockHook3
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(3);
-            expect(result?.PostToolUse).toHaveLength(1);
-            expect(result?.Stop).toHaveLength(1);
-        });
-    });
-    describe("No duplication handling", ()=>{
-        it("should not deduplicate identical hooks", ()=>{
-            const sharedHook = {
-                type: "command",
-                command: "echo 'shared'"
-            };
-            const globalHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            sharedHook
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            sharedHook
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(2);
-        });
-    });
-    describe("Empty arrays", ()=>{
-        it("should handle empty hook arrays in global config", ()=>{
-            const globalHooks = {
-                PreToolUse: []
-            };
-            const agentHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(1);
-        });
-        it("should handle empty hook arrays in agent config", ()=>{
-            const globalHooks = {
-                PreToolUse: [
-                    {
-                        matcher: "*",
-                        hooks: [
-                            mockHook1
-                        ]
-                    }
-                ]
-            };
-            const agentHooks = {
-                PreToolUse: []
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(1);
-        });
-        it("should handle both having empty arrays", ()=>{
-            const globalHooks = {
-                PreToolUse: []
-            };
-            const agentHooks = {
-                PreToolUse: []
-            };
-            const result = mergeHooks(globalHooks, agentHooks);
-            expect(result?.PreToolUse).toHaveLength(0);
-        });
-    });
-});

package/dist/tests/imagePersistence.test.cjs

@@ -1,169 +0,0 @@
-"use strict";
-var __webpack_exports__ = {};
-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 external_vitest_namespaceObject = require("vitest");
-const imagePersistence_cjs_namespaceObject = require("../cli/core/imagePersistence.cjs");
-const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
-(0, external_vitest_namespaceObject.describe)("imagePersistence", ()=>{
-    const tempDirs = [];
-    (0, external_vitest_namespaceObject.afterEach)(()=>{
-        for (const dir of tempDirs)(0, external_node_fs_namespaceObject.rmSync)(dir, {
-            recursive: true,
-            force: true
-        });
-        tempDirs.length = 0;
-    });
-    (0, external_vitest_namespaceObject.it)("persists assistant image data URLs to disk", ()=>{
-        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
-        tempDirs.push(tempDir);
-        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
-        const messages = [
-            {
-                role: "assistant",
-                attachments: [
-                    {
-                        kind: "image",
-                        dataUrl: PNG_DATA_URL
-                    }
-                ]
-            }
-        ];
-        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
-            dbPath,
-            sessionId: "session-123",
-            messages
-        });
-        const attachment = messages[0].attachments?.[0];
-        (0, external_vitest_namespaceObject.expect)(typeof attachment?.path).toBe("string");
-        (0, external_vitest_namespaceObject.expect)(attachment?.mimeType).toBe("image/png");
-        (0, external_vitest_namespaceObject.expect)(typeof attachment?.size).toBe("number");
-        (0, external_vitest_namespaceObject.expect)(attachment?.size).toBeGreaterThan(0);
-        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(attachment.path)).toBe(true);
-        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.readFileSync)(attachment.path).length).toBe(attachment?.size);
-    });
-    (0, external_vitest_namespaceObject.it)("does not persist non-assistant images", ()=>{
-        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
-        tempDirs.push(tempDir);
-        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
-        const messages = [
-            {
-                role: "user",
-                attachments: [
-                    {
-                        kind: "image",
-                        dataUrl: PNG_DATA_URL
-                    }
-                ]
-            }
-        ];
-        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
-            dbPath,
-            sessionId: "session-123",
-            messages
-        });
-        (0, external_vitest_namespaceObject.expect)(messages[0].attachments?.[0].path).toBeUndefined();
-    });
-    (0, external_vitest_namespaceObject.it)("keeps remote image URLs untouched", ()=>{
-        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
-        tempDirs.push(tempDir);
-        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
-        const messages = [
-            {
-                role: "assistant",
-                attachments: [
-                    {
-                        kind: "image",
-                        dataUrl: "https://example.com/image.png"
-                    }
-                ]
-            }
-        ];
-        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
-            dbPath,
-            sessionId: "session-123",
-            messages
-        });
-        (0, external_vitest_namespaceObject.expect)(messages[0].attachments?.[0].path).toBeUndefined();
-    });
-    (0, external_vitest_namespaceObject.it)("derives deterministic file paths for repeated image payloads", ()=>{
-        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
-        tempDirs.push(tempDir);
-        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
-        const messages = [
-            {
-                role: "assistant",
-                attachments: [
-                    {
-                        kind: "image",
-                        dataUrl: PNG_DATA_URL
-                    }
-                ]
-            }
-        ];
-        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
-            dbPath,
-            sessionId: "session-123",
-            messages
-        });
-        const firstPath = messages[0].attachments?.[0].path;
-        const nextMessages = [
-            {
-                role: "assistant",
-                attachments: [
-                    {
-                        kind: "image",
-                        dataUrl: PNG_DATA_URL
-                    }
-                ]
-            }
-        ];
-        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
-            dbPath,
-            sessionId: "session-123",
-            messages: nextMessages
-        });
-        const secondPath = nextMessages[0].attachments?.[0].path;
-        (0, external_vitest_namespaceObject.expect)(firstPath).toBeTruthy();
-        (0, external_vitest_namespaceObject.expect)(secondPath).toBe(firstPath);
-    });
-    (0, external_vitest_namespaceObject.it)("removes persisted session media directory", ()=>{
-        const tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-image-store-"));
-        tempDirs.push(tempDir);
-        const dbPath = (0, external_node_path_namespaceObject.join)(tempDir, "wingman.db");
-        const sessionId = "session-cleanup";
-        const messages = [
-            {
-                role: "assistant",
-                attachments: [
-                    {
-                        kind: "image",
-                        dataUrl: PNG_DATA_URL
-                    }
-                ]
-            }
-        ];
-        (0, imagePersistence_cjs_namespaceObject.persistAssistantImagesToDisk)({
-            dbPath,
-            sessionId,
-            messages
-        });
-        const mediaDir = (0, imagePersistence_cjs_namespaceObject.getSessionMediaDirectory)(dbPath, sessionId);
-        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(true);
-        (0, imagePersistence_cjs_namespaceObject.removeSessionMediaDirectory)(dbPath, sessionId);
-        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(mediaDir)).toBe(false);
-    });
-    (0, external_vitest_namespaceObject.it)("parses base64 data URLs and resolves extensions", ()=>{
-        const parsed = (0, imagePersistence_cjs_namespaceObject.parseBase64DataUrl)(PNG_DATA_URL);
-        (0, external_vitest_namespaceObject.expect)(parsed?.mimeType).toBe("image/png");
-        (0, external_vitest_namespaceObject.expect)(typeof parsed?.data).toBe("string");
-        (0, external_vitest_namespaceObject.expect)((0, imagePersistence_cjs_namespaceObject.resolveImageExtension)("image/jpeg")).toBe("jpg");
-        (0, external_vitest_namespaceObject.expect)((0, imagePersistence_cjs_namespaceObject.resolveImageExtension)("image/svg+xml")).toBe("svg");
-        (0, external_vitest_namespaceObject.expect)((0, imagePersistence_cjs_namespaceObject.resolveImageExtension)("image/custom+format")).toBe("customformat");
-    });
-});
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

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

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