@xenon-device-management/xenon 2.13.2 → 2.14.0

package/lib/src/services/network/xenonProxy.js

@@ -0,0 +1,107 @@
+"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.isUnsetProxy = isUnsetProxy;
+exports.parseProxySetting = parseProxySetting;
+exports.localIPv4Addresses = localIPv4Addresses;
+exports.pointsAtThisMachine = pointsAtThisMachine;
+exports.isPortListening = isPortListening;
+exports.isDeadCaptureProxy = isDeadCaptureProxy;
+const net_1 = __importDefault(require("net"));
+const os_1 = __importDefault(require("os"));
+/**
+ * Reading a phone's global HTTP proxy (`settings get global http_proxy`), and
+ * telling one Xenon's network capture left behind from one somebody set on
+ * purpose.
+ */
+/** Android's ways of saying "no proxy": unset (`null`), empty, or `:0`. */
+function isUnsetProxy(value) {
+    const v = (value !== null && value !== void 0 ? value : '').trim();
+    return v === '' || v === 'null' || v === ':0';
+}
+/** `host:port`, or null for no proxy or anything else. */
+function parseProxySetting(value) {
+    if (isUnsetProxy(value))
+        return null;
+    const v = value.trim();
+    const colon = v.lastIndexOf(':');
+    if (colon <= 0)
+        return null;
+    const host = v.slice(0, colon);
+    const portText = v.slice(colon + 1);
+    if (!/^\d+$/.test(portText))
+        return null;
+    const port = Number(portText);
+    if (port < 1 || port > 65535)
+        return null;
+    return { host, port };
+}
+/** This machine's own IPv4 addresses, as a phone on its network reaches it. */
+function localIPv4Addresses() {
+    const out = [];
+    for (const infos of Object.values(os_1.default.networkInterfaces())) {
+        for (const info of infos !== null && infos !== void 0 ? infos : []) {
+            if (info.family === 'IPv4' && !info.internal)
+                out.push(info.address);
+        }
+    }
+    return out;
+}
+/**
+ * Whether a phone that uses `host` as its proxy reaches this machine: through
+ * `adb reverse` (127.0.0.1, the phone itself), an emulator's alias for its
+ * host (10.0.2.2), or this machine's own address (the interceptor's LAN
+ * fallback). These are the only hosts the interceptor ever sets.
+ */
+function pointsAtThisMachine(host, ownAddresses) {
+    const h = host.trim().toLowerCase();
+    return h === '127.0.0.1' || h === 'localhost' || h === '10.0.2.2' || ownAddresses.includes(h);
+}
+/**
+ * Whether something on this machine accepts a TCP connection on `port`.
+ * Anything but a refusal counts as yes (a timeout too): only a port known to be
+ * dead may have a proxy that points at it cleared.
+ */
+function isPortListening(port, timeoutMs = 1000) {
+    return new Promise((resolve) => {
+        const socket = net_1.default.connect({ host: '127.0.0.1', port });
+        const done = (answer) => {
+            socket.removeAllListeners();
+            socket.destroy();
+            resolve(answer);
+        };
+        socket.setTimeout(timeoutMs, () => done(true));
+        socket.once('connect', () => done(true));
+        socket.once('error', (err) => done(err.code !== 'ECONNREFUSED'));
+    });
+}
+/**
+ * Whether `value` is a proxy Xenon's network capture set and nobody serves any
+ * more: it points at this machine, on one of this server's capture ports, and
+ * nothing answers there. A phone with such a proxy has no network at all. A
+ * proxy that points anywhere else, or at a port that answers (a capture that
+ * is running, maybe another Xenon's on this machine), is never one.
+ */
+function isDeadCaptureProxy(value_1, captureRange_1) {
+    return __awaiter(this, arguments, void 0, function* (value, captureRange, probe = isPortListening) {
+        const proxy = parseProxySetting(value);
+        if (!proxy)
+            return false;
+        if (!pointsAtThisMachine(proxy.host, localIPv4Addresses()))
+            return false;
+        if (proxy.port < captureRange[0] || proxy.port > captureRange[1])
+            return false;
+        return !(yield probe(proxy.port));
+    });
+}

