@smartbear/mcp 0.13.5 → 0.14.1

package/dist/bugsnag/client.js

@@ -28,7 +28,16 @@ const PERMITTED_UPDATE_OPERATIONS = [
   "fix",
   "ignore",
   "discard",
-  "undiscard"
+  "undiscard",
+  "snooze",
+  "link_issue",
+  "unlink_issue"
+];
+const PERMITTED_REOPEN_CONDITIONS = [
+  "occurs_after",
+  "n_occurrences_in_m_hours",
+  "n_additional_occurrences",
+  "n_additional_users"
 ];
 const ConfigurationSchema = z.object({
   auth_token: z.string().describe("BugSnag personal authentication token"),
@@ -656,7 +665,30 @@ class BugsnagClient {
     const updateErrorInputSchema = z.object({
       projectId: toolInputParameters.projectId,
       errorId: toolInputParameters.errorId,
-      operation: z.enum(PERMITTED_UPDATE_OPERATIONS).describe("The operation to apply to the error")
+      operation: z.enum(PERMITTED_UPDATE_OPERATIONS).describe("The operation to apply to the error"),
+      issue_url: z.string().optional().describe(
+        "The URL of the issue to link to the error - required when operation is 'link_issue'"
+      ),
+      reopenRules: z.object({
+        reopenIf: z.enum(PERMITTED_REOPEN_CONDITIONS).describe("Condition for when the error should be reopened"),
+        additionalUsers: z.number().min(1).max(1e5).optional().describe(
+          "for n_additional_users reopen rules, the number of additional users to be affected by an Error before the Error is automatically reopened."
+        ),
+        seconds: z.number().min(1).optional().describe(
+          "for occurs_after reopen rules, the number of seconds that the Error should be snoozed for."
+        ),
+        occurrences: z.number().min(1).optional().describe(
+          "for n_occurrences_in_m_hours reopen rules, the number of occurrences to allow in the number of hours indicated by the hours field, before the Error is automatically reopened."
+        ),
+        hours: z.number().min(1).optional().describe(
+          "for n_occurrences_in_m_hours reopen rules, the number of hours."
+        ),
+        additionalOccurrences: z.number().min(1).optional().describe(
+          "or n_additional_occurrences reopen rules, the number of additional occurrences allowed before reopening."
+        )
+      }).optional().describe(
+        "Reopen rules for snooze operation - required when operation is 'snooze'"
+      )
     });
     register(
       {
@@ -666,7 +698,8 @@ class BugsnagClient {
         useCases: [
           "Mark an error as open, fixed or ignored",
           "Discard or un-discard an error",
-          "Update the severity of an error"
+          "Update the severity of an error",
+          "Snooze an error with defined conditions for when it should be reopened"
         ],
         inputSchema: updateErrorInputSchema,
         examples: [
@@ -677,10 +710,72 @@ class BugsnagClient {
               operation: "fix"
             },
             expectedOutput: "Success response indicating the error was marked as fixed"
+          },
+          {
+            description: "Snooze an error for 1 hour",
+            parameters: {
+              errorId: "6863e2af8c857c0a5023b411",
+              operation: "snooze",
+              reopenRules: {
+                reopenIf: "occurs_after",
+                seconds: 3600
+              }
+            },
+            expectedOutput: "Success response indicating the error was snoozed for 1 hour"
+          },
+          {
+            description: "Snooze an error until 5 additional users are affected",
+            parameters: {
+              errorId: "6863e2af8c857c0a5023b411",
+              operation: "snooze",
+              reopenRules: {
+                reopenIf: "n_additional_users",
+                additionalUsers: 5
+              }
+            },
+            expectedOutput: "Success response indicating the error was snoozed until 5 additional users are affected"
+          },
+          {
+            description: "Snooze an error until 10 occurrences in 24 hours",
+            parameters: {
+              errorId: "6863e2af8c857c0a5023b411",
+              operation: "snooze",
+              reopenRules: {
+                reopenIf: "n_occurrences_in_m_hours",
+                occurrences: 10,
+                hours: 24
+              }
+            },
+            expectedOutput: "Success response indicating the error was snoozed until 10 occurrences in 24 hours"
+          },
+          {
+            description: "Link a Jira issue to an error",
+            parameters: {
+              errorId: "6863e2af8c857c0a5023b411",
+              operation: "link_issue",
+              issue_url: "https://smartbear.atlassian.net/browse/PIPE-9547"
+            },
+            expectedOutput: "Success response indicating the Jira issue was linked to the error"
+          },
+          {
+            description: "Unlink a Jira issue from an error",
+            parameters: {
+              errorId: "6863e2af8c857c0a5023b411",
+              operation: "unlink_issue"
+            },
+            expectedOutput: "Success response indicating the Jira issue was unlinked from the error"
           }
         ],
         hints: [
-          "Only use valid operations - BugSnag may reject invalid values"
+          "Only use valid operations - BugSnag may reject invalid values",
+          "When using 'snooze' operation, reopenRules parameter is required",
+          "When using 'link_issue' operation, issue_url parameter is required",
+          "Use 'unlink_issue' to remove the link between an error and its issue",
+          "For 'occurs_after' reopen rules, specify 'seconds' parameter",
+          "For 'n_additional_users' reopen rules, specify 'additionalUsers' parameter (max 100,000)",
+          "For 'n_occurrences_in_m_hours' reopen rules, specify both 'occurrences' and 'hours' parameters",
+          "For 'n_additional_occurrences' reopen rules, specify 'additionalOccurrences' parameter",
+          "Snoozing temporarily silences an error until the specified reopen condition is met"
         ],
         readOnly: false,
         idempotent: false
@@ -688,6 +783,39 @@ class BugsnagClient {
       async (args, _extra) => {
         const params = updateErrorInputSchema.parse(args);
         const project = await this.getInputProject(params.projectId);
+        if (params.operation === "snooze" && !params.reopenRules) {
+          throw new ToolError(
+            "reopenRules parameter is required when using 'snooze' operation"
+          );
+        }
+        if (params.operation === "link_issue" && !params.issue_url) {
+          throw new ToolError(
+            "'issue_url' parameter is required for 'link_issue' operation"
+          );
+        }
+        if (params.reopenRules) {
+          const { reopenIf } = params.reopenRules;
+          if (reopenIf === "occurs_after" && !params.reopenRules.seconds) {
+            throw new ToolError(
+              "'seconds' parameter is required for 'occurs_after' reopen rules"
+            );
+          }
+          if (reopenIf === "n_additional_users" && !params.reopenRules.additionalUsers) {
+            throw new ToolError(
+              "'additionalUsers' parameter is required for 'n_additional_users' reopen rules"
+            );
+          }
+          if (reopenIf === "n_occurrences_in_m_hours" && (!params.reopenRules.occurrences || !params.reopenRules.hours)) {
+            throw new ToolError(
+              "Both 'occurrences' and 'hours' parameters are required for 'n_occurrences_in_m_hours' reopen rules"
+            );
+          }
+          if (reopenIf === "n_additional_occurrences" && !params.reopenRules.additionalOccurrences) {
+            throw new ToolError(
+              "'additionalOccurrences' parameter is required for 'n_additional_occurrences' reopen rules"
+            );
+          }
+        }
         let severity;
         if (params.operation === "override_severity") {
           const result2 = await getInput({
@@ -708,15 +836,46 @@ class BugsnagClient {
             severity = result2.content.severity;
           }
         }
+        let reopenRules;
+        if (params.reopenRules) {
+          reopenRules = {
+            reopen_if: params.reopenRules.reopenIf
+          };
+          if (params.reopenRules.additionalUsers !== void 0) {
+            reopenRules.additional_users = params.reopenRules.additionalUsers;
+          }
+          if (params.reopenRules.seconds !== void 0) {
+            reopenRules.seconds = params.reopenRules.seconds;
+          }
+          if (params.reopenRules.occurrences !== void 0) {
+            reopenRules.occurrences = params.reopenRules.occurrences;
+          }
+          if (params.reopenRules.hours !== void 0) {
+            reopenRules.hours = params.reopenRules.hours;
+          }
+          if (params.reopenRules.additionalOccurrences !== void 0) {
+            reopenRules.additional_occurrences = params.reopenRules.additionalOccurrences;
+          }
+        }
+        const errorUpdateRequestBody = {
+          operation: Object.values(ErrorUpdateRequest.OperationEnum).find(
+            (value) => value === params.operation
+          )
+        };
+        if (severity !== void 0) {
+          errorUpdateRequestBody.severity = severity;
+        }
+        if (reopenRules !== void 0) {
+          errorUpdateRequestBody.reopen_rules = reopenRules;
+        }
+        if (params.operation === "link_issue" && params.issue_url) {
+          errorUpdateRequestBody.issue_url = params.issue_url;
+          errorUpdateRequestBody.verify_issue_url = true;
+        }
         const result = await this.errorsApi.updateErrorOnProject(
           project.id,
           params.errorId,
-          {
-            operation: Object.values(ErrorUpdateRequest.OperationEnum).find(
-              (value) => value === params.operation
-            ),
-            severity
-          }
+          errorUpdateRequestBody
         );
         return {
           content: [

package/dist/package.json.js

@@ -1,4 +1,4 @@
-const version = "0.13.5";
+const version = "0.14.1";
 const config = { "mcpServerName": "SmartBear MCP Server" };
 const packageJson = {
   version,

package/dist/pactflow/client/utils.js

@@ -43,12 +43,18 @@ async function getRemoteSpecContents(openAPISchema) {
     try {
       return yaml.load(specRawBody);
     } catch (yamlError) {
-      throw new ToolError(
-        `Unsupported Content-Type: ${remoteSpec.headers.get(
-          "Content-Type"
-        )} for remote OpenAPI document. Found following parse errors:-
+      const isStdioTransport = process.env.MCP_TRANSPORT?.toLowerCase() === "stdio";
+      if (isStdioTransport) {
+        throw new ToolError(
+          `Unsupported Content-Type: ${remoteSpec.headers.get(
+            "Content-Type"
+          )} for remote OpenAPI document. Found following parse errors:-
 JSON parse error: ${jsonError}
 YAML parse error: ${yamlError}`
+        );
+      }
+      throw new ToolError(
+        `Failed to parse remote OpenAPI document. Ensure the URL returns valid JSON or YAML content.`
       );
     }
   }

package/dist/swagger/client/portal-types.js

@@ -60,6 +60,9 @@ const CreateTableOfContentsArgsSchema = z.object({
     type: z.enum(["apiUrl", "html", "markdown"]).describe(
       "Content type - 'apiUrl' for API references, 'html' for HTML content, or 'markdown' for Markdown content"
     ),
+    source: z.enum(["internal", "external"]).optional().describe(
+      "Source of the document content - 'internal' allows to edit content in both UI and API, 'external' enables editing only via API."
+    ),
     url: z.string().optional().describe(
       "URL for API reference content (required when type is 'apiUrl')"
     ),
@@ -186,11 +189,14 @@ const GetDocumentArgsSchema = z.object({
 });
 const UpdateDocumentArgsSchema = z.object({
   documentId: z.string().describe("Document UUID - unique identifier for the document"),
-  content: z.string().describe(
+  content: z.string().optional().describe(
     "The document content to update (HTML or Markdown based on document type)"
   ),
   type: z.enum(["html", "markdown"]).optional().describe(
     "Content type - 'html' for HTML content or 'markdown' for Markdown content"
+  ),
+  source: z.enum(["internal", "external"]).optional().describe(
+    "Source of the document content - 'internal' allows to edit content in both UI and API, 'external' enables editing only via API."
   )
 });
 const DeleteTableOfContentsArgsSchema = z.object({

package/dist/swagger/client/tools.js

@@ -96,7 +96,7 @@ const TOOLS = [
   },
   {
     title: "Update Document",
-    summary: "Update the content of an existing document. Supports both HTML and Markdown content types.",
+    summary: "Update the content or source of an existing document. Supports both HTML and Markdown content types.",
     inputSchema: UpdateDocumentArgsSchema,
     handler: "updateDocument"
   },

package/dist/zephyr/client.js

@@ -5,10 +5,16 @@ 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 { CreateTestCase } from "./tool/test-case/create-test-case.js";
+import { CreateTestCaseWebLink } from "./tool/test-case/create-web-link.js";
 import { GetTestCase } from "./tool/test-case/get-test-case.js";
 import { GetTestCases } from "./tool/test-case/get-test-cases.js";
+import { UpdateTestCase } from "./tool/test-case/update-test-case.js";
+import { CreateTestCycle } from "./tool/test-cycle/create-test-cycle.js";
 import { GetTestCycle } from "./tool/test-cycle/get-test-cycle.js";
 import { GetTestCycles } from "./tool/test-cycle/get-test-cycles.js";
+import { UpdateTestCycle } from "./tool/test-cycle/update-test-cycle.js";
+import { CreateTestExecution } from "./tool/test-execution/create-test-execution.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";
@@ -47,7 +53,13 @@ class ZephyrClient {
       new GetEnvironments(this),
       new GetTestCase(this),
       new GetTestExecution(this),
-      new GetTestExecutions(this)
+      new GetTestExecutions(this),
+      new CreateTestCase(this),
+      new CreateTestCycle(this),
+      new UpdateTestCase(this),
+      new UpdateTestCycle(this),
+      new CreateTestExecution(this),
+      new CreateTestCaseWebLink(this)
     ];
     for (const tool of tools) {
       register(tool.specification, tool.handle);

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

@@ -25,6 +25,28 @@ class ApiClient {
     });
     return await this.validateAndGetResponseBody(response);
   }
+  async post(endpoint, body) {
+    const response = await fetch(this.getUrl(endpoint), {
+      method: "POST",
+      headers: {
+        ...this.defaultHeaders,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
+  async put(endpoint, body) {
+    const response = await fetch(this.getUrl(endpoint), {
+      method: "PUT",
+      headers: {
+        ...this.defaultHeaders,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    return await this.validateAndGetResponseBody(response);
+  }
   async validateAndGetResponseBody(response) {
     if (!response.ok) {
       const errorText = await response.text();
@@ -32,7 +54,19 @@ class ApiClient {
         `Request failed with status ${response.status}: ${errorText}`
       );
     }
-    return response.json();
+    const contentLength = response.headers.get("content-length");
+    if (response.status === 204 || contentLength === "0") {
+      return {};
+    }
+    const text = await response.text();
+    if (!text?.trim()) {
+      return {};
+    }
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { data: text };
+    }
   }
 }
 export {