@smartbear/mcp 0.27.2 → 0.29.0

package/dist/swagger/client/functional-testing-api.js

@@ -1,3 +1,4 @@
+import { appendClientIdentity } from "../../common/info.js";
 import { ToolError } from "../../common/tools.js";
 const API_HOSTNAME = "api.reflect.run";
 const FUNCTIONAL_TESTING_API_KEY_HEADER = "X-API-KEY";
@@ -16,11 +17,27 @@ class FunctionalTestingAPI {
     return {
       [FUNCTIONAL_TESTING_API_KEY_HEADER]: token,
       "Content-Type": "application/json",
-      "User-Agent": this.userAgent
+      "User-Agent": appendClientIdentity(this.userAgent)
     };
   }
+  async ftFetch(input, init) {
+    let response;
+    try {
+      response = await fetch(input, init);
+    } catch {
+      throw new ToolError(
+        "Swagger Functional Testing service is currently unreachable. Retry after a moment."
+      );
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw new ToolError(
+        "Authentication failed. Verify your API token is valid and has not expired."
+      );
+    }
+    return response;
+  }
   async listTests() {
-    const response = await fetch(`${this.baseUrl}/tests`, {
+    const response = await this.ftFetch(`${this.baseUrl}/tests`, {
       method: "GET",
       headers: this.getFtHeaders()
     });
@@ -33,8 +50,8 @@ class FunctionalTestingAPI {
   }
   async runTest(args) {
     if (!args.testId) throw new ToolError("testId argument is required");
-    const response = await fetch(
-      `${this.baseUrl}/tests/${args.testId}/executions`,
+    const response = await this.ftFetch(
+      `${this.baseUrl}/tests/${encodeURIComponent(args.testId)}/executions`,
       {
         method: "POST",
         headers: this.getFtHeaders()
@@ -51,8 +68,8 @@ class FunctionalTestingAPI {
     if (!args.executionId) {
       throw new ToolError("executionId argument is required");
     }
-    const response = await fetch(
-      `${this.baseUrl}/executions/${args.executionId}`,
+    const response = await this.ftFetch(
+      `${this.baseUrl}/executions/${encodeURIComponent(args.executionId)}`,
       {
         method: "GET",
         headers: this.getFtHeaders()
@@ -63,8 +80,173 @@ class FunctionalTestingAPI {
         `Failed to get test status: ${response.status} ${response.statusText}`
       );
     }
+    const data = await response.json();
+    if (Array.isArray(data.tests)) {
+      for (const test of data.tests) {
+        const run = test.run;
+        if (run) {
+          delete run.videoUrl;
+        }
+      }
+    }
+    return data;
+  }
+  async listSuiteExecutions(args) {
+    if (!args.suiteId) throw new ToolError("suiteId argument is required");
+    const response = await this.ftFetch(
+      `${this.baseUrl}/suites/${encodeURIComponent(args.suiteId)}/executions`,
+      {
+        method: "GET",
+        headers: this.getFtHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(suiteExecutionsErrorMessage(response));
+    }
+    const data = await response.json();
+    return {
+      ...data,
+      executions: {
+        data: data.executions.data.map(
+          ({ executionId, status, isFinished }) => ({
+            executionId,
+            status,
+            isFinished
+          })
+        )
+      }
+    };
+  }
+  async listSuites() {
+    const response = await this.ftFetch(`${this.baseUrl}/suites`, {
+      method: "GET",
+      headers: this.getFtHeaders()
+    });
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to list Functional Testing suites: ${response.status} ${response.statusText}`
+      );
+    }
     return response.json();
   }
+  async cancelSuiteExecution(args) {
+    if (!args.suiteId) throw new ToolError("suiteId argument is required");
+    if (!args.executionId) {
+      throw new ToolError("executionId argument is required");
+    }
+    const response = await this.ftFetch(
+      `${this.baseUrl}/suites/${encodeURIComponent(args.suiteId)}/executions/${encodeURIComponent(args.executionId)}/cancel`,
+      {
+        method: "PATCH",
+        headers: this.getFtHeaders()
+      }
+    );
+    if (!response.ok) {
+      throw new ToolError(cancelSuiteExecutionErrorMessage(response));
+    }
+    return response.json();
+  }
+  async runSuite(args) {
+    if (!args.suiteId) throw new ToolError("suiteId argument is required");
+    const body = args.tunnelAgentName ? JSON.stringify({
+      overrides: { agent: { name: args.tunnelAgentName } }
+    }) : void 0;
+    let response;
+    try {
+      response = await fetch(
+        `${this.baseUrl}/suites/${args.suiteId}/executions`,
+        {
+          method: "POST",
+          headers: this.getFtHeaders(),
+          body
+        }
+      );
+    } catch {
+      throw new ToolError(
+        "Swagger Functional Testing service is currently unreachable. Retry after a moment."
+      );
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw new ToolError(
+        "Authentication failed. Verify your API token is valid and has not expired."
+      );
+    }
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to run suite: ${response.status} ${response.statusText}`
+      );
+    }
+    return this.withoutField("url", response);
+  }
+  async getSuiteExecution(args) {
+    if (!args.suiteId) throw new ToolError("suiteId argument is required");
+    if (!args.executionId) {
+      throw new ToolError("executionId argument is required");
+    }
+    let response;
+    try {
+      response = await fetch(
+        `${this.baseUrl}/suites/${args.suiteId}/executions/${args.executionId}`,
+        {
+          method: "GET",
+          headers: this.getFtHeaders()
+        }
+      );
+    } catch {
+      throw new ToolError(
+        "Swagger Functional Testing service is currently unreachable. Retry after a moment."
+      );
+    }
+    if (response.status === 401 || response.status === 403) {
+      throw new ToolError(
+        "Authentication failed. Verify your API token is valid and has not expired."
+      );
+    }
+    if (!response.ok) {
+      throw new ToolError(
+        `Failed to get suite execution status: ${response.status} ${response.statusText}`
+      );
+    }
+    const data = await this.withoutField("url", response);
+    const testsData = data.tests?.data;
+    if (Array.isArray(testsData)) {
+      for (const test of testsData) {
+        if (Array.isArray(test.runs)) {
+          for (const run of test.runs) {
+            delete run.videoUrl;
+          }
+        }
+      }
+    }
+    return data;
+  }
+  async withoutField(field, response) {
+    const data = await response.json();
+    delete data[field];
+    return data;
+  }
+}
+function suiteExecutionsErrorMessage(response) {
+  switch (response.status) {
+    // Defensive: the Reflect API currently returns 200 with an empty
+    // `executions.data` list for an unknown suiteId rather than a 404, so this
+    // branch is not expected to fire today. Kept in case the API starts
+    // returning 404 for missing suites.
+    case 404:
+      return "Test suite not found. Verify the suiteId is correct and belongs to your workspace.";
+    default:
+      return `Failed to list suite executions: ${response.status} ${response.statusText}`;
+  }
+}
+function cancelSuiteExecutionErrorMessage(response) {
+  switch (response.status) {
+    case 404:
+      return "Suite execution not found. Verify the suiteId and executionId are correct and belong to your workspace.";
+    case 409:
+      return "Suite execution cannot be cancelled because it has already finished.";
+    default:
+      return `Failed to cancel suite execution: ${response.status} ${response.statusText}`;
+  }
 }
 export {
   FUNCTIONAL_TESTING_API_KEY_HEADER,

package/dist/swagger/client/functional-testing-tools.js

@@ -1,10 +1,12 @@
-import { RunFunctionalTestingTestParamsSchema, GetFunctionalTestingExecutionTestSchema } from "./functional-testing-types.js";
+import { RunFunctionalTestingTestParamsSchema, GetFunctionalTestingExecutionTestSchema, ListFunctionalTestingSuiteExecutionsSchema, CancelFunctionalTestingSuiteExecutionSchema, RunFunctionalTestingSuiteParamsSchema, GetFunctionalTestingSuiteExecutionSchema } from "./functional-testing-types.js";
 const FUNCTIONAL_TESTING_TOOLS = [
   {
     title: "List Tests",
     toolset: "Functional Testing",
     summary: "Lists all API tests available in your Swagger Functional Testing account. Use this tool when you need to discover available tests before running them or checking their status. Do not use this tool to retrieve test execution results or history.",
-    handler: "listFunctionalTestingTests"
+    handler: "listFunctionalTestingTests",
+    idempotent: true,
+    readOnly: true
   },
   {
     title: "Run Test",
@@ -21,7 +23,52 @@ const FUNCTIONAL_TESTING_TOOLS = [
     summary: "Get the status of a Swagger Functional Testing test execution. It returns information about the execution such as its status (running, passed or failed), run time, as well as the break down of the status of each test step.",
     inputSchema: GetFunctionalTestingExecutionTestSchema,
     handler: "getFunctionalTestingExecution",
+    idempotent: true,
+    readOnly: true
+  },
+  {
+    title: "List Suite Executions",
+    toolset: "Functional Testing",
+    summary: "Lists all executions for a given test suite in your Swagger Functional Testing workspace. Use this tool when you need to review execution history and timings for a specific suite. Do not use this tool to retrieve the status of a single execution or individual test results.",
+    inputSchema: ListFunctionalTestingSuiteExecutionsSchema,
+    handler: "listFunctionalTestingSuiteExecutions",
+    readOnly: true,
+    idempotent: true
+  },
+  {
+    title: "Cancel Suite Execution",
+    toolset: "Functional Testing",
+    summary: "Cancels an ongoing test suite execution in your Swagger Functional Testing workspace. Use this tool when you need to stop a long-running or accidentally triggered suite run. Do not use this tool to cancel individual test runs.",
+    inputSchema: CancelFunctionalTestingSuiteExecutionSchema,
+    handler: "cancelFunctionalTestingSuiteExecution",
+    readOnly: false,
     idempotent: false
+  },
+  {
+    title: "List Suites",
+    toolset: "Functional Testing",
+    summary: "Lists all test suites available in your Swagger Functional Testing workspace. Use this tool when you need to discover available suites before running them or checking their execution history. Do not use this tool to retrieve individual tests or test suite execution results.",
+    handler: "listFunctionalTestingSuites",
+    idempotent: true,
+    readOnly: true
+  },
+  {
+    title: "Run Suite",
+    toolset: "Functional Testing",
+    summary: "Runs a specific test suite in your Swagger Functional Testing workspace. The execution is asynchronous — it returns an executionId, not results directly. Use `swagger_get_suite_status` with your suiteId and executionId to track progress and retrieve the final per-test results. Optionally accepts a `tunnelAgentName` argument to override the suite's saved tunnel for this run. Do not use this tool to run a single test — use `swagger_run_test` instead.",
+    inputSchema: RunFunctionalTestingSuiteParamsSchema,
+    handler: "runFunctionalTestingSuite",
+    idempotent: false,
+    readOnly: false
+  },
+  {
+    title: "Get Suite Status",
+    toolset: "Functional Testing",
+    summary: "Get the status of a Swagger Functional Testing suite execution. Returns the overall status (pending, canceled, passed or failed), whether the run is finished, and a per-test breakdown with pass/fail. Use this to poll for the outcome of a suite run triggered by `swagger_run_suite`. Requires both `suiteId` and the `executionId` arguments returned by `swagger_run_suite`.",
+    inputSchema: GetFunctionalTestingSuiteExecutionSchema,
+    handler: "getFunctionalTestingSuiteExecution",
+    idempotent: true,
+    readOnly: true
   }
 ];
 export {

package/dist/swagger/client/functional-testing-types.js

@@ -5,7 +5,28 @@ const RunFunctionalTestingTestParamsSchema = z.object({
 const GetFunctionalTestingExecutionTestSchema = z.object({
   executionId: z.string().describe("ID of the Functional Testing execution").trim().min(1)
 });
+const ListFunctionalTestingSuiteExecutionsSchema = z.object({
+  suiteId: z.string().describe("ID of the Functional Testing suite to list executions for").trim().min(1)
+});
+const CancelFunctionalTestingSuiteExecutionSchema = z.object({
+  suiteId: z.string().describe("ID of the Functional Testing suite the execution belongs to").trim().min(1),
+  executionId: z.string().describe("ID of the Functional Testing suite execution to cancel").trim().min(1)
+});
+const RunFunctionalTestingSuiteParamsSchema = z.object({
+  suiteId: z.string().describe("ID of the Functional Testing suite to run").trim().min(1),
+  tunnelAgentName: z.string().describe(
+    "Optional tunnel agent name to override the suite's saved tunnel for this run. When omitted, the suite's saved tunnel overrides are used, falling back to each test's saved tunnel."
+  ).trim().min(1).optional()
+});
+const GetFunctionalTestingSuiteExecutionSchema = z.object({
+  suiteId: z.string().describe("ID of the Functional Testing suite").trim().min(1),
+  executionId: z.string().describe("ID of the Functional Testing suite execution").trim().min(1)
+});
 export {
+  CancelFunctionalTestingSuiteExecutionSchema,
   GetFunctionalTestingExecutionTestSchema,
+  GetFunctionalTestingSuiteExecutionSchema,
+  ListFunctionalTestingSuiteExecutionsSchema,
+  RunFunctionalTestingSuiteParamsSchema,
   RunFunctionalTestingTestParamsSchema
 };

package/dist/swagger/client/portal-types.js

@@ -216,7 +216,10 @@ const CreateDocumentationPageArgsSchema = z.object({
   portalId: z.string().describe("Portal UUID or subdomain - unique identifier for the portal"),
   productId: z.string().uuid().describe("Product UUID - unique identifier for the product"),
   pageTitle: z.string().describe(
-    "Title of the documentation page - will be displayed in navigation (3-255 characters, used to generate the page slug)"
+    "Title of the documentation page - will be displayed in navigation (3-255 characters)"
+  ),
+  pageSlug: z.string().optional().describe(
+    "URL slug for the documentation page. 3-255 characters, lowercase, alphanumeric with hyphens, underscores, or dots (e.g. 'my-page'). If not provided, the slug is generated from the page title."
   ),
   pageContent: z.string().optional().describe(
     "Content of the documentation page. Provide HTML when contentType is 'html', Markdown when contentType is 'markdown'."

package/dist/swagger/client.js

@@ -181,6 +181,22 @@ class SwaggerClient {
   async getFunctionalTestingExecution(args) {
     return this.withFunctionalTesting((ftApi) => ftApi.getTestExecution(args));
   }
+  async listFunctionalTestingSuiteExecutions(args) {
+    return this.withFunctionalTesting(
+      (ftApi) => ftApi.listSuiteExecutions(args)
+    );
+  }
+  async cancelFunctionalTestingSuiteExecution(args) {
+    return this.withFunctionalTesting(
+      (ftApi) => ftApi.cancelSuiteExecution(args)
+    );
+  }
+  async runFunctionalTestingSuite(args) {
+    return this.withFunctionalTesting((ftApi) => ftApi.runSuite(args));
+  }
+  async getFunctionalTestingSuiteExecution(args) {
+    return this.withFunctionalTesting((ftApi) => ftApi.getSuiteExecution(args));
+  }
   /**
    * Perform an operation with the Functional Testing API.
    * Throws a ToolError if Functional Testing is not configured
@@ -191,6 +207,9 @@ class SwaggerClient {
     }
     return fn(this.ftApi);
   }
+  async listFunctionalTestingSuites() {
+    return this.withFunctionalTesting((ftApi) => ftApi.listSuites());
+  }
   async registerTools(register, _getInput) {
     TOOLS.forEach((tool) => {
       if (tool.toolset === "Functional Testing" && !this.ftApi) {

package/dist/zephyr/common/auth-service.js

@@ -1,4 +1,4 @@
-import { USER_AGENT } from "../../common/info.js";
+import { getUserAgent } from "../../common/info.js";
 class AuthService {
   bearerToken;
   constructor(accessToken) {
@@ -8,7 +8,7 @@ class AuthService {
     return {
       Authorization: `Bearer ${this.bearerToken}`,
       "Content-Type": "application/json",
-      "User-Agent": USER_AGENT,
+      "User-Agent": getUserAgent(),
       "zscale-source": "smartbear-mcp"
     };
   }