package/lib/src/services/omni-vision/OmniVisionService.js

@@ -59,6 +59,8 @@ const sharp_1 = __importDefault(require("sharp"));
 const AIService_1 = require("../AIService");
 const logger_1 = __importDefault(require("../../logger"));
 const crypto_1 = __importDefault(require("crypto"));
+const ocrTextMatch_1 = require("./ocrTextMatch");
+const screenScale_1 = require("./screenScale");
 // Mobile UIs have sparse text on complex backgrounds - reduce contrast to preserve readability
 const DEFAULT_CONTRAST = 1.2; // Slightly above 1.0 for mild enhancement (was 0.8 which was too aggressive)
 const UPSCALE_THRESHOLD = 800; // Only upscale very small images (was 1500)
@@ -379,10 +381,17 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
             }
         });
     }
+    /** The OCR words with usable boxes, in the screenshot's pixels. */
+    wordBoxes(words) {
+        return words.map((w) => this.normalizeWordBBox(w)).filter(Boolean);
+    }
     /**
-     * Proactive OCR Search: Finds elements matching text even if not in XML
-     */
-    /**
+     * Proactive OCR Search: Finds elements matching text even if not in XML.
+     *
+     * The text may be several words ("Sign in"); see ocrTextMatch.ts. Each
+     * element's rect is in the driver's coordinates (points on iOS), like a
+     * real element's, so tapping it lands on the text.
+     *
      * `throwOnError`: fail instead of answering "no match" when the screenshot
      * or OCR fails. Device control's "Test locator" asks for it; an Appium
      * findElement doesn't, and turns the empty list into NoSuchElement.
@@ -398,17 +407,15 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
                     this.logger.warn(`OCR proactive search yielded no words. Text content: "${ocrText.trim().substring(0, 100)}..."`);
                     return [];
                 }
-                const matches = words.filter((w) => w.text && w.text.toLowerCase().includes(text.toLowerCase()) && w.confidence > 60);
+                const matches = (0, ocrTextMatch_1.findText)(this.wordBoxes(words), String(text !== null && text !== void 0 ? text : '')).filter((m) => m.confidence > 60);
+                if (matches.length === 0)
+                    return [];
+                const scale = yield (0, screenScale_1.screenScaleOf)(driver, screenshot);
                 return matches.map((m) => {
                     const el = {
                         id: `omni_ocr_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`,
                         text: m.text,
-                        rect: {
-                            x: m.bbox.x0,
-                            y: m.bbox.y0,
-                            width: m.bbox.x1 - m.bbox.x0,
-                            height: m.bbox.y1 - m.bbox.y0,
-                        },
+                        rect: (0, screenScale_1.toDriverRect)({ x: m.x0, y: m.y0, width: m.x1 - m.x0, height: m.y1 - m.y0 }, scale),
                         confidence: m.confidence / 100,
                     };
                     this.virtualElementStore.set(el.id, el);
@@ -433,14 +440,12 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
                 const screenshot = yield driver.getScreenshot();
                 const coordinates = yield AIService_1.AI_SERVICE.visualFind(screenshot, iconDescription, opts);
                 if (coordinates) {
+                    // The AI answers in the screenshot's pixels; the rect is the driver's
+                    // (points on iOS), like a real element's.
+                    const scale = yield (0, screenScale_1.screenScaleOf)(driver, screenshot);
                     const el = {
                         id: `omni_ai_${Date.now()}`,
-                        rect: {
-                            x: coordinates.x - 20,
-                            y: coordinates.y - 20,
-                            width: 40,
-                            height: 40,
-                        },
+                        rect: (0, screenScale_1.toDriverRect)({ x: coordinates.x - 20, y: coordinates.y - 20, width: 40, height: 40 }, scale),
                         confidence: 0.85,
                     };
                     this.virtualElementStore.set(el.id, el);
@@ -460,6 +465,7 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
      */
     analyzeScreen(driver) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             this.logger.info('Performing full screen analysis...');
             try {
                 const screenshot = yield driver.getScreenshot();
@@ -470,32 +476,28 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
                 this.validateBuffer(buffer, 'Screen Analysis');
                 // 1. Get all text via OCR using the robust worker flow
                 const { text: ocrText, words } = yield this.performOcr(buffer);
-                // 2. Ask AI for qualitative analysis (Non-blocking)
-                let aiAnalysis = null;
+                // 2. Ask the AI provider about the screen, with the screenshot. Its
+                // failure leaves the OCR answer standing, and says why there are no
+                // insights. Through 2.13.2 this sent the screenshot's base64 as a file
+                // path, so the provider got no image and a "why did this test fail"
+                // prompt, and answered about no screen at all.
+                let aiInsights = null;
+                let aiError;
                 try {
-                    aiAnalysis = yield AIService_1.AI_SERVICE.analyzeFailure({
-                        sessionId: driver.sessionId,
-                        failureReason: 'Screen Analysis Request',
-                        commandLogs: [],
-                        deviceLogs: [],
-                        screenshotPath: screenshot, // In a real scenario, we'd save this to a file first or pass base64
-                    });
+                    aiInsights = yield AIService_1.AI_SERVICE.describeScreen(screenshot);
                 }
                 catch (aiErr) {
-                    this.logger.warn(`AI insights skipped: ${aiErr.message}`);
+                    aiError = (_a = aiErr === null || aiErr === void 0 ? void 0 : aiErr.message) !== null && _a !== void 0 ? _a : String(aiErr);
+                    this.logger.warn(`AI insights skipped: ${aiError}`);
                 }
-                return {
-                    timestamp: new Date().toISOString(),
-                    ocr: {
+                return Object.assign({ timestamp: new Date().toISOString(), ocr: {
                         text: ocrText,
                         words: words.map((w) => ({
                             text: w.text || '',
                             confidence: w.confidence || 0,
                             bbox: w.bbox || { x0: 0, y0: 0, x1: 0, y1: 0 },
                         })),
-                    },
-                    ai_insights: aiAnalysis,
-                };
+                    }, ai_insights: aiInsights }, (aiError !== undefined ? { ai_insights_error: aiError } : {}));
             }
             catch (err) {
                 this.logger.error(`Screen analysis failed: ${err.message}`);
@@ -511,6 +513,11 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
     }
     /**
      * Omni-Click: Find a target by OCR text and click its center using W3C actions.
+     *
+     * The text may be several words ("Sign in"); see ocrTextMatch.ts. The tap
+     * and `target` are in the driver's coordinates (points on iOS). A failed
+     * screenshot or OCR, or a screen size that can't be read on iOS, fails;
+     * `clicked: false` means the text was looked for and not found.
      */
     omniClickByText(driver, req) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -533,22 +540,21 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
             const screenshot = yield driver.getScreenshot();
             const buffer = Buffer.from(screenshot, 'base64');
             const { words } = yield this.performOcr(buffer);
