@xenon-device-management/xenon 2.13.2 → 2.14.0

package/lib/src/services/ServerManager.js

@@ -78,9 +78,12 @@ const package_json_1 = __importDefault(require("../../package.json"));
 const IPluginArgs_1 = require("../interfaces/IPluginArgs");
 const config_service_1 = require("../data-service/config-service");
 const PluginContext_1 = require("../PluginContext");
+const SelfHealingSwitch_1 = require("./settings/SelfHealingSwitch");
 const device_store_1 = require("../data-service/device-store");
 const device_utils_1 = require("../device-utils");
 const localDeviceHosts_1 = require("../device-managers/localDeviceHosts");
+const deviceSettings_1 = require("../data-service/deviceSettings");
+const PhoneNetworkRestore_1 = require("./network/PhoneNetworkRestore");
 const app_1 = require("../app");
 const registerCommandAuth_1 = require("../app/registerCommandAuth");
 const defaultGateway_1 = require("../gateway/defaultGateway");
@@ -129,10 +132,14 @@ let ServerManager = ServerManager_1 = class ServerManager {
                 this.logger.warn('Authentication is DISABLED — every /xenon/api caller is treated as a ' +
                     'synthetic SUPER_ADMIN. Local development only.');
             }
+            this.applyRecordingOptions(pluginArgs);
             yield this.syncDatabaseAndAIConfig(pluginArgs);
             yield this.initializeCoreSubsystems(pluginArgs, cliArgs.port);
             // Before anything below starts go-ios: the reap would kill it too.
             yield this.reapLeftoverGoIos();
+            // The Settings page's AI self-healing toggle, which the command interceptor
+            // reads from memory at every command: load it before a command can arrive.
+            yield typedi_1.Container.get(SelfHealingSwitch_1.SelfHealingSwitch).load();
             this.registerRoutes(expressApp, httpServer, cliArgs, pluginArgs);
             yield this.bootEmulators(pluginArgs);
             this.registerDependenciesInContainer(pluginArgs, cliArgs, nodeId);
@@ -258,6 +265,9 @@ let ServerManager = ServerManager_1 = class ServerManager {
             yield (0, device_utils_1.updateDeviceList)(localHosts, pluginArgs.hub, pluginArgs.tlsRejectUnauthorized);
             // remove stale devices
             yield (0, device_utils_1.removeStaleDevices)(localHosts, pluginArgs.tlsRejectUnauthorized);
+            // In the background: put back the network a previous run left changed on
+            // this server's phones (an Offline profile, an interceptor proxy).
+            void this.cleanUpPhoneNetworks(localHosts, nodeId);
             this.logger.info(`🚀 Xenon will be served at http://${pluginArgs.bindHostOrIp}:${cliArgs.port}/xenon with id ${nodeId}`);
             this.logger.info('You can provide the following URLs to access Xenon:');
             for (const url of (0, networkAddresses_1.listReachableBaseUrls)(cliArgs.port)) {
@@ -266,6 +276,29 @@ let ServerManager = ServerManager_1 = class ServerManager {
             }
         });
     }
