@xenon-device-management/xenon 2.13.1 → 2.14.0

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

@@ -70,6 +70,7 @@ const ResilioTreeHealingProvider_1 = require("./ResilioTreeHealingProvider");
 const HealingMetrics_1 = require("./HealingMetrics");
 const attributes_1 = require("../telemetry/attributes");
 const xenonOptions_1 = require("../session/xenonOptions");
+const screenScale_1 = require("../omni-vision/screenScale");
 // §2.7 healing-tier capability gate. The tier numbering here is the
 // externally-facing capability contract (xe:options.healingTiers),
 // which is array-position based: providers[i] is tier i+1 (1=Resilio,
@@ -158,7 +159,10 @@ let HealingOrchestrator = class HealingOrchestrator {
                 span.addEvent('tier_started', { tier: provider.name });
                 try {
                     this.logger.info(`Attempting Tier ${provider.tier}: ${provider.name}...`);
-                    const result = yield provider.heal(context);
+                    let result = yield provider.heal(context);
+                    if (result === null || result === void 0 ? void 0 : result.rect) {
+                        result = yield this.rectInDriverCoordinates(result, result.rect, context, provider);
+                    }
                     HealingMetrics_1.HEALING_METRICS.record(provider.tier, provider.name, result ? 'success' : 'failure', Date.now() - tierStart);
                     if (result) {
                         this.logger.info(`✨ Provider ${provider.name} found a match! Confidence: ${(result.confidence * 100).toFixed(0)}%`);
@@ -267,6 +271,33 @@ let HealingOrchestrator = class HealingOrchestrator {
             return null;
         });
     }
+    /**
+     * The OCR and Visual AI tiers find the element in the screenshot, so their
+     * `rect` is in its pixels. The interceptor taps it, and asks iOS for the
+     * element there, in the driver's coordinates (points on iOS), so it is
+     * converted here. If that can't be worked out on iOS, a virtual element
+     * (only a position) is no use and the tier counts as failed; a real element
+     * the tier resolved keeps its id and loses only the rect.
+     */
+    rectInDriverCoordinates(result, rect, context, provider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const scale = yield (0, screenScale_1.screenScaleOf)(context.driver, (_a = context.screenshotBase64) !== null && _a !== void 0 ? _a : '');
+                return Object.assign(Object.assign({}, result), { rect: (0, screenScale_1.toDriverRect)(rect, scale) });
+            }
+            catch (err) {
+                const reason = (_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err;
+                if (!result.id.startsWith('healed_')) {
+                    this.logger.warn(`${provider.name}: the element's position is unknown (${reason}).`);
+                    return Object.assign(Object.assign({}, result), { rect: undefined });
+                }
+                this.logger.warn(`${provider.name} found the element in the screenshot, but not where it is on the ` +
+                    `screen (${reason}); trying the next tier.`);
+                return null;
+            }
+        });
+    }
 };
 exports.HealingOrchestrator = HealingOrchestrator;
 exports.HealingOrchestrator = HealingOrchestrator = __decorate([

package/lib/src/services/interceptor/AndroidProxyAdapter.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AndroidProxyAdapter = void 0;
+const xenonProxy_1 = require("../network/xenonProxy");
 class AndroidProxyAdapter {
     constructor(getAdb) {
         this.getAdb = getAdb;
@@ -38,6 +39,23 @@ class AndroidProxyAdapter {
             yield adb.adbExec(['-s', udid, 'shell', 'settings', 'put', 'global', 'http_proxy', ':0']);
         });
     }
+    /** The phone's global HTTP proxy as stored: `host:port`, or `null` / `:0` / '' for none. */
+    readProxy(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = yield this.getAdb(udid);
+            const out = yield adb.adbExec(['-s', udid, 'shell', 'settings', 'get', 'global', 'http_proxy']);
+            return String(out !== null && out !== void 0 ? out : '').trim();
+        });
+    }
+    /** Puts `previous` back as the phone's proxy, or clears it when there was none. */
+    restoreProxy(udid, previous) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (previous === null || (0, xenonProxy_1.isUnsetProxy)(previous))
+                return this.clearProxy(udid);
+            const adb = yield this.getAdb(udid);
+            yield adb.adbExec(['-s', udid, 'shell', 'settings', 'put', 'global', 'http_proxy', previous]);
+        });
+    }
     // Forwards a port on the device back to a port on the host over the adb transport
     // (USB or wireless adb). The device sees `127.0.0.1:devicePort` and that traffic
     // reaches the host's `hostPort`. This is the standard way to make a host-side

