@smartbear/mcp 0.9.0 → 0.11.0

package/dist/swagger/client.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
+// Apply backward compatibility for API_HUB_API_KEY
+import "./config-utils.js";
+import { SwaggerAPI, SwaggerConfiguration, TOOLS, } from "./client/index.js";
+const ConfigurationSchema = z.object({
+    api_key: z.string().describe("Swagger API key for authentication"),
+});
+// Tool definitions for API Hub API client
+export class SwaggerClient {
+    api;
+    name = "Swagger";
+    toolPrefix = "swagger";
+    configPrefix = "Swagger";
+    config = ConfigurationSchema;
+    async configure(_server, config, _cache) {
+        this.api = new SwaggerAPI(new SwaggerConfiguration({ token: config.api_key }), `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`);
+        return true;
+    }
+    getApi() {
+        if (!this.api)
+            throw new Error("Client not configured");
+        return this.api;
+    }
+    // Delegate API methods to the SwaggerAPI instance
+    async getPortals() {
+        return this.getApi().getPortals();
+    }
+    async createPortal(body) {
+        return this.getApi().createPortal(body);
+    }
+    async getPortal(args) {
+        return this.getApi().getPortal(args.portalId);
+    }
+    async deletePortal(args) {
+        return this.getApi().deletePortal(args.portalId);
+    }
+    async updatePortal(args) {
+        const { portalId, ...body } = args;
+        return this.getApi().updatePortal(portalId, body);
+    }
+    async getPortalProducts(args) {
+        return this.getApi().getPortalProducts(args.portalId);
+    }
+    async createPortalProduct(args) {
+        const { portalId, ...body } = args;
+        return this.getApi().createPortalProduct(portalId, body);
+    }
+    async getPortalProduct(args) {
+        return this.getApi().getPortalProduct(args.productId);
+    }
+    async deletePortalProduct(args) {
+        return this.getApi().deletePortalProduct(args.productId);
+    }
+    async updatePortalProduct(args) {
+        const { productId, ...body } = args;
+        return this.getApi().updatePortalProduct(productId, body);
+    }
+    async publishPortalProduct(args) {
+        const { productId, preview } = args;
+        return this.getApi().publishPortalProduct(productId, preview);
+    }
+    async getPortalProductSections(args) {
+        const { productId, ...params } = args;
+        return this.getApi().getPortalProductSections(productId, params);
+    }
+    async createTableOfContents(args) {
+        const { sectionId, ...body } = args;
+        return this.getApi().createTableOfContents(sectionId, body);
+    }
+    async getTableOfContents(args) {
+        return this.getApi().getTableOfContents(args);
+    }
+    async getDocument(args) {
+        return this.getApi().getDocument(args);
+    }
+    async updateDocument(args) {
+        return this.getApi().updateDocument(args);
+    }
+    async deleteDocument(args) {
+        return this.getApi().deleteDocument(args);
+    }
+    async deleteTableOfContents(args) {
+        return this.getApi().deleteTableOfContents(args);
+    }
+    // Registry API methods for SwaggerHub Design functionality
+    async searchApis(args = {}) {
+        return this.getApi().searchApis(args);
+    }
+    async getApiDefinition(args) {
+        return this.getApi().getApiDefinition(args);
+    }
+    async createOrUpdateApi(args) {
+        return this.getApi().createOrUpdateApi(args);
+    }
+    async createApiFromTemplate(args) {
+        return this.getApi().createApiFromTemplate(args);
+    }
+    // User Management API methods
+    async getOrganizations(args) {
+        return this.getApi().getOrganizations(args);
+    }
+    async scanStandardization(args) {
+        return this.getApi().scanStandardization(args);
+    }
+    registerTools(register, _getInput) {
+        TOOLS.forEach((tool) => {
+            const { handler, formatResponse, ...toolParams } = tool;
+            register(toolParams, async (args, _extra) => {
+                try {
+                    // Dynamic method invocation
+                    const handlerFn = this[handler];
+                    if (typeof handlerFn !== "function") {
+                        throw new Error(`Handler '${handler}' not found on SwaggerClient`);
+                    }
+                    const result = await handlerFn.call(this, args);
+                    // Use custom formatter if available, otherwise return JSON
+                    const formattedResult = formatResponse
+                        ? formatResponse(result)
+                        : result;
+                    const responseText = typeof formattedResult === "string"
+                        ? formattedResult
+                        : JSON.stringify(formattedResult);
+                    return {
+                        content: [{ type: "text", text: responseText }],
+                    };
+                }
+                catch (error) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                            },
+                        ],
+                    };
+                }
+            });
+        });
+    }
+}

