@xenon-device-management/xenon 1.1.0

package/lib/src/services/healing/HealingOrchestrator.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealingOrchestrator = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const FuzzyXmlHealingProvider_1 = require("./FuzzyXmlHealingProvider");
+const OcrHealingProvider_1 = require("./OcrHealingProvider");
+const VisualAiHealingProvider_1 = require("./VisualAiHealingProvider");
+const LlmHealingProvider_1 = require("./LlmHealingProvider");
+const HealEtalonService_1 = require("./HealEtalonService");
+const ResilioTreeHealingProvider_1 = require("./ResilioTreeHealingProvider");
+let HealingOrchestrator = class HealingOrchestrator {
+    constructor(etalonService) {
+        this.etalonService = etalonService;
+        this.logger = logger_1.default.scope('HealingOrchestrator');
+        this.providers = [];
+        this.providers = [
+            new ResilioTreeHealingProvider_1.ResilioTreeHealingProvider(this.etalonService),
+            new FuzzyXmlHealingProvider_1.FuzzyXmlHealingProvider(this.etalonService),
+            new OcrHealingProvider_1.OcrHealingProvider(),
+            new VisualAiHealingProvider_1.VisualAiHealingProvider(),
+            new LlmHealingProvider_1.LlmHealingProvider(),
+        ];
+    }
+    attemptHealing(sessionId, driver, strategy, selector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.info(`🚨 Self-Healing triggered for session ${sessionId}. Broken locator: ${strategy}=${selector}`);
+            // Preparation: Collect data required for healing
+            // Note: We do this once to avoid multiple expensive round-trips
+            const context = { sessionId, driver, strategy, selector };
+            try {
+                this.logger.debug('Collecting page source and screenshot for analysis...');
+                const [xml, screenshot] = yield Promise.all([driver.getPageSource(), driver.getScreenshot()]);
+                context.pageSource = xml;
+                context.screenshotBase64 = screenshot;
+            }
+            catch (err) {
+                this.logger.error(`Failed to collect healing context: ${err.message}`);
+                return null;
+            }
+            // Tiered Execution: Try providers in order of cost/complexity
+            for (const provider of this.providers) {
+                try {
+                    this.logger.info(`Attempting Tier ${provider.tier}: ${provider.name}...`);
+                    const result = yield provider.heal(context);
+                    if (result) {
+                        this.logger.info(`✨ Provider ${provider.name} found a match! Confidence: ${(result.confidence * 100).toFixed(0)}%`);
+                        // Tier 1/2 Optimization: Stability Verification Loop
+                        // We try all candidates to see which one is the most stable (semantic vs absolute)
+                        if (result.candidateSelectors && result.candidateSelectors.length > 0) {
+                            this.logger.debug(`Verifying ${result.candidateSelectors.length} candidate locators for stability...`);
+                            for (const candidate of result.candidateSelectors) {
+                                try {
+                                    const elements = yield context.driver.findElements('xpath', candidate);
+                                    if (elements.length === 1) {
+                                        this.logger.info(`🎯 Verified stable & unique locator: ${candidate}`);
+                                        result.recommendedSelector = candidate;
+                                        break; // Found a unique stable locator
+                                    }
+                                    else if (elements.length > 1) {
+                                        this.logger.debug(`⚠️ Candidate locator is not unique (${elements.length} matches): ${candidate}`);
+                                    }
+                                }
+                                catch (e) {
+                                    this.logger.debug(`Candidate locator check failed: ${candidate}`);
+                                }
+                            }
+                        }
+                        // Principal Learning: Autonomously update the etalon to prevent future failures
+                        // We only do this if confidence is over 70% to avoid pollution with false positives
+                        if (result.confidence > 0.7 && result.node) {
+                            try {
+                                this.logger.info(`🧠 Learning from healing success: updating etalon for ${selector}`);
+                                // Recalculate path for ResilioTree if node is available
+                                let learnedPath = null;
+                                if (result.node) {
+                                    try {
+                                        const { Path } = yield Promise.resolve().then(() => __importStar(require('resiliotree')));
+                                        const pathNodes = [];
+                                        let curr = result.node;
+                                        while (curr) {
+                                            pathNodes.unshift(curr);
+                                            curr = curr.parent || curr.parentNode;
+                                        }
+                                        learnedPath = new Path(pathNodes).toJSON();
+                                    }
+                                    catch (e) { }
+                                }
+                                yield this.etalonService.saveSignature(strategy, selector, result.node, learnedPath);
+                            }
+                            catch (learnErr) {
+                                this.logger.debug(`Failed to update etalon after healing: ${learnErr.message}`);
+                            }
+                        }
+                        return result;
+                    }
+                }
+                catch (err) {
+                    this.logger.error(`Provider ${provider.name} failed: ${err.message}`);
+                }
+            }
+            this.logger.warn(`❌ All healing tiers failed for selector: ${selector}`);
+            return null;
+        });
+    }
+};
+exports.HealingOrchestrator = HealingOrchestrator;
+exports.HealingOrchestrator = HealingOrchestrator = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [HealEtalonService_1.HealEtalonService])
+], HealingOrchestrator);

