@smartbear/mcp 0.15.0 → 0.17.0

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

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { toolInputParameters } from "../../input-schemas.js";
+const inputSchema = z.object({
+  projectId: toolInputParameters.projectId,
+  buildId: toolInputParameters.buildId
+});
+class GetBuild extends Tool {
+  specification = {
+    title: "Get Build",
+    summary: "Get more details for a specific build by its ID",
+    purpose: "Retrieve detailed information about a build for analysis and debugging",
+    useCases: [
+      "View build metadata such as version, source control info, and error counts",
+      "Analyze a specific build to correlate with error spikes or deployments",
+      "See the stability targets for a project and if the build meets them"
+    ],
+    inputSchema,
+    examples: [
+      {
+        description: "Get details for a specific build",
+        parameters: {
+          buildId: "5f8d0d55c9e77c0017a1b2c3"
+        },
+        expectedOutput: "JSON object with build details including version, source control info, error counts and stability data."
+      }
+    ],
+    hints: ["Build IDs can be found using the List builds tool"],
+    readOnly: true,
+    idempotent: true,
+    outputDescription: "JSON object containing build 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 response = await this.client.projectApi.getProjectReleaseById(
+      project.id,
+      params.buildId
+    );
+    if (!response.body)
+      throw new ToolError(`No build for ${params.buildId} found.`);
+    const build = this.client.addStabilityData(response.body, project);
+    return {
+      content: [{ type: "text", text: JSON.stringify(build) }]
+    };
+  };
+}
+export {
+  GetBuild
+};

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.15.0";
+const version = "0.17.0";
 const config = { "mcpServerName": "SmartBear MCP Server" };
 const packageJson = {
   version,

package/dist/reflect/client.js

@@ -1,12 +1,20 @@
 import { z } from "zod";
 import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
+import { ToolError } from "../common/tools.js";
 import { API_KEY_HEADER } from "./config/constants.js";
+import { SapTest } from "./prompt/sap-test.js";
+import { AddPromptStep } from "./tool/recording/add-prompt-step.js";
+import { AddSegment } from "./tool/recording/add-segment.js";
+import { ConnectToSession } from "./tool/recording/connect-to-session.js";
+import { DeletePreviousStep } from "./tool/recording/delete-previous-step.js";
+import { GetScreenshot } from "./tool/recording/get-screenshot.js";
 import { CancelSuiteExecution } from "./tool/suites/cancel-suite-execution.js";
 import { ExecuteSuite } from "./tool/suites/execute-suite.js";
 import { GetSuiteExecutionStatus } from "./tool/suites/get-suite-execution-status.js";
 import { ListSuiteExecutions } from "./tool/suites/list-suite-executions.js";
 import { ListSuites } from "./tool/suites/list-suites.js";
 import { GetTestStatus } from "./tool/tests/get-test-status.js";
+import { ListSegments } from "./tool/tests/list-segments.js";
 import { ListTests } from "./tool/tests/list-tests.js";
 import { RunTest } from "./tool/tests/run-test.js";
 const ConfigurationSchema = z.object({
@@ -14,11 +22,16 @@ const ConfigurationSchema = z.object({
 });
 class ReflectClient {
   headers = {};
+  apiToken = "";
+  activeConnections = /* @__PURE__ */ new Map();
+  sessionStates = /* @__PURE__ */ new Map();
+  mcpSessionConnections = /* @__PURE__ */ new Map();
   name = "Reflect";
   toolPrefix = "reflect";
   configPrefix = "Reflect";
   config = ConfigurationSchema;
   async configure(_server, config, _cache) {
+    this.apiToken = config.api_token;
     this.headers = {
       [API_KEY_HEADER]: `${config.api_token}`,
       "Content-Type": "application/json",
@@ -28,9 +41,49 @@ class ReflectClient {
   isConfigured() {
     return Object.keys(this.headers).length !== 0;
   }
+  getApiToken() {
+    return this.apiToken;
+  }
   getHeaders() {
     return this.headers;
   }
+  getSessionState(sessionId) {
+    return this.sessionStates.get(sessionId);
+  }
+  isSessionConnected(sessionId) {
+    const wsManager = this.activeConnections.get(sessionId);
+    return wsManager?.isConnected() ?? false;
+  }
+  getConnectedSession(sessionId) {
+    if (!this.isSessionConnected(sessionId)) {
+      throw new ToolError(
+        `Session ${sessionId} is not connected. Call connect_to_session first.`
+      );
+    }
+    return this.activeConnections.get(sessionId);
+  }
+  registerConnection(sessionId, ws, state, mcpSessionId) {
+    this.activeConnections.set(sessionId, ws);
+    this.sessionStates.set(sessionId, state);
+    if (mcpSessionId) {
+      const existing = this.mcpSessionConnections.get(mcpSessionId) ?? /* @__PURE__ */ new Set();
+      existing.add(sessionId);
+      this.mcpSessionConnections.set(mcpSessionId, existing);
+    }
+  }
+  async cleanupSession(mcpSessionId) {
+    const reflectSessionIds = this.mcpSessionConnections.get(mcpSessionId);
+    if (!reflectSessionIds) return;
+    for (const reflectSessionId of reflectSessionIds) {
+      const ws = this.activeConnections.get(reflectSessionId);
+      if (ws) {
+        await ws.disconnect();
+        this.activeConnections.delete(reflectSessionId);
+        this.sessionStates.delete(reflectSessionId);
+      }
+    }
+    this.mcpSessionConnections.delete(mcpSessionId);
+  }
   async registerTools(register, _getInput) {
     const tools = [
       new ListSuites(this),
@@ -40,12 +93,24 @@ class ReflectClient {
       new CancelSuiteExecution(this),
       new ListTests(this),
       new RunTest(this),
-      new GetTestStatus(this)
+      new GetTestStatus(this),
+      new ListSegments(this),
+      new ConnectToSession(this),
+      new AddPromptStep(this),
+      new GetScreenshot(this),
+      new DeletePreviousStep(this),
+      new AddSegment(this)
     ];
     for (const tool of tools) {
       register(tool.specification, tool.handle);
     }
   }
+  registerPrompts(register) {
+    const prompts = [new SapTest(this)];
+    for (const prompt of prompts) {
+      register(prompt.name, prompt.params, prompt.callback);
+    }
+  }
 }
 export {
   ReflectClient

package/dist/reflect/config/constants.js

@@ -1,6 +1,8 @@
 const API_KEY_HEADER = "X-API-KEY";
 const API_HOSTNAME = "api.reflect.run";
+const WEBSOCKET_HOSTNAME = "recording.us-east-1.reflect.run";
 export {
   API_HOSTNAME,
-  API_KEY_HEADER
+  API_KEY_HEADER,
+  WEBSOCKET_HOSTNAME
 };

package/dist/reflect/prompt/sap-test.js

@@ -0,0 +1,29 @@
+import { Prompt } from "../../common/prompts.js";
+class SapTest extends Prompt {
+  name = "reflect-sap-test";
+  params = {
+    title: "Reflect SAP Test",
+    description: "Guidelines for creating a Reflect test against an SAP S4/HANA or SAP BTP application.",
+    argsSchema: {}
+  };
+  callback = () => ({
+    messages: [
+      {
+        role: "user",
+        content: {
+          type: "text",
+          text: `When creating an SAP test:
+        1. Always precede an input step with a click step.
+        2. Always capture a screenshot after each step, even form field actions.
+        3. If text is ellipsized with a hyphen, do not include the hyphen in your prompt step.
+        4. If you navigate to the wrong page, use browser navigation (e.g. "Click the back button") or on-screen navigation to get to the prior screen. Make sure to delete the original step and any steps you added to navigate back to the previous screen so that the test is repeatable and contains no unnecessary steps.
+        5. When applicable, use the prompt "Press the tab key" to tab through fields and the prompt "Press the enter key" to submit a form.
+        6. When building tests from BPD docs, if the input value for the next step is based on an example value in the doc, prompt the user to ask for their desired value. Provide the example value in your prompt so the user has additional context.`
+        }
+      }
+    ]
+  });
+}
+export {
+  SapTest
+};

package/dist/reflect/tool/recording/add-prompt-step.js

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+class AddPromptStep extends Tool {
+  specification = {
+    title: "Add Prompt Step",
+    summary: "Add a natural language prompt step to an active Reflect recording session",
+    readOnly: false,
+    idempotent: false,
+    parameters: [
+      {
+        name: "sessionId",
+        type: z.string(),
+        description: "The ID of the Reflect recording session",
+        required: true
+      },
+      {
+        name: "prompt",
+        type: z.string(),
+        description: 'The natural language prompt describing the test step. The prompt should describe a single action, assertion, or query. The prompt can only contain literal text; it cannot contain template variables, secrets, or other dynamic syntax. If we are in a Web recording, the prompt can perform browser navigation (e.g. "Click on the back button", "Navigate to https://www.example.com") and use the tab and enter keys to navigate (e.g. "Press the tab key", "Press the enter key").',
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { sessionId, prompt } = args;
+    if (!sessionId) throw new ToolError("sessionId argument is required");
+    if (!prompt) throw new ToolError("prompt argument is required");
+    const wsManager = this.client.getConnectedSession(sessionId);
+    const id = randomUUID();
+    const responsePromise = wsManager.waitForResponse(id);
+    await wsManager.sendMcpMessage({
+      type: "mcp:add-prompt-step",
+      id,
+      prompt
+    });
+    const response = await responsePromise;
+    const result = response.result;
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            sessionId,
+            message: `Successfully added prompt step: "${prompt}"`,
+            intent: {
+              prompt,
+              type: result?.type,
+              response: result?.response
+            }
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  AddPromptStep
+};

package/dist/reflect/tool/recording/add-segment.js

@@ -0,0 +1,56 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+class AddSegment extends Tool {
+  specification = {
+    title: "Add Segment",
+    summary: "Insert a reusable test segment into an active Reflect recording session",
+    readOnly: false,
+    idempotent: false,
+    parameters: [
+      {
+        name: "sessionId",
+        type: z.string(),
+        description: "The ID of the Reflect recording session",
+        required: true
+      },
+      {
+        name: "segmentId",
+        type: z.number(),
+        description: "The ID of the segment to add",
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { sessionId, segmentId } = args;
+    if (!sessionId) throw new ToolError("sessionId argument is required");
+    if (segmentId === void 0 || segmentId === null)
+      throw new ToolError("segmentId argument is required");
+    const wsManager = this.client.getConnectedSession(sessionId);
+    const id = randomUUID();
+    const responsePromise = wsManager.waitForResponse(id);
+    await wsManager.sendMcpMessage({
+      type: "mcp:add-segment",
+      id,
+      segmentId
+    });
+    await responsePromise;
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            sessionId,
+            message: `Successfully added and executed segment ${segmentId}`,
+            segmentId
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  AddSegment
+};

package/dist/reflect/tool/recording/connect-to-session.js

@@ -0,0 +1,89 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { WebSocketManager } from "../../websocket-manager.js";
+class ConnectToSession extends Tool {
+  specification = {
+    title: "Connect To Session",
+    summary: `Connect to an active Reflect recording session via WebSocket to enable interactive control. 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.`,
+    readOnly: false,
+    idempotent: true,
+    parameters: [
+      {
+        name: "sessionId",
+        type: z.string(),
+        description: "The ID of the Reflect recording session to connect to",
+        required: true
+      }
+    ]
+  };
+  handle = async (args, extra) => {
+    const { sessionId } = args;
+    if (!sessionId) throw new ToolError("sessionId argument is required");
+    if (this.client.isSessionConnected(sessionId)) {
+      const state = this.client.getSessionState(sessionId);
+      const { platform: platform2, test: test2 } = state;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, sessionId, platform: platform2, test: test2 })
+          }
+        ]
+      };
+    }
+    const wsManager = new WebSocketManager(
+      sessionId,
+      this.client.getApiToken()
+    );
+    try {
+      await wsManager.connect();
+    } catch (error) {
+      throw new ToolError(
+        `Failed to connect to session: ${error.message}`
+      );
+    }
+    const connectId = randomUUID();
+    let connectResponse;
+    try {
+      const connectResponsePromise = wsManager.waitForResponse(connectId);
+      await wsManager.sendMcpMessage({
+        type: "mcp:connect-to-session",
+        id: connectId
+      });
+      connectResponse = await connectResponsePromise;
+    } catch (connectError) {
+      await wsManager.disconnect();
+      throw new ToolError(
+        `MCP connect-to-session failed: ${connectError instanceof Error ? connectError.message : String(connectError)}`
+      );
+    }
+    const mcpSessionId = extra?.sessionId;
+    const { platform, test } = connectResponse;
+    this.client.registerConnection(
+      sessionId,
+      wsManager,
+      { platform, test },
+      mcpSessionId
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: true, sessionId, platform, test })
+        }
+      ]
+    };
+  };
+}
+export {
+  ConnectToSession
+};