@alternative-path/qa-path-mcp 1.0.0

package/dist/tools/testgroup-launch-tools.js

@@ -0,0 +1,727 @@
+import { jsonResponse } from "../utils/mcp-response.js";
+/**
+ * MCP tools for test groups and test launches.
+ * - list_testgroups: list test groups in a project (with pagination support)
+ * - get_testgroup: get a specific test group by ID
+ * - create_testgroup: create a new test group
+ * - update_tests_in_testgroup: add or remove test cases from an existing test group
+ * - create_test_launch: create a new test launch in an existing test group
+ * - update_test_launch: update details of an existing test launch (status: completed | aborted)
+ */
+export class TestGroupLaunchTools {
+    apiClient;
+    projectContext;
+    constructor(apiClient, projectContext) {
+        this.apiClient = apiClient;
+        this.projectContext = projectContext;
+    }
+    getTools() {
+        return [
+            {
+                name: "list_testgroups",
+                description: "List test groups in a project with filtering and sorting. Returns test groups with their details including name, description, and associated test case counts. Supports text-based queries in canonical format for efficient filtering (e.g., \"name contains 'API' AND createdByUser = 'user-id'\"). IMPORTANT: Always call get_query_schema with entity='testgroup' first to understand available fields, operators, and valid values. Use field names (not labels) in queries, and use IDs for association fields like createdByUser.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Text query in canonical format for filtering test groups (e.g., \"name = 'API Test Group'\", \"name contains 'API'\", \"createdByUser = 'user-id' AND created_at > '2024-01-01'\"). IMPORTANT: Always call get_query_schema with entity='testgroup' first to understand available fields, operators, and valid values. Use field names (not labels) in queries. Use IDs for association fields like createdByUser. Leave empty or omit only if you need ALL test groups. For finding a specific test group, use a query filter instead of fetching all test groups. Max length: 5000 characters.",
+                            maxLength: 5000,
+                        },
+                        sortField: {
+                            type: "string",
+                            description: "Optional field to sort by. Allowed values: 'name', 'description', 'key', 'group_type', 'created_at', 'updated_at', 'next_scheduled_run', 'createdByUser'.",
+                            enum: ["name", "description", "key", "group_type", "created_at", "updated_at", "next_scheduled_run", "createdByUser"],
+                        },
+                        sortOrder: {
+                            type: "string",
+                            description: "Optional sort order: 'ASC' or 'DESC'. Defaults to 'DESC'.",
+                            enum: ["ASC", "DESC"],
+                        },
+                        page: {
+                            type: "number",
+                            description: "Page number (required, minimum: 1).",
+                            minimum: 1,
+                        },
+                        pageSize: {
+                            type: "number",
+                            description: "Number of results per page (required, minimum: 1, maximum: 10000).",
+                            minimum: 1,
+                            maximum: 10000,
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["page", "pageSize"],
+                },
+            },
+            {
+                name: "get_testgroup",
+                description: "Get detailed information about a specific test group by ID. Returns the test group with all its details including associated test cases.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testGroupId: {
+                            type: "string",
+                            description: "UUID of the test group to retrieve (required).",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["testGroupId"],
+                },
+            },
+            {
+                name: "create_testgroup",
+                description: "Create a new test group in a project. Test groups are used to organize test cases for execution (test launches).",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        name: {
+                            type: "string",
+                            description: "Name of the test group (required).",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Optional description of the test group.",
+                        },
+                        // next_scheduled_run: {
+                        //   type: "string",
+                        //   description:
+                        //     "Optional ISO 8601 datetime for next scheduled run (e.g. 2025-02-01T10:00:00.000Z).",
+                        // },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["name"],
+                },
+            },
+            {
+                name: "update_tests_in_testgroup",
+                description: "Add and/or remove test cases from an existing test group. Provide addTestCaseIds to add test cases, removeTestCaseIds to remove them. At least one of addTestCaseIds or removeTestCaseIds must be provided.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testGroupId: {
+                            type: "string",
+                            description: "UUID of the test group to update.",
+                        },
+                        addTestCaseIds: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional array of test case UUIDs to add to the test group.",
+                        },
+                        removeTestCaseIds: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Optional array of test case UUIDs to remove from the test group.",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["testGroupId"],
+                },
+            },
+            {
+                name: "list_environments",
+                description: "List environments for the project. Use this to get environment IDs for create_test_launch when the user has not specified environment by name. Required for create_test_launch flow.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'.",
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: "list_llm_models",
+                description: "List LLM (automation) models available for test launches. Use this to get llmModelId for create_test_launch when the user has not specified model by name. Required for create_test_launch flow.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project. Backend uses org context.",
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: "create_test_launch",
+                description: "Create a new test launch in an existing test group. A test launch runs the test cases associated with the group. Requires environmentId and llmModelId (UUIDs). If the user provided environment or LLM by name, call list_environments and list_llm_models first, map the user's choice to the id from the response, then call this tool with those ids.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testGroupId: {
+                            type: "string",
+                            description: "UUID of the test group to launch.",
+                        },
+                        name: {
+                            type: "string",
+                            description: "Optional name for the launch (max 100 characters). If not provided, a default may be used.",
+                        },
+                        environmentId: {
+                            type: "string",
+                            description: "Environment UUID for the launch (required). Get ids from list_environments. If the user gave an environment name, call list_environments and map the name to the id, then pass it here.",
+                        },
+                        llmModelId: {
+                            type: "string",
+                            description: "LLM model UUID for the launch (required). Get ids from list_llm_models. If the user gave a model name, call list_llm_models and map the name to the id, then pass it here.",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["testGroupId"],
+                },
+            },
+            {
+                name: "list_test_launches",
+                description: "List test launches for a specific test group. Supports searching by name/key and filtering by status. Use this to find a launch by name (e.g., 'Regression launch') before updating its status.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        testGroupId: {
+                            type: "string",
+                            description: "UUID of the test group to list launches for (required).",
+                        },
+                        search: {
+                            type: "string",
+                            description: "Optional search term to filter launches by name or key (case-insensitive). Use this to find launches by name, e.g., search for 'Regression launch' to find 'Regression launch'.",
+                            maxLength: 255,
+                        },
+                        status: {
+                            type: "string",
+                            enum: ["all", "new", "in_progress", "completed", "aborted", "paused"],
+                            description: "Optional status filter. Allowed values: 'all', 'new', 'in_progress', 'completed', 'aborted', 'paused'. Defaults to 'all'.",
+                        },
+                        page: {
+                            type: "number",
+                            description: "Page number (default: 1, minimum: 1).",
+                            minimum: 1,
+                            default: 1,
+                        },
+                        pageSize: {
+                            type: "number",
+                            description: "Number of results per page (default: 25, minimum: 1, maximum: 100).",
+                            minimum: 1,
+                            maximum: 100,
+                            default: 25,
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["testGroupId"],
+                },
+            },
+            {
+                name: "get_test_launch",
+                description: "Get detailed information about a specific test launch by ID. Returns launch details including status, execution statistics, and associated test group information.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        launchId: {
+                            type: "string",
+                            description: "UUID of the test launch to retrieve (required).",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["launchId"],
+                },
+            },
+            {
+                name: "update_test_launch",
+                description: "Update an existing test launch. Currently supports updating status to 'completed' or 'aborted' (e.g. to mark a launch as completed or abort a running launch). Use list_test_launches to find the launchId if you only know the launch name.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        launchId: {
+                            type: "string",
+                            description: "UUID of the test launch to update. Use list_test_launches to find the launchId if you only know the launch name.",
+                        },
+                        status: {
+                            type: "string",
+                            enum: ["completed", "aborted"],
+                            description: "New status for the launch: 'completed' or 'aborted'.",
+                        },
+                        projectId: {
+                            type: "string",
+                            description: "Optional project ID (UUID). If not provided, uses the active project set via 'set_active_project'. " +
+                                "If no active project is set, the tool will return an error with instructions on how to set one.",
+                        },
+                    },
+                    required: ["launchId", "status"],
+                },
+            },
+        ];
+    }
+    handles(name) {
+        return [
+            "list_testgroups",
+            "get_testgroup",
+            "create_testgroup",
+            "update_tests_in_testgroup",
+            "list_environments",
+            "list_llm_models",
+            "create_test_launch",
+            "list_test_launches",
+            "get_test_launch",
+            "update_test_launch",
+        ].includes(name);
+    }
+    async handle(name, args) {
+        switch (name) {
+            case "list_testgroups":
+                return await this.listTestGroups(args);
+            case "get_testgroup":
+                return await this.getTestGroup(args);
+            case "create_testgroup":
+                return await this.createTestGroup(args);
+            case "update_tests_in_testgroup":
+                return await this.updateTestsInTestGroup(args);
+            case "list_environments":
+                return await this.listEnvironments(args);
+            case "list_llm_models":
+                return await this.listLlmModels(args);
+            case "create_test_launch":
+                return await this.createTestLaunch(args);
+            case "list_test_launches":
+                return await this.listTestLaunches(args);
+            case "get_test_launch":
+                return await this.getTestLaunch(args);
+            case "update_test_launch":
+                return await this.updateTestLaunch(args);
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    getProjectId(args, toolName) {
+        return this.projectContext.resolveProjectId(args, toolName);
+    }
+    async listTestGroups(args) {
+        const projectId = this.getProjectId(args, "list_testgroups");
+        const { sortField, sortOrder, query, page, pageSize } = args;
+        // Validate required pagination parameters
+        if (!page || typeof page !== "number" || page < 1) {
+            return jsonResponse({
+                success: false,
+                error_code: "INVALID_PAGE",
+                message: "page (number) is required and must be >= 1.",
+            });
+        }
+        if (!pageSize || typeof pageSize !== "number" || pageSize < 1 || pageSize > 10000) {
+            return jsonResponse({
+                success: false,
+                error_code: "INVALID_PAGE_SIZE",
+                message: "pageSize (number) is required and must be between 1 and 10000.",
+            });
+        }
+        const ALLOWED_SORT_FIELDS = ["name", "description", "key", "group_type", "created_at", "updated_at", "next_scheduled_run", "createdByUser"];
+        if (sortField && !ALLOWED_SORT_FIELDS.includes(sortField)) {
+            return jsonResponse({
+                success: false,
+                error_code: "INVALID_SORT_FIELD",
+                message: `sortField must be one of: ${ALLOWED_SORT_FIELDS.join(", ")}.`,
+            });
+        }
+        if (query && typeof query === "string" && query.length > 5000) {
+            return jsonResponse({
+                success: false,
+                error_code: "INVALID_QUERY",
+                message: "query string must not exceed 5000 characters.",
+            });
+        }
+        const body = {
+            page,
+            pageSize,
+        };
+        if (sortField)
+            body.sortField = sortField;
+        if (sortOrder)
+            body.sortOrder = sortOrder;
+        if (query && query.trim().length > 0)
+            body.query = query.trim();
+        try {
+            const response = await this.apiClient.post(`${projectId}/testgroups/get`, body);
+            if (response.success !== true) {
+                return jsonResponse({
+                    success: false,
+                    error_code: "LIST_FAILED",
+                    message: response.message ?? "Failed to retrieve test groups.",
+                });
+            }
+            const data = response?.data ?? response;
+            return jsonResponse({
+                success: true,
+                message: "Test groups fetched successfully.",
+                data,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                error_code: "LIST_FAILED",
+                message: err?.message ?? "Failed to fetch test groups.",
+            });
+        }
+    }
+    async getTestGroup(args) {
+        const projectId = this.getProjectId(args, "get_testgroup");
+        const { testGroupId } = args;
+        if (!testGroupId || typeof testGroupId !== "string") {
+            return jsonResponse({
+                success: false,
+                message: "testGroupId (string) is required.",
+            });
+        }
+        try {
+            const response = await this.apiClient.get(`${projectId}/testgroups/get/${testGroupId}`);
+            const data = response?.data ?? response;
+            return jsonResponse({
+                success: true,
+                message: "Test group fetched successfully.",
+                data,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                message: err?.message ?? "Failed to fetch test group.",
+            });
+        }
+    }
+    async createTestGroup(args) {
+        const projectId = this.getProjectId(args, "create_testgroup");
+        const { name, description } = args;
+        if (!name || typeof name !== "string") {
+            return jsonResponse({
+                success: false,
+                message: "name (string) is required.",
+            });
+        }
+        try {
+            const body = { name };
+            if (description != null)
+                body.description = description;
+            // if (next_scheduled_run != null) body.next_scheduled_run = next_scheduled_run;
+            const response = await this.apiClient.post(`${projectId}/testgroups/create`, body);
+            const data = response?.data ?? response;
+            return jsonResponse({
+                success: true,
+                message: "Test group created successfully.",
+                data,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                message: err?.message ?? "Failed to create test group.",
+            });
+        }
+    }
+    async updateTestsInTestGroup(args) {
+        const projectId = this.getProjectId(args, "update_tests_in_testgroup");
+        const { testGroupId, addTestCaseIds, removeTestCaseIds } = args;
+        if (!testGroupId) {
+            return jsonResponse({
+                success: false,
+                message: "testGroupId is required.",
+            });
+        }
+        const addIds = Array.isArray(addTestCaseIds) ? addTestCaseIds.filter((id) => id) : [];
+        const removeIds = Array.isArray(removeTestCaseIds) ? removeTestCaseIds.filter((id) => id) : [];
+        if (addIds.length === 0 && removeIds.length === 0) {
+            return jsonResponse({
+                success: false,
+                message: "Provide at least one of addTestCaseIds or removeTestCaseIds (non-empty arrays).",
+            });
+        }
+        const results = {};
+        const errors = [];
+        if (addIds.length > 0) {
+            try {
+                await this.apiClient.post(`${projectId}/testgroups/associate-testcases`, {
+                    testGroupId,
+                    testCaseIds: addIds,
+                });
+                results.added = addIds.length;
+            }
+            catch (err) {
+                errors.push(`Add: ${err?.message ?? String(err)}`);
+            }
+        }
+        if (removeIds.length > 0) {
+            try {
+                await this.apiClient.delete(`${projectId}/testgroups/remove-testcases/${testGroupId}`, { data: { testCaseIds: removeIds } });
+                results.removed = removeIds.length;
+            }
+            catch (err) {
+                errors.push(`Remove: ${err?.message ?? String(err)}`);
+            }
+        }
+        if (errors.length > 0) {
+            results.errors = errors;
+            return jsonResponse({
+                success: errors.length < 2,
+                message: errors.length === 2
+                    ? "Both add and remove failed."
+                    : "One operation failed.",
+                ...results,
+            });
+        }
+        return jsonResponse({
+            success: true,
+            message: "Test group test cases updated successfully.",
+            ...results,
+        });
+    }
+    async listEnvironments(args) {
+        const projectId = this.getProjectId(args, "list_environments");
+        try {
+            const response = await this.apiClient.get(`${projectId}/environment/fetch-environment-list`);
+            const data = response?.data ?? response;
+            const list = Array.isArray(data) ? data : [];
+            return jsonResponse({
+                success: true,
+                message: "Environments fetched successfully.",
+                data: list,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                error_code: "LIST_FAILED",
+                message: err?.message ?? "Failed to fetch environments.",
+            });
+        }
+    }
+    async listLlmModels(args) {
+        this.getProjectId(args, "list_llm_models"); // ensure project context resolved
+        try {
+            const response = await this.apiClient.get("aimodel/fetch-automation-models");
+            const data = response?.data ?? response;
+            const list = Array.isArray(data) ? data : [];
+            return jsonResponse({
+                success: true,
+                message: "LLM models fetched successfully.",
+                data: list,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                error_code: "LIST_FAILED",
+                message: err?.message ?? "Failed to fetch LLM models.",
+            });
+        }
+    }
+    async createTestLaunch(args) {
+        const projectId = this.getProjectId(args, "create_test_launch");
+        const { testGroupId, name, environmentId, llmModelId } = args;
+        if (!testGroupId) {
+            return jsonResponse({
+                success: false,
+                message: "testGroupId is required.",
+            });
+        }
+        const ENVIRONMENT_REQUIRED_RESPONSE = {
+            success: false,
+            error_code: "ENVIRONMENT_REQUIRED",
+            message: "environmentId is required.",
+            ACTION_REQUIRED: [
+                "Call list_environments to fetch the available environments for this project.",
+                "If the user provided an environment by name, map it to the id from the list (e.g. match by name).",
+                "Ask the user to choose one if needed, then retry create_test_launch with environmentId set to the chosen id.",
+            ],
+        };
+        const LLM_MODEL_REQUIRED_RESPONSE = {
+            success: false,
+            error_code: "LLM_MODEL_REQUIRED",
+            message: "llmModelId is required.",
+            ACTION_REQUIRED: [
+                "Call list_llm_models to fetch the available LLM models.",
+                "If the user provided a model by name, map it to the id from the list (e.g. match by name).",
+                "Ask the user to choose one if needed, then retry create_test_launch with llmModelId set to the chosen id.",
+            ],
+        };
+        if (!environmentId) {
+            return jsonResponse(ENVIRONMENT_REQUIRED_RESPONSE);
+        }
+        if (!llmModelId) {
+            return jsonResponse(LLM_MODEL_REQUIRED_RESPONSE);
+        }
+        try {
+            const body = {
+                testgroupId: testGroupId,
+                isSequential: true,
+                config: {
+                    environmentId,
+                    llmModelId,
+                },
+            };
+            if (name != null)
+                body.name = name;
+            const response = await this.apiClient.post(`${projectId}/test-launch/createTestLaunch`, body);
+            const data = response?.data ?? response;
+            return jsonResponse({
+                success: true,
+                message: "Test launch created successfully.",
+                data,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                error_code: "LAUNCH_CREATE_FAILED",
+                message: err?.message ?? "Failed to create test launch.",
+            });
+        }
+    }
+    async listTestLaunches(args) {
+        const projectId = this.getProjectId(args, "list_test_launches");
+        const { testGroupId, search, status, page = 1, pageSize = 25 } = args;
+        if (!testGroupId) {
+            return jsonResponse({
+                success: false,
+                message: "testGroupId is required.",
+            });
+        }
+        // Validate pagination
+        if (typeof page !== "number" || page < 1) {
+            return jsonResponse({
+                success: false,
+                message: "page must be a number >= 1.",
+            });
+        }
+        if (typeof pageSize !== "number" || pageSize < 1 || pageSize > 100) {
+            return jsonResponse({
+                success: false,
+                message: "pageSize must be a number between 1 and 100.",
+            });
+        }
+        // Validate status
+        const allowedStatuses = ["all", "new", "in_progress", "completed", "aborted", "paused"];
+        if (status && !allowedStatuses.includes(status)) {
+            return jsonResponse({
+                success: false,
+                message: `status must be one of: ${allowedStatuses.join(", ")}.`,
+            });
+        }
+        // Validate search length
+        if (search && typeof search === "string" && search.length > 255) {
+            return jsonResponse({
+                success: false,
+                message: "search string must not exceed 255 characters.",
+            });
+        }
+        try {
+            const params = {
+                page,
+                pageSize,
+            };
+            if (search && search.trim().length > 0) {
+                params.search = search.trim();
+            }
+            if (status) {
+                params.status = status;
+            }
+            const response = await this.apiClient.get(`${projectId}/test-launch/${testGroupId}/launches`, { params });
+            const data = response?.data ?? response;
+            return jsonResponse({
+                success: true,
+                message: "Test launches fetched successfully.",
+                data,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                message: err?.message ?? "Failed to fetch test launches.",
+            });
+        }
+    }
+    async getTestLaunch(args) {
+        const projectId = this.getProjectId(args, "get_test_launch");
+        const { launchId } = args;
+        if (!launchId) {
+            return jsonResponse({
+                success: false,
+                message: "launchId is required.",
+            });
+        }
+        try {
+            const response = await this.apiClient.get(`${projectId}/test-launch/getLaunchDetailsSummary/${launchId}`);
+            const data = response?.data ?? response;
+            return jsonResponse({
+                success: true,
+                message: "Test launch fetched successfully.",
+                data,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                message: err?.message ?? "Failed to fetch test launch.",
+            });
+        }
+    }
+    async updateTestLaunch(args) {
+        const projectId = this.getProjectId(args, "update_test_launch");
+        const { launchId, status } = args;
+        if (!launchId) {
+            return jsonResponse({
+                success: false,
+                message: "launchId is required.",
+            });
+        }
+        const allowed = ["completed", "aborted"];
+        const normalizedStatus = typeof status === "string" ? status.toLowerCase() : status;
+        if (!allowed.includes(normalizedStatus)) {
+            return jsonResponse({
+                success: false,
+                message: `status must be one of: ${allowed.join(", ")}.`,
+            });
+        }
+        try {
+            await this.apiClient.patch(`${projectId}/test-launch/status/${launchId}`, { status: normalizedStatus });
+            return jsonResponse({
+                success: true,
+                message: `Test launch status updated to '${normalizedStatus}' successfully.`,
+                launchId,
+                status: normalizedStatus,
+            });
+        }
+        catch (err) {
+            return jsonResponse({
+                success: false,
+                message: err?.message ?? "Failed to update test launch.",
+            });
+        }
+    }
+}
+//# sourceMappingURL=testgroup-launch-tools.js.map