@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/src/utils/instance-id.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Instance ID generation utilities using content-based hashing.
+ */
+import type { ServerInstance } from '../config/config.schema.js';
+/**
+ * Generates a stable 8-character hash from an object.
+ * Uses SHA-256 and returns the first 8 hex characters.
+ *
+ * @param obj - The object to hash
+ * @returns An 8-character hex string
+ */
+export declare function generateInstanceHash(obj: Record<string, unknown>): string;
+/**
+ * Generates a deterministic instance ID based on server name and instance configuration.
+ * The ID format is: ${serverName}-${hash}
+ *
+ * @param serverName - Name of the server
+ * @param instanceConfig - Partial instance configuration
+ * @returns A deterministic instance ID
+ */
+export declare function generateInstanceId(serverName: string, instanceConfig: Partial<ServerInstance>): string;
+//# sourceMappingURL=instance-id.d.ts.map

package/dist/server/src/utils/instance-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-id.d.ts","sourceRoot":"","sources":["../../../../src/utils/instance-id.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAyBzE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,GACtC,MAAM,CAiBR"}

package/dist/server/src/utils/instance-id.js

@@ -0,0 +1,59 @@
+/**
+ * Instance ID generation utilities using content-based hashing.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Generates a stable 8-character hash from an object.
+ * Uses SHA-256 and returns the first 8 hex characters.
+ *
+ * @param obj - The object to hash
+ * @returns An 8-character hex string
+ */
+export function generateInstanceHash(obj) {
+    function stableStringify(value) {
+        if (value === null || typeof value !== 'object') {
+            return JSON.stringify(value);
+        }
+        if (Array.isArray(value)) {
+            return '[' + value.map(stableStringify).join(',') + ']';
+        }
+        const sortedObj = {};
+        for (const key of Object.keys(value).sort()) {
+            sortedObj[key] = value[key];
+        }
+        return ('{' +
+            Object.keys(sortedObj)
+                .map((key) => JSON.stringify(key) + ':' + stableStringify(sortedObj[key]))
+                .join(',') +
+            '}');
+    }
+    const stableString = stableStringify(obj);
+    const hash = createHash('sha256');
+    hash.update(stableString);
+    return hash.digest('hex').slice(0, 8);
+}
+/**
+ * Generates a deterministic instance ID based on server name and instance configuration.
+ * The ID format is: ${serverName}-${hash}
+ *
+ * @param serverName - Name of the server
+ * @param instanceConfig - Partial instance configuration
+ * @returns A deterministic instance ID
+ */
+export function generateInstanceId(serverName, instanceConfig) {
+    const hashableContent = {};
+    if (instanceConfig.args && instanceConfig.args.length > 0) {
+        hashableContent.args = instanceConfig.args;
+    }
+    if (instanceConfig.env) {
+        hashableContent.env = instanceConfig.env;
+    }
+    if (instanceConfig.headers) {
+        hashableContent.headers = instanceConfig.headers;
+    }
+    if (instanceConfig.tags && Object.keys(instanceConfig.tags).length > 0) {
+        hashableContent.tags = instanceConfig.tags;
+    }
+    const hash = generateInstanceHash(hashableContent);
+    return `${serverName}-${hash}`;
+}

package/dist/server/src/utils/json-utils.d.ts

@@ -23,7 +23,7 @@ type ConfigGetter = () => {
         logging: {
             jsonPretty: boolean;
             mcpCommDebug: boolean;
-            sessionDebug: boolean;
+            apiDebug: boolean;
         };
     };
 };
@@ -60,11 +60,11 @@ export declare function getJsonPrettySetting(): boolean;
  */
 export declare function getMcpCommDebugSetting(): boolean;
 /**
- * Get session debug setting from config getter.
+ * Get API debug setting from config getter.
  *
- * @returns boolean indicating whether to enable session debug logging
+ * @returns boolean indicating whether to enable API debug logging
  */
