@wingman-ai/gateway 0.4.0 → 0.4.2

package/dist/skills/overlay.js

@@ -0,0 +1,38 @@
+import { cp, mkdtemp, rm, symlink } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+const uniqueSkillNames = (skills)=>{
+    const seen = new Set();
+    const unique = [];
+    for (const skill of skills){
+        const normalized = skill.trim();
+        if (!(!normalized || seen.has(normalized))) {
+            seen.add(normalized);
+            unique.push(normalized);
+        }
+    }
+    return unique;
+};
+const createSkillOverlayDirectory = async (skillsRoot, activeSkillNames)=>{
+    const overlayRoot = await mkdtemp(join(tmpdir(), "wingman-skill-overlay-"));
+    for (const skillName of uniqueSkillNames(activeSkillNames)){
+        const source = join(skillsRoot, skillName);
+        const destination = join(overlayRoot, skillName);
+        try {
+            await symlink(source, destination, "win32" === process.platform ? "junction" : "dir");
+        } catch  {
+            await cp(source, destination, {
+                recursive: true,
+                force: true
+            });
+        }
+    }
+    return overlayRoot;
+};
+const removeSkillOverlayDirectory = async (overlayPath)=>{
+    await rm(overlayPath, {
+        recursive: true,
+        force: true
+    });
+};
+export { createSkillOverlayDirectory, removeSkillOverlayDirectory };

package/dist/tests/additionalMessageMiddleware.test.cjs

@@ -117,6 +117,98 @@ const additional_messages_cjs_namespaceObject = require("../agent/middleware/add
         }).length;
         (0, external_vitest_namespaceObject.expect)(injectedCount).toBe(1);
     });
