easy-mcp-nest 0.1.0

package/dist/config/config-holder.service.d.ts

@@ -0,0 +1,6 @@
+import { McpConfig } from "./mcp-config.interface";
+export declare class ConfigHolderService {
+    private config;
+    setConfig(config: McpConfig): void;
+    getConfig(): McpConfig;
+}

package/dist/config/config-holder.service.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigHolderService = void 0;
+const common_1 = require("@nestjs/common");
+const logger_util_1 = require("../core/utils/logger.util");
+let ConfigHolderService = class ConfigHolderService {
+    config;
+    setConfig(config) {
+        this.config = config;
+        logger_util_1.logger.info("ConfigHolderService", "Configuration successfully loaded into ConfigHolderService", {
+            component: "Config",
+            toolCount: config.tools?.length || 0,
+        });
+    }
+    getConfig() {
+        if (!this.config) {
+            throw new Error("EasyMCP Configuration not set. Call EasyMCP.initialize() first.");
+        }
+        return this.config;
+    }
+};
+exports.ConfigHolderService = ConfigHolderService;
+exports.ConfigHolderService = ConfigHolderService = __decorate([
+    (0, common_1.Injectable)()
+], ConfigHolderService);
+//# sourceMappingURL=config-holder.service.js.map

package/dist/config/config-holder.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-holder.service.js","sourceRoot":"","sources":["../../src/config/config-holder.service.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAA4C;AAE5C,2DAAmD;AAG5C,IAAM,mBAAmB,GAAzB,MAAM,mBAAmB;IACtB,MAAM,CAAY;IAEnB,SAAS,CAAC,MAAiB;QAChC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,oBAAM,CAAC,IAAI,CAAC,qBAAqB,EAAE,4DAA4D,EAAE;YAC/F,SAAS,EAAE,QAAQ;YACnB,SAAS,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;SACrC,CAAC,CAAC;IACL,CAAC;IAEM,SAAS;QACd,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;CACF,CAAA;AAnBY,kDAAmB;8BAAnB,mBAAmB;IAD/B,IAAA,mBAAU,GAAE;GACA,mBAAmB,CAmB/B"}

package/dist/config/config-validator.d.ts

@@ -0,0 +1,5 @@
+import { McpConfig } from './mcp-config.interface';
+export declare class ConfigValidator {
+    static validate(config: McpConfig): void;
+    private static validateTool;
+}

