@smartbear/mcp 0.3.0 → 0.4.0

package/dist/common/server.js

@@ -0,0 +1,145 @@
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ZodAny, ZodArray, ZodBoolean, ZodEnum, ZodLiteral, ZodNumber, ZodObject, ZodString, ZodUnion, } from "zod";
+import Bugsnag from "../common/bugsnag.js";
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "./info.js";
+export class SmartBearMcpServer extends McpServer {
+    constructor() {
+        super({
+            name: MCP_SERVER_NAME,
+            version: MCP_SERVER_VERSION,
+        }, {
+            capabilities: {
+                resources: { listChanged: true }, // Server supports dynamic resource lists
+                tools: { listChanged: true }, // Server supports dynamic tool lists
+            },
+        });
+    }
+    addClient(client) {
+        client.registerTools((params, cb) => {
+            const toolName = `${client.prefix}_${params.title.replace(/\s+/g, "_").toLowerCase()}`;
+            const toolTitle = `${client.name}: ${params.title}`;
+            return super.registerTool(toolName, {
+                title: toolTitle,
+                description: this.getDescription(params),
+                inputSchema: this.getInputSchema(params),
+                annotations: this.getAnnotations(toolTitle, params),
+            }, async (args, extra) => {
+                try {
+                    return await cb(args, extra);
+                }
+                catch (e) {
+                    Bugsnag.notify(e);
+                    throw e;
+                }
+            });
+        }, (params, options) => {
+            return this.server.elicitInput(params, options);
+        });
+        if (client.registerResources) {
+            client.registerResources((name, path, cb) => {
+                return super.registerResource(name, new ResourceTemplate(`${client.prefix}://${name}/${path}`, { list: undefined }), {}, async (url, variables, extra) => {
+                    try {
+                        return await cb(url, variables, extra);
+                    }
+                    catch (e) {
+                        Bugsnag.notify(e);
+                        throw e;
+                    }
+                });
+            });
+        }
+    }
+    getAnnotations(toolTitle, params) {
+        const annotations = {
+            title: toolTitle,
+            readOnlyHint: params.readOnly ?? true,
+            destructiveHint: params.destructive ?? false,
+            idempotentHint: params.idempotent ?? true,
+            openWorldHint: params.openWorld ?? false,
+        };
+        return annotations;
+    }
+    getInputSchema(params) {
+        const args = {};
+        for (const param of params.parameters ?? []) {
+            args[param.name] = param.type;
+            if (param.description) {
+                args[param.name] = args[param.name].describe(param.description);
+            }
+            if (!param.required) {
+                args[param.name] = args[param.name].optional();
+            }
+        }
+        if (params.zodSchema && params.zodSchema instanceof ZodObject) {
+            for (const key of Object.keys(params.zodSchema.shape)) {
+                const field = params.zodSchema.shape[key];
+                args[key] = field;
+                if (field.description) {
+                    args[key] = args[key].describe(field.description);
+                }
+                if (field.isOptional()) {
+                    args[key] = args[key].optional();
+                }
+            }
+        }
+        return args;
+    }
+    getDescription(params) {
+        const { summary, useCases, examples, parameters, zodSchema, hints, outputFormat } = params;
+        let description = summary;
+        // Parameters if available otherwise use zodSchema
+        if ((parameters ?? []).length > 0) {
+            description += `\n\n**Parameters:**\n${parameters?.map(p => `- ${p.name} (${this.getReadableTypeName(p.type)})${p.required ? ' *required*' : ''}` +
+                `${p.description ? `: ${p.description}` : ''}` +
+                `${p.examples ? ` (e.g. ${p.examples.join(', ')})` : ''}` +
+                `${p.constraints ? `\n  - ${p.constraints.join('\n  - ')}` : ''}`).join('\n')}`;
+        }
+        if (zodSchema && zodSchema instanceof ZodObject) {
+            description += "\n\n**Parameters:**\n";
+            for (const key of Object.keys(zodSchema.shape)) {
+                const field = zodSchema.shape[key];
+                description += this.formatParameterDescription(key, field);
+            }
+        }
+        if (outputFormat) {
+            description += `\n\n**Output Format:** ${outputFormat}`;
+        }
+        // Use Cases
+        if (useCases && useCases.length > 0) {
+            description += `\n\n**Use Cases:** ${useCases.map((uc, i) => `${i + 1}. ${uc}`).join(' ')}`;
+        }
+        // Examples
+        if (examples && examples.length > 0) {
+            description += `\n\n**Examples:**\n` + examples.map((ex, idx) => `${idx + 1}. ${ex.description}\n\`\`\`json\n${JSON.stringify(ex.parameters, null, 2)}\n\`\`\`${ex.expectedOutput ? `\nExpected Output: ${ex.expectedOutput}` : ''}`).join('\n\n');
+        }
+        // Hints
+        if (hints && hints.length > 0) {
+            description += `\n\n**Hints:** ${hints.map((hint, i) => `${i + 1}. ${hint}`).join(' ')}`;
+        }
+        return description.trim();
+    }
+    formatParameterDescription(key, field) {
+        return `- ${key} (${this.getReadableTypeName(field)})${field.isOptional() ? '' : ' *required*'}${field.description ? `: ${field.description}` : ''}${key === "examples" && field instanceof ZodEnum ? ` (e.g. ${Object.keys(field.enum).join(', ')})` : ''}${key === "constraints" && field instanceof ZodEnum ? `\n  - ${Object.keys(field.enum).join('\n  - ')}` : ''} \n`;
+    }
+    getReadableTypeName(zodType) {
+        if (zodType instanceof ZodString)
+            return 'string';
+        if (zodType instanceof ZodNumber)
+            return 'number';
+        if (zodType instanceof ZodBoolean)
+            return 'boolean';
+        if (zodType instanceof ZodArray)
+            return 'array';
+        if (zodType instanceof ZodObject)
+            return 'object';
+        if (zodType instanceof ZodEnum)
+            return 'enum';
+        if (zodType instanceof ZodLiteral)
+            return 'literal';
+        if (zodType instanceof ZodUnion)
+            return 'union';
+        if (zodType instanceof ZodAny)
+            return 'any';
+        return 'any';
+    }
+}

