@wingman-ai/gateway 0.1.0

package/dist/cli/config/loader.cjs

@@ -0,0 +1,143 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    WingmanConfigLoader: ()=>WingmanConfigLoader
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_schema_cjs_namespaceObject = require("./schema.cjs");
+const env_cjs_namespaceObject = require("../../gateway/env.cjs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class WingmanConfigLoader {
+    loadConfig() {
+        const configPath = (0, external_node_path_namespaceObject.join)(this.workspace, this.configDir, "wingman.config.json");
+        if (!(0, external_node_fs_namespaceObject.existsSync)(configPath)) {
+            this.logger.info(`Config file not found at ${configPath}, using default configuration`);
+            return this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+        }
+        try {
+            const content = (0, external_node_fs_namespaceObject.readFileSync)(configPath, "utf-8");
+            const json = JSON.parse(content);
+            const validation = (0, external_schema_cjs_namespaceObject.validateConfig)(json);
+            if (!validation.success || !validation.data) {
+                this.logger.error(`Warning: Invalid wingman.config.json: ${validation.error}`);
+                this.logger.error("Using default configuration");
+                return this.getDefaultConfig();
+            }
+            this.logger.debug(`Loaded configuration from ${configPath} with values: ${JSON.stringify(validation.data)}`);
+            return this.applyGatewayAuthEnvOverrides(validation.data);
+        } catch (error) {
+            if (error instanceof SyntaxError) this.logger.error(`Warning: Invalid JSON in ${configPath}: ${error.message}`);
+            else this.logger.error(`Warning: Failed to load config: ${error}`);
+            this.logger.error("Using default configuration");
+            return this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+        }
+    }
+    applyGatewayAuthEnvOverrides(config) {
+        const token = (0, env_cjs_namespaceObject.getGatewayTokenFromEnv)();
+        if (token && config.gateway?.auth?.mode === "token" && !config.gateway.auth.token) return {
+            ...config,
+            gateway: {
+                ...config.gateway,
+                auth: {
+                    ...config.gateway.auth,
+                    token
+                }
+            }
+        };
+        return config;
+    }
+    getDefaultConfig() {
+        return {
+            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: []
+            }
+        };
+    }
+    constructor(configDir = ".wingman", workspace = process.cwd()){
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "logger", void 0);
+        this.configDir = configDir;
+        this.workspace = workspace;
+        this.logger = (0, external_logger_cjs_namespaceObject.createLogger)();
+    }
+}
+exports.WingmanConfigLoader = __webpack_exports__.WingmanConfigLoader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "WingmanConfigLoader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/config/loader.d.ts

@@ -0,0 +1,14 @@
+import { type WingmanConfigType } from "./schema.js";
+export declare class WingmanConfigLoader {
+    private configDir;
+    private workspace;
+    private logger;
+    constructor(configDir?: string, workspace?: string);
+    /**
+     * Load wingman.config.json from .wingman/ directory
+     * Returns default config if file doesn't exist or is invalid
+     */
+    loadConfig(): WingmanConfigType;
+    private applyGatewayAuthEnvOverrides;
+    private getDefaultConfig;
+}

package/dist/cli/config/loader.js