package/dist/config/config-validator.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidator = void 0;
+const easy_mcp_error_1 = require("../core/errors/easy-mcp-error");
+class ConfigValidator {
+    static validate(config) {
+        if (!config) {
+            throw new easy_mcp_error_1.ConfigurationError('Configuration object is required');
+        }
+        if (!config.tools || !Array.isArray(config.tools)) {
+            throw new easy_mcp_error_1.ConfigurationError('tools must be a non-empty array');
+        }
+        if (config.tools.length === 0) {
+            throw new easy_mcp_error_1.ConfigurationError('At least one tool must be provided');
+        }
+        config.tools.forEach((tool, index) => {
+            this.validateTool(tool, index);
+        });
+        if (config.serverInfo) {
+            if (!config.serverInfo.name || typeof config.serverInfo.name !== 'string' || config.serverInfo.name.trim().length === 0) {
+                throw new easy_mcp_error_1.ConfigurationError('serverInfo.name must be a non-empty string');
+            }
+            if (!config.serverInfo.version || typeof config.serverInfo.version !== 'string' || config.serverInfo.version.trim().length === 0) {
+                throw new easy_mcp_error_1.ConfigurationError('serverInfo.version must be a non-empty string');
+            }
+        }
+    }
+    static validateTool(tool, index) {
+        if (!tool) {
+            throw new easy_mcp_error_1.ConfigurationError(`Tool at index ${index} is null or undefined`);
+        }
+        if (!tool.name || typeof tool.name !== 'string' || tool.name.trim().length === 0) {
+            throw new easy_mcp_error_1.ConfigurationError(`Tool at index ${index}: name must be a non-empty string`);
+        }
+        if (!tool.description || typeof tool.description !== 'string' || tool.description.trim().length === 0) {
+            throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': description must be a non-empty string`);
+        }
+        if (typeof tool.function !== 'function') {
+            throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': function must be a function`);
+        }
+        if (!tool.inputSchema) {
+            throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': inputSchema is required`);
+        }
+        if (tool.inputSchema.type !== 'OBJECT') {
+            throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': inputSchema.type must be 'OBJECT'`);
+        }
+        if (!tool.inputSchema.properties || typeof tool.inputSchema.properties !== 'object' || Array.isArray(tool.inputSchema.properties)) {
+            throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': inputSchema.properties must be an object`);
+        }
+        for (const [propName, propDef] of Object.entries(tool.inputSchema.properties)) {
+            if (!propDef || typeof propDef !== 'object' || Array.isArray(propDef)) {
+                throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': property '${propName}' must be an object`);
+            }
+            if (!propDef.type || typeof propDef.type !== 'string') {
+                throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': property '${propName}' must have a type`);
+            }
+            const validTypes = ['STRING', 'NUMBER', 'INTEGER', 'BOOLEAN', 'ARRAY', 'OBJECT'];
+            if (!validTypes.includes(propDef.type)) {
+                throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': property '${propName}' has invalid type '${propDef.type}'. Must be one of: ${validTypes.join(', ')}`);
+            }
+            if (!propDef.description || typeof propDef.description !== 'string') {
+                throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': property '${propName}' must have a description`);
+            }
+        }
+        if (tool.inputSchema.required !== undefined) {
+            if (!Array.isArray(tool.inputSchema.required)) {
+                throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': inputSchema.required must be an array`);
+            }
+            for (const requiredProp of tool.inputSchema.required) {
+                if (!(requiredProp in tool.inputSchema.properties)) {
+                    throw new easy_mcp_error_1.ConfigurationError(`Tool '${tool.name}': required property '${requiredProp}' does not exist in properties`);
+                }
+            }
+        }
+    }
+}
+exports.ConfigValidator = ConfigValidator;
+//# sourceMappingURL=config-validator.js.map

package/dist/config/config-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-validator.js","sourceRoot":"","sources":["../../src/config/config-validator.ts"],"names":[],"mappings":";;;AACA,kEAAmE;AAMnE,MAAa,eAAe;IAM1B,MAAM,CAAC,QAAQ,CAAC,MAAiB;QAC/B,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,mCAAkB,CAAC,kCAAkC,CAAC,CAAC;QACnE,CAAC;QAGD,IAAI,CAAC,MAAM,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,mCAAkB,CAAC,iCAAiC,CAAC,CAAC;QAClE,CAAC;QAED,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,mCAAkB,CAAC,oCAAoC,CAAC,CAAC;QACrE,CAAC;QAED,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YACnC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACjC,CAAC,CAAC,CAAC;QAGH,IAAI,MAAM,CAAC,UAAU,EAAE,CAAC;YACtB,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,IAAI,OAAO,MAAM,CAAC,UAAU,CAAC,IAAI,KAAK,QAAQ,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACxH,MAAM,IAAI,mCAAkB,CAAC,4CAA4C,CAAC,CAAC;YAC7E,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,IAAI,OAAO,MAAM,CAAC,UAAU,CAAC,OAAO,KAAK,QAAQ,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACjI,MAAM,IAAI,mCAAkB,CAAC,+CAA+C,CAAC,CAAC;YAChF,CAAC;QACH,CAAC;IACH,CAAC;IAKO,MAAM,CAAC,YAAY,CAAC,IAA2B,EAAE,KAAa;QACpE,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,mCAAkB,CAAC,iBAAiB,KAAK,uBAAuB,CAAC,CAAC;QAC9E,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACjF,MAAM,IAAI,mCAAkB,CAAC,iBAAiB,KAAK,mCAAmC,CAAC,CAAC;QAC1F,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,OAAO,IAAI,CAAC,WAAW,KAAK,QAAQ,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtG,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,2CAA2C,CAAC,CAAC;QAC9F,CAAC;QAED,IAAI,OAAO,IAAI,CAAC,QAAQ,KAAK,UAAU,EAAE,CAAC;YACxC,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,gCAAgC,CAAC,CAAC;QACnF,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,4BAA4B,CAAC,CAAC;QAC/E,CAAC;QAED,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACvC,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,sCAAsC,CAAC,CAAC;QACzF,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,IAAI,OAAO,IAAI,CAAC,WAAW,CAAC,UAAU,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,CAAC;YAClI,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,6CAA6C,CAAC,CAAC;QAChG,CAAC;QAGD,KAAK,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,CAAC;YAC9E,IAAI,CAAC,OAAO,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACtE,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,gBAAgB,QAAQ,qBAAqB,CAAC,CAAC;YAChG,CAAC;YAED,IAAI,CAAC,OAAO,CAAC,IAAI,IAAI,OAAO,OAAO,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACtD,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,gBAAgB,QAAQ,oBAAoB,CAAC,CAAC;YAC/F,CAAC;YAGD,MAAM,UAAU,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;YACjF,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvC,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,gBAAgB,QAAQ,uBAAuB,OAAO,CAAC,IAAI,sBAAsB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC3J,CAAC;YAED,IAAI,CAAC,OAAO,CAAC,WAAW,IAAI,OAAO,OAAO,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;gBACpE,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,gBAAgB,QAAQ,2BAA2B,CAAC,CAAC;YACtG,CAAC;QACH,CAAC;QAGD,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC5C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC9C,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,0CAA0C,CAAC,CAAC;YAC7F,CAAC;YAGD,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC;gBACrD,IAAI,CAAC,CAAC,YAAY,IAAI,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,EAAE,CAAC;oBACnD,MAAM,IAAI,mCAAkB,CAAC,SAAS,IAAI,CAAC,IAAI,yBAAyB,YAAY,gCAAgC,CAAC,CAAC;gBACxH,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;CACF;AAtGD,0CAsGC"}

