lexxit-automation-framework 2.0.19 → 3.0.0

package/src/types/types.ts

@@ -0,0 +1,159 @@
+// ─── Execution State (for live dashboard) ─────────────────────────────────────
+
+export type ExecutionOverallStatus = 'RUNNING' | 'PASS' | 'FAIL';
+export type StepLiveStatus = 'PENDING' | 'RUNNING' | 'PASS' | 'FAIL' | 'SKIP';
+
+export type ScreenshotMode = 'on_failure' | 'always' | 'never';
+
+export interface LiveStepState {
+  step_name: string;
+  status: StepLiveStatus;
+  expected_result: string | null;
+  comments: string | null;
+  duration: number | null;
+}
+
+export interface LiveScriptState {
+  test_script_uid: string;
+  test_case_name: string;
+  status: ExecutionOverallStatus;
+  video_path: string | null;
+  steps: LiveStepState[];
+}
+
+export interface ExecutionState {
+  execution_id: string;
+  test_set_name: string;
+  status: ExecutionOverallStatus;
+  start_time: string;
+  end_time: string | null;
+  scripts: LiveScriptState[];
+  final_result: TestSetResult | null;
+}
+
+// ─── Step Result ──────────────────────────────────────────────────────────────
+
+export interface StepResult {
+  uid: string | null;
+  obj_uid: string | null;
+  page_uid: string | null;
+  step_name: string;
+  step_script: string;
+  status: 'PASS' | 'FAIL' | 'SKIP';
+  expected_result: string;
+  comments: string;
+  duration: number;           // milliseconds
+  start_time: string;         // ISO string e.g. 2026-06-23T11:25:32.487Z
+  screenshot?: string;
+  pageSource?: string;
+  autoHealed?: boolean;
+  failureType?: 'ELEMENT_NOT_FOUND' | 'TIMEOUT' | 'NAVIGATION_TIMEOUT' | 'OTHER';
+  comparisonCode?: any;
+}
+
+// ─── Failure Metadata for API ─────────────────────────────────────────────────
+
+export interface FailureMetadata {
+  test_script_uid: string;
+  test_case_name: string;
+  step_name: string;
+  step_index: number;
+  failure_reason: string;
+  screenshot?: string;
+  pageSource?: string;
+  browser_type: string;
+  timestamp: string;
+  app_id?: string;
+}
+
+// ─── Step Request ─────────────────────────────────────────────────────────────
+
+export interface StepRequest {
+  step_name: string;
+  step_script: string;
+  label: string;
+  locators?: string[];
+  obj_uid?: string | null;
+  page_uid?: string | null;
+  status?: string;
+  value?: string;
+}
+
+// ─── Test Script Request ──────────────────────────────────────────────────────
+
+export interface TestScriptRequest {
+  test_script_uid: string;
+  test_case_name: string;
+  voice_enabled: boolean;
+  app_id: string;
+  browser: 'chromium' | 'chrome' | 'firefox' | 'edge';
+  headless: boolean;
+  screenshot_mode: 'on_failure' | 'always' | 'never';
+  stop_on_failure: boolean;
+  steps: StepRequest[];
+}
+
+// ─── Test Set Request ─────────────────────────────────────────────────────────
+
+export interface TestSetRequest {
+  test_set_name: string;
+  open_dashboard: boolean;
+  parallel: boolean;
+  stop_on_failure: boolean;
+  video_enabled: boolean;
+  exec_mode?: ExecMode;
+  scripts: TestScriptRequest[];
+}
+
+// ─── Test Script Result ───────────────────────────────────────────────────────
+
+export interface TestScriptResult {
+  test_script_uid: string;
+  test_case_name: string;
+  app_id: string;
+  browser: string;
+  status: 'PASS' | 'FAIL';
+  results: StepResult[];
+  // flat counts — no summary object
+  total_steps: number;
+  passed_steps: number;
+  failed_steps: number;
+  skipped_steps: number;
+  duration: number;           // milliseconds
+  start_time: string;         // ISO string
+}
+
+// ─── Test Set Result ──────────────────────────────────────────────────────────
+
+export interface TestSetResult {
+  executionId: string;
+  status: 'PASS' | 'FAIL';
+  total_scripts: number;
+  passed: number;
+  failed: number;
+  duration: number;           // milliseconds
+  results: TestScriptResult[];
+}
+
+export interface ExecMode {
+  mode: 'fast' | 'medium' | 'slow';
+  delay_ms?: number;
+}
+
+// ─── SSE ─────────────────────────────────────────────────────────────────────
+
+export type SSEEventType =
+  | 'execution_start'
+  | 'script_start'
+  | 'step_start'
+  | 'step_complete'
+  | 'script_complete'
+  | 'execution_complete'
+  | 'log';
+
+export interface SSEEvent {
+  type: SSEEventType;
+  executionId: string;
+  timestamp: string;
+  data: any;
+}

