@smartbear/mcp 0.3.0 → 0.5.0

package/dist/pactflow/client.js

@@ -0,0 +1,180 @@
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
+import { TOOLS } from "./client/tools.js";
+// Tool definitions for PactFlow AI API client
+export class PactflowClient {
+    name = "Contract Testing";
+    prefix = "contract-testing";
+    headers;
+    aiBaseUrl;
+    baseUrl;
+    clientType;
+    constructor(auth, baseUrl, clientType) {
+        // Set headers based on the type of auth provided
+        if (typeof auth === "string") {
+            this.headers = {
+                Authorization: `Bearer ${auth}`,
+                "Content-Type": "application/json",
+                "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+            };
+        }
+        else {
+            const authString = `${auth.username}:${auth.password}`;
+            this.headers = {
+                Authorization: `Basic ${Buffer.from(authString).toString("base64")}`,
+                "Content-Type": "application/json",
+                "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+            };
+        }
+        this.baseUrl = baseUrl;
+        this.aiBaseUrl = `${this.baseUrl}/api/ai`;
+        this.clientType = clientType;
+    }
+    // PactFlow AI client methods
+    /**
+     * Generate new Pact tests based on the provided input.
+     *
+     * @param toolInput The input data for the generation process.
+     * @returns The result of the generation process.
+     * @throws Error if the HTTP request fails or the operation times out.
+     */
+    async generate(toolInput) {
+        // Submit the generation request
+        const response = await fetch(`${this.aiBaseUrl}/generate`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(toolInput),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status} - ${await response.text()}`);
+        }
+        const status_response = await response.json();
+        return await this.pollForCompletion(status_response, "Generation");
+    }
+    /**
+     * Review the provided Pact tests and suggest improvements.
+     *
+     * @param toolInput The input data for the review process.
+     * @returns The result of the review process.
+     * @throws Error if the HTTP request fails or the operation times out.
+     */
+    async review(toolInput) {
+        // Submit review request
+        const response = await fetch(`${this.aiBaseUrl}/review`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(toolInput),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status} - ${await response.text()}`);
+        }
+        const status_response = await response.json();
+        return await this.pollForCompletion(status_response, "Review Pacts");
+    }
+    async getStatus(statusUrl) {
+        const response = await fetch(statusUrl, {
+            method: "HEAD",
+            headers: this.headers,
+        });
+        return {
+            status: response.status,
+            isComplete: response.status === 200,
+        };
+    }
+    async getResult(resultUrl) {
+        const response = await fetch(resultUrl, {
+            method: "GET",
+            headers: this.headers,
+        });
+        // Check if the response is OK (status 200)
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return response.json();
+    }
+    async pollForCompletion(status_response, operationName) {
+        // Polling for completion
+        const startTime = Date.now();
+        const timeout = 120000; // 120 seconds
+        const pollInterval = 1000; // 1 second
+        while (Date.now() - startTime < timeout) {
+            const statusCheck = await this.getStatus(status_response.status_url);
+            if (statusCheck.isComplete) {
+                // Operation is complete, get the result
+                return await this.getResult(status_response.result_url);
+            }
+            if (statusCheck.status !== 202) {
+                throw new Error(`${operationName} failed with status: ${statusCheck.status}`);
+            }
+            // Wait before next poll
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+        throw new Error(`${operationName} timed out after ${timeout / 1000} seconds`);
+    }
+    // PactFlow / Pact_Broker client methods
+    async getProviderStates({ provider }) {
+        const uri_encoded_provider_name = encodeURIComponent(provider);
+        const response = await fetch(`${this.baseUrl}/pacts/provider/${uri_encoded_provider_name}/provider-states`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status} - ${await response.text()}`);
+        }
+        return response.json();
+    }
+    /**
+     * Checks if a given pacticipant version is safe to deploy
+     * to a specified environment.
+     *
+     * @param body - Input containing:
+     *   - `pacticipant`: The name of the service (pacticipant).
+     *   - `version`: The version of the pacticipant being evaluated for deployment.
+     *   - `environment`: The target environment (e.g., staging, production).
+     * @returns CanIDeployResponse containing deployment decision and verification results.
+     * @throws Error if the request fails or returns a non-OK response.
+     */
+    async canIDeploy(body) {
+        const { pacticipant, version, environment } = body;
+        const queryParams = new URLSearchParams({
+            pacticipant,
+            version,
+            environment,
+        });
+        const url = `${this.baseUrl}/can-i-deploy?${queryParams.toString()}`;
+        try {
+            const response = await fetch(url, {
+                method: "GET",
+                headers: this.headers,
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                throw new Error(`Can-I-Deploy Request Failed - status: ${response.status} ${response.statusText}${errorText ? ` - ${errorText}` : ""}`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            console.error("[CanIDeploy] Unexpected error:", error);
+            throw error;
+        }
+    }
+    registerTools(register, _getInput) {
+        for (const tool of TOOLS.filter(t => t.clients.includes(this.clientType))) {
+            const { handler, clients: _, formatResponse, ...toolparams } = tool; // eslint-disable-line @typescript-eslint/no-unused-vars
+            register(toolparams, async (args, _extra) => {
+                const handler_fn = this[handler];
+                if (typeof handler_fn !== "function") {
+                    throw new Error(`Handler '${handler}' not found on PactClient`);
+                }
+                const result = await handler_fn.call(this, args);
+                // Use custom response formatter if provided
+                if (formatResponse) {
+                    return formatResponse(result);
+                }
+                // Default fallback
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            });
+        }
+    }
+}

package/dist/reflect/client.js

@@ -3,6 +3,8 @@ import { z } from "zod";
 // ReflectClient class implementing the Client interface
 export class ReflectClient {
     headers;
+    name = "Reflect";
+    prefix = "reflect";
     constructor(token) {
         this.headers = {
             "X-API-KEY": `${token}`,
@@ -66,14 +68,29 @@ export class ReflectClient {
         });
         return response.json();
     }
-    registerTools(server) {
-        server.tool("list_reflect_suites", "List all reflect suites", {}, async (_args, _extra) => {
+    registerTools(register, _getInput) {
+        register({
+            title: "List Suites",
+            summary: "Retrieve a list of all reflect suites available",
+            parameters: [],
+        }, async (_args, _extra) => {
             const response = await this.listReflectSuites();
             return {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        server.tool("list_reflect_suite_executions", "List all executions for a given reflect suite", { suiteId: z.string().describe("ID of the reflect suite to list executions for") }, async (args, _extra) => {
+        register({
+            title: "List Suite Executions",
+            summary: "List all executions for a given suite",
+            parameters: [
+                {
+                    name: "suiteId",
+                    type: z.string(),
+                    description: "ID of the reflect suite to list executions for",
+                    required: true
+                },
+            ],
+        }, async (args, _extra) => {
             if (!args.suiteId)
                 throw new Error("suiteId argument is required");
             const response = await this.listSuiteExecutions(args.suiteId);
@@ -81,9 +98,23 @@ export class ReflectClient {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        server.tool("reflect_suite_execution_status", "Get the status of a reflect suite execution", {
-            suiteId: z.string().describe("ID of the reflect suite to list executions for"),
-            executionId: z.string().describe("ID of the reflect suite execution to get status for"),
+        register({
+            title: "Get Suite Execution Status",
+            summary: "Get the status of a reflect suite execution",
+            parameters: [
+                {
+                    name: "suiteId",
+                    type: z.string(),
+                    description: "ID of the reflect suite to get execution status for",
+                    required: true
+                },
+                {
+                    name: "executionId",
+                    type: z.string(),
+                    description: "ID of the reflect suite execution to get status for",
+                    required: true
+                },
+            ],
         }, async (args, _extra) => {
             if (!args.suiteId || !args.executionId)
                 throw new Error("Both suiteId and executionId arguments are required");
@@ -92,7 +123,18 @@ export class ReflectClient {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        server.tool("reflect_suite_execution", "Execute a reflect suite", { suiteId: z.string().describe("ID of the reflect suite to list executions for") }, async (args, _extra) => {
+        register({
+            title: "Execute Suite",
+            summary: "Execute a reflect suite",
+            parameters: [
+                {
+                    name: "suiteId",
+                    type: z.string(),
+                    description: "ID of the reflect suite to list executions for",
+                    required: true
+                }
+            ]
+        }, async (args, _extra) => {
             if (!args.suiteId)
                 throw new Error("suiteId argument is required");
             const response = await this.executeSuite(args.suiteId);
@@ -100,9 +142,23 @@ export class ReflectClient {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        server.tool("cancel_reflect_suite_execution", "Cancel a reflect suite execution", {
-            suiteId: z.string().describe("ID of the reflect suite to cancel execution for"),
-            executionId: z.string().describe("ID of the reflect suite execution to cancel"),
+        register({
+            title: "Cancel Suite Execution",
+            summary: "Cancel a reflect suite execution",
+            parameters: [
+                {
+                    name: "suiteId",
+                    type: z.string(),
+                    description: "ID of the reflect suite to cancel execution for",
+                    required: true
+                },
+                {
+                    name: "executionId",
+                    type: z.string(),
+                    description: "ID of the reflect suite execution to cancel",
+                    required: true
+                },
+            ],
         }, async (args, _extra) => {
             if (!args.suiteId || !args.executionId)
                 throw new Error("Both suiteId and executionId arguments are required");
@@ -111,13 +167,28 @@ export class ReflectClient {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        server.tool("list_reflect_tests", "List all reflect tests", {}, async (_args, _extra) => {
+        register({
+            title: "List Tests",
+            summary: "List all reflect tests",
+            parameters: [],
+        }, async (_args, _extra) => {
             const response = await this.listReflectTests();
             return {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        server.tool("run_reflect_test", "Run a reflect test", { testId: z.string().describe("ID of the reflect test to run") }, async (args, _extra) => {
+        register({
+            title: "Run Test",
+            summary: "Run a reflect test",
+            parameters: [
+                {
+                    name: "testId",
+                    type: z.string(),
+                    description: "ID of the reflect test to run",
+                    required: true
+                }
+            ],
+        }, async (args, _extra) => {
             if (!args.testId)
                 throw new Error("testId argument is required");
             const response = await this.runReflectTest(args.testId);
@@ -125,9 +196,23 @@ export class ReflectClient {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
         });
-        server.tool("reflect_test_status", "Get the status of a reflect test execution", {
-            testId: z.string().describe("ID of the reflect test to run"),
-            executionId: z.string().describe("ID of the reflect test execution to get status for"),
+        register({
+            title: "Get Test Status",
+            summary: "Get the status of a reflect test execution",
+            parameters: [
+                {
+                    name: "testId",
+                    type: z.string(),
+                    description: "ID of the reflect test to run",
+                    required: true
+                },
+                {
+                    name: "executionId",
+                    type: z.string(),
+                    description: "ID of the reflect test execution to get status for",
+                    required: true
+                },
+            ],
         }, async (args, _extra) => {
             if (!args.testId || !args.executionId)
                 throw new Error("Both testId and executionId arguments are required");
@@ -137,7 +222,4 @@ export class ReflectClient {
             };
         });
     }
-    registerResources(_server) {
-        // Reflect does not currently support dynamic resources
-    }
 }

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@smartbear/mcp",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "MCP server for interacting SmartBear Products",
   "keywords": [
     "smartbear",
     "mcp",
-    "insight-hub",
+    "bugsnag",
     "reflect",
-    "api-hub"
+    "api-hub",
+    "pactflow"
   ],
   "homepage": "https://developer.smartbear.com/smartbear-mcp",
   "repository": {
@@ -43,10 +44,12 @@
     "@bugsnag/js": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.15.0",
     "node-cache": "^5.1.2",
+    "swagger-client": "^3.35.6",
     "zod": "^3"
   },
   "devDependencies": {
     "@eslint/js": "^9.29.0",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22",
     "@vitest/coverage-v8": "^3.2.4",
     "eslint": "^9.29.0",
@@ -54,6 +57,7 @@
     "shx": "^0.3.4",
     "typescript": "^5.6.2",
     "typescript-eslint": "^8.34.1",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.4",
+    "vitest-fetch-mock": "^0.4.5"
   }
 }

package/dist/common/templates.js

@@ -1,57 +0,0 @@
-export function toolDescriptionTemplate(params) {
-    const { summary, useCases, examples, parameters, hints, outputFormat } = params;
-    let description = summary;
-    // Parameters (essential)
-    if (parameters.length > 0) {
-        description += `\n\n**Parameters:** ${parameters.map(p => `${p.name} (${p.type})${p.required ? ' *required*' : ''}`).join(', ')}`;
-    }
-    if (outputFormat) {
-        description += `\n\n**Output Format:** ${outputFormat}`;
-    }
-    // Use Cases
-    if (useCases.length > 0) {
-        description += `\n\n**Use Cases:** ${useCases.map((uc, i) => `${i + 1}. ${uc}`).join(' ')}`;
-    }
-    // Examples
-    if (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.length > 0) {
-        description += `\n\n**Tips:** ${hints.map((hint, i) => `${i + 1}. ${hint}`).join(' ')}`;
-    }
-    return description.trim();
-}
-// Backward-compatible version of the original function
-export function simpleToolDescriptionTemplate(summary, useCases, examples, hints) {
-    return toolDescriptionTemplate({
-        summary,
-        purpose: summary,
-        useCases,
-        examples: examples.map(example => ({
-            description: example,
-            parameters: {}
-        })),
-        parameters: [],
-        hints
-    });
-}
-// Helper function to create parameter descriptions
-export function createParameter(name, type, required, description, options = {}) {
-    return {
-        name,
-        type,
-        required,
-        description,
-        examples: options.examples,
-        constraints: options.constraints
-    };
-}
-// Helper function to create examples with proper structure
-export function createExample(description, parameters, expectedOutput) {
-    return {
-        description,
-        parameters,
-        expectedOutput
-    };
-}