-            const normalized = words.map((w) => this.normalizeWordBBox(w)).filter(Boolean);
-            const matches = normalized
-                .filter((w) => w.text.toLowerCase().includes(text.toLowerCase()))
-                .sort((a, b) => (b.confidence || 0) - (a.confidence || 0) || a.y0 - b.y0 || a.x0 - b.x0);
+            const matches = (0, ocrTextMatch_1.findText)(this.wordBoxes(words), text).sort((a, b) => (b.confidence || 0) - (a.confidence || 0) || a.y0 - b.y0 || a.x0 - b.x0);
             if (matches.length === 0) {
                 return { clicked: false, message: `No OCR match found for text "${text}"` };
             }
             const pick = matches[Math.min(index - 1, matches.length - 1)];
+            const scale = yield (0, screenScale_1.screenScaleOf)(driver, screenshot);
+            const found = (0, screenScale_1.toDriverRect)({ x: pick.x0, y: pick.y0, width: pick.x1 - pick.x0, height: pick.y1 - pick.y0 }, scale);
             const rect = {
-                x: Math.max(0, Math.round(pick.x0)),
-                y: Math.max(0, Math.round(pick.y0)),
-                width: Math.max(1, Math.round(pick.x1 - pick.x0)),
-                height: Math.max(1, Math.round(pick.y1 - pick.y0)),
+                x: Math.max(0, Math.round(found.x)),
+                y: Math.max(0, Math.round(found.y)),
+                width: Math.max(1, Math.round(found.width)),
+                height: Math.max(1, Math.round(found.height)),
             };
