@wingman-ai/gateway 0.4.1 → 0.4.3

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

@@ -98,3 +98,366 @@ describe("SkillRepository clawhub provider", ()=>{
         expect(fetchMock).toHaveBeenCalledTimes(4);
     });
 });
+describe("SkillRepository github provider", ()=>{
+    const originalFetch = globalThis.fetch;
+    afterEach(()=>{
+        globalThis.fetch = originalFetch;
+        vi.restoreAllMocks();
+    });
+    it("merges skills across repositories with later sources overriding earlier ones", async ()=>{
+        const encodeSkill = (name, description)=>Buffer.from(`---\nname: ${name}\ndescription: ${description}\n---\n`, "utf-8").toString("base64");
+        const fetchMock = vi.fn(async (input)=>{
+            const url = input.toString();
+            if (url.endsWith("/repos/example-org/community-skills/contents/skills")) return new Response(JSON.stringify([
+                {
+                    name: "gog",
+                    path: "skills/gog",
+                    type: "dir",
+                    url: "https://api.github.com/repos/example-org/community-skills/contents/skills/gog"
+                },
+                {
+                    name: "alpha",
+                    path: "skills/alpha",
+                    type: "dir",
+                    url: "https://api.github.com/repos/example-org/community-skills/contents/skills/alpha"
+                }
+            ]), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills")) return new Response(JSON.stringify([
+                {
+                    name: "alpha",
+                    path: "skills/alpha",
+                    type: "dir",
+                    url: "https://api.github.com/repos/example-team/custom-skills/contents/skills/alpha"
+                },
+                {
+                    name: "wingman-special",
+                    path: "skills/wingman-special",
+                    type: "dir",
+                    url: "https://api.github.com/repos/example-team/custom-skills/contents/skills/wingman-special"
+                }
+            ]), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-org/community-skills/contents/skills/gog/SKILL.md")) return new Response(JSON.stringify({
+                type: "file",
+                content: encodeSkill("gog", "Community gog skill")
+            }), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-org/community-skills/contents/skills/alpha/SKILL.md")) return new Response(JSON.stringify({
+                type: "file",
+                content: encodeSkill("alpha", "Community alpha skill")
+            }), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills/alpha/SKILL.md")) return new Response(JSON.stringify({
+                type: "file",
+                content: encodeSkill("alpha", "Custom alpha override")
+            }), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills/wingman-special/SKILL.md")) return new Response(JSON.stringify({
+                type: "file",
+                content: encodeSkill("wingman-special", "Custom-only skill")
+            }), {
+                status: 200
+            });
+            return new Response("Not Found", {
+                status: 404
+            });
+        });
+        globalThis.fetch = fetchMock;
+        const repository = new SkillRepository({
+            provider: "github",
+            repositories: [
+                {
+                    owner: "example-org",
+                    name: "community-skills"
+                },
+                {
+                    owner: "example-team",
+                    name: "custom-skills"
+                }
+            ]
+        });
+        const skills = await repository.listAvailableSkills();
+        expect(skills).toEqual([
+            {
+                name: "gog",
+                description: "Community gog skill",
+                path: "skills/gog",
+                metadata: {
+                    name: "gog",
+                    description: "Community gog skill"
+                }
+            },
+            {
+                name: "alpha",
+                description: "Custom alpha override",
+                path: "skills/alpha",
+                metadata: {
+                    name: "alpha",
+                    description: "Custom alpha override"
+                }
+            },
+            {
+                name: "wingman-special",
+                description: "Custom-only skill",
+                path: "skills/wingman-special",
+                metadata: {
+                    name: "wingman-special",
+                    description: "Custom-only skill"
+                }
+            }
+        ]);
+    });
+    it("downloads a skill from the highest-priority matching repository", async ()=>{
+        const encodedSkill = Buffer.from("---\nname: alpha\ndescription: Custom alpha override\n---\n", "utf-8").toString("base64");
+        const encodedExample = Buffer.from("# Custom Example\n", "utf-8").toString("base64");
+        const fetchMock = vi.fn(async (input)=>{
+            const url = input.toString();
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills/alpha/SKILL.md")) return new Response(JSON.stringify({
+                type: "file",
+                content: encodedSkill,
+                encoding: "base64"
+            }), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills/alpha")) return new Response(JSON.stringify([
+                {
+                    type: "file",
+                    name: "SKILL.md",
+                    path: "skills/alpha/SKILL.md",
+                    content: encodedSkill,
+                    encoding: "base64"
+                },
+                {
+                    type: "file",
+                    name: "examples.md",
+                    path: "skills/alpha/examples.md",
+                    content: encodedExample,
+                    encoding: "base64"
+                }
+            ]), {
+                status: 200
+            });
+            return new Response("Not Found", {
+                status: 404
+            });
+        });
+        globalThis.fetch = fetchMock;
+        const repository = new SkillRepository({
+            provider: "github",
+            repositories: [
+                {
+                    owner: "example-org",
+                    name: "community-skills"
+                },
+                {
+                    owner: "example-team",
+                    name: "custom-skills"
+                }
+            ]
+        });
+        const files = await repository.downloadSkill("alpha");
+        expect(files.size).toBe(2);
+        expect(files.get("SKILL.md")?.toString("utf-8")).toContain("Custom alpha override");
+        expect(files.get("examples.md")?.toString("utf-8")).toContain("Custom Example");
+        const requestedUrls = fetchMock.mock.calls.map((call)=>call[0].toString());
+        expect(requestedUrls.some((url)=>url.includes("/repos/example-org/community-skills/contents/skills/alpha"))).toBe(false);
+    });
+    it("uses legacy repositoryOwner/repositoryName when repositories are not provided", async ()=>{
+        const fetchMock = vi.fn(async (input)=>{
+            const url = input.toString();
+            if (url.endsWith("/repos/myorg/myskills/contents/skills")) return new Response(JSON.stringify([
+                {
+                    name: "legacy-skill",
+                    path: "skills/legacy-skill",
+                    type: "dir",
+                    url: "https://api.github.com/repos/myorg/myskills/contents/skills/legacy-skill"
+                }
+            ]), {
+                status: 200
+            });
+            if (url.endsWith("/repos/myorg/myskills/contents/skills/legacy-skill/SKILL.md")) return new Response(JSON.stringify({
+                type: "file",
+                content: Buffer.from("---\nname: legacy-skill\ndescription: Legacy source\n---\n", "utf-8").toString("base64")
+            }), {
+                status: 200
+            });
+            return new Response("Not Found", {
+                status: 404
+            });
+        });
+        globalThis.fetch = fetchMock;
+        const repository = new SkillRepository({
+            provider: "github",
+            repositoryOwner: "myorg",
+            repositoryName: "myskills"
+        });
+        const skills = await repository.listAvailableSkills();
+        expect(skills).toHaveLength(1);
+        expect(skills[0]?.name).toBe("legacy-skill");
+    });
+    it("fails clearly when github provider has no configured repositories", async ()=>{
+        const repository = new SkillRepository({
+            provider: "github"
+        });
+        await expect(repository.listAvailableSkills()).rejects.toThrow("No GitHub skill repositories configured");
+    });
+});
+describe("SkillRepository hybrid provider", ()=>{
+    const originalFetch = globalThis.fetch;
+    afterEach(()=>{
+        globalThis.fetch = originalFetch;
+        vi.restoreAllMocks();
+    });
+    it("merges ClawHub and GitHub skills, with GitHub overriding conflicts", async ()=>{
+        const encodeSkill = (name, description)=>Buffer.from(`---\nname: ${name}\ndescription: ${description}\n---\n`, "utf-8").toString("base64");
+        const fetchMock = vi.fn(async (input)=>{
+            const url = input.toString();
+            if ("https://clawhub.ai/api/v1/skills?sort=downloads&limit=100" === url) return new Response(JSON.stringify({
+                items: [
+                    {
+                        slug: "alpha",
+                        summary: "ClawHub alpha skill"
+                    },
+                    {
+                        slug: "weather",
+                        summary: "ClawHub weather skill"
+                    }
+                ],
+                nextCursor: null
+            }), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills")) return new Response(JSON.stringify([
+                {
+                    name: "alpha",
+                    path: "skills/alpha",
+                    type: "dir",
+                    url: "https://api.github.com/repos/example-team/custom-skills/contents/skills/alpha"
+                },
+                {
+                    name: "wingman-special",
+                    path: "skills/wingman-special",
+                    type: "dir",
+                    url: "https://api.github.com/repos/example-team/custom-skills/contents/skills/wingman-special"
+                }
+            ]), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills/alpha/SKILL.md")) return new Response(JSON.stringify({
+                type: "file",
+                content: encodeSkill("alpha", "GitHub alpha override")
+            }), {
+                status: 200
+            });
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills/wingman-special/SKILL.md")) return new Response(JSON.stringify({
+                type: "file",
+                content: encodeSkill("wingman-special", "GitHub only skill")
+            }), {
+                status: 200
+            });
+            return new Response("Not Found", {
+                status: 404
+            });
+        });
+        globalThis.fetch = fetchMock;
+        const repository = new SkillRepository({
+            provider: "hybrid",
+            repositories: [
+                {
+                    owner: "example-team",
+                    name: "custom-skills"
+                }
+            ],
+            clawhubBaseUrl: "https://clawhub.ai"
+        });
+        const skills = await repository.listAvailableSkills();
+        expect(skills).toEqual([
+            {
+                name: "weather",
+                description: "ClawHub weather skill",
+                path: "weather",
+                metadata: {
+                    name: "weather",
+                    description: "ClawHub weather skill"
+                }
+            },
+            {
+                name: "alpha",
+                description: "GitHub alpha override",
+                path: "skills/alpha",
+                metadata: {
+                    name: "alpha",
+                    description: "GitHub alpha override"
+                }
+            },
+            {
+                name: "wingman-special",
+                description: "GitHub only skill",
+                path: "skills/wingman-special",
+                metadata: {
+                    name: "wingman-special",
+                    description: "GitHub only skill"
+                }
+            }
+        ]);
+    });
+    it("falls back to ClawHub when a skill is missing from configured GitHub repos", async ()=>{
+        const fetchMock = vi.fn(async (input)=>{
+            const url = input.toString();
+            if (url.endsWith("/repos/example-team/custom-skills/contents/skills/gog/SKILL.md")) return new Response("Not Found", {
+                status: 404
+            });
+            if ("https://clawhub.ai/api/v1/skills/gog" === url) return new Response(JSON.stringify({
+                skill: {
+                    slug: "gog",
+                    summary: "Google workspace tooling"
+                },
+                latestVersion: {
+                    version: "1.0.0"
+                }
+            }), {
+                status: 200
+            });
+            if ("https://clawhub.ai/api/v1/skills/gog/versions/1.0.0" === url) return new Response(JSON.stringify({
+                version: {
+                    version: "1.0.0",
+                    files: [
+                        {
+                            path: "SKILL.md"
+                        }
+                    ]
+                }
+            }), {
+                status: 200
+            });
+            if (url.includes("/api/v1/skills/gog/file?")) return new Response("---\nname: gog\ndescription: Test\n---\n", {
+                status: 200
+            });
+            return new Response("Not Found", {
+                status: 404
+            });
+        });
+        globalThis.fetch = fetchMock;
+        const repository = new SkillRepository({
+            provider: "hybrid",
+            repositories: [
+                {
+                    owner: "example-team",
+                    name: "custom-skills"
+                }
+            ],
+            clawhubBaseUrl: "https://clawhub.ai"
+        });
+        const metadata = await repository.getSkillMetadata("gog");
+        expect(metadata.name).toBe("gog");
+        expect(metadata.description).toContain("Google workspace tooling");
+        const files = await repository.downloadSkill("gog");
+        expect(files.has("SKILL.md")).toBe(true);
+    });
+});

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

