@smartbear/mcp 0.4.0 → 0.5.0

package/dist/pactflow/client/utils.js

@@ -0,0 +1,70 @@
+import { RemoteOpenAPIDocumentSchema, } from "./ai.js";
+import yaml from "js-yaml";
+// @ts-expect-error missing type declarations
+import Swagger from "swagger-client";
+/**
+ * Resolve the OpenAPI specification from the provided input.
+ *
+ * @param remoteOpenAPIDocument The remote OpenAPI document to resolve.
+ * @returns The resolved OpenAPI document.
+ * @throws Error if the resolution fails.
+ */
+export async function resolveOpenAPISpec(remoteOpenAPIDocument) {
+    const openAPISchema = RemoteOpenAPIDocumentSchema.safeParse(remoteOpenAPIDocument);
+    if (openAPISchema.error || !remoteOpenAPIDocument) {
+        throw new Error(`Invalid RemoteOpenAPIDocument: ${JSON.stringify(openAPISchema.error?.issues)}`);
+    }
+    const unresolvedSpec = await getRemoteSpecContents(openAPISchema.data);
+    const resolvedSpec = await Swagger.resolve({ spec: unresolvedSpec });
+    if (resolvedSpec.errors?.length) {
+        throw new Error(`Failed to resolve OpenAPI document: ${resolvedSpec.errors?.join(", ")}`);
+    }
+    return resolvedSpec.spec;
+}
+/**
+ * Fetch the contents of a remote OpenAPI document.
+ *
+ * @param openAPISchema The schema for the remote OpenAPI document.
+ * @returns A promise that resolves to a map of the OpenAPI document contents.
+ * @throws Error if the URL is not provided or the fetch fails.
+ */
+export async function getRemoteSpecContents(openAPISchema) {
+    if (!openAPISchema.url) {
+        throw new Error("'url' must be provided.");
+    }
+    let headers = {};
+    if (openAPISchema.authToken) {
+        headers = {
+            Authorization: `${openAPISchema.authScheme ?? "Bearer"} ${openAPISchema.authToken}`,
+        };
+    }
+    const remoteSpec = await fetch(openAPISchema.url, {
+        headers,
+        method: "GET",
+    });
+    const specRawBody = await remoteSpec.text();
+    try {
+        return JSON.parse(specRawBody);
+    }
+    catch (jsonError) {
+        try {
+            return yaml.load(specRawBody);
+        }
+        catch (yamlError) {
+            throw new Error(`Unsupported Content-Type: ${remoteSpec.headers.get("Content-Type")} for remote OpenAPI document. Found following parse errors:-\nJSON parse error: ${jsonError}\nYAML parse error: ${yamlError}`);
+        }
+    }
+}
+/**
+ * Adds the OpenAPI specification to the input schema if a remote document is provided.
+ *
+ * @param inputSchema The input schema to modify.
+ * @returns The modified input schema with the OpenAPI specification added.
+ */
+export async function addOpenAPISpecToSchema(inputSchema) {
+    if (inputSchema.remoteDocument) {
+        const resolvedSpec = await resolveOpenAPISpec(inputSchema.remoteDocument);
+        inputSchema.document = resolvedSpec;
+    }
+    return inputSchema;
+}

package/dist/pactflow/client.js

@@ -1,5 +1,5 @@
-import { TOOLS } from "./client/tools.js";
 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";
@@ -30,28 +30,42 @@ export class PactflowClient {
         this.clientType = clientType;
     }
     // PactFlow AI client methods
-    async generate(body) {
+    /**
+     * 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(body),
+            body: JSON.stringify(toolInput),
         });
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+            throw new Error(`HTTP error! status: ${response.status} - ${await response.text()}`);
         }
         const status_response = await response.json();
         return await this.pollForCompletion(status_response, "Generation");
     }
-    async review(body) {
-        // submit review request
+    /**
+     * 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(body),
+            body: JSON.stringify(toolInput),
         });
         if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
+            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");
@@ -108,10 +122,44 @@ export class PactflowClient {
         }
         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;
-            console.log(clients);
+            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") {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@smartbear/mcp",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "MCP server for interacting SmartBear Products",
   "keywords": [
     "smartbear",
     "mcp",
-    "insight-hub",
+    "bugsnag",
     "reflect",
     "api-hub",
     "pactflow"
@@ -44,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",
@@ -55,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/package.json

@@ -1,60 +0,0 @@
-{
-    "name": "@smartbear/mcp",
-    "version": "0.4.0",
-    "description": "MCP server for interacting SmartBear Products",
-    "keywords": [
-        "smartbear",
-        "mcp",
-        "insight-hub",
-        "reflect",
-        "api-hub",
-        "pactflow"
-    ],
-    "homepage": "https://developer.smartbear.com/smartbear-mcp",
-    "repository": {
-        "type": "git",
-        "url": "git@github.com:SmartBear/smartbear-mcp.git"
-    },
-    "license": "MIT",
-    "type": "module",
-    "bin": {
-        "mcp": "dist/index.js"
-    },
-    "files": [
-        "dist",
-        "assets",
-        "**/README.md"
-    ],
-    "config": {
-        "mcpServerName": "SmartBear MCP Server"
-    },
-    "scripts": {
-        "build": "tsc && shx chmod +x dist/*.js",
-        "lint": "eslint . --ext .ts",
-        "prepare": "npm run build",
-        "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",
-        "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",
-        "vitest": "^3.2.4"
-    }
-}