package/lib/src/services/healing/LlmHealingProvider.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LlmHealingProvider = void 0;
+const types_1 = require("./types");
+const AIService_1 = require("../AIService");
+const logger_1 = __importDefault(require("../../logger"));
+class LlmHealingProvider {
+    constructor() {
+        this.name = 'LLM Reasoning Provider';
+        this.tier = types_1.HealingTier.TIER_5_LLM_REASONING;
+        this.logger = logger_1.default.scope('LlmHealing');
+    }
+    heal(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!context.pageSource) {
+                this.logger.debug('No page source available for LLM reasoning');
+                return null;
+            }
+            // Check if AI service is enabled before attempting
+            if (!AIService_1.AI_SERVICE.isEnabled()) {
+                this.logger.debug('AI service not enabled, skipping LLM healing');
+                return null;
+            }
+            try {
+                this.logger.info(`Attempting Deep LLM healing for locator: "${context.selector}"`);
+                const healingResult = yield AIService_1.AI_SERVICE.healLocator({
+                    selector: context.selector,
+                    strategy: context.strategy,
+                    xml: context.pageSource,
+                    screenshotBase64: context.screenshotBase64,
+                });
+                if (healingResult && healingResult.recommendedXpath) {
+                    this.logger.info(`✅ LLM found healing path: ${healingResult.recommendedXpath}`);
+                    // Try to resolve the element to ensure it exists
+                    try {
+                        const element = yield context.driver.findElement('xpath', healingResult.recommendedXpath);
+                        return {
+                            id: element.ELEMENT || element['element-6066-11e4-a52e-4f735466cecf'],
+                            tier: this.tier,
+                            confidence: 0.95, // Deep reasoning is typically highly accurate
+                            originalSelector: context.selector,
+                            recommendedSelector: healingResult.recommendedXpath,
+                            message: `Found alternative element via Deep AI Reasoning: ${healingResult.reason}`,
+                        };
+                    }
+                    catch (err) {
+                        this.logger.error('LLM recommended path failed to resolve on device');
+                    }
+                }
+            }
+            catch (err) {
+                // Log service unavailability at debug level (expected), other errors at warn level
+                if (((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('unavailable')) || ((_b = err.message) === null || _b === void 0 ? void 0 : _b.includes('404'))) {
+                    this.logger.debug(`LLM healing skipped: ${err.message}`);
+                }
+                else {
+                    this.logger.warn(`Error during LLM healing: ${err.message}`);
+                }
+            }
+            return null;
+        });
+    }
+}
+exports.LlmHealingProvider = LlmHealingProvider;

package/lib/src/services/healing/OcrHealingProvider.js

