@smartbear/mcp 0.14.1 → 0.16.0

package/dist/bugsnag/tool/release/get-release.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  releaseId: toolInputParameters.releaseId
+});
+class GetRelease extends Tool {
+  specification = {
+    title: "Get Release",
+    summary: "Get more details for a specific release by its ID, including source control information and associated builds",
+    purpose: "Retrieve detailed information about a release for analysis and debugging",
+    useCases: [
+      "View release metadata such as version, source control info, and error counts",
+      "Analyze the stability data and targets for a release",
+      "See the builds that make up the release"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get details for a specific release",
+        parameters: {
+          releaseId: "5f8d0d55c9e77c0017a1b2c3"
+        },
+        expectedOutput: "JSON object with release details including version, source control info, error counts and stability data."
+      }
+    ],
+    hints: ["Release IDs can be found using the List releases tool"],
+    readOnly: true,
+    idempotent: true,
+    outputDescription: "JSON object containing release details along with stability metrics such as user and session stability, and whether it meets project targets"
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const releaseResponse = await this.client.projectApi.getReleaseGroup(
+      params.releaseId
+    );
+    if (!releaseResponse.body)
+      throw new ToolError(`No release for ${params.releaseId} found.`);
+    const release = this.client.addStabilityData(releaseResponse.body, project);
+    let builds = [];
+    if (releaseResponse.body) {
+      const buildsResponse = await this.client.projectApi.listBuildsInRelease(
+        params.releaseId
+      );
+      if (buildsResponse.body) {
+        builds = buildsResponse.body.map(
+          (b) => this.client.addStabilityData(b, project)
+        );
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            release,
+            builds
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  GetRelease
+};

package/dist/bugsnag/tool/release/list-releases.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { Tool } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  releaseStage: toolInputParameters.releaseStage,
+  visibleOnly: z.boolean().describe(
+    "Whether to only include releases that are marked as visible in the dashboard"
+  ).default(false),
+  perPage: toolInputParameters.perPage,
+  nextUrl: toolInputParameters.nextUrl
+});
+class ListReleases extends Tool {
+  specification = {
+    title: "List Releases",
+    summary: "List releases for a project",
+    purpose: "Retrieve a list of release summaries to analyze deployment history and associated errors",
+    useCases: [
+      "View recent releases to correlate with error spikes",
+      "Filter releases by stage (e.g. production, staging) for targeted analysis"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "List production releases for a project",
+        parameters: {},
+        expectedOutput: "JSON array of release objects in the production stage"
+      },
+      {
+        description: "List staging releases for a project",
+        parameters: {
+          releaseStage: "staging"
+        },
+        expectedOutput: "JSON array of release objects in the staging stage"
+      },
+      {
+        description: "Get the next page of results",
+        parameters: {
+          nextUrl: "/projects/515fb9337c1074f6fd000003/releases?offset=30&per_page=30"
+        },
+        expectedOutput: "JSON array of release objects with metadata from the next page"
+      }
+    ],
+    hints: [
+      "Use the Get Release tool to get more details on a specific release, including the builds it contains",
+      "The release stage defaults to 'production' if not specified",
+      "Use visibleOnly to filter out releases that have been marked as hidden in the dashboard"
+    ],
+    readOnly: true,
+    idempotent: true,
+    outputDescription: "JSON array of release summary objects with metadata, with a URL to the next page if more results are available"
+  };
+  handle = async (args, _extra) => {
+    const params = inputSchema.parse(args);
+    const project = await this.client.getInputProject(params.projectId);
+    const response = await this.client.projectApi.listProjectReleaseGroups(
+      project.id,
+      params.releaseStage,
+      false,
+      // Not top-only
+      params.visibleOnly,
+      params.perPage,
+      params.nextUrl
+    );
+    let releases = [];
+    if (response.body) {
+      releases = response.body.map(
+        (r) => this.client.addStabilityData(r, project)
+      );
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            data: releases,
+            next_url: response.nextUrl ?? void 0,
+            data_count: releases.length,
+            total_count: response.totalCount ?? void 0
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  ListReleases
+};

package/dist/common/prompts.js

@@ -0,0 +1,9 @@
+class Prompt {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+}
+export {
+  Prompt
+};

package/dist/common/server.js

@@ -10,6 +10,7 @@ class SmartBearMcpServer extends McpServer {
   cache;
   samplingSupported = false;
   elicitationSupported = false;
+  clients = [];
   constructor() {
     super(
       {
@@ -17,6 +18,15 @@ class SmartBearMcpServer extends McpServer {
         version: MCP_SERVER_VERSION
       },
       {
+        instructions: `When creating or editing a Reflect test using a connected recording session, follow these guidelines:
+
+1. After connecting to a session, get the list of segments for the session's platform type so you know what actions could be added via segments vs needing to create new steps. Do not list tests, only list segments.
+2. Before performing an action, take a screenshot to understand the current state of the application.
+3. Each add_prompt_step request should perform a single action or assertion. Do not combine multiple actions or assertions into a single step.
+4. Only perform one action at a time unless you're sure the action won't move the application to a different screen. For example, you can send multiple add_prompt_step requests to fill out individual form fields if those fields are visible on the current screen.
+5. Check the list of existing Segments to see if a Segment exists that achieves a similar goal to what you're trying to do next. If so, add the segment instead of creating new steps.
+6. If a step fails, use delete_previous_step to remove it and try a different approach.
+7. After completing a task, if the task required multiple prompt steps, add a final prompt step that validates the current state of the page based on what you see on the screen. In your validation, do not reference information that can change from run to run.`,
         capabilities: {
           resources: { listChanged: true },
           // Server supports dynamic resource lists
@@ -46,7 +56,13 @@ class SmartBearMcpServer extends McpServer {
   isElicitationSupported() {
     return this.elicitationSupported;
   }
+  async cleanupSession(mcpSessionId) {
+    for (const client of this.clients) {
+      await client.cleanupSession?.(mcpSessionId);
+    }
+  }
   async addClient(client) {
+    this.clients.push(client);
     await client.registerTools(
       (params, cb) => {
         const toolName = `${client.toolPrefix}_${params.title.replace(/\s+/g, "_").toLowerCase()}`;

package/dist/common/transport-http.js

@@ -153,6 +153,7 @@ async function createNewTransport(req, res, transports) {
     if (transport.sessionId) {
       console.log(`[MCP] Session closed: ${transport.sessionId}`);
       transports.delete(transport.sessionId);
+      server.cleanupSession(transport.sessionId);
     }
   };
   await server.connect(transport);
@@ -205,6 +206,7 @@ async function handleLegacySseRequest(req, res, transports) {
   transports.set(transport.sessionId, { server, transport });
   res.on("close", () => {
     transports.delete(transport.sessionId);
+    server.cleanupSession(transport.sessionId);
   });
   await server.connect(transport);
 }

package/dist/package.json.js

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

package/dist/qmetry/client/api/client-api.js

@@ -13,7 +13,8 @@ async function qmetryRequest({
   const headers = {
     apikey: token,
     project: project || QMETRY_DEFAULTS.PROJECT_KEY,
-    "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`
+    "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+    "qmetry-source": "smartbear-mcp"
   };
   if (body) {
     headers["Content-Type"] = "application/json";

package/dist/qmetry/client/automation.js

@@ -91,7 +91,8 @@ async function importAutomationResults(token, baseUrl, project, payload) {
   const headers = {
     apikey: token,
     project: finalPayload.projectID || project || QMETRY_DEFAULTS.PROJECT_KEY,
-    "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`
+    "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+    "qmetry-source": "smartbear-mcp"
     // Note: Content-Type will be set automatically by fetch for FormData
   };
   let res;

package/dist/qmetry/client/tools/testcase-tools.js

@@ -254,7 +254,7 @@ const TESTCASE_TOOLS = [
           versionComment: "version 2 with preserved steps",
           notruncurrent: true,
           notrunall: true,
-          isStepUpdated: false
+          isStepUpdated: true
         },
         expectedOutput: "New version 2 created with all steps from version 1 preserved. Steps carry forward with their tcStepID values. Version comment added for tracking."
       },
@@ -267,6 +267,70 @@ const TESTCASE_TOOLS = [
           name: "New Name"
         },
         expectedOutput: "Metadata updated only. Steps unchanged. tcID/tcVersionID auto-resolved. Existing version modified."
+      },
+      {
+        description: "Create NEW VERSION from existing version 2 with updated steps (working payload for linked test cases)",
+        parameters: {
+          tcID: 4594145,
+          tcVersionID: 5536706,
+          tcVersion: 2,
+          name: "Mock Test Case - E-commerce Checkout Flow - v3",
+          steps: [
+            {
+              orderId: 1,
+              description: "Open browser and navigate to e-commerce website",
+              expectedOutcome: "Homepage loads successfully with product catalog",
+              inputData: "URL: https://example-shop.com",
+              tcStepID: 38129471
+            },
+            {
+              orderId: 2,
+              description: "Search for product",
+              expectedOutcome: "Search results display relevant products",
+              inputData: "Search term: 'wireless headphones'",
+              tcStepID: 38129475
+            },
+            {
+              orderId: 3,
+              description: "Select product and add to cart",
+              expectedOutcome: "Product added to cart, cart counter increments",
+              inputData: "Click 'Add to Cart' button",
+              tcStepID: 38129472
+            },
+            {
+              orderId: 4,
+              description: "Proceed to checkout",
+              expectedOutcome: "Checkout page displays with cart summary",
+              inputData: "Click cart icon and 'Proceed to Checkout'",
+              tcStepID: 38129473
+            },
+            {
+              orderId: 5,
+              description: "Complete payment",
+              expectedOutcome: "Order confirmation page displayed",
+              inputData: "Fill payment details and submit",
+              tcStepID: 38129474
+            },
+            {
+              orderId: 6,
+              description: "Verify order confirmation email received",
+              expectedOutcome: "Email with order details received in inbox",
+              inputData: "Check email account for confirmation"
+            },
+            {
+              orderId: 7,
+              description: "Check order status in account dashboard",
+              expectedOutcome: "Order status shows as 'Processing' with tracking information",
+              inputData: "Navigate to My Orders section"
+            }
+          ],
+          withVersion: true,
+          versionComment: "Created version 3: Added 2 new verification steps (email and order status check)",
+          notrunall: false,
+          notruncurrent: false,
+          scope: "project"
+        },
+        expectedOutput: "New version 3 created successfully from version 2. Test case now has 7 steps (5 preserved + 2 new). Key: tcVersion=2 was used because version 2 already existed in system. notrunall and notruncurrent both false (not true). Result shows tcVersion: 3 in response with new tcVersionID."
       }
     ],
     hints: [
@@ -444,6 +508,210 @@ const TESTCASE_TOOLS = [
       "- Pitfall 5: Not including tcStepID for steps when creating version → Steps may duplicate instead of preserving",
       "- Pitfall 6: Confusing tcVersionID (version identifier) with tcVersion (version number) → Wrong API payload",
       "",
+      "CRITICAL ERROR HANDLING: TC.VERSION_NOT_SYNCED FOR LINKED TEST CASES",
+      "",
+      "PROBLEM: Test cases linked to test suites or with existing executions cannot be updated directly",
+      "TRIGGERS:",
+      "  ✓ Test case is linked to one or more test suites",
+      "  ✓ Test case has execution history (test runs exist)",
+      "  ✓ Test case is part of a release/cycle with test runs",
+      "  ✓ Any step modification when test case has associations",
+      "",
+      "ERROR CODE: TC.VERSION_NOT_SYNCED",
+      "ERROR MESSAGE: 'This Test Case has been associated. Create a new version to save modifications.'",
+      "",
+      "AUTOMATIC RETRY STRATEGY (IMPLEMENT THIS PATTERN):",
+      "When you receive TC.VERSION_NOT_SYNCED error, AUTOMATICALLY retry with version creation:",
+      "DO NOT ask user for confirmation - this is expected behavior for associated test cases",
+      "",
+      "1. FIRST ATTEMPT (Normal Update):",
+      "   - Try updating with isStepUpdated=true (for step changes) or without withVersion flag",
+      "   - If error code is TC.VERSION_NOT_SYNCED, proceed to step 2",
+      "   - If error is different, report the error to user",
+      "",
+      "2. AUTOMATIC RETRY (Version Creation):",
+      "   - Use the SAME tcID, tcVersionID, and steps array from first attempt",
+      "   - Add these flags to payload:",
+      "     * withVersion: true (CRITICAL - enables version creation)",
+      "     * tcVersion: <current version number> (get from test case details or executions)",
+      "     * notrunall: false (use false, not true)",
+      "     * notruncurrent: false (use false, not true)",
+      "     * scope: 'project' (always required)",
+      "     * versionComment: 'Auto-created version due to test suite association' (or custom message)",
+      "   - Set isStepUpdated: true whenever you modify steps (including when withVersion=true)",
+      "   - IMPORTANT: Include ALL existing steps with tcStepID + new steps without tcStepID",
+      "",
+      "3. VERIFICATION:",
+      "   - Check response for new tcVersionID (will be different from source)",
+      "   - Verify tcVersion incremented (e.g., 1→2, 2→3)",
+      "   - Confirm success message: 'Test Case <entityKey> updated successfully'",
+      "",
+      "UI BEHAVIOR COMPARISON:",
+      "QMetry UI shows a popup: 'Save as new version?' with optional comment field",
+      "API equivalent: Automatic retry with withVersion=true after detecting TC.VERSION_NOT_SYNCED",
+      "",
+      "REAL-WORLD EXAMPLE FROM UI PAYLOADS:",
+      "",
+      "First Attempt (FAILS with TC.VERSION_NOT_SYNCED):",
+      "```pseudo",
+      "{",
+      '  "tcID": 4594140,',
+      '  "tcVersionID": 5536696,',
+      '  "withVersion": false,',
+      '  "notrunall": false,',
+      '  "steps": [',
+      "    // ... 5 existing steps with tcStepID ...",
+      "    // ... 1 new step without tcStepID (orderId: 6) ...",
+      "  ],",
+      '  "removeSteps": [],',
+      '  "isStepUpdated": true',
+      "}",
+      "```",
+      "Response: 400 - TC.VERSION_NOT_SYNCED error",
+      "",
+      "Second Attempt (SUCCEEDS - Creates Version 2):",
+      "```pseudo",
+      "{",
+      '  "withVersion": true,          // NEW: Version creation flag',
+      '  "notrunall": false,',
+      '  "notruncurrent": false,',
+      '  "steps": [',
+      "    // SAME steps array as first attempt",
+      "    // ... 5 existing steps with tcStepID ...",
+      "    // ... 1 new step without tcStepID ...",
+      "  ],",
+      '  "removeSteps": [],',
+      '  "scope": "project",',
+      '  "tcID": 4594140,              // SAME tcID',
+      '  "tcVersion": 1,               // NEW: Current version number',
+      '  "tcVersionID": 5536696,       // SAME tcVersionID (source version)',
+      '  "versionComment": "test",     // NEW: Version comment (optional)',
+      "  // NOTE: isStepUpdated field is NOT included when withVersion=true",
+      "}",
+      "```",
+      "Response: 200 - Success, new tcVersionID created (e.g., 5536697), tcVersion=2",
+      "",
+      "IMPLEMENTATION PSEUDO-CODE:",
+      "```typescript",
+      "try {",
+      "  // First attempt: Normal update",
+      "  const response = await updateTestCase({",
+      "    tcID, tcVersionID, steps, isStepUpdated: true",
+      "  });",
+      "} catch (error) {",
+      "  if (error.code === 'TC.VERSION_NOT_SYNCED') {",
+      "    // Automatic retry with version creation",
+      "    const testCaseDetails = await fetchTestCaseDetails(tcID);",
+      "    // CRITICAL: Use the LATEST version number from system",
+      "    const latestVersion = testCaseDetails.tcVersion;  // e.g., 2 if v2 exists",
+      "    const response = await updateTestCase({",
+      "      tcID,",
+      "      tcVersionID,  // Same source version",
+      "      tcVersion: latestVersion,  // Use latest version number (not always 1!)",
+      "      steps,  // Same steps array",
+      "      // DO NOT include isStepUpdated when withVersion=true",
+      "      withVersion: true,  // Enable version creation",
+      "      notrunall: false,  // Use false (verified working value)",
+      "      notruncurrent: false,  // Use false (verified working value)",
+      "      scope: 'project',  // Always required",
+      "      versionComment: 'Auto-created version due to test suite association'",
+      "    });",
+      "  } else {",
+      "    throw error;  // Different error, report to user",
+      "  }",
+      "}",
+      "```",
+      "",
+      "KEY INSIGHTS:",
+      "- DO NOT ask user for confirmation - auto-retry is expected behavior",
+      "- Use SAME tcVersionID in both attempts (source version for creation)",
+      "- Second attempt creates NEW version (tcVersionID changes in response)",
+      "- Steps array is IDENTICAL in both attempts",
+      "- tcVersion parameter is ONLY in second attempt (withVersion=true)",
+      "- This matches QMetry UI behavior where popup auto-triggers version creation",
+      "",
+      "CRITICAL: INCREMENTAL tcVersion SELECTION RULE",
+      "",
+      "PROBLEM: When multiple versions exist, which tcVersion should you use?",
+      "SOLUTION: Use the VERSION NUMBER of the version you are creating FROM (the latest existing version)",
+      "",
+      "RULE: When creating a new version, tcVersion must equal the CURRENT LATEST VERSION in the system",
+      "",
+      "EXAMPLES:",
+      "- If only version 1 exists: Use tcVersion: 1 (creates version 2 from v1)",
+      "- If version 1 and 2 exist: Use tcVersion: 2 (creates version 3 from v2)",
+      "- If version 1, 2, and 3 exist: Use tcVersion: 3 (creates version 4 from v3)",
+      "",
+      "WORKFLOW TO DETERMINE CORRECT tcVersion:",
+      "1. Call FETCH_TEST_CASE_DETAILS or FETCH_TEST_CASE_EXECUTIONS",
+      "2. Check the highest tcVersion number in the system",
+      "3. Use that number as your tcVersion parameter in the update payload",
+      "4. This ensures you're creating from the latest version, not an old one",
+      "",
+      "REAL-WORLD SCENARIO:",
+      "Scenario: Test case VKMCP-TC-43 has version 2 already created in UI",
+      "Wrong Approach (will fail): tcVersion: 1, withVersion: true → TC.VERSION_NOT_SYNCED error",
+      "Correct Approach (will succeed): tcVersion: 2, withVersion: true → Creates version 3 successfully",
+      "",
+      "VERIFIED WORKING PAYLOAD (from user's Postman testing):",
+      "```json",
+      "{",
+      '  "notrunall": false,',
+      '  "notruncurrent": false,',
+      '  "scope": "project",',
+      '  "tcID": 4594145,',
+      '  "tcVersion": 2,                        // KEY: Use version 2 because v2 already exists',
+      '  "tcVersionID": 5536706,                // Source version ID (stays same)',
+      '  "versionComment": "Added new steps",  // Describes what changed',
+      '  "withVersion": true,                   // Enable version creation',
+      '  "steps": [',
+      "    // 5 existing steps with tcStepID (preserved from source)",
+      "    // 2 new steps without tcStepID (to be added)",
+      "  ]",
+      "}",
+      "```",
+      "Result: New version 3 created successfully with 7 total steps",
+      "",
+      "DEFAULT VALUES FOR TC.VERSION_NOT_SYNCED RETRIES (THIS PATTERN):",
+      "- notrunall: false - For this retry pattern, override any usual `true` default",
+      "- notruncurrent: false - For this retry pattern, override any usual `true` default",
+      '- scope: "project" - Always use this',
+      "- withVersion: true - Required when creating a new version (both initial and retries)",
+      "",
+      "WHEN TO APPLY THIS PATTERN:",
+      "✓ Adding steps to test case linked to test suite",
+      "✓ Editing steps in test case with existing executions",
+      "✓ Removing steps from associated test case",
+      "✓ Any modification to steps when TC.VERSION_NOT_SYNCED occurs",
+      "✓ When creating new versions from existing versions (always check latest version number)",
+      "",
+      "WHEN NOT TO APPLY:",
+      "✗ Test case is NOT linked to test suite (normal update works)",
+      "✗ Only updating metadata (name, priority, etc.) without steps",
+      "✗ Different error codes (handle appropriately)",
+      "",
+      "BENEFITS OF THIS APPROACH:",
+      "1. Seamless UX - LLM handles version creation automatically",
+      "2. Matches UI behavior - no manual intervention needed",
+      "3. Preserves test history - creates proper version trail",
+      "4. Maintains test suite linkage - version creation preserves associations",
+      "5. Handles incremental versions correctly - uses latest version as source",
+      "",
+      "🎯 GRACEFUL HANDLING SUMMARY:",
+      "",
+      "When adding/editing/removing steps from test cases:",
+      "1. Always TRY normal update first (without withVersion flag)",
+      "2. If TC.VERSION_NOT_SYNCED error received:",
+      "   - Fetch latest version number from test case details/executions",
+      "   - Automatically retry with withVersion=true + correct tcVersion",
+      "   - Use notrunall=false, notruncurrent=false, scope='project'",
+      "   - Include version comment describing the changes",
+      "3. Report success with new version details to user",
+      "4. NEVER ask for confirmation - handle it transparently",
+      "",
+      "This ensures test cases with executions or suite associations are handled gracefully",
+      "without user intervention, matching the QMetry UI experience exactly.",
+      "",
       "executionMinutes time is in minutes (legacy field).",
       "estimatedTime is in seconds (preferred for version creation).",
       "Description and testingType are optional but recommended for clarity."

package/dist/qmetry/client/tools/testsuite-tools.js

@@ -947,7 +947,7 @@ const TESTSUITE_TOOLS = [
     hints: [
       "CRITICAL: entityIDs, entityType, qmTsRunId, and runStatusID are REQUIRED parameters",
       "",
-      "⚠️ CRITICAL - ALWAYS FETCH STATUS IDs FROM PROJECT INFO:",
+      "CRITICAL - ALWAYS FETCH STATUS IDs FROM PROJECT INFO:",
       "NEVER use hardcoded or memorized status IDs. Status IDs are PROJECT-SPECIFIC and must be fetched dynamically.",
       "MANDATORY WORKFLOW BEFORE USING runStatusID:",
       "1. Call mcp_smartbear_qmetry_fetch_qmetry_project_info with the current projectKey",