@@ -0,0 +1,183 @@
+"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 sms_cjs_namespaceObject = require("../gateway/http/sms.cjs");
+const requireTempDir = (value)=>{
+    if (!value) throw new Error("temp dir not initialized");
+    return value;
+};
+(0, external_vitest_namespaceObject.describe)("sms policy api", ()=>{
+    let tempDir = null;
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if (!tempDir) return;
+        (0, external_node_fs_namespaceObject.rmSync)(tempDir, {
+            recursive: true,
+            force: true
+        });
+        tempDir = null;
+    });
+    (0, external_vitest_namespaceObject.it)("updates, fetches, and resets policy records", async ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-api-"));
+        const store = (0, sms_cjs_namespaceObject.createSmsPolicyStateStore)(()=>requireTempDir(tempDir));
+        const target = encodeURIComponent("sms-macos:+15555550000");
+        const ctx = {};
+        const updateReq = new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                stopEnabled: true,
+                pauseForMs: 120000,
+                alertMode: "all"
+            })
+        });
+        const updateRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, updateReq, new URL(updateReq.url));
+        (0, external_vitest_namespaceObject.expect)(updateRes?.status).toBe(200);
+        const updated = await updateRes?.json();
+        (0, external_vitest_namespaceObject.expect)(updated.paused).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(updated.pausedUntil).toBeTypeOf("number");
+        (0, external_vitest_namespaceObject.expect)(updated.stopEnabled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(updated.alertMode).toBe("all");
+        const getRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "GET"
+        }), new URL(`http://localhost/api/sms/policies/${target}`));
+        (0, external_vitest_namespaceObject.expect)(getRes?.status).toBe(200);
+        const listRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, new Request("http://localhost/api/sms/policies", {
+            method: "GET"
+        }), new URL("http://localhost/api/sms/policies"));
+        (0, external_vitest_namespaceObject.expect)(listRes?.status).toBe(200);
+        const listPayload = await listRes?.json();
+        (0, external_vitest_namespaceObject.expect)(listPayload.policies).toHaveLength(1);
+        const deleteRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, new Request(`http://localhost/api/sms/policies/${target}`, {
+            method: "DELETE"
+        }), new URL(`http://localhost/api/sms/policies/${target}`));
+        (0, external_vitest_namespaceObject.expect)(deleteRes?.status).toBe(200);
+        const reset = await deleteRes?.json();
+        (0, external_vitest_namespaceObject.expect)(reset.paused).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(reset.stopEnabled).toBe(false);
+    });
+    (0, external_vitest_namespaceObject.it)("applies control commands and leaves non-commands as pass-through text", async ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-api-"));
+        const store = (0, sms_cjs_namespaceObject.createSmsPolicyStateStore)(()=>requireTempDir(tempDir));
+        const target = encodeURIComponent("sms-macos:+15555550000");
+        const ctx = {
+            router: {
+                selectAgent: ()=>"main",
+                buildSessionKey: ()=>"agent:main:sms-macos:dm:+15555550000"
+            }
+        };
+        const pauseReq = new Request(`http://localhost/api/sms/policies/${target}/command`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                text: "PAUSE 2h",
+                nowMs: 10000
+            })
+        });
+        const pauseRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, pauseReq, new URL(pauseReq.url));
+        (0, external_vitest_namespaceObject.expect)(pauseRes?.status).toBe(200);
+        const pausedPayload = await pauseRes?.json();
+        (0, external_vitest_namespaceObject.expect)(pausedPayload.handled).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(pausedPayload.command?.name).toBe("pause");
+        (0, external_vitest_namespaceObject.expect)(pausedPayload.policy.paused).toBe(true);
+        const textReq = new Request(`http://localhost/api/sms/policies/${target}/command`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                text: "deploy this now"
+            })
+        });
+        const textRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, textReq, new URL(textReq.url));
+        (0, external_vitest_namespaceObject.expect)(textRes?.status).toBe(200);
+        const textPayload = await textRes?.json();
+        (0, external_vitest_namespaceObject.expect)(textPayload.handled).toBe(false);
+        (0, external_vitest_namespaceObject.expect)(textPayload.passThroughText).toBe("deploy this now");
+    });
+    (0, external_vitest_namespaceObject.it)("normalizes inbound messages into command, stopped, or agent results", async ()=>{
+        tempDir = (0, external_node_fs_namespaceObject.mkdtempSync)((0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), "wingman-sms-api-"));
+        const store = (0, sms_cjs_namespaceObject.createSmsPolicyStateStore)(()=>requireTempDir(tempDir));
+        const ctx = {
+            router: {
+                selectAgent: ()=>"main",
+                buildSessionKey: ()=>"agent:main:sms-macos:dm:+15555550000"
+            }
+        };
+        const commandReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "HELP"
+            })
+        });
+        const commandRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, commandReq, new URL(commandReq.url));
+        (0, external_vitest_namespaceObject.expect)(commandRes?.status).toBe(200);
+        const commandPayload = await commandRes?.json();
+        (0, external_vitest_namespaceObject.expect)(commandPayload.kind).toBe("command");
+        (0, external_vitest_namespaceObject.expect)(commandPayload.handled).toBe(true);
+        const stopReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "STOP"
+            })
+        });
+        const stopRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, stopReq, new URL(stopReq.url));
+        (0, external_vitest_namespaceObject.expect)(stopRes?.status).toBe(200);
+        const blockedReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "summarize my build failures"
+            })
+        });
+        const blockedRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, blockedReq, new URL(blockedReq.url));
+        (0, external_vitest_namespaceObject.expect)(blockedRes?.status).toBe(200);
+        const blockedPayload = await blockedRes?.json();
+        (0, external_vitest_namespaceObject.expect)(blockedPayload.kind).toBe("stopped");
+        (0, external_vitest_namespaceObject.expect)(blockedPayload.responseText).toContain("stopped");
+        store.upsert("sms-macos:+15555550000", {
+            stopEnabled: false
+        });
+        const agentReq = new Request("http://localhost/api/sms/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                target: "sms-macos:+15555550000",
+                text: "summarize my build failures",
+                queueIfBusy: true
+            })
+        });
+        const agentRes = await (0, sms_cjs_namespaceObject.handleSmsApi)(ctx, store, agentReq, new URL(agentReq.url));
+        (0, external_vitest_namespaceObject.expect)(agentRes?.status).toBe(200);
+        const agentPayload = await agentRes?.json();
+        (0, external_vitest_namespaceObject.expect)(agentPayload.kind).toBe("agent");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.agentId).toBe("main");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.content).toBe("summarize my build failures");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.sessionKey).toBe("agent:main:sms-macos:dm:+15555550000");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.routing?.channel).toBe("sms-macos");
+        (0, external_vitest_namespaceObject.expect)(agentPayload.request.queueIfBusy).toBe(true);
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

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