@browserstack/mcp-server 1.0.12 → 1.0.14

package/dist/tools/live-utils/start-session.js

@@ -1,37 +1,31 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startBrowserSession = startBrowserSession;
-const logger_1 = __importDefault(require("../../logger"));
-const child_process_1 = __importDefault(require("child_process"));
-const desktop_filter_1 = require("./desktop-filter");
-const mobile_filter_1 = require("./mobile-filter");
-const types_1 = require("./types");
-const local_1 = require("../../lib/local");
+import logger from "../../logger.js";
+import childProcess from "child_process";
+import { filterDesktop } from "./desktop-filter.js";
+import { filterMobile } from "./mobile-filter.js";
+import { PlatformType, } from "./types.js";
+import { isLocalURL, ensureLocalBinarySetup, killExistingBrowserStackLocalProcesses, } from "../../lib/local.js";
 /**
  * Prepares local tunnel setup based on URL type
  */
 async function prepareLocalTunnel(url) {
-    const isLocal = (0, local_1.isLocalURL)(url);
+    const isLocal = isLocalURL(url);
     if (isLocal) {
-        await (0, local_1.ensureLocalBinarySetup)();
+        await ensureLocalBinarySetup();
     }
     else {
-        await (0, local_1.killExistingBrowserStackLocalProcesses)();
+        await killExistingBrowserStackLocalProcesses();
     }
     return isLocal;
 }
 /**
  * Entrypoint: detects platformType & delegates.
  */