-            const cx = Math.round(rect.x + rect.width / 2);
-            const cy = Math.round(rect.y + rect.height / 2);
+            const cx = Math.round(found.x + found.width / 2);
+            const cy = Math.round(found.y + found.height / 2);
             // Click via touch actions
             yield driver.performActions([
                 {
@@ -583,6 +589,10 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
     }
     /**
      * Omni-Click by Icon: Find a target by visual description and click its center.
+     *
+     * Fails when it can't look (no AI provider, a failed screenshot or AI call);
+     * `clicked: false` means the AI looked and found nothing. Through 2.13.2 every
+     * one of those answered `clicked: false`, "No visual match found".
      */
     omniClickByIcon(driver, req) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -596,7 +606,7 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
                 };
             }
             this.logger.info(`Omni-Click: searching for icon "${icon}" via AI...`);
-            const element = yield this.findByIcon(driver, icon);
+            const element = yield this.findByIcon(driver, icon, { throwOnError: true });
             if (!element) {
                 return { clicked: false, message: `No visual match found for icon "${icon}"` };
             }

package/lib/src/services/omni-vision/VisionAssertionService.js

@@ -20,6 +20,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VisionAssertionService = void 0;
 const typedi_1 = require("typedi");
+const base_driver_1 = require("@appium/base-driver");
 const AIService_1 = require("../AIService");
 const logger_1 = __importDefault(require("../../logger"));
 let VisionAssertionService = class VisionAssertionService {
@@ -27,38 +28,40 @@ let VisionAssertionService = class VisionAssertionService {
         this.logger = logger_1.default.scope('VisionAssertion');
     }
     /**
-     * Asserts a visual state using AI reasoning
+     * `xenon: assertVisualState`: whether `instruction`, a condition in plain
+     * words, holds on the device's screen now, as the AI provider judges it from
+     * a screenshot.
+     *
+     * Answers `{ result, message }` only with the provider's own verdict.
+     * Whenever there is none it fails, saying the condition was not checked: no
+     * condition, no screenshot, no AI provider, a failed or rate-limited call,
+     * or an answer that isn't true or false. It never answers `false` for "could
+     * not check": a test asserting that something is absent would pass. Through
+     * 2.13.2 it answered `{ result: true, message: 'Assertion placeholder' }` in
+     * all of those cases.
      */
     assertState(driver, instruction) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logger.info(`Asserting visual state: "${instruction}"`);
+            var _a;
+            const condition = typeof instruction === 'string' ? instruction.trim() : '';
+            if (!condition) {
+                throw new base_driver_1.errors.InvalidArgumentError('assertVisualState needs a condition to check, as a string or { instruction }, ' +
+                    "for example 'The cart is empty'.");
+            }
+            this.logger.info(`Asserting visual state: "${condition}"`);
+            let screenshot;
             try {
-                const screenshot = yield driver.getScreenshot();
-                const prompt = `
-        You are a visual testing quality agent. 
-        Your task is to verify if the following condition is true based on the provided screenshot.
-        
-        Condition: "${instruction}"
-        
-        Response Format: JSON only, strictly { "result": boolean, "message": "detailed explanation of what you see" }.
-      `;
-                const response = yield AIService_1.AI_SERVICE.visualFind(screenshot, prompt);
-                // Note: We use visualFind which calls analyze. We expect a JSON response.
-                // Since analyze returns raw text, we attempt to parse it.
-                if (response && response.result !== undefined) {
-                    return {
-                        result: response.result,
-                        message: response.message || 'Assertion evaluated successfully.',
-                    };
-                }
-                // Fallback: If AI_SERVICE.visualFind was used literally, it might not return what we expect.
-                // Let's assume a more direct path if needed, but for now we'll stick to this pattern.
-                return { result: true, message: 'Assertion placeholder' };
+                screenshot = yield driver.getScreenshot();
             }
             catch (err) {
-                this.logger.error(`Visual assertion failed: ${err.message}`);
-                return { result: false, message: `Error: ${err.message}` };
+                throw new Error(`No screenshot could be taken, so the condition was not checked: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+            if (!screenshot) {
+                throw new Error('No screenshot could be taken, so the condition was not checked.');
             }
+            const verdict = yield AIService_1.AI_SERVICE.assertVisual(screenshot, condition);
+            this.logger.info(`"${condition}": ${verdict.result} (${verdict.message})`);
+            return verdict;
         });
     }
 };

package/lib/src/services/omni-vision/ocrTextMatch.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Finding a text, one word or several, among the words OCR read off a
+ * screenshot. Tesseract gives one box per word, so a text with a space in it
+ * ("Sign in") is looked for across neighbouring words on one line, and its
+ * box is the box around the words it covers.
+ *
+ * Pure: boxes in, boxes out, in the screenshot's pixels.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordRuns = wordRuns;
+exports.findText = findText;
+/**
+ * Two words further apart than this many times their height are not
+ * neighbours: a space is about a third of a word's height, and a gap this
+ * wide is another column, such as "Cancel" and "Done" at either end of a bar.
+ */
+const MAX_GAP_IN_HEIGHTS = 1.5;
+const normalize = (text) => text.toLowerCase().replace(/\s+/g, ' ').trim();
+const heightOf = (w) => Math.max(1, w.y1 - w.y0);
+/** Whether a word sits on a line: their heights overlap by at least half the shorter one. */
+function onLine(line, word) {
+    const overlap = Math.min(line.y1, word.y1) - Math.max(line.y0, word.y0);
+    return overlap > 0 && overlap >= Math.min(heightOf(line), heightOf(word)) / 2;
+}
+/**
+ * The words in runs of neighbours: on one line, left to right, with no wide
+ * gap between them. Runs are in reading order.
+ */
+function wordRuns(words) {
+    const lines = [];
+    for (const word of [...words].sort((a, b) => a.y0 - b.y0 || a.x0 - b.x0)) {
+        const line = lines.find((l) => onLine(l, word));
+        if (line) {
+            line.words.push(word);
+            line.y0 = Math.min(line.y0, word.y0);
+            line.y1 = Math.max(line.y1, word.y1);
+        }
+        else {
+            lines.push({ y0: word.y0, y1: word.y1, words: [word] });
+        }
+    }
+    const runs = [];
+    for (const line of lines.sort((a, b) => a.y0 - b.y0)) {
+        let run = [];
+        for (const word of line.words.sort((a, b) => a.x0 - b.x0)) {
+            const previous = run[run.length - 1];
+            const gap = previous ? word.x0 - previous.x1 : 0;
+            if (previous && gap > MAX_GAP_IN_HEIGHTS * Math.max(heightOf(previous), heightOf(word))) {
+                runs.push(run);
+                run = [];
+            }
+            run.push(word);
+        }
+        if (run.length)
+            runs.push(run);
+    }
+    return runs;
+}
+/**
+ * Every place `text` appears, ignoring case and runs of spaces, within a word
+ * or across neighbouring words: "Sign in" in "Sign" "in", "password" in
+ * "password?". Each match covers the words it touches: its box surrounds
+ * them, its text is theirs joined with spaces, and its confidence is the
+ * lowest of theirs. A one-word text matches inside one word, as it always
+ * did. Matches are in reading order.
+ */
+function findText(words, text) {
+    const wanted = normalize(text);
+    if (!wanted)
+        return [];
+    const matches = [];
+    for (const run of wordRuns(words)) {
+        // The run as one string, remembering where each word sits in it.
+        let line = '';
+        const spans = [];
+        for (const word of run) {
+            if (line)
+                line += ' ';
+            const start = line.length;
+            line += normalize(word.text);
+            spans.push({ start, end: line.length });
+        }
+        const seen = new Set();
+        for (let at = line.indexOf(wanted); at !== -1; at = line.indexOf(wanted, at + 1)) {
+            const end = at + wanted.length;
+            const first = spans.findIndex((s) => s.end > at);
+            const last = spans.findIndex((s) => s.end >= end);
+            const key = `${first}-${last}`;
+            if (first === -1 || last === -1 || seen.has(key))
+                continue;
+            seen.add(key);
+            const covered = run.slice(first, last + 1);
+            matches.push({
+                x0: Math.min(...covered.map((w) => w.x0)),
+                y0: Math.min(...covered.map((w) => w.y0)),
+                x1: Math.max(...covered.map((w) => w.x1)),
+                y1: Math.max(...covered.map((w) => w.y1)),
+                text: covered.map((w) => w.text).join(' '),
+                confidence: Math.min(...covered.map((w) => w.confidence)),
+            });
+        }
+    }
+    return matches;
+}

package/lib/src/services/omni-vision/screenScale.js

@@ -0,0 +1,68 @@
+"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.SAME_SCALE = void 0;
+exports.driverUsesPoints = driverUsesPoints;
+exports.screenScaleOf = screenScaleOf;
+exports.toDriverRect = toDriverRect;
+const sharp_1 = __importDefault(require("sharp"));
+exports.SAME_SCALE = { x: 1, y: 1 };
+/**
+ * Whether the driver's coordinates are points rather than the screenshot's
+ * pixels. A driver Xenon can't place (device control's screenshot-only
+ * stand-in, which never taps) keeps pixels.
+ */
+function driverUsesPoints(driver) {
+    var _a, _b, _c, _d;
+    const platform = String((_d = (_b = (_a = driver === null || driver === void 0 ? void 0 : driver.caps) === null || _a === void 0 ? void 0 : _a.platformName) !== null && _b !== void 0 ? _b : (_c = driver === null || driver === void 0 ? void 0 : driver.opts) === null || _c === void 0 ? void 0 : _c.platformName) !== null && _d !== void 0 ? _d : '');
+    return ['ios', 'tvos'].includes(platform.toLowerCase());
+}
+/**
+ * The scale between `screenshotBase64` and the driver's coordinates:
+ * 1 unless the driver uses points, then the screenshot's size over the
+ * window's. Throws when that can't be worked out on a driver that uses
+ * points, since a tap in pixels there lands in the wrong place.
+ */
+function screenScaleOf(driver, screenshotBase64) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!driverUsesPoints(driver))
+            return exports.SAME_SCALE;
+        const image = yield (0, sharp_1.default)(Buffer.from(screenshotBase64, 'base64'))
+            .metadata()
+            .catch((err) => {
+            throw new Error(`The screenshot's size could not be read: ${err.message}`);
+        });
+        const window = typeof driver.getWindowRect === 'function'
+            ? yield driver.getWindowRect()
+            : yield driver.getWindowSize();
+        const x = Number(image.width) / Number(window === null || window === void 0 ? void 0 : window.width);
+        const y = Number(image.height) / Number(window === null || window === void 0 ? void 0 : window.height);
+        if (!(Number.isFinite(x) && x > 0 && Number.isFinite(y) && y > 0)) {
+            throw new Error(`The screen size could not be worked out (screenshot ${image.width}x${image.height}, ` +
+                `window ${window === null || window === void 0 ? void 0 : window.width}x${window === null || window === void 0 ? void 0 : window.height}).`);
+        }
+        return { x, y };
+    });
+}
+/** A rect found in the screenshot, in the driver's coordinates. */
+function toDriverRect(rect, scale) {
+    if (scale.x === 1 && scale.y === 1)
+        return rect;
+    return {
+        x: rect.x / scale.x,
+        y: rect.y / scale.y,
+        width: rect.width / scale.x,
+        height: rect.height / scale.y,
+    };
+}

