@smartbear/mcp 0.1.0

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SmartBear Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+<div align="center">
+  <a href="https://www.smartbear.com">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="assets/smartbear-logo-light.svg">
+      <img alt="SmartBear logo" src="assets/smartbear-logo-dark.svg">
+    </picture>
+  </a>
+  <h1>SmartBear MCP server</h1>
+</div>
+
+An [MCP](https://modelcontextprotocol.io) server for SmartBear's API Hub, Test Hub and Insight Hub.
+
+## Build
+
+Checkout this repository and run the following to build the server:
+
+```bash
+npm run build
+```
+
+## Usage
+
+The server is started with the API key or auth token that you use with your product(s). They are optional and can be removed from your configuration if you aren't using the product.
+
+### VS Code
+
+Add the following configuration to `.vscode/mcp.json`, replacing `<PATH_TO_SMARTBEAR_MCP>` with the location of this repo on your filesystem:
+
+```json
+{
+  "servers": {
+    "smartbear": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["<PATH_TO_SMARTBEAR_MCP>/dist/index.js"],
+
+      "env": {
+        "INSIGHT_HUB_AUTH_TOKEN": "${input:insight_hub_auth_token}",
+        "REFLECT_API_TOKEN": "${input:reflect_api_token}",
+        "API_HUB_API_KEY": "${input:api_hub_api_key}"
+      }
+    }
+  },
+  "inputs": [
+      {
+         "id": "insight_hub_auth_token",
+         "type": "promptString",
+         "description": "Insight Hub Auth Token",
+         "password": true
+      },
+      {
+         "id": "reflect_api_token",
+         "type": "promptString",
+         "description": "Reflect API Token",
+         "password": true
+      },
+      {
+         "id": "api_hub_api_key",
+         "type": "promptString",
+         "description": "API Hub API Key",
+         "password": true
+      }
+  ]
+}
+```
+
+### MCP Inspector
+
+To test the MCP server locally, you can use the following command (assuming a local build of the MCP server in the same location):
+
+```bash
+REFLECT_API_TOKEN=your_reflect_token INSIGHT_HUB_AUTH_TOKEN=your_insight_hub_token API_HUB_API_KEY=your_api_hub_api_key npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+This will open an inspector window in your browser, where you can test the tools.
+
+## Environment Variables
+
+- `INSIGHT_HUB_AUTH_TOKEN`: Required for Insight Hub tools. The Auth Token for Insight Hub.
+- `REFLECT_API_TOKEN`: Required for Reflect tools. The Reflect Account API Key for Reflect-based tools.
+- `API_HUB_API_KEY`: Required for API Hub tools. The API Key for API Hub tools.
+- `MCP_SERVER_INSIGHT_HUB_API_KEY`: Optional. If set, enables error reporting of the _MCP_server_ code via the BugSnag SDK. This is useful for debugging and monitoring of the MCP server itself and shouldn't be set to the same API key as your app.
+
+## Supported Tools
+
+See individual guides for suggested prompts and supported tools and resources:
+
+- [Insight Hub](./insight-hub/README.md)\
+  Get your top events and invite your LLM to help you fix them.
+- [Reflect](./reflect/README.md)
+- [API Hub](./api-hub/README.md)
+
+## License
+
+This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

package/dist/api-hub/client.js

@@ -0,0 +1,181 @@
+import { z } from "zod";
+// Tool definitions for API Hub API client
+export class ApiHubClient {
+    headers;
+    constructor(token) {
+        this.headers = {
+            "Authorization": `Bearer ${token}`,
+            "Content-Type": "application/json",
+        };
+    }
+    async getPortals() {
+        const response = await fetch("https://api.portal.swaggerhub.com/v1/portals", {
+            method: "GET",
+            headers: this.headers,
+        });
+        return response.json();
+    }
+    async createPortal(body) {
+        const response = await fetch(`https://api.portal.swaggerhub.com/v1/portals`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return response.json();
+    }
+    async getPortal(portalId) {
+        const response = await fetch(`https://api.portal.swaggerhub.com/v1/portals/${portalId}`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        return response.json();
+    }
+    async deletePortal(portalId) {
+        await fetch(`https://api.portal.swaggerhub.com/v1/portals/${portalId}`, {
+            method: "DELETE",
+            headers: this.headers,
+        });
+    }
+    async updatePortal(portalId, body) {
+        const response = await fetch(`https://api.portal.swaggerhub.com/v1/portals/${portalId}`, {
+            method: "PATCH",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return response.json();
+    }
+    async getPortalProducts(portalId) {
+        const response = await fetch(`https://api.portal.swaggerhub.com/v1/portals/${portalId}/products`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        return response.json();
+    }
+    async createPortalProduct(portalId, body) {
+        const response = await fetch(`https://api.portal.swaggerhub.com/v1/portals/${portalId}/products`, {
+            method: "POST",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return response.json();
+    }
+    async getPortalProduct(productId) {
+        const response = await fetch(`https://api.portal.swaggerhub.com/v1/products/${productId}`, {
+            method: "GET",
+            headers: this.headers,
+        });
+        return response.json();
+    }
+    async deletePortalProduct(productId) {
+        await fetch(`https://api.portal.swaggerhub.com/v1/products/${productId}`, {
+            method: "DELETE",
+            headers: this.headers,
+        });
+    }
+    async updatePortalProduct(productId, body) {
+        const response = await fetch(`https://api.portal.swaggerhub.com/v1/products/${productId}`, {
+            method: "PATCH",
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        return response.json();
+    }
+    registerTools(server) {
+        server.tool("list_portals", "Search for available portals within API Hub. Only portals where you have at least a designer role, either at the product level or organization level, are returned.", {}, async (_args, _extra) => {
+            const response = await this.getPortals();
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("create_portal", "Create a new portal within API Hub.", {
+            name: z.string().optional().describe("The portal name."),
+            subdomain: z.string().describe("The portal subdomain."),
+            offline: z.boolean().optional().describe("If set to true the portal will not be visible to customers."),
+            routing: z.string().optional().describe("Determines the routing strategy ('browser' or 'proxy')."),
+            credentialsEnabled: z.string().optional().describe("Indicates if credentials are enabled for the portal."),
+            swaggerHubOrganizationId: z.string().describe("The corresponding API Hub (formerly SwaggerHub) organization UUID."),
+            openapiRenderer: z.string().optional().describe("Portal level setting for the OpenAPI renderer. SWAGGER_UI - Use the Swagger UI renderer. ELEMENTS - Use the Elements renderer. TOGGLE - Switch between the two renderers with elements set as the default."),
+            pageContentFormat: z.string().optional().describe("The format of the page content.")
+        }, async (args, _extra) => {
+            const response = await this.createPortal(args);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("get_portal", "Retrieve information about a specific portal.", { portalId: z.string().describe("Portal UUID or subdomain.") }, async (args, _extra) => {
+            const response = await this.getPortal(args.portalId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("delete_portal", "Delete a portal.", { portalId: z.string().describe("Portal UUID or subdomain.") }, async (args, _extra) => {
+            await this.deletePortal(args.portalId);
+            return {
+                content: [{ type: "text", text: "Portal deleted successfully." }],
+            };
+        });
+        server.tool("update_portal", "Update a specifc portal's configuration", {
+            portalId: z.string().describe("Portal UUID or subdomain."),
+            name: z.string().optional().describe("The portal name."),
+            subdomain: z.string().optional().describe("The portal subdomain."),
+            customDomain: z.boolean().optional().describe("Indicates if the portal has a custom domain."),
+            gtmKey: z.string().optional().describe("Google Tag Manager key for the portal."),
+            offline: z.boolean().optional().describe("If set to true the portal will not be visible to customers."),
+            routing: z.string().optional().describe("Determines the routing strategy ('browser' or 'proxy')."),
+            credentialsEnabled: z.boolean().optional().describe("Indicates if credentials are enabled for the portal."),
+            openapiRenderer: z.string().optional().describe("Portal level setting for the OpenAPI renderer. SWAGGER_UI - Use the Swagger UI renderer. ELEMENTS - Use the Elements renderer. TOGGLE - Switch between the two renderers with elements set as the default."),
+            pageContentFormat: z.string().optional().describe("The format of the page content.")
+        }, async (args, _extra) => {
+            const response = await this.updatePortal(args.portalId, args);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("list_portal_products", "Get products for a specific portal that match your criteria.", { portalId: z.string().describe("Portal UUID or subdomain.") }, async (args, _extra) => {
+            const response = await this.getPortalProducts(args.portalId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("create_portal_product", "Create a new product for a specific portal.", {
+            portalId: z.string().describe("Portal UUID or subdomain."),
+            type: z.string().describe("Product type (Allowed values: 'new', 'copy')."),
+            name: z.string().describe("Product name."),
+            slug: z.string().describe("URL component for this product. Must be unique within the portal."),
+            description: z.string().optional().describe("Product description."),
+            public: z.boolean().optional().describe("Indicates if the product is public."),
+            hidden: z.string().optional().describe("Indicates if the product is hidden."),
+            role: z.boolean().optional().describe("Indicates if the product has a role.")
+        }, async (args, _extra) => {
+            const response = await this.createPortalProduct(args.portalId, args);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("get_portal_product", "Retrieve information about a specific product resource.", { productId: z.string().describe("Product UUID, or identifier in the format.") }, async (args, _extra) => {
+            const response = await this.getPortalProduct(args.productId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("delete_portal_product", "Delete a product from a specific portal", { productId: z.string().describe("Product UUID, or identifier in the format.") }, async (args, _extra) => {
+            await this.deletePortalProduct(args.productId);
+            return {
+                content: [{ type: "text", text: "Product deleted successfully." }],
+            };
+        });
+        server.tool("update_portal_product", "Update a product's settings within a specific portal.", {
+            productId: z.string().describe("Product UUID, or identifier in the format."),
+            name: z.string().optional().describe("Product name."),
+            slug: z.string().optional().describe("URL component for this product. Must be unique within the portal."),
+            description: z.string().optional().describe("Product description."),
+            public: z.boolean().optional().describe("Indicates if the product is public."),
+            hidden: z.string().optional().describe("Indicates if the product is hidden.")
+        }, async (args, _extra) => {
+            const response = await this.updatePortalProduct(args.productId, args);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+    }
+}

package/dist/common/bugsnag.js

@@ -0,0 +1,3 @@
+// workaround for a known issue with Bugsnag types in node16 modules: https://github.com/bugsnag/bugsnag-js/issues/2052
+import * as Bugsnag from "@bugsnag/js";
+export default Bugsnag.default;

package/dist/common/info.js

@@ -0,0 +1,3 @@
+import packageJson from '../package.json' with { type: "json" };
+export const MCP_SERVER_NAME = packageJson.config.mcpServerName;
+export const MCP_SERVER_VERSION = packageJson.version;

package/dist/common/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import Bugsnag from "./common/bugsnag.js";
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "./common/info.js";
+import { InsightHubClient } from "./insight-hub/client.js";
+import { ReflectClient } from "./reflect/client.js";
+import { ApiHubClient } from "./api-hub/client.js";
+// This is used to report errors in the MCP server itself
+// If you want to use your own BugSnag API key, set the MCP_SERVER_INSIGHT_HUB_API_KEY environment variable
+const McpServerBugsnagAPIKey = process.env.MCP_SERVER_INSIGHT_HUB_API_KEY;
+if (McpServerBugsnagAPIKey) {
+    Bugsnag.start(McpServerBugsnagAPIKey);
+}
+async function main() {
+    const server = new McpServer({
+        name: MCP_SERVER_NAME,
+        version: MCP_SERVER_VERSION,
+    }, {
+        capabilities: {
+            resources: { listChanged: true }, // Server supports dynamic resource lists
+            tools: { listChanged: true }, // Server supports dynamic tool lists
+        },
+    });
+    const reflectToken = process.env.REFLECT_API_TOKEN;
+    const insightHubToken = process.env.INSIGHT_HUB_AUTH_TOKEN;
+    const apiHubToken = process.env.API_HUB_API_KEY;
+    if (!reflectToken && !insightHubToken && !apiHubToken) {
+        console.error("Please set one of REFLECT_API_TOKEN, INSIGHT_HUB_AUTH_TOKEN or API_HUB_API_KEY environment variables");
+        process.exit(1);
+    }
+    if (reflectToken) {
+        const reflectClient = new ReflectClient(reflectToken);
+        reflectClient.registerTools(server);
+        reflectClient.registerResources(server);
+    }
+    if (insightHubToken) {
+        const insightHubClient = new InsightHubClient(insightHubToken);
+        insightHubClient.registerTools(server);
+        insightHubClient.registerResources(server);
+    }
+    if (apiHubToken) {
+        const apiHubClient = new ApiHubClient(apiHubToken);
+        apiHubClient.registerTools(server);
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/insight-hub/client/api/CurrentUser.js

@@ -0,0 +1,54 @@
+import { BaseAPI, pickFieldsFromArray } from './base.js';
+// --- API Class ---
+export class CurrentUserAPI extends BaseAPI {
+    static organizationFields = ['id', 'name'];
+    static projectFields = ['id', 'name', 'slug'];
+    constructor(configuration) {
+        super(configuration);
+    }
+    /**
+     * List the current user's organizations
+     * GET /user/organizations
+     */
+    async listUserOrganizations(options = {}) {
+        const { admin, paginate = false, ...queryOptions } = options;
+        const params = new URLSearchParams();
+        if (admin !== undefined)
+            params.append('admin', String(admin));
+        for (const [key, value] of Object.entries(queryOptions)) {
+            if (value !== undefined)
+                params.append(key, String(value));
+        }
+        const url = params.toString() ? `/user/organizations?${params}` : '/user/organizations';
+        const data = await this.request({
+            method: 'GET',
+            url,
+        }, paginate);
+        // Only return allowed fields
+        return pickFieldsFromArray(data, CurrentUserAPI.organizationFields);
+    }
+    /**
+     * List projects for a given organization
+     * GET /organizations/{organization_id}/projects
+     * @param organizationId The organization ID
+     * @param options Optional parameters for filtering, pagination, etc.
+     * @returns A promise that resolves to the list of projects in the organization
+     */
+    async getOrganizationProjects(organizationId, options = {}) {
+        const { paginate = false, ...queryOptions } = options;
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(queryOptions)) {
+            if (value !== undefined)
+                params.append(key, String(value));
+        }
+        const url = params.toString()
+            ? `/organizations/${organizationId}/projects?${params}`
+            : `/organizations/${organizationId}/projects`;
+        const data = await this.request({
+            method: 'GET',
+            url,
+        }, paginate);
+        // Only return allowed fields
+        return pickFieldsFromArray(data, CurrentUserAPI.projectFields);
+    }
+}

package/dist/insight-hub/client/api/Error.js

@@ -0,0 +1,61 @@
+import { BaseAPI } from './base.js';
+// --- API Class ---
+export class ErrorAPI extends BaseAPI {
+    constructor(configuration) {
+        super(configuration);
+    }
+    /**
+     * View an Error on a Project
+     * GET /projects/{project_id}/errors/{error_id}
+     */
+    async viewErrorOnProject(projectId, errorId, options = {}) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options)) {
+            if (value !== undefined)
+                params.append(key, String(value));
+        }
+        const url = params.toString()
+            ? `/projects/${projectId}/errors/${errorId}?${params}`
+            : `/projects/${projectId}/errors/${errorId}`;
+        return (await this.request({
+            method: 'GET',
+            url,
+        }));
+    }
+    /**
+     * View the latest Event on an Error
+     * GET /errors/{error_id}/latest_event
+     */
+    async viewLatestEventOnError(errorId, options = {}) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options)) {
+            if (value !== undefined)
+                params.append(key, String(value));
+        }
+        const url = params.toString()
+            ? `/errors/${errorId}/latest_event?${params}`
+            : `/errors/${errorId}/latest_event`;
+        return (await this.request({
+            method: 'GET',
+            url,
+        }));
+    }
+    /**
+     * View an Event by ID
+     * GET /projects/{project_id}/events/{event_id}
+     */
+    async viewEventById(projectId, eventId, options = {}) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options)) {
+            if (value !== undefined)
+                params.append(key, String(value));
+        }
+        const url = params.toString()
+            ? `/projects/${projectId}/events/${eventId}?${params}`
+            : `/projects/${projectId}/events/${eventId}`;
+        return (await this.request({
+            method: 'GET',
+            url,
+        }));
+    }
+}

package/dist/insight-hub/client/api/base.js

@@ -0,0 +1,54 @@
+// Utility to pick only allowed fields from an object
+export function pickFields(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+// Utility to pick only allowed fields from an array of objects
+export function pickFieldsFromArray(arr, keys) {
+    return arr.map(obj => pickFields(obj, keys));
+}
+export class BaseAPI {
+    configuration;
+    constructor(configuration) {
+        this.configuration = configuration;
+    }
+    async request(options, paginate = false) {
+        const headers = {
+            ...this.configuration.headers,
+            ...options.headers,
+        };
+        headers['Authorization'] = `token ${this.configuration.authToken}`;
+        const fetchOptions = {
+            method: options.method,
+            headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        };
+        const url = options.url.startsWith('http') ? options.url : `${this.configuration.basePath || ''}${options.url}`;
+        let results = [];
+        let nextUrl = url;
+        do {
+            const response = await fetch(nextUrl, fetchOptions);
+            const data = await response.json();
+            if (paginate) {
+                results = results.concat(data);
+                const link = response.headers.get('Link');
+                if (link) {
+                    const match = link.match(/<([^>]+)>;\s*rel="next"/);
+                    nextUrl = match ? match[1] : undefined;
+                }
+                else {
+                    nextUrl = undefined;
+                }
+            }
+            else {
+                return data;
+            }
+        } while (paginate && nextUrl);
+        return results;
+    }
+}

package/dist/insight-hub/client/api/index.js

@@ -0,0 +1,2 @@
+export { CurrentUserAPI } from "./CurrentUser.js";
+export { ErrorAPI } from "./Error.js";

package/dist/insight-hub/client/configuration.js

@@ -0,0 +1,10 @@
+export class Configuration {
+    authToken;
+    basePath;
+    headers;
+    constructor(param) {
+        this.authToken = param.authToken;
+        this.basePath = param.basePath;
+        this.headers = param.headers || {};
+    }
+}

package/dist/insight-hub/client/index.js

@@ -0,0 +1,2 @@
+export * from "./api/index.js";
+export * from "./configuration.js";

package/dist/insight-hub/client.js

@@ -0,0 +1,149 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { MCP_SERVER_NAME, MCP_SERVER_VERSION } from "../common/info.js";
+import { CurrentUserAPI, ErrorAPI, Configuration } from "./client/index.js";
+import { z } from "zod";
+import Bugsnag from "../common/bugsnag.js";
+export class InsightHubClient {
+    currentUserApi;
+    errorsApi;
+    constructor(token) {
+        const config = new Configuration({
+            authToken: token,
+            headers: {
+                "User-Agent": `${MCP_SERVER_NAME}/${MCP_SERVER_VERSION}`,
+                "Content-Type": "application/json",
+            },
+            basePath: "https://api.bugsnag.com",
+        });
+        this.currentUserApi = new CurrentUserAPI(config);
+        this.errorsApi = new ErrorAPI(config);
+    }
+    async listOrgs() {
+        return this.currentUserApi.listUserOrganizations();
+    }
+    async listProjects(orgId, options) {
+        options = {
+            ...options,
+            paginate: true
+        };
+        return this.currentUserApi.getOrganizationProjects(orgId, options);
+    }
+    async getErrorDetails(projectId, errorId) {
+        return this.errorsApi.viewErrorOnProject(projectId, errorId);
+    }
+    async getLatestErrorEvent(errorId) {
+        return this.errorsApi.viewLatestEventOnError(errorId);
+    }
+    async getProjectEvent(projectId, eventId) {
+        return this.errorsApi.viewEventById(projectId, eventId);
+    }
+    async findEventById(eventId) {
+        const projects = await this.listOrgs().then(([org]) => this.listProjects(org.id));
+        const eventDetails = await Promise.all(projects.map((p) => this.getProjectEvent(p.id, eventId).catch(_e => null)));
+        return eventDetails.find(event => !!event);
+    }
+    registerTools(server) {
+        server.tool("list_insight_hub_projects", "List all projects in an organization", { orgId: z.string().describe("ID of the organization to list projects for") }, async (args, _extra) => {
+            try {
+                if (!args.orgId)
+                    throw new Error("orgId argument is required");
+                const response = await this.listProjects(args.orgId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response) }],
+                };
+            }
+            catch (e) {
+                Bugsnag.notify(e);
+                throw e;
+            }
+        });
+        server.tool("get_insight_hub_error", "Get error details from a project", {
+            projectId: z.string().describe("ID of the project"),
+            errorId: z.string().describe("ID of the error to fetch"),
+        }, async (args, _extra) => {
+            try {
+                if (!args.projectId || !args.errorId)
+                    throw new Error("Both projectId and errorId arguments are required");
+                const response = await this.getErrorDetails(args.projectId, args.errorId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response) }],
+                };
+            }
+            catch (e) {
+                Bugsnag.notify(e);
+                throw e;
+            }
+        });
+        server.tool("get_insight_hub_error_latest_event", "Get the latest event for an error", {
+            errorId: z.string().describe("ID of the error to get the latest event for"),
+        }, async (args, _extra) => {
+            try {
+                if (!args.errorId)
+                    throw new Error("errorId argument is required");
+                const response = await this.getLatestErrorEvent(args.errorId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response) }],
+                };
+            }
+            catch (e) {
+                Bugsnag.notify(e);
+                throw e;
+            }
+        });
+        server.tool("get_insight_hub_event_details", "Get details of a specific event on Insight Hub", {
+            link: z.string().describe("Link to the event details"),
+        }, async (args, _extra) => {
+            try {
+                if (!args.link)
+                    throw new Error("link argument is required");
+                const url = new URL(args.link);
+                const eventId = url.searchParams.get("event_id");
+                const projectSlug = url.pathname.split('/')[2];
+                if (!projectSlug || !eventId)
+                    throw new Error("Both projectSlug and eventId must be present in the link");
+                // get the project id from list of projects
+                // limitation: this assumes a single page of results, so will not work for orgs with >100 projects
+                const orgId = await this.currentUserApi.listUserOrganizations().then(orgs => orgs[0].id);
+                const projectId = await this.listProjects(orgId).then(projects => projects.find((p) => p.slug === projectSlug)?.id);
+                const response = await this.getProjectEvent(projectId, eventId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response) }],
+                };
+            }
+            catch (e) {
+                Bugsnag.notify(e);
+                throw e;
+            }
+        });
+    }
+    registerResources(server) {
+        server.resource("insight_hub_orgs", "insighthub://orgs", { description: "List all organizations in Insight Hub", mimeType: "application/json" }, async (uri) => {
+            try {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify(await this.listOrgs())
+                        }]
+                };
+            }
+            catch (e) {
+                Bugsnag.notify(e);
+                throw e;
+            }
+        });
+        server.resource("insight_hub_event", new ResourceTemplate("insighthub://event/{id}", { list: undefined }), async (uri, { id }) => {
+            try {
+                return {
+                    contents: [{
+                            uri: uri.href,
+                            text: JSON.stringify(await this.findEventById(id))
+                        }]
+                };
+            }
+            catch (e) {
+                Bugsnag.notify(e);
+                throw e;
+            }
+        });
+    }
+}

package/dist/package.json

@@ -0,0 +1,35 @@
+{
+    "name": "@smartbear/mcp",
+    "version": "0.1.0",
+    "description": "MCP server for interacting SmartBear Products",
+    "license": "MIT",
+    "type": "module",
+    "bin": {
+        "mcp-server-smartbear": "dist/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "config": {
+        "mcpServerName": "SmartBear MCP Server"
+    },
+    "scripts": {
+        "build": "tsc && shx chmod +x dist/*.js",
+        "lint": "eslint . --ext .ts",
+        "prepare": "npm run build",
+        "watch": "tsc --watch"
+    },
+    "dependencies": {
+        "@bugsnag/js": "^8.2.0",
+        "@modelcontextprotocol/sdk": "1.12.1"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.29.0",
+        "@types/node": "^22",
+        "eslint": "^9.29.0",
+        "globals": "^16.2.0",
+        "shx": "^0.3.4",
+        "typescript": "^5.6.2",
+        "typescript-eslint": "^8.34.1"
+    }
+}

package/dist/reflect/client.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+// ReflectClient class implementing the Client interface
+export class ReflectClient {
+    headers;
+    constructor(token) {
+        this.headers = {
+            "X-API-KEY": `${token}`,
+            "Content-Type": "application/json",
+        };
+    }
+    async listReflectSuits() {
+        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();
+    }
+    registerTools(server) {
+        server.tool("list_reflect_suites", "List all reflect suites", {}, async (_args, _extra) => {
+            const response = await this.listReflectSuits();
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("list_reflect_suite_executions", "List all executions for a given reflect suite", { suiteId: z.string().describe("ID of the reflect suite to list executions for") }, async (args, _extra) => {
+            if (!args.suiteId)
+                throw new Error("suiteId argument is required");
+            const response = await this.listSuiteExecutions(args.suiteId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("reflect_suite_execution_status", "Get the status of a reflect suite execution", {
+            suiteId: z.string().describe("ID of the reflect suite to list executions for"),
+            executionId: z.string().describe("ID of the reflect suite execution to get status for"),
+        }, async (args, _extra) => {
+            if (!args.suiteId || !args.executionId)
+                throw new Error("Both suiteId and executionId arguments are required");
+            const response = await this.getSuiteExecutionStatus(args.suiteId, args.executionId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("reflect_suite_execution", "Execute a reflect suite", { suiteId: z.string().describe("ID of the reflect suite to list executions for") }, async (args, _extra) => {
+            if (!args.suiteId)
+                throw new Error("suiteId argument is required");
+            const response = await this.executeSuite(args.suiteId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("cancel_reflect_suite_execution", "Cancel a reflect suite execution", {
+            suiteId: z.string().describe("ID of the reflect suite to cancel execution for"),
+            executionId: z.string().describe("ID of the reflect suite execution to cancel"),
+        }, async (args, _extra) => {
+            if (!args.suiteId || !args.executionId)
+                throw new Error("Both suiteId and executionId arguments are required");
+            const response = await this.cancelSuiteExecution(args.suiteId, args.executionId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("list_reflect_tests", "List all reflect tests", {}, async (_args, _extra) => {
+            const response = await this.listReflectTests();
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("run_reflect_test", "Run a reflect test", { testId: z.string().describe("ID of the reflect test to run") }, async (args, _extra) => {
+            if (!args.testId)
+                throw new Error("testId argument is required");
+            const response = await this.runReflectTest(args.testId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+        server.tool("reflect_test_status", "Get the status of a reflect test execution", {
+            testId: z.string().describe("ID of the reflect test to run"),
+            executionId: z.string().describe("ID of the reflect test execution to get status for"),
+        }, async (args, _extra) => {
+            if (!args.testId || !args.executionId)
+                throw new Error("Both testId and executionId arguments are required");
+            const response = await this.getReflectTestStatus(args.testId, args.executionId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        });
+    }
+    registerResources(_server) {
+        // Reflect does not currently support dynamic resources
+    }
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@smartbear/mcp",
+  "version": "0.1.0",
+  "description": "MCP server for interacting SmartBear Products",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "mcp-server-smartbear": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "config": {
+    "mcpServerName": "SmartBear MCP Server"
+  },
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/*.js",
+    "lint": "eslint . --ext .ts",
+    "prepare": "npm run build",
+    "watch": "tsc --watch"
+  },
+  "dependencies": {
+    "@bugsnag/js": "^8.2.0",
+    "@modelcontextprotocol/sdk": "1.12.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.29.0",
+    "@types/node": "^22",
+    "eslint": "^9.29.0",
+    "globals": "^16.2.0",
+    "shx": "^0.3.4",
+    "typescript": "^5.6.2",
+    "typescript-eslint": "^8.34.1"
+  }
+}