@smartbear/mcp 0.8.0 → 0.10.0

package/dist/api-hub/client/tools.js

@@ -5,8 +5,9 @@
  * Each tool includes parameters, descriptions, and handler method names.
  * This follows the pattern established in the pactflow module.
  */
-import { CreatePortalArgsSchema, CreateProductArgsSchema, PortalArgsSchema, ProductArgsSchema, UpdatePortalArgsSchema, UpdateProductArgsSchema, } from "./portal-types.js";
-import { ApiDefinitionParamsSchema, ApiSearchParamsSchema, CreateApiFromTemplateParamsSchema, CreateApiParamsSchema, } from "./registry-types.js";
+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 { OrganizationsQuerySchema } from "./user-management-types.js";
 export const TOOLS = [
     {
         title: "List Portals",
@@ -17,82 +18,144 @@ export const TOOLS = [
     {
         title: "Create Portal",
         summary: "Create a new portal within API Hub.",
-        zodSchema: CreatePortalArgsSchema,
+        inputSchema: CreatePortalArgsSchema,
         handler: "createPortal",
     },
     {
         title: "Get Portal",
         summary: "Retrieve information about a specific portal.",
-        zodSchema: PortalArgsSchema,
+        inputSchema: PortalArgsSchema,
         handler: "getPortal",
     },
     {
         title: "Delete Portal",
         summary: "Delete a specific portal.",
-        zodSchema: PortalArgsSchema,
+        inputSchema: PortalArgsSchema,
         handler: "deletePortal",
         formatResponse: () => "Portal deleted successfully.",
     },
     {
         title: "Update Portal",
         summary: "Update a specific portal's configuration.",
-        zodSchema: UpdatePortalArgsSchema,
+        inputSchema: UpdatePortalArgsSchema,
         handler: "updatePortal",
     },
     {
         title: "List Portal Products",
         summary: "Get products for a specific portal that match your criteria.",
-        zodSchema: PortalArgsSchema,
+        inputSchema: PortalArgsSchema,
         handler: "getPortalProducts",
     },
     {
         title: "Create Portal Product",
         summary: "Create a new product for a specific portal.",
-        zodSchema: CreateProductArgsSchema,
+        inputSchema: CreateProductArgsSchema,
         handler: "createPortalProduct",
     },
     {
         title: "Get Portal Product",
         summary: "Retrieve information about a specific product resource.",
-        zodSchema: ProductArgsSchema,
+        inputSchema: ProductArgsSchema,
         handler: "getPortalProduct",
     },
     {
         title: "Delete Portal Product",
         summary: "Delete a product from a specific portal",
-        zodSchema: ProductArgsSchema,
+        inputSchema: ProductArgsSchema,
         handler: "deletePortalProduct",
         formatResponse: () => "Product deleted successfully.",
     },
     {
         title: "Update Portal Product",
         summary: "Update a product's settings within a specific portal.",
-        zodSchema: UpdateProductArgsSchema,
+        inputSchema: UpdateProductArgsSchema,
         handler: "updatePortalProduct",
     },
+    {
+        title: "Publish Portal Product",
+        summary: "Publish a product's content to make it live or as preview. This endpoint publishes the current content of a product, making it visible to portal visitors. Use preview mode to test before going live.",
+        inputSchema: PublishProductArgsSchema,
+        handler: "publishPortalProduct",
+    },
+    {
+        title: "List Portal Product Sections",
+        summary: "Get sections for a specific product within a portal.",
+        inputSchema: GetProductSectionsArgsSchema,
+        handler: "getPortalProductSections",
+    },
+    {
+        title: "Create Table Of Contents",
+        summary: "Create a new table of contents item in a portal product section. Supports API references, HTML content, and Markdown content types.",
+        inputSchema: CreateTableOfContentsArgsSchema,
+        handler: "createTableOfContents",
+    },
+    {
+        title: "List Table Of Contents",
+        summary: "Get table of contents for a section of a product within a portal.",
+        inputSchema: GetTableOfContentsArgsSchema,
+        handler: "getTableOfContents",
+    },
+    {
+        title: "Delete Table Of Contents",
+        summary: "Delete table of contents entry. Performs a soft-delete of an entry from the table of contents. Supports recursive deletion of nested items.",
+        inputSchema: DeleteTableOfContentsArgsSchema,
+        handler: "deleteTableOfContents",
+    },
+    // Document management tools
+    {
+        title: "Get Document",
+        summary: "Get document content and metadata by document ID. Useful for retrieving HTML or Markdown content from table of contents items.",
+        inputSchema: GetDocumentArgsSchema,
+        handler: "getDocument",
+    },
+    {
+        title: "Update Document",
+        summary: "Update the content of an existing document. Supports both HTML and Markdown content types.",
+        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",
         summary: "Search for APIs and Domains in SwaggerHub Registry using the comprehensive /specs endpoint and retrieve metadata including owner, name, description, summary, version, and specification.",
-        zodSchema: ApiSearchParamsSchema,
+        inputSchema: ApiSearchParamsSchema,
         handler: "searchApis",
     },
     {
         title: "Get API Definition",
         summary: "Fetch resolved API definition from SwaggerHub Registry based on owner, API name, and version.",
-        zodSchema: ApiDefinitionParamsSchema,
+        inputSchema: ApiDefinitionParamsSchema,
         handler: "getApiDefinition",
     },
     {
         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.",
-        zodSchema: CreateApiParamsSchema,
+        inputSchema: CreateApiParamsSchema,
         handler: "createOrUpdateApi",
     },
     {
         title: "Create API from Template",
         summary: "Create a new API in SwaggerHub Registry using a predefined template. This endpoint creates APIs based on existing templates without requiring manual definition content. APIs are always created with fixed values: private visibility, no project assignment, and reconciliation enabled (these values cannot be changed). Returns HTTP 201 for creation, HTTP 200 for update. Response includes 'operation' field and API details with SwaggerHub URL.",
-        zodSchema: CreateApiFromTemplateParamsSchema,
+        inputSchema: CreateApiFromTemplateParamsSchema,
         handler: "createApiFromTemplate",
     },
+    // User Management API tools for organization management functionality
+    {
+        title: "List Organizations",
+        summary: "Get organizations for a user. Returns a list of organizations that the authenticating user is a member of. On-Premise admin gets a list of all organizations in the system.",
+        inputSchema: OrganizationsQuerySchema,
+        handler: "getOrganizations",
+    },
+    {
+        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.",
+        inputSchema: ScanStandardizationParamsSchema,
+        handler: "scanStandardization",
+    },
 ];

package/dist/api-hub/client/user-management-types.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+// Query parameters for getting organizations
+export const OrganizationsQuerySchema = z.object({
+    q: z
+        .string()
+        .optional()
+        .describe("Search organizations by partial or full name (case-insensitive)"),
+    sortBy: z
+        .enum(["NAME", "EMAIL"])
+        .optional()
+        .describe("The property to sort the results by"),
+    order: z.enum(["ASC", "DESC"]).optional().describe("Sort order"),
+    page: z
+        .number()
+        .min(0)
+        .optional()
+        .describe("0-based index of the page to return"),
+    pageSize: z
+        .number()
+        .min(1)
+        .max(1000)
+        .optional()
+        .describe("Number of results per page to return"),
+});

package/dist/api-hub/client.js

@@ -44,6 +44,33 @@ export class ApiHubClient {
         const { productId, ...body } = args;
         return this.api.updatePortalProduct(productId, body);
     }
+    async publishPortalProduct(args) {
+        const { productId, preview } = args;
+        return this.api.publishPortalProduct(productId, preview);
+    }
+    async getPortalProductSections(args) {
+        const { productId, ...params } = args;
+        return this.api.getPortalProductSections(productId, params);
+    }
+    async createTableOfContents(args) {
+        const { sectionId, ...body } = args;
+        return this.api.createTableOfContents(sectionId, body);
+    }
+    async getTableOfContents(args) {
+        return this.api.getTableOfContents(args);
+    }
+    async getDocument(args) {
+        return this.api.getDocument(args);
+    }
+    async updateDocument(args) {
+        return this.api.updateDocument(args);
+    }
+    async deleteDocument(args) {
+        return this.api.deleteDocument(args);
+    }
+    async deleteTableOfContents(args) {
+        return this.api.deleteTableOfContents(args);
+    }
     // Registry API methods for SwaggerHub Design functionality
     async searchApis(args = {}) {
         return this.api.searchApis(args);
@@ -57,6 +84,13 @@ export class ApiHubClient {
     async createApiFromTemplate(args) {
         return this.api.createApiFromTemplate(args);
     }
+    // User Management API methods
+    async getOrganizations(args) {
+        return this.api.getOrganizations(args);
+    }
+    async scanStandardization(args) {
+        return this.api.scanStandardization(args);
+    }
     registerTools(register, _getInput) {
         TOOLS.forEach((tool) => {
             const { handler, formatResponse, ...toolParams } = tool;

package/dist/bugsnag/client/api/CurrentUser.js

@@ -1,41 +1,19 @@
-import { BaseAPI, pickFieldsFromArray } from "./base.js";
+import { CurrentUserApiFetchParamCreator, } from "./api.js";
+import { BaseAPI } from "./base.js";
 import { ProjectAPI } from "./Project.js";
-// --- API Class ---
 export class CurrentUserAPI extends BaseAPI {
-    static filterFields = [
-        "collaborators_url",
-        "projects_url",
-        "upgrade_url",
+    static organizationFields = [
+        "id",
+        "name",
+        "slug",
     ];
-    static organizationFields = ["id", "name", "slug"];
-    constructor(configuration) {
-        super(configuration, CurrentUserAPI.filterFields);
-    }
     /**
      * List the current user's organizations
      * GET /user/organizations
      */
-    async listUserOrganizations(options = {}) {
-        const { admin, ...queryOptions } = options;
-        const params = new URLSearchParams();
-        if (admin !== undefined)
-            params.append("admin", String(admin));
-        for (const [key, value] of Object.entries(queryOptions)) {
-            if (value !== undefined)
-                params.append(key, String(value));
-        }
-        const url = params.toString()
-            ? `/user/organizations?${params}`
-            : "/user/organizations";
-        const data = await this.request({
-            method: "GET",
-            url,
-        });
-        // Only return allowed fields
-        return {
-            ...data,
-            body: pickFieldsFromArray(data.body || [], CurrentUserAPI.organizationFields),
-        };
+    async listUserOrganizations(admin, perPage, options = {}) {
+        const localVarFetchArgs = CurrentUserApiFetchParamCreator(this.configuration).listUserOrganizations(admin, perPage, options);
+        return await this.requestArray(localVarFetchArgs.url, localVarFetchArgs.options, true, CurrentUserAPI.organizationFields);
     }
     /**
      * List projects for a given organization
@@ -44,23 +22,8 @@ export class CurrentUserAPI extends BaseAPI {
      * @param options Optional parameters for filtering, pagination, etc.
      * @returns A promise that resolves to the list of projects in the organization
      */
-    async getOrganizationProjects(organizationId, options = {}) {
-        const { ...queryOptions } = options;
-        const params = new URLSearchParams();
-        for (const [key, value] of Object.entries(queryOptions)) {
-            if (value !== undefined)
-                params.append(key, String(value));
-        }
-        const url = params.toString()
-            ? `/organizations/${organizationId}/projects?${params}`
-            : `/organizations/${organizationId}/projects`;
-        const data = await this.request({
-            method: "GET",
-            url,
-        });
-        return {
-            ...data,
-            body: pickFieldsFromArray(data.body || [], ProjectAPI.projectFields),
-        };
+    async getOrganizationProjects(organizationId, q, sort, direction, perPage, options) {
+        const localVarFetchArgs = CurrentUserApiFetchParamCreator(this.configuration).getOrganizationProjects(organizationId, q, sort, direction, perPage, options);
+        return await this.requestArray(localVarFetchArgs.url, localVarFetchArgs.options, true, ProjectAPI.projectFields);
     }
 }

package/dist/bugsnag/client/api/Error.js

@@ -1,177 +1,64 @@
-import { BaseAPI } from "./base.js";
-import { toQueryString } from "./filters.js";
-export const ErrorOperations = [
-    "override_severity",
-    "assign",
-    "create_issue",
-    "link_issue",
-    "unlink_issue",
-    "open",
-    "snooze",
-    "fix",
-    "ignore",
-    "delete",
-    "discard",
-    "undiscard",
-];
-export const ReopenConditions = [
-    "occurs_after",
-    "n_occurrences_in_m_hours",
-    "n_additional_occurrences",
-    "n_additional_users",
-];
-// --- API Class ---
+import { ErrorsApiFetchParamCreator, } from "./api.js";
+import { BaseAPI, getQueryParams } from "./base.js";
 export class ErrorAPI extends BaseAPI {
     static filterFields = ["url", "project_url", "events_url"];
-    constructor(configuration) {
-        super(configuration, ErrorAPI.filterFields);
-    }
     /**
      * View an Error on a Project
      * GET /projects/{project_id}/errors/{error_id}
      */
-    async viewErrorOnProject(projectId, errorId, options = {}) {
-        const params = new URLSearchParams();
-        for (const [key, value] of Object.entries(options)) {
-            if (value !== undefined)
-                params.append(key, String(value));
-        }
-        const url = params.toString()
-            ? `/projects/${projectId}/errors/${errorId}?${params}`
-            : `/projects/${projectId}/errors/${errorId}`;
-        return (await this.request({
-            method: "GET",
-            url,
-        }));
+    async viewErrorOnProject(projectId, errorId) {
+        const localVarFetchArgs = ErrorsApiFetchParamCreator(this.configuration).viewErrorOnProject(projectId, errorId);
+        return await this.requestObject(localVarFetchArgs.url, localVarFetchArgs.options);
     }
     /**
      * Get the latest Event in a Project, with optional filters
      * GET /projects/{project_id}/events
      */
-    async getLatestEventOnProject(projectId, queryString = "") {
-        const url = `/projects/${projectId}/events${queryString}`;
-        const response = await this.request({
-            method: "GET",
-            url,
-        });
-        return {
-            ...response,
-            body: response.body && response.body.length > 0
-                ? response.body[0]
-                : undefined, // Return only the latest event
-        };
+    async listEventsOnProject(projectId, base, sort, direction, perPage, filters, fullReports) {
+        const localVarFetchArgs = ErrorsApiFetchParamCreator(this.configuration).listEventsOnProject(projectId, base ?? undefined, sort, direction, perPage, undefined, fullReports, { query: filters });
+        return await this.requestArray(localVarFetchArgs.url, localVarFetchArgs.options, false);
     }
     /**
      * View an Event by ID
      * GET /projects/{project_id}/events/{event_id}
      */
-    async viewEventById(projectId, eventId, options = {}) {
-        const params = new URLSearchParams();
-        for (const [key, value] of Object.entries(options)) {
-            if (value !== undefined)
-                params.append(key, String(value));
-        }
-        const url = params.toString()
-            ? `/projects/${projectId}/events/${eventId}?${params}`
-            : `/projects/${projectId}/events/${eventId}`;
-        return (await this.request({
-            method: "GET",
-            url,
-        }));
+    async viewEventById(projectId, eventId) {
+        const localVarFetchArgs = ErrorsApiFetchParamCreator(this.configuration).viewEventById(projectId, eventId);
+        return await this.requestObject(localVarFetchArgs.url, localVarFetchArgs.options);
     }
     /**
      * List the Errors on a Project
      * GET /projects/{project_id}/errors
      */
-    async listProjectErrors(projectId, options = {}) {
-        let url = `/projects/${projectId}/errors`;
-        // Next links need to be used as-is to ensure results are consistent, so only the page size can be modified
-        if (options.next_url !== undefined) {
-            const nextUrl = new URL(options.next_url);
-            if (options.per_page !== undefined) {
-                nextUrl.searchParams.set("per_page", options.per_page.toString());
+    async listProjectErrors(projectId, base, sort, direction, perPage, filters, nextUrl) {
+        const options = getQueryParams(nextUrl, nextUrl ? undefined : filters);
+        if (nextUrl) {
+            if (perPage) {
+                // Next links need to be used as-is to ensure results are consistent, so only the page size can be modified
+                // the others will get overridden
+                options.query.per_page = perPage.toString();
             }
-            url = nextUrl.toString();
+            direction = undefined;
+            sort = undefined;
+            base = undefined;
         }
-        else {
-            const params = new URLSearchParams();
-            // Add filter parameters
-            if (options.filters) {
-                const filterParams = new URLSearchParams(toQueryString(options.filters));
-                filterParams.forEach((value, key) => {
-                    params.append(key, value);
-                });
-            }
-            // Add pagination and sorting parameters
-            if (options.base !== undefined) {
-                params.append("base", options.base);
-            }
-            if (options.sort !== undefined) {
-                params.append("sort", options.sort);
-            }
-            if (options.direction !== undefined) {
-                params.append("direction", options.direction);
-            }
-            if (options.per_page !== undefined) {
-                params.append("per_page", options.per_page.toString());
-            }
-            if (params.size > 0) {
-                url = `/projects/${projectId}/errors?${params}`;
-            }
-        }
-        return (await this.request({
-            method: "GET",
-            url,
-        }, false));
+        const localVarFetchArgs = ErrorsApiFetchParamCreator(this.configuration).listProjectErrors(projectId, base ?? undefined, sort, direction, perPage, undefined, options);
+        return await this.requestArray(localVarFetchArgs.url, localVarFetchArgs.options, false);
     }
     /**
      * Update an Error on a Project
      * PATCH /projects/{project_id}/errors/{error_id}
      */
-    async updateErrorOnProject(projectId, errorId, data, options = {}) {
-        const params = new URLSearchParams();
-        for (const [key, value] of Object.entries(options)) {
-            if (value !== undefined)
-                params.append(key, String(value));
-        }
-        const url = params.toString()
-            ? `/projects/${projectId}/errors/${errorId}?${params}`
-            : `/projects/${projectId}/errors/${errorId}`;
-        return (await this.request({
-            method: "PATCH",
-            url,
-            body: data,
-        }));
+    async updateErrorOnProject(projectId, errorId, body) {
+        const localVarFetchArgs = ErrorsApiFetchParamCreator(this.configuration).updateErrorOnProject(body, projectId, errorId);
+        return await this.requestObject(localVarFetchArgs.url, localVarFetchArgs.options);
     }
     /**
      * List Pivots on an Error
      * GET /projects/{project_id}/errors/{error_id}/pivots
      */
-    async listErrorPivots(projectId, errorId, options = {}) {
-        const params = new URLSearchParams();
-        if (options.filters) {
-            const filterParams = new URLSearchParams(toQueryString(options.filters));
-            filterParams.forEach((value, key) => {
-                params.append(key, value);
-            });
-        }
-        if (options.summary_size !== undefined) {
-            params.append("summary_size", options.summary_size.toString());
-        }
-        if (options.pivots && options.pivots.length > 0) {
-            options.pivots.forEach((pivot) => {
-                params.append("pivots[]", pivot);
-            });
-        }
-        if (options.per_page !== undefined) {
-            params.append("per_page", options.per_page.toString());
-        }
-        const url = params.toString()
-            ? `/projects/${projectId}/errors/${errorId}/pivots?${params}`
-            : `/projects/${projectId}/errors/${errorId}/pivots`;
-        return await this.request({
-            method: "GET",
-            url,
-        });
+    async getPivotValuesOnAnError(projectId, errorId, filters, summarySize, pivots, perPage) {
+        const localVarFetchArgs = ErrorsApiFetchParamCreator(this.configuration).listPivotsOnAnError(projectId, errorId, undefined, summarySize, pivots, perPage, { query: filters });
+        return await this.requestArray(localVarFetchArgs.url, localVarFetchArgs.options, false);
     }
 }