package/lib/src/services/recording/concurrency-gate.js

@@ -18,10 +18,19 @@ const config_1 = require("../../config");
  * and are NOT counted against this gate — they bypass it entirely.
  */
 let ConcurrencyGate = class ConcurrencyGate {
-    constructor(limit) {
-        var _a;
+    /**
+     * An explicit `limit` is fixed. Without one the gate follows
+     * `config.maxConcurrentRecordings` as it stands at each admission, not as it
+     * stood when the gate was built: the gate is created on first use, and the
+     * `maxConcurrentRecordings` option is applied at boot.
+     */
+    constructor(fixedLimit) {
+        this.fixedLimit = fixedLimit;
         this.active = new Set();
-        this.limit = (_a = limit !== null && limit !== void 0 ? limit : config_1.config.maxConcurrentRecordings) !== null && _a !== void 0 ? _a : 4;
+    }
+    get limit() {
+        var _a, _b;
+        return (_b = (_a = this.fixedLimit) !== null && _a !== void 0 ? _a : config_1.config.maxConcurrentRecordings) !== null && _b !== void 0 ? _b : 4;
     }
     /**
      * Atomic admission: either ALL recordingIds are admitted, or none are.

package/lib/src/services/settings/SelfHealingSwitch.js

@@ -0,0 +1,70 @@
+"use strict";
+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 __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.SelfHealingSwitch = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const web_config_service_1 = require("../../data-service/web-config-service");
+const labSettings_1 = require("./labSettings");
+/**
+ * Whether self-healing is on, for the command interceptor, which asks at every
+ * command and so must never read the database.
+ *
+ * The value saved on the Settings page (the `WebConfig` row `enableSelfHealing`)
+ * is kept here, loaded once at boot and replaced when `POST /config` saves it.
+ * The rule is the one every lab setting follows (`selfHealingEnabled`): the
+ * saved value, else the plugin option the server started with, else on. The
+ * interceptor passes the options it was given, so the startup half is always
+ * the live one.
+ *
+ * Through 2.13 the toggle was stored nowhere and the interceptor read the
+ * startup options alone, so switching healing off in the dashboard did nothing.
+ */
+let SelfHealingSwitch = class SelfHealingSwitch {
+    /** Whether a failed findElement goes on to the healing tiers, now. */
+    isEnabled(startup) {
+        return (0, labSettings_1.selfHealingEnabled)(startup.enableSelfHealing, this.saved);
+    }
+    /**
+     * Reads the saved value, once, at boot. A database that can't be read leaves
+     * the startup option in charge, as it does for the cleanup job, and is said
+     * once here rather than at every command.
+     */
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { enableSelfHealing } = yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig();
+                this.saved = typeof enableSelfHealing === 'boolean' ? enableSelfHealing : undefined;
+            }
+            catch (err) {
+                this.saved = undefined;
+                logger_1.default.warn(`Could not read the saved self-healing setting, using the startup option: ${err === null || err === void 0 ? void 0 : err.message}`);
+            }
+        });
+    }
+    /** What `POST /config` just saved, in force for the next command. */
+    set(saved) {
+        this.saved = saved;
+    }
+};
+exports.SelfHealingSwitch = SelfHealingSwitch;
+exports.SelfHealingSwitch = SelfHealingSwitch = __decorate([
+    (0, typedi_1.Service)()
+], SelfHealingSwitch);