@smartbear/mcp 0.2.2 → 0.4.0

package/dist/package.json

@@ -1,13 +1,14 @@
 {
     "name": "@smartbear/mcp",
-    "version": "0.2.2",
+    "version": "0.4.0",
     "description": "MCP server for interacting SmartBear Products",
     "keywords": [
         "smartbear",
         "mcp",
         "insight-hub",
         "reflect",
-        "api-hub"
+        "api-hub",
+        "pactflow"
     ],
     "homepage": "https://developer.smartbear.com/smartbear-mcp",
     "repository": {
@@ -31,20 +32,29 @@
         "build": "tsc && shx chmod +x dist/*.js",
         "lint": "eslint . --ext .ts",
         "prepare": "npm run build",
-        "watch": "tsc --watch"
+        "watch": "tsc --watch",
+        "test": "vitest",
+        "test:watch": "vitest --watch",
+        "test:coverage": "vitest --coverage",
+        "test:coverage:ci": "vitest --coverage --reporter=verbose",
+        "test:run": "vitest run",
+        "coverage:check": "vitest --coverage --reporter=verbose --config vitest.config.coverage.ts"
     },
     "dependencies": {
         "@bugsnag/js": "^8.2.0",
         "@modelcontextprotocol/sdk": "^1.15.0",
-        "node-cache": "^5.1.2"
+        "node-cache": "^5.1.2",
+        "zod": "^3"
     },
     "devDependencies": {
         "@eslint/js": "^9.29.0",
         "@types/node": "^22",
+        "@vitest/coverage-v8": "^3.2.4",
         "eslint": "^9.29.0",
         "globals": "^16.2.0",
         "shx": "^0.3.4",
         "typescript": "^5.6.2",
-        "typescript-eslint": "^8.34.1"
+        "typescript-eslint": "^8.34.1",
+        "vitest": "^3.2.4"
     }
 }

package/dist/pactflow/client/ai.js

@@ -0,0 +1,127 @@
+import { z } from "zod";
+// Type definitions for PactFlow AI API
+export const GenerationLanguages = [
+    "javascript",
+    "typescript",
+    "java",
+    "golang",
+    "dotnet",
+    "kotlin",
+    "swift",
+    "php",
+];
+export const HttpMethods = [
+    "GET",
+    "PUT",
+    "POST",
+    "DELETE",
+    "OPTIONS",
+    "HEAD",
+    "PATCH",
+    "TRACE",
+];
+// zod schemas
+export const FileInputSchema = z.object({
+    filename: z
+        .string()
+        .optional()
+        .describe("Filename (helps identify file type and context)"),
+    language: z
+        .string()
+        .optional()
+        .describe("Programming language (e.g., 'javascript', 'java', 'python') for better analysis"),
+    body: z
+        .string()
+        .describe("Complete file contents - client code, models, test files, etc."),
+});
+export const OpenAPISchema = z
+    .object({
+    openapi: z
+        .string()
+        .optional()
+        .describe("For OpenAPI version (e.g., '3.0.0')"),
+    swagger: z
+        .string()
+        .describe("For OpenAPI documents version 2.x (e.g., '2.0')")
+        .optional(),
+    paths: z
+        .record(z.string(), z.record(z.string(), z.any()))
+        .describe("OpenAPI paths object containing all API endpoints"),
+    components: z
+        .record(z.string(), z.record(z.string(), z.any()))
+        .optional()
+        .describe("OpenAPI components section (schemas, responses, etc.)"),
+})
+    .passthrough()
+    .describe("The complete OpenAPI document describing the API")
+    .refine((data) => data.openapi || data.swagger, {
+    message: "Either 'openapi' (for v3+) or 'swagger' (for v2) must be provided",
+    path: ["openapi"],
+})
+    .optional();
+export const EndpointMatcherSchema = z
+    .object({
+    path: z
+        .string()
+        .optional()
+        .describe("Path pattern to match specific endpoints (e.g., '/users/{id}', '/users/*', '/users/**'). Supports glob patterns: ? (single char), * (excluding /), ** (including /)"),
+    methods: z
+        .array(z.enum(HttpMethods))
+        .optional()
+        .describe("HTTP methods to include (e.g., ['GET', 'POST']). If not specified, all methods are matched"),
+    statusCodes: z
+        .array(z.union([z.number(), z.string()]))
+        .optional()
+        .describe("Response status codes to include (e.g., [200, '2XX', 404]). Use 'X' as wildcard (e.g., '2XX' for 200-299). Defaults to successful codes (2XX)"),
+    operationId: z
+        .string()
+        .optional()
+        .describe("OpenAPI operation ID to match (e.g., 'getUserById', 'get*'). Supports glob patterns"),
+})
+    .required()
+    .describe("REQUIRED: Matcher to specify which endpoints from the OpenAPI document to generate tests for. At least one matcher field must be provided");
+export const OpenAPIWithMatcherSchema = z
+    .object({
+    document: OpenAPISchema,
+    matcher: EndpointMatcherSchema,
+})
+    .describe("If provided, the OpenAPI document which describes the API being tested and is accompanied by a matcher which will be used to identify the interactions in the OpenAPI document which are relevant to the Pact refinement process.");
+export const RefineInputSchema = z.object({
+    pactTests: FileInputSchema.describe("Primary pact tests that needs to be refined."),
+    code: z
+        .array(FileInputSchema)
+        .describe("Collection of source code files to analyze and extract API interactions from. Include client code, data models, existing tests, or any code that makes API calls")
+        .optional(),
+    userInstructions: z
+        .string()
+        .describe("Optional free-form instructions that provide additional context or specify areas of focus during the refinement process of the Pact test.")
+        .optional(),
+    errorMessages: z
+        .array(z.string())
+        .describe("Optional error output from failed contract test runs. These can be used to better understand the context or failures observed and guide the recommendations toward resolving specific issues.")
+        .optional(),
+    openapi: OpenAPIWithMatcherSchema.optional(),
+});
+export const RequestResponsePairSchema = z
+    .object({
+    request: FileInputSchema,
+    response: FileInputSchema,
+})
+    .describe("Direct request/response pair for a specific interaction. Use this when you have concrete examples of API requests and responses");
+export const GenerationInputSchema = z.object({
+    language: z
+        .enum(GenerationLanguages)
+        .optional()
+        .describe("Target language for the generated Pact tests. If not provided, will be inferred from other inputs."),
+    requestResponse: RequestResponsePairSchema.optional(),
+    code: z
+        .array(FileInputSchema)
+        .optional()
+        .describe("Collection of source code files to analyze and extract API interactions from. Include client code, data models, existing tests, or any code that makes API calls"),
+    openapi: OpenAPIWithMatcherSchema.optional(),
+    additionalInstructions: z
+        .string()
+        .optional()
+        .describe("Optional free-form instructions to guide the generation process (e.g., 'Focus on error scenarios', 'Include authentication headers', 'Use specific test framework patterns')"),
+    testTemplate: FileInputSchema.optional().describe("Optional test template to use as a basis for generation. Helps ensure generated tests follow your specific patterns, frameworks, and coding standards"),
+});

