@smartbear/mcp 0.10.0 → 0.12.0

package/dist/{api-hub → swagger}/client/portal-types.js

@@ -89,7 +89,8 @@ export const CreateTableOfContentsArgsSchema = z.object({
         .describe("Content configuration for the table of contents item")
         .refine((content) => {
         if (content?.type === "apiUrl") {
-            return content.url?.endsWith("/swagger.json");
+            return (content.url?.endsWith("/swagger.json") ||
+                content.url?.endsWith("/swagger.yaml"));
         }
         return true;
     }, {
@@ -171,6 +172,11 @@ export const CreateProductArgsSchema = PortalArgsSchema.extend({
     type: z
         .string()
         .describe("Product creation type - 'new' to create from scratch or 'copy' to duplicate an existing product"),
+    productId: z
+        .string()
+        .uuid()
+        .optional()
+        .describe("Source product UUID to copy from - required when type is 'copy', specifies which existing product to duplicate. Omit when type is 'new'"),
     name: z
         .string()
         .describe("Product display name - will be shown to users in the portal navigation and product listings (3-40 characters)"),
@@ -241,11 +247,6 @@ export const UpdateDocumentArgsSchema = z.object({
         .optional()
         .describe("Content type - 'html' for HTML content or 'markdown' for Markdown content"),
 });
-export const DeleteDocumentArgsSchema = z.object({
-    documentId: z
-        .string()
-        .describe("Document UUID - unique identifier for the document to delete"),
-});
 export const DeleteTableOfContentsArgsSchema = z.object({
     tableOfContentsId: z
         .string()

package/dist/{api-hub → swagger}/client/registry-types.js

@@ -75,3 +75,29 @@ export const ScanStandardizationParamsSchema = z.object({
         .string()
         .describe("API definition content (OpenAPI/AsyncAPI specification in JSON or YAML format) to scan for standardization errors"),
 });
+export const CreateApiFromPromptParamsSchema = z.object({
+    owner: z
+        .string()
+        .describe("API owner (organization or user, case-sensitive)"),
+    apiName: z.string().describe("API name"),
+    prompt: z
+        .string()
+        .describe("The prompt describing the desired API functionality (e.g., 'Create a RESTful API for managing a pet store with endpoints for pets, orders, and inventory')"),
+    specType: z
+        .enum([
+        "openapi20",
+        "openapi30x",
+        "openapi31x",
+        "asyncapi2xx",
+        "asyncapi30x",
+    ])
+        .default("openapi30x")
+        .describe("Specification type for the generated API definition. Use: 'openapi20' for OpenAPI 2.0, 'openapi30x' for OpenAPI 3.0.x (default), 'openapi31x' for OpenAPI 3.1.x, 'asyncapi2xx' for AsyncAPI 2.x, 'asyncapi30x' for AsyncAPI 3.0.x"),
+});
+export const StandardizeApiParamsSchema = z.object({
+    owner: z
+        .string()
+        .describe("API owner (organization or user, case-sensitive)"),
+    api: z.string().describe("API name (case-sensitive)"),
+    version: z.string().describe("Version identifier"),
+});

package/dist/{api-hub → swagger}/client/tools.js

@@ -1,23 +1,23 @@
 /**
  * TOOLS
  *
- * Defines tool configurations for API Hub operations.
+ * Defines tool configurations for Swagger operations.
  * Each tool includes parameters, descriptions, and handler method names.
  * This follows the pattern established in the pactflow module.
  */
-import { CreatePortalArgsSchema, CreateProductArgsSchema, CreateTableOfContentsArgsSchema, DeleteDocumentArgsSchema, DeleteTableOfContentsArgsSchema, GetDocumentArgsSchema, GetProductSectionsArgsSchema, GetTableOfContentsArgsSchema, PortalArgsSchema, ProductArgsSchema, PublishProductArgsSchema, UpdateDocumentArgsSchema, UpdatePortalArgsSchema, UpdateProductArgsSchema, } from "./portal-types.js";
-import { ApiDefinitionParamsSchema, ApiSearchParamsSchema, CreateApiFromTemplateParamsSchema, CreateApiParamsSchema, ScanStandardizationParamsSchema, } from "./registry-types.js";
+import { CreatePortalArgsSchema, CreateProductArgsSchema, CreateTableOfContentsArgsSchema, DeleteTableOfContentsArgsSchema, GetDocumentArgsSchema, GetProductSectionsArgsSchema, GetTableOfContentsArgsSchema, PortalArgsSchema, ProductArgsSchema, PublishProductArgsSchema, UpdateDocumentArgsSchema, UpdatePortalArgsSchema, UpdateProductArgsSchema, } from "./portal-types.js";
+import { ApiDefinitionParamsSchema, ApiSearchParamsSchema, CreateApiFromPromptParamsSchema, CreateApiFromTemplateParamsSchema, CreateApiParamsSchema, ScanStandardizationParamsSchema, StandardizeApiParamsSchema, } from "./registry-types.js";
 import { OrganizationsQuerySchema } from "./user-management-types.js";
 export const TOOLS = [
     {
         title: "List Portals",
-        summary: "Search for available portals within API Hub. Only portals where you have at least a designer role, either at the product level or organization level, are returned.",
+        summary: "Search for available portals within Swagger. Only portals where you have at least a designer role, either at the product level or organization level, are returned.",
         parameters: [],
         handler: "getPortals",
     },
     {
         title: "Create Portal",
-        summary: "Create a new portal within API Hub.",
+        summary: "Create a new portal within Swagger.",
         inputSchema: CreatePortalArgsSchema,
         handler: "createPortal",
     },
@@ -27,13 +27,6 @@ export const TOOLS = [
         inputSchema: PortalArgsSchema,
         handler: "getPortal",
     },
-    {
-        title: "Delete Portal",
-        summary: "Delete a specific portal.",
-        inputSchema: PortalArgsSchema,
-        handler: "deletePortal",
-        formatResponse: () => "Portal deleted successfully.",
-    },
     {
         title: "Update Portal",
         summary: "Update a specific portal's configuration.",
@@ -114,12 +107,6 @@ export const TOOLS = [
         inputSchema: UpdateDocumentArgsSchema,
         handler: "updateDocument",
     },
-    {
-        title: "Delete Document",
-        summary: "Delete a document by its ID. This will permanently remove the document content.",
-        inputSchema: DeleteDocumentArgsSchema,
-        handler: "deleteDocument",
-    },
     // Registry API tools for SwaggerHub Design functionality
     {
         title: "Search APIs and Domains",
@@ -135,7 +122,7 @@ export const TOOLS = [
     },
     {
         title: "Create or Update API",
-        summary: "Create a new API or update an existing API in SwaggerHub Registry for API Hub for Design. The API specification type (OpenAPI, AsyncAPI) is automatically detected from the definition content. APIs are always created with fixed values: version 1.0.0, private visibility, and automock disabled (these values cannot be changed). Returns HTTP 201 for creation, HTTP 200 for update. Response includes 'operation' field indicating whether it was a 'create' or 'update' operation along with API details and SwaggerHub URL.",
+        summary: "Create a new API or update an existing API in SwaggerHub Registry for Swagger Studio. The API specification type (OpenAPI, AsyncAPI) is automatically detected from the definition content. APIs are always created with fixed values: version 1.0.0, private visibility, and automock disabled (these values cannot be changed). Returns HTTP 201 for creation, HTTP 200 for update. Response includes 'operation' field indicating whether it was a 'create' or 'update' operation along with API details and SwaggerHub URL.",
         inputSchema: CreateApiParamsSchema,
         handler: "createOrUpdateApi",
     },
@@ -154,8 +141,20 @@ export const TOOLS = [
     },
     {
         title: "Scan API Standardization",
-        summary: "Run a standardization scan against an API definition using the organization's standardization configuration. Accepts a YAML or JSON OpenAPI/AsyncAPI definition and returns a list of standardization errors and validation issues.",
+        summary: "Run a standardization scan against an API definition using the organization's governance and standardization rules. Accepts a YAML or JSON OpenAPI/AsyncAPI definition and returns a list of standardization errors and validation issues. Use this tool when users ask to validate, scan, or check API governance or standardization.",
         inputSchema: ScanStandardizationParamsSchema,
         handler: "scanStandardization",
     },
+    {
+        title: "Create API from Prompt using SmartBear AI",
+        summary: "Generate and save an API definition based on a prompt using SmartBear AI. This tool automatically applies organization governance and standardization rules during API generation. The specType parameter determines the format of the generated definition. Use: 'openapi20' for OpenAPI 2.0, 'openapi30x' for OpenAPI 3.0.x, 'openapi31x' for OpenAPI 3.1.x, 'asyncapi2xx' for AsyncAPI 2.x, 'asyncapi30x' for AsyncAPI 3.0.x. Use this tool when creating APIs that comply with governance policies or when generating APIs from natural language descriptions. Use this tool when users ask to create, generate, or design APIs with governance or standardization requirements. Returns HTTP 201 for creation, HTTP 200 for update. Response includes 'operation' field indicating whether it was a 'create' or 'update' operation along with API details and SwaggerHub URL.",
+        inputSchema: CreateApiFromPromptParamsSchema,
+        handler: "createApiFromPrompt",
+    },
+    {
+        title: "Standardize API",
+        summary: "Standardize and fix an API definition using AI to ensure compliance with governance policies. Scans the API definition for standardization errors and automatically fixes them using SmartBear AI. If errors are found, they will be sent to SmartBear AI to generate a corrected definition, which is then saved back to the registry. Returns the number of errors found and the fixed definition if successful. Use this tool when users ask to standardize, fix, govern, or ensure governance compliance of APIs.",
+        inputSchema: StandardizeApiParamsSchema,
+        handler: "standardizeApi",
+    },
 ];

package/dist/{api-hub → swagger}/client.js

@@ -1,95 +1,107 @@
+import { z } from "zod";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
-import { ApiHubAPI, ApiHubConfiguration, TOOLS, } from "./client/index.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 ApiHubClient {
-    config;
+export class SwaggerClient {
     api;
-    name = "API Hub";
-    prefix = "api_hub";
-    constructor(token) {
-        this.config = new ApiHubConfiguration({ token });
-        this.api = new ApiHubAPI(this.config, `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`);
-    }
-    // Delegate API methods to the ApiHubAPI instance
+    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.api.getPortals();
+        return this.getApi().getPortals();
     }
     async createPortal(body) {
-        return this.api.createPortal(body);
+        return this.getApi().createPortal(body);
     }
     async getPortal(args) {
-        return this.api.getPortal(args.portalId);
-    }
-    async deletePortal(args) {
-        return this.api.deletePortal(args.portalId);
+        return this.getApi().getPortal(args.portalId);
     }
     async updatePortal(args) {
         const { portalId, ...body } = args;
-        return this.api.updatePortal(portalId, body);
+        return this.getApi().updatePortal(portalId, body);
     }
     async getPortalProducts(args) {
-        return this.api.getPortalProducts(args.portalId);
+        return this.getApi().getPortalProducts(args.portalId);
     }
     async createPortalProduct(args) {
         const { portalId, ...body } = args;
-        return this.api.createPortalProduct(portalId, body);
+        return this.getApi().createPortalProduct(portalId, body);
     }
     async getPortalProduct(args) {
-        return this.api.getPortalProduct(args.productId);
+        return this.getApi().getPortalProduct(args.productId);
     }
     async deletePortalProduct(args) {
-        return this.api.deletePortalProduct(args.productId);
+        return this.getApi().deletePortalProduct(args.productId);
     }
     async updatePortalProduct(args) {
         const { productId, ...body } = args;
-        return this.api.updatePortalProduct(productId, body);
+        return this.getApi().updatePortalProduct(productId, body);
     }
     async publishPortalProduct(args) {
         const { productId, preview } = args;
-        return this.api.publishPortalProduct(productId, preview);
+        return this.getApi().publishPortalProduct(productId, preview);
     }
     async getPortalProductSections(args) {
         const { productId, ...params } = args;
-        return this.api.getPortalProductSections(productId, params);
+        return this.getApi().getPortalProductSections(productId, params);
     }
     async createTableOfContents(args) {
         const { sectionId, ...body } = args;
-        return this.api.createTableOfContents(sectionId, body);
+        return this.getApi().createTableOfContents(sectionId, body);
     }
     async getTableOfContents(args) {
-        return this.api.getTableOfContents(args);
+        return this.getApi().getTableOfContents(args);
     }
     async getDocument(args) {
-        return this.api.getDocument(args);
+        return this.getApi().getDocument(args);
     }
     async updateDocument(args) {
-        return this.api.updateDocument(args);
-    }
-    async deleteDocument(args) {
-        return this.api.deleteDocument(args);
+        return this.getApi().updateDocument(args);
     }
     async deleteTableOfContents(args) {
-        return this.api.deleteTableOfContents(args);
+        return this.getApi().deleteTableOfContents(args);
     }
     // Registry API methods for SwaggerHub Design functionality
     async searchApis(args = {}) {
-        return this.api.searchApis(args);
+        return this.getApi().searchApis(args);
     }
     async getApiDefinition(args) {
-        return this.api.getApiDefinition(args);
+        return this.getApi().getApiDefinition(args);
     }
     async createOrUpdateApi(args) {
-        return this.api.createOrUpdateApi(args);
+        return this.getApi().createOrUpdateApi(args);
     }
     async createApiFromTemplate(args) {
-        return this.api.createApiFromTemplate(args);
+        return this.getApi().createApiFromTemplate(args);
     }
     // User Management API methods
     async getOrganizations(args) {
-        return this.api.getOrganizations(args);
+        return this.getApi().getOrganizations(args);
+    }
+    async createApiFromPrompt(args) {
+        return this.getApi().createApiFromPrompt(args);
     }
     async scanStandardization(args) {
-        return this.api.scanStandardization(args);
+        return this.getApi().scanStandardization(args);
+    }
+    async standardizeApi(args) {
+        return this.getApi().standardizeApi(args);
     }
     registerTools(register, _getInput) {
         TOOLS.forEach((tool) => {
@@ -99,7 +111,7 @@ export class ApiHubClient {
                     // Dynamic method invocation
                     const handlerFn = this[handler];
                     if (typeof handlerFn !== "function") {
-                        throw new Error(`Handler '${handler}' not found on ApiHubClient`);
+                        throw new Error(`Handler '${handler}' not found on SwaggerClient`);
                     }
                     const result = await handlerFn.call(this, args);
                     // Use custom formatter if available, otherwise return JSON

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/tests/unit/bugsnag/utils/factories.js

@@ -0,0 +1,86 @@
+export function getMockOrganization(id, name, slug, extra = {}) {
+    return {
+        id,
+        name,
+        slug: slug ?? name.toLowerCase().replace(/\s+/g, "-"),
+        updatedAt: new Date(),
+        createdAt: new Date(),
+        autoUpgrade: false,
+        managedByPlatformServices: false,
+        ...extra,
+    };
+}
+export function getMockProject(id, name, apiKey, extra = {}) {
+    return { id, name, apiKey, ...extra };
+}
+export function getMockEventField(displayId, extra = {}) {
+    return {
+        displayId: displayId,
+        custom: false,
+        filterOptions: { name: "filter" },
+        pivotOptions: {},
+        ...extra,
+    };
+}
+export function getMockError(id, extra = {}) {
+    return { id, ...extra };
+}
+export function getMockEvent(id, extra = {}) {
+    return { id, ...extra };
+}
+export function getMockReleaseGroup(id, extra = {}) {
+    return {
+        id,
+        projectId: "proj-1",
+        releaseStageName: "production",
+        appVersion: "1.0.0",
+        firstReleasedAt: new Date().toISOString(),
+        firstReleaseId: "release-1",
+        releasesCount: 1,
+        hasSecondaryVersions: false,
+        totalSessionsCount: 0,
+        topReleaseGroup: false,
+        visible: true,
+        ...extra,
+    };
+}
+export function getMockRelease(id, extra = {}) {
+    return { id, ...extra };
+}
+export function getMockSpanGroup(id, name, category, extra = {}) {
+    return {
+        id: `span-group-${id}`,
+        name: `span-name-${name}`,
+        displayName: name,
+        category: category,
+        ...extra,
+    };
+}
+export function getMockSpan(traceId, id, name, category, isFirstClass = true, extra = {}) {
+    return {
+        traceId,
+        id: `span-${id}`,
+        name: `span-name-${name}`,
+        displayName: name,
+        category: category,
+        isFirstClass: isFirstClass,
+        duration: Math.round(Math.random() * 1000),
+        timestamp: new Date(Date.now()).toISOString(),
+        startTime: new Date(Date.now() - 1000).toISOString(),
+        timeAdjustmentType: "unadjusted",
+        ...extra,
+    };
+}
+export function getMockTrace(name, type) {
+    return {
+        displayId: name,
+        fieldType: type,
+        filterOptions: {
+            name: name,
+            description: "Cached field",
+            searchable: true,
+            matchTypes: ["eq"],
+        },
+        custom: true,
+    };
+}

package/dist/zephyr/client.js

@@ -1,22 +1,58 @@
+import z from "zod";
 import { ApiClient } from "./common/api-client.js";
+import { GetEnvironments } from "./tool/environment/get-environments.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";
+import { GetTestExecutions } from "./tool/test-execution/get-test-executions.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 apiClient = this.getApiClient();
         const tools = [
-            new GetProjects(this.apiClient),
-            new GetProject(this.apiClient),
-            new GetTestCycles(this.apiClient),
+            new GetProjects(apiClient),
+            new GetProject(apiClient),
+            new GetTestCycles(apiClient),
+            new GetTestCycle(apiClient),
+            new GetPriorities(apiClient),
+            new GetStatuses(apiClient),
+            new GetTestCases(apiClient),
+            new GetEnvironments(apiClient),
+            new GetTestCase(apiClient),
+            new GetTestExecution(apiClient),
+            new GetTestExecutions(apiClient),
         ];
-        tools.forEach((tool) => {
+        for (const tool of tools) {
             register(tool.specification, tool.handle);
-        });
+        }
     }
 }