@wingman-ai/gateway 0.1.0

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

@@ -0,0 +1,364 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const loader_cjs_namespaceObject = require("../cli/config/loader.cjs");
+const external_fs_namespaceObject = require("fs");
+const external_path_namespaceObject = require("path");
+const external_os_namespaceObject = require("os");
+(0, external_vitest_namespaceObject.describe)("CLI Config Loader", ()=>{
+    let testDir;
+    let configDir;
+    let originalGatewayToken;
+    (0, external_vitest_namespaceObject.beforeEach)(()=>{
+        originalGatewayToken = process.env.WINGMAN_GATEWAY_TOKEN;
+        delete process.env.WINGMAN_GATEWAY_TOKEN;
+        testDir = (0, external_path_namespaceObject.join)((0, external_os_namespaceObject.tmpdir)(), `wingman-test-${Date.now()}`);
+        configDir = (0, external_path_namespaceObject.join)(testDir, ".wingman");
+        (0, external_fs_namespaceObject.mkdirSync)(configDir, {
+            recursive: true
+        });
+    });
+    (0, external_vitest_namespaceObject.afterEach)(()=>{
+        if ("string" == typeof originalGatewayToken) process.env.WINGMAN_GATEWAY_TOKEN = originalGatewayToken;
+        else delete process.env.WINGMAN_GATEWAY_TOKEN;
+        if ((0, external_fs_namespaceObject.existsSync)(testDir)) (0, external_fs_namespaceObject.rmSync)(testDir, {
+            recursive: true,
+            force: true
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Default config", ()=>{
+        (0, external_vitest_namespaceObject.it)("should return default config when file doesn't exist", ()=>{
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config).toEqual({
+                logLevel: "info",
+                recursionLimit: 5000,
+                search: {
+                    provider: "duckduckgo",
+                    maxResults: 5
+                },
+                voice: {
+                    provider: "web_speech",
+                    defaultPolicy: "off",
+                    webSpeech: {},
+                    elevenlabs: {}
+                },
+                cli: {
+                    theme: "default",
+                    outputMode: "auto"
+                },
+                skills: {
+                    repositoryOwner: "anthropics",
+                    repositoryName: "skills",
+                    skillsDirectory: "skills"
+                },
+                gateway: {
+                    host: "127.0.0.1",
+                    port: 18789,
+                    fsRoots: [],
+                    auth: {
+                        mode: "none",
+                        allowTailscale: false
+                    },
+                    controlUi: {
+                        enabled: true,
+                        port: 18790,
+                        pairingRequired: true,
+                        allowInsecureAuth: false
+                    },
+                    adapters: {}
+                },
+                agents: {
+                    list: [],
+                    bindings: []
+                }
+            });
+        });
+        (0, external_vitest_namespaceObject.it)("should have default log level of info", ()=>{
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe("info");
+        });
+        (0, external_vitest_namespaceObject.it)("should have default recursion limit of 5000", ()=>{
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.recursionLimit).toBe(5000);
+        });
+        (0, external_vitest_namespaceObject.it)("should have default search provider as duckduckgo", ()=>{
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.search?.provider).toBe("duckduckgo");
+        });
+        (0, external_vitest_namespaceObject.it)("should have default CLI output mode as auto", ()=>{
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.cli?.outputMode).toBe("auto");
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Valid configuration", ()=>{
+        (0, external_vitest_namespaceObject.it)("should load valid minimal config", ()=>{
+            const configData = {
+                logLevel: "debug"
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe("debug");
+        });
+        (0, external_vitest_namespaceObject.it)("should load complete config", ()=>{
+            const configData = {
+                logLevel: "debug",
+                defaultAgent: "coder",
+                recursionLimit: 5,
+                search: {
+                    provider: "perplexity",
+                    maxResults: 10
+                },
+                cli: {
+                    theme: "dark",
+                    outputMode: "json"
+                },
+                skills: {
+                    repositoryOwner: "myorg",
+                    repositoryName: "myskills",
+                    skillsDirectory: "custom-skills"
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config).toMatchObject(configData);
+        });
+        (0, external_vitest_namespaceObject.it)("should handle all valid log levels", ()=>{
+            const levels = [
+                "debug",
+                "info",
+                "warn",
+                "error",
+                "silent"
+            ];
+            for (const level of levels){
+                const configData = {
+                    logLevel: level
+                };
+                (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+                const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+                const config = loader.loadConfig();
+                (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe(level);
+            }
+        });
+        (0, external_vitest_namespaceObject.it)("should handle all valid search providers", ()=>{
+            const providers = [
+                "duckduckgo",
+                "perplexity"
+            ];
+            for (const provider of providers){
+                const configData = {
+                    search: {
+                        provider,
+                        maxResults: 5
+                    }
+                };
+                (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+                const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+                const config = loader.loadConfig();
+                (0, external_vitest_namespaceObject.expect)(config.search?.provider).toBe(provider);
+            }
+        });
+        (0, external_vitest_namespaceObject.it)("should handle all valid CLI output modes", ()=>{
+            const modes = [
+                "auto",
+                "interactive",
+                "json"
+            ];
+            for (const mode of modes){
+                const configData = {
+                    cli: {
+                        outputMode: mode,
+                        theme: "default"
+                    }
+                };
+                (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+                const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+                const config = loader.loadConfig();
+                (0, external_vitest_namespaceObject.expect)(config.cli?.outputMode).toBe(mode);
+            }
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Invalid configuration", ()=>{
+        (0, external_vitest_namespaceObject.it)("should return default config for invalid JSON", ()=>{
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), "{ invalid json }");
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe("info");
+        });
+        (0, external_vitest_namespaceObject.it)("should return default config for invalid log level", ()=>{
+            const configData = {
+                logLevel: "invalid"
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe("info");
+        });
+        (0, external_vitest_namespaceObject.it)("should return default config for invalid recursion limit (too low)", ()=>{
+            const configData = {
+                recursionLimit: 0
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.recursionLimit).toBe(5000);
+        });
+        (0, external_vitest_namespaceObject.it)("should return default config for invalid recursion limit (too high)", ()=>{
+            const configData = {
+                recursionLimit: 1000001
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.recursionLimit).toBe(5000);
+        });
+        (0, external_vitest_namespaceObject.it)("should return default config for invalid search provider", ()=>{
+            const configData = {
+                search: {
+                    provider: "invalid",
+                    maxResults: 5
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.search?.provider).toBe("duckduckgo");
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Partial configuration", ()=>{
+        (0, external_vitest_namespaceObject.it)("should merge partial config with defaults", ()=>{
+            const configData = {
+                logLevel: "debug"
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe("debug");
+            (0, external_vitest_namespaceObject.expect)(config.recursionLimit).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(config.search).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should handle partial search config", ()=>{
+            const configData = {
+                search: {
+                    provider: "perplexity"
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.search?.provider).toBe("perplexity");
+            (0, external_vitest_namespaceObject.expect)(config.search?.maxResults).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should handle partial CLI config", ()=>{
+            const configData = {
+                cli: {
+                    outputMode: "json"
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.cli?.outputMode).toBe("json");
+            (0, external_vitest_namespaceObject.expect)(config.cli?.theme).toBeDefined();
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Custom config directory", ()=>{
+        (0, external_vitest_namespaceObject.it)("should support custom config directory name", ()=>{
+            const customDir = (0, external_path_namespaceObject.join)(testDir, ".custom-config");
+            (0, external_fs_namespaceObject.mkdirSync)(customDir, {
+                recursive: true
+            });
+            const configData = {
+                logLevel: "debug"
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(customDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".custom-config", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe("debug");
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Edge cases", ()=>{
+        (0, external_vitest_namespaceObject.it)("should handle empty JSON object", ()=>{
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), "{}");
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config).toBeDefined();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBeDefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should handle config file with extra fields", ()=>{
+            const configData = {
+                logLevel: "debug",
+                extraField: "should be ignored",
+                nested: {
+                    extra: "fields"
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe("debug");
+        });
+        (0, external_vitest_namespaceObject.it)("should handle empty file", ()=>{
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), "");
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.logLevel).toBe("info");
+        });
+    });
+    (0, external_vitest_namespaceObject.describe)("Environment overrides", ()=>{
+        (0, external_vitest_namespaceObject.it)("should apply WINGMAN_GATEWAY_TOKEN when auth mode is token", ()=>{
+            process.env.WINGMAN_GATEWAY_TOKEN = "env-token";
+            const configData = {
+                gateway: {
+                    auth: {
+                        mode: "token"
+                    }
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.gateway.auth.token).toBe("env-token");
+        });
+        (0, external_vitest_namespaceObject.it)("should not override token when auth mode is none", ()=>{
+            process.env.WINGMAN_GATEWAY_TOKEN = "env-token";
+            const configData = {
+                gateway: {
+                    auth: {
+                        mode: "none"
+                    }
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.gateway.auth.token).toBeUndefined();
+        });
+        (0, external_vitest_namespaceObject.it)("should prefer config token over environment token", ()=>{
+            process.env.WINGMAN_GATEWAY_TOKEN = "env-token";
+            const configData = {
+                gateway: {
+                    auth: {
+                        mode: "token",
+                        token: "config-token"
+                    }
+                }
+            };
+            (0, external_fs_namespaceObject.writeFileSync)((0, external_path_namespaceObject.join)(configDir, "wingman.config.json"), JSON.stringify(configData));
+            const loader = new loader_cjs_namespaceObject.WingmanConfigLoader(".wingman", testDir);
+            const config = loader.loadConfig();
+            (0, external_vitest_namespaceObject.expect)(config.gateway.auth.token).toBe("config-token");
+        });
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/tests/cli-config-loader.test.d.ts

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