package/dist/tests/unit/common/server.test.js

@@ -1,319 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { SmartBearMcpServer } from "../../../common/server.js";
-import z from "zod";
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import Bugsnag from "../../../common/bugsnag.js";
-// Mock Bugsnag
-vi.mock("../../../common/bugsnag.js", () => ({
-    default: {
-        notify: vi.fn(),
-    },
-}));
-describe("SmartBearMcpServer", () => {
-    let server;
-    let superRegisterToolMock;
-    let superRegisterResourceMock;
-    beforeEach(() => {
-        server = new SmartBearMcpServer();
-        // This approach is required to mock the super call - other techniques result in mocking the actual server
-        superRegisterToolMock = vi
-            .spyOn(Object.getPrototypeOf(Object.getPrototypeOf(server)), "registerTool")
-            .mockImplementation(vi.fn());
-        superRegisterResourceMock = vi
-            .spyOn(Object.getPrototypeOf(Object.getPrototypeOf(server)), "registerResource")
-            .mockImplementation(vi.fn());
-        server.server.elicitInput = vi.fn().mockResolvedValue("mocked input");
-        // Reset the Bugsnag mock
-        vi.mocked(Bugsnag.notify).mockClear();
-    });
-    describe("getDescription tests", () => {
-        it("should return the correct description", () => {
-            const zSchema = z.object({
-                examples: z.enum(["test_1", "test_2"]),
-                constraints: z.enum(["test_1", "test_2"]),
-            });
-            const toolparams = {
-                title: "Test Tool",
-                summary: "A test tool",
-                zodSchema: zSchema,
-            };
-            const description = server["getDescription"](toolparams);
-            expect(description).toBe(`A test tool
-
-**Parameters:**
-- examples (enum) *required* (e.g. test_1, test_2) 
-- constraints (enum) *required*
-  - test_1
-  - test_2`);
-        });
-    });
-    describe("addClient", () => {
-        let mockClient;
-        beforeEach(() => {
-            mockClient = {
-                name: "Test Product",
-                prefix: "test_product",
-                registerTools: vi.fn(),
-                registerResources: vi.fn(),
-            };
-        });
-        it("should register tools when client provides them", async () => {
-            server.addClient(mockClient);
-            // The server should call the client's registerTools function
-            expect(mockClient.registerTools).toHaveBeenCalledWith(expect.any(Function), expect.any(Function));
-            // Get the register function passed from the server and execute it with test tool details
-            const registerFn = mockClient.registerTools.mock.calls[0][0];
-            const registerCbMock = vi.fn();
-            registerFn({
-                title: "Test Tool",
-                summary: "A test tool",
-                parameters: [
-                    {
-                        name: "p1",
-                        type: z.string(),
-                        required: true,
-                        description: "The input for the tool",
-                    },
-                ],
-            }, registerCbMock);
-            expect(superRegisterToolMock).toHaveBeenCalledOnce();
-            // Assert some of the details
-            const registerToolParams = superRegisterToolMock.mock.calls[0];
-            expect(registerToolParams[0]).toBe("test_product_test_tool");
-            expect(registerToolParams[1]["title"]).toBe("Test Product: Test Tool");
-            expect(registerToolParams[1]["description"]).toBe("A test tool\n\n" +
-                "**Parameters:**\n" +
-                "- p1 (string) *required*: The input for the tool");
-            expect(registerToolParams[1]["inputSchema"]["p1"].toString()).toBe(z.string().describe("The input for the tool").toString());
-            expect(registerToolParams[1]["annotations"]).toEqual({
-                title: "Test Product: Test Tool",
-                readOnlyHint: true,
-                destructiveHint: false,
-                idempotentHint: true,
-                openWorldHint: false,
-            });
-            // Get the wrapper function that will execute the tool and call it
-            registerToolParams[2]();
-            expect(registerCbMock).toHaveBeenCalledOnce();
-            expect(vi.mocked(Bugsnag.notify)).not.toHaveBeenCalled();
-        });
-        it("should register tools with complex parameters", async () => {
-            server.addClient(mockClient);
-            // Get the register function passed from the server and execute it with test tool details
-            const registerFn = mockClient.registerTools.mock.calls[0][0];
-            registerFn({
-                title: "Test Tool",
-                summary: "A test tool",
-                parameters: [
-                    {
-                        name: "p1",
-                        type: z.string(),
-                        required: true,
-                        description: "The input for the tool",
-                        examples: ["example1", "example2"],
-                        constraints: ["constraint1", "constraint2"],
-                    },
-                    {
-                        name: "p2",
-                        type: z.number(),
-                        required: false,
-                        description: "The optional numeric input for the tool",
-                    },
-                    {
-                        name: "p3",
-                        type: z.boolean(),
-                        required: true,
-                    },
-                    {
-                        name: "p4",
-                        type: z.array(z.string()),
-                        required: true,
-                    },
-                    {
-                        name: "p5",
-                        type: z.object({
-                            key1: z.string(),
-                            key2: z.number(),
-                        }),
-                        required: true,
-                    },
-                    {
-                        name: "p6",
-                        type: z.enum(["value1", "value2", "value3"]),
-                        required: true,
-                    },
-                    {
-                        name: "p7",
-                        type: z.literal("value"),
-                        required: true,
-                    },
-                    {
-                        name: "p8",
-                        type: z.union([z.literal("value1"), z.literal("value2")]),
-                        required: true,
-                    },
-                    {
-                        name: "p9",
-                        type: z.any(),
-                        required: true,
-                    },
-                ],
-                purpose: "To test the tool registration process",
-                useCases: ["Testing", "Development"],
-                examples: [
-                    {
-                        description: "Example 1",
-                        parameters: {
-                            p1: "example1",
-                            p2: 42,
-                        },
-                        expectedOutput: "Expected output for example 1",
-                    },
-                    {
-                        description: "Example 2",
-                        parameters: {
-                            p1: "example2",
-                            p2: 24,
-                        },
-                    },
-                ],
-                hints: ["First hint", "Second hint"],
-                outputFormat: "The output format",
-                readOnly: true,
-                destructive: true,
-                idempotent: true,
-                openWorld: true,
-            }, vi.fn());
-            // Assert some of the details
-            const registerToolParams = superRegisterToolMock.mock.calls[0];
-            expect(registerToolParams[0]).toBe("test_product_test_tool");
-            expect(registerToolParams[1]["title"]).toBe("Test Product: Test Tool");
-            expect(registerToolParams[1]["description"]).toBe("A test tool\n\n" +
-                "**Parameters:**\n" +
-                "- p1 (string) *required*: The input for the tool (e.g. example1, example2)\n" +
-                "  - constraint1\n" +
-                "  - constraint2\n" +
-                "- p2 (number): The optional numeric input for the tool\n" +
-                "- p3 (boolean) *required*\n" +
-                "- p4 (array) *required*\n" +
-                "- p5 (object) *required*\n" +
-                "- p6 (enum) *required*\n" +
-                "- p7 (literal) *required*\n" +
-                "- p8 (union) *required*\n" +
-                "- p9 (any) *required*\n\n" +
-                "**Output Format:** The output format\n\n" +
-                "**Use Cases:** 1. Testing 2. Development\n\n" +
-                "**Examples:**\n" +
-                "1. Example 1\n" +
-                "```json\n" +
-                "{\n" +
-                '  "p1": "example1",\n' +
-                '  "p2": 42\n' +
-                "}\n" +
-                "```\n" +
-                "Expected Output: Expected output for example 1\n\n" +
-                "2. Example 2\n" +
-                "```json\n" +
-                "{\n" +
-                '  "p1": "example2",\n' +
-                '  "p2": 24\n' +
-                "}\n" +
-                "```\n\n" +
-                "**Hints:** 1. First hint 2. Second hint");
-            expect(registerToolParams[1]["inputSchema"]["p1"].toString()).toBe(z.string().describe("The input for the tool").toString());
-            expect(registerToolParams[1]["annotations"]).toEqual({
-                title: "Test Product: Test Tool",
-                readOnlyHint: true,
-                destructiveHint: true,
-                idempotentHint: true,
-                openWorldHint: true,
-            });
-        });
-        it("should handle errors when registering tools", async () => {
-            server.addClient(mockClient);
-            // Get the register function passed from the server and execute it with test tool details
-            const registerFn = mockClient.registerTools.mock.calls[0][0];
-            const registerCbMock = vi.fn();
-            registerFn({
-                title: "Test Tool",
-                summary: "A test tool",
-                parameters: [],
-            }, registerCbMock);
-            // Make the callback throw an error to test error handling
-            registerCbMock.mockImplementation(() => {
-                throw new Error("Test error from registerCbMock");
-            });
-            // Get the wrapper function that will execute the tool and call it
-            const registerToolParams = superRegisterToolMock.mock.calls[0];
-            await expect(registerToolParams[2]()).rejects.toThrow("Test error from registerCbMock");
-            expect(registerCbMock).toHaveBeenCalledOnce();
-            expect(vi.mocked(Bugsnag.notify)).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({
-                message: "Test error from registerCbMock",
-            }));
-        });
-        it("should elicit input when client requires it", async () => {
-            server.addClient(mockClient);
-            // The server should call the client's registerTools function
-            expect(mockClient.registerTools).toHaveBeenCalledWith(expect.any(Function), expect.any(Function));
-            // Get the register function passed from the server and execute it with test tool details
-            const getInputFn = mockClient.registerTools.mock.calls[0][1];
-            const params = vi.mockObject({});
-            const options = vi.mockObject({});
-            getInputFn(params, options);
-            expect(server.server.elicitInput).toHaveBeenCalledExactlyOnceWith(params, options);
-        });
-        it("should register resources when client provides them", async () => {
-            const mockClient = {
-                name: "Test Product",
-                prefix: "test_product",
-                registerTools: vi.fn(),
-                registerResources: vi.fn(),
-            };
-            server.addClient(mockClient);
-            // The server should call the client's registerResources function
-            expect(mockClient.registerResources).toHaveBeenCalledWith(expect.any(Function));
-            // Get the register function passed from the server and execute it with test resource details
-            const registerFn = mockClient.registerResources.mock.calls[0][0];
-            const registerCbMock = vi.fn();
-            registerFn("test_resource", "{identifier}", registerCbMock);
-            expect(superRegisterResourceMock).toHaveBeenCalledExactlyOnceWith(expect.any(String), expect.any(ResourceTemplate), expect.any(Object), expect.any(Function));
-            // Assert some of the details
-            const registerResourceParams = superRegisterResourceMock.mock.calls[0];
-            expect(registerResourceParams[0]).toBe("test_resource");
-            expect(registerResourceParams[1].uriTemplate.template).toBe("test_product://test_resource/{identifier}");
-            // Get the wrapper function that will execute the tool and call it
-            registerResourceParams[3]();
-            expect(registerCbMock).toHaveBeenCalledOnce();
-            expect(vi.mocked(Bugsnag.notify)).not.toHaveBeenCalled();
-        });
-        it("should not register resources when client does not provide them", async () => {
-            const mockClient = {
-                name: "Test Product",
-                prefix: "test_product",
-                registerTools: vi.fn(),
-                registerResources: undefined,
-            };
-            server.addClient(mockClient);
-            // It should not crash with undefined registerResources function
-            expect(vi.mocked(Bugsnag.notify)).not.toHaveBeenCalled();
-        });
-        it("should handle errors when registering resources", async () => {
-            server.addClient(mockClient);
-            // Get the register function passed from the server and execute it with test resource details
-            const registerFn = mockClient.registerResources.mock.calls[0][0];
-            const registerCbMock = vi.fn();
-            registerFn("test_resource", "{identifier}", registerCbMock);
-            // Make the callback throw an error to test error handling
-            registerCbMock.mockImplementation(() => {
-                throw new Error("Test error from registerCbMock");
-            });
-            // Get the wrapper function that will execute the resource and call it
-            const registerResourceParams = superRegisterResourceMock.mock.calls[0];
-            await expect(registerResourceParams[3]()).rejects.toThrow("Test error from registerCbMock");
-            expect(registerCbMock).toHaveBeenCalledOnce();
-            expect(vi.mocked(Bugsnag.notify)).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({
-                message: "Test error from registerCbMock",
-            }));
-        });
-    });
-});

