@smartbear/mcp 0.15.0 → 0.16.0

package/dist/reflect/tool/recording/get-screenshot.js

@@ -0,0 +1,55 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+class GetScreenshot extends Tool {
+  specification = {
+    title: "Get Screenshot",
+    summary: "Capture a screenshot from the current state of an active Reflect recording session",
+    readOnly: true,
+    idempotent: true,
+    parameters: [
+      {
+        name: "sessionId",
+        type: z.string(),
+        description: "The ID of the Reflect recording session",
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { sessionId } = args;
+    if (!sessionId) throw new ToolError("sessionId argument is required");
+    const wsManager = this.client.getConnectedSession(sessionId);
+    const id = randomUUID();
+    const responsePromise = wsManager.waitForResponse(id);
+    await wsManager.sendMcpMessage({
+      type: "mcp:get-screenshot",
+      id
+    });
+    const response = await responsePromise;
+    const { imageBase64, state } = response;
+    if (!imageBase64) {
+      throw new ToolError("No imageBase64 in screenshot response");
+    }
+    return {
+      content: [
+        {
+          type: "image",
+          data: imageBase64,
+          mimeType: "image/png"
+        },
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            message: "Screenshot captured",
+            state
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  GetScreenshot
+};

package/dist/reflect/tool/tests/list-segments.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME, API_KEY_HEADER } from "../../config/constants.js";
+class ListSegments extends Tool {
+  specification = {
+    title: "List Segments",
+    summary: "Retrieve available reusable test segments for the given platform type. Segments are reusable test steps with an optional set of parameters that can used across multiple tests.",
+    readOnly: true,
+    idempotent: true,
+    parameters: [
+      {
+        name: "platform",
+        type: z.enum(["api", "native-mobile", "web"]),
+        description: "The platform type to retrieve segments for",
+        required: true
+      },
+      {
+        name: "offset",
+        type: z.number(),
+        description: "Offset for pagination",
+        required: false
+      },
+      {
+        name: "limit",
+        type: z.number(),
+        description: "Maximum number of segments to return",
+        required: false
+      }
+    ]
+  };
+  handle = async (args) => {
+    const {
+      platform,
+      offset = 0,
+      limit = 25
+    } = args;
+    const url = `https://${API_HOSTNAME}/v1/segments?type=${platform}&offset=${offset}&limit=${limit}`;
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        [API_KEY_HEADER]: this.client.getApiToken(),
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to list segments: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            success: true,
+            segments: data.segments,
+            count: data.count,
+            message: `Found ${data.count} segment(s) for platform '${platform}'`
+          })
+        }
+      ]
+    };
+  };
+}
+export {
+  ListSegments
+};

package/dist/reflect/websocket-manager.js

@@ -0,0 +1,92 @@
+import WebSocket from "ws";
+import { WEBSOCKET_HOSTNAME, API_KEY_HEADER } from "./config/constants.js";
+class WebSocketManager {
+  sessionId;
+  apiKey;
+  mcpSocket = null;
+  pendingResponses = /* @__PURE__ */ new Map();
+  constructor(sessionId, apiKey) {
+    this.sessionId = sessionId;
+    this.apiKey = apiKey;
+  }
+  async connect() {
+    if (this.mcpSocket?.readyState === WebSocket.OPEN) {
+      throw new Error("WebSocket is already connected");
+    }
+    try {
+      await this.connectMcpSocket();
+    } catch (error) {
+      throw new Error(
+        `Failed to connect WebSocket: ${error.message}`
+      );
+    }
+  }
+  async connectMcpSocket() {
+    return new Promise((resolve, reject) => {
+      const url = `wss://${WEBSOCKET_HOSTNAME}/websocket/v2/recordings/${this.sessionId}/topics/mcp?sid=${this.sessionId}`;
+      this.mcpSocket = new WebSocket(url, {
+        headers: {
+          [API_KEY_HEADER]: this.apiKey
+        }
+      });
+      this.mcpSocket.on("open", () => {
+        resolve();
+      });
+      this.mcpSocket.on("message", (data) => {
+        try {
+          const message = JSON.parse(data.toString());
+          const { id, type } = message;
+          if (id && this.pendingResponses.has(id)) {
+            const pending = this.pendingResponses.get(id);
+            this.pendingResponses.delete(id);
+            if (type?.endsWith(":success")) {
+              pending.resolve(message);
+            } else if (type?.endsWith(":failure")) {
+              pending.reject(message);
+            }
+          }
+        } catch (error) {
+          console.error("Failed to parse MCP message:", error);
+        }
+      });
+      this.mcpSocket.on("error", (error) => {
+        reject(new Error(`MCP socket error: ${error.message}`));
+      });
+    });
+  }
+  async sendMcpMessage(message) {
+    if (!this.mcpSocket || this.mcpSocket.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    return new Promise((resolve, reject) => {
+      this.mcpSocket?.send(JSON.stringify(message), (error) => {
+        if (error) {
+          reject(new Error(`Failed to send MCP message: ${error.message}`));
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+  waitForResponse(id) {
+    return new Promise((resolve, reject) => {
+      this.pendingResponses.set(id, { resolve, reject });
+    });
+  }
+  async disconnect() {
+    if (this.mcpSocket) {
+      this.mcpSocket.removeAllListeners();
+      if (this.mcpSocket.readyState === WebSocket.OPEN || this.mcpSocket.readyState === WebSocket.CONNECTING) {
+        this.mcpSocket.close();
+      }
+      this.mcpSocket = null;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  isConnected() {
+    return this.mcpSocket?.readyState === WebSocket.OPEN;
+  }
+}
+export {
+  WebSocketManager
+};