+    (0, external_vitest_namespaceObject.it)("refreshes injected node context on each invocation", async ()=>{
+        let connectedIds = [
+            "node-a"
+        ];
+        const middleware = (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)({
+            nodeConnectedIdsProvider: ()=>connectedIds
+        });
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const first = await beforeAgent({
+            messages: [
+                new external_langchain_namespaceObject.HumanMessage("Hello")
+            ]
+        }, {});
+        const firstContent = first.messages[0]?.content ?? "";
+        (0, external_vitest_namespaceObject.expect)(firstContent).toContain("Connected node IDs: node-a");
+        connectedIds = [
+            "node-b"
+        ];
+        const second = await beforeAgent({
+            messages: first.messages
+        }, {});
+        const secondContent = second.messages[0]?.content ?? "";
+        (0, external_vitest_namespaceObject.expect)(secondContent).toContain("Connected node IDs: node-b");
+        (0, external_vitest_namespaceObject.expect)(secondContent).not.toContain("Connected node IDs: node-a");
+    });
+    (0, external_vitest_namespaceObject.it)("injects connected node IDs for node tool targeting when provided", async ()=>{
+        const middleware = (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)({
+            nodeConnectedIdsProvider: ()=>[
+                    "node-b",
+                    "node-a",
+                    "",
+                    "node-b"
+                ]
+        });
+        const input = {
+            messages: [
+                new external_langchain_namespaceObject.HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        const content = result.messages[0]?.content ?? "";
+        (0, external_vitest_namespaceObject.expect)(content).toContain("Connected Node Targets");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("Connected node IDs: node-b, node-a");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("target.nodeId or target.clientId");
+    });
+    (0, external_vitest_namespaceObject.it)("injects default node target clientId when present", async ()=>{
+        const middleware = (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)({
+            nodeConnectedIdsProvider: ()=>[],
+            defaultNodeTargetClientId: "desktop-abc123"
+        });
+        const input = {
+            messages: [
+                new external_langchain_namespaceObject.HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        const content = result.messages[0]?.content ?? "";
+        (0, external_vitest_namespaceObject.expect)(content).toContain("Connected node IDs: (none currently connected)");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("Default node target clientId for this request: desktop-abc123");
+    });
+    (0, external_vitest_namespaceObject.it)("injects connected node metadata when provided", async ()=>{
+        const middleware = (0, additional_messages_cjs_namespaceObject.additionalMessageMiddleware)({
+            nodeConnectedTargetsProvider: ()=>[
+                    {
+                        nodeId: "node-a",
+                        clientId: "desktop-a",
+                        name: "Russell MacBook",
+                        capabilities: [
+                            "system.notify",
+                            "system.run"
+                        ]
+                    }
+                ]
+        });
+        const input = {
+            messages: [
+                new external_langchain_namespaceObject.HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        const content = result.messages[0]?.content ?? "";
+        (0, external_vitest_namespaceObject.expect)(content).toContain("Connected node metadata:");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("node-a (clientId: desktop-a; name: Russell MacBook;");
+        (0, external_vitest_namespaceObject.expect)(content).toContain("capabilities: system.notify, system.run");
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/additionalMessageMiddleware.test.js

@@ -93,4 +93,96 @@ describe("additionalMessageMiddleware", ()=>{
         }).length;
         expect(injectedCount).toBe(1);
     });
+    it("refreshes injected node context on each invocation", async ()=>{
+        let connectedIds = [
+            "node-a"
+        ];
+        const middleware = additionalMessageMiddleware({
+            nodeConnectedIdsProvider: ()=>connectedIds
+        });
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const first = await beforeAgent({
+            messages: [
+                new HumanMessage("Hello")
+            ]
+        }, {});
+        const firstContent = first.messages[0]?.content ?? "";
+        expect(firstContent).toContain("Connected node IDs: node-a");
+        connectedIds = [
+            "node-b"
+        ];
+        const second = await beforeAgent({
+            messages: first.messages
+        }, {});
+        const secondContent = second.messages[0]?.content ?? "";
+        expect(secondContent).toContain("Connected node IDs: node-b");
+        expect(secondContent).not.toContain("Connected node IDs: node-a");
+    });
+    it("injects connected node IDs for node tool targeting when provided", async ()=>{
+        const middleware = additionalMessageMiddleware({
+            nodeConnectedIdsProvider: ()=>[
+                    "node-b",
+                    "node-a",
+                    "",
+                    "node-b"
+                ]
+        });
+        const input = {
+            messages: [
+                new HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        const content = result.messages[0]?.content ?? "";
+        expect(content).toContain("Connected Node Targets");
+        expect(content).toContain("Connected node IDs: node-b, node-a");
+        expect(content).toContain("target.nodeId or target.clientId");
+    });
+    it("injects default node target clientId when present", async ()=>{
+        const middleware = additionalMessageMiddleware({
+            nodeConnectedIdsProvider: ()=>[],
+            defaultNodeTargetClientId: "desktop-abc123"
+        });
+        const input = {
+            messages: [
+                new HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        const content = result.messages[0]?.content ?? "";
+        expect(content).toContain("Connected node IDs: (none currently connected)");
+        expect(content).toContain("Default node target clientId for this request: desktop-abc123");
+    });
+    it("injects connected node metadata when provided", async ()=>{
+        const middleware = additionalMessageMiddleware({
+            nodeConnectedTargetsProvider: ()=>[
+                    {
+                        nodeId: "node-a",
+                        clientId: "desktop-a",
+                        name: "Russell MacBook",
+                        capabilities: [
+                            "system.notify",
+                            "system.run"
+                        ]
+                    }
+                ]
+        });
+        const input = {
+            messages: [
+                new HumanMessage("Hello")
+            ]
+        };
+        const beforeAgent = "function" == typeof middleware.beforeAgent ? middleware.beforeAgent : middleware.beforeAgent?.hook;
+        if (!beforeAgent) throw new Error("beforeAgent hook not configured");
+        const result = await beforeAgent(input, {});
+        const content = result.messages[0]?.content ?? "";
+        expect(content).toContain("Connected node metadata:");
+        expect(content).toContain("node-a (clientId: desktop-a; name: Russell MacBook;");
+        expect(content).toContain("capabilities: system.notify, system.run");
+    });
 });

package/dist/tests/cli-config-loader.test.cjs

@@ -75,9 +75,13 @@ const external_os_namespaceObject = require("os");
                     outputMode: "auto"
                 },
                 skills: {
-                    provider: "github",
-                    repositoryOwner: "anthropics",
-                    repositoryName: "skills",
+                    provider: "hybrid",
+                    repositories: [
+                        {
+                            owner: "RussellCanfield",
+                            name: "wingman-ai"
+                        }
+                    ],
                     clawhubBaseUrl: "https://clawhub.ai",
                     skillsDirectory: "skills",
                     security: {

package/dist/tests/cli-config-loader.test.js

@@ -73,9 +73,13 @@ describe("CLI Config Loader", ()=>{
                     outputMode: "auto"
                 },
                 skills: {
-                    provider: "github",
-                    repositoryOwner: "anthropics",
-                    repositoryName: "skills",
+                    provider: "hybrid",
+                    repositories: [
+                        {
+                            owner: "RussellCanfield",
+                            name: "wingman-ai"
+                        }
+                    ],
                     clawhubBaseUrl: "https://clawhub.ai",
                     skillsDirectory: "skills",
                     security: {

package/dist/tests/cli-init.test.cjs

@@ -35,6 +35,12 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
         const config = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8"));
         (0, external_vitest_namespaceObject.expect)(config.defaultAgent).toBe("wingman");
         (0, external_vitest_namespaceObject.expect)(config.gateway.fsRoots).toContain(".");
+        (0, external_vitest_namespaceObject.expect)(config.browser?.defaultProfile).toBe("default");
+        (0, external_vitest_namespaceObject.expect)(config.browser?.profiles?.default).toBe(".wingman/browser-profiles/default");
+        (0, external_vitest_namespaceObject.expect)(config.browser?.extensions?.wingman).toBe(".wingman/browser-extensions/wingman");
+        (0, external_vitest_namespaceObject.expect)(config.browser?.defaultExtensions).toContain("wingman");
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)((0, external_node_path_namespaceObject.join)(workspace, ".wingman", "browser-profiles", "default"))).toBe(true);
+        (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)((0, external_node_path_namespaceObject.join)(workspace, ".wingman", "browser-extensions", "wingman", "manifest.json"))).toBe(true);
         const agentPath = (0, external_node_path_namespaceObject.join)(workspace, ".wingman", "agents", "wingman", "agent.json");
         (0, external_vitest_namespaceObject.expect)((0, external_node_fs_namespaceObject.existsSync)(agentPath)).toBe(true);
         const agent = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(agentPath, "utf-8"));
@@ -135,6 +141,54 @@ const init_cjs_namespaceObject = require("../cli/commands/init.cjs");
             "./existing",
             "."
         ]));
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.defaultProfile).toBe("default");
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.profiles?.default).toBe(".wingman/browser-profiles/default");
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.extensions?.wingman).toBe(".wingman/browser-extensions/wingman");
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.defaultExtensions).toContain("wingman");
+    });
+    (0, external_vitest_namespaceObject.it)("merges config without overriding existing browser profile defaults", async ()=>{
+        const configDir = (0, external_node_path_namespaceObject.join)(workspace, ".wingman");
+        const configPath = (0, external_node_path_namespaceObject.join)(configDir, "wingman.config.json");
+        (0, external_node_fs_namespaceObject.mkdirSync)(configDir, {
+            recursive: true
+        });
+        (0, external_node_fs_namespaceObject.writeFileSync)(configPath, JSON.stringify({
+            defaultAgent: "wingman",
+            browser: {
+                defaultProfile: "trading",
+                profiles: {
+                    trading: ".wingman/browser-profiles/trading"
+                },
+                extensions: {
+                    relay: ".wingman/browser-extensions/relay"
+                },
+                defaultExtensions: [
+                    "relay"
+                ]
+            }
+        }, null, 2));
+        await (0, init_cjs_namespaceObject.executeInitCommand)({
+            subcommand: "",
+            args: [],
+            verbosity: "silent",
+            outputMode: "json",
+            options: {
+                merge: true,
+                only: "config"
+            },
+            agent: "wingman"
+        }, {
+            workspace
+        });
+        const updated = JSON.parse((0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8"));
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.defaultProfile).toBe("trading");
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.profiles?.trading).toBe(".wingman/browser-profiles/trading");
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.defaultExtensions).toEqual(external_vitest_namespaceObject.expect.arrayContaining([
+            "relay",
+            "wingman"
+        ]));
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.extensions?.relay).toBe(".wingman/browser-extensions/relay");
+        (0, external_vitest_namespaceObject.expect)(updated.browser?.extensions?.wingman).toBe(".wingman/browser-extensions/wingman");
     });
     (0, external_vitest_namespaceObject.it)("sync mode copies bundled agents without creating config", async ()=>{
         await (0, init_cjs_namespaceObject.executeInitCommand)({

package/dist/tests/cli-init.test.js

@@ -33,6 +33,12 @@ describe("CLI init", ()=>{
         const config = JSON.parse(readFileSync(configPath, "utf-8"));
         expect(config.defaultAgent).toBe("wingman");
         expect(config.gateway.fsRoots).toContain(".");
+        expect(config.browser?.defaultProfile).toBe("default");
+        expect(config.browser?.profiles?.default).toBe(".wingman/browser-profiles/default");
+        expect(config.browser?.extensions?.wingman).toBe(".wingman/browser-extensions/wingman");
+        expect(config.browser?.defaultExtensions).toContain("wingman");
+        expect(existsSync(join(workspace, ".wingman", "browser-profiles", "default"))).toBe(true);
+        expect(existsSync(join(workspace, ".wingman", "browser-extensions", "wingman", "manifest.json"))).toBe(true);
         const agentPath = join(workspace, ".wingman", "agents", "wingman", "agent.json");
         expect(existsSync(agentPath)).toBe(true);
         const agent = JSON.parse(readFileSync(agentPath, "utf-8"));
@@ -133,6 +139,54 @@ describe("CLI init", ()=>{
             "./existing",
             "."
         ]));
+        expect(updated.browser?.defaultProfile).toBe("default");
+        expect(updated.browser?.profiles?.default).toBe(".wingman/browser-profiles/default");
+        expect(updated.browser?.extensions?.wingman).toBe(".wingman/browser-extensions/wingman");
+        expect(updated.browser?.defaultExtensions).toContain("wingman");
+    });
+    it("merges config without overriding existing browser profile defaults", async ()=>{
+        const configDir = join(workspace, ".wingman");
+        const configPath = join(configDir, "wingman.config.json");
+        mkdirSync(configDir, {
+            recursive: true
+        });
+        writeFileSync(configPath, JSON.stringify({
+            defaultAgent: "wingman",
+            browser: {
+                defaultProfile: "trading",
+                profiles: {
+                    trading: ".wingman/browser-profiles/trading"
+                },
+                extensions: {
+                    relay: ".wingman/browser-extensions/relay"
+                },
+                defaultExtensions: [
+                    "relay"
+                ]
+            }
+        }, null, 2));
+        await executeInitCommand({
+            subcommand: "",
+            args: [],
+            verbosity: "silent",
+            outputMode: "json",
+            options: {
+                merge: true,
+                only: "config"
+            },
+            agent: "wingman"
+        }, {
+            workspace
+        });
+        const updated = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(updated.browser?.defaultProfile).toBe("trading");
+        expect(updated.browser?.profiles?.trading).toBe(".wingman/browser-profiles/trading");
+        expect(updated.browser?.defaultExtensions).toEqual(expect.arrayContaining([
+            "relay",
+            "wingman"
+        ]));
+        expect(updated.browser?.extensions?.relay).toBe(".wingman/browser-extensions/relay");
+        expect(updated.browser?.extensions?.wingman).toBe(".wingman/browser-extensions/wingman");
     });
     it("sync mode copies bundled agents without creating config", async ()=>{
         await executeInitCommand({

package/dist/tests/config-json-schema.test.cjs

@@ -18,6 +18,18 @@ const jsonSchema_cjs_namespaceObject = require("../cli/config/jsonSchema.cjs");
         const scannerArgsDefault = schema.properties.skills.properties.security.properties.scannerArgs.default;
         (0, external_vitest_namespaceObject.expect)(scannerArgsDefault).toContain("mcp-scan>=0.4,<0.5");
     });
+    (0, external_vitest_namespaceObject.it)("exposes hybrid defaults for skill sources", ()=>{
+        const schema = (0, jsonSchema_cjs_namespaceObject.buildWingmanConfigJsonSchema)();
+        const repositoriesDefault = schema.properties.skills.properties.repositories.default;
+        const providerDefault = schema.properties.skills.properties.provider.default;
+        (0, external_vitest_namespaceObject.expect)(providerDefault).toBe("hybrid");
+        (0, external_vitest_namespaceObject.expect)(repositoriesDefault).toEqual([
+            {
+                owner: "RussellCanfield",
+                name: "wingman-ai"
+            }
+        ]);
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/tests/config-json-schema.test.js

@@ -16,4 +16,16 @@ describe("wingman config json schema", ()=>{
         const scannerArgsDefault = schema.properties.skills.properties.security.properties.scannerArgs.default;
         expect(scannerArgsDefault).toContain("mcp-scan>=0.4,<0.5");
     });
+    it("exposes hybrid defaults for skill sources", ()=>{
+        const schema = buildWingmanConfigJsonSchema();
+        const repositoriesDefault = schema.properties.skills.properties.repositories.default;
+        const providerDefault = schema.properties.skills.properties.provider.default;
+        expect(providerDefault).toBe("hybrid");
+        expect(repositoriesDefault).toEqual([
+            {
+                owner: "RussellCanfield",
+                name: "wingman-ai"
+            }
+        ]);
+    });
 });