@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/src/services/NetworkConditioningService.js

@@ -1,43 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __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) {
@@ -54,6 +21,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NetworkConditioningService = void 0;
 const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../logger"));
+const adbForPhone_1 = require("./network/adbForPhone");
+const AndroidRadios_1 = require("./network/AndroidRadios");
+const PhoneNetworkLedger_1 = require("./network/PhoneNetworkLedger");
+const phoneNetworkLock_1 = require("./network/phoneNetworkLock");
 const NETWORK_PROFILES = {
     Normal: null,
     '4G': { latencyMs: 20, downloadKbps: 15000, uploadKbps: 7500 },
@@ -62,26 +33,47 @@ const NETWORK_PROFILES = {
     Offline: { latencyMs: 0, downloadKbps: 0, uploadKbps: 0 },
 };
 /**
- * Service to manage network conditioning (Throttling/Latency)
+ * A session's network profile (`xe:network_profile`).
+ *
+ * Every profile's delay is added to each of the session's commands by the
+ * session gateway (getLatency). On an Android phone `Offline` also turns
+ * mobile data and Wi-Fi off, and `Normal` turns them on; 4G, 3G and Edge
+ * change nothing on the phone. An iPhone, real or simulated, gets the delay
+ * only: Xcode has no command to change a simulator's network (`xcrun simctl`
+ * has no `network` subcommand in Xcode 26), and a real iPhone's can't be
+ * changed from a Mac.
+ *
+ * What `Offline` changed is undone when the session ends, however it ends
+ * (PhoneNetworkRestore), and written down meanwhile (PhoneNetworkLedger) so a
+ * restart can undo it after a crash.
  */
 let NetworkConditioningService = class NetworkConditioningService {
     constructor() {
         this.log = logger_1.default.scope('NetworkConditioning');
         this.activeConditions = new Map();
+        this.radios = new AndroidRadios_1.AndroidRadios(adbForPhone_1.adbForPhone);
+        this.toldAboutIPhones = false;
     }
     /**
      * Applies a network profile to a session/device
      */
     applyProfile(sessionId, device, profile) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             this.log.info(`Applying network profile '${profile}' to session ${sessionId} on device ${device.udid}`);
-            this.activeConditions.set(sessionId, profile);
-            // Platform specific optimizations
-            if (device.platform === 'android') {
-                yield this.applyAndroidConditioning(device.udid, profile);
+            const condition = { profile, device };
+            this.activeConditions.set(sessionId, condition);
+            if (((_a = device.platform) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'android') {
+                if (profile === 'Offline')
+                    yield this.takeOffline(sessionId, condition);
+                else if (profile === 'Normal')
+                    yield this.turnOnline(device.udid);
+                // 4G, 3G and Edge: the delay only.
             }
-            else if (device.deviceType === 'simulator') {
-                yield this.applyIOSSimulatorConditioning(device.udid, profile);
+            else if (!this.toldAboutIPhones) {
+                this.toldAboutIPhones = true;
+                this.log.info('Network profiles on iPhones and iOS simulators only delay each command: the ' +
+                    "device's own network isn't changed, so Offline leaves it online.");
             }
         });
     }
@@ -89,70 +81,75 @@ let NetworkConditioningService = class NetworkConditioningService {
      * Gets the active profile for a session
      */
     getProfile(sessionId) {
-        return this.activeConditions.get(sessionId);
+        var _a;
+        return (_a = this.activeConditions.get(sessionId)) === null || _a === void 0 ? void 0 : _a.profile;
+    }
+    /** Whether the session has a profile on this server. */
+    has(sessionId) {
+        return this.activeConditions.has(sessionId);
+    }
+    /** The sessions with a profile on this server. */
+    sessionIds() {
+        return [...this.activeConditions.keys()];
     }
     /**
-     * Resets network conditions for a session
+     * Ends the session's profile and undoes what it changed on the phone, once:
+     * the entry is taken before anything is awaited, so a second call finds
+     * nothing to do. A phone that can't be reached keeps its record in the
+     * ledger, and is put back at its next session or this server's next start.
      */
-    reset(sessionId, device) {
+    reset(sessionId) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.activeConditions.has(sessionId)) {
-                this.log.info(`Resetting network conditions for session ${sessionId}`);
-                this.activeConditions.delete(sessionId);
-                if (device.platform === 'android') {
-                    yield this.applyAndroidConditioning(device.udid, 'Normal');
+            const condition = this.activeConditions.get(sessionId);
+            if (!condition)
+                return;
+            this.activeConditions.delete(sessionId);
+            this.log.info(`Resetting network conditions for session ${sessionId}`);
+            const prior = condition.offlinePrior;
+            if (!prior)
+                return;
+            const udid = condition.device.udid;
+            yield (0, phoneNetworkLock_1.withPhoneNetworkLock)(udid, () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.radios.turnOn(udid, AndroidRadios_1.AndroidRadios.toRestore(prior));
+                    yield typedi_1.Container.get(PhoneNetworkLedger_1.PhoneNetworkLedger).settle(sessionId, 'offline');
+                    this.log.info(`📱 Android: network put back on ${udid} after session ${sessionId}`);
                 }
-                else if (device.deviceType === 'simulator') {
-                    yield this.applyIOSSimulatorConditioning(device.udid, 'Normal');
+                catch (e) {
+                    this.log.warn(`⚠️ Could not put the network back on ${udid} after session ${sessionId}: ${e === null || e === void 0 ? void 0 : e.message}. ` +
+                        "Xenon tries again at the phone's next session and when it restarts.");
                 }
-            }
+            }));
         });
     }