@@ -0,0 +1,119 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcrHealingProvider = void 0;
+const types_1 = require("./types");
+const tesseract_js_1 = __importDefault(require("tesseract.js"));
+const logger_1 = __importDefault(require("../../logger"));
+class OcrHealingProvider {
+    constructor() {
+        this.name = 'OCR Text Provider';
+        this.tier = types_1.HealingTier.TIER_3_LOCAL_OCR;
+        this.logger = logger_1.default.scope('OcrHealing');
+    }
+    heal(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!context.screenshotBase64) {
+                this.logger.debug('No screenshot available for OCR matching');
+                return null;
+            }
+            try {
+                // Extract what text we are looking for from the selector
+                const soughtText = this.extractTextHint(context.selector);
+                if (!soughtText)
+                    return null;
+                this.logger.info(`Attempting OCR search for text: "${soughtText}"`);
+                // Run OCR on the screenshot
+                const buffer = Buffer.from(context.screenshotBase64, 'base64');
+                const result = yield tesseract_js_1.default.recognize(buffer, 'eng');
+                const { words } = result.data;
+                // Look for the best word match
+                const bestWord = words
+                    ? words.find((w) => w.text.toLowerCase().includes(soughtText.toLowerCase()) ||
+                        soughtText.toLowerCase().includes(w.text.toLowerCase()))
+                    : null;
+                if (bestWord) {
+                    this.logger.info(`✅ OCR found text "${bestWord.text}" at ${JSON.stringify(bestWord.bbox)}`);
+                    // Convert bbox to center coordinates
+                    const x = Math.round((bestWord.bbox.x0 + bestWord.bbox.x1) / 2);
+                    const y = Math.round((bestWord.bbox.y0 + bestWord.bbox.y1) / 2);
+                    // Try to get the REAL element at these coordinates by tapping
+                    try {
+                        // Use W3C Actions to tap at the OCR-detected coordinates, then find the element at that position
+                        const element = yield context.driver
+                            .findElement('-ios predicate string', `label CONTAINS[c] "${bestWord.text.replace(/"/g, '\\"')}"`)
+                            .catch(() => null);
+                        if (element) {
+                            const elementId = element.ELEMENT || element['element-6066-11e4-a52e-4f735466cecf'];
+                            if (elementId) {
+                                this.logger.info('🎯 OCR resolved to real element via predicate search');
+                                return {
+                                    id: elementId,
+                                    tier: this.tier,
+                                    confidence: bestWord.confidence / 100,
+                                    originalSelector: context.selector,
+                                    recommendedSelector: `ocr:text="${bestWord.text}"`,
+                                    message: `Found text "${bestWord.text}" via local OCR (${bestWord.confidence.toFixed(0)}% confidence)`,
+                                    rect: {
+                                        x: bestWord.bbox.x0,
+                                        y: bestWord.bbox.y0,
+                                        width: bestWord.bbox.x1 - bestWord.bbox.x0,
+                                        height: bestWord.bbox.y1 - bestWord.bbox.y0,
+                                    },
+                                };
+                            }
+                        }
+                    }
+                    catch (predErr) {
+                        this.logger.debug(`Predicate search failed: ${predErr.message}`);
+                    }
+                    // Fallback: Return coordinate-based result with virtual ID
+                    // The CommandInterceptor handles rect-based results via coordinate tap
+                    return {
+                        id: `healed_ocr_${Date.now()}`,
+                        tier: this.tier,
+                        confidence: bestWord.confidence / 100,
+                        originalSelector: context.selector,
+                        recommendedSelector: `ocr:text="${bestWord.text}"`,
+                        message: `Found text "${bestWord.text}" via local OCR (${bestWord.confidence.toFixed(0)}% confidence)`,
+                        rect: {
+                            x: bestWord.bbox.x0,
+                            y: bestWord.bbox.y0,
+                            width: bestWord.bbox.x1 - bestWord.bbox.x0,
+                            height: bestWord.bbox.y1 - bestWord.bbox.y0,
+                        },
+                    };
+                }
+            }
+            catch (err) {
+                this.logger.error(`Error during OCR healing: ${err.message}`);
+            }
+            return null;
+        });
+    }
+    extractTextHint(selector) {
+        // If selector is //*[@text='Login'] or similar, grab 'Login'
+        const textMatch = selector.match(/text=['"]([^'"]+)['"]/i) ||
+            selector.match(/content-desc=['"]([^'"]+)['"]/i) ||
+            selector.match(/label=['"]([^'"]+)['"]/i) ||
+            selector.match(/name=['"]([^'"]+)['"]/i);
+        if (textMatch)
+            return textMatch[1];
+        // Otherwise try to grab last part of selector if it looks like words
+        const parts = selector.split(/[\/\@\[\]\=\'\"]/);
+        const lastWord = parts.reverse().find((p) => p.length > 3);
+        return lastWord || null;
+    }
+}
+exports.OcrHealingProvider = OcrHealingProvider;

package/lib/src/services/healing/ResilioTreeHealingProvider.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResilioTreeHealingProvider = void 0;
+const types_1 = require("./types");
+const { Path, PathFinder, JSDOMParser, LCSPathDistance, HeuristicNodeDistance, } = require('resiliotree');
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const HealedLocatorGenerator_1 = require("./HealedLocatorGenerator");
+class ResilioTreeHealingProvider {
+    constructor(etalonService) {
+        this.etalonService = etalonService;
+        this.name = 'ResilioTree Provider';
+        this.tier = types_1.HealingTier.TIER_1_RECOVERY; // High priority robust recovery
+        this.logger = logger_1.default.scope('ResilioTreeHealing');
+        this.generator = typedi_1.Container.get(HealedLocatorGenerator_1.HealedLocatorGenerator);
+    }
+    heal(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!context.pageSource) {
+                this.logger.debug('No page source available for ResilioTree healing');
+                return null;
+            }
+            try {
+                const signature = yield this.etalonService.getSignature(context.selector);
+                if (!signature || !signature.path) {
+                    this.logger.debug(`No ResilioTree path found for selector: ${context.selector}`);
+                    return null;
+                }
+                this.logger.info(`Attempting robust ResilioTree recovery for: ${context.selector}`);
+                // 1. Parse current page source into ResilioTree model
+                const parser = new JSDOMParser();
+                const targetRoot = parser.parse(context.pageSource);
+                // 2. Revive the saved path from JSON
+                const savedPath = Path.fromJSON(signature.path);
+                // 3. Find the nearest node using ResilioTree's PathFinder
+                const pathDistance = new LCSPathDistance();
+                const nodeDistance = new HeuristicNodeDistance();
+                const pathFinder = new PathFinder(pathDistance, nodeDistance);
+                const nearestNode = pathFinder.findNearest(savedPath, targetRoot);
+                if (nearestNode) {
+                    const candidateLocators = this.generator.generate(nearestNode);
+                    const recommendedXpath = candidateLocators[0] || this.generateXpath(nearestNode);
+                    this.logger.info(`ResilioTree suggested recovery XPath: ${recommendedXpath}`);
+                    try {
+                        const healedElement = yield context.driver.findElement('xpath', recommendedXpath);
+                        if (healedElement) {
+                            return {
+                                id: healedElement.ELEMENT || healedElement['element-6066-11e4-a52e-4f735466cecf'],
+                                originalSelector: context.selector,
+                                recommendedSelector: recommendedXpath,
+                                candidateSelectors: candidateLocators,
+                                confidence: 0.9, // ResilioTree path matching is high confidence
+                                tier: this.tier,
+                                node: nearestNode,
+                                message: `Recovered via ResilioTree path matching. New XPath: ${recommendedXpath}`,
+                            };
+                        }
+                    }
+                    catch (e) {
+                        this.logger.debug(`Driver failed to find element suggested by ResilioTree: ${recommendedXpath}`);
+                    }
+                }
+            }
+            catch (err) {
+                this.logger.error(`Error during ResilioTree healing: ${err.message}`);
+            }
+            return null;
+        });
+    }
+    /**
+     * Generates an absolute XPath for a ResilioTree Node
+     */
+    generateXpath(node) {
+        const parts = [];
+        let curr = node;
+        while (curr) {
+            const tag = curr.tag.toLowerCase();
+            // Skip JSDOM added wrapper tags for mobile compatibility
+            if (tag !== 'html' && tag !== 'body') {
+                const index = curr.index + 1; // XPath is 1-based
+                parts.unshift(`${curr.tag}[${index}]`);
+            }
+            curr = curr.parent;
+        }
+        return `/${parts.join('/')}`;
+    }
+}
+exports.ResilioTreeHealingProvider = ResilioTreeHealingProvider;