-export declare function getSessionDebugSetting(): boolean;
+export declare function getApiDebugSetting(): boolean;
 /**
  * Stringify object for logging with dynamic pretty formatting based on LOG_JSON_PRETTY environment variable
  * @param obj Object to stringify

package/dist/server/src/utils/json-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/json-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAiED;;GAEG;AACH,KAAK,YAAY,GAAG,MAAM;IACxB,MAAM,EAAE;QACN,OAAO,EAAE;YACP,UAAU,EAAE,OAAO,CAAC;YACpB,YAAY,EAAE,OAAO,CAAC;YACtB,YAAY,EAAE,OAAO,CAAC;SACvB,CAAC;KACH,CAAC;CACH,CAAC;AAQF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAE3E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAU/E;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAG1E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAiB9C;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAUhD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAUhD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAOxD;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,GAAG,EAAE,OAAO,EACZ,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,GAClD,MAAM,CAOR"}
+{"version":3,"file":"json-utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/json-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAiED;;GAEG;AACH,KAAK,YAAY,GAAG,MAAM;IACxB,MAAM,EAAE;QACN,OAAO,EAAE;YACP,UAAU,EAAE,OAAO,CAAC;YACpB,YAAY,EAAE,OAAO,CAAC;YACtB,QAAQ,EAAE,OAAO,CAAC;SACnB,CAAC;KACH,CAAC;CACH,CAAC;AAQF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAE3E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAU/E;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAG1E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAiB9C;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAUhD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAU5C;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAOxD;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,GAAG,EAAE,OAAO,EACZ,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,GAClD,MAAM,CAOR"}

package/dist/server/src/utils/json-utils.js

@@ -165,15 +165,15 @@ export function getMcpCommDebugSetting() {
     return getDefaultForDevMode(false);
 }
 /**
- * Get session debug setting from config getter.
+ * Get API debug setting from config getter.
  *
- * @returns boolean indicating whether to enable session debug logging
+ * @returns boolean indicating whether to enable API debug logging
  */