-    applyAndroidConditioning(udid, profile) {
+    takeOffline(sessionId, condition) {
         return __awaiter(this, void 0, void 0, function* () {
+            const udid = condition.device.udid;
             try {
-                const { exec } = yield Promise.resolve().then(() => __importStar(require('child_process')));
-                const { promisify } = yield Promise.resolve().then(() => __importStar(require('util')));
-                const execAsync = promisify(exec);
-                if (profile === 'Offline') {
-                    this.log.info(`📱 Android: Disabling data for ${udid}`);
-                    yield execAsync(`adb -s ${udid} shell svc data disable`);
-                    yield execAsync(`adb -s ${udid} shell svc wifi disable`);
-                }
-                else if (profile === 'Normal') {
-                    this.log.info(`📱 Android: Enabling data for ${udid}`);
-                    yield execAsync(`adb -s ${udid} shell svc data enable`);
-                    yield execAsync(`adb -s ${udid} shell svc wifi enable`);
-                }
-                // Latency is handled by the proxy
+                yield (0, phoneNetworkLock_1.withPhoneNetworkLock)(udid, () => __awaiter(this, void 0, void 0, function* () {
+                    const prior = yield this.radios.read(udid);
+                    // Written down before the change: a crash after it must still find it.
+                    yield typedi_1.Container.get(PhoneNetworkLedger_1.PhoneNetworkLedger).note(sessionId, udid, { offline: prior });
+                    condition.offlinePrior = prior;
+                    this.log.info(`📱 Android: turning mobile data and Wi-Fi off on ${udid}`);
+                    yield this.radios.turnOff(udid);
+                }));
             }
             catch (e) {
-                this.log.warn(`⚠️ Failed to apply Android conditioning for ${udid}: ${e.message}`);
+                this.log.warn(`⚠️ Failed to apply Android conditioning for ${udid}: ${e === null || e === void 0 ? void 0 : e.message}`);
             }
         });
     }
-    applyIOSSimulatorConditioning(udid, profile) {
+    turnOnline(udid) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const { exec } = yield Promise.resolve().then(() => __importStar(require('child_process')));
-                const { promisify } = yield Promise.resolve().then(() => __importStar(require('util')));
-                const execAsync = promisify(exec);
-                // simctl network <device> <status>
-                // Profiles: wifi, 3g, edge, etc. (depends on OS version)
-                let status = 'none';
-                if (profile === '3G')
-                    status = '3g';
-                if (profile === 'Edge')
-                    status = 'edge';
-                if (profile === 'Offline')
-                    status = 'off';
-                if (profile === 'Normal')
-                    status = 'none';
-                this.log.info(`🍎 iOS Sim: Setting network to ${status} for ${udid}`);
-                yield execAsync(`xcrun simctl network ${udid} status ${status}`);
+                yield (0, phoneNetworkLock_1.withPhoneNetworkLock)(udid, () => __awaiter(this, void 0, void 0, function* () {
+                    this.log.info(`📱 Android: turning mobile data and Wi-Fi on on ${udid}`);
+                    yield this.radios.turnOn(udid, { data: true, wifi: true });
+                }));
             }
             catch (e) {
-                this.log.warn(`⚠️ Failed to apply iOS Simulator conditioning for ${udid}: ${e.message}`);
+                this.log.warn(`⚠️ Failed to apply Android conditioning for ${udid}: ${e === null || e === void 0 ? void 0 : e.message}`);
             }
         });
     }
