@smartbear/mcp 0.12.1 → 0.13.1

package/dist/common/bugsnag.js

@@ -1,3 +1,5 @@
-// workaround for a known issue with Bugsnag types in node16 modules: https://github.com/bugsnag/bugsnag-js/issues/2052
-import * as Bugsnag from "@bugsnag/js";
-export default Bugsnag.default;
+import * as Bugsnag$1 from "@bugsnag/js";
+const Bugsnag = Bugsnag$1.default;
+export {
+  Bugsnag as default
+};

package/dist/common/cache.js

@@ -1,63 +1,56 @@
 import NodeCache from "node-cache";
-/**
- * Common cache service that can be shared across all clients.
- * Wraps NodeCache and provides a way to disable caching entirely.
- * Reads CACHE_ENABLED and CACHE_TTL environment variables for configuration.
- */
-export class CacheService {
-    cache;
-    enabled;
-    constructor() {
-        // Read configuration from environment variables
-        this.enabled = process.env.CACHE_ENABLED !== "false";
-        const ttl = process.env.CACHE_TTL
-            ? Number.parseInt(process.env.CACHE_TTL, 10)
-            : 86400; // Default 24 hours
-        this.cache = this.enabled
-            ? new NodeCache({
-                stdTTL: ttl,
-            })
-            : null;
+class CacheService {
+  cache;
+  enabled;
+  constructor() {
+    this.enabled = process.env.CACHE_ENABLED !== "false";
+    const ttl = process.env.CACHE_TTL ? Number.parseInt(process.env.CACHE_TTL, 10) : 86400;
+    this.cache = this.enabled ? new NodeCache({
+      stdTTL: ttl
+    }) : null;
+  }
+  /**
+   * Get a value from the cache
+   */
+  get(key) {
+    if (!this.enabled || !this.cache) {
+      return void 0;
     }
-    /**
-     * Get a value from the cache
-     */
-    get(key) {
-        if (!this.enabled || !this.cache) {
-            return undefined;
-        }
-        return this.cache.get(key);
+    return this.cache.get(key);
+  }
+  /**
+   * Set a value in the cache
+   */
+  set(key, value) {
+    if (!this.enabled || !this.cache) {
+      return false;
     }
-    /**
-     * Set a value in the cache
-     */
-    set(key, value) {
-        if (!this.enabled || !this.cache) {
-            return false;
-        }
-        return this.cache.set(key, value);
+    return this.cache.set(key, value);
+  }
+  /**
+   * Delete a value from the cache
+   */
+  del(key) {
+    if (!this.enabled || !this.cache) {
+      return 0;
     }
-    /**
-     * Delete a value from the cache
-     */
-    del(key) {
-        if (!this.enabled || !this.cache) {
-            return 0;
-        }
-        return this.cache.del(key);
-    }
-    /**
-     * Check if caching is enabled
-     */
-    isEnabled() {
-        return this.enabled;
-    }
-    /**
-     * Clear all cache entries
-     */
-    flushAll() {
-        if (this.enabled && this.cache) {
-            this.cache.flushAll();
-        }
+    return this.cache.del(key);
+  }
+  /**
+   * Check if caching is enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Clear all cache entries
+   */
+  flushAll() {
+    if (this.enabled && this.cache) {
+      this.cache.flushAll();
     }
+  }
 }
+export {
+  CacheService
+};

package/dist/common/client-registry.js

@@ -1,128 +1,115 @@
-import { ZodOptional, ZodString } from "zod";
-/**
- * Central registry for all MCP clients
- * Add new clients here to make them automatically available
- */
+import { ZodURL } from "zod";
+import { unwrapZodType, isOptionalType } from "./zod-utils.js";
 class ClientRegistry {
-    entries = [];
-    enabledClients = null;
-    /**
-     * Configure which clients should be enabled based on MCP_CLIENTS env var
-     * If not set or empty, all clients are enabled
-     * If set, should be comma-separated list of client names (case-insensitive)
-     */
-    constructor() {
-        const enabledClientsEnv = process.env.MCP_CLIENTS?.trim();
-        if (!enabledClientsEnv) {
-            // Empty or not set = all clients enabled
-            this.enabledClients = null;
-            return;
-        }
-        // Parse comma-separated list and normalize to lowercase for comparison
-        this.enabledClients = new Set(enabledClientsEnv
-            .split(",")
-            .map((name) => name.trim().toLowerCase())
-            .filter((name) => name.length > 0));
+  entries = [];
+  enabledClients = null;
+  /**
+   * Configure which clients should be enabled based on MCP_CLIENTS env var
+   * If not set or empty, all clients are enabled
+   * If set, should be comma-separated list of client names (case-insensitive)
+   */
+  constructor() {
+    const enabledClientsEnv = process.env.MCP_CLIENTS?.trim();
+    if (!enabledClientsEnv) {
+      this.enabledClients = null;
+      return;
     }
-    /**
-     * Check if a client is enabled based on MCP_CLIENTS configuration
-     */
-    isClientEnabled(name) {
-        if (this.enabledClients === null) {
-            return true; // All clients enabled
-        }
-        return this.enabledClients.has(name.toLowerCase());
+    this.enabledClients = new Set(
+      enabledClientsEnv.split(",").map((name) => name.trim().toLowerCase()).filter((name) => name.length > 0)
+    );
+  }
+  /**
+   * Check if a client is enabled based on MCP_CLIENTS configuration
+   */
+  isClientEnabled(name) {
+    if (this.enabledClients === null) {
+      return true;
     }
-    /**
-     * Validate if a config option is an Allowed Endpoint URL
-     * Supports both exact matches and regex patterns
-     * Patterns starting with / and ending with / are treated as regex
-     * @param zodType The Zod type definition for the config option
-     * @param value The actual config value to validate
-     */
-    validateAllowedEndpoint(zodType, value) {
-        if (zodType instanceof ZodOptional) {
-            zodType = zodType._def.innerType;
-        }
-        if (zodType instanceof ZodString) {
-            if (zodType.isURL) {
-                const allowedEndpoints = process.env.MCP_ALLOWED_ENDPOINTS?.split(",");
-                if (allowedEndpoints) {
-                    for (const endpoint of allowedEndpoints) {
-                        const trimmedEndpoint = endpoint.trim();
-                        // Check if this is a regex pattern (wrapped in /)
-                        if (trimmedEndpoint.startsWith("/") &&
-                            trimmedEndpoint.endsWith("/")) {
-                            try {
-                                const pattern = trimmedEndpoint.slice(1, -1); // Remove leading/trailing /
-                                const regex = new RegExp(pattern);
-                                if (regex.test(value)) {
-                                    return;
-                                }
-                            }
-                            catch (error) {
-                                console.warn(`Invalid regex pattern in MCP_ALLOWED_ENDPOINTS: ${trimmedEndpoint}, error: ${error}`);
-                            }
-                        }
-                        else {
-                            // Exact match
-                            if (value === trimmedEndpoint) {
-                                return;
-                            }
-                        }
-                    }
-                    throw new Error(`URL ${value} is not allowed`);
-                }
+    return this.enabledClients.has(name.toLowerCase());
+  }
+  /**
+   * Validate if a config option is an Allowed Endpoint URL
+   * Supports both exact matches and regex patterns
+   * Patterns starting with / and ending with / are treated as regex
+   * @param zodType The Zod type definition for the config option
+   * @param value The actual config value to validate
+   */
+  validateAllowedEndpoint(zodType, value) {
+    if (unwrapZodType(zodType) instanceof ZodURL) {
+      const allowedEndpoints = process.env.MCP_ALLOWED_ENDPOINTS?.split(",");
+      if (allowedEndpoints) {
+        for (const endpoint of allowedEndpoints) {
+          const trimmedEndpoint = endpoint.trim();
+          if (trimmedEndpoint.startsWith("/") && trimmedEndpoint.endsWith("/")) {
+            try {
+              const pattern = trimmedEndpoint.slice(1, -1);
+              const regex = new RegExp(pattern);
+              if (regex.test(value)) {
+                return;
+              }
+            } catch (error) {
+              console.warn(
+                `Invalid regex pattern in MCP_ALLOWED_ENDPOINTS: ${trimmedEndpoint}, error: ${error}`
+              );
             }
-        }
-    }
-    /**
-     * Register a client class
-     * @param name Display name for the client (for logging)
-     */
-    register(client) {
-        this.entries.push(client);
-    }
-    /**
-     * Get all registered clients (filtered by MCP_CLIENTS if configured)
-     */
-    getAll() {
-        return this.entries.filter((entry) => this.isClientEnabled(entry.name));
-    }
-    /**
-     * Configures all enabled clients on the given MCP server
-     * @param server The MCP server on which the client is registered
-     * @param getConfigValue A function that obtains a configuration value for the given client and requirement name
-     * @returns The number of clients successfully configured
-     */
-    async configure(server, getConfigValue) {
-        let configuredCount = 0;
-        entryLoop: for (const entry of this.getAll()) {
-            const config = {};
-            for (const configKey of Object.keys(entry.config.shape)) {
-                const value = getConfigValue(entry, configKey);
-                if (value !== null) {
-                    // validate if a config option is an Allowed Endpoint URL
-                    this.validateAllowedEndpoint(entry.config.shape[configKey], value);
-                    config[configKey] = value;
-                }
-                else if (!entry.config.shape[configKey].isOptional()) {
-                    continue entryLoop; // Skip configuring this client - missing required config
-                }
-            }
-            if (await entry.configure(server, config)) {
-                server.addClient(entry);
-                configuredCount++;
+          } else {
+            if (value === trimmedEndpoint) {
+              return;
             }
+          }
         }
-        return configuredCount;
+        throw new Error(`URL ${value} is not allowed`);
+      }
     }
-    /**
-     * Clear all registrations (useful for testing)
-     */
-    clear() {
-        this.entries = [];
+  }
+  /**
+   * Register a client class
+   * @param name Display name for the client (for logging)
+   */
+  register(client) {
+    this.entries.push(client);
+  }
+  /**
+   * Get all registered clients (filtered by MCP_CLIENTS if configured)
+   */
+  getAll() {
+    return this.entries.filter((entry) => this.isClientEnabled(entry.name));
+  }
+  /**
+   * Configures all enabled clients on the given MCP server
+   * @param server The MCP server on which the client is registered
+   * @param getConfigValue A function that obtains a configuration value for the given client and requirement name
+   * @returns The number of clients successfully configured
+   */
+  async configure(server, getConfigValue) {
+    let configuredCount = 0;
+    entryLoop: for (const entry of this.getAll()) {
+      const config = {};
+      for (const configKey of Object.keys(entry.config.shape)) {
+        const value = getConfigValue(entry, configKey);
+        if (value !== null) {
+          this.validateAllowedEndpoint(entry.config.shape[configKey], value);
+          config[configKey] = value;
+        } else if (!isOptionalType(entry.config.shape[configKey])) {
+          continue entryLoop;
+        }
+      }
+      await entry.configure(server, config);
+      if (entry.isConfigured()) {
+        await server.addClient(entry);
+        configuredCount++;
+      }
     }
+    return configuredCount;
+  }
+  /**
+   * Clear all registrations (useful for testing)
+   */
+  clear() {
+    this.entries = [];
+  }
 }
-// Create and export the singleton registry
-export const clientRegistry = new ClientRegistry();
+const clientRegistry = new ClientRegistry();
+export {
+  clientRegistry
+};

package/dist/common/info.js

@@ -1,3 +1,7 @@
-import packageJson from "../../package.json" with { type: "json" };
-export const MCP_SERVER_NAME = packageJson.config.mcpServerName;
-export const MCP_SERVER_VERSION = packageJson.version;
+import packageJson from "../package.json.js";
+const MCP_SERVER_NAME = packageJson.config.mcpServerName;
+const MCP_SERVER_VERSION = packageJson.version;
+export {
+  MCP_SERVER_NAME,
+  MCP_SERVER_VERSION
+};

package/dist/common/register-clients.js

@@ -1,12 +1,3 @@
-/**
- * Client registration module
- *
- * This file registers all available MCP clients with the client registry.
- * To add a new client:
- * 1. Import the client class
- * 2. Call clientRegistry.register() with the client details
- * 3. Specify if the client needs the MCP server instance or async initialization
- */
 import { BugsnagClient } from "../bugsnag/client.js";
 import { CollaboratorClient } from "../collaborator/client.js";
 import { PactflowClient } from "../pactflow/client.js";
@@ -15,17 +6,10 @@ import { ReflectClient } from "../reflect/client.js";
 import { SwaggerClient } from "../swagger/client.js";
 import { ZephyrClient } from "../zephyr/client.js";
 import { clientRegistry } from "./client-registry.js";
-// Register Reflect client
 clientRegistry.register(new ReflectClient());
-// Register Bugsnag client
 clientRegistry.register(new BugsnagClient());
-// Register Swagger client
 clientRegistry.register(new SwaggerClient());
-// Register PactFlow/Pact Broker client
 clientRegistry.register(new PactflowClient());
-// Register QMetry client
 clientRegistry.register(new QmetryClient());
-// Register Zephyr client
 clientRegistry.register(new ZephyrClient());
-// Register Collaborator client
 clientRegistry.register(new CollaboratorClient());