package/dist/index.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import Bugsnag from "./common/bugsnag.js";
-import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "./common/info.js";
 import { InsightHubClient } from "./insight-hub/client.js";
 import { ReflectClient } from "./reflect/client.js";
 import { ApiHubClient } from "./api-hub/client.js";
+import { SmartBearMcpServer } from "./common/server.js";
+import { PactflowClient } from "./pactflow/client.js";
 // This is used to report errors in the MCP server itself
 // If you want to use your own BugSnag API key, set the MCP_SERVER_INSIGHT_HUB_API_KEY environment variable
 const McpServerBugsnagAPIKey = process.env.MCP_SERVER_INSIGHT_HUB_API_KEY;
@@ -13,36 +13,45 @@ if (McpServerBugsnagAPIKey) {
     Bugsnag.start(McpServerBugsnagAPIKey);
 }
 async function main() {
-    const server = new McpServer({
-        name: MCP_SERVER_NAME,
-        version: MCP_SERVER_VERSION,
-    }, {
-        capabilities: {
-            resources: { listChanged: true }, // Server supports dynamic resource lists
-            tools: { listChanged: true }, // Server supports dynamic tool lists
-        },
-    });
+    const server = new SmartBearMcpServer();
     const reflectToken = process.env.REFLECT_API_TOKEN;
     const insightHubToken = process.env.INSIGHT_HUB_AUTH_TOKEN;
     const apiHubToken = process.env.API_HUB_API_KEY;
-    if (!reflectToken && !insightHubToken && !apiHubToken) {
-        console.error("Please set one of REFLECT_API_TOKEN, INSIGHT_HUB_AUTH_TOKEN or API_HUB_API_KEY environment variables");
-        process.exit(1);
-    }
+    const pactBrokerToken = process.env.PACT_BROKER_TOKEN;
+    const pactBrokerUrl = process.env.PACT_BROKER_BASE_URL;
+    const pactBrokerUsername = process.env.PACT_BROKER_USERNAME;
+    const pactBrokerPassword = process.env.PACT_BROKER_PASSWORD;
+    let client_defined = false;
     if (reflectToken) {
-        const reflectClient = new ReflectClient(reflectToken);
-        reflectClient.registerTools(server);
-        reflectClient.registerResources(server);
+        server.addClient(new ReflectClient(reflectToken));
+        client_defined = true;
     }
     if (insightHubToken) {
         const insightHubClient = new InsightHubClient(insightHubToken, process.env.INSIGHT_HUB_PROJECT_API_KEY, process.env.INSIGHT_HUB_ENDPOINT);
         await insightHubClient.initialize();
-        insightHubClient.registerTools(server);
-        insightHubClient.registerResources(server);
+        server.addClient(insightHubClient);
+        client_defined = true;
     }
     if (apiHubToken) {
-        const apiHubClient = new ApiHubClient(apiHubToken);
-        apiHubClient.registerTools(server);
+        server.addClient(new ApiHubClient(apiHubToken));
+        client_defined = true;
+    }
+    if (pactBrokerUrl) {
+        if (pactBrokerToken) {
+            server.addClient(new PactflowClient(pactBrokerToken, pactBrokerUrl, "pactflow"));
+            client_defined = true;
+        }
+        else if (pactBrokerUsername && pactBrokerPassword) {
+            server.addClient(new PactflowClient({ username: pactBrokerUsername, password: pactBrokerPassword }, pactBrokerUrl, "pact_broker"));
+            client_defined = true;
+        }
+        else {
+            console.error("If the Pact Broker base URL is specified, you must specify either (a) a PactFlow token, or (b) a Pact Broker username and password pair.");
+        }
+    }
+    if (!client_defined) {
+        console.error("Please set one of REFLECT_API_TOKEN, INSIGHT_HUB_AUTH_TOKEN, API_HUB_API_KEY or PACT_BROKER_BASE_URL / (and relevant Pact auth) environment variables");
+        process.exit(1);
     }
     const transport = new StdioServerTransport();
     await server.connect(transport);