package/lib/src/services/interceptor/interceptorOptions.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInterceptorOptions = resolveInterceptorOptions;
+const XenonCapabilityManager_1 = require("../../XenonCapabilityManager");
+/**
+ * The network capture a session gets: its own capability (any of the shapes
+ * getXenonCapabilities reads) wins field by field, and the server's
+ * `interceptor` option fills in what the session leaves unset.
+ *
+ * - `enabled`: the session's, when it says true or false; else the server's;
+ *   else off.
+ * - `bufferSize`, `captureBodies`: the session's, else the server's, else the
+ *   service's defaults (1000, true).
+ * - `mocks`, `includeHosts`, `excludeHosts`: the session's only.
+ *
+ * `sessionCaps` is getXenonCapabilities' output, where a field the session
+ * didn't set is `undefined`.
+ */
+function resolveInterceptorOptions(sessionCaps, server) {
+    var _a;
+    const own = (key) => sessionCaps[key];
+    const enabled = own(XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED);
+    const bufferSize = own(XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_BUFFER_SIZE);
+    const captureBodies = own(XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_CAPTURE_BODIES);
+    return {
+        enabled: typeof enabled === 'boolean' ? enabled : (server === null || server === void 0 ? void 0 : server.enabled) === true,
+        bufferSize: (_a = positive(bufferSize)) !== null && _a !== void 0 ? _a : positive(server === null || server === void 0 ? void 0 : server.bufferSize),
+        captureBodies: typeof captureBodies === 'boolean'
+            ? captureBodies
+            : typeof (server === null || server === void 0 ? void 0 : server.captureBodies) === 'boolean'
+                ? server.captureBodies
+                : true,
+        mocks: listOr(own(XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_MOCKS)),
+        includeHosts: listOr(own(XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_INCLUDE_HOSTS)),
+        excludeHosts: listOr(own(XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_EXCLUDE_HOSTS)),
+    };
+}
+function positive(value) {
+    const n = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+    return typeof n === 'number' && Number.isFinite(n) && n > 0 ? n : undefined;
+}
+function listOr(value) {
+    return Array.isArray(value) ? value : [];
+}

package/lib/src/services/lease/activeLeases.js

@@ -0,0 +1,37 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.leaseKey = void 0;
+exports.activeLeasesByDevice = activeLeasesByDevice;
+exports.activeLeaseOn = activeLeaseOn;
+const prisma_1 = require("../../prisma");
+const leaseKey = (udid, host) => `${udid}@${host}`;
+exports.leaseKey = leaseKey;
+/** Every live lease, keyed by `leaseKey(udid, host)`. */
+function activeLeasesByDevice() {
+    return __awaiter(this, arguments, void 0, function* (db = prisma_1.prisma, now = Date.now()) {
+        const rows = yield db.lease.findMany({
+            where: { status: 'active', expiresAt: { gte: now } },
+            select: { id: true, deviceUdid: true, deviceHost: true, actorId: true },
+        });
+        return new Map(rows.map((l) => [(0, exports.leaseKey)(l.deviceUdid, l.deviceHost), l]));
+    });
+}
+/** The live lease on one phone, or null. */
+function activeLeaseOn(udid_1, host_1) {
+    return __awaiter(this, arguments, void 0, function* (udid, host, db = prisma_1.prisma, now = Date.now()) {
+        var _a;
+        return ((_a = (yield db.lease.findFirst({
+            where: { deviceUdid: udid, deviceHost: host, status: 'active', expiresAt: { gte: now } },
+            select: { id: true, deviceUdid: true, deviceHost: true, actorId: true },
+        }))) !== null && _a !== void 0 ? _a : null);
+    });
+}

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