package/dist/config/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const CONFIG_TOKEN = "MCP_CONFIG_HOLDER";
+export declare const INTERFACE_LAYER_TOKEN = "IInterfaceLayer";
+export declare const MAX_MESSAGE_SIZE_BYTES: number;
+export declare const MAX_CONTENT_LENGTH: number;

package/dist/config/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CONTENT_LENGTH = exports.MAX_MESSAGE_SIZE_BYTES = exports.INTERFACE_LAYER_TOKEN = exports.CONFIG_TOKEN = void 0;
+exports.CONFIG_TOKEN = "MCP_CONFIG_HOLDER";
+exports.INTERFACE_LAYER_TOKEN = "IInterfaceLayer";
+exports.MAX_MESSAGE_SIZE_BYTES = 10 * 1024 * 1024;
+exports.MAX_CONTENT_LENGTH = exports.MAX_MESSAGE_SIZE_BYTES;
+//# sourceMappingURL=constants.js.map

package/dist/config/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/config/constants.ts"],"names":[],"mappings":";;;AACa,QAAA,YAAY,GAAG,mBAAmB,CAAC;AAGnC,QAAA,qBAAqB,GAAG,iBAAiB,CAAC;AAO1C,QAAA,sBAAsB,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAM1C,QAAA,kBAAkB,GAAG,8BAAsB,CAAC"}

package/dist/config/mcp-config.interface.d.ts

@@ -0,0 +1,18 @@
+export interface ToolRegistrationInput {
+    name: string;
+    description: string;
+    function: (args: Record<string, any>) => Promise<any>;
+    inputSchema: {
+        type: "OBJECT";
+        properties: Record<string, any>;
+        required?: string[];
+    };
+}
+export interface ServerInfo {
+    name: string;
+    version: string;
+}
+export interface McpConfig {
+    tools: ToolRegistrationInput[];
+    serverInfo?: ServerInfo;
+}

package/dist/config/mcp-config.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=mcp-config.interface.js.map

package/dist/config/mcp-config.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-config.interface.js","sourceRoot":"","sources":["../../src/config/mcp-config.interface.ts"],"names":[],"mappings":""}

package/dist/config/version.d.ts