package/dist/swagger/config-utils.js

@@ -0,0 +1,18 @@
+/**
+ * Configuration utilities for Swagger client
+ * Handles backward compatibility with legacy environment variables
+ */
+/**
+ * Apply API_HUB_API_KEY fallback to SWAGGER_API_KEY if needed
+ * This modifies process.env to enable backward compatibility
+ * @deprecated API_HUB_API_KEY support - TODO: Remove after migration period (May 2026)
+ */
+export function applySwaggerApiKeyFallback() {
+    // If SWAGGER_API_KEY is not set but API_HUB_API_KEY is, use the legacy variable
+    if (!process.env.SWAGGER_API_KEY && process.env.API_HUB_API_KEY) {
+        console.warn("[Swagger] API_HUB_API_KEY is deprecated. Please use SWAGGER_API_KEY instead.");
+        process.env.SWAGGER_API_KEY = process.env.API_HUB_API_KEY;
+    }
+}
+// Apply the fallback immediately when this module is imported
+applySwaggerApiKeyFallback();

package/dist/zephyr/client.js

@@ -1,16 +1,54 @@
+import z from "zod";
 import { ApiClient } from "./common/api-client.js";
+import { GetPriorities } from "./tool/priority/get-priorities.js";
+import { GetProject } from "./tool/project/get-project.js";
 import { GetProjects } from "./tool/project/get-projects.js";
+import { GetStatuses } from "./tool/status/get-statuses.js";
+import { GetTestCase } from "./tool/test-case/get-test-case.js";
+import { GetTestCases } from "./tool/test-case/get-test-cases.js";
+import { GetTestCycle } from "./tool/test-cycle/get-test-cycle.js";
+import { GetTestCycles } from "./tool/test-cycle/get-test-cycles.js";
+import { GetTestExecution } from "./tool/test-execution/get-test-execution.js";
+const BASE_URL_DEFAULT = "https://api.zephyrscale.smartbear.com/v2";
+const ConfigurationSchema = z.object({
+    api_token: z.string().describe("Zephyr Scale API token for authentication"),
+    base_url: z
+        .string()
+        .url()
+        .optional()
+        .describe("Zephyr Scale API base URL")
+        .default(BASE_URL_DEFAULT),
+});
 export class ZephyrClient {
     apiClient;
     name = "Zephyr";
-    prefix = "zephyr";
-    constructor(bearerToken, baseUrl = "https://api.zephyrscale.smartbear.com/v2") {
-        this.apiClient = new ApiClient(bearerToken, baseUrl);
+    toolPrefix = "zephyr";
+    configPrefix = "Zephyr";
+    config = ConfigurationSchema;
+    async configure(_server, config, _cache) {
+        this.apiClient = new ApiClient(config.api_token, config.base_url || BASE_URL_DEFAULT);
+        return true;
+    }
+    getApiClient() {
+        if (!this.apiClient)
+            throw new Error("Client not configured");
+        return this.apiClient;
     }
     registerTools(register, _getInput) {
-        const tools = [new GetProjects(this.apiClient)];
-        tools.forEach((tool) => {
+        const apiClient = this.getApiClient();
+        const tools = [
+            new GetProjects(apiClient),
+            new GetProject(apiClient),
+            new GetTestCycles(apiClient),
+            new GetTestCycle(apiClient),
+            new GetPriorities(apiClient),
+            new GetStatuses(apiClient),
+            new GetTestCases(apiClient),
+            new GetTestCase(apiClient),
+            new GetTestExecution(apiClient),
+        ];
+        for (const tool of tools) {
             register(tool.specification, tool.handle);
-        });
+        }
     }
 }

package/dist/zephyr/common/api-client.js

@@ -1,3 +1,4 @@
+import { ToolError } from "../../common/types.js";
 import { AuthService } from "./auth-service.js";
 export class ApiClient {
     baseUrl;
@@ -22,6 +23,13 @@ export class ApiClient {
             method: "GET",
             headers: this.defaultHeaders,
         });
+        return await this.validateAndGetResponseBody(response);
+    }
+    async validateAndGetResponseBody(response) {
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new ToolError(`Request failed with status ${response.status}: ${errorText}`);
+        }
         return response.json();
     }
 }