package/lib/src/services/healing/VisualAiHealingProvider.js

@@ -0,0 +1,90 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisualAiHealingProvider = void 0;
+const types_1 = require("./types");
+const AIService_1 = require("../AIService");
+const logger_1 = __importDefault(require("../../logger"));
+class VisualAiHealingProvider {
+    constructor() {
+        this.name = 'Visual AI Provider';
+        this.tier = types_1.HealingTier.TIER_4_VISUAL_AI;
+        this.logger = logger_1.default.scope('VisualAiHealing');
+    }
+    heal(context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (!context.screenshotBase64) {
+                this.logger.debug('No screenshot available for visual AI matching');
+                return null;
+            }
+            // Check if AI service is enabled before attempting
+            if (!AIService_1.AI_SERVICE.isEnabled()) {
+                this.logger.debug('AI service not enabled, skipping Visual AI healing');
+                return null;
+            }
+            try {
+                // Describe what we are looking for based on the selector
+                const description = this.generateVisualDescription(context.selector);
+                this.logger.info(`Attempting Visual AI find for: "${description}"`);
+                const coordinates = yield AIService_1.AI_SERVICE.visualFind(context.screenshotBase64, description);
+                if (coordinates && typeof coordinates.x === 'number' && typeof coordinates.y === 'number') {
+                    this.logger.info(`✅ Visual AI found element at (${coordinates.x}, ${coordinates.y})`);
+                    return {
+                        id: `healed_visual_${Date.now()}`,
+                        tier: this.tier,
+                        confidence: 0.8, // Basic vision models don't always give confidence, assuming high if found
+                        originalSelector: context.selector,
+                        recommendedSelector: `visual:description="${description}"`,
+                        message: `Found element visually via AI Vision (${description})`,
+                        rect: {
+                            x: coordinates.x - 20, // Approximate bounding box
+                            y: coordinates.y - 20,
+                            width: 40,
+                            height: 40,
+                        },
+                    };
+                }
+            }
+            catch (err) {
+                // Log service unavailability at debug level (expected), other errors at warn level
+                if (((_a = err.message) === null || _a === void 0 ? void 0 : _a.includes('unavailable')) || ((_b = err.message) === null || _b === void 0 ? void 0 : _b.includes('404'))) {
+                    this.logger.debug(`Visual AI healing skipped: ${err.message}`);
+                }
+                else {
+                    this.logger.warn(`Error during Visual AI healing: ${err.message}`);
+                }
+            }
+            return null;
+        });
+    }
+    generateVisualDescription(selector) {
+        // Convert selector to a descriptive string for the AI
+        // Handle iOS (@name, @label) and Android (@text, @content-desc) patterns
+        const textMatch = selector.match(/text=['"]([^'"]+)['"]/i) ||
+            selector.match(/label=['"]([^'"]+)['"]/i) ||
+            selector.match(/name=['"]([^'"]+)['"]/i) ||
+            selector.match(/content-desc=['"]([^'"]+)['"]/i);
+        if (textMatch) {
+            return `the element with text "${textMatch[1]}"`;
+        }
+        // Clean up IDs
+        const idMatch = selector.match(/id=['"]([^'"]+)['"]/i) || selector.match(/resource-id=['"]([^'"]+)['"]/i);
+        if (idMatch) {
+            return `the element with ID or identifier "${idMatch[1]}"`;
+        }
+        return `the element described by the locator "${selector}"`;
+    }
+}
+exports.VisualAiHealingProvider = VisualAiHealingProvider;

package/lib/src/services/healing/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealingTier = void 0;
+var HealingTier;
+(function (HealingTier) {
+    HealingTier[HealingTier["TIER_1_RECOVERY"] = 0] = "TIER_1_RECOVERY";
+    HealingTier[HealingTier["TIER_1_NATIVE"] = 1] = "TIER_1_NATIVE";
+    HealingTier[HealingTier["TIER_2_FUZZY_XML"] = 2] = "TIER_2_FUZZY_XML";
+    HealingTier[HealingTier["TIER_3_LOCAL_OCR"] = 3] = "TIER_3_LOCAL_OCR";
+    HealingTier[HealingTier["TIER_4_VISUAL_AI"] = 4] = "TIER_4_VISUAL_AI";
+    HealingTier[HealingTier["TIER_5_LLM_REASONING"] = 5] = "TIER_5_LLM_REASONING";
+})(HealingTier || (exports.HealingTier = HealingTier = {}));