@browserstack/mcp-server 1.1.8 → 1.2.0

package/dist/tools/testmanagement-utils/add-test-result.js

@@ -1,7 +1,6 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 import { z } from "zod";
-import { formatAxiosError } from "../../lib/error.js";
 /**
  * Schema for adding a test result to a test run.
  */
@@ -26,7 +25,7 @@ export const AddTestResultSchema = z.object({
 /**
  * Adds a test result to a specific test run via BrowserStack Test Management API.
  */
-export async function addTestResult(rawArgs) {
+export async function addTestResult(rawArgs, config) {
     try {
         const args = AddTestResultSchema.parse(rawArgs);
         const url = `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(args.project_identifier)}/test-runs/${encodeURIComponent(args.test_run_id)}/results`;
@@ -34,12 +33,15 @@ export async function addTestResult(rawArgs) {
             test_result: args.test_result,
             test_case_id: args.test_case_id,
         };
-        const response = await axios.post(url, body, {
-            auth: {
-                username: config.browserstackUsername,
-                password: config.browserstackAccessKey,
+        const authString = getBrowserStackAuth(config);
+        const [username, password] = authString.split(":");
+        const response = await apiClient.post({
+            url,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
             },
-            headers: { "Content-Type": "application/json" },
+            body,
         });
         const data = response.data;
         if (!data.success) {
@@ -56,6 +58,17 @@ export async function addTestResult(rawArgs) {
         };
     }
     catch (err) {
-        return formatAxiosError(err, "Failed to add test result to test run");
+        const msg = err?.response?.data?.message ||
+            err?.response?.data?.error ||
+            err?.message ||
+            String(err);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to add test result to test run: ${msg}`,
+                },
+            ],
+        };
     }
 }

package/dist/tools/testmanagement-utils/create-lca-steps.d.ts

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+/**
+ * Schema for creating LCA steps for a test case
+ */
+export declare const CreateLCAStepsSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    test_case_identifier: z.ZodString;
+    base_url: z.ZodString;
+    credentials: z.ZodOptional<z.ZodObject<{
+        username: z.ZodString;
+        password: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        username: string;
+        password: string;
+    }, {
+        username: string;
+        password: string;
+    }>>;
+    local_enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    test_name: z.ZodString;
+    test_case_details: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        preconditions: z.ZodString;
+        test_case_steps: z.ZodArray<z.ZodObject<{
+            step: z.ZodString;
+            result: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            step: string;
+            result: string;
+        }, {
+            step: string;
+            result: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        test_case_steps: {
+            step: string;
+            result: string;
+        }[];
+        preconditions: string;
+    }, {
+        name: string;
+        description: string;
+        test_case_steps: {
+            step: string;
+            result: string;
+        }[];
+        preconditions: string;
+    }>;
+    wait_for_completion: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    project_identifier: string;
+    test_case_identifier: string;
+    base_url: string;
+    local_enabled: boolean;
+    test_name: string;
+    test_case_details: {
+        name: string;
+        description: string;
+        test_case_steps: {
+            step: string;
+            result: string;
+        }[];
+        preconditions: string;
+    };
+    wait_for_completion: boolean;
+    credentials?: {
+        username: string;
+        password: string;
+    } | undefined;
+}, {
+    project_identifier: string;
+    test_case_identifier: string;
+    base_url: string;
+    test_name: string;
+    test_case_details: {
+        name: string;
+        description: string;
+        test_case_steps: {
+            step: string;
+            result: string;
+        }[];
+        preconditions: string;
+    };
+    credentials?: {
+        username: string;
+        password: string;
+    } | undefined;
+    local_enabled?: boolean | undefined;
+    wait_for_completion?: boolean | undefined;
+}>;
+export type CreateLCAStepsArgs = z.infer<typeof CreateLCAStepsSchema>;
+/**
+ * Creates LCA (Low Code Automation) steps for a test case in BrowserStack Test Management
+ */
+export declare function createLCASteps(args: CreateLCAStepsArgs, context: any, config: BrowserStackConfig): Promise<CallToolResult>;

package/dist/tools/testmanagement-utils/create-lca-steps.js

@@ -1,9 +1,8 @@
 import { z } from "zod";
-import axios from "axios";
-import config from "../../config.js";
-import { formatAxiosError } from "../../lib/error.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { projectIdentifierToId, testCaseIdentifierToDetails, } from "./TCG-utils/api.js";
 import { pollLCAStatus } from "./poll-lca-status.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 /**
  * Schema for creating LCA steps for a test case
  */
@@ -50,12 +49,12 @@ export const CreateLCAStepsSchema = z.object({
 /**
  * Creates LCA (Low Code Automation) steps for a test case in BrowserStack Test Management
  */
-export async function createLCASteps(args, context) {
+export async function createLCASteps(args, context, config) {
     try {
         // Get the project ID from identifier
-        const projectId = await projectIdentifierToId(args.project_identifier);
+        const projectId = await projectIdentifierToId(args.project_identifier, config);
         // Get the test case ID and folder ID from identifier
-        const { testCaseId, folderId } = await testCaseIdentifierToDetails(projectId, args.test_case_identifier);
+        const { testCaseId, folderId } = await testCaseIdentifierToDetails(projectId, args.test_case_identifier, config);
         const url = `https://test-management.browserstack.com/api/v1/projects/${projectId}/test-cases/${testCaseId}/lcnc`;
         const payload = {
             base_url: args.base_url,
@@ -66,67 +65,53 @@ export async function createLCASteps(args, context) {
             version: "v2",
             webhook_path: `https://test-management.browserstack.com/api/v1/projects/${projectId}/test-cases/${testCaseId}/webhooks/lcnc`,
         };
-        const response = await axios.post(url, payload, {
+        await apiClient.post({
+            url,
             headers: {
-                "API-TOKEN": `${config.browserstackUsername}:${config.browserstackAccessKey}`,
+                "API-TOKEN": getBrowserStackAuth(config),
                 accept: "application/json, text/plain, */*",
                 "Content-Type": "application/json",
             },
+            body: payload,
         });
-        if (response.status >= 200 && response.status < 300) {
-            // Check if user wants to wait for completion
-            if (!args.wait_for_completion) {
+        // Check if user wants to wait for completion
+        if (!args.wait_for_completion) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                    },
+                    {
+                        type: "text",
+                        text: "LCA build started. Check the BrowserStack Lowcode Automation UI for completion status.",
+                    },
+                ],
+            };
+        }
+        // Start polling for LCA build completion
+        try {
+            const max_wait_minutes = 10; // Maximum wait time in minutes
+            const maxWaitMs = max_wait_minutes * 60 * 1000;
+            const lcaResult = await pollLCAStatus(projectId, folderId, testCaseId, context, maxWaitMs, // max wait time
+            2 * 60 * 1000, // 2 minutes initial wait
+            10 * 1000, // 10 seconds interval
+            config);
+            if (lcaResult && lcaResult.status === "done") {
                 return {
                     content: [
                         {
                             type: "text",
-                            text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                            text: `Successfully created LCA steps for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
                         },
                         {
                             type: "text",
-                            text: "LCA build started. Check the BrowserStack Lowcode Automation UI for completion status.",
+                            text: `LCA build completed! Resource URL: ${lcaResult.resource_path}`,
                         },
                     ],
                 };
             }
-            // Start polling for LCA build completion
-            try {
-                const max_wait_minutes = 10; // Maximum wait time in minutes
-                const maxWaitMs = max_wait_minutes * 60 * 1000;
-                const lcaResult = await pollLCAStatus(projectId, folderId, testCaseId, context, maxWaitMs, // max wait time
-                2 * 60 * 1000, // 2 minutes initial wait
-                10 * 1000);
-                if (lcaResult && lcaResult.status === "done") {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Successfully created LCA steps for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
-                            },
-                            {
-                                type: "text",
-                                text: `LCA build completed! Resource URL: ${lcaResult.resource_path}`,
-                            },
-                        ],
-                    };
-                }
-                else {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
-                            },
-                            {
-                                type: "text",
-                                text: `Warning: LCA build did not complete within ${max_wait_minutes} minutes. You can check the status later in the BrowserStack Test Management UI.`,
-                            },
-                        ],
-                    };
-                }
-            }
-            catch (pollError) {
-                console.error("Error during LCA polling:", pollError);
+            else {
                 return {
                     content: [
                         {
@@ -135,14 +120,26 @@ export async function createLCASteps(args, context) {
                         },
                         {
                             type: "text",
-                            text: "Warning: Error occurred while polling for LCA build completion. Check the BrowserStack Test Management UI for status.",
+                            text: `Warning: LCA build did not complete within ${max_wait_minutes} minutes. You can check the status later in the BrowserStack Test Management UI.`,
                         },
                     ],
                 };
             }
         }
-        else {
-            throw new Error(`Unexpected response: ${JSON.stringify(response.data)}`);
+        catch (pollError) {
+            console.error("Error during LCA polling:", pollError);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `LCA steps creation initiated for test case ${args.test_case_identifier} (ID: ${testCaseId})`,
+                    },
+                    {
+                        type: "text",
+                        text: "Warning: Error occurred while polling for LCA build completion. Check the BrowserStack Test Management UI for status.",
+                    },
+                ],
+            };
         }
     }
     catch (error) {
@@ -161,6 +158,18 @@ export async function createLCASteps(args, context) {
                 };
             }
         }
-        return formatAxiosError(error, "Failed to create LCA steps");
+        const msg = error?.response?.data?.message ||
+            error?.response?.data?.error ||
+            error?.message ||
+            String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Failed to create LCA steps: ${msg}`,
+                },
+            ],
+            isError: true,
+        };
     }
 }

package/dist/tools/testmanagement-utils/create-project-folder.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+export declare const CreateProjFoldSchema: z.ZodObject<{
+    project_name: z.ZodOptional<z.ZodString>;
+    project_description: z.ZodOptional<z.ZodString>;
+    project_identifier: z.ZodOptional<z.ZodString>;
+    folder_name: z.ZodOptional<z.ZodString>;
+    folder_description: z.ZodOptional<z.ZodString>;
+    parent_id: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    project_name?: string | undefined;
+    project_description?: string | undefined;
+    project_identifier?: string | undefined;
+    folder_name?: string | undefined;
+    folder_description?: string | undefined;
+    parent_id?: number | undefined;
+}, {
+    project_name?: string | undefined;
+    project_description?: string | undefined;
+    project_identifier?: string | undefined;
+    folder_name?: string | undefined;
+    folder_description?: string | undefined;
+    parent_id?: number | undefined;
+}>;
+type CreateProjFoldArgs = z.infer<typeof CreateProjFoldSchema>;
+/**
+ * Creates a project and/or folder in BrowserStack Test Management.
+ */
+export declare function createProjectOrFolder(args: CreateProjFoldArgs, config: BrowserStackConfig): Promise<CallToolResult>;
+export {};

package/dist/tools/testmanagement-utils/create-project-folder.js

@@ -1,8 +1,8 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
-import { formatAxiosError } from "../../lib/error.js"; // or correct path
+import { formatAxiosError } from "../../lib/error.js";
 import { projectIdentifierToId } from "../testmanagement-utils/TCG-utils/api.js";
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
 // Schema for combined project/folder creation
 export const CreateProjFoldSchema = z.object({
     project_name: z
@@ -30,21 +30,29 @@ export const CreateProjFoldSchema = z.object({
 /**
  * Creates a project and/or folder in BrowserStack Test Management.
  */
-export async function createProjectOrFolder(args) {
+export async function createProjectOrFolder(args, config) {
     const { project_name, project_description, project_identifier, folder_name, folder_description, parent_id, } = CreateProjFoldSchema.parse(args);
     if (!project_name && !project_identifier && !folder_name) {
         throw new Error("Provide project_name (to create project), or project_identifier and folder_name (to create folder).");
     }
+    const authString = getBrowserStackAuth(config);
+    const [username, password] = authString.split(":");
     let projId = project_identifier;
     // Step 1: Create project if project_name provided
     if (project_name) {
         try {
-            const res = await axios.post("https://test-management.browserstack.com/api/v2/projects", { project: { name: project_name, description: project_description } }, {
-                auth: {
-                    username: config.browserstackUsername,
-                    password: config.browserstackAccessKey,
+            const authString = getBrowserStackAuth(config);
+            const [username, password] = authString.split(":");
+            const res = await apiClient.post({
+                url: "https://test-management.browserstack.com/api/v2/projects",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Basic " +
+                        Buffer.from(`${username}:${password}`).toString("base64"),
+                },
+                body: {
+                    project: { name: project_name, description: project_description },
                 },
-                headers: { "Content-Type": "application/json" },
             });
             if (!res.data.success) {
                 throw new Error(`Failed to create project: ${JSON.stringify(res.data)}`);
@@ -53,7 +61,7 @@ export async function createProjectOrFolder(args) {
             projId = res.data.project.identifier;
         }
         catch (err) {
-            return formatAxiosError(err, "Failed to create project..");
+            return formatAxiosError(err, "Failed to create project.");
         }
     }
     // Step 2: Create folder if folder_name provided
@@ -61,25 +69,27 @@ export async function createProjectOrFolder(args) {
         if (!projId)
             throw new Error("Cannot create folder without project_identifier.");
         try {
-            const res = await axios.post(`https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(projId)}/folders`, {
-                folder: {
-                    name: folder_name,
-                    description: folder_description,
-                    parent_id,
+            const res = await apiClient.post({
+                url: `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(projId)}/folders`,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Basic " +
+                        Buffer.from(`${username}:${password}`).toString("base64"),
                 },
-            }, {
-                auth: {
-                    username: config.browserstackUsername,
-                    password: config.browserstackAccessKey,
+                body: {
+                    folder: {
+                        name: folder_name,
+                        description: folder_description,
+                        parent_id,
+                    },
                 },
-                headers: { "Content-Type": "application/json" },
             });
             if (!res.data.success) {
                 throw new Error(`Failed to create folder: ${JSON.stringify(res.data)}`);
             }
             // Folder created successfully
             const folder = res.data.folder;
-            const projectId = await projectIdentifierToId(projId);
+            const projectId = await projectIdentifierToId(projId, config);
             return {
                 content: [
                     {

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

@@ -0,0 +1,122 @@
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { BrowserStackConfig } from "../../lib/types.js";
+interface TestCaseStep {
+    step: string;
+    result: string;
+}
+interface IssueTracker {
+    name: string;
+    host: string;
+}
+export interface TestCaseCreateRequest {
+    project_identifier: string;
+    folder_id: string;
+    name: string;
+    description?: string;
+    owner?: string;
+    preconditions?: string;
+    test_case_steps: TestCaseStep[];
+    issues?: string[];
+    issue_tracker?: IssueTracker;
+    tags?: string[];
+    custom_fields?: Record<string, string>;
+}
+export interface TestCaseResponse {
+    data: {
+        success: boolean;
+        test_case: {
+            case_type: string;
+            priority: string;
+            status: string;
+            folder_id: number;
+            issues: Array<{
+                jira_id: string;
+                issue_type: string;
+            }>;
+            tags: string[];
+            template: string;
+            description: string;
+            preconditions: string;
+            title: string;
+            identifier: string;
+            automation_status: string;
+            owner: string;
+            steps: TestCaseStep[];
+            custom_fields: Array<{
+                name: string;
+                value: string;
+            }>;
+        };
+    };
+}
+export declare const CreateTestCaseSchema: z.ZodObject<{
+    project_identifier: z.ZodString;
+    folder_id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    preconditions: z.ZodOptional<z.ZodString>;
+    test_case_steps: z.ZodArray<z.ZodObject<{
+        step: z.ZodString;
+        result: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        step: string;
+        result: string;
+    }, {
+        step: string;
+        result: string;
+    }>, "many">;
+    issues: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    issue_tracker: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        host: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        host: string;
+    }, {
+        name: string;
+        host: string;
+    }>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    custom_fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    test_case_steps: {
+        step: string;
+        result: string;
+    }[];
+    project_identifier: string;
+    folder_id: string;
+    issues?: string[] | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    custom_fields?: Record<string, string> | undefined;
+    preconditions?: string | undefined;
+    owner?: string | undefined;
+    issue_tracker?: {
+        name: string;
+        host: string;
+    } | undefined;
+}, {
+    name: string;
+    test_case_steps: {
+        step: string;
+        result: string;
+    }[];
+    project_identifier: string;
+    folder_id: string;
+    issues?: string[] | undefined;
+    description?: string | undefined;
+    tags?: string[] | undefined;
+    custom_fields?: Record<string, string> | undefined;
+    preconditions?: string | undefined;
+    owner?: string | undefined;
+    issue_tracker?: {
+        name: string;
+        host: string;
+    } | undefined;
+}>;
+export declare function sanitizeArgs(args: any): any;
+export declare function createTestCase(params: TestCaseCreateRequest, config: BrowserStackConfig): Promise<CallToolResult>;
+export {};

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

@@ -1,7 +1,6 @@
-import axios from "axios";
-import config from "../../config.js";
+import { apiClient } from "../../lib/apiClient.js";
 import { z } from "zod";
-import { formatAxiosError } from "../../lib/error.js"; // or correct
+import { formatAxiosError } from "../../lib/error.js";
 import { projectIdentifierToId } from "./TCG-utils/api.js";
 export const CreateTestCaseSchema = z.object({
     project_identifier: z
@@ -67,15 +66,19 @@ export function sanitizeArgs(args) {
     }
     return cleaned;
 }
-export async function createTestCase(params) {
+import { getBrowserStackAuth } from "../../lib/get-auth.js";
+export async function createTestCase(params, config) {
     const body = { test_case: params };
+    const authString = getBrowserStackAuth(config);
+    const [username, password] = authString.split(":");
     try {
-        const response = await axios.post(`https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(params.project_identifier)}/folders/${encodeURIComponent(params.folder_id)}/test-cases`, body, {
-            auth: {
-                username: config.browserstackUsername,
-                password: config.browserstackAccessKey,
+        const response = await apiClient.post({
+            url: `https://test-management.browserstack.com/api/v2/projects/${encodeURIComponent(params.project_identifier)}/folders/${encodeURIComponent(params.folder_id)}/test-cases`,
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: "Basic " + Buffer.from(`${username}:${password}`).toString("base64"),
             },
-            headers: { "Content-Type": "application/json" },
+            body,
         });
         const { data } = response.data;
         if (!data.success) {
@@ -91,7 +94,7 @@ export async function createTestCase(params) {
             };
         }
         const tc = data.test_case;
-        const projectId = await projectIdentifierToId(params.project_identifier);
+        const projectId = await projectIdentifierToId(params.project_identifier, config);
         return {
             content: [
                 {