@@ -0,0 +1,71 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidRadios = void 0;
+/**
+ * A phone's Wi-Fi and mobile data, through the resolved adb (`adbExec`: no
+ * shell, no bare `adb`).
+ */
+class AndroidRadios {
+    constructor(getAdb) {
+        this.getAdb = getAdb;
+    }
+    /**
+     * `wifi_on` is 1 or 2 when Wi-Fi is on (2: on in spite of airplane mode),
+     * 0 or 3 when it is off. `mobile_data` is 1 or 0. Anything else, or a read
+     * that fails, is null: "don't know".
+     */
+    read(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = yield this.getAdb(udid);
+            const get = (name) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const out = yield adb.adbExec(['-s', udid, 'shell', 'settings', 'get', 'global', name]);
+                    return String(out !== null && out !== void 0 ? out : '').trim();
+                }
+                catch (_a) {
+                    return null;
+                }
+            });
+            const wifi = yield get('wifi_on');
+            const data = yield get('mobile_data');
+            return {
+                wifiOn: wifi === '1' || wifi === '2' ? true : wifi === '0' || wifi === '3' ? false : null,
+                dataOn: data === '1' ? true : data === '0' ? false : null,
+            };
+        });
+    }
+    /** Mobile data, then Wi-Fi, off. */
+    turnOff(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adb = yield this.getAdb(udid);
+            yield adb.adbExec(['-s', udid, 'shell', 'svc', 'data', 'disable']);
+            yield adb.adbExec(['-s', udid, 'shell', 'svc', 'wifi', 'disable']);
+        });
+    }
+    /** Turns on the ones asked for; leaves the others as they are. */
+    turnOn(udid, which) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!which.data && !which.wifi)
+                return;
+            const adb = yield this.getAdb(udid);
+            if (which.data)
+                yield adb.adbExec(['-s', udid, 'shell', 'svc', 'data', 'enable']);
+            if (which.wifi)
+                yield adb.adbExec(['-s', udid, 'shell', 'svc', 'wifi', 'enable']);
+        });
+    }
+    /** What to turn back on after Offline: what was on, and what nobody knew about. */
+    static toRestore(prior) {
+        return { data: prior.dataOn !== false, wifi: prior.wifiOn !== false };
+    }
+}
+exports.AndroidRadios = AndroidRadios;

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