@@ -161,10 +158,10 @@ let NetworkConditioningService = class NetworkConditioningService {
      */
     getLatency(sessionId) {
         var _a;
-        const profile = this.activeConditions.get(sessionId);
-        if (!profile)
+        const condition = this.activeConditions.get(sessionId);
+        if (!condition)
             return 0;
-        return ((_a = NETWORK_PROFILES[profile]) === null || _a === void 0 ? void 0 : _a.latencyMs) || 0;
+        return ((_a = NETWORK_PROFILES[condition.profile]) === null || _a === void 0 ? void 0 : _a.latencyMs) || 0;
     }
 };
 exports.NetworkConditioningService = NetworkConditioningService;

package/lib/src/services/NotificationService.js

@@ -26,9 +26,14 @@ const axios_1 = __importDefault(require("axios"));
 const logger_1 = __importDefault(require("../logger"));
 const prisma_service_1 = require("../data-service/prisma-service");
 const typedi_1 = require("typedi");
+const webhookEvents_1 = require("./webhookEvents");
+/** How many sessions' failure notices are remembered, so a session ending twice sends once. */
+const NOTIFIED_SESSIONS_KEPT = 2000;
 let NotificationService = class NotificationService {
     constructor(prisma) {
         this.prisma = prisma;
+        /** Sessions whose failure was sent, oldest first (a Set keeps insertion order). */
+        this.notifiedSessions = new Set();
     }
     getConfigs() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -72,31 +77,41 @@ let NotificationService = class NotificationService {
         });
     }
     /**
-     * Sends a sample event to a webhook the way a real one would be sent, and
-     * fails if the delivery does: "Send test" used to say it worked whatever
-     * happened, and ignored the webhook's type.
+     * Tells the webhooks subscribed to `session_failed` that a session failed.
+     *
+     * Once per session however many times it ends: a driver crash and the
+     * client's own delete both end it, as do a heartbeat timeout and a delete.
+     * Remembered by id in memory, so a restart forgets it, which is harmless:
+     * a session does not end again after one.
+     */
+    notifySessionFailed(session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.notifiedSessions.has(session.id))
+                return;
+            this.notifiedSessions.add(session.id);
+            if (this.notifiedSessions.size > NOTIFIED_SESSIONS_KEPT) {
+                const oldest = this.notifiedSessions.values().next().value;
+                this.notifiedSessions.delete(oldest);
+            }
+            yield this.dispatchEvent('session_failed', (0, webhookEvents_1.sessionFailedPayload)(session));
+        });
+    }
+    /**
+     * Sends a sample of `event` to a webhook the way a real one would be sent,
+     * and fails if the delivery does: "Send test" used to say it worked
+     * whatever happened, and ignored the webhook's type and template.
      */
     sendTest(url_1) {
-        return __awaiter(this, arguments, void 0, function* (url, type = 'slack', payloadTemplate) {
-            yield this.sendToWebhook({ url, type, payloadTemplate: payloadTemplate !== null && payloadTemplate !== void 0 ? payloadTemplate : null }, 'device_new', { udid: 'test-device-udid', name: 'Test Device', host: '127.0.0.1' });
+        return __awaiter(this, arguments, void 0, function* (url, type = 'slack', payloadTemplate, event = 'device_new') {
+            yield this.sendToWebhook({ url, type, payloadTemplate: payloadTemplate !== null && payloadTemplate !== void 0 ? payloadTemplate : null }, event, webhookEvents_1.WEBHOOK_EVENTS[event].sample());
         });
     }
     /** Delivers one event. Throws when the webhook refuses or can't be reached. */
     sendToWebhook(config, eventType, payload) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Principal Logic: Use custom template if defined
+            // A custom template, if there is one, replaces the built-in message.
             if (config.payloadTemplate) {
-                const substitutedBody = this.substituteTemplate(config.payloadTemplate, Object.assign({ eventType }, payload));
-                // JSON if the template renders to JSON, otherwise sent as text. Only
-                // the parse may fall back: one catch around both used to post again,
-                // as text, when the JSON delivery itself failed.
-                let body;
-                try {
-                    body = JSON.parse(substitutedBody);
-                }
-                catch (_a) {
-                    body = { text: substitutedBody };
-                }
+                const body = (0, webhookEvents_1.renderTemplate)(config.payloadTemplate, Object.assign({ eventType }, payload));
                 yield axios_1.default.post(config.url, body);
                 return;
             }
@@ -109,17 +124,6 @@ let NotificationService = class NotificationService {
             }
         });
     }