-export function getSessionDebugSetting() {
+export function getApiDebugSetting() {
     if (_configGetter) {
         try {
             const config = _configGetter();
-            return config.system.logging.sessionDebug;
+            return config.system.logging.apiDebug;
         }
         catch {
             // Fall through to default if config getter fails

package/dist/server/src/utils/logger/dev-logger.d.ts

@@ -3,7 +3,8 @@
  * This file contains development log initialization and management.
  */
 import fs from 'fs';
-import { LogRotator, type RotatorConfig } from '../log-rotator.js';
+import { LogRotator } from '../log-rotator.js';
+import type { RotatorConfig } from '../log-rotator.js';
 /**
  * Development logger configuration and setup.
  */

package/dist/server/src/utils/logger/dev-logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-logger.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/dev-logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEnE;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,aAAa,CAA2B;IAEhD;;OAEG;IACH,IAAI,MAAM,IAAI,EAAE,CAAC,WAAW,GAAG,IAAI,CAElC;IAED;;;OAGG;IACH,IAAI,OAAO,IAAI,UAAU,GAAG,IAAI,CAE/B;IAED;;;;;;;;;;OAUG;IACH,YAAY,CAAC,aAAa,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAoB/F;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd"}
+{"version":3,"file":"dev-logger.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/dev-logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,aAAa,CAA2B;IAEhD;;OAEG;IACH,IAAI,MAAM,IAAI,EAAE,CAAC,WAAW,GAAG,IAAI,CAElC;IAED;;;OAGG;IACH,IAAI,OAAO,IAAI,UAAU,GAAG,IAAI,CAE/B;IAED;;;;;;;;;;OAUG;IACH,YAAY,CAAC,aAAa,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAoB/F;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd"}

package/dist/server/src/utils/logger/log-formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-formatter.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-formatter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAsED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,UAAU,SAAI,GAAG,UAAU,GAAG,IAAI,CAQ/D;AA2HD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAK/D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CASlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAatD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM7C;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,UAAU,GACnB,MAAM,CAsCR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CA6B/F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAiClD"}
+{"version":3,"file":"log-formatter.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-formatter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAsED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,UAAU,SAAI,GAAG,UAAU,GAAG,IAAI,CAQ/D;AA2HD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAK/D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CASlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAatD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM7C;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,UAAU,GACnB,MAAM,CAsCR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CA6B/F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAyHlD"}

package/dist/server/src/utils/logger/log-formatter.js

@@ -324,25 +324,102 @@ export function createLogMessage(level, message, context) {
  * @returns Formatted error string
  */
 export function formatError(error) {
+    // Special case: handle arrays that might contain errors
+    if (Array.isArray(error)) {
+        if (error.length === 0) {
+            return '';
+        }
+        // If it's a single-element array, unwrap it and format the element
+        if (error.length === 1) {
+            const element = error[0];
+            // Skip empty objects that are likely log context
+            if (typeof element === 'object' &&
+                element !== null &&
+                !Array.isArray(element) &&
+                ('module' in element || 'traceId' in element || 'spanId' in element)) {
+                return '';
+            }
+            // Otherwise format the single element
+            return formatError(element);
+        }
+        // For multi-element arrays, format each element
+        const formattedElements = error
+            .map((elem) => {
+            const formatted = formatError(elem);
+            return formatted || '[skipped]';
+        })
+            .filter((f) => f !== '[skipped]');
+        if (formattedElements.length === 0) {
+            return '';
+        }
+        if (formattedElements.length === 1) {
+            return formattedElements[0];
+        }
+        return `[ ${formattedElements.join(', ')} ]`;
+    }
     if (error instanceof Error) {
-        let result = error.message;
+        let result = '';
+        // Include error name if available
+        if (error.name) {
+            result += error.name;
+        }
+        // Include error message if available
+        if (error.message) {
+            result += result ? `: ${error.message}` : error.message;
+        }
+        // If no name and message, try string representation
+        if (!result) {
+            result = String(error);
+        }
+        // Include stack trace if available
         if (error.stack) {
             const stackLines = error.stack.split('\n').slice(1, 6);
             if (stackLines.length > 0) {
                 result += '\n' + stackLines.join('\n');
             }
         }
+        // Check for non-enumerable properties using Object.getOwnPropertyNames
+        const ownProps = Object.getOwnPropertyNames(error);
+        const extraProps = [];
+        for (const prop of ownProps) {
+            if (prop !== 'name' && prop !== 'message' && prop !== 'stack') {
+                try {
+                    const value = error[prop];
+                    extraProps.push(`${prop}: ${stringifyForLogging(value)}`);
+                }
+                catch {
+                    extraProps.push(`${prop}: [could not serialize]`);
+                }
+            }
+        }
+        if (extraProps.length > 0) {
+            result += '\n  Additional properties: ' + extraProps.join(', ');
+        }
         return result;
     }
     if (typeof error === 'object' && error !== null) {
         if ('module' in error || 'traceId' in error || 'spanId' in error) {
             return '';
         }
-        if (Array.isArray(error) && error.length === 0) {
-            return '';
+        // Check for empty object (both enumerable and non-enumerable properties)
+        const enumKeys = Object.keys(error);
+        const allProps = Object.getOwnPropertyNames(error);
+        if (enumKeys.length === 0 && allProps.length === 0) {
+            return '[empty object]';
         }
-        if (Object.keys(error).length === 0) {
-            return '';
+        // If only non-enumerable properties, show them
+        if (enumKeys.length === 0 && allProps.length > 0) {
+            const props = [];
+            for (const prop of allProps) {
+                try {
+                    const value = error[prop];
+                    props.push(`${prop}: ${stringifyForLogging(value)}`);
+                }
+                catch {
+                    props.push(`${prop}: [could not serialize]`);
+                }
+            }
+            return `{ ${props.join(', ')} }`;
         }
         try {
             return stringifyForLogging(error);

package/dist/server/src/utils/logger/log-modules.d.ts

@@ -24,25 +24,22 @@ export declare const LOG_MODULES: {
     readonly DEV_SERVER: {
         module: string;
     };
-    readonly CONFIG_MANAGER: {
-        module: string;
-    };
-    readonly CONFIG_LOADER: {
+    readonly RUNNER: {
         module: string;
     };
-    readonly CONFIG_CHANGES: {
+    readonly CONFIG_MANAGER: {
         module: string;
     };
-    readonly SESSION_MANAGER: {
+    readonly CONFIG_LOADER: {
         module: string;
     };
-    readonly SESSION: {
+    readonly CONFIG_SAVER: {
         module: string;
     };
-    readonly SESSION_API: {
+    readonly CONFIG_CHANGES: {
         module: string;
     };
-    readonly SESSION_TRACKER: {
+    readonly SERVER_CONFIG_MANAGER: {
         module: string;
     };
     readonly CONNECTION_MANAGER: {
@@ -51,6 +48,9 @@ export declare const LOG_MODULES: {
     readonly HUB_MANAGER: {
         module: string;
     };
+    readonly SERVER_SELECTOR: {
+        module: string;
+    };
     readonly GATEWAY: {
         module: string;
     };
@@ -66,6 +66,9 @@ export declare const LOG_MODULES: {
     readonly TOOL_LIST: {
         module: string;
     };
+    readonly TOOL_LIST_GENERATOR: {
+        module: string;
+    };
     readonly INITIALIZE_HANDLER: {
         module: string;
     };
@@ -81,6 +84,9 @@ export declare const LOG_MODULES: {
     readonly SEARCH: {
         module: string;
     };
+    readonly ERROR_HANDLER: {
+        module: string;
+    };
     readonly COMMUNICATION: {
         module: string;
     };

package/dist/server/src/utils/logger/log-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-modules.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-modules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4DtB;;;;;;;;;;;OAWG;mCACmB,MAAM;;;CACpB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,OAAO,WAAW,EAAE,SAAS,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,YAAY,CAAC,CAAC"}
+{"version":3,"file":"log-modules.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-modules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8DtB;;;;;;;;;;;OAWG;mCACmB,MAAM;;;CACpB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,OAAO,WAAW,EAAE,SAAS,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,YAAY,CAAC,CAAC"}

package/dist/server/src/utils/logger/log-modules.js

@@ -21,18 +21,17 @@ export const LOG_MODULES = {
     // Core system modules
     SERVER: { module: 'Server' },
     DEV_SERVER: { module: 'DevServer' },
+    RUNNER: { module: 'Runner' },
     // Config management
     CONFIG_MANAGER: { module: 'ConfigManager' },
     CONFIG_LOADER: { module: 'ConfigLoader' },
-    CONFIG_CHANGES: { module: 'System Config Changes' },
-    // Session management
-    SESSION_MANAGER: { module: 'SessionManager' },
-    SESSION: { module: 'Session' },
-    SESSION_API: { module: 'Session API' },
-    SESSION_TRACKER: { module: 'SessionTracker' },
+    CONFIG_SAVER: { module: 'ConfigSaver' },
+    CONFIG_CHANGES: { module: 'SystemConfigManager' },
+    SERVER_CONFIG_MANAGER: { module: 'ServerConfigManager' },
     // Connection management
     CONNECTION_MANAGER: { module: 'ConnectionManager' },
     HUB_MANAGER: { module: 'HubManager' },
+    SERVER_SELECTOR: { module: 'ServerSelector' },
     // Gateway related
     GATEWAY: { module: 'Gateway' },
     GATEWAY_SERVICE: { module: 'GatewayService' },
@@ -40,6 +39,7 @@ export const LOG_MODULES = {
     HUB_TOOLS: { module: 'HubTools' },
     SYSTEM_TOOL: { module: 'SystemTool' },
     TOOL_LIST: { module: 'ToolList' },
+    TOOL_LIST_GENERATOR: { module: 'ToolListGenerator' },
     // Gateway request handlers
     INITIALIZE_HANDLER: { module: 'Initialize' },
     SYSTEM_TOOLS_HANDLER: { module: 'SystemTools' },
@@ -47,6 +47,8 @@ export const LOG_MODULES = {
     TOOLS_HANDLER: { module: 'Tools' },
     // Search service
     SEARCH: { module: 'Search' },
+    // Error handling
+    ERROR_HANDLER: { module: 'ErrorHandler' },
     // Communication
     COMMUNICATION: { module: 'Communication' },
     CONTEXT: { module: 'Context' },

package/dist/server/src/utils/parameter-validator.d.ts

@@ -0,0 +1,10 @@
+import type { JsonSchema } from '../../shared/models/tool.model.js';
+/**
+ * Validates tool arguments against the provided JSON schema
+ *
+ * @param args - The tool arguments to validate
+ * @param schema - The JSON schema to validate against
+ * @returns null if valid, or an error message string if invalid
+ */
+export declare function validateParameters(args: Record<string, unknown>, schema: JsonSchema): string | null;
+//# sourceMappingURL=parameter-validator.d.ts.map

package/dist/server/src/utils/parameter-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-validator.d.ts","sourceRoot":"","sources":["../../../../src/utils/parameter-validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAE/D;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,MAAM,EAAE,UAAU,GACjB,MAAM,GAAG,IAAI,CAyBf"}

package/dist/server/src/utils/parameter-validator.js

@@ -0,0 +1,53 @@
+/**
+ * Validates tool arguments against the provided JSON schema
+ *
+ * @param args - The tool arguments to validate
+ * @param schema - The JSON schema to validate against
+ * @returns null if valid, or an error message string if invalid
+ */
+export function validateParameters(args, schema) {
+    // Check required fields
+    if (schema.required && Array.isArray(schema.required)) {
+        for (const requiredField of schema.required) {
+            if (!(requiredField in args)) {
+                return `Missing required parameter: '${requiredField}'. Required parameters: [${schema.required.join(', ')}]`;
+            }
+        }
+    }
+    // Check parameter types (basic validation)
+    if (schema.properties) {
+        for (const [paramName, paramSchema] of Object.entries(schema.properties)) {
+            if (paramName in args) {
+                const argValue = args[paramName];
+                const expectedType = paramSchema.type;
+                if (expectedType && !isValidType(argValue, expectedType)) {
+                    return `Invalid type for parameter '${paramName}'. Expected: ${expectedType}, got: ${typeof argValue}`;
+                }
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Validates if a value matches the expected type
+ *
+ * @param value - The value to validate
+ * @param expectedType - The expected JSON schema type
+ * @returns true if valid, false otherwise
+ */
+function isValidType(value, expectedType) {
+    switch (expectedType) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number';
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'array':
+            return Array.isArray(value);
+        default:
+            return true; // Cannot validate unknown types, so pass by default
+    }
+}

package/dist/server/src/utils/process-tree.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Windows Process Tree Utility Module
+ *
+ * This module provides process tree management utilities specifically for Windows.
+ * It handles the case where shell: true spawns cmd.exe which then spawns
+ * the actual working process (like node.exe, python.exe, etc.).
+ *
+ * On non-Windows platforms, all methods return safe default values
+ * and don't perform any actual operations.
+ */
+/**
+ * Gets all child process IDs for a given parent PID on Windows.
+ *
+ * @param pid - Parent process ID
+ @returns Promise resolving to array of child PID
+ */
+export declare function getChildren(pid: number): Promise<number[]>;
+/**
+ * Gets the entire process tree (all descendants) for a given PID.
+ * Includes the original PID at the beginning of the array.
+ *
+ * @param pid - Root process ID
+ * @returns Array of all process IDs in the tree
+ */
+export declare function getProcessTree(pid: number): Promise<number[]>;
+/**
+ * Checks if any process in the process tree is still running.
+ *
+ * @param pid - Root process ID
+ * @returns True if any process in the tree is running
+ */
+export declare function isAnyInTreeRunning(pid: number): Promise<boolean>;
+/**
+ * Tries to find the actual working process PID in the tree.
+ * This looks for processes that are likely the actual worker
+ * (node.exe, python.exe, etc.) rather than shell processes.
+ *
+ * @param pid - Root process ID
+ * @returns Working process PID if found, undefined otherwise
+ */
+export declare function getWorkingProcessPid(pid: number): Promise<number | undefined>;
+/**
+ * Kills the entire process tree.
+ *
+ * @param pid - Root process ID
+ * @param signal - Signal to send (default: SIGTERM)
+ */
+export declare function killProcessTree(pid: number, signal?: NodeJS.Signals): Promise<void>;
+//# sourceMappingURL=process-tree.d.ts.map

package/dist/server/src/utils/process-tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-tree.d.ts","sourceRoot":"","sources":["../../../../src/utils/process-tree.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBhE;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAqBnE;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAmBtE;AAED;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAkCnF;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,MAAM,CAAC,OAAmB,GACjC,OAAO,CAAC,IAAI,CAAC,CAgCf"}