@smartbear/mcp 0.9.0 → 0.11.0

package/dist/bugsnag/input-schemas.js

@@ -0,0 +1,51 @@
+import z from "zod";
+const filterValueSchema = z.object({
+    type: z.enum(["eq", "ne", "empty"]),
+    value: z.union([z.string(), z.boolean(), z.number()]),
+});
+/**
+ * A collection of input parameter schemas for reuse between tools.
+ * Add new entries when common parameters are identified.
+ */
+export const toolInputParameters = {
+    empty: z.object({}).describe("No parameters are required for this tool"),
+    projectId: z
+        .string()
+        .optional()
+        .describe("ID of the project. This is optional if a current project is set and is used to set the current project for BugSnag tools."),
+    errorId: z.string().describe("Unique identifier of the error"),
+    releaseId: z.string().describe("ID of the release"),
+    buildId: z.string().describe("ID of the build"),
+    direction: z
+        .enum(["asc", "desc"])
+        .describe("Sort direction for ordering results")
+        .default("desc"),
+    filters: z
+        .record(z.array(filterValueSchema))
+        .describe("Apply filters to narrow down the error list. Use the List Project Event Filters tool to discover available filter fields. " +
+        "Time filters support extended ISO 8601 format (e.g. 2018-05-20T00:00:00Z) or relative format (e.g. 7d, 24h).")
+        .default({
+        "event.since": [{ type: "eq", value: "30d" }],
+        "error.status": [{ type: "eq", value: "open" }],
+    }),
+    nextUrl: z
+        .string()
+        .describe("URL for retrieving the next page of results. Use the value in the previous response to get the next page when more results are available. " +
+        "Only values provided in the output from this tool can be used. Do not attempt to construct it manually.")
+        .optional(),
+    page: z.number().describe("Page number to return (starts from 1)").default(1),
+    perPage: z
+        .number()
+        .describe("How many results to return per page.")
+        .min(1)
+        .max(100)
+        .default(30),
+    releaseStage: z
+        .string()
+        .describe("Filter releases by this stage (e.g. production, staging), defaults to 'production'")
+        .default("production"),
+    sort: z
+        .enum(["first_seen", "last_seen", "events", "users", "unsorted"])
+        .describe("Field to sort the errors by")
+        .default("last_seen"),
+};

package/dist/collaborator/client.js