@@ -0,0 +1,4 @@
+export declare const PACKAGE_NAME: string;
+export declare const VERSION: string;
+export declare function getVersion(): string;
+export declare function getPackageName(): string;

package/dist/config/version.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.PACKAGE_NAME = void 0;
+exports.getVersion = getVersion;
+exports.getPackageName = getPackageName;
+const logger_util_1 = require("../core/utils/logger.util");
+function readPackageJson() {
+    try {
+        const packageJson = require("../../package.json");
+        const name = typeof packageJson.name === "string"
+            ? packageJson.name
+            : "easy-mcp-framework";
+        const version = typeof packageJson.version === "string"
+            ? packageJson.version
+            : "0.0.0";
+        return {
+            name,
+            version,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger_util_1.logger.warn("version", "Could not read package.json. Using fallback version.", {
+            error: errorMessage,
+        });
+        return {
+            name: "easy-mcp-framework",
+            version: "0.0.0",
+        };
+    }
+}
+const packageInfo = readPackageJson();
+exports.PACKAGE_NAME = packageInfo.name;
+exports.VERSION = packageInfo.version;
+function getVersion() {
+    return exports.VERSION;
+}
+function getPackageName() {
+    return exports.PACKAGE_NAME;
+}
+//# sourceMappingURL=version.js.map

package/dist/config/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/config/version.ts"],"names":[],"mappings":";;;AA6DA,gCAEC;AAMD,wCAEC;AAvED,2DAAmD;AAYnD,SAAS,eAAe;IACtB,IAAI,CAAC;QAIH,MAAM,WAAW,GAAG,OAAO,CAAC,oBAAoB,CAAgB,CAAC;QAGjE,MAAM,IAAI,GAAG,OAAO,WAAW,CAAC,IAAI,KAAK,QAAQ;YAC/C,CAAC,CAAC,WAAW,CAAC,IAAI;YAClB,CAAC,CAAC,oBAAoB,CAAC;QACzB,MAAM,OAAO,GAAG,OAAO,WAAW,CAAC,OAAO,KAAK,QAAQ;YACrD,CAAC,CAAC,WAAW,CAAC,OAAO;YACrB,CAAC,CAAC,OAAO,CAAC;QAEZ,OAAO;YACL,IAAI;YACJ,OAAO;SACR,CAAC;IACJ,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAGf,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5E,oBAAM,CAAC,IAAI,CAAC,SAAS,EAAE,sDAAsD,EAAE;YAC7E,KAAK,EAAE,YAAY;SACpB,CAAC,CAAC;QACH,OAAO;YACL,IAAI,EAAE,oBAAoB;YAC1B,OAAO,EAAE,OAAO;SACjB,CAAC;IACJ,CAAC;AACH,CAAC;AAED,MAAM,WAAW,GAAG,eAAe,EAAE,CAAC;AAKzB,QAAA,YAAY,GAAG,WAAW,CAAC,IAAI,CAAC;AAKhC,QAAA,OAAO,GAAG,WAAW,CAAC,OAAO,CAAC;AAM3C,SAAgB,UAAU;IACxB,OAAO,eAAO,CAAC;AACjB,CAAC;AAMD,SAAgB,cAAc;IAC5B,OAAO,oBAAY,CAAC;AACtB,CAAC"}

package/dist/core/core.module.d.ts

@@ -0,0 +1,2 @@
+export declare class CoreModule {
+}

package/dist/core/core.module.js

@@ -0,0 +1,24 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreModule = void 0;
+const common_1 = require("@nestjs/common");
+const mcp_server_service_1 = require("./mcp-server/mcp-server.service");
+const interface_module_1 = require("../interface/interface.module");
+let CoreModule = class CoreModule {
+};
+exports.CoreModule = CoreModule;
+exports.CoreModule = CoreModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: [interface_module_1.InterfaceModule],
+        providers: [mcp_server_service_1.McpServerService],
+        exports: [mcp_server_service_1.McpServerService],
+    })
+], CoreModule);
+//# sourceMappingURL=core.module.js.map

