@browserstack/mcp-server 1.2.15-beta.1 → 1.2.16-beta.1

package/dist/tools/percy-sdk.js

@@ -1,7 +1,6 @@
 import { trackMCP } from "../index.js";
 import { fetchPercyChanges } from "./review-agent.js";
 import { addListTestFiles } from "./list-test-files.js";
-import { runPercyScan } from "./run-percy-scan.js";
 import { SetUpPercyParamsShape } from "./sdk-utils/common/schema.js";
 import { updateTestsWithPercyCommands } from "./add-percy-snapshots.js";
 import { approveOrDeclinePercyBuild } from "./review-agent-utils/percy-approve-reject.js";
@@ -9,7 +8,10 @@ import { setUpPercyHandler, simulatePercyChangeHandler, } from "./sdk-utils/hand
 import { z } from "zod";
 import { SETUP_PERCY_DESCRIPTION, LIST_TEST_FILES_DESCRIPTION, PERCY_SNAPSHOT_COMMANDS_DESCRIPTION, SIMULATE_PERCY_CHANGE_DESCRIPTION, } from "./sdk-utils/common/constants.js";
 import { UpdateTestFileWithInstructionsParams } from "./percy-snapshot-utils/constants.js";
-import { RunPercyScanParamsShape, FetchPercyChangesParamsShape, ManagePercyBuildApprovalParamsShape, } from "./sdk-utils/common/schema.js";
+import { 
+// PMAA-100: kept commented so the registration block below is easy to restore once the proper fix lands.
+// RunPercyScanParamsShape,
+FetchPercyChangesParamsShape, ManagePercyBuildApprovalParamsShape, } from "./sdk-utils/common/schema.js";
 import { handleMCPError } from "../lib/utils.js";
 export function registerPercyTools(server, config) {
     const tools = {};
@@ -66,15 +68,22 @@ export function registerPercyTools(server, config) {
             return handleMCPError("listTestFiles", server, config, error);
         }
     });