@@ -0,0 +1,377 @@
+import { z } from "zod";
+const ConfigurationSchema = z.object({
+    base_url: z.string().url().describe("Collaborator server base URL"),
+    username: z.string().describe("Collaborator username for authentication"),
+    login_ticket: z
+        .string()
+        .describe("Collaborator login ticket for authentication"),
+});
+export class CollaboratorClient {
+    name = "Collaborator";
+    toolPrefix = "collaborator";
+    configPrefix = "Collaborator";
+    config = ConfigurationSchema;
+    baseUrl;
+    username;
+    loginTicket;
+    async configure(_server, config, _cache) {
+        this.baseUrl = config.base_url;
+        this.username = config.username;
+        this.loginTicket = config.login_ticket;
+        return true;
+    }
+    /**
+     * Calls the Collaborator API with the given commands, prepending authentication automatically.
+     * @param commands Array of Collaborator API commands (excluding authentication)
+     * @returns Raw Collaborator API response
+     */
+    async call(commands) {
+        if (!this.baseUrl || !this.username || !this.loginTicket) {
+            throw new Error("Collaborator client not configured");
+        }
+        const url = `${this.baseUrl}/services/json/v1`;
+        // Always prepend authentication command automatically
+        const body = [
+            {
+                command: "SessionService.authenticate",
+                args: { login: this.username, ticket: this.loginTicket },
+            },
+            ...commands,
+        ];
+        const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`Collaborator API call failed: ${response.status} - ${await response.text()}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Registers the Collaborator API tool with the MCP server. Accepts commands (excluding authentication).
+     */
+    registerTools(register, _getInput) {
+        // findReviewById tool
+        register({
+            title: "Find Collaborator Review By ID",
+            summary: "Finds a review in Collaborator by its review ID.",
+            inputSchema: z.object({
+                reviewId: z.string().describe("The Collaborator review ID to find."),
+            }),
+        }, async (args, _extra) => {
+            const { reviewId } = args;
+            const commands = [
+                {
+                    command: "ReviewService.findReviewById",
+                    args: { reviewId },
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // createReview tool
+        register({
+            title: "Create Collaborator Review",
+            summary: "Creates a new review in Collaborator. All parameters are optional.",
+            inputSchema: z.object({
+                creator: z
+                    .string()
+                    .optional()
+                    .describe("Collaborator username of the review creator. Optional. Default: currently logged in user."),
+                title: z
+                    .string()
+                    .optional()
+                    .describe("Title of the review. Optional. Default: null."),
+                templateName: z
+                    .string()
+                    .optional()
+                    .describe("Review template name. Optional. Default: system default template."),
+                accessPolicy: z
+                    .string()
+                    .optional()
+                    .describe("Access policy for the review. Optional. Default: ANYONE."),
+            }),
+        }, async (args, _extra) => {
+            const commandArgs = {};
+            if (args.creator !== undefined)
+                commandArgs.creator = args.creator;
+            if (args.title !== undefined)
+                commandArgs.title = args.title;
+            if (args.templateName !== undefined)
+                commandArgs.templateName = args.templateName;
+            if (args.accessPolicy !== undefined)
+                commandArgs.accessPolicy = args.accessPolicy;
+            const commands = [
+                {
+                    command: "ReviewService.createReview",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // rejectReview tool
+        register({
+            title: "Reject Collaborator Review",
+            summary: "Rejects a review in Collaborator by its review ID and reason.",
+            inputSchema: z.object({
+                reviewId: z
+                    .union([z.string(), z.number()])
+                    .describe("The Collaborator review ID to reject."),
+                reason: z.string().describe("Reason for rejecting the review."),
+            }),
+        }, async (args, _extra) => {
+            const { reviewId, reason } = args;
+            const commands = [
+                {
+                    command: "ReviewService.reject",
+                    args: {
+                        reviewId,
+                        reason,
+                    },
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        register({
+            title: "ReviewService Action",
+            summary: "Invoke any ReviewService method by name and arguments. For finishReviewPhase and waitOnPhase, provide reviewId (required) and until (optional, defaults to 'ANY').",
+            inputSchema: z.object({
+                action: z.enum([
+                    "moveReviewToAnnotatePhase",
+                    "cancel",
+                    "reopen",
+                    "uncancel",
+                ]),
+                args: z.record(z.any()),
+            }),
+        }, async (params, _extra) => {
+            const { action, args } = params;
+            const commands = [{ command: `ReviewService.${action}`, args }];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // getReviews tool
+        register({
+            title: "Get Collaborator Reviews",
+            summary: "Retrieves reviews from Collaborator using ReviewService.getReviews. All parameters are optional and only provided ones are sent.",
+            inputSchema: z.object({
+                login: z
+                    .string()
+                    .optional()
+                    .describe("Collaborator username to filter reviews."),
+                role: z
+                    .string()
+                    .optional()
+                    .describe("Role to filter reviews (e.g., AUTHOR)."),
+                creator: z
+                    .boolean()
+                    .optional()
+                    .describe("Whether to filter by creator."),
+                reviewPhase: z
+                    .string()
+                    .optional()
+                    .describe("Review phase to filter (e.g., PLANNING)."),
+                fullInfo: z
+                    .boolean()
+                    .optional()
+                    .describe("Whether to retrieve full review info."),
+                fromDate: z
+                    .string()
+                    .optional()
+                    .describe('Minimal creation date in format "yyyy-MM-dd"'),
+                toDate: z
+                    .string()
+                    .optional()
+                    .describe('Maximal creation date in format "yyyy-MM-dd"'),
+            }),
+        }, async (args, _extra) => {
+            const reviewArgs = {};
+            if (args.login !== undefined)
+                reviewArgs.login = args.login;
+            if (args.role !== undefined)
+                reviewArgs.role = args.role;
+            if (args.creator !== undefined)
+                reviewArgs.creator = args.creator;
+            if (args.reviewPhase !== undefined)
+                reviewArgs.reviewPhase = args.reviewPhase;
+            if (args.fullInfo !== undefined)
+                reviewArgs.fullInfo = args.fullInfo;
+            if (args.fromDate !== undefined)
+                reviewArgs.fromDate = args.fromDate;
+            if (args.toDate !== undefined)
+                reviewArgs.toDate = args.toDate;
+            const commands = [
+                {
+                    command: "ReviewService.getReviews",
+                    args: reviewArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // createIntegration tool
+        register({
+            title: "Create Collaborator Remote System Configuration",
+            summary: "Creates a remote system configuration in Collaborator (e.g., Bitbucket, GitHub, etc).",
+            inputSchema: z.object({
+                token: z
+                    .string()
+                    .describe("Remote system token, e.g., BITBUCKET, GITHUB, etc."),
+                title: z.string().describe("Remote system title."),
+                config: z
+                    .string()
+                    .describe("JSON string containing configuration parameters for the remote system."),
+                reviewTemplateId: z
+                    .string()
+                    .optional()
+                    .describe("Optional review template ID used by this remote system."),
+            }),
+        }, async (args, _extra) => {
+            const { token, title, config, reviewTemplateId } = args;
+            const commandArgs = { token, title, config };
+            if (reviewTemplateId)
+                commandArgs.reviewTemplateId = reviewTemplateId;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.createIntegration",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // editIntegration tool
+        register({
+            title: "Edit Collaborator Remote System Configuration",
+            summary: "Edits parameters of an existing remote system configuration in Collaborator. Only title and config are editable after creation.",
+            inputSchema: z.object({
+                id: z
+                    .string()
+                    .describe("ID of the remote system Configuration to edit."),
+                title: z.string().optional().describe("Remote system title."),
+                config: z
+                    .string()
+                    .optional()
+                    .describe("JSON string containing configuration parameters for the remote system."),
+                reviewTemplateId: z
+                    .string()
+                    .optional()
+                    .describe("Optional review template ID used by this remote system."),
+            }),
+        }, async (args, _extra) => {
+            const { id, title, config, reviewTemplateId } = args;
+            const commandArgs = { id };
+            if (title)
+                commandArgs.title = title;
+            if (config)
+                commandArgs.config = config;
+            if (reviewTemplateId)
+                commandArgs.reviewTemplateId = reviewTemplateId;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.editIntegration",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // deleteIntegration tool
+        register({
+            title: "Delete Collaborator Remote System Configuration",
+            summary: "Deletes a remote system configuration in Collaborator by its ID.",
+            inputSchema: z.object({
+                id: z
+                    .union([z.string(), z.number()])
+                    .describe("ID of the remote system Configuration to delete."),
+            }),
+        }, async (args, _extra) => {
+            const commandArgs = {};
+            if (args.id !== undefined)
+                commandArgs.id =
+                    typeof args.id === "string" && !Number.isNaN(Number(args.id))
+                        ? Number(args.id)
+                        : args.id;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.deleteIntegration",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        register({
+            title: "Update Collaborator Remote System Configuration Webhook",
+            summary: "Updates the webhook for a remote system configuration in Collaborator by its ID.",
+            inputSchema: z.object({
+                id: z
+                    .union([z.string(), z.number()])
+                    .describe("ID of the remote system Configuration to update the webhook for."),
+            }),
+        }, async (args, _extra) => {
+            const commandArgs = {};
+            if (args.id !== undefined)
+                commandArgs.id =
+                    typeof args.id === "string" && !Number.isNaN(Number(args.id))
+                        ? Number(args.id)
+                        : args.id;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.updateWebhook",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+        // Test connection tool
+        register({
+            title: "Test Collaborator Remote System Configuration Connection",
+            summary: "Tests the connection for a remote system configuration in Collaborator by its ID.",
+            inputSchema: z.object({
+                id: z
+                    .union([z.string(), z.number()])
+                    .describe("ID of the remote system Configuration to test connection for."),
+            }),
+        }, async (args, _extra) => {
+            const commandArgs = {};
+            if (args.id !== undefined)
+                commandArgs.id =
+                    typeof args.id === "string" && !Number.isNaN(Number(args.id))
+                        ? Number(args.id)
+                        : args.id;
+            const commands = [
+                {
+                    command: "AdminRemoteSystemService.testConnection",
+                    args: commandArgs,
+                },
+            ];
+            const result = await this.call(commands);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        });
+    }
+}

package/dist/common/cache.js

@@ -0,0 +1,63 @@
+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;
+    }
+    /**
+     * Get a value from the cache
+     */
+    get(key) {
+        if (!this.enabled || !this.cache) {
+            return undefined;
+        }
+        return this.cache.get(key);
+    }
+    /**
+     * Set a value in the cache
+     */
+    set(key, value) {
+        if (!this.enabled || !this.cache) {
+            return false;
+        }
+        return this.cache.set(key, value);
+    }
+    /**
+     * 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();
+        }
+    }
+}

package/dist/common/client-registry.js

@@ -0,0 +1,128 @@
+import { ZodOptional, ZodString } from "zod";
+/**
+ * Central registry for all MCP clients
+ * Add new clients here to make them automatically available
+ */
+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));
+    }
+    /**
+     * 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());
+    }
+    /**
+     * 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`);
+                }
+            }
+        }
+    }
+    /**
+     * 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++;
+            }
+        }
+        return configuredCount;
+    }
+    /**
+     * Clear all registrations (useful for testing)
+     */
+    clear() {
+        this.entries = [];
+    }
+}
+// Create and export the singleton registry
+export const clientRegistry = new ClientRegistry();

package/dist/common/register-clients.js

@@ -0,0 +1,31 @@
+/**
+ * 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";
+import { QmetryClient } from "../qmetry/client.js";
+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());