package/dist/core/core.module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.module.js","sourceRoot":"","sources":["../../src/core/core.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAgD;AAChD,wEAAmE;AACnE,oEAAgE;AAQzD,IAAM,UAAU,GAAhB,MAAM,UAAU;CAAG,CAAA;AAAb,gCAAU;qBAAV,UAAU;IANtB,IAAA,eAAM,GAAE;IACR,IAAA,eAAM,EAAC;QACN,OAAO,EAAE,CAAC,kCAAe,CAAC;QAC1B,SAAS,EAAE,CAAC,qCAAgB,CAAC;QAC7B,OAAO,EAAE,CAAC,qCAAgB,CAAC;KAC5B,CAAC;GACW,UAAU,CAAG"}

package/dist/core/errors/easy-mcp-error.d.ts

@@ -0,0 +1,14 @@
+export declare class EasyMcpError extends Error {
+    constructor(message: string);
+}
+export declare class ConfigurationError extends EasyMcpError {
+    constructor(message: string);
+}
+export declare class ToolExecutionError extends EasyMcpError {
+    readonly toolName?: string | undefined;
+    readonly originalError?: Error | undefined;
+    constructor(message: string, toolName?: string | undefined, originalError?: Error | undefined);
+}
+export declare class ToolNotFoundError extends EasyMcpError {
+    constructor(toolName: string);
+}

package/dist/core/errors/easy-mcp-error.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolNotFoundError = exports.ToolExecutionError = exports.ConfigurationError = exports.EasyMcpError = void 0;
+class EasyMcpError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EasyMcpError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+exports.EasyMcpError = EasyMcpError;
+class ConfigurationError extends EasyMcpError {
+    constructor(message) {
+        super(message);
+        this.name = 'ConfigurationError';
+    }
+}
+exports.ConfigurationError = ConfigurationError;
+class ToolExecutionError extends EasyMcpError {
+    toolName;
+    originalError;
+    constructor(message, toolName, originalError) {
+        super(message);
+        this.toolName = toolName;
+        this.originalError = originalError;
+        this.name = 'ToolExecutionError';
+    }
+}
+exports.ToolExecutionError = ToolExecutionError;
+class ToolNotFoundError extends EasyMcpError {
+    constructor(toolName) {
+        super(`Tool '${toolName}' not found in registry`);
+        this.name = 'ToolNotFoundError';
+    }
+}
+exports.ToolNotFoundError = ToolNotFoundError;
+//# sourceMappingURL=easy-mcp-error.js.map

package/dist/core/errors/easy-mcp-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"easy-mcp-error.js","sourceRoot":"","sources":["../../../src/core/errors/easy-mcp-error.ts"],"names":[],"mappings":";;;AAGA,MAAa,YAAa,SAAQ,KAAK;IACrC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;QAE3B,IAAI,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAC5B,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;CACF;AATD,oCASC;AAKD,MAAa,kBAAmB,SAAQ,YAAY;IAClD,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AALD,gDAKC;AAKD,MAAa,kBAAmB,SAAQ,YAAY;IACL;IAAmC;IAAhF,YAAY,OAAe,EAAkB,QAAiB,EAAkB,aAAqB;QACnG,KAAK,CAAC,OAAO,CAAC,CAAC;QAD4B,aAAQ,GAAR,QAAQ,CAAS;QAAkB,kBAAa,GAAb,aAAa,CAAQ;QAEnG,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AALD,gDAKC;AAKD,MAAa,iBAAkB,SAAQ,YAAY;IACjD,YAAY,QAAgB;QAC1B,KAAK,CAAC,SAAS,QAAQ,yBAAyB,CAAC,CAAC;QAClD,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAC;IAClC,CAAC;CACF;AALD,8CAKC"}

package/dist/core/mcp-server/mcp-server.service.d.ts