@@ -0,0 +1,109 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { validateConfig } from "./schema.js";
+import { getGatewayTokenFromEnv } from "../../gateway/env.js";
+import { createLogger } from "../../logger.js";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class WingmanConfigLoader {
+    loadConfig() {
+        const configPath = join(this.workspace, this.configDir, "wingman.config.json");
+        if (!existsSync(configPath)) {
+            this.logger.info(`Config file not found at ${configPath}, using default configuration`);
+            return this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+        }
+        try {
+            const content = readFileSync(configPath, "utf-8");
+            const json = JSON.parse(content);
+            const validation = validateConfig(json);
+            if (!validation.success || !validation.data) {
+                this.logger.error(`Warning: Invalid wingman.config.json: ${validation.error}`);
+                this.logger.error("Using default configuration");
+                return this.getDefaultConfig();
+            }
+            this.logger.debug(`Loaded configuration from ${configPath} with values: ${JSON.stringify(validation.data)}`);
+            return this.applyGatewayAuthEnvOverrides(validation.data);
+        } catch (error) {
+            if (error instanceof SyntaxError) this.logger.error(`Warning: Invalid JSON in ${configPath}: ${error.message}`);
+            else this.logger.error(`Warning: Failed to load config: ${error}`);
+            this.logger.error("Using default configuration");
+            return this.applyGatewayAuthEnvOverrides(this.getDefaultConfig());
+        }
+    }
+    applyGatewayAuthEnvOverrides(config) {
+        const token = getGatewayTokenFromEnv();
+        if (token && config.gateway?.auth?.mode === "token" && !config.gateway.auth.token) return {
+            ...config,
+            gateway: {
+                ...config.gateway,
+                auth: {
+                    ...config.gateway.auth,
+                    token
+                }
+            }
+        };
+        return config;
+    }
+    getDefaultConfig() {
+        return {
+            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: []
+            }
+        };
+    }
+    constructor(configDir = ".wingman", workspace = process.cwd()){
+        _define_property(this, "configDir", void 0);
+        _define_property(this, "workspace", void 0);
+        _define_property(this, "logger", void 0);
+        this.configDir = configDir;
+        this.workspace = workspace;
+        this.logger = createLogger();
+    }
+}
+export { WingmanConfigLoader };

package/dist/cli/config/schema.cjs

