@smartbear/mcp 0.14.1 → 0.15.0

package/dist/reflect/client.js

@@ -1,6 +1,14 @@
 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 { 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 { ListTests } from "./tool/tests/list-tests.js";
+import { RunTest } from "./tool/tests/run-test.js";
 const ConfigurationSchema = z.object({
   api_token: z.string().describe("Reflect API authentication token")
 });
@@ -12,7 +20,7 @@ class ReflectClient {
   config = ConfigurationSchema;
   async configure(_server, config, _cache) {
     this.headers = {
-      "X-API-KEY": `${config.api_token}`,
+      [API_KEY_HEADER]: `${config.api_token}`,
       "Content-Type": "application/json",
       "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`
     };
@@ -20,269 +28,23 @@ class ReflectClient {
   isConfigured() {
     return Object.keys(this.headers).length !== 0;
   }
-  async listReflectSuites() {
-    const response = await fetch("https://api.reflect.run/v1/suites", {
-      method: "GET",
-      headers: this.headers
-    });
-    return response.json();
-  }
-  async listSuiteExecutions(suiteId) {
-    const response = await fetch(
-      `https://api.reflect.run/v1/suites/${suiteId}/executions`,
-      {
-        method: "GET",
-        headers: this.headers
-      }
-    );
-    return response.json();
-  }
-  async getSuiteExecutionStatus(suiteId, executionId) {
-    const response = await fetch(
-      `https://api.reflect.run/v1/suites/${suiteId}/executions/${executionId}`,
-      {
-        method: "GET",
-        headers: this.headers
-      }
-    );
-    return response.json();
-  }
-  async executeSuite(suiteId) {
-    const response = await fetch(
-      `https://api.reflect.run/v1/suites/${suiteId}/executions`,
-      {
-        method: "POST",
-        headers: this.headers
-      }
-    );
-    return response.json();
-  }
-  async cancelSuiteExecution(suiteId, executionId) {
-    const response = await fetch(
-      `https://api.reflect.run/v1/suites/${suiteId}/executions/${executionId}/cancel`,
-      {
-        method: "PATCH",
-        headers: this.headers
-      }
-    );
-    return response.json();
-  }
-  async listReflectTests() {
-    const response = await fetch("https://api.reflect.run/v1/tests", {
-      method: "GET",
-      headers: this.headers
-    });
-    return response.json();
-  }
-  async runReflectTest(testId) {
-    const response = await fetch(
-      `https://api.reflect.run/v1/tests/${testId}/executions`,
-      {
-        method: "POST",
-        headers: this.headers
-      }
-    );
-    return response.json();
-  }
-  async getReflectTestStatus(_testId, executionId) {
-    const response = await fetch(
-      `https://api.reflect.run/v1/executions/${executionId}`,
-      {
-        method: "GET",
-        headers: this.headers
-      }
-    );
-    return response.json();
+  getHeaders() {
+    return this.headers;
   }
   async registerTools(register, _getInput) {
-    register(
-      {
-        title: "List Suites",
-        summary: "Retrieve a list of all reflect suites available",
-        parameters: []
-      },
-      async (_args, _extra) => {
-        const response = await this.listReflectSuites();
-        return {
-          content: [{ type: "text", text: JSON.stringify(response) }]
-        };
-      }
-    );
-    register(
-      {
-        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
-          }
-        ]
-      },
-      async (args, _extra) => {
-        if (!args.suiteId) throw new ToolError("suiteId argument is required");
-        const response = await this.listSuiteExecutions(args.suiteId);
-        return {
-          content: [{ type: "text", text: JSON.stringify(response) }]
-        };
-      }
-    );
-    register(
-      {
-        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
-          }
-        ]
-      },
-      async (args, _extra) => {
-        if (!args.suiteId || !args.executionId)
-          throw new ToolError(
-            "Both suiteId and executionId arguments are required"
-          );
-        const response = await this.getSuiteExecutionStatus(
-          args.suiteId,
-          args.executionId
-        );
-        return {
-          content: [{ type: "text", text: JSON.stringify(response) }]
-        };
-      }
-    );
-    register(
-      {
-        title: "Execute Suite",
-        summary: "Execute a reflect suite",
-        parameters: [
-          {
-            name: "suiteId",
-            type: z.string(),
-            description: "ID of the reflect suite to list executions for",
-            required: true
-          }
-        ]
-      },
-      async (args, _extra) => {
-        if (!args.suiteId) throw new ToolError("suiteId argument is required");
-        const response = await this.executeSuite(args.suiteId);
-        return {
-          content: [{ type: "text", text: JSON.stringify(response) }]
-        };
-      }
-    );
-    register(
-      {
-        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
-          }
-        ]
-      },
-      async (args, _extra) => {
-        if (!args.suiteId || !args.executionId)
-          throw new ToolError(
-            "Both suiteId and executionId arguments are required"
-          );
-        const response = await this.cancelSuiteExecution(
-          args.suiteId,
-          args.executionId
-        );
-        return {
-          content: [{ type: "text", text: JSON.stringify(response) }]
-        };
-      }
-    );
-    register(
-      {
-        title: "List Tests",
-        summary: "List all reflect tests",
-        parameters: []
-      },
-      async (_args, _extra) => {
-        const response = await this.listReflectTests();
-        return {
-          content: [{ type: "text", text: JSON.stringify(response) }]
-        };
-      }
-    );
-    register(
-      {
-        title: "Run Test",
-        summary: "Run a reflect test",
-        parameters: [
-          {
-            name: "testId",
-            type: z.string(),
-            description: "ID of the reflect test to run",
-            required: true
-          }
-        ]
-      },
-      async (args, _extra) => {
-        if (!args.testId) throw new ToolError("testId argument is required");
-        const response = await this.runReflectTest(args.testId);
-        return {
-          content: [{ type: "text", text: JSON.stringify(response) }]
-        };
-      }
-    );
-    register(
-      {
-        title: "Get Test Status",
-        summary: "Get the status of a reflect test execution",
-        parameters: [
-          {
-            name: "testId",
-            type: z.string(),
-            description: "ID of the reflect test to run",
-            required: true
-          },
-          {
-            name: "executionId",
-            type: z.string(),
-            description: "ID of the reflect test execution to get status for",
-            required: true
-          }
-        ]
-      },
-      async (args, _extra) => {
-        if (!args.testId || !args.executionId)
-          throw new ToolError(
-            "Both testId and executionId arguments are required"
-          );
-        const response = await this.getReflectTestStatus(
-          args.testId,
-          args.executionId
-        );
-        return {
-          content: [{ type: "text", text: JSON.stringify(response) }]
-        };
-      }
-    );
+    const tools = [
+      new ListSuites(this),
+      new ListSuiteExecutions(this),
+      new GetSuiteExecutionStatus(this),
+      new ExecuteSuite(this),
+      new CancelSuiteExecution(this),
+      new ListTests(this),
+      new RunTest(this),
+      new GetTestStatus(this)
+    ];
+    for (const tool of tools) {
+      register(tool.specification, tool.handle);
+    }
   }
 }
 export {

package/dist/reflect/config/constants.js

@@ -0,0 +1,6 @@
+const API_KEY_HEADER = "X-API-KEY";
+const API_HOSTNAME = "api.reflect.run";
+export {
+  API_HOSTNAME,
+  API_KEY_HEADER
+};

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