+    /**
+     * What a previous run of this server left on its phones' network: the
+     * changes its ledger holds, and on this server's own Android phones a proxy
+     * that points at a capture port of this machine where nothing answers.
+     * Each change is logged. A phone not connected now is put back at its next
+     * session here, or at the next start.
+     */
+    cleanUpPhoneNetworks(localHosts, nodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const devices = yield device_store_1.DeviceStoreFactory.getStore().getAllDevices();
+                const androids = devices
+                    .filter((d) => { var _a; return ((_a = d.platform) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'android' && !d.cloud; })
+                    .filter((d) => (0, localDeviceHosts_1.isOwnDevice)(localHosts, nodeId, d))
+                    .map((d) => d.udid);
+                yield typedi_1.Container.get(PhoneNetworkRestore_1.PhoneNetworkRestore).cleanUpAtBoot([...new Set(androids)]);
+            }
+            catch (err) {
+                this.logger.warn(`Could not check the phones' network settings: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+        });
+    }
     resolvePluginArgs(cliArgs) {
         return __awaiter(this, void 0, void 0, function* () {
             const pluginConfigs = cliArgs.plugin;
@@ -290,6 +323,24 @@ let ServerManager = ServerManager_1 = class ServerManager {
             return pluginArgs;
         });
     }
+    /**
+     * `maxConcurrentRecordings` and `recordingsAssetsPath` are schema options,
+     * but only their environment variables ever reached `config`. Apply the
+     * options now (option, else the variable, else the default) before the
+     * artifact store is built from the path and the recordings router first
+     * reads the cap. See `recordingConfigFrom`.
+     */
+    applyRecordingOptions(pluginArgs) {
+        const envCap = process.env.XENON_MAX_CONCURRENT_RECORDINGS;
+        const applied = (0, config_1.recordingConfigFrom)(pluginArgs);
+        if (pluginArgs.maxConcurrentRecordings === undefined &&
+            (envCap === null || envCap === void 0 ? void 0 : envCap.trim()) &&
+            Number(envCap) !== applied.maxConcurrentRecordings) {
+            this.logger.warn(`Ignoring XENON_MAX_CONCURRENT_RECORDINGS=${JSON.stringify(envCap)}: ` +
+                `it must be a whole number of at least 1. The cap is ${applied.maxConcurrentRecordings}.`);
+        }
+        (0, config_1.updateConfig)(applied);
+    }
     syncDatabaseAndAIConfig(pluginArgs) {
         return __awaiter(this, void 0, void 0, function* () {
             const { updateConfig } = yield Promise.resolve().then(() => __importStar(require('../config')));
@@ -334,11 +385,15 @@ let ServerManager = ServerManager_1 = class ServerManager {
     }
     initializeCoreSubsystems(pluginArgs, port) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Before anything opens the database: the URL must suit the database
+            // client this install was built with (SQLite for the published plugin).
+            const { assertSupportedDatabase } = yield Promise.resolve().then(() => __importStar(require('../scripts/database-check')));
+            assertSupportedDatabase();
             yield (0, device_utils_1.initializeStorage)();
             const { runMigrations } = yield Promise.resolve().then(() => __importStar(require('../scripts/run-migrations')));
             yield runMigrations();
             // A hub keeps its nodes' phones: the sessions on them outlive its restart.
-            yield device_store_1.DeviceStoreFactory.getStore().clearStorage((0, localDeviceHosts_1.devicesClearedAtBoot)(pluginArgs, (0, localDeviceHosts_1.localDeviceHosts)(pluginArgs, port)));
+            yield (0, deviceSettings_1.resetDevicesAtBoot)(device_store_1.DeviceStoreFactory.getStore(), pluginArgs, (0, localDeviceHosts_1.localDeviceHosts)(pluginArgs, port));
             const { bootstrapIdentity } = yield Promise.resolve().then(() => __importStar(require('./identity/bootstrap')));
             yield bootstrapIdentity();
             typedi_1.Container.get(EmailService_1.EmailService).warnIfLogFallbackEnabled();
@@ -417,16 +472,47 @@ let ServerManager = ServerManager_1 = class ServerManager {
                 `${router.describeAppiumPath()}.`);
         }
     }
+    /**
+     * Boot the emulators `emulators` lists, with each one's launch options.
+     *
+     * An iOS-only server, or one told to use real Android devices only
+     * (`androidDeviceType: real`, which discovery would then ignore them for),
+     * boots none. Anything else boots them, `platform: both` included: it used
+     * to boot only when `platform` named Android, so with the default it did
+     * nothing. A boot that fails is logged and the rest go on: an emulator that
+     * won't start must not keep the server from coming up with the phones it
+     * has, and with `both` counted this step now runs on many more servers.
+     */
     bootEmulators(pluginArgs) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (pluginArgs.emulators &&
-                pluginArgs.emulators.length > 0 &&
-                pluginArgs.platform.toLowerCase().includes('android')) {
-                this.logger.info('Emulators will be booted!!');
-                const adb = yield appium_adb_1.ADB.createADB({});
-                const array = pluginArgs.emulators || [];
-                yield Promise.all(array.map((arr) => adb.launchAVD(arr.avdName, arr)));
+            const emulators = pluginArgs.emulators || [];
+            if (emulators.length === 0)
+                return;
+            const platform = String(pluginArgs.platform).toLowerCase();
+            if (platform === 'ios') {
+                this.logger.warn(`Not booting the ${emulators.length} configured emulator(s): platform is ios.`);
+                return;
+            }
+            if (pluginArgs.androidDeviceType === 'real') {
+                this.logger.warn(`Not booting the ${emulators.length} configured emulator(s): androidDeviceType is real.`);
+                return;
             }
+            this.logger.info(`Booting ${emulators.length} configured emulator(s)...`);
+            let adb;
+            try {
+                adb = yield appium_adb_1.ADB.createADB({});
+            }
+            catch (err) {
+                this.logger.warn(`Not booting the configured emulators: no usable adb (${err === null || err === void 0 ? void 0 : err.message}).`);
+                return;
+            }
+            const results = yield Promise.allSettled(emulators.map((emulator) => adb.launchAVD(emulator.avdName, emulator)));
+            results.forEach((result, index) => {
+                var _a, _b;
+                if (result.status === 'rejected') {
+                    this.logger.warn(`Could not boot emulator ${emulators[index].avdName}: ${(_b = (_a = result.reason) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : result.reason}`);
+                }
+            });
         });
     }
     registerDependenciesInContainer(pluginArgs, cliArgs, nodeId) {

package/lib/src/services/SessionLifecycleService.js

@@ -98,6 +98,8 @@ const SessionStatus_1 = require("../types/SessionStatus");
 const SessionType_1 = __importDefault(require("../enums/SessionType"));
 const async_lock_1 = __importDefault(require("async-lock"));
 const base_driver_1 = require("@appium/base-driver");
+const PhoneNetworkRestore_1 = require("./network/PhoneNetworkRestore");
+const interceptorOptions_1 = require("./interceptor/interceptorOptions");
 /**
  * How long the hub waits for a node (or cloud provider) to create a session.
  * A create is sent once (InternalRequestConfig `retry: false`): the node may
@@ -877,26 +879,11 @@ let SessionLifecycleService = class SessionLifecycleService {
     applyPostSessionLogic(session, caps, device) {
         return __awaiter(this, void 0, void 0, function* () {
             const context = typedi_1.Container.get(PluginContext_1.PluginContext);
-            const networkProfile = caps[XenonCapabilityManager_1.XENON_CAPABILITIES.NETWORK_PROFILE];
-            if (networkProfile) {
-                const { NetworkConditioningService } = yield Promise.resolve().then(() => __importStar(require('./NetworkConditioningService')));
-                yield typedi_1.Container.get(NetworkConditioningService).applyProfile(session.getId(), device, networkProfile);
-            }
-            if (caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_ENABLED]) {
-                try {
-                    const { InterceptorService } = yield Promise.resolve().then(() => __importStar(require('./InterceptorService')));
-                    yield typedi_1.Container.get(InterceptorService).start(session.getId(), device, {
-                        enabled: true,
-                        bufferSize: caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_BUFFER_SIZE],
-                        captureBodies: caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_CAPTURE_BODIES] !== false,
-                        mocks: caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_MOCKS] || [],
-                        includeHosts: caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_INCLUDE_HOSTS] || [],
-                        excludeHosts: caps[XenonCapabilityManager_1.XENON_CAPABILITIES.INTERCEPTOR_EXCLUDE_HOSTS] || [],
-                    });
-                }
-                catch (err) {
-                    this.logger.warn(`🕸️ Failed to start interceptor for ${session.getId()}: ${err.message}`);
-                }
+            // Only the server that drives the phone changes its network: a node
+            // applies its own sessions' profile and interceptor, and a hub that did
+            // it too ran its own adb against the node's phone.
+            if (session.getType() === SessionType_1.default.LOCAL) {
+                yield this.applySessionNetwork(session.getId(), caps, device, context.pluginArgs);
             }
             const isDashboardEnabled = !!context.pluginArgs.enableDashboard;
             const shouldSaveLogs = session.getType() !== SessionType_1.default.CLOUD;
@@ -930,6 +917,36 @@ let SessionLifecycleService = class SessionLifecycleService {
             }
         });
     }
+    /**
+     * The session's network profile and network capture, on a phone this
+     * server drives. First what an earlier session left on the phone and
+     * couldn't put back is undone, so this session starts from the phone's own
+     * settings and records those as the ones to put back. Each ending undoes
+     * these through PhoneNetworkRestore.
+     */
+    applySessionNetwork(sessionId, caps, device, pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (((_a = device.platform) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'android') {
+                yield typedi_1.Container.get(PhoneNetworkRestore_1.PhoneNetworkRestore).restoreLeftovers({ udid: device.udid });
+            }
+            const networkProfile = caps[XenonCapabilityManager_1.XENON_CAPABILITIES.NETWORK_PROFILE];
+            if (networkProfile) {
+                const { NetworkConditioningService } = yield Promise.resolve().then(() => __importStar(require('./NetworkConditioningService')));
+                yield typedi_1.Container.get(NetworkConditioningService).applyProfile(sessionId, device, networkProfile);
+            }
+            const interceptor = (0, interceptorOptions_1.resolveInterceptorOptions)(caps, pluginArgs.interceptor);
+            if (interceptor.enabled) {
+                try {
+                    const { InterceptorService } = yield Promise.resolve().then(() => __importStar(require('./InterceptorService')));
+                    yield typedi_1.Container.get(InterceptorService).start(sessionId, device, interceptor);
+                }
+                catch (err) {
+                    this.logger.warn(`🕸️ Failed to start interceptor for ${sessionId}: ${err.message}`);
+                }
+            }
+        });
+    }
     /**
      * The row a hub keeps for a session it routes to a node or a cloud when the
      * dashboard's own (onSessionStarted) isn't written: with the dashboard off,
@@ -1097,6 +1114,10 @@ let SessionLifecycleService = class SessionLifecycleService {
             // which releases ports and archives video twice.
             if (sessionId) {
                 yield sessionCleanupLock.acquire(sessionId, () => __awaiter(this, void 0, void 0, function* () {
+                    // The phone's network (profile, interceptor proxy) and the capture,
+                    // before the phone is released to the next session. Whether or not
+                    // SESSION_MANAGER holds the session.
+                    yield typedi_1.Container.get(PhoneNetworkRestore_1.PhoneNetworkRestore).restoreSession(sessionId, 'session deleted');
                     yield (0, device_service_1.releaseSessionDevices)(sessionId);
                     this.logger.info(`📱 Unblocking the device that is blocked for session ${sessionId}`);
                     const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
@@ -1137,37 +1158,10 @@ let SessionLifecycleService = class SessionLifecycleService {
                             // Another concurrent deleteSession already cleaned up.
                             return;
                         }
-                        const device = session.getDevice();
-                        try {
-                            const { NetworkConditioningService } = yield Promise.resolve().then(() => __importStar(require('./NetworkConditioningService')));
-                            yield typedi_1.Container.get(NetworkConditioningService).reset(sessionId, device);
-                        }
-                        catch (resetErr) {
-                            this.logger.warn(`⚠️ NetworkConditioningService.reset failed for session ${sessionId}: ${resetErr.message}`);
-                        }
-                        try {
-                            const { InterceptorService } = yield Promise.resolve().then(() => __importStar(require('./InterceptorService')));
-                            const interceptor = typedi_1.Container.get(InterceptorService);
-                            if (interceptor.isActive(sessionId))
-                                yield interceptor.stop(sessionId);
-                        }
-                        catch (interceptorErr) {
-                            this.logger.warn(`⚠️ InterceptorService.stop failed for session ${sessionId}: ${interceptorErr.message}`);
-                        }
+                        // The phone's network was put back before it was released (above).
                         yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(sessionId, status, reason);
                         SessionManager_1.SESSION_MANAGER.removeSession(sessionId);
                         typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).forget(sessionId);
-                        try {
-                            const { getSessionById } = yield Promise.resolve().then(() => __importStar(require('../dashboard/services/session-service')));
-                            const sessionData = yield getSessionById(sessionId);
-                            if (sessionData && (sessionData.status === 'failed' || sessionData.failure_reason)) {
-                                const { NotificationService } = yield Promise.resolve().then(() => __importStar(require('./NotificationService')));
-                                yield typedi_1.Container.get(NotificationService).dispatchEvent('session_failed', sessionData);
-                            }
-                        }
-                        catch (err) {
-                            /* ignore notification errors */
-                        }
                     }));
                 }
             }
@@ -1240,6 +1234,7 @@ let SessionLifecycleService = class SessionLifecycleService {
     stopSessionForShutdown(sessionId, reason) {
         return __awaiter(this, void 0, void 0, function* () {
             yield sessionCleanupLock.acquire(sessionId, () => __awaiter(this, void 0, void 0, function* () {
+                yield typedi_1.Container.get(PhoneNetworkRestore_1.PhoneNetworkRestore).restoreSession(sessionId, reason);
                 try {
                     yield (0, device_service_1.releaseSessionDevices)(sessionId);
                 }
@@ -1258,7 +1253,10 @@ let SessionLifecycleService = class SessionLifecycleService {
                     }
                 }
                 try {
-                    yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(sessionId, SessionStatus_1.SessionStatus.FAILED, reason);
+                    // A shutdown fails the sessions it drains; no test caused it, so no webhook.
+                    yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(sessionId, SessionStatus_1.SessionStatus.FAILED, reason, {
+                        notify: false,
+                    });
                 }
                 catch (err) {
                     this.logger.warn(`[shutdown] onSessionStopped failed for ${sessionId}: ${err.message}`);

package/lib/src/services/ShutdownCoordinator.js

@@ -24,6 +24,7 @@ const logger_1 = __importDefault(require("../logger"));
 const SessionManager_1 = require("../sessions/SessionManager");
 const SessionLifecycleService_1 = require("./SessionLifecycleService");
 const SessionType_1 = __importDefault(require("../enums/SessionType"));
+const PhoneNetworkRestore_1 = require("./network/PhoneNetworkRestore");
 // Graceful shutdown phase that runs BEFORE the existing infrastructure
 // teardown in index.ts:cleanup(). Active sessions get a bounded chance to
 // archive their video + release ports + mark themselves failed, so we don't
@@ -57,6 +58,7 @@ let ShutdownCoordinator = class ShutdownCoordinator {
             const sessions = SessionManager_1.SESSION_MANAGER.getAllSessions().filter((session) => session.getType() === SessionType_1.default.LOCAL);
             if (sessions.length === 0) {
                 this.logger.info('No active sessions to drain');
+                yield this.restorePhoneNetworks(timeoutMs);
                 return { attempted: 0, completed: 0 };
             }
             this.logger.info(`Draining ${sessions.length} active session(s) (overall=${timeoutMs}ms, per-session=${perSessionTimeoutMs}ms)`);
@@ -84,10 +86,41 @@ let ShutdownCoordinator = class ShutdownCoordinator {
             }));
             const results = yield Promise.allSettled(tasks);
             const completed = results.filter((r) => r.status === 'fulfilled' && r.value).length;
+            yield this.restorePhoneNetworks(Math.max(0, deadline - Date.now()));
             this.logger.info(`Drain complete: ${completed}/${sessions.length} session(s) finalized`);
             return { attempted: sessions.length, completed };
         });
     }
+    /**
+     * The network of every phone a session of this server still has changed
+     * (profile, interceptor proxy), sessions SESSION_MANAGER doesn't hold
+     * included, within what is left of the budget. A shutdown that never gets
+     * here (Appium exits on SIGTERM first) leaves it to the next start, from
+     * the ledger (PhoneNetworkRestore.cleanUpAtBoot).
+     */
+    restorePhoneNetworks(budgetMs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (budgetMs <= 0)
+                return;
+            let timer;
+            try {
+                yield Promise.race([
+                    typedi_1.Container.get(PhoneNetworkRestore_1.PhoneNetworkRestore).restoreAll('Xenon is shutting down'),
+                    new Promise((resolve) => {
+                        timer = setTimeout(resolve, budgetMs);
+                    }),
+                ]);
+            }
+            catch (err) {
+                this.logger.warn(`[shutdown] Putting phone networks back failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        });
+    }
 };
 exports.ShutdownCoordinator = ShutdownCoordinator;
 exports.ShutdownCoordinator = ShutdownCoordinator = __decorate([

package/lib/src/services/TeamService.js

@@ -52,20 +52,37 @@ let TeamService = class TeamService {
     delete(id) {
         return __awaiter(this, void 0, void 0, function* () {
             // Apps too: App.teamId is onDelete SetNull, so deleting a team that owns
-            // apps would quietly share them with every member.
-            const [devices, members, apps] = yield Promise.all([
+            // apps would quietly share them with every member. So is a phone's saved
+            // team (DeviceSetting): a phone of the team that is not connected now
+            // would come back in the shared pool.
+            const [connected, saved, members, apps] = yield Promise.all([
                 prisma_1.prisma.device.count({ where: { teamId: id } }),
+                prisma_1.prisma.deviceSetting.findMany({ where: { teamId: id }, select: { udid: true, host: true } }),
                 prisma_1.prisma.teamMember.count({ where: { teamId: id } }),
                 prisma_1.prisma.app.count({ where: { teamId: id } }),
             ]);
+            const away = yield this.notConnected(saved);
+            const devices = connected + away;
             if (devices > 0 || members > 0 || apps > 0) {
-                throw new Error(`Team still has ${devices} device(s), ${members} member(s) and ${apps} app(s). Reassign them before deleting.`);
+                const phones = away > 0 ? `${devices} device(s) (${away} not connected now)` : `${devices} device(s)`;
+                throw new Error(`Team still has ${phones}, ${members} member(s) and ${apps} app(s). Reassign them before deleting.`);
             }
             // Clear teamId on any (revoked) ApiKey rows so the FK doesn't block delete.
             yield prisma_1.prisma.apiKey.updateMany({ where: { teamId: id }, data: { teamId: null } });
             yield prisma_1.prisma.team.delete({ where: { id } });
         });
     }
+    /** How many of these saved phones have no Device row: not connected now. */
+    notConnected(saved) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (saved.length === 0)
+                return 0;
+            const here = yield prisma_1.prisma.device.count({
+                where: { OR: saved.map(({ udid, host }) => ({ udid, host })) },
+            });
+            return saved.length - here;
+        });
+    }
     listMembers(teamId) {
         return __awaiter(this, void 0, void 0, function* () {
             const rows = yield prisma_1.prisma.teamMember.findMany({

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/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;