package/dist/pactflow/client/base.js

@@ -0,0 +1 @@
+export {};

package/dist/pactflow/client/tools.js

@@ -0,0 +1,46 @@
+/**
+ * TOOLS
+ *
+ * Extends the default `ToolParams` with:
+ *  - `handler`: Name of the `PactflowClient` method to execute.
+ *  - `clients`: List of `ClientType`s allowed to use the tool.
+ *  - `formatResponse` (optional): Formats the tool's output before returning.
+ *
+ * In `PactflowClient.registerTools()`, tools are filtered by `clientType`
+ * and registered with their corresponding handler.
+ */
+import { z } from "zod";
+import { GenerationInputSchema, RefineInputSchema } from "./ai.js";
+export const TOOLS = [
+    {
+        title: "Generate Pact Tests",
+        summary: "Generate Pact tests using PactFlow AI. You can provide one or more of the following input types: (1) request/response pairs for specific interactions, (2) code files to analyze and extract interactions from, and/or (3) OpenAPI document to generate tests for specific endpoints. When providing an OpenAPI document, a matcher is required to specify which endpoints to generate tests for.",
+        purpose: "Generate Pact tests for API interactions",
+        zodSchema: GenerationInputSchema,
+        handler: "generate",
+        clients: ["pactflow"], // ONLY pactflow
+    },
+    {
+        title: "Review Pact Tests",
+        summary: "Review Pact tests using PactFlow AI. You can provide the following inputs: (1) Pact tests to be reviewed along with metadata",
+        purpose: "Review Pact tests for API interactions",
+        zodSchema: RefineInputSchema,
+        handler: "review",
+        clients: ["pactflow"]
+    },
+    {
+        title: "Get Provider States",
+        summary: "Retrieve the states of a specific provider",
+        purpose: "A provider state in Pact defines the specific preconditions that must be met on the provider side before a consumer–provider interaction can be tested. It sets up the provider in the right context—such as ensuring a particular user or record exists—so that the provider can return the response the consumer expects. This makes contract tests reliable, repeatable, and isolated by injecting or configuring the necessary data and conditions directly into the provider before each test runs.",
+        parameters: [
+            {
+                name: "provider",
+                type: z.string(),
+                description: "name of the provider to retrieve states for",
+                required: true
+            }
+        ],
+        handler: "getProviderStates",
+        clients: ["pactflow", "pact_broker"]
+    }
+];

package/dist/pactflow/client.js

@@ -0,0 +1,132 @@
+import { TOOLS } from "./client/tools.js";
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.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
+    async generate(body) {
+        // Submit the generation request
+        const response = await fetch(`${this.aiBaseUrl}/generate`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const status_response = await response.json();
+        return await this.pollForCompletion(status_response, "Generation");
+    }
+    async review(body) {
+        // submit review request
+        const response = await fetch(`${this.aiBaseUrl}/review`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        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();
+    }
+    registerTools(register, _getInput) {
+        for (const tool of TOOLS.filter(t => t.clients.includes(this.clientType))) {
+            const { handler, clients, formatResponse, ...toolparams } = tool;
+            console.log(clients);
+            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
-    }
 }