@smartbear/mcp 0.14.1 → 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/suites/cancel-suite-execution.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME } from "../../config/constants.js";
+class CancelSuiteExecution extends Tool {
+  specification = {
+    title: "Cancel Suite Execution",
+    summary: "Cancel a reflect suite execution",
+    parameters: [
+      {
+        name: "suiteId",
+        type: z.string(),
+        description: "ID of the reflect suite to cancel execution for",
+        required: true
+      },
+      {
+        name: "executionId",
+        type: z.string(),
+        description: "ID of the reflect suite execution to cancel",
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { suiteId, executionId } = args;
+    if (!suiteId || !executionId) {
+      throw new ToolError(
+        "Both suiteId and executionId arguments are required"
+      );
+    }
+    const response = await fetch(
+      `https://${API_HOSTNAME}/v1/suites/${suiteId}/executions/${executionId}/cancel`,
+      {
+        method: "PATCH",
+        headers: this.client.getHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to cancel suite execution: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  };
+}
+export {
+  CancelSuiteExecution
+};

package/dist/reflect/tool/suites/execute-suite.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME } from "../../config/constants.js";
+class ExecuteSuite extends Tool {
+  specification = {
+    title: "Execute Suite",
+    summary: "Execute a reflect suite",
+    parameters: [
+      {
+        name: "suiteId",
+        type: z.string(),
+        description: "ID of the reflect suite to execute",
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { suiteId } = args;
+    if (!suiteId) throw new ToolError("suiteId argument is required");
+    const response = await fetch(
+      `https://${API_HOSTNAME}/v1/suites/${suiteId}/executions`,
+      {
+        method: "POST",
+        headers: this.client.getHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to execute suite: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  };
+}
+export {
+  ExecuteSuite
+};

package/dist/reflect/tool/suites/get-suite-execution-status.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME } from "../../config/constants.js";
+class GetSuiteExecutionStatus extends Tool {
+  specification = {
+    title: "Get Suite Execution Status",
+    summary: "Get the status of a reflect suite execution",
+    parameters: [
+      {
+        name: "suiteId",
+        type: z.string(),
+        description: "ID of the reflect suite to get execution status for",
+        required: true
+      },
+      {
+        name: "executionId",
+        type: z.string(),
+        description: "ID of the reflect suite execution to get status for",
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { suiteId, executionId } = args;
+    if (!suiteId || !executionId) {
+      throw new ToolError(
+        "Both suiteId and executionId arguments are required"
+      );
+    }
+    const response = await fetch(
+      `https://${API_HOSTNAME}/v1/suites/${suiteId}/executions/${executionId}`,
+      {
+        method: "GET",
+        headers: this.client.getHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to get suite execution status: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  };
+}
+export {
+  GetSuiteExecutionStatus
+};

package/dist/reflect/tool/suites/list-suite-executions.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME } from "../../config/constants.js";
+class ListSuiteExecutions extends Tool {
+  specification = {
+    title: "List Suite Executions",
+    summary: "List all executions for a given suite",
+    parameters: [
+      {
+        name: "suiteId",
+        type: z.string(),
+        description: "ID of the reflect suite to list executions for",
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { suiteId } = args;
+    if (!suiteId) throw new ToolError("suiteId argument is required");
+    const response = await fetch(
+      `https://${API_HOSTNAME}/v1/suites/${suiteId}/executions`,
+      {
+        method: "GET",
+        headers: this.client.getHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to list suite executions: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  };
+}
+export {
+  ListSuiteExecutions
+};

package/dist/reflect/tool/suites/list-suites.js

@@ -0,0 +1,27 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME } from "../../config/constants.js";
+class ListSuites extends Tool {
+  specification = {
+    title: "List Suites",
+    summary: "Retrieve a list of all reflect suites available",
+    parameters: []
+  };
+  handle = async (_args) => {
+    const response = await fetch(`https://${API_HOSTNAME}/v1/suites`, {
+      method: "GET",
+      headers: this.client.getHeaders()
+    });
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to list suites: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  };
+}
+export {
+  ListSuites
+};

package/dist/reflect/tool/tests/get-test-status.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME } from "../../config/constants.js";
+class GetTestStatus extends Tool {
+  specification = {
+    title: "Get Test Status",
+    summary: "Get the status of a reflect test execution",
+    parameters: [
+      {
+        name: "executionId",
+        type: z.string(),
+        description: "ID of the reflect test execution to get status for",
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { executionId } = args;
+    if (!executionId) {
+      throw new ToolError("executionId argument is required");
+    }
+    const response = await fetch(
+      `https://${API_HOSTNAME}/v1/executions/${executionId}`,
+      {
+        method: "GET",
+        headers: this.client.getHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to get test status: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  };
+}
+export {
+  GetTestStatus
+};

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/tool/tests/list-tests.js

@@ -0,0 +1,27 @@
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME } from "../../config/constants.js";
+class ListTests extends Tool {
+  specification = {
+    title: "List Tests",
+    summary: "List all reflect tests",
+    parameters: []
+  };
+  handle = async (_args) => {
+    const response = await fetch(`https://${API_HOSTNAME}/v1/tests`, {
+      method: "GET",
+      headers: this.client.getHeaders()
+    });
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to list tests: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  };
+}
+export {
+  ListTests
+};

package/dist/reflect/tool/tests/run-test.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { Tool, ToolError } from "../../../common/tools.js";
+import { API_HOSTNAME } from "../../config/constants.js";
+class RunTest extends Tool {
+  specification = {
+    title: "Run Test",
+    summary: "Run a reflect test",
+    parameters: [
+      {
+        name: "testId",
+        type: z.string(),
+        description: "ID of the reflect test to run",
+        required: true
+      }
+    ]
+  };
+  handle = async (args) => {
+    const { testId } = args;
+    if (!testId) throw new ToolError("testId argument is required");
+    const response = await fetch(
+      `https://${API_HOSTNAME}/v1/tests/${testId}/executions`,
+      {
+        method: "POST",
+        headers: this.client.getHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to run test: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await response.json();
+    return {
+      content: [{ type: "text", text: JSON.stringify(data) }]
+    };
+  };
+}
+export {
+  RunTest
+};

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
+};

package/dist/zephyr/client.js

@@ -1,22 +1,39 @@
 import zod__default from "zod";
 import { ApiClient } from "./common/api-client.js";
 import { GetEnvironments } from "./tool/environment/get-environments.js";
+import { CreateFolder } from "./tool/folder/create-folder.js";
+import { GetTestCases as GetTestCases$1 } from "./tool/issue-link/get-test-cases.js";
+import { GetTestCycles as GetTestCycles$1 } from "./tool/issue-link/get-test-cycles.js";
+import { GetTestExecutions as GetTestExecutions$1 } from "./tool/issue-link/get-test-executions.js";
 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 { CreateTestCaseIssueLink } from "./tool/test-case/create-issue-link.js";
 import { CreateTestCase } from "./tool/test-case/create-test-case.js";
+import { CreateTestScript } from "./tool/test-case/create-test-script.js";
+import { CreateTestSteps } from "./tool/test-case/create-test-steps.js";
 import { CreateTestCaseWebLink } from "./tool/test-case/create-web-link.js";
+import { GetTestCaseLinks } from "./tool/test-case/get-links.js";
 import { GetTestCase } from "./tool/test-case/get-test-case.js";
 import { GetTestCases } from "./tool/test-case/get-test-cases.js";
+import { GetTestScript } from "./tool/test-case/get-test-script.js";
+import { GetTestCaseSteps } from "./tool/test-case/get-test-steps.js";
 import { UpdateTestCase } from "./tool/test-case/update-test-case.js";
+import { CreateTestCycleIssueLink } from "./tool/test-cycle/create-issue-link.js";
 import { CreateTestCycle } from "./tool/test-cycle/create-test-cycle.js";
+import { CreateTestCycleWebLink } from "./tool/test-cycle/create-web-link.js";
+import { GetTestCycleLinks } from "./tool/test-cycle/get-links.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 { CreateTestExecutionIssueLink } from "./tool/test-execution/create-issue-link.js";
 import { CreateTestExecution } from "./tool/test-execution/create-test-execution.js";
 import { GetTestExecution } from "./tool/test-execution/get-test-execution.js";
+import { GetTestExecutionLinks } from "./tool/test-execution/get-test-execution-links.js";
 import { GetTestExecutions } from "./tool/test-execution/get-test-executions.js";
+import { GetTestExecutionSteps } from "./tool/test-execution/get-test-steps.js";
+import { UpdateTestExecution } from "./tool/test-execution/update-test-execution.js";
 const BASE_URL_DEFAULT = "https://api.zephyrscale.smartbear.com/v2";
 const ConfigurationSchema = zod__default.object({
   api_token: zod__default.string().describe("Zephyr Scale API token for authentication"),
@@ -47,11 +64,13 @@ class ZephyrClient {
       new GetProject(this),
       new GetTestCycles(this),
       new GetTestCycle(this),
+      new GetTestCycleLinks(this),
       new GetPriorities(this),
       new GetStatuses(this),
       new GetTestCases(this),
       new GetEnvironments(this),
       new GetTestCase(this),
+      new GetTestCaseLinks(this),
       new GetTestExecution(this),
       new GetTestExecutions(this),
       new CreateTestCase(this),
@@ -59,7 +78,22 @@ class ZephyrClient {
       new UpdateTestCase(this),
       new UpdateTestCycle(this),
       new CreateTestExecution(this),
-      new CreateTestCaseWebLink(this)
+      new CreateTestCaseWebLink(this),
+      new CreateTestSteps(this),
+      new CreateTestCaseIssueLink(this),
+      new CreateTestCycleIssueLink(this),
+      new CreateFolder(this),
+      new CreateTestScript(this),
+      new UpdateTestExecution(this),
+      new CreateTestExecutionIssueLink(this),
+      new GetTestCaseSteps(this),
+      new GetTestCases$1(this),
+      new GetTestCycles$1(this),
+      new GetTestScript(this),
+      new CreateTestCycleWebLink(this),
+      new GetTestExecutionSteps(this),
+      new GetTestExecutionLinks(this),
+      new GetTestExecutions$1(this)
     ];
     for (const tool of tools) {
       register(tool.specification, tool.handle);