-    tools.runPercyScan = server.tool("runPercyScan", "Run a Percy visual test scan. Example prompts : Run this Percy build/scan. Never run percy scan/build without this tool", RunPercyScanParamsShape, async (args) => {
-        try {
-            trackMCP("runPercyScan", server.server.getClientVersion(), config);
-            return runPercyScan(args, config);
-        }
-        catch (error) {
-            return handleMCPError("runPercyScan", server, config, error);
-        }
-    });
+    // PMAA-100: runPercyScan temporarily disabled — fetched Percy token was being
+    // returned in plaintext within tool output (see HackerOne #3576387). Re-enable
+    // once the token is replaced with a placeholder in run-percy-scan.ts.
+    // tools.runPercyScan = server.tool(
+    //   "runPercyScan",
+    //   "Run a Percy visual test scan. Example prompts : Run this Percy build/scan. Never run percy scan/build without this tool",
+    //   RunPercyScanParamsShape,
+    //   async (args) => {
+    //     try {
+    //       trackMCP("runPercyScan", server.server.getClientVersion()!, config);
+    //       return runPercyScan(args, config);
+    //     } catch (error) {
+    //       return handleMCPError("runPercyScan", server, config, error);
+    //     }
+    //   },
+    // );
     tools.fetchPercyChanges = server.tool("fetchPercyChanges", "Retrieves and summarizes all visual changes detected by Percy AI between the latest and previous builds, helping quickly review what has changed in your project.", FetchPercyChangesParamsShape, async (args) => {
         try {
             trackMCP("fetchPercyChanges", server.server.getClientVersion(), config);

package/dist/tools/testmanagement-utils/get-testplan.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for fetching a single test plan by identifier, including its linked test runs.
+ */
+export declare const GetTestPlanSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    test_plan_identifier: z.ZodString;
+}, z.core.$strip>;
+export type GetTestPlanArgs = z.infer<typeof GetTestPlanSchema>;
+/**
+ * Fetches a test plan by identifier and its linked test runs, returning a unified view
+ * suitable for generating documentation (metadata + linked runs + status summary + case count).
+ */
+export declare function getTestPlan(args: GetTestPlanArgs, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/testmanagement-utils/get-testplan.js

@@ -0,0 +1,99 @@
+import { apiClient } from "../../lib/apiClient.js";
+import { z } from "zod";
+import { formatAxiosError } from "../../lib/error.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import { getTMBaseURL } from "../../lib/tm-base-url.js";
+/**
+ * Schema for fetching a single test plan by identifier, including its linked test runs.
+ */
+export const GetTestPlanSchema = z.object({
+    project_identifier: z
+        .string()
+        .describe("Identifier of the project (starts with PR- followed by a number)."),
+    test_plan_identifier: z
+        .string()
+        .describe("Identifier of the test plan (starts with TP- followed by a number)."),
+});
+/**
+ * Fetches a test plan by identifier and its linked test runs, returning a unified view
+ * suitable for generating documentation (metadata + linked runs + status summary + case count).
+ */
+export async function getTestPlan(args, config) {
+    try {
+        const tmBaseUrl = await getTMBaseURL(config);
+        const projectId = encodeURIComponent(args.project_identifier);
+        const planId = encodeURIComponent(args.test_plan_identifier);
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const authHeader = "Basic " + Buffer.from(`${username}:${password}`).toString("base64");
+        const planResp = await apiClient.get({
+            url: `${tmBaseUrl}/api/v2/projects/${projectId}/test-plans/${planId}`,
+            headers: { Authorization: authHeader },
+        });
+        if (!planResp.data?.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to fetch test plan: ${JSON.stringify(planResp.data)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const plan = planResp.data.test_plan;
+        const runsResp = await apiClient.get({
+            url: `${tmBaseUrl}/api/v2/projects/${projectId}/test-plans/${planId}/test-runs`,
+            headers: { Authorization: authHeader },
+        });
+        const runs = runsResp.data?.success
+            ? (runsResp.data.test_runs ?? [])
+            : [];
+        const statusSummary = {};
+        let totalCases = 0;
+        for (const run of runs) {
+            statusSummary[run.run_state] = (statusSummary[run.run_state] ?? 0) + 1;
+            totalCases += run.test_cases_count ?? 0;
+        }
+        const header = [
+            `Test Plan ${plan.identifier}: ${plan.name}`,
+            `Status: ${plan.active_state}`,
+            plan.description ? `Description: ${plan.description}` : null,
+            plan.start_date || plan.end_date
+                ? `Dates: ${plan.start_date ?? "—"} → ${plan.end_date ?? "—"}`
+                : null,
+            `Linked runs: ${runs.length} (plan counts — active ${plan.test_runs_count?.active ?? 0} / closed ${plan.test_runs_count?.closed ?? 0})`,
+            `Total test cases across runs: ${totalCases}`,
+            Object.keys(statusSummary).length > 0
+                ? `Run-state breakdown: ${Object.entries(statusSummary)
+                    .map(([s, n]) => `${s}=${n}`)
+                    .join(", ")}`
+                : null,
+        ]
+            .filter(Boolean)
+            .join("\n");
+        const runsBlock = runs.length
+            ? "\n\nLinked test runs:\n" +
+                runs
+                    .map((r) => `• ${r.identifier}: ${r.name} [${r.run_state}] — ${r.test_cases_count} case(s)${r.assignee ? ` (assignee: ${r.assignee})` : ""}`)
+                    .join("\n")
+            : "\n\nNo test runs linked to this plan.";
+        return {
+            content: [
+                { type: "text", text: header + runsBlock },
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        test_plan: plan,
+                        linked_test_runs: runs,
+                        status_summary: statusSummary,
+                        total_test_cases: totalCases,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return formatAxiosError(err, "Failed to fetch test plan");
+    }
+}

package/dist/tools/testmanagement-utils/list-folders.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for listing folders in a BrowserStack Test Management project.
+ */
+export declare const ListFoldersSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    parent_id: z.ZodOptional<z.ZodNumber>;
+    p: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListFoldersArgs = z.infer<typeof ListFoldersSchema>;
+/**
+ * Lists folders (or sub-folders) for a project in BrowserStack Test Management.
+ */
+export declare function listFolders(args: ListFoldersArgs, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/testmanagement-utils/list-folders.js

@@ -0,0 +1,77 @@
+import { apiClient } from "../../lib/apiClient.js";
+import { z } from "zod";
+import { formatAxiosError } from "../../lib/error.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import { getTMBaseURL } from "../../lib/tm-base-url.js";
+/**
+ * Schema for listing folders in a BrowserStack Test Management project.
+ */
+export const ListFoldersSchema = z.object({
+    project_identifier: z
+        .string()
+        .describe("Identifier of the project to fetch folders from (starts with PR- followed by a number)."),
+    parent_id: z
+        .number()
+        .optional()
+        .describe("If provided, list sub-folders under this parent folder id. If omitted, lists top-level folders."),
+    p: z.number().optional().describe("Page number."),
+});
+/**
+ * Lists folders (or sub-folders) for a project in BrowserStack Test Management.
+ */
+export async function listFolders(args, config) {
+    try {
+        const params = new URLSearchParams();
+        if (args.p !== undefined)
+            params.append("p", args.p.toString());
+        const tmBaseUrl = await getTMBaseURL(config);
+        const projectId = encodeURIComponent(args.project_identifier);
+        // GET /api/v2/projects/{projectIdentifier}/folders
+        // or  /api/v2/projects/{projectIdentifier}/folders/{parent_id}/sub-folders
+        const path = args.parent_id !== undefined
+            ? `folders/${args.parent_id}/sub-folders`
+            : `folders`;
+        const url = `${tmBaseUrl}/api/v2/projects/${projectId}/${path}?${params.toString()}`;
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const resp = await apiClient.get({
+            url,
+            headers: {
+                Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
+            },
+        });
+        const folders = resp.data?.folders ?? [];
+        const info = resp.data?.info ?? {};
+        const count = info.count ?? folders.length;
+        if (folders.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: args.parent_id !== undefined
+                            ? `No sub-folders found under folder ${args.parent_id} in project ${args.project_identifier}.`
+                            : `No folders found in project ${args.project_identifier}.`,
+                    },
+                ],
+            };
+        }
+        const summary = folders
+            .map((f) => `• [id=${f.id}] ${f.name} — ${f.cases_count} case(s), ${f.sub_folders_count} sub-folder(s)${f.parent_id ? ` (parent=${f.parent_id})` : ""}`)
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Found ${count} folder(s) in project ${args.project_identifier}:\n\n${summary}`,
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(folders, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return formatAxiosError(err, "Failed to list folders");
+    }
+}

package/dist/tools/testmanagement-utils/list-testcases.js

@@ -13,7 +13,7 @@ export const ListTestCasesSchema = z.object({
     folder_id: z
         .string()
         .optional()
-        .describe("If provided, only return cases in this folder."),
+        .describe("Optional. If provided, only return test cases in this folder. If omitted, returns all test cases in the project. Folder ids can be discovered via listFolders."),
     case_type: z
         .string()
         .optional()

package/dist/tools/testmanagement-utils/list-testplans.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for listing test plans in a BrowserStack Test Management project.
+ */
+export declare const ListTestPlansSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    p: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListTestPlansArgs = z.infer<typeof ListTestPlansSchema>;
+/**
+ * Lists test plans for a project in BrowserStack Test Management.
+ */
+export declare function listTestPlans(args: ListTestPlansArgs, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/testmanagement-utils/list-testplans.js

@@ -0,0 +1,75 @@
+import { apiClient } from "../../lib/apiClient.js";
+import { z } from "zod";
+import { formatAxiosError } from "../../lib/error.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+import { getTMBaseURL } from "../../lib/tm-base-url.js";
+/**
+ * Schema for listing test plans in a BrowserStack Test Management project.
+ */
+export const ListTestPlansSchema = z.object({
+    project_identifier: z
+        .string()
+        .describe("Identifier of the project to fetch test plans from (starts with PR- followed by a number)."),
+    p: z.number().optional().describe("Page number."),
+});
+/**
+ * Lists test plans for a project in BrowserStack Test Management.
+ */
+export async function listTestPlans(args, config) {
+    try {
+        const params = new URLSearchParams();
+        if (args.p !== undefined)
+            params.append("p", args.p.toString());
+        const tmBaseUrl = await getTMBaseURL(config);
+        const projectId = encodeURIComponent(args.project_identifier);
+        const url = `${tmBaseUrl}/api/v2/projects/${projectId}/test-plans?${params.toString()}`;
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const resp = await apiClient.get({
+            url,
+            headers: {
+                Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
+            },
+        });
+        const data = resp.data;
+        if (!data.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to list test plans: ${JSON.stringify(data)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const plans = data.test_plans ?? [];
+        const info = data.info ?? {};
+        const count = info.count ?? plans.length;
+        if (plans.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No test plans found in project ${args.project_identifier}.`,
+                    },
+                ],
+            };
+        }
+        const summary = plans
+            .map((p) => `• ${p.identifier}: ${p.name} [${p.active_state}] — ${p.test_runs_count?.active ?? 0} active / ${p.test_runs_count?.closed ?? 0} closed run(s)`)
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Found ${count} test plan(s) in project ${args.project_identifier}:\n\n${summary}`,
+                },
+                { type: "text", text: JSON.stringify(plans, null, 2) },
+            ],
+        };
+    }
+    catch (err) {
+        return formatAxiosError(err, "Failed to list test plans");
+    }
+}

package/dist/tools/testmanagement-utils/update-testcase.d.ts

@@ -11,6 +11,14 @@ export interface TestCaseUpdateRequest {
         step: string;
         result: string;
     }>;
+    owner?: string;
+    priority?: string;
+    case_type?: string;
+    automation_status?: string;
+    status?: string;
+    tags?: string[];
+    issues?: string[];
+    custom_fields?: Record<string, string | number | boolean>;
 }
 export declare const UpdateTestCaseSchema: z.ZodObject<{
     project_identifier: z.ZodString;
@@ -22,6 +30,14 @@ export declare const UpdateTestCaseSchema: z.ZodObject<{
         step: z.ZodString;
         result: z.ZodString;
     }, z.core.$strip>>>;
+    owner: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodString>;
+    case_type: z.ZodOptional<z.ZodString>;
+    automation_status: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    issues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    custom_fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
 }, z.core.$strip>;
 /**
  * Updates an existing test case in BrowserStack Test Management.

package/dist/tools/testmanagement-utils/update-testcase.js

@@ -1,7 +1,7 @@
 import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
 import { formatAxiosError } from "../../lib/error.js";
-import { projectIdentifierToId } from "./TCG-utils/api.js";
+import { fetchFormFields, projectIdentifierToId } from "./TCG-utils/api.js";
 import { getTMBaseURL } from "../../lib/tm-base-url.js";
 import { getBrowserStackAuth } from "../../lib/get-auth.js";
 import logger from "../../logger.js";
@@ -28,26 +28,148 @@ export const UpdateTestCaseSchema = z.object({
     }))
         .optional()
         .describe("Updated list of test case steps with expected results."),
+    owner: z
+        .string()
+        .email()
+        .optional()
+        .describe("Email of the test case owner."),
+    priority: z
+        .string()
+        .optional()
+        .describe("Updated priority. Accepts either display name (e.g. 'Medium', 'Critical', 'High', 'Low') or internal name (e.g. 'medium'). Valid values are per-project and discoverable via the form-fields endpoint."),
+    case_type: z
+        .string()
+        .optional()
+        .describe("Updated test case type. Accepts either display name (e.g. 'Functional', 'Regression', 'Smoke & Sanity') or internal name (e.g. 'functional', 'smoke_sanity'). Valid values are per-project."),
+    automation_status: z
+        .string()
+        .optional()
+        .describe("Updated automation status. Use internal name such as 'not_automated', 'automated', 'automation_not_required', 'cannot_be_automated', or 'obsolete'."),
+    status: z
+        .string()
+        .optional()
+        .describe("Updated review status of the test case (e.g. 'active', 'draft', 'in_review', 'outdated', 'rejected')."),
+    tags: z
+        .array(z.string())
+        .optional()
+        .describe("Replacement list of tags for the test case."),
+    issues: z
+        .array(z.string())
+        .optional()
+        .describe("Replacement list of linked Jira/Asana/Azure issue IDs for the test case."),
+    custom_fields: z
+        .record(z.string(), z.union([z.string(), z.number(), z.boolean()]))
+        .optional()
+        .describe("Map of custom field name/id to value. Valid field names and value types are per-project; discover them via the project's form fields."),
 });
+/**
+ * Build a normalizer for a default field's accepted value.
+ * The TM PATCH endpoint accepts different casings for different default
+ * fields (Title-Case display name for priority/case_type, snake_case
+ * internal_name for automation_status). We accept either from the caller
+ * and emit the form the API actually wants.
+ *
+ * Returns undefined when no matching option is found — callers should
+ * pass the raw value through so the backend can surface its own error.
+ */
+function normalizeDefaultFieldValue(fieldValues, input, emit) {
+    const normalized = input.toLowerCase().trim();
+    const match = fieldValues.find((v) => (v.internal_name ?? "").toLowerCase() === normalized ||
+        (v.name ?? "").toLowerCase() === normalized);
+    if (!match)
+        return undefined;
+    if (emit === "name")
+        return match.name;
+    return match.internal_name ?? match.name;
+}
+/**
+ * Normalise default-field inputs (priority/case_type/automation_status) to
+ * what the TM PATCH endpoint accepts. Fetches the project's form-fields
+ * on demand; on failure, returns inputs unchanged and lets the backend
+ * surface validation errors.
+ */
+async function normalizeDefaultFields(params, config) {
+    const needsLookup = params.priority !== undefined ||
+        params.case_type !== undefined ||
+        params.automation_status !== undefined;
+    if (!needsLookup)
+        return {};
+    try {
+        const numericProjectId = await projectIdentifierToId(params.project_identifier, config);
+        const { default_fields } = await fetchFormFields(numericProjectId, config);
+        const out = {};
+        if (params.priority !== undefined) {
+            out.priority =
+                normalizeDefaultFieldValue(default_fields?.priority?.values ?? [], params.priority, "name") ?? params.priority;
+        }
+        if (params.case_type !== undefined) {
+            out.case_type =
+                normalizeDefaultFieldValue(default_fields?.case_type?.values ?? [], params.case_type, "name") ?? params.case_type;
+        }
+        if (params.automation_status !== undefined) {
+            // automation_status.values have null internal_name and the internal
+            // name is actually held in `value` (see API inspection). Accept
+            // either the display name or the internal snake_case form.
+            const values = default_fields?.automation_status?.values ?? [];
+            const input = params.automation_status.toLowerCase().trim();
+            const match = values.find((v) => (v.value ?? "").toLowerCase() === input ||
+                (v.name ?? "").toLowerCase() === input);
+            out.automation_status = match?.value ?? params.automation_status;
+        }
+        return out;
+    }
+    catch (err) {
+        logger.warn("Failed to normalize default field values; passing through as given: %s", err instanceof Error ? err.message : String(err));
+        return {
+            priority: params.priority,
+            case_type: params.case_type,
+            automation_status: params.automation_status,
+        };
+    }
+}
 /**
  * Updates an existing test case in BrowserStack Test Management.
  */
 export async function updateTestCase(params, config) {
     const authString = getBrowserStackAuth(config);
     const [username, password] = authString.split(":");
-    // Build the request body with only the fields to update
     const testCaseBody = {};
-    if (params.name !== undefined) {
+    if (params.name !== undefined)
         testCaseBody.name = params.name;
-    }
-    if (params.description !== undefined) {
+    if (params.description !== undefined)
         testCaseBody.description = params.description;
-    }
-    if (params.preconditions !== undefined) {
+    if (params.preconditions !== undefined)
         testCaseBody.preconditions = params.preconditions;
-    }
-    if (params.test_case_steps !== undefined) {
+    if (params.test_case_steps !== undefined)
         testCaseBody.steps = params.test_case_steps;
+    if (params.owner !== undefined)
+        testCaseBody.owner = params.owner;
+    if (params.status !== undefined)
+        testCaseBody.status = params.status;
+    if (params.tags !== undefined)
+        testCaseBody.tags = params.tags;
+    if (params.issues !== undefined)
+        testCaseBody.issues = params.issues;
+    if (params.custom_fields !== undefined)
+        testCaseBody.custom_fields = params.custom_fields;
+    // Default fields need value normalization (see notes above the helper).
+    const normalized = await normalizeDefaultFields(params, config);
+    if (normalized.priority !== undefined)
+        testCaseBody.priority = normalized.priority;
+    if (normalized.case_type !== undefined)
+        testCaseBody.case_type = normalized.case_type;
+    if (normalized.automation_status !== undefined)
+        testCaseBody.automation_status = normalized.automation_status;
+    if (Object.keys(testCaseBody).length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No updatable fields provided. Pass at least one of: name, description, preconditions, test_case_steps, owner, priority, case_type, automation_status, status, tags, issues, custom_fields.",
+                },
+            ],
+            isError: true,
+        };
     }
     const body = { test_case: testCaseBody };
     try {
@@ -80,7 +202,7 @@ export async function updateTestCase(params, config) {
                 {
                     type: "text",
                     text: `Test case successfully updated:
-          
+
 **Test Case Details:**
 - **ID**: ${tc.identifier}
 - **Name**: ${tc.title}
@@ -88,6 +210,7 @@ export async function updateTestCase(params, config) {
 - **Case Type**: ${tc.case_type}
 - **Priority**: ${tc.priority}
 - **Status**: ${tc.status}
+- **Automation Status**: ${tc.automation_status ?? "N/A"}
 
 **View on BrowserStack Dashboard:**
 https://test-management.browserstack.com/projects/${projectId}/folders/${tc.folder_id}/test-cases/${tc.identifier}

package/dist/tools/testmanagement.d.ts

@@ -5,6 +5,7 @@ import { CreateProjFoldSchema } from "./testmanagement-utils/create-project-fold
 import { TestCaseCreateRequest } from "./testmanagement-utils/create-testcase.js";
 import { TestCaseUpdateRequest } from "./testmanagement-utils/update-testcase.js";
 import { ListTestCasesSchema } from "./testmanagement-utils/list-testcases.js";
+import { ListFoldersSchema } from "./testmanagement-utils/list-folders.js";
 import { CreateTestRunSchema } from "./testmanagement-utils/create-testrun.js";
 import { ListTestRunsSchema } from "./testmanagement-utils/list-testruns.js";
 import { UpdateTestRunSchema } from "./testmanagement-utils/update-testrun.js";
@@ -12,6 +13,8 @@ import { AddTestResultSchema } from "./testmanagement-utils/add-test-result.js";
 import { UploadFileSchema } from "./testmanagement-utils/upload-file.js";
 import { CreateTestCasesFromFileSchema } from "./testmanagement-utils/TCG-utils/types.js";
 import { CreateLCAStepsSchema } from "./testmanagement-utils/create-lca-steps.js";
+import { ListTestPlansSchema } from "./testmanagement-utils/list-testplans.js";
+import { GetTestPlanSchema } from "./testmanagement-utils/get-testplan.js";
 import { BrowserStackConfig } from "../lib/types.js";
 /**
  * Wrapper to call createProjectOrFolder util.
@@ -29,6 +32,10 @@ export declare function updateTestCaseTool(args: TestCaseUpdateRequest, config:
  * Lists test cases in a project with optional filters (status, priority, custom fields, etc.)
  */
 export declare function listTestCasesTool(args: z.infer<typeof ListTestCasesSchema>, config: BrowserStackConfig, server: McpServer): Promise<CallToolResult>;
+/**
+ * Lists folders in a project (or sub-folders under a parent folder).
+ */
+export declare function listFoldersTool(args: z.infer<typeof ListFoldersSchema>, config: BrowserStackConfig, server: McpServer): Promise<CallToolResult>;
 /**
  * Creates a test run in BrowserStack Test Management.
  */
@@ -59,6 +66,14 @@ export declare function createTestCasesFromFileTool(args: z.infer<typeof CreateT
  * Creates LCA (Low Code Automation) steps for a test case in BrowserStack Test Management.
  */
 export declare function createLCAStepsTool(args: z.infer<typeof CreateLCAStepsSchema>, context: any, config: BrowserStackConfig, server: McpServer): Promise<CallToolResult>;
+/**
+ * Lists test plans in a project.
+ */
+export declare function listTestPlansTool(args: z.infer<typeof ListTestPlansSchema>, config: BrowserStackConfig, server: McpServer): Promise<CallToolResult>;
+/**
+ * Fetches a test plan by identifier, with its linked runs and a derived status summary.
+ */
+export declare function getTestPlanTool(args: z.infer<typeof GetTestPlanSchema>, config: BrowserStackConfig, server: McpServer): Promise<CallToolResult>;
 /**
  * Registers both project/folder and test-case tools.
  */

package/dist/tools/testmanagement.js

@@ -4,6 +4,7 @@ import { createProjectOrFolder, CreateProjFoldSchema, } from "./testmanagement-u
 import { createTestCase as createTestCaseAPI, sanitizeArgs, CreateTestCaseSchema, } from "./testmanagement-utils/create-testcase.js";
 import { updateTestCase as updateTestCaseAPI, UpdateTestCaseSchema, } from "./testmanagement-utils/update-testcase.js";
 import { listTestCases, ListTestCasesSchema, } from "./testmanagement-utils/list-testcases.js";
+import { listFolders, ListFoldersSchema, } from "./testmanagement-utils/list-folders.js";
 import { CreateTestRunSchema, createTestRun, } from "./testmanagement-utils/create-testrun.js";
 import { ListTestRunsSchema, listTestRuns, } from "./testmanagement-utils/list-testruns.js";
 import { UpdateTestRunSchema, updateTestRun, } from "./testmanagement-utils/update-testrun.js";
@@ -12,6 +13,8 @@ import { UploadFileSchema, uploadFile, } from "./testmanagement-utils/upload-fil
 import { createTestCasesFromFile } from "./testmanagement-utils/testcase-from-file.js";
 import { CreateTestCasesFromFileSchema } from "./testmanagement-utils/TCG-utils/types.js";
 import { createLCASteps, CreateLCAStepsSchema, } from "./testmanagement-utils/create-lca-steps.js";
+import { listTestPlans, ListTestPlansSchema, } from "./testmanagement-utils/list-testplans.js";
+import { getTestPlan, GetTestPlanSchema, } from "./testmanagement-utils/get-testplan.js";
 //TODO: Moving the traceMCP and catch block to the parent(server) function
 /**
  * Wrapper to call createProjectOrFolder util.
@@ -102,6 +105,27 @@ export async function listTestCasesTool(args, config, server) {
         };
     }
 }
+/**
+ * Lists folders in a project (or sub-folders under a parent folder).
+ */
+export async function listFoldersTool(args, config, server) {
+    try {
+        trackMCP("listFolders", server.server.getClientVersion(), undefined, config);
+        return await listFolders(args, config);
+    }
+    catch (err) {
+        trackMCP("listFolders", server.server.getClientVersion(), err, config);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to list folders: ${err instanceof Error ? err.message : "Unknown error"}. Please open an issue on GitHub if the problem persists`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
 /**
  * Creates a test run in BrowserStack Test Management.
  */
@@ -251,6 +275,50 @@ export async function createLCAStepsTool(args, context, config, server) {
         };
     }
 }
+/**
+ * Lists test plans in a project.
+ */
+export async function listTestPlansTool(args, config, server) {
+    try {
+        trackMCP("listTestPlans", server.server.getClientVersion(), undefined, config);
+        return await listTestPlans(args, config);
+    }
+    catch (err) {
+        logger.error("Failed to list test plans: %s", err);
+        trackMCP("listTestPlans", server.server.getClientVersion(), err, config);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to list test plans: ${err instanceof Error ? err.message : "Unknown error"}. Please open an issue on GitHub if the problem persists`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+/**
+ * Fetches a test plan by identifier, with its linked runs and a derived status summary.
+ */
+export async function getTestPlanTool(args, config, server) {
+    try {
+        trackMCP("getTestPlan", server.server.getClientVersion(), undefined, config);
+        return await getTestPlan(args, config);
+    }
+    catch (err) {
+        logger.error("Failed to fetch test plan: %s", err);
+        trackMCP("getTestPlan", server.server.getClientVersion(), err, config);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to fetch test plan: ${err instanceof Error ? err.message : "Unknown error"}. Please open an issue on GitHub if the problem persists`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
 /**
  * Registers both project/folder and test-case tools.
  */
@@ -258,8 +326,9 @@ export default function addTestManagementTools(server, config) {
     const tools = {};
     tools.createProjectOrFolder = server.tool("createProjectOrFolder", "Create a project and/or folder in BrowserStack Test Management.", CreateProjFoldSchema.shape, (args) => createProjectOrFolderTool(args, config, server));
     tools.createTestCase = server.tool("createTestCase", "Use this tool to create a test case in BrowserStack Test Management.", CreateTestCaseSchema.shape, (args) => createTestCaseTool(args, config, server));
-    tools.updateTestCase = server.tool("updateTestCase", "Use this tool to update an existing test case in BrowserStack Test Management. Allows editing test case details like name, description, steps, owner, priority, and more.", UpdateTestCaseSchema.shape, (args) => updateTestCaseTool(args, config, server));
-    tools.listTestCases = server.tool("listTestCases", "List test cases in a project with optional filters (status, priority, custom fields, etc.)", ListTestCasesSchema.shape, (args) => listTestCasesTool(args, config, server));
+    tools.updateTestCase = server.tool("updateTestCase", "Update an existing test case in BrowserStack Test Management. Any subset of the following fields may be changed: name, description, preconditions, test_case_steps, owner, priority, case_type, automation_status, status, tags, issues, custom_fields. Only the supplied fields are modified.", UpdateTestCaseSchema.shape, (args) => updateTestCaseTool(args, config, server));
+    tools.listTestCases = server.tool("listTestCases", "List test cases in a project, optionally scoped to a specific folder. Omit folder_id to list all test cases in the project; provide folder_id (discoverable via listFolders) to list only that folder's cases. Supports filters: case_type, priority, pagination.", ListTestCasesSchema.shape, (args) => listTestCasesTool(args, config, server));
+    tools.listFolders = server.tool("listFolders", "List folders in a BrowserStack Test Management project, returning each folder's id and name (plus case counts and sub-folder counts). Pass parent_id to list sub-folders under a specific folder instead of top-level folders.", ListFoldersSchema.shape, (args) => listFoldersTool(args, config, server));
     tools.createTestRun = server.tool("createTestRun", "Create a test run in BrowserStack Test Management.", CreateTestRunSchema.shape, (args) => createTestRunTool(args, config, server));
     tools.listTestRuns = server.tool("listTestRuns", "List test runs in a project with optional filters (date ranges, assignee, state, etc.)", ListTestRunsSchema.shape, (args) => listTestRunsTool(args, config, server));
     tools.updateTestRun = server.tool("updateTestRun", "Update a test run in BrowserStack Test Management.", UpdateTestRunSchema.shape, (args) => updateTestRunTool(args, config, server));
@@ -267,5 +336,7 @@ export default function addTestManagementTools(server, config) {
     tools.uploadProductRequirementFile = server.tool("uploadProductRequirementFile", "Upload files (e.g., PDRs, PDFs) to BrowserStack Test Management and retrieve a file mapping ID. This is utilized for generating test cases from files and is part of the Test Case Generator AI Agent in BrowserStack.", UploadFileSchema.shape, (args) => uploadProductRequirementFileTool(args, config, server));
     tools.createTestCasesFromFile = server.tool("createTestCasesFromFile", "Generate test cases from a file in BrowserStack Test Management using the Test Case Generator AI Agent.", CreateTestCasesFromFileSchema.shape, (args, context) => createTestCasesFromFileTool(args, context, config, server));
     tools.createLCASteps = server.tool("createLCASteps", "Generate Low Code Automation (LCA) steps for a test case in BrowserStack Test Management using the Low Code Automation Agent.", CreateLCAStepsSchema.shape, (args, context) => createLCAStepsTool(args, context, config, server));
+    tools.listTestPlans = server.tool("listTestPlans", "List test plans in a BrowserStack Test Management project. Returns each plan's identifier (TP-*), name, status, description, dates, and active/closed test-run counts. Supports pagination.", ListTestPlansSchema.shape, (args) => listTestPlansTool(args, config, server));
+    tools.getTestPlan = server.tool("getTestPlan", "Fetch a test plan by identifier (TP-*) from BrowserStack Test Management. Returns plan metadata, the full list of linked test runs, total test-case count across runs, and a status summary — suitable for generating test documentation or QA status reports.", GetTestPlanSchema.shape, (args) => getTestPlanTool(args, config, server));
     return tools;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browserstack/mcp-server",
-  "version": "1.2.15-beta.1",
+  "version": "1.2.16-beta.1",
   "description": "BrowserStack's Official MCP Server",
   "mcpName": "io.github.browserstack/mcp-server",
   "main": "dist/index.js",