-    // Principal Logic: Recursive variable substitution with {{key}} support
-    substituteTemplate(template, data) {
-        return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
-            const keys = key.trim().split('.');
-            let value = data;
-            for (const k of keys) {
-                value = value ? value[k] : undefined;
-            }
-            return value !== undefined ? String(value) : match;
-        });
-    }
     sendSlackMessage(url, eventType, payload) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
@@ -131,7 +135,10 @@ let NotificationService = class NotificationService {
                     color = '#ff0000';
                     break;
                 case 'session_failed':
-                    text = `❌ *Session Failed*: ${payload.sessionId}\nReason: ${payload.failureReason}`;
+                    text =
+                        `❌ *Session Failed*: ${payload.sessionId}\n` +
+                            `Reason: ${payload.failureReason || 'no reason recorded'}\n` +
+                            `Device: ${payload.deviceName || payload.udid} (${payload.udid})`;
                     color = '#ff0000';
                     break;
                 case 'device_new':

package/lib/src/services/OrphanSweeper.js

@@ -25,6 +25,8 @@ const logger_1 = __importDefault(require("../logger"));
 const event_manager_1 = require("../dashboard/event-manager");
 const SessionStatus_1 = require("../types/SessionStatus");
 const device_service_1 = require("../data-service/device-service");
+const PhoneNetworkRestore_1 = require("./network/PhoneNetworkRestore");
+const sessionMemory_1 = require("../sessions/sessionMemory");
 let OrphanSweeper = class OrphanSweeper {
     constructor() {
         this.log = logger_1.default.scope('OrphanSweeper');
@@ -69,6 +71,11 @@ let OrphanSweeper = class OrphanSweeper {
                             endTime: new Date(),
                         },
                     });
+                    // A session this process still drove has its phone's network put
+                    // back before the phone is released; for a previous process's it is
+                    // the ledger's, at boot (PhoneNetworkRestore).
+                    yield typedi_1.Container.get(PhoneNetworkRestore_1.PhoneNetworkRestore).restoreSession(s.id, 'heartbeat timeout');
+                    (0, sessionMemory_1.forgetSessionMemory)(s.id);
                     // This session's claim only, not every row with its udid: the phone
                     // may be another session's by now (deviceClaims.ts).
                     yield (0, device_service_1.releaseSessionDevices)(s.id);

package/lib/src/services/PortAllocator.js

@@ -55,6 +55,11 @@ let PortAllocator = class PortAllocator {
     configure(overrides) {
         this.ranges = Object.assign(Object.assign({}, DEFAULT_RANGES), overrides);
     }
+    /** The ports leased for `purpose`, first and last included. */
+    rangeOf(purpose) {
+        const [start, end] = this.ranges[purpose];
+        return [start, end];
+    }
     acquire(purpose_1, udid_1) {
         return __awaiter(this, arguments, void 0, function* (purpose, udid, opts = {}) {
             var _a;

package/lib/src/services/SelectorVerificationJob.js

@@ -32,8 +32,11 @@ const selectorKeys_1 = require("./selector-health/selectorKeys");
 const log = logger_1.default.scope('SelectorVerification');
 /**
  * Threshold of distinct clean build_ids required to promote a Pending
- * SelectorState row to Resolved. "Clean" means at least one findElement
- * for the (strategy, selector) tuple ran in the build with no heal.
+ * SelectorState row to Resolved. "Clean" means the selector was found without
+ * healing in the build: a findElement of the (strategy, selector) tuple that
+ * answered an element, or a findElements that answered at least one, and no
+ * heal of it. Through 2.14 a find that failed outright counted too, so a
+ * selector that was never found again was verified as fixed.
  */
 const CLEAN_BUILDS_TO_RESOLVE = 3;
 /**
@@ -127,12 +130,20 @@ let SelectorVerificationJob = class SelectorVerificationJob {
             // that ran under a CI build (build_id IS NOT NULL); ad-hoc local runs
             // intentionally don't move verification forward.
             //
+            // A find that found the selector is one that didn't fail (`is_error`,
+            // the dashboard's record of an error answer) and didn't answer an empty
+            // list (`{"value":[]`, findElements finding nothing). The command log
+            // keeps the answer as JSON.stringify wrote it, or as the node sent it.
+            //
             // Identifier names (PascalCase tables, camelCase createdAt) match the
             // actual SQLite schema generated by Prisma — see
             // `sqlite3 prisma/dev.db ".schema SessionLog"`.
             const heals = yield this.prisma.$queryRaw `
       SELECT s."build_id" AS build_id,
-             MAX(CASE WHEN sl."is_healed" THEN 1 ELSE 0 END) AS healed
+             MAX(CASE WHEN sl."is_healed" THEN 1 ELSE 0 END) AS healed,
+             MAX(CASE WHEN NOT sl."is_healed" AND NOT sl."is_error"
+                       AND sl."response" NOT LIKE '{"value":[]%'
+                      THEN 1 ELSE 0 END) AS found
       FROM "SessionLog" sl
       INNER JOIN "Session" s ON sl."session_id" = s."id"
       WHERE sl."original_strategy" = ${row.original_strategy}
@@ -142,7 +153,7 @@ let SelectorVerificationJob = class SelectorVerificationJob {
         AND s."build_id" IS NOT NULL
       GROUP BY s."build_id"
     `;
-            const cleanBuildCount = heals.filter((r) => Number(r.healed) === 0).length;
+            const cleanBuildCount = heals.filter((r) => Number(r.healed) === 0 && Number(r.found) === 1).length;
             if (cleanBuildCount >= CLEAN_BUILDS_TO_RESOLVE) {
                 yield this.promoteToResolved(row);
             }

package/lib/src/services/ServerManager.js

@@ -78,9 +78,13 @@ 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 aiEngineSettings_1 = require("./settings/aiEngineSettings");
 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 +133,17 @@ 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();
+            // The AI engine page's provider, model and base URL, over the startup
+            // options applied above (what a cleared value goes back to).
+            yield typedi_1.Container.get(aiEngineSettings_1.AiEngineSettings).load();
             this.registerRoutes(expressApp, httpServer, cliArgs, pluginArgs);
             yield this.bootEmulators(pluginArgs);
             this.registerDependenciesInContainer(pluginArgs, cliArgs, nodeId);
@@ -258,6 +269,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 +280,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 +327,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,14 +389,19 @@ 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();
+            typedi_1.Container.get(EmailService_1.EmailService).warnAboutPublicUrl();
             const { startUserSessionCleanupCron } = yield Promise.resolve().then(() => __importStar(require('./identity/sessionCleanupCron')));
             startUserSessionCleanupCron();
             // Hub-issued JWT signing key (REST/MCP tokens, stream tickets) — key
@@ -390,7 +450,12 @@ let ServerManager = ServerManager_1 = class ServerManager {
         });
     }
     registerRoutes(expressApp, httpServer, cliArgs, pluginArgs) {
-        expressApp.use('/xenon', (0, app_1.createRouter)(pluginArgs));
+        expressApp.use('/xenon', (0, app_1.createRouter)(pluginArgs, {
+            address: cliArgs.address,
+            port: cliArgs.port,
+            // Appium serves HTTPS with both of these (base-driver's server()).
+            tls: !!(cliArgs.sslCertificatePath && cliArgs.sslKeyPath),
+        }));
         // The session gateway goes in front of Appium's routes: Xenon's own
         // /wd-internal calls (with the per-process secret), per-command auth
         // (XENON_REQUIRE_COMMAND_AUTH), then, on a hub, forwarding of the sessions
@@ -417,16 +482,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) {