@@ -0,0 +1,22 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ToolRegistryService } from "../../tooling/tool-registry/tool-registry.service";
+import { type IInterfaceLayer } from "../../interface/interface.interface";
+import { StdioGatewayService } from "../../interface/stdio-gateway.service";
+import { JsonRpcRequest, JsonRpcResponse } from "../../interface/jsonrpc.interface";
+import { ConfigHolderService } from "../../config/config-holder.service";
+export declare class McpServerService implements OnModuleInit {
+    private readonly toolRegistry;
+    private readonly interfaceLayer;
+    private readonly stdioGatewayService;
+    private readonly configHolder;
+    private clientIdentifier;
+    constructor(toolRegistry: ToolRegistryService, interfaceLayer: IInterfaceLayer, stdioGatewayService: StdioGatewayService, configHolder: ConfigHolderService);
+    private getServerInfo;
+    private getActorIdentifier;
+    onModuleInit(): void;
+    startListening(): Promise<void>;
+    handleRequest(request: JsonRpcRequest): Promise<JsonRpcResponse>;
+    private handleInitialize;
+    private handleListTools;
+    private handleCallTool;
+}

package/dist/core/mcp-server/mcp-server.service.js

@@ -0,0 +1,285 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpServerService = void 0;
+const common_1 = require("@nestjs/common");
+const tool_registry_service_1 = require("../../tooling/tool-registry/tool-registry.service");
+const constants_1 = require("../../config/constants");
+const stdio_gateway_service_1 = require("../../interface/stdio-gateway.service");
+const jsonrpc_interface_1 = require("../../interface/jsonrpc.interface");
+const mcp_protocol_interface_1 = require("../../interface/mcp-protocol.interface");
+const easy_mcp_error_1 = require("../errors/easy-mcp-error");
+const constants_2 = require("../../config/constants");
+const config_holder_service_1 = require("../../config/config-holder.service");
+const version_1 = require("../../config/version");
+const schema_validator_1 = require("../utils/schema-validator");
+const logger_util_1 = require("../utils/logger.util");
+const sanitize_util_1 = require("../utils/sanitize.util");
+let McpServerService = class McpServerService {
+    toolRegistry;
+    interfaceLayer;
+    stdioGatewayService;
+    configHolder;
+    clientIdentifier = "stdio-client";
+    constructor(toolRegistry, interfaceLayer, stdioGatewayService, configHolder) {
+        this.toolRegistry = toolRegistry;
+        this.interfaceLayer = interfaceLayer;
+        this.stdioGatewayService = stdioGatewayService;
+        this.configHolder = configHolder;
+    }
+    getServerInfo() {
+        const config = this.configHolder.getConfig();
+        const defaultInfo = {
+            name: version_1.PACKAGE_NAME,
+            version: version_1.VERSION,
+        };
+        return config.serverInfo ?? defaultInfo;
+    }
+    getActorIdentifier(request) {
+        if (request.method === "initialize") {
+            const params = request.params;
+            if (params?.clientInfo?.name) {
+                this.clientIdentifier = params.clientInfo.name;
+                return this.clientIdentifier;
+            }
+        }
+        return this.clientIdentifier;
+    }
+    onModuleInit() {
+        this.stdioGatewayService.setMcpServerService(this);
+        logger_util_1.logger.info("McpServerService", "Circular dependency resolved", {
+            component: "Layer 3",
+        });
+    }
+    async startListening() {
+        logger_util_1.logger.info("McpServerService", "Initiating Layer 1 Interface startup", {
+            component: "Layer 3: Abstraction Core",
+        });
+        await this.interfaceLayer.start();
+        logger_util_1.logger.info("McpServerService", "McpServerService is operational and awaiting Layer 1 input", {
+            component: "Layer 3",
+        });
+    }
+    async handleRequest(request) {
+        const isDebugMode = process.env.DEBUG === '1' || process.env.DEBUG === 'true';
+        if (isDebugMode) {
+            logger_util_1.logger.debug("McpServerService", "Received JSON-RPC request", {
+                method: request.method,
+                requestId: request.id,
+                hasParams: !!request.params,
+            });
+        }
+        try {
+            let response;
+            switch (request.method) {
+                case "initialize":
+                    response = this.handleInitialize(request);
+                    if (isDebugMode) {
+                        const initResult = response.result;
+                        logger_util_1.logger.debug("McpServerService", "Initialize response", {
+                            protocolVersion: initResult?.protocolVersion,
+                            hasError: !!response.error,
+                            errorCode: response.error?.code,
+                        });
+                    }
+                    logger_util_1.logger.audit("McpServerService", "initialize", response.error ? "failure" : "success", { method: request.method }, request.id, this.getActorIdentifier(request));
+                    return response;
+                case "tools/list":
+                    response = this.handleListTools(request);
+                    if (isDebugMode) {
+                        const listResult = response.result;
+                        logger_util_1.logger.debug("McpServerService", "Tools/list response", {
+                            toolCount: listResult?.tools?.length || 0,
+                            hasError: !!response.error,
+                        });
+                    }
+                    logger_util_1.logger.audit("McpServerService", "tools/list", response.error ? "failure" : "success", { method: request.method }, request.id, this.getActorIdentifier(request));
+                    return response;
+                case "tools/call":
+                    response = await this.handleCallTool(request);
+                    return response;
+                default:
+                    logger_util_1.logger.warn("McpServerService", "Method not found", {
+                        component: "Layer 3",
+                        method: request.method,
+                        requestId: request.id,
+                    });
+                    return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.MethodNotFound, `Method not found: ${request.method}`);
+            }
+        }
+        catch (error) {
+            logger_util_1.logger.error("McpServerService", "Unhandled error in handleRequest", {
+                component: "Layer 3",
+                method: request.method,
+                requestId: request.id,
+                error: (0, sanitize_util_1.sanitizeErrorMessage)(error),
+            });
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InternalError, "Internal error");
+        }
+    }
+    handleInitialize(request) {
+        const params = request.params;
+        if (!params || typeof params.protocolVersion !== "string") {
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, "Missing or invalid protocolVersion");
+        }
+        const SUPPORTED_PROTOCOL_VERSION = "2024-11-05";
+        if (params.protocolVersion !== SUPPORTED_PROTOCOL_VERSION) {
+            logger_util_1.logger.warn("McpServerService", "Unsupported protocol version", {
+                component: "Layer 3",
+                supportedVersion: SUPPORTED_PROTOCOL_VERSION,
+                requestId: request.id,
+            });
+            const isDebugMode = process.env.DEBUG === '1' || process.env.DEBUG === 'true';
+            if (isDebugMode) {
+                logger_util_1.logger.debug("McpServerService", "Protocol version mismatch", {
+                    supported: SUPPORTED_PROTOCOL_VERSION,
+                    clientName: params.clientInfo?.name || 'unknown',
+                });
+            }
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, `Unsupported protocol version: ${params.protocolVersion}. Supported version: ${SUPPORTED_PROTOCOL_VERSION}. Please update your client to use protocol version ${SUPPORTED_PROTOCOL_VERSION}.`);
+        }
+        const result = {
+            protocolVersion: SUPPORTED_PROTOCOL_VERSION,
+            capabilities: {
+                tools: {},
+            },
+            serverInfo: this.getServerInfo(),
+        };
+        return (0, jsonrpc_interface_1.createJsonRpcSuccess)(request.id, result);
+    }
+    handleListTools(request) {
+        const tools = this.toolRegistry.getToolSchemasForLLM();
+        const mcpTools = tools.map((tool) => ({
+            name: tool.function.name,
+            description: tool.function.description,
+            inputSchema: tool.function.parameters,
+        }));
+        const result = {
+            tools: mcpTools,
+        };
+        return (0, jsonrpc_interface_1.createJsonRpcSuccess)(request.id, result);
+    }
+    async handleCallTool(request) {
+        const params = request.params;
+        const actorId = this.getActorIdentifier(request);
+        if (!params) {
+            logger_util_1.logger.audit("McpServerService", "tools/call", "failure", { reason: "Missing params", method: request.method }, request.id, actorId);
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, "Missing params");
+        }
+        if (!params.name || typeof params.name !== "string") {
+            logger_util_1.logger.audit("McpServerService", "tools/call", "failure", { reason: "Missing or invalid tool name", method: request.method }, request.id, actorId);
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, "Missing or invalid tool name");
+        }
+        const toolName = params.name;
+        if (params.arguments !== undefined && params.arguments !== null) {
+            if (typeof params.arguments !== "object" ||
+                Array.isArray(params.arguments)) {
+                logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
+                    reason: "Invalid arguments type - must be a plain object",
+                    toolName,
+                    method: request.method,
+                }, request.id, actorId);
+                return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, "Arguments must be a plain object");
+            }
+        }
+        const args = params.arguments || {};
+        const tool = this.toolRegistry.getTool(toolName);
+        if (!tool) {
+            logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
+                reason: "Tool not found",
+                toolName,
+                method: request.method,
+            }, request.id, actorId);
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, mcp_protocol_interface_1.McpErrorCode.ToolNotFound, "Tool not found");
+        }
+        const validationError = (0, schema_validator_1.validateToolArguments)(args, tool.parameters, tool.required);
+        if (validationError) {
+            logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
+                reason: "Invalid arguments",
+                toolName,
+                validationError,
+                method: request.method,
+            }, request.id, actorId);
+            const isDebugMode = process.env.DEBUG === '1' || process.env.DEBUG === 'true';
+            if (isDebugMode) {
+                logger_util_1.logger.debug("McpServerService", "Tool argument validation failed", {
+                    toolName,
+                    validationError,
+                    providedArgs: Object.keys(args),
+                    expectedParams: Object.keys(tool.parameters),
+                    requiredParams: tool.required,
+                });
+            }
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, jsonrpc_interface_1.JsonRpcErrorCode.InvalidParams, `Tool '${toolName}' validation failed: ${validationError}. Check the tool schema and ensure all required parameters are provided.`);
+        }
+        try {
+            const toolResult = await this.toolRegistry.executeTool(toolName, args);
+            const sanitizedResult = (0, sanitize_util_1.sanitizeToolResult)(toolResult);
+            const result = {
+                content: [
+                    {
+                        type: "text",
+                        text: sanitizedResult,
+                    },
+                ],
+                isError: false,
+            };
+            logger_util_1.logger.audit("McpServerService", "tools/call", "success", {
+                toolName,
+                resultSize: sanitizedResult.length,
+                method: request.method,
+            }, request.id, actorId);
+            return (0, jsonrpc_interface_1.createJsonRpcSuccess)(request.id, result);
+        }
+        catch (error) {
+            if (error instanceof easy_mcp_error_1.ToolNotFoundError) {
+                logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
+                    reason: "ToolNotFoundError",
+                    toolName,
+                    method: request.method,
+                }, request.id, actorId);
+                return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, mcp_protocol_interface_1.McpErrorCode.ToolNotFound, "Tool not found");
+            }
+            if (error instanceof easy_mcp_error_1.ToolExecutionError) {
+                logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
+                    reason: "ToolExecutionError",
+                    toolName,
+                    method: request.method,
+                }, request.id, actorId);
+                return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, mcp_protocol_interface_1.McpErrorCode.ToolExecutionError, "Tool execution failed");
+            }
+            logger_util_1.logger.error("McpServerService", "Unknown error during tool execution", {
+                component: "Layer 3",
+                toolName,
+                requestId: request.id,
+                error: (0, sanitize_util_1.sanitizeErrorMessage)(error),
+            });
+            logger_util_1.logger.audit("McpServerService", "tools/call", "failure", {
+                reason: "Unknown error",
+                toolName,
+                method: request.method,
+            }, request.id, actorId);
+            return (0, jsonrpc_interface_1.createJsonRpcError)(request.id, mcp_protocol_interface_1.McpErrorCode.ToolExecutionError, "Tool execution failed");
+        }
+    }
+};
+exports.McpServerService = McpServerService;
+exports.McpServerService = McpServerService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(constants_1.INTERFACE_LAYER_TOKEN)),
+    __param(3, (0, common_1.Inject)(constants_2.CONFIG_TOKEN)),
+    __metadata("design:paramtypes", [tool_registry_service_1.ToolRegistryService, Object, stdio_gateway_service_1.StdioGatewayService,
+        config_holder_service_1.ConfigHolderService])
+], McpServerService);
+//# sourceMappingURL=mcp-server.service.js.map