-async function startBrowserSession(args) {
-    const entry = args.platformType === types_1.PlatformType.DESKTOP
-        ? await (0, desktop_filter_1.filterDesktop)(args)
-        : await (0, mobile_filter_1.filterMobile)(args);
+export async function startBrowserSession(args) {
+    const entry = args.platformType === PlatformType.DESKTOP
+        ? await filterDesktop(args)
+        : await filterMobile(args);
     const isLocal = await prepareLocalTunnel(args.url);
-    const url = args.platformType === types_1.PlatformType.DESKTOP
+    const url = args.platformType === PlatformType.DESKTOP
         ? buildDesktopUrl(args, entry, isLocal)
         : buildMobileUrl(args, entry, isLocal);
     openBrowser(url);
@@ -81,14 +75,14 @@ function openBrowser(launchUrl) {
                 ? ["cmd", "/c", "start", launchUrl]
                 : ["xdg-open", launchUrl];
         // nosemgrep:javascript.lang.security.detect-child-process.detect-child-process
-        const child = child_process_1.default.spawn(command[0], command.slice(1), {
+        const child = childProcess.spawn(command[0], command.slice(1), {
             stdio: "ignore",
             detached: true,
         });
-        child.on("error", (err) => logger_1.default.error(`Failed to open browser: ${err}. URL: ${launchUrl}`));
+        child.on("error", (err) => logger.error(`Failed to open browser: ${err}. URL: ${launchUrl}`));
         child.unref();
     }
     catch (err) {
-        logger_1.default.error(`Failed to launch browser: ${err}. URL: ${launchUrl}`);
+        logger.error(`Failed to launch browser: ${err}. URL: ${launchUrl}`);
     }
 }

package/dist/tools/live-utils/types.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlatformType = void 0;
-var PlatformType;
+export var PlatformType;
 (function (PlatformType) {
     PlatformType["DESKTOP"] = "desktop";
     PlatformType["MOBILE"] = "mobile";
-})(PlatformType || (exports.PlatformType = PlatformType = {}));
+})(PlatformType || (PlatformType = {}));

package/dist/tools/live-utils/version-resolver.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveVersion = resolveVersion;
 /**
  * If req === "latest" or "oldest", returns max/min numeric (or lex)
  * Else if exact match, returns that
  * Else picks the numerically closest (or first)
  */
-function resolveVersion(requested, available) {
+export function resolveVersion(requested, available) {
     // strip duplicates & sort
     const uniq = Array.from(new Set(available));
     // pick min/max

package/dist/tools/live.js

@@ -1,36 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addBrowserLiveTools;
-const zod_1 = require("zod");
-const logger_1 = __importDefault(require("../logger"));
-const start_session_1 = require("./live-utils/start-session");
-const types_1 = require("./live-utils/types");
-const instrumentation_1 = require("../lib/instrumentation");
+import { z } from "zod";
+import logger from "../logger.js";
+import { startBrowserSession } from "./live-utils/start-session.js";
+import { PlatformType } from "./live-utils/types.js";
+import { trackMCP } from "../lib/instrumentation.js";
 // Define the schema shape
 const LiveArgsShape = {
-    platformType: zod_1.z
-        .nativeEnum(types_1.PlatformType)
+    platformType: z
+        .nativeEnum(PlatformType)
         .describe("Must be 'desktop' or 'mobile'"),
-    desiredURL: zod_1.z.string().url().describe("The URL to test"),
-    desiredOS: zod_1.z
+    desiredURL: z.string().url().describe("The URL to test"),
+    desiredOS: z
         .enum(["Windows", "OS X", "android", "ios", "winphone"])
         .describe("Desktop OS ('Windows' or 'OS X') or mobile OS ('android','ios','winphone')"),
-    desiredOSVersion: zod_1.z
+    desiredOSVersion: z
         .string()
         .describe("The OS version must be specified as a version number (e.g., '10', '14.0') or as a keyword such as 'latest' or 'oldest'. Normalize variations like 'newest' or 'most recent' to 'latest', and terms like 'earliest' or 'first' to 'oldest'. For macOS, version names (e.g., 'Sequoia') must be used instead of numeric versions."),
-    desiredBrowser: zod_1.z
+    desiredBrowser: z
         .enum(["chrome", "firefox", "safari", "edge", "ie"])
         .describe("Browser for desktop (Chrome, IE, Firefox, Safari, Edge)"),
-    desiredBrowserVersion: zod_1.z
+    desiredBrowserVersion: z
         .string()
         .optional()
         .describe("Browser version for desktop (e.g. '133.2', 'latest'). If the user says 'latest', 'newest', or similar, normalize it to 'latest'. Likewise, convert terms like 'earliest' or 'oldest' to 'oldest'."),
-    desiredDevice: zod_1.z.string().optional().describe("Device name for mobile"),
+    desiredDevice: z.string().optional().describe("Device name for mobile"),
 };
-const LiveArgsSchema = zod_1.z.object(LiveArgsShape);
+const LiveArgsSchema = z.object(LiveArgsShape);
 /**
  * Launches a desktop browser session
  */
@@ -39,8 +33,8 @@ async function launchDesktopSession(args) {
         throw new Error("You must provide a desiredBrowser");
     if (!args.desiredBrowserVersion)
         throw new Error("You must provide a desiredBrowserVersion");
-    return (0, start_session_1.startBrowserSession)({
-        platformType: types_1.PlatformType.DESKTOP,
+    return startBrowserSession({
+        platformType: PlatformType.DESKTOP,
         url: args.desiredURL,
         os: args.desiredOS,
         osVersion: args.desiredOSVersion,
@@ -54,8 +48,8 @@ async function launchDesktopSession(args) {
 async function launchMobileSession(args) {
     if (!args.desiredDevice)
         throw new Error("You must provide a desiredDevice");
-    return (0, start_session_1.startBrowserSession)({
-        platformType: types_1.PlatformType.MOBILE,
+    return startBrowserSession({
+        platformType: PlatformType.MOBILE,
         browser: args.desiredBrowser,
         url: args.desiredURL,
         os: args.desiredOS,
@@ -70,7 +64,7 @@ async function runBrowserSession(rawArgs) {
     // Validate and narrow
     const args = LiveArgsSchema.parse(rawArgs);
     // Branch desktop vs mobile and delegate
-    const launchUrl = args.platformType === types_1.PlatformType.DESKTOP
+    const launchUrl = args.platformType === PlatformType.DESKTOP
         ? await launchDesktopSession(args)
         : await launchMobileSession(args);
     return {
@@ -82,15 +76,15 @@ async function runBrowserSession(rawArgs) {
         ],
     };
 }
-function addBrowserLiveTools(server) {
+export default function addBrowserLiveTools(server) {
     server.tool("runBrowserLiveSession", "Launch a BrowserStack Live session (desktop or mobile).", LiveArgsShape, async (args) => {
         try {
-            (0, instrumentation_1.trackMCP)("runBrowserLiveSession", server.server.getClientVersion());
+            trackMCP("runBrowserLiveSession", server.server.getClientVersion());
             return await runBrowserSession(args);
         }
         catch (error) {
-            logger_1.default.error("Live session failed: %s", error);
-            (0, instrumentation_1.trackMCP)("runBrowserLiveSession", server.server.getClientVersion(), error);
+            logger.error("Live session failed: %s", error);
+            trackMCP("runBrowserLiveSession", server.server.getClientVersion(), error);
             return {
                 content: [
                     {

package/dist/tools/observability.js

@@ -1,16 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFailuresInLastRun = getFailuresInLastRun;
-exports.default = addObservabilityTools;
-const zod_1 = require("zod");
-const api_1 = require("../lib/api");
-const instrumentation_1 = require("../lib/instrumentation");
-const logger_1 = __importDefault(require("../logger"));
-async function getFailuresInLastRun(buildName, projectName) {
-    const buildsData = await (0, api_1.getLatestO11YBuildInfo)(buildName, projectName);
+import { z } from "zod";
+import { getLatestO11YBuildInfo } from "../lib/api.js";
+import { trackMCP } from "../lib/instrumentation.js";
+import logger from "../logger.js";
+export async function getFailuresInLastRun(buildName, projectName) {
+    const buildsData = await getLatestO11YBuildInfo(buildName, projectName);
     const observabilityUrl = buildsData.observability_url;
     if (!observabilityUrl) {
         throw new Error("No observability URL found in build data, this is likely because the build is not yet available on BrowserStack Observability.");
@@ -35,22 +28,22 @@ async function getFailuresInLastRun(buildName, projectName) {
         ],
     };
 }
-function addObservabilityTools(server) {
+export default function addObservabilityTools(server) {
     server.tool("getFailuresInLastRun", "Use this tool to debug failures in the last run of the test suite on BrowserStack. Use only when browserstack.yml file is present in the project root.", {
-        buildName: zod_1.z
+        buildName: z
             .string()
             .describe("Name of the build to get failures for. This is the 'build' key in the browserstack.yml file. If not sure, ask the user for the build name."),
-        projectName: zod_1.z
+        projectName: z
             .string()
             .describe("Name of the project to get failures for. This is the 'projectName' key in the browserstack.yml file. If not sure, ask the user for the project name."),
     }, async (args) => {
         try {
-            (0, instrumentation_1.trackMCP)("getFailuresInLastRun", server.server.getClientVersion());
+            trackMCP("getFailuresInLastRun", server.server.getClientVersion());
             return await getFailuresInLastRun(args.buildName, args.projectName);
         }
         catch (error) {
-            logger_1.default.error("Failed to get failures in the last run: %s", error);
-            (0, instrumentation_1.trackMCP)("getFailuresInLastRun", server.server.getClientVersion(), error);
+            logger.error("Failed to get failures in the last run: %s", error);
+            trackMCP("getFailuresInLastRun", server.server.getClientVersion(), error);
             return {
                 content: [
                     {

package/dist/tools/sdk-utils/constants.js

@@ -1,10 +1,4 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SUPPORTED_CONFIGURATIONS = void 0;
-const config_1 = __importDefault(require("../../config"));
+import config from "../../config.js";
 const nodejsInstructions = `
 - Ensure that \`browserstack-node-sdk\` is present in package.json, use the latest version.
 - Add new scripts to package.json for running tests on BrowserStack (use \`npx\` to trigger the sdk):
@@ -27,7 +21,7 @@ python3 -m pip install browserstack-sdk
 
 Run the following command to setup the browserstack-sdk:
 \`\`\`bash
-browserstack-sdk setup --username "${config_1.default.browserstackUsername}" --key "${config_1.default.browserstackAccessKey}"
+browserstack-sdk setup --username "${config.browserstackUsername}" --key "${config.browserstackAccessKey}"
 \`\`\`
 
 In order to run tests on BrowserStack, run the following command:
@@ -35,7 +29,7 @@ In order to run tests on BrowserStack, run the following command:
 browserstack-sdk python <path-to-test-file>
 \`\`\`
 `;
-exports.SUPPORTED_CONFIGURATIONS = {
+export const SUPPORTED_CONFIGURATIONS = {
     nodejs: {
         playwright: {
             jest: { instructions: nodejsInstructions },

package/dist/tools/sdk-utils/instructions.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInstructionsForProjectConfiguration = void 0;
-exports.generateBrowserStackYMLInstructions = generateBrowserStackYMLInstructions;
-const constants_1 = require("./constants");
+import { SUPPORTED_CONFIGURATIONS } from "./constants.js";
 const errorMessageSuffix = "Please open an issue at our Github repo: https://github.com/browserstack/browserstack-mcp-server/issues to request support for your project configuration";
-const getInstructionsForProjectConfiguration = (detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage) => {
-    const configuration = constants_1.SUPPORTED_CONFIGURATIONS[detectedLanguage];
+export const getInstructionsForProjectConfiguration = (detectedBrowserAutomationFramework, detectedTestingFramework, detectedLanguage) => {
+    const configuration = SUPPORTED_CONFIGURATIONS[detectedLanguage];
     if (!configuration) {
         throw new Error(`BrowserStack MCP Server currently does not support ${detectedLanguage}, ${errorMessageSuffix}`);
     }
@@ -17,8 +13,7 @@ const getInstructionsForProjectConfiguration = (detectedBrowserAutomationFramewo
     }
     return configuration[detectedBrowserAutomationFramework][detectedTestingFramework].instructions;
 };
-exports.getInstructionsForProjectConfiguration = getInstructionsForProjectConfiguration;
-function generateBrowserStackYMLInstructions(desiredPlatforms) {
+export function generateBrowserStackYMLInstructions(desiredPlatforms) {
     return `
       Create a browserstack.yml file in the project root. The file should be in the following format:
 

package/dist/tools/sdk-utils/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/tools/testmanagement-utils/TCG-utils/api.js

@@ -0,0 +1,259 @@
+import axios from "axios";
+import { TCG_TRIGGER_URL, TCG_POLL_URL, FETCH_DETAILS_URL, FORM_FIELDS_URL, BULK_CREATE_URL, } from "./config.js";
+import { createTestCasePayload } from "./helpers.js";
+import config from "../../../config.js";
+/**
+ * Fetch default and custom form fields for a project.
+ */
+export async function fetchFormFields(projectId) {
+    const res = await axios.get(FORM_FIELDS_URL(projectId), {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+        },
+    });
+    return res.data;
+}
+/**
+ * Trigger AI-based test case generation for a document.
+ */
+export async function triggerTestCaseGeneration(document, documentId, folderId, projectId, source) {
+    const res = await axios.post(TCG_TRIGGER_URL, {
+        document,
+        documentId,
+        folderId,
+        projectId,
+        source,
+        webhookUrl: `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/webhooks/tcg`,
+    }, {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "Content-Type": "application/json",
+            "request-source": source,
+        },
+    });
+    if (res.status !== 200) {
+        throw new Error(`Trigger failed: ${res.statusText}`);
+    }
+    return res.data["x-bstack-traceRequestId"];
+}
+/**
+ * Initiate a fetch for test-case details; returns the traceRequestId for polling.
+ */
+export async function fetchTestCaseDetails(documentId, folderId, projectId, testCaseIds, source) {
+    if (testCaseIds.length === 0) {
+        throw new Error("No testCaseIds provided to fetchTestCaseDetails");
+    }
+    const res = await axios.post(FETCH_DETAILS_URL, {
+        document_id: documentId,
+        folder_id: folderId,
+        project_id: projectId,
+        test_case_ids: testCaseIds,
+    }, {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            "request-source": source,
+            "Content-Type": "application/json",
+        },
+    });
+    if (res.data.data.success !== true) {
+        throw new Error(`Fetch details failed: ${res.data.data.message}`);
+    }
+    return res.data.request_trace_id;
+}
+/**
+ * Poll for a given traceRequestId until all test-case details are returned.
+ */
+export async function pollTestCaseDetails(traceRequestId) {
+    const detailMap = {};
+    let done = false;
+    while (!done) {
+        // add a bit of jitter to avoid synchronized polling storms
+        await new Promise((r) => setTimeout(r, 10000 + Math.random() * 5000));
+        const poll = await axios.post(`${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(traceRequestId)}`, {}, {
+            headers: {
+                "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            },
+        });
+        if (!poll.data.data.success) {
+            throw new Error(`Polling failed: ${poll.data.data.message}`);
+        }
+        for (const msg of poll.data.data.message) {
+            if (msg.type === "termination") {
+                done = true;
+            }
+            if (msg.type === "testcase_details") {
+                for (const test of msg.data.testcase_details) {
+                    detailMap[test.id] = {
+                        steps: test.steps,
+                        preconditions: test.preconditions,
+                    };
+                }
+            }
+        }
+    }
+    return detailMap;
+}
+/**
+ * Poll for scenarios & testcases, trigger detail fetches, then poll all details in parallel.
+ */
+export async function pollScenariosTestDetails(args, traceId, context, documentId, source) {
+    const { folderId, projectReferenceId } = args;
+    const scenariosMap = {};
+    const detailPromises = [];
+    let iteratorCount = 0;
+    // Promisify interval-style polling using a wrapper
+    await new Promise((resolve, reject) => {
+        const intervalId = setInterval(async () => {
+            try {
+                const poll = await axios.post(`${TCG_POLL_URL}?x-bstack-traceRequestId=${encodeURIComponent(traceId)}`, {}, {
+                    headers: {
+                        "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                    },
+                });
+                if (poll.status !== 200) {
+                    clearInterval(intervalId);
+                    reject(new Error(`Polling error: ${poll.statusText}`));
+                    return;
+                }
+                for (const msg of poll.data.data.message) {
+                    if (msg.type === "scenario") {
+                        msg.data.scenarios.forEach((sc) => {
+                            scenariosMap[sc.id] = { id: sc.id, name: sc.name, testcases: [] };
+                        });
+                        const count = Object.keys(scenariosMap).length;
+                        await context.sendNotification({
+                            method: "notifications/progress",
+                            params: {
+                                progressToken: context._meta?.progressToken ?? traceId,
+                                progress: count,
+                                total: count,
+                                message: `Fetched ${count} scenarios`,
+                            },
+                        });
+                    }
+                    if (msg.type === "testcase") {
+                        const sc = msg.data.scenario;
+                        if (sc) {
+                            const array = Array.isArray(msg.data.testcases)
+                                ? msg.data.testcases
+                                : msg.data.testcases
+                                    ? [msg.data.testcases]
+                                    : [];
+                            const ids = array.map((tc) => tc.id || tc.test_case_id);
+                            const reqId = await fetchTestCaseDetails(documentId, folderId, projectReferenceId, ids, source);
+                            detailPromises.push(pollTestCaseDetails(reqId));
+                            scenariosMap[sc.id] ||= {
+                                id: sc.id,
+                                name: sc.name,
+                                testcases: [],
+                                traceId,
+                            };
+                            scenariosMap[sc.id].testcases.push(...array);
+                            iteratorCount++;
+                            const total = Object.keys(scenariosMap).length;
+                            await context.sendNotification({
+                                method: "notifications/progress",
+                                params: {
+                                    progressToken: context._meta?.progressToken ?? traceId,
+                                    progress: iteratorCount,
+                                    total,
+                                    message: `Fetched ${array.length} test cases for scenario ${iteratorCount} out of ${total}`,
+                                },
+                            });
+                        }
+                    }
+                    if (msg.type === "termination") {
+                        clearInterval(intervalId);
+                        resolve();
+                    }
+                }
+            }
+            catch (err) {
+                clearInterval(intervalId);
+                reject(err);
+            }
+        }, 10000); // 10 second interval
+    });
+    // once all detail fetches are triggered, wait for them to complete
+    const detailsList = await Promise.all(detailPromises);
+    const allDetails = detailsList.reduce((acc, cur) => ({ ...acc, ...cur }), {});
+    // attach the fetched detail objects back to each testcase
+    for (const scenario of Object.values(scenariosMap)) {
+        scenario.testcases = scenario.testcases.map((tc) => ({
+            ...tc,
+            ...(allDetails[tc.id || tc.test_case_id] ?? {}),
+        }));
+    }
+    return scenariosMap;
+}
+/**
+ * Bulk-create generated test cases in BrowserStack.
+ */
+export async function bulkCreateTestCases(scenariosMap, projectId, folderId, fieldMaps, booleanFieldId, traceId, context, documentId) {
+    const results = {};
+    const total = Object.keys(scenariosMap).length;
+    let doneCount = 0;
+    let testCaseCount = 0;
+    for (const { id, testcases } of Object.values(scenariosMap)) {
+        const testCaseLength = testcases.length;
+        testCaseCount += testCaseLength;
+        if (testCaseLength === 0)
+            continue;
+        const payload = {
+            test_cases: testcases.map((tc) => createTestCasePayload(tc, id, folderId, fieldMaps, documentId, booleanFieldId, traceId)),
+        };
+        try {
+            const resp = await axios.post(BULK_CREATE_URL(projectId, folderId), payload, {
+                headers: {
+                    "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            results[id] = resp.data;
+            await context.sendNotification({
+                method: "notifications/progress",
+                params: {
+                    progressToken: context._meta?.progressToken ?? "bulk-create",
+                    message: `Bulk create done for scenario ${doneCount} of ${total}`,
+                    total,
+                    progress: doneCount,
+                },
+            });
+        }
+        catch (error) {
+            //send notification
+            await context.sendNotification({
+                method: "notifications/progress",
+                params: {
+                    progressToken: context._meta?.progressToken ?? traceId,
+                    message: `Bulk create failed for scenario ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    total,
+                    progress: doneCount,
+                },
+            });
+            //continue to next scenario
+            continue;
+        }
+        doneCount++;
+    }
+    const resultString = `Total of ${testCaseCount} test cases created in ${total} scenarios.`;
+    return resultString;
+}
+export async function projectIdentifierToId(projectId) {
+    const url = `https://test-management.browserstack.com/api/v1/projects/?q=${projectId}`;
+    const response = await axios.get(url, {
+        headers: {
+            "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+            accept: "application/json, text/plain, */*",
+        },
+    });
+    if (response.data.success !== true) {
+        throw new Error(`Failed to fetch project ID: ${response.statusText}`);
+    }
+    for (const project of response.data.projects) {
+        if (project.identifier === projectId) {
+            return project.id;
+        }
+    }
+    throw new Error(`Project with identifier ${projectId} not found.`);
+}

package/dist/tools/testmanagement-utils/TCG-utils/config.js

@@ -0,0 +1,5 @@
+export const TCG_TRIGGER_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/suggest-test-cases";
+export const TCG_POLL_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/test-cases-polling";
+export const FETCH_DETAILS_URL = "https://test-management.browserstack.com/api/v1/integration/tcg/test-generation/fetch-test-case-details";
+export const FORM_FIELDS_URL = (projectId) => `https://test-management.browserstack.com/api/v1/projects/${projectId}/form-fields-v2`;
+export const BULK_CREATE_URL = (projectId, folderId) => `https://test-management.browserstack.com/api/v1/projects/${projectId}/folder/${folderId}/bulk-test-cases`;

package/dist/tools/testmanagement-utils/TCG-utils/helpers.js

@@ -0,0 +1,53 @@
+/**
+ * Build mappings for default fields for priority, status, and case type.
+ */
+export function buildDefaultFieldMaps(defaultFields) {
+    const priority = Object.fromEntries(defaultFields.priority.values.map((v) => [
+        v.name.toLowerCase(),
+        v.value,
+    ]));
+    const status = Object.fromEntries(defaultFields.status.values.map((v) => [v.internal_name, v.value]));
+    const caseType = Object.fromEntries(defaultFields.case_type.values.map((v) => [v.internal_name, v.value]));
+    return { priority, status, caseType };
+}
+/**
+ * Find a boolean custom field ID if present.
+ */
+export function findBooleanFieldId(customFields) {
+    const boolField = customFields.find((f) => f.field_type === "field_boolean");
+    return boolField?.id;
+}
+/**
+ * Construct payload for creating a single test case in bulk.
+ */
+export function createTestCasePayload(tc, scenarioId, folderId, fieldMaps, documentId, booleanFieldId, traceId) {
+    const pri = tc.priority ?? "Medium";
+    const stat = fieldMaps.status["active"];
+    const ct = fieldMaps.caseType["functional"];
+    return {
+        attachments: [documentId],
+        name: tc.name,
+        description: tc.description,
+        test_case_folder_id: folderId,
+        priority: pri,
+        status: stat,
+        case_type: ct,
+        automation_status: "not_automated",
+        fetch_ai_test_case_details: true,
+        template: "test_case_steps",
+        metadata: JSON.stringify({
+            ai_prompt: {
+                attachment_id: documentId,
+                rich_text_id: null,
+                scenario: scenarioId,
+                test_case_count: tc.test_case_count || 1,
+                uuid: tc.uuid || crypto.randomUUID?.() || "unknown-uuid",
+                "x-bstack-traceRequestId": traceId,
+            },
+        }),
+        tags: ["AI Generated", "MCP Generated"],
+        custom_fields: booleanFieldId ? { [booleanFieldId]: false } : undefined,
+        test_case_steps: tc.steps,
+        preconditions: tc.preconditions,
+    };
+}

package/dist/tools/testmanagement-utils/TCG-utils/types.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const CreateTestCasesFromFileSchema = z.object({
+    documentId: z.string().describe("Internal document identifier"),
+    folderId: z.string().describe("BrowserStack folder ID"),
+    projectReferenceId: z
+        .string()
+        .describe("The BrowserStack project reference ID is a unique identifier found in the project URL within the BrowserStack Test Management Platform. This ID is also returned by the Upload Document tool."),
+});