package/dist/tests/unit/insight-hub/api-utilities.test.js

@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { pickFields, pickFieldsFromArray } from '../../../insight-hub/client/api/base.js';
-describe('API Utilities', () => {
-    describe('pickFields', () => {
-        it('should pick only specified fields from object', () => {
-            const input = { id: '1', name: 'Test', secret: 'hidden', extra: 'data' };
-            const result = pickFields(input, ['id', 'name']);
-            expect(result).toEqual({ id: '1', name: 'Test' });
-            expect(result).not.toHaveProperty('secret');
-            expect(result).not.toHaveProperty('extra');
-        });
-        it('should handle missing fields gracefully', () => {
-            const input = { id: '1' };
-            const result = pickFields(input, ['id', 'name', 'missing']);
-            expect(result).toEqual({ id: '1' });
-        });
-    });
-    describe('pickFieldsFromArray', () => {
-        it('should pick fields from array of objects', () => {
-            const input = [
-                { id: '1', name: 'Test1', secret: 'hidden1' },
-                { id: '2', name: 'Test2', secret: 'hidden2' }
-            ];
-            const result = pickFieldsFromArray(input, ['id', 'name']);
-            expect(result).toEqual([
-                { id: '1', name: 'Test1' },
-                { id: '2', name: 'Test2' }
-            ]);
-        });
-    });
-});