feat: add automate self-heal tools integration

Author: tech-sushant

src/index.ts

@@ -15,6 +15,7 @@ import addTestManagementTools from "./tools/testmanagement.js";
 import addAppAutomationTools from "./tools/appautomate.js";
 import addFailureLogsTools from "./tools/getFailureLogs.js";
 import addAutomateTools from "./tools/automate.js";
+import addSelfHealTools from "./tools/selfheal.js";
 import { setupOnInitialized } from "./oninitialized.js";
 
 function registerTools(server: McpServer) {
@@ -26,6 +27,7 @@ function registerTools(server: McpServer) {
   addAppAutomationTools(server);
   addFailureLogsTools(server);
   addAutomateTools(server);
+  addSelfHealTools(server);
 }
 
 // Create an MCP server

src/tools/selfheal-utils/selfheal.ts

@@ -0,0 +1,61 @@
+import { assertOkResponse } from "../../lib/utils.js";
+import config from "../../config.js";
+
+interface SelectorMapping {
+  originalSelector: string;
+  healedSelector: string;
+}
+
+export async function getSelfHealSelectors(sessionId: string) {
+  const credentials = `${config.browserstackUsername}:${config.browserstackAccessKey}`;
+  const auth = Buffer.from(credentials).toString("base64");
+  const url = `https://api.browserstack.com/automate/sessions/${sessionId}/logs`;
+
+  const response = await fetch(url, {
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Basic ${auth}`,
+    },
+  });
+
+  await assertOkResponse(response, "session logs");
+  const logText = await response.text();
+  return extractHealedSelectors(logText);
+}
+
+function extractHealedSelectors(logText: string): SelectorMapping[] {
+  // Pattern to match SELFHEAL entries with healed selectors
+  const selfhealPattern =
+    /SELFHEAL\s*{\s*"status":"true",\s*"data":\s*{\s*"using":"css selector",\s*"value":"(.*?)"}/g;
+
+  // Pattern to match preceding selector requests
+  const requestPattern =
+    /POST \/session\/[^/]+\/element.*?"using":"css selector","value":"(.*?)"/g;
+
+  // Find all healed selectors
+  const healedSelectors: string[] = [];
+  let healedMatch;
+  while ((healedMatch = selfhealPattern.exec(logText)) !== null) {
+    healedSelectors.push(healedMatch[1]);
+  }
+
+  // Find all selector requests
+  const selectorRequests: string[] = [];
+  let requestMatch;
+  while ((requestMatch = requestPattern.exec(logText)) !== null) {
+    selectorRequests.push(requestMatch[1]);
+  }
+
+  // Pair each healed selector with its corresponding original selector
+  const healedMappings: SelectorMapping[] = [];
+  const minLength = Math.min(selectorRequests.length, healedSelectors.length);
+
+  for (let i = 0; i < minLength; i++) {
+    healedMappings.push({
+      originalSelector: selectorRequests[i],
+      healedSelector: healedSelectors[i],
+    });
+  }
+
+  return healedMappings;
+}

src/tools/selfheal.ts

@@ -0,0 +1,54 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { getSelfHealSelectors } from "./selfheal-utils/selfheal.js";
+import logger from "../logger.js";
+
+// Tool function that fetches self-healing selectors
+export async function fetchSelfHealSelectorTool(args: {
+  sessionId: string;
+}): Promise<CallToolResult> {
+  try {
+    const selectors = await getSelfHealSelectors(args.sessionId);
+    return {
+      content: [
+        {
+          type: "text",
+          text:
+            "Self-heal selectors fetched successfully" +
+            JSON.stringify(selectors),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error("Error fetching self-heal selector suggestions", error);
+    throw error;
+  }
+}
+
+// Registers the fetchSelfHealSelector tool with the MCP server
+export default function addSelfHealTools(server: McpServer) {
+  server.tool(
+    "fetchSelfHealSelector",
+    "Fetch self-healing selector suggestions for a broken selector",
+    {
+      sessionId: z.string().describe("The session ID of the test run"),
+    },
+    async (args) => {
+      try {
+        return await fetchSelfHealSelectorTool(args);
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error during fetching self-heal suggestions: ${errorMessage}`,
+            },
+          ],
+        };
+      }
+    },
+  );
+}