feat: Add RCA tools for fetching and formatting Root Cause Analysis data

Author: tech-sushant

src/server-factory.ts

@@ -17,6 +17,7 @@ import addSelfHealTools from "./tools/selfheal.js";
 import addAppLiveTools from "./tools/applive.js";
 import { setupOnInitialized } from "./oninitialized.js";
 import { BrowserStackConfig } from "./lib/types.js";
+import addRCATools from "./tools/rca-agent.js";
 
 /**
  * Wrapper class for BrowserStack MCP Server
@@ -55,6 +56,7 @@ export class BrowserStackMcpServer {
       addFailureLogsTools,
       addAutomateTools,
       addSelfHealTools,
+      addRCATools,
     ];
 
     toolAdders.forEach((adder) => {

src/tools/rca-agent-utils/format-rca.ts

@@ -0,0 +1,35 @@
+// Utility function to format RCA data for better readability
+export function formatRCAData(rcaData: any): string {
+  if (!rcaData || !rcaData.testCases || rcaData.testCases.length === 0) {
+    return "No RCA data available.";
+  }
+
+  let output = "## Root Cause Analysis Report\n\n";
+  
+  rcaData.testCases.forEach((testCase: any, index: number) => {
+    // Show test case name first with smaller heading
+    output += `### ${testCase.displayName || `Test Case ${index + 1}`}\n`;
+    output += `**Test ID:** ${testCase.id}\n`;
+    output += `**Status:** ${testCase.state}\n\n`;
+
+    if (testCase.rcaData?.originalResponse?.rcaData) {
+      const rca = testCase.rcaData.originalResponse.rcaData;
+      
+      if (rca.root_cause) {
+        output += `**Root Cause:** ${rca.root_cause}\n\n`;
+      }
+      
+      if (rca.description) {
+        output += `**Description:**\n${rca.description}\n\n`;
+      }
+      
+      if (rca.possible_fix) {
+        output += `**Recommended Fix:**\n${rca.possible_fix}\n\n`;
+      }
+    }
+    
+    output += "---\n\n";
+  });
+
+  return output;
+}

src/tools/rca-agent-utils/get-build-id.ts

@@ -0,0 +1,32 @@
+export async function getBuildId(
+  projectName: string,
+  buildName: string,
+  username: string,
+  accessKey: string,
+): Promise<string> {
+  const url = new URL(
+    "https://api-automation.browserstack.com/ext/v1/builds/latest",
+  );
+  url.searchParams.append("project_name", projectName);
+  url.searchParams.append("build_name", buildName);
+  url.searchParams.append("user_name", username);
+
+  const authHeader =
+    "Basic " + Buffer.from(`${username}:${accessKey}`).toString("base64");
+
+  const response = await fetch(url.toString(), {
+    headers: {
+      Authorization: authHeader,
+      "Content-Type": "application/json",
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch build ID: ${response.status} ${response.statusText}`,
+    );
+  }
+
+  const data = await response.json();
+  return data.build_id;
+}

src/tools/rca-agent-utils/get-failed-test-id.ts

@@ -0,0 +1,104 @@
+interface TestDetails {
+  status: string;
+  details: any;
+  children?: TestDetails[];
+  display_name?: string;
+}
+
+interface TestRun {
+  hierarchy: TestDetails[];
+  pagination?: {
+    has_next: boolean;
+    next_page: string | null;
+  };
+}
+
+export interface FailedTestInfo {
+  id: string;
+  displayName: string;
+}
+
+export async function getFailedTestIds(
+  buildId: string,
+  authString: string,
+): Promise<FailedTestInfo[]> {
+  const baseUrl = `https://api-automation.browserstack.com/ext/v1/builds/${buildId}/testRuns?test_statuses=failed`;
+  let nextUrl = baseUrl;
+  let allFailedTests: FailedTestInfo[] = [];
+  let requestNumber = 0;
+
+  // Construct Basic auth header
+  const encodedCredentials = Buffer.from(authString).toString("base64");
+  const authHeader = `Basic ${encodedCredentials}`;
+
+  try {
+    while (true) {
+      requestNumber++;
+
+      const response = await fetch(nextUrl, {
+        headers: {
+          Authorization: authHeader,
+          "Content-Type": "application/json",
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch test runs: ${response.status} ${response.statusText}`,
+        );
+      }
+
+      const data = (await response.json()) as TestRun;
+
+      // Extract failed IDs from current page
+      if (data.hierarchy && data.hierarchy.length > 0) {
+        const currentFailedTests = extractFailedTestIds(data.hierarchy);
+        allFailedTests = allFailedTests.concat(currentFailedTests);
+      }
+
+      // Check for pagination termination conditions
+      if (!data.pagination?.has_next || !data.pagination.next_page) {
+        break;
+      }
+
+      // Safety limit to prevent runaway requests
+      if (requestNumber >= 5) {
+        break;
+      }
+
+      // Prepare next request
+      nextUrl = `${baseUrl}?next_page=${encodeURIComponent(data.pagination.next_page)}`;
+    }
+
+    // Return unique failed test IDs
+    return allFailedTests;
+  } catch (error) {
+    console.error("Error fetching failed tests:", error);
+    throw error;
+  }
+}
+
+// Recursive function to extract failed test IDs from hierarchy
+function extractFailedTestIds(hierarchy: TestDetails[]): FailedTestInfo[] {
+  let failedTests: FailedTestInfo[] = [];
+
+  for (const node of hierarchy) {
+    if (node.details?.status === "failed" && node.details?.run_count) {
+      if (node.details?.observability_url) {
+        const idMatch = node.details.observability_url.match(/details=(\d+)/);
+        if (idMatch) {
+          failedTests.push({
+            id: idMatch[1],
+            displayName: node.display_name || `Test ${idMatch[1]}`
+          });
+        }
+      }
+    }
+
+    if (node.children && node.children.length > 0) {
+      failedTests = failedTests.concat(extractFailedTestIds(node.children));
+    }
+  }
+
+  return failedTests;
+}