@@ -0,0 +1,184 @@
+"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.PhoneNetworkLedger = void 0;
+const typedi_1 = require("typedi");
+const async_lock_1 = __importDefault(require("async-lock"));
+const prisma_1 = require("../../prisma");
+const logger_1 = __importDefault(require("../../logger"));
+const PREFIX = 'phone-network:';
+/**
+ * Xenon's record of the network changes it made to its phones, kept until
+ * each is put back. In memory a session's changes are undone when it ends; a
+ * crash or a kill -9 forgets them, and the phone stays offline or pointed at
+ * a proxy nobody serves. At its next start the server reads this record and
+ * puts those phones back (PhoneNetworkRestore).
+ *
+ * Kept in this server's own database, which is what makes it this server's:
+ * a hub and a node on one machine see the same Android phones, but each has
+ * its own database. It has no table of its own: WebConfig is the database's
+ * key-value table (MetricsService keeps its counters there), and a new table
+ * would mean a migration and a regenerated client for a handful of rows. One
+ * row per session, `phone-network:<sessionId>`, holding the JSON above.
+ *
+ * A failed write is logged and never fails a session: the change is still
+ * made, and undone when the session ends; only a crash before then would
+ * leave it.
+ */
+let PhoneNetworkLedger = class PhoneNetworkLedger {
+    constructor() {
+        this.logger = logger_1.default.scope('PhoneNetwork');
+        this.lock = new async_lock_1.default();
+    }
+    /** Adds `part` to the session's record, creating the record if needed. */
+    note(sessionId, udid, part) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.guard(`record a network change for ${udid} (session ${sessionId})`, () => this.lock.acquire(sessionId, () => __awaiter(this, void 0, void 0, function* () {
+                const current = yield this.read(sessionId);
+                const next = Object.assign(Object.assign({}, (current !== null && current !== void 0 ? current : { sessionId, udid, at: Date.now() })), part);
+                yield this.write(next);
+            })));
+        });
+    }
+    /** The part was put back: drops it, and the record once nothing is left. */
+    settle(sessionId, part) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.guard(`settle the ${part} change of session ${sessionId}`, () => this.lock.acquire(sessionId, () => __awaiter(this, void 0, void 0, function* () {
+                const current = yield this.read(sessionId);
+                if (!current)
+                    return;
+                const next = Object.assign({}, current);
+                delete next[part];
+                if (next.offline || next.proxy)
+                    yield this.write(next);
+                else
+                    yield this.remove(sessionId);
+            })));
+        });
+    }
+    /** Drops the session's record, whatever it holds. */
+    forget(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.guard(`forget the network changes of session ${sessionId}`, () => this.lock.acquire(sessionId, () => this.remove(sessionId)));
+        });
+    }
+    /** The session's record, or null. */
+    get(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                return yield this.read(sessionId);
+            }
+            catch (err) {
+                this.logger.warn(`Could not read the phone network record: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                return null;
+            }
+        });
+    }
+    /** Every record, oldest first. A row that isn't a record is dropped. */
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let rows = [];
+            try {
+                rows = yield prisma_1.prisma.webConfig.findMany({
+                    where: { name: { startsWith: PREFIX } },
+                    select: { name: true, value: true },
+                });
+            }
+            catch (err) {
+                this.logger.warn(`Could not read the phone network record: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                return [];
+            }
+            const out = [];
+            for (const row of rows) {
+                const change = parseChange(row.value);
+                if (change)
+                    out.push(change);
+                else
+                    yield this.remove(row.name.slice(PREFIX.length)).catch(() => undefined);
+            }
+            return out.sort((a, b) => a.at - b.at);
+        });
+    }
+    read(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const row = yield prisma_1.prisma.webConfig.findUnique({ where: { name: PREFIX + sessionId } });
+            return row ? parseChange(row.value) : null;
+        });
+    }
+    write(change) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const name = PREFIX + change.sessionId;
+            const value = JSON.stringify(change);
+            yield prisma_1.prisma.webConfig.upsert({
+                where: { name },
+                update: { value },
+                create: { id: name, name, value },
+            });
+        });
+    }
+    remove(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield prisma_1.prisma.webConfig.deleteMany({ where: { name: PREFIX + sessionId } });
+        });
+    }
+    guard(what, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                yield fn();
+            }
+            catch (err) {
+                this.logger.warn(`Could not ${what}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+        });
+    }
+};
+exports.PhoneNetworkLedger = PhoneNetworkLedger;
+exports.PhoneNetworkLedger = PhoneNetworkLedger = __decorate([
+    (0, typedi_1.Service)()
+], PhoneNetworkLedger);
+function parseChange(value) {
+    try {
+        const v = JSON.parse(value);
+        if (!v || typeof v.sessionId !== 'string' || typeof v.udid !== 'string')
+            return null;
+        if (typeof v.at !== 'number')
+            return null;
+        const change = { sessionId: v.sessionId, udid: v.udid, at: v.at };
+        if (v.offline && typeof v.offline === 'object') {
+            change.offline = {
+                wifiOn: boolOrNull(v.offline.wifiOn),
+                dataOn: boolOrNull(v.offline.dataOn),
+            };
+        }
+        if (v.proxy && typeof v.proxy.set === 'string') {
+            change.proxy = Object.assign({ set: v.proxy.set, previous: typeof v.proxy.previous === 'string' ? v.proxy.previous : null }, (typeof v.proxy.reversePort === 'number' ? { reversePort: v.proxy.reversePort } : {}));
+        }
+        return change.offline || change.proxy ? change : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function boolOrNull(v) {
+    return typeof v === 'boolean' ? v : null;
+}