package/src/utils/healingService.ts

@@ -0,0 +1,210 @@
+import { StepResult } from '../types/types';
+import { TRIAGE, COMPARE } from '../config';
+/**
+ * Shape of a single healed entry from api/compare response
+ */
+export interface HealedEntry {
+  name: string;
+  obj_uid: string;
+  step_script: string;
+}
+
+/**
+ * Service for handling advanced auto-healing via triage + compare APIs
+ */
+export class HealingService {
+  
+  private triageApiUrl  = TRIAGE;
+  private compareApiUrl = COMPARE;
+
+  /**
+   * Classify failure type from error message
+   */
+  static classifyFailure(comments: string, result?: any): string {
+    const msg = comments.toLowerCase();
+
+    if (msg.includes('element not found') || msg.includes('not visible')) {
+      return 'ELEMENT_NOT_FOUND';
+    }
+    if (msg.includes('timeout') && msg.includes('navigation')) {
+      return 'NAVIGATION_TIMEOUT';
+    }
+    if (msg.includes('timeout')) {
+      return 'TIMEOUT';
+    }
+
+    return 'OTHER';
+  }
+
+  /**
+   * Call triage API to determine if auto-healing should be attempted
+   */
+  async callTriageAPI(triagePayload: any): Promise<{ callCompareScript: boolean; rootCause?: string; confidence?: number; reason?: string }> {
+    try {
+      console.log(`🩺 Calling triage API at ${this.triageApiUrl}...`);
+      const response = await fetch(this.triageApiUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(triagePayload)
+      });
+
+      if (!response.ok) {
+        console.warn(`⚠️ Triage API returned ${response.status} — skipping compare`);
+        return { callCompareScript: false };
+      }
+
+      const result = await response.json();
+      console.log(`🩺 Triage result:`, JSON.stringify(result));
+      console.log(`   Root cause: ${result?.root_cause} | Confidence: ${result?.confidence} | Call compare: ${result?.call_compare_script}`);
+
+      return {
+        callCompareScript: result?.call_compare_script === true,
+        rootCause: result?.root_cause,
+        confidence: result?.confidence,
+        reason: result?.reason
+      };
+    } catch (error: any) {
+      console.error(`❌ Triage API call failed: ${error.message} — skipping compare`);
+      return { callCompareScript: false };
+    }
+  }
+
+  /**
+   * Call compare API to get healed selectors/scripts
+   */
+  async callCompareAPI(comparePayload: any): Promise<any> {
+    try {
+      console.log(`📡 Calling compare API at ${this.compareApiUrl}...`);
+      const response = await fetch(this.compareApiUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(comparePayload)
+      });
+
+      if (!response.ok) {
+        console.warn(`⚠️ Compare API returned ${response.status}`);
+        return null;
+      }
+
+      const result = await response.json();
+      console.log(`📦 Compare result:`, JSON.stringify(result));
+
+      const healedChanged: HealedEntry[] = result?.diff_report?.self_healing?.healed_changed ?? [];
+      const healedRemoved: HealedEntry[] = result?.diff_report?.self_healing?.healed_removed ?? [];
+      const allHealed: HealedEntry[] = [...healedChanged, ...healedRemoved];
+
+      console.log(`🔬 healed_changed: ${healedChanged.length} | healed_removed: ${healedRemoved.length} | total: ${allHealed.length}`);
+
+      if (allHealed.length > 0) {
+        console.log(`🗃️ Found ${allHealed.length} healed entr${allHealed.length === 1 ? 'y' : 'ies'}: [${allHealed.map(e => e.name).join(', ')}]`);
+      }
+
+      return result;
+    } catch (error: any) {
+      console.error(`❌ Compare API call failed: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Build triage payload from execution context
+   */
+  static buildTriagePayload(
+    stepResults: StepResult[],
+    currentStep: any,
+    stepIndex: number,
+    scriptUid: string,
+    appId?: string
+  ): any {
+    const comments = currentStep.comments || 'Unknown error';
+    const failureType = HealingService.classifyFailure(comments);
+
+    return {
+      status: 'fail',
+      app_id: appId,
+      total_scripts: 1,
+      results: [
+        {
+          test_script_uid: scriptUid,
+          app_id: appId,
+          status: 'fail',
+          results: [
+            // All completed steps
+            ...stepResults.map((r, idx) => ({
+              uid: r.uid ?? null,
+              obj_uid: r.obj_uid ?? null,
+              step_name: r.step_name,
+              step_script: r.expected_result || '',
+              page_uid: r.page_uid ?? null,
+              comments: r.comments,
+              screenshot: r.screenshot ?? '',
+              duration: r.duration,
+              start_time: r.start_time.replace('T', ' ').substring(0, 19),
+              expected_result: r.expected_result ?? '',
+              status: r.status.toLowerCase()
+            })),
+            // Current failing step
+            {
+              uid: currentStep.uid ?? null,
+              obj_uid: currentStep.obj_uid ?? null,
+              step_name: currentStep.step_name,
+              step_script: currentStep.step_script,
+              page_uid: currentStep.page_uid ?? null,
+              comments: comments,
+              screenshot: currentStep.screenshot ?? '',
+              duration: currentStep.duration || '0 seconds',
+              start_time: new Date().toISOString().replace('T', ' ').substring(0, 19),
+              expected_result: currentStep.expected_result ?? '',
+              status: 'fail',
+              data: {
+                failure_type: failureType,
+                error: comments
+              }
+            }
+          ]
+        }
+      ]
+    };
+  }
+
+  /**
+   * Build compare payload from page context
+   */
+  static buildComparePayload(
+    appId: string,
+    pageUid: string,
+    objUid: string,
+    pageSource: string,
+    currentUrl: string,
+    stepIndex: number
+  ): any {
+    return {
+      app_id: appId,
+      page_uid: pageUid,
+      obj_uid: objUid,
+      pgContent: pageSource,
+      sub_url: currentUrl,
+      mode: 'html',
+      failed_step_index: stepIndex
+    };
+  }
+
+  /**
+   * Replace $variable placeholders with actual values
+   */
+  static replaceVariables(healedScript: string, stepValue?: string): string {
+    if (!healedScript.includes("'$")) {
+      return healedScript;
+    }
+
+    if (stepValue !== undefined && stepValue !== null && stepValue !== '') {
+      const replaced = healedScript.replace(/'(\$[^']+)'/, `'${stepValue}'`);
+      console.log(`🔧 $variable replaced with value: "${stepValue}"`);
+      console.log(`📝 Final healed script: ${replaced}`);
+      return replaced;
+    }
+
+    console.log(`⚠️ Step value is empty — $variable left unreplaced`);
+    return healedScript;
+  }
+}

package/src/utils/locatorService.ts

@@ -0,0 +1,73 @@
+import { Page, Locator } from 'playwright';
+
+export interface ResolvedElement {
+  element: Locator;
+  matchedIndex: number;
+  matchedXPath: string;
+}
+
+export class LocatorService {
+  /**
+   * Resolves an element using a list of xpath locators.
+   * Combines all xpaths into a single Playwright locator using OR-combined xpath expressions,
+   * waits for the first visible + attached match, then determines which specific
+   * locator (by position) actually matched.
+   */
+  static async resolveElement(page: Page, locators: string[], timeout: number = 10000): Promise<ResolvedElement> {
+    if (!locators || locators.length === 0) {
+      throw new Error('No locators provided');
+    }
+
+    const xpathLocators = locators.filter(l => l.trim().startsWith('/') || l.trim().startsWith('('));
+    const combinedXPath = xpathLocators.join(' | ');
+    const element = page.locator(`xpath=${combinedXPath}`).first();
+
+    try {
+      await element.waitFor({ state: 'visible', timeout });
+    } catch (error: any) {
+      throw new Error(`Element not found or not visible using locators: [${locators.join(', ')}] - ${error.message}`);
+    }
+
+    const matchedIndex = await this.findMatchedIndex(page, element, xpathLocators);
+
+    return {
+      element,
+      matchedIndex,
+      matchedXPath: matchedIndex >= 0 ? xpathLocators[matchedIndex] : combinedXPath
+    };
+  }
+
+  /**
+   * Determines which specific locator (by position) matches the resolved element,
+   * by checking each individual xpath separately and comparing element identity.
+   */
+  private static async findMatchedIndex(page: Page, resolvedElement: Locator, locators: string[]): Promise<number> {
+    try {
+      const resolvedHandle = await resolvedElement.elementHandle();
+      if (!resolvedHandle) return -1;
+
+      for (let i = 0; i < locators.length; i++) {
+        const candidate = page.locator(`xpath=${locators[i]}`).first();
+        const count = await candidate.count().catch(() => 0);
+
+        if (count === 0) continue;
+
+        const candidateHandle = await candidate.elementHandle().catch(() => null);
+        if (!candidateHandle) continue;
+
+        const isSameElement = await page.evaluate(
+          ({ a, b }) => a === b,
+          { a: resolvedHandle, b: candidateHandle }
+        ).catch(() => false);
+
+        if (isSameElement) {
+          return i;
+        }
+      }
+
+      return -1;
+    } catch {
+      return -1;
+    }
+  }
+}

package/src/utils/logger.ts

@@ -0,0 +1,27 @@
+export class Logger {
+  private context: string;
+
+  private constructor(context: string) {
+    this.context = context;
+  }
+
+  static create(context: string): Logger {
+    return new Logger(context);
+  }
+
+  info(msg: string): void {
+    console.log(`[${this.timestamp()}] [INFO] [${this.context}] ${msg}`);
+  }
+
+  error(msg: string): void {
+    console.error(`[${this.timestamp()}] [ERROR] [${this.context}] ${msg}`);
+  }
+
+  warn(msg: string): void {
+    console.warn(`[${this.timestamp()}] [WARN] [${this.context}] ${msg}`);
+  }
+
+  private timestamp(): string {
+    return new Date().toISOString().replace('T', ' ').split('.')[0];
+  }
+}

package/src/utils/metadataService.ts

@@ -0,0 +1,137 @@
+import { FailureMetadata, StepResult } from '../types/types';
+
+const API_BASE_URL = process.env.API_BASE_URL || 'http://localhost:5501';
+
+/**
+ * Service for handling failure metadata collection and transmission to API
+ */
+
+export class MetadataService {
+  /**
+   * Capture page source from Playwright page
+   */
+  static async capturePageSource(page: any): Promise<string | undefined> {
+    try {
+      const content = await page.content();
+      return content;
+    } catch (error) {
+      console.warn('Failed to capture page source:', error);
+      return undefined;
+    }
+  }
+
+ 
+  static buildFailureMetadata(
+    testScriptUid: string,
+    testCaseName: string,
+    stepIndex: number,
+    step: StepResult,
+    browserType: string,
+    appId?: string
+  ): FailureMetadata {
+    return {
+      test_script_uid: testScriptUid,
+      test_case_name: testCaseName,
+      step_name: step.step_name,
+      step_index: stepIndex,
+      failure_reason: step.comments,
+      screenshot: step.screenshot,
+      pageSource: step.pageSource,
+      browser_type: browserType,
+      timestamp: new Date().toISOString(),
+      app_id: appId
+    };
+  }
+
+  /**
+   * Send failure metadata to API for analysis and auto-healing
+   */
+  static async sendFailureMetadata(metadata: FailureMetadata): Promise<{ autoHealSuggestion?: string; success: boolean }> {
+    try {
+      const response = await fetch(`${API_BASE_URL}/api/failure-metadata`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(metadata)
+      });
+
+      if (!response.ok) {
+        console.warn(`Failed to send metadata: ${response.statusText}`);
+        return { success: false };
+      }
+
+      const data = await response.json();
+      return { autoHealSuggestion: data.autoHealSuggestion, success: true };
+    } catch (error: any) {
+      console.warn('Error sending failure metadata:', error.message);
+      return { success: false };
+    }
+  }
+
+  /**
+   * Apply auto-healing suggestion if available
+   * This could involve retrying with adjusted selectors, different wait conditions, etc.
+   */
+  static async applyAutoHealing(
+    suggestion: string,
+    originalStep: any,
+    page: any
+  ): Promise<boolean> {
+    try {
+      // Parse and apply healing suggestion
+      // Example: suggestion could be "{\"action\": \"retry\", \"adjustedSelector\": \"...\"}"
+      const healingData = JSON.parse(suggestion);
+
+      if (healingData.action === 'retry') {
+        console.log('Auto-healing: Retrying step with adjusted selector');
+        // Implementation would depend on step type
+        return true;
+      }
+
+      if (healingData.action === 'navigate') {
+        console.log('Auto-healing: Navigating to URL:', healingData.url);
+        await page.goto(healingData.url, { waitUntil: 'networkidle' });
+        return true;
+      }
+
+      return false;
+    } catch (error: any) {
+      console.warn('Failed to apply auto-healing:', error.message);
+      return false;
+    }
+  }
+
+ 
+  static async processScriptFailure(
+    results: StepResult[],
+    testScriptUid: string,
+    testCaseName: string,
+    browserType: string,
+    appId?: string
+  ): Promise<void> {
+    const failedSteps = results.filter((r) => r.status === 'FAIL');
+
+    for (let i = 0; i < failedSteps.length; i++) {
+      const step = failedSteps[i];
+      const stepIndex = results.indexOf(step);
+
+      const metadata = this.buildFailureMetadata(
+        testScriptUid,
+        testCaseName,
+        stepIndex,
+        step,
+        browserType,
+        appId
+      );
+
+      const response = await this.sendFailureMetadata(metadata);
+
+      if (response.success) {
+        console.log(`Failure metadata sent for step: ${step.step_name}`);
+        if (response.autoHealSuggestion) {
+          console.log('Auto-healing suggestion received:', response.autoHealSuggestion);
+          // Auto-healing would be applied during re-execution
+        }
+      }
+    }
+  }
+}