@mablhq/mabl-cli 2.70.1 → 2.70.4

package/commands/mcp/mcp_cmds/start.js

@@ -11,6 +11,7 @@ const loggingProvider_1 = require("../../../providers/logging/loggingProvider");
 const tools_1 = __importDefault(require("./tools"));
 const constants_1 = require("../../constants");
 const createMablTestForCurrentWork_1 = require("./prompts/createMablTestForCurrentWork");
+const common_1 = require("./tools/common");
 exports.command = 'start [options]';
 exports.describe = 'Start the MCP server';
 exports.builder = (yargs) => {
@@ -40,10 +41,8 @@ async function startServer(parsed) {
         },
     });
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, () => ({
-        tools: tools_1.default.map((tool) => ({
-            name: tool.schema.name,
-            description: tool.schema.description,
-            inputSchema: tool.schema.inputSchema.safeParse({}).success
+        tools: tools_1.default.map((tool) => {
+            const inputSchema = tool.schema.inputSchema.safeParse({}).success
                 ? { type: 'object', properties: {} }
                 : {
                     type: 'object',
@@ -57,8 +56,16 @@ async function startServer(parsed) {
                             },
                         ];
                     })),
-                },
-        })),
+                };
+            return {
+                name: tool.schema.name,
+                description: tool.schema.description,
+                inputSchema,
+                ...(tool.schema.outputSchema
+                    ? { outputSchema: (0, common_1.zodSchemaToOpenApiSchema)(tool.schema.outputSchema) }
+                    : {}),
+            };
+        }),
     }));
     server.setRequestHandler(types_js_1.ListPromptsRequestSchema, () => ({
         prompts: [createMablTestForCurrentWork_1.createMablTestPrompt],

package/commands/mcp/mcp_cmds/tools/analyzeFailure.js

@@ -16,6 +16,17 @@ const analyzeFailure = (0, mcpMablTool_1.defineTool)({
     },
     handle: async (params, apiKey, server) => {
         const runId = params.runId;
+        if (runId.endsWith('-j')) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `The runId ${runId} appears to be a test id. Please call the getResults tool with this id first, then call analyze-failure again with the resulting first runId with status "Failed".`,
+                        isError: false,
+                    },
+                ],
+            };
+        }
         const mablApiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClientFromOptionalApiKey(apiKey);
         const workspaceId = (await mablApiClient.getApiKeyDetails()).workspace_id;
         if (!workspaceId) {

package/commands/mcp/mcp_cmds/tools/common.js

@@ -1,13 +1,74 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringToToolResult = stringToToolResult;
-function stringToToolResult(value) {
+exports.zodSchemaToOpenApiSchema = zodSchemaToOpenApiSchema;
+const zod_1 = require("zod");
+function stringToToolResult(value, isError = false) {
     return {
         content: [
             {
                 type: 'text',
                 text: value,
+                isError,
             },
         ],
     };
 }
+function zodSchemaToOpenApiSchema(schema) {
+    if (schema instanceof zod_1.z.ZodArray) {
+        const element = schema.element;
+        if (element instanceof zod_1.z.ZodObject) {
+            const itemShape = element.shape;
+            return {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: Object.fromEntries(Object.entries(itemShape).map(([key, value]) => {
+                        const description = value._def.description;
+                        return [
+                            key,
+                            {
+                                type: (() => {
+                                    if (value instanceof zod_1.z.ZodString) {
+                                        return 'string';
+                                    }
+                                    if (value instanceof zod_1.z.ZodNumber) {
+                                        return 'number';
+                                    }
+                                    if (value instanceof zod_1.z.ZodBoolean) {
+                                        return 'boolean';
+                                    }
+                                    if (value instanceof zod_1.z.ZodArray) {
+                                        return 'array';
+                                    }
+                                    if (value instanceof zod_1.z.ZodObject) {
+                                        return 'object';
+                                    }
+                                    return 'string';
+                                })(),
+                                description: description || '',
+                            },
+                        ];
+                    })),
+                },
+            };
+        }
+    }
+    else if (schema instanceof zod_1.z.ZodObject) {
+        const shape = schema.shape;
+        return {
+            type: 'object',
+            properties: Object.fromEntries(Object.entries(shape).map(([key, value]) => {
+                const description = value._def.description;
+                return [
+                    key,
+                    {
+                        type: 'string',
+                        description: description || '',
+                    },
+                ];
+            })),
+        };
+    }
+    return undefined;
+}

package/commands/mcp/mcp_cmds/tools/exportToPlaywright.js

@@ -15,15 +15,15 @@ exports.environmentRequiredToolResult = (0, common_1.stringToToolResult)(`
     Tell the user that the environmentId is required to export the test to Playwright with good locators.
     Call the get-environments tool to get the list of environments for the test.
     Ask them to select the environmentId from the list of environments and then call this tool again with the environmentId.
-  `);
+  `, true);
 exports.performanceTestToolResult = (0, common_1.stringToToolResult)(`
     ## Instructions
     Tell the user that the test provided is a performance test and it can't be exported to playwright.
-  `);
+  `, true);
 exports.defaultTestToolResult = (0, common_1.stringToToolResult)(`
     ## Instructions
     Tell the user that default tests can not be exported to playwright.
-  `);
+  `, true);
 const exportToPlaywrightSchema = zod_1.z.object({
     testId: zod_1.z
         .string()

package/commands/mcp/mcp_cmds/tools/getResults.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const mcpMablTool_1 = require("./mcpMablTool");
 const zod_1 = require("zod");
 const mablApiClientFactory_1 = require("../../../../api/mablApiClientFactory");
+const mablApi_1 = require("../../../../mablApi");
+const common_1 = require("./common");
 const getResults = (0, mcpMablTool_1.defineTool)({
     schema: {
         name: 'get-results',
@@ -14,28 +16,71 @@ const getResults = (0, mcpMablTool_1.defineTool)({
                 .describe('The id of the mabl test to get recent results of'),
         }),
         type: 'readOnly',
+        outputSchema: zod_1.z.array(zod_1.z.object({
+            testRunId: zod_1.z.string().nullable(),
+            environmentId: zod_1.z.string().nullable(),
+            status: zod_1.z.string().nullable(),
+            completedTimeMs: zod_1.z.number().nullable(),
+            errorMessage: zod_1.z.string(),
+        })),
     },
     handle: async (params, apiKey) => {
         const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClientFromOptionalApiKey(apiKey);
         const testId = params.testId;
         const testRunResults = (await apiClient.getRecentTestRunsForTest(testId))
             .test_script_executions || [];
+        const workspaceIdMaybe = (await apiClient.getApiKeyDetails()).workspace_id;
+        if (!workspaceIdMaybe) {
+            return (0, common_1.stringToToolResult)('Workspace ID not found', true);
+        }
+        const workspaceId = workspaceIdMaybe;
+        const processedResults = await Promise.all(testRunResults.map(async (testRun) => {
+            let errorMessage = '';
+            if (testRun.status === mablApi_1.TestRun.StatusEnum.Failed &&
+                testRun.failure_categorization?.is_failure_category_generated !== true) {
+                try {
+                    const analysis = await apiClient.analyzeTestRun(workspaceId, {
+                        test_run_id: testRun.id,
+                    });
+                    testRun.failure_categorization = {
+                        ...testRun.failure_categorization,
+                        ...analysis,
+                    };
+                }
+                catch (e) {
+                    console.error('Error analyzing test run:', e);
+                    errorMessage = `Analysis error: ${e instanceof Error ? e.message : String(e)}`;
+                }
+            }
+            if (testRun.failure_categorization) {
+                errorMessage =
+                    testRun.failure_categorization.failure_summary_text ??
+                        testRun.failure_summary?.error ??
+                        '';
+            }
+            if (!errorMessage) {
+                errorMessage = 'No categorized error available.';
+            }
+            const id = testRun.id;
+            const completedTimeMs = testRun.completed_time;
+            const status = testRun.status;
+            const envId = testRun.journey_parameters?.deployment?.environment_id;
+            return {
+                testRunId: id,
+                environmentId: envId,
+                status,
+                completedTimeMs,
+                errorMessage,
+            };
+        }));
         return {
             content: [
                 {
                     type: 'text',
-                    text: testRunResults
-                        .map((testRun) => {
-                        const id = testRun.id;
-                        const completedTimeMs = testRun.completed_time;
-                        const status = testRun.status;
-                        const envId = testRun.journey_parameters?.deployment?.environment_id;
-                        const errorMessage = testRun.failure_summary?.error;
-                        return `TestRunId: ${id} EnvironmentId: ${envId} Status: ${status} CompletedTimeMs: ${completedTimeMs} ErrorMessage: ${errorMessage}`;
-                    })
-                        .join('\n'),
+                    text: JSON.stringify(processedResults),
                 },
             ],
+            structuredContent: processedResults,
         };
     },
 });

package/core/execution/ApiTestUtils.js

@@ -1498,6 +1498,8 @@ function postmanAuthToApiTestAuth(auth) {
                 verifier: getValueFromVariablesForAuthType('verifier'),
             };
             break;
+        default:
+            return undefined;
     }
     return apiTestAuth;
 }