@wingman-ai/gateway 0.1.0

package/dist/gateway/validation.js

@@ -0,0 +1,158 @@
+import { z } from "zod";
+const MessageTypeSchema = z["enum"]([
+    "connect",
+    "res",
+    "req:agent",
+    "event:agent",
+    "session_subscribe",
+    "session_unsubscribe",
+    "register",
+    "registered",
+    "unregister",
+    "join_group",
+    "leave_group",
+    "broadcast",
+    "direct",
+    "ping",
+    "pong",
+    "error",
+    "ack"
+]);
+const GatewayMessageSchema = z.object({
+    type: MessageTypeSchema,
+    id: z.string().optional(),
+    client: z.object({
+        instanceId: z.string().min(1),
+        clientType: z.string().min(1),
+        version: z.string().optional()
+    }).optional(),
+    auth: z.object({
+        token: z.string().optional(),
+        password: z.string().optional(),
+        deviceId: z.string().optional()
+    }).optional(),
+    ok: z.boolean().optional(),
+    clientId: z.string().optional(),
+    nodeId: z.string().optional(),
+    groupId: z.string().optional(),
+    roomId: z.string().optional(),
+    targetNodeId: z.string().optional(),
+    payload: z.unknown().optional(),
+    timestamp: z.number(),
+    messageId: z.string().optional()
+});
+const RegisterPayloadSchema = z.object({
+    name: z.string().min(1).max(100),
+    capabilities: z.array(z.string()).optional(),
+    token: z.string().optional()
+});
+const JoinGroupPayloadSchema = z.object({
+    groupId: z.string().optional(),
+    groupName: z.string().min(1).max(100).optional(),
+    createIfNotExists: z.boolean().optional(),
+    description: z.string().max(500).optional()
+});
+const BroadcastPayloadSchema = z.object({
+    groupId: z.string().min(1),
+    message: z.unknown()
+});
+const DirectPayloadSchema = z.object({
+    targetNodeId: z.string().min(1),
+    message: z.unknown()
+});
+const ErrorPayloadSchema = z.object({
+    code: z.string().min(1),
+    message: z.string().min(1),
+    details: z.unknown().optional()
+});
+function validateGatewayMessage(data) {
+    try {
+        const result = GatewayMessageSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid message format: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+function validateRegisterPayload(data) {
+    try {
+        const result = RegisterPayloadSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid register payload: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+function validateJoinGroupPayload(data) {
+    try {
+        const result = JoinGroupPayloadSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid join group payload: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+function validateBroadcastPayload(data) {
+    try {
+        const result = BroadcastPayloadSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid broadcast payload: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+function validateDirectPayload(data) {
+    try {
+        const result = DirectPayloadSchema.safeParse(data);
+        if (!result.success) return {
+            success: false,
+            error: `Invalid direct payload: ${result.error.message}`
+        };
+        return {
+            success: true,
+            data: result.data
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown validation error"
+        };
+    }
+}
+export { BroadcastPayloadSchema, DirectPayloadSchema, ErrorPayloadSchema, GatewayMessageSchema, JoinGroupPayloadSchema, MessageTypeSchema, RegisterPayloadSchema, validateBroadcastPayload, validateDirectPayload, validateGatewayMessage, validateJoinGroupPayload, validateRegisterPayload };

package/dist/index.cjs

@@ -0,0 +1,95 @@
+"use strict";
+var __webpack_modules__ = {
+    "./agent/config/agentLoader.js" (module) {
+        module.exports = require("./agent/config/agentLoader.cjs");
+    },
+    "./cli/config/loader.js" (module) {
+        module.exports = require("./cli/config/loader.cjs");
+    },
+    "./cli/core/agentInvoker.js" (module) {
+        module.exports = require("./cli/core/agentInvoker.cjs");
+    },
+    "./cli/core/outputManager.js" (module) {
+        module.exports = require("./cli/core/outputManager.cjs");
+    },
+    "./logger.js" (module) {
+        module.exports = require("./logger.cjs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+        AgentConfigLoader: ()=>_agent_config_agentLoader_js__rspack_import_1.AgentLoader,
+        AgentInvoker: ()=>_cli_core_agentInvoker_js__rspack_import_3.AgentInvoker,
+        OutputManager: ()=>_cli_core_outputManager_js__rspack_import_2.OutputManager,
+        WingmanConfigLoader: ()=>_cli_config_loader_js__rspack_import_4.WingmanConfigLoader
+    });
+    var _logger_js__rspack_import_0 = __webpack_require__("./logger.js");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _logger_js__rspack_import_0)if ([
+        "OutputManager",
+        "default",
+        "AgentInvoker",
+        "WingmanConfigLoader",
+        "AgentConfigLoader"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_logger_js__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _agent_config_agentLoader_js__rspack_import_1 = __webpack_require__("./agent/config/agentLoader.js");
+    var _cli_core_outputManager_js__rspack_import_2 = __webpack_require__("./cli/core/outputManager.js");
+    var _cli_core_agentInvoker_js__rspack_import_3 = __webpack_require__("./cli/core/agentInvoker.js");
+    var _cli_config_loader_js__rspack_import_4 = __webpack_require__("./cli/config/loader.js");
+})();
+exports.AgentConfigLoader = __webpack_exports__.AgentConfigLoader;
+exports.AgentInvoker = __webpack_exports__.AgentInvoker;
+exports.OutputManager = __webpack_exports__.OutputManager;
+exports.WingmanConfigLoader = __webpack_exports__.WingmanConfigLoader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "AgentConfigLoader",
+    "AgentInvoker",
+    "OutputManager",
+    "WingmanConfigLoader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./logger.js";
+export { AgentLoader as AgentConfigLoader } from "./agent/config/agentLoader.js";
+export { OutputManager } from "./cli/core/outputManager.js";
+export { AgentInvoker } from "./cli/core/agentInvoker.js";
+export { WingmanConfigLoader } from "./cli/config/loader.js";
+export type * from "./cli/types.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+import { AgentLoader } from "./agent/config/agentLoader.js";
+import { OutputManager } from "./cli/core/outputManager.js";
+import { AgentInvoker } from "./cli/core/agentInvoker.js";
+import { WingmanConfigLoader } from "./cli/config/loader.js";
+export * from "./logger.js";
+export { AgentLoader as AgentConfigLoader, AgentInvoker, OutputManager, WingmanConfigLoader };

package/dist/logger.cjs

@@ -0,0 +1,270 @@
+"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__, {
+    EventLogger: ()=>EventLogger,
+    writeToLogFile: ()=>writeToLogFile,
+    createEventLogger: ()=>createEventLogger,
+    createLogger: ()=>createLogger,
+    WingmanLogger: ()=>WingmanLogger,
+    createLoggerFromConfig: ()=>createLoggerFromConfig,
+    getLogFilePath: ()=>getLogFilePath,
+    SilentLogger: ()=>SilentLogger
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_node_os_namespaceObject = require("node:os");
+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;
+}
+const DEFAULT_LOG_FILE_NAME = "wingman.log";
+const DEFAULT_LOG_DIR = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.homedir)(), ".wingman", "logs");
+const DEFAULT_MAX_BYTES = parsePositiveInt(process.env.WINGMAN_LOG_MAX_BYTES, 5242880);
+const DEFAULT_MAX_FILES = parsePositiveInt(process.env.WINGMAN_LOG_MAX_FILES, 5);
+function serializeLogArg(arg) {
+    const isError = "function" == typeof Error.isError ? Error.isError(arg) : arg instanceof Error;
+    if (isError) return {
+        name: arg.name,
+        message: arg.message,
+        stack: arg.stack
+    };
+    return arg;
+}
+function parsePositiveInt(value, fallback) {
+    if (!value) return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function resolveDefaultLogFileName() {
+    const isoDate = new Date().toISOString().slice(0, 10);
+    return `wingman-${isoDate}.log`;
+}
+function resolveLogFilePath() {
+    const explicitFile = process.env.WINGMAN_LOG_FILE;
+    if (explicitFile && explicitFile.trim().length > 0) return explicitFile;
+    const logDir = process.env.WINGMAN_LOG_DIR?.trim() || DEFAULT_LOG_DIR;
+    return (0, external_node_path_namespaceObject.join)(logDir, resolveDefaultLogFileName() || DEFAULT_LOG_FILE_NAME);
+}
+function getLogFilePath() {
+    return resolveLogFilePath();
+}
+function writeToLogFile(chunk) {
+    const text = "string" == typeof chunk ? chunk : chunk.toString("utf-8");
+    getSharedFileWriter().write(text);
+}
+class RollingFileWriter {
+    write(chunk) {
+        try {
+            this.ensureInitialized();
+            const bytes = Buffer.byteLength(chunk);
+            if (this.currentSize + bytes > this.maxBytes) {
+                this.rotate();
+                this.currentSize = 0;
+            }
+            (0, external_node_fs_namespaceObject.appendFileSync)(this.filePath, chunk);
+            this.currentSize += bytes;
+        } catch  {}
+    }
+    ensureInitialized() {
+        if (this.initialized) return;
+        this.initialized = true;
+        (0, external_node_fs_namespaceObject.mkdirSync)((0, external_node_path_namespaceObject.dirname)(this.filePath), {
+            recursive: true
+        });
+        if ((0, external_node_fs_namespaceObject.existsSync)(this.filePath)) this.currentSize = (0, external_node_fs_namespaceObject.statSync)(this.filePath).size;
+    }
+    rotate() {
+        try {
+            const oldest = `${this.filePath}.${this.maxFiles}`;
+            if ((0, external_node_fs_namespaceObject.existsSync)(oldest)) (0, external_node_fs_namespaceObject.unlinkSync)(oldest);
+            for(let i = this.maxFiles - 1; i >= 1; i--){
+                const source = `${this.filePath}.${i}`;
+                if ((0, external_node_fs_namespaceObject.existsSync)(source)) (0, external_node_fs_namespaceObject.renameSync)(source, `${this.filePath}.${i + 1}`);
+            }
+            if ((0, external_node_fs_namespaceObject.existsSync)(this.filePath)) (0, external_node_fs_namespaceObject.renameSync)(this.filePath, `${this.filePath}.1`);
+        } catch  {}
+    }
+    constructor(filePath, maxBytes, maxFiles){
+        _define_property(this, "currentSize", 0);
+        _define_property(this, "initialized", false);
+        _define_property(this, "filePath", void 0);
+        _define_property(this, "maxBytes", void 0);
+        _define_property(this, "maxFiles", void 0);
+        this.filePath = filePath;
+        this.maxBytes = Math.max(1, maxBytes);
+        this.maxFiles = Math.max(1, maxFiles);
+    }
+}
+let sharedFileWriter = null;
+function getSharedFileWriter() {
+    if (!sharedFileWriter) sharedFileWriter = new RollingFileWriter(resolveLogFilePath(), DEFAULT_MAX_BYTES, DEFAULT_MAX_FILES);
+    return sharedFileWriter;
+}
+class WingmanLogger {
+    shouldLog(level) {
+        const levels = [
+            "debug",
+            "info",
+            "warn",
+            "error",
+            "silent"
+        ];
+        const currentIndex = levels.indexOf(this.level);
+        const messageIndex = levels.indexOf(level);
+        return "silent" !== this.level && messageIndex >= currentIndex;
+    }
+    log(level, message, ...args) {
+        if (!this.shouldLog(level)) return;
+        const timestamp = new Date().toISOString();
+        const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+        this.output.write(`${prefix} ${message}\n`);
+        if (args.length > 0) {
+            const serialized = args.map((arg)=>serializeLogArg(arg));
+            this.output.write(`${JSON.stringify(serialized, null, 2)}\n`);
+        }
+    }
+    debug(message, ...args) {
+        this.log("debug", message, ...args);
+    }
+    info(message, ...args) {
+        this.log("info", message, ...args);
+    }
+    warn(message, ...args) {
+        this.log("warn", message, ...args);
+    }
+    error(message, ...args) {
+        this.log("error", message, ...args);
+    }
+    constructor(level = "info", output = getSharedFileWriter()){
+        _define_property(this, "level", void 0);
+        _define_property(this, "output", void 0);
+        this.level = level;
+        this.output = output;
+    }
+}
+class SilentLogger {
+    debug() {}
+    info() {}
+    warn() {}
+    error() {}
+}
+function createLogger(level = process.env.WINGMAN_LOG_LEVEL || "info") {
+    if ("silent" === level) return new SilentLogger();
+    return new WingmanLogger(level);
+}
+function createLoggerFromConfig(config) {
+    return createLogger(config.level);
+}
+class EventLogger {
+    shouldLog(level) {
+        const levels = [
+            "debug",
+            "info",
+            "warn",
+            "error",
+            "silent"
+        ];
+        const currentIndex = levels.indexOf(this.level);
+        const messageIndex = levels.indexOf(level);
+        return "silent" !== this.level && messageIndex >= currentIndex;
+    }
+    log(level, message, ...args) {
+        if (!this.shouldLog(level)) return;
+        this.callback({
+            level,
+            message,
+            timestamp: new Date().toISOString(),
+            args: args.length > 0 ? args : void 0
+        });
+        if (!this.secondaryLogger) return;
+        switch(level){
+            case "debug":
+                this.secondaryLogger.debug(message, ...args);
+                break;
+            case "info":
+                this.secondaryLogger.info(message, ...args);
+                break;
+            case "warn":
+                this.secondaryLogger.warn(message, ...args);
+                break;
+            case "error":
+                this.secondaryLogger.error(message, ...args);
+                break;
+            case "silent":
+                break;
+        }
+    }
+    debug(message, ...args) {
+        this.log("debug", message, ...args);
+    }
+    info(message, ...args) {
+        this.log("info", message, ...args);
+    }
+    warn(message, ...args) {
+        this.log("warn", message, ...args);
+    }
+    error(message, ...args) {
+        this.log("error", message, ...args);
+    }
+    constructor(callback, level = "info", secondaryLogger){
+        _define_property(this, "callback", void 0);
+        _define_property(this, "level", void 0);
+        _define_property(this, "secondaryLogger", void 0);
+        this.callback = callback;
+        this.level = level;
+        this.secondaryLogger = secondaryLogger;
+    }
+}
+function createEventLogger(callback, level = "info") {
+    return new EventLogger(callback, level, createLogger(level));
+}
+exports.EventLogger = __webpack_exports__.EventLogger;
+exports.SilentLogger = __webpack_exports__.SilentLogger;
+exports.WingmanLogger = __webpack_exports__.WingmanLogger;
+exports.createEventLogger = __webpack_exports__.createEventLogger;
+exports.createLogger = __webpack_exports__.createLogger;
+exports.createLoggerFromConfig = __webpack_exports__.createLoggerFromConfig;
+exports.getLogFilePath = __webpack_exports__.getLogFilePath;
+exports.writeToLogFile = __webpack_exports__.writeToLogFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EventLogger",
+    "SilentLogger",
+    "WingmanLogger",
+    "createEventLogger",
+    "createLogger",
+    "createLoggerFromConfig",
+    "getLogFilePath",
+    "writeToLogFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/logger.d.ts

@@ -0,0 +1,54 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+interface LogWriter {
+    write(chunk: string): void;
+}
+export declare function getLogFilePath(): string;
+export declare function writeToLogFile(chunk: string | Buffer): void;
+export interface Logger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+export declare class WingmanLogger implements Logger {
+    private level;
+    private output;
+    constructor(level?: LogLevel, output?: LogWriter);
+    private shouldLog;
+    private log;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+export declare class SilentLogger implements Logger {
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+}
+export declare function createLogger(level?: LogLevel): Logger;
+export interface SerializableLoggerConfig {
+    level: LogLevel;
+}
+export declare function createLoggerFromConfig(config: SerializableLoggerConfig): Logger;
+export type LogEventCallback = (event: {
+    level: LogLevel;
+    message: string;
+    timestamp: string;
+    args?: any[];
+}) => void;
+export declare class EventLogger implements Logger {
+    private callback;
+    private level;
+    private secondaryLogger?;
+    constructor(callback: LogEventCallback, level?: LogLevel, secondaryLogger?: Logger | undefined);
+    private shouldLog;
+    private log;
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+}
+export declare function createEventLogger(callback: LogEventCallback, level?: LogLevel): Logger;
+export {};