@wingman-ai/gateway 0.4.1 → 0.4.3

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

@@ -1,7 +1,8 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { getSessionMediaDirectory, persistAssistantImagesToDisk } from "../cli/core/imagePersistence.js";
 import { SessionManager } from "../cli/core/sessionManager.js";
 import { handleSessionsApi } from "../gateway/http/sessions.js";
 const isBunRuntime = void 0 !== globalThis.Bun;
@@ -9,9 +10,11 @@ const describeIfBun = isBunRuntime ? describe : describe.skip;
 describeIfBun("sessions API", ()=>{
     let manager;
     let tempDir;
+    let dbPath;
+    const PNG_DATA_URL = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO3X6S0AAAAASUVORK5CYII=";
     beforeEach(async ()=>{
         tempDir = mkdtempSync(join(tmpdir(), "wingman-sessions-"));
-        const dbPath = join(tempDir, "sessions.db");
+        dbPath = join(tempDir, "sessions.db");
         manager = new SessionManager(dbPath);
         await manager.initialize();
     });
@@ -43,6 +46,23 @@ describeIfBun("sessions API", ()=>{
         expect(createRes).not.toBeNull();
         expect(createRes?.ok).toBe(true);
         const created = await createRes.json();
+        const mediaDir = getSessionMediaDirectory(dbPath, created.id);
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: created.id,
+            messages: [
+                {
+                    role: "assistant",
+                    attachments: [
+                        {
+                            kind: "image",
+                            dataUrl: PNG_DATA_URL
+                        }
+                    ]
+                }
+            ]
+        });
+        expect(existsSync(mediaDir)).toBe(true);
         manager.updateSession(created.id, {
             messageCount: 2,
             lastMessagePreview: "Hello"
@@ -55,10 +75,58 @@ describeIfBun("sessions API", ()=>{
         expect(deleteRes?.ok).toBe(true);
         const payload = await deleteRes.json();
         expect(payload.messageCount).toBe(0);
+        expect(existsSync(mediaDir)).toBe(false);
         const updated = manager.getSession(created.id);
         expect(updated?.messageCount).toBe(0);
         expect(updated?.lastMessagePreview).toBeNull();
     });
+    it("removes persisted session media when deleting a session", 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: "Delete Session Media"
+            })
+        });
+        const createRes = await handleSessionsApi(ctx, createReq, new URL(createReq.url));
+        expect(createRes).not.toBeNull();
+        expect(createRes?.ok).toBe(true);
+        const created = await createRes.json();
+        const mediaDir = getSessionMediaDirectory(dbPath, created.id);
+        persistAssistantImagesToDisk({
+            dbPath,
+            sessionId: created.id,
+            messages: [
+                {
+                    role: "assistant",
+                    attachments: [
+                        {
+                            kind: "image",
+                            dataUrl: PNG_DATA_URL
+                        }
+                    ]
+                }
+            ]
+        });
+        expect(existsSync(mediaDir)).toBe(true);
+        const deleteReq = new Request(`http://localhost/api/sessions/${encodeURIComponent(created.id)}?agentId=main`, {
+            method: "DELETE"
+        });
+        const deleteRes = await handleSessionsApi(ctx, deleteReq, new URL(deleteReq.url));
+        expect(deleteRes).not.toBeNull();
+        expect(deleteRes?.ok).toBe(true);
+        expect(existsSync(mediaDir)).toBe(false);
+        expect(manager.getSession(created.id)).toBeNull();
+    });
     it("returns pending messages and clears them via DELETE", async ()=>{
         const ctx = {
             getSessionManager: async ()=>manager,

package/dist/tests/skill-activation.test.cjs

@@ -0,0 +1,86 @@
+"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 activation_cjs_namespaceObject = require("../skills/activation.cjs");
+const tempDirs = [];
+const createSkill = (root, skillName, frontmatter)=>{
+    const skillDir = (0, external_node_path_namespaceObject.join)(root, skillName);
+    (0, external_node_fs_namespaceObject.mkdirSync)(skillDir, {
+        recursive: true
+    });
+    (0, external_node_fs_namespaceObject.writeFileSync)(skillDir + "/SKILL.md", `${frontmatter}\n\n# ${skillName}\n`);
+};
+(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.describe)("resolveSkillActivation", ()=>{
+    (0, external_vitest_namespaceObject.it)("deactivates skills with missing required bins", async ()=>{
+        const root = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-skill-activation-"));
+        tempDirs.push(root);
+        createSkill(root, "gog", `---
+name: gog
+description: Google tooling
+metadata:
+  wingman:
+    requires:
+      bins: ["gog"]
+---`);
+        createSkill(root, "weather", `---
+name: weather
+description: Weather tooling
+---`);
+        const result = await (0, activation_cjs_namespaceObject.resolveSkillActivation)(root, (binName)=>"gog" !== binName);
+        (0, external_vitest_namespaceObject.expect)(result.activeSkillNames).toContain("weather");
+        (0, external_vitest_namespaceObject.expect)(result.activeSkillNames).not.toContain("gog");
+        (0, external_vitest_namespaceObject.expect)(result.inactiveSkills).toEqual([
+            {
+                name: "gog",
+                namespace: "wingman",
+                requiredBins: [
+                    "gog"
+                ],
+                missingBins: [
+                    "gog"
+                ]
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("ignores unsupported namespaces and keeps skills active", async ()=>{
+        const root = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-skill-activation-"));
+        tempDirs.push(root);
+        createSkill(root, "legacy", `---
+name: legacy
+description: Legacy metadata
+metadata:
+  clawdbot:
+    requires:
+      bins: ["gog"]
+---`);
+        const result = await (0, activation_cjs_namespaceObject.resolveSkillActivation)(root, ()=>false);
+        (0, external_vitest_namespaceObject.expect)(result.activeSkillNames).toContain("legacy");
+        (0, external_vitest_namespaceObject.expect)(result.inactiveSkills).toHaveLength(0);
+    });
+    (0, external_vitest_namespaceObject.it)("keeps skill active when frontmatter parsing fails", async ()=>{
+        const root = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-skill-activation-"));
+        tempDirs.push(root);
+        const skillDir = (0, external_node_path_namespaceObject.join)(root, "broken");
+        (0, external_node_fs_namespaceObject.mkdirSync)(skillDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)((0, external_node_path_namespaceObject.join)(skillDir, "SKILL.md"), "---\nname: broken\nnot-valid\n---");
+        const result = await (0, activation_cjs_namespaceObject.resolveSkillActivation)(root, ()=>true);
+        (0, external_vitest_namespaceObject.expect)(result.activeSkillNames).toContain("broken");
+        (0, external_vitest_namespaceObject.expect)(result.inactiveSkills).toHaveLength(0);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/skill-activation.test.d.ts

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

package/dist/tests/skill-activation.test.js

@@ -0,0 +1,80 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { resolveSkillActivation } from "../skills/activation.js";
+const tempDirs = [];
+const createSkill = (root, skillName, frontmatter)=>{
+    const skillDir = join(root, skillName);
+    mkdirSync(skillDir, {
+        recursive: true
+    });
+    writeFileSync(skillDir + "/SKILL.md", `${frontmatter}\n\n# ${skillName}\n`);
+};
+afterEach(()=>{
+    for (const dir of tempDirs)rmSync(dir, {
+        recursive: true,
+        force: true
+    });
+    tempDirs.length = 0;
+});
+describe("resolveSkillActivation", ()=>{
+    it("deactivates skills with missing required bins", async ()=>{
+        const root = mkdtempSync(join(tmpdir(), "wingman-skill-activation-"));
+        tempDirs.push(root);
+        createSkill(root, "gog", `---
+name: gog
+description: Google tooling
+metadata:
+  wingman:
+    requires:
+      bins: ["gog"]
+---`);
+        createSkill(root, "weather", `---
+name: weather
+description: Weather tooling
+---`);
+        const result = await resolveSkillActivation(root, (binName)=>"gog" !== binName);
+        expect(result.activeSkillNames).toContain("weather");
+        expect(result.activeSkillNames).not.toContain("gog");
+        expect(result.inactiveSkills).toEqual([
+            {
+                name: "gog",
+                namespace: "wingman",
+                requiredBins: [
+                    "gog"
+                ],
+                missingBins: [
+                    "gog"
+                ]
+            }
+        ]);
+    });
+    it("ignores unsupported namespaces and keeps skills active", async ()=>{
+        const root = mkdtempSync(join(tmpdir(), "wingman-skill-activation-"));
+        tempDirs.push(root);
+        createSkill(root, "legacy", `---
+name: legacy
+description: Legacy metadata
+metadata:
+  clawdbot:
+    requires:
+      bins: ["gog"]
+---`);
+        const result = await resolveSkillActivation(root, ()=>false);
+        expect(result.activeSkillNames).toContain("legacy");
+        expect(result.inactiveSkills).toHaveLength(0);
+    });
+    it("keeps skill active when frontmatter parsing fails", async ()=>{
+        const root = mkdtempSync(join(tmpdir(), "wingman-skill-activation-"));
+        tempDirs.push(root);
+        const skillDir = join(root, "broken");
+        mkdirSync(skillDir, {
+            recursive: true
+        });
+        writeFileSync(join(skillDir, "SKILL.md"), "---\nname: broken\nnot-valid\n---");
+        const result = await resolveSkillActivation(root, ()=>true);
+        expect(result.activeSkillNames).toContain("broken");
+        expect(result.inactiveSkills).toHaveLength(0);
+    });
+});

package/dist/tests/skill-metadata.test.cjs

@@ -0,0 +1,119 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const metadata_cjs_namespaceObject = require("../skills/metadata.cjs");
+(0, external_vitest_namespaceObject.describe)("parseSkillFrontmatter", ()=>{
+    (0, external_vitest_namespaceObject.it)("parses wingman metadata with requires and install recipes", ()=>{
+        const content = `---
+name: gog
+description: Google tooling
+metadata:
+  wingman:
+    emoji: "🎮"
+    requires:
+      bins: ["gog"]
+    install:
+      - id: brew
+        kind: brew
+        formula: steipete/tap/gogcli
+        bins: ["gog"]
+        label: Install gog (brew)
+---
+
+# gog
+`;
+        const parsed = (0, metadata_cjs_namespaceObject.parseSkillFrontmatter)(content);
+        (0, external_vitest_namespaceObject.expect)(parsed.name).toBe("gog");
+        (0, external_vitest_namespaceObject.expect)(parsed.description).toBe("Google tooling");
+        (0, external_vitest_namespaceObject.expect)(parsed.runtimeMetadata?.namespace).toBe("wingman");
+        (0, external_vitest_namespaceObject.expect)(parsed.runtimeMetadata?.requires.bins).toEqual([
+            "gog"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(parsed.runtimeMetadata?.install).toEqual([
+            {
+                id: "brew",
+                kind: "brew",
+                formula: "steipete/tap/gogcli",
+                bins: [
+                    "gog"
+                ],
+                label: "Install gog (brew)"
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("prefers wingman over openclaw when both namespaces are present", ()=>{
+        const content = `---
+name: dual
+description: Dual namespace
+metadata:
+  openclaw:
+    requires:
+      bins: ["oldbin"]
+  wingman:
+    requires:
+      bins: ["newbin"]
+---
+
+# dual
+`;
+        const parsed = (0, metadata_cjs_namespaceObject.parseSkillFrontmatter)(content);
+        (0, external_vitest_namespaceObject.expect)(parsed.runtimeMetadata?.namespace).toBe("wingman");
+        (0, external_vitest_namespaceObject.expect)(parsed.runtimeMetadata?.requires.bins).toEqual([
+            "newbin"
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("supports openclaw namespace when wingman is absent", ()=>{
+        const content = `---
+name: open
+description: Openclaw namespace
+metadata:
+  openclaw:
+    requires:
+      bins: ["gog"]
+---
+
+# open
+`;
+        const parsed = (0, metadata_cjs_namespaceObject.parseSkillFrontmatter)(content);
+        (0, external_vitest_namespaceObject.expect)(parsed.runtimeMetadata?.namespace).toBe("openclaw");
+        (0, external_vitest_namespaceObject.expect)(parsed.runtimeMetadata?.requires.bins).toEqual([
+            "gog"
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("ignores unsupported namespaces like clawdbot", ()=>{
+        const content = `---
+name: legacy
+description: Legacy metadata
+metadata:
+  clawdbot:
+    requires:
+      bins: ["gog"]
+---
+
+# legacy
+`;
+        const parsed = (0, metadata_cjs_namespaceObject.parseSkillFrontmatter)(content);
+        (0, external_vitest_namespaceObject.expect)(parsed.runtimeMetadata).toBeNull();
+    });
+    (0, external_vitest_namespaceObject.it)("normalizes allowed tools from either key", ()=>{
+        const content = `---
+name: ui-registry
+description: UI helpers
+allowedTools:
+  - ui_registry_list
+  - ui_present
+---
+
+# ui
+`;
+        const parsed = (0, metadata_cjs_namespaceObject.parseSkillFrontmatter)(content);
+        (0, external_vitest_namespaceObject.expect)(parsed.allowedTools).toEqual([
+            "ui_registry_list",
+            "ui_present"
+        ]);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/skill-metadata.test.d.ts

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

package/dist/tests/skill-metadata.test.js

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import { parseSkillFrontmatter } from "../skills/metadata.js";
+describe("parseSkillFrontmatter", ()=>{
+    it("parses wingman metadata with requires and install recipes", ()=>{
+        const content = `---
+name: gog
+description: Google tooling
+metadata:
+  wingman:
+    emoji: "🎮"
+    requires:
+      bins: ["gog"]
+    install:
+      - id: brew
+        kind: brew
+        formula: steipete/tap/gogcli
+        bins: ["gog"]
+        label: Install gog (brew)
+---
+
+# gog
+`;
+        const parsed = parseSkillFrontmatter(content);
+        expect(parsed.name).toBe("gog");
+        expect(parsed.description).toBe("Google tooling");
+        expect(parsed.runtimeMetadata?.namespace).toBe("wingman");
+        expect(parsed.runtimeMetadata?.requires.bins).toEqual([
+            "gog"
+        ]);
+        expect(parsed.runtimeMetadata?.install).toEqual([
+            {
+                id: "brew",
+                kind: "brew",
+                formula: "steipete/tap/gogcli",
+                bins: [
+                    "gog"
+                ],
+                label: "Install gog (brew)"
+            }
+        ]);
+    });
+    it("prefers wingman over openclaw when both namespaces are present", ()=>{
+        const content = `---
+name: dual
+description: Dual namespace
+metadata:
+  openclaw:
+    requires:
+      bins: ["oldbin"]
+  wingman:
+    requires:
+      bins: ["newbin"]
+---
+
+# dual
+`;
+        const parsed = parseSkillFrontmatter(content);
+        expect(parsed.runtimeMetadata?.namespace).toBe("wingman");
+        expect(parsed.runtimeMetadata?.requires.bins).toEqual([
+            "newbin"
+        ]);
+    });
+    it("supports openclaw namespace when wingman is absent", ()=>{
+        const content = `---
+name: open
+description: Openclaw namespace
+metadata:
+  openclaw:
+    requires:
+      bins: ["gog"]
+---
+
+# open
+`;
+        const parsed = parseSkillFrontmatter(content);
+        expect(parsed.runtimeMetadata?.namespace).toBe("openclaw");
+        expect(parsed.runtimeMetadata?.requires.bins).toEqual([
+            "gog"
+        ]);
+    });
+    it("ignores unsupported namespaces like clawdbot", ()=>{
+        const content = `---
+name: legacy
+description: Legacy metadata
+metadata:
+  clawdbot:
+    requires:
+      bins: ["gog"]
+---
+
+# legacy
+`;
+        const parsed = parseSkillFrontmatter(content);
+        expect(parsed.runtimeMetadata).toBeNull();
+    });
+    it("normalizes allowed tools from either key", ()=>{
+        const content = `---
+name: ui-registry
+description: UI helpers
+allowedTools:
+  - ui_registry_list
+  - ui_present
+---
+
+# ui
+`;
+        const parsed = parseSkillFrontmatter(content);
+        expect(parsed.allowedTools).toEqual([
+            "ui_registry_list",
+            "ui_present"
+        ]);
+    });
+});