@@ -0,0 +1,262 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    SearchConfigSchema: ()=>SearchConfigSchema,
+    SkillsConfigSchema: ()=>SkillsConfigSchema,
+    AgentsConfigSchema: ()=>AgentsConfigSchema,
+    WingmanConfigSchema: ()=>WingmanConfigSchema,
+    validateConfig: ()=>validateConfig,
+    GatewayConfigSchema: ()=>GatewayConfigSchema
+});
+const external_zod_namespaceObject = require("zod");
+const types_cjs_namespaceObject = require("../../agent/middleware/hooks/types.cjs");
+const external_gateway_hooks_types_cjs_namespaceObject = require("../../gateway/hooks/types.cjs");
+const mcp_cjs_namespaceObject = require("../../types/mcp.cjs");
+const voice_cjs_namespaceObject = require("../../types/voice.cjs");
+const SearchConfigSchema = external_zod_namespaceObject.z.object({
+    provider: external_zod_namespaceObject.z["enum"]([
+        "duckduckgo",
+        "perplexity"
+    ]).default("duckduckgo").describe("Search provider to use"),
+    maxResults: external_zod_namespaceObject.z.number().min(1).max(20).optional().default(5).describe("Maximum number of search results to return")
+});
+const SkillsConfigSchema = external_zod_namespaceObject.z.object({
+    repositoryOwner: external_zod_namespaceObject.z.string().default("anthropics").describe("GitHub repository owner for skills"),
+    repositoryName: external_zod_namespaceObject.z.string().default("skills").describe("GitHub repository name for skills"),
+    githubToken: external_zod_namespaceObject.z.string().optional().describe("GitHub personal access token for higher API rate limits"),
+    skillsDirectory: external_zod_namespaceObject.z.string().default("skills").describe("Directory to install skills in")
+});
+const GatewayAuthSchema = external_zod_namespaceObject.z.object({
+    mode: external_zod_namespaceObject.z["enum"]([
+        "token",
+        "password",
+        "none"
+    ]).default("none"),
+    token: external_zod_namespaceObject.z.string().optional(),
+    password: external_zod_namespaceObject.z.string().optional(),
+    allowTailscale: external_zod_namespaceObject.z.boolean().optional().default(false)
+}).default({
+    mode: "none",
+    allowTailscale: false
+});
+const GatewayControlUiSchema = external_zod_namespaceObject.z.object({
+    enabled: external_zod_namespaceObject.z.boolean().default(true),
+    port: external_zod_namespaceObject.z.number().min(1).max(65535).default(18790),
+    pairingRequired: external_zod_namespaceObject.z.boolean().default(true),
+    allowInsecureAuth: external_zod_namespaceObject.z.boolean().default(false)
+}).default({
+    enabled: true,
+    port: 18790,
+    pairingRequired: true,
+    allowInsecureAuth: false
+});
+const DiscordAdapterSchema = external_zod_namespaceObject.z.object({
+    enabled: external_zod_namespaceObject.z.boolean().default(false),
+    token: external_zod_namespaceObject.z.string().optional(),
+    mentionOnly: external_zod_namespaceObject.z.boolean().default(true),
+    allowBots: external_zod_namespaceObject.z.boolean().default(false),
+    allowedGuilds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).default([]),
+    allowedChannels: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).default([]),
+    channelSessions: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.string()).default({}),
+    sessionCommand: external_zod_namespaceObject.z.string().default("!session"),
+    gatewayUrl: external_zod_namespaceObject.z.string().optional(),
+    gatewayToken: external_zod_namespaceObject.z.string().optional(),
+    gatewayPassword: external_zod_namespaceObject.z.string().optional(),
+    responseChunkSize: external_zod_namespaceObject.z.number().min(500).max(2000).default(1900)
+}).default({
+    enabled: false,
+    mentionOnly: true,
+    allowBots: false,
+    allowedGuilds: [],
+    allowedChannels: [],
+    channelSessions: {},
+    sessionCommand: "!session",
+    responseChunkSize: 1900
+});
+const GatewayAdaptersSchema = external_zod_namespaceObject.z.object({
+    discord: DiscordAdapterSchema.optional()
+}).default({});
+const GatewayConfigSchema = external_zod_namespaceObject.z.object({
+    host: external_zod_namespaceObject.z.string().default("127.0.0.1"),
+    port: external_zod_namespaceObject.z.number().min(1).max(65535).default(18789),
+    stateDir: external_zod_namespaceObject.z.string().optional(),
+    fsRoots: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional().default([]),
+    auth: GatewayAuthSchema.optional().default({
+        mode: "none",
+        allowTailscale: false
+    }),
+    controlUi: GatewayControlUiSchema.optional().default({
+        enabled: true,
+        port: 18790,
+        pairingRequired: true,
+        allowInsecureAuth: false
+    }),
+    adapters: GatewayAdaptersSchema.optional().default({})
+}).default({
+    host: "127.0.0.1",
+    port: 18789,
+    fsRoots: [],
+    auth: {
+        mode: "none",
+        allowTailscale: false
+    },
+    controlUi: {
+        enabled: true,
+        port: 18790,
+        pairingRequired: true,
+        allowInsecureAuth: false
+    },
+    adapters: {}
+});
+const AgentListItemSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string().min(1),
+    name: external_zod_namespaceObject.z.string().optional(),
+    default: external_zod_namespaceObject.z.boolean().optional(),
+    workspace: external_zod_namespaceObject.z.string().optional(),
+    agentDir: external_zod_namespaceObject.z.string().optional(),
+    model: external_zod_namespaceObject.z.string().optional()
+});
+const BindingPeerSchema = external_zod_namespaceObject.z.object({
+    kind: external_zod_namespaceObject.z["enum"]([
+        "dm",
+        "group",
+        "channel"
+    ]),
+    id: external_zod_namespaceObject.z.string().min(1)
+});
+const BindingMatchSchema = external_zod_namespaceObject.z.object({
+    channel: external_zod_namespaceObject.z.string().min(1),
+    accountId: external_zod_namespaceObject.z.string().optional(),
+    guildId: external_zod_namespaceObject.z.string().optional(),
+    teamId: external_zod_namespaceObject.z.string().optional(),
+    peer: BindingPeerSchema.optional()
+});
+const BindingSchema = external_zod_namespaceObject.z.object({
+    agentId: external_zod_namespaceObject.z.string().min(1),
+    match: BindingMatchSchema
+});
+const AgentsConfigSchema = external_zod_namespaceObject.z.object({
+    list: external_zod_namespaceObject.z.array(AgentListItemSchema).default([]),
+    bindings: external_zod_namespaceObject.z.array(BindingSchema).default([])
+}).default({
+    list: [],
+    bindings: []
+});
+const WingmanConfigSchema = external_zod_namespaceObject.z.object({
+    logLevel: external_zod_namespaceObject.z["enum"]([
+        "debug",
+        "info",
+        "warn",
+        "error",
+        "silent"
+    ]).optional().default("info"),
+    defaultAgent: external_zod_namespaceObject.z.string().optional(),
+    recursionLimit: external_zod_namespaceObject.z.number().min(1).max(1000000).optional().default(5000),
+    toolHooks: types_cjs_namespaceObject.HooksConfigSchema.optional().describe("Global tool hooks configuration"),
+    hooks: external_gateway_hooks_types_cjs_namespaceObject.InternalHooksConfigSchema.optional().describe("Internal hook configuration"),
+    search: SearchConfigSchema.optional().default({
+        provider: "duckduckgo",
+        maxResults: 5
+    }),
+    voice: voice_cjs_namespaceObject.VoiceConfigSchema.optional().default({
+        provider: "web_speech",
+        defaultPolicy: "off",
+        webSpeech: {},
+        elevenlabs: {}
+    }),
+    cli: external_zod_namespaceObject.z.object({
+        theme: external_zod_namespaceObject.z.string().default("default"),
+        outputMode: external_zod_namespaceObject.z["enum"]([
+            "auto",
+            "interactive",
+            "json"
+        ]).default("auto")
+    }).default({
+        theme: "default",
+        outputMode: "auto"
+    }),
+    skills: SkillsConfigSchema.optional().default({
+        repositoryOwner: "anthropics",
+        repositoryName: "skills",
+        skillsDirectory: "skills"
+    }),
+    gateway: GatewayConfigSchema.optional().default({
+        host: "127.0.0.1",
+        port: 18789,
+        fsRoots: [],
+        auth: {
+            mode: "none",
+            allowTailscale: false
+        },
+        controlUi: {
+            enabled: true,
+            port: 18790,
+            pairingRequired: true,
+            allowInsecureAuth: false
+        },
+        adapters: {}
+    }),
+    agents: AgentsConfigSchema.optional().default({
+        list: [],
+        bindings: []
+    }),
+    mcp: mcp_cjs_namespaceObject.MCPServersConfigSchema.optional().describe("Global MCP server configurations")
+});
+function validateConfig(data) {
+    try {
+        const validated = WingmanConfigSchema.parse(data);
+        return {
+            success: true,
+            data: validated
+        };
+    } catch (error) {
+        if (error instanceof external_zod_namespaceObject.z.ZodError) return {
+            success: false,
+            error: error.issues.map((e)=>`${e.path.join(".")}: ${e.message}`).join(", ")
+        };
+        return {
+            success: false,
+            error: String(error)
+        };
+    }
+}
+exports.AgentsConfigSchema = __webpack_exports__.AgentsConfigSchema;
+exports.GatewayConfigSchema = __webpack_exports__.GatewayConfigSchema;
+exports.SearchConfigSchema = __webpack_exports__.SearchConfigSchema;
+exports.SkillsConfigSchema = __webpack_exports__.SkillsConfigSchema;
+exports.WingmanConfigSchema = __webpack_exports__.WingmanConfigSchema;
+exports.validateConfig = __webpack_exports__.validateConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AgentsConfigSchema",
+    "GatewayConfigSchema",
+    "SearchConfigSchema",
+    "SkillsConfigSchema",
+    "WingmanConfigSchema",
+    "validateConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});