@xenon-device-management/xenon 2.13.1 → 2.14.0

package/lib/src/services/AIService.js

@@ -46,6 +46,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AI_SERVICE = exports.AIService = void 0;
+exports.parseVisualVerdict = parseVisualVerdict;
 const generative_ai_1 = require("@google/generative-ai");
 const openai_1 = __importDefault(require("openai"));
 const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
@@ -55,6 +56,41 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const config_1 = require("../config");
 const CircuitBreaker_1 = require("./CircuitBreaker");
+/** What GeminiProvider answers, instead of throwing, when the provider is rate-limited (429). */
+const RATE_LIMITED = 'CONNECTION_OK_RATE_LIMITED';
+/**
+ * A provider's answer to the assertion prompt, `{ "result": true|false,
+ * "reason": "..." }`, read leniently (code fences, text around the JSON,
+ * `message` for `reason`, "true"/"false" as strings) but never guessed: null
+ * when it holds no true/false `result`.
+ */
+function parseVisualVerdict(answer) {
+    const text = answer.replace(/```(?:json)?/gi, '').trim();
+    const start = text.indexOf('{');
+    const end = text.lastIndexOf('}');
+    if (start === -1 || end <= start)
+        return null;
+    let data;
+    try {
+        data = JSON.parse(text.slice(start, end + 1));
+    }
+    catch (_a) {
+        return null;
+    }
+    const raw = data === null || data === void 0 ? void 0 : data.result;
+    const result = raw === true || raw === 'true' ? true : raw === false || raw === 'false' ? false : null;
+    if (result === null)
+        return null;
+    const reason = typeof data.reason === 'string'
+        ? data.reason
+        : typeof data.message === 'string'
+            ? data.message
+            : '';
+    return {
+        result,
+        message: reason.trim() || (result ? 'The condition holds.' : 'The condition does not hold.'),
+    };
+}
 class GeminiProvider {
     constructor(apiKey, modelName) {
         this.genAI = new generative_ai_1.GoogleGenerativeAI(apiKey.trim());
@@ -365,6 +401,69 @@ Fix: Add a pre-emptive check for the location permission dialog or use the \`aut
             }
         });
     }
+    /**
+     * Asks the provider whether `condition` holds on the screenshot
+     * (`xenon: assertVisualState`). Answers only with the provider's own
+     * verdict: with no provider, a failed call, a rate limit or an answer that
+     * isn't true or false it throws, saying the condition was not checked. A
+     * `false` there would pass a test asserting that something is absent.
+     */
+    assertVisual(screenshotBase64, condition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.initializeProvider();
+            const notChecked = 'so the condition was not checked';
+            if (!this.provider) {
+                throw new Error(`No AI provider is configured, ${notChecked}. Set XENON_AI_PROVIDER and the provider's key.`);
+            }
+            const prompt = `
+You are checking a screenshot of a mobile app for an automated test.
+
+Condition: ${JSON.stringify(condition)}
+
+Is the condition true of what the screenshot shows? Judge only what is visible on the screen.
+Answer with JSON only, exactly: {"result": true or false, "reason": "one sentence on what you see"}
+        `.trim();
+            let answer;
+            try {
+                answer = yield this.callProvider(prompt, screenshotBase64);
+            }
+            catch (err) {
+                throw new Error(`The AI provider failed, ${notChecked}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+            if (answer === RATE_LIMITED) {
+                throw new Error(`The AI provider is rate-limited, ${notChecked}. Try again later.`);
+            }
+            const verdict = parseVisualVerdict(answer);
+            if (!verdict) {
+                const said = answer.replace(/\s+/g, ' ').trim().slice(0, 200);
+                throw new Error(`Xenon could not read the AI provider's answer as true or false, ${notChecked}. ` +
+                    `It answered: ${JSON.stringify(said)}`);
+            }
+            return verdict;
+        });
+    }
+    /**
+     * A short description of the screen in the screenshot, for
+     * `xenon: analyzeScreen` and device control's Omni-Scan. Throws when there
+     * is no provider or the call fails, so the caller can say why there is none.
+     */
+    describeScreen(screenshotBase64) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.initializeProvider();
+            if (!this.provider)
+                throw new Error('No AI provider is configured');
+            const prompt = `
+You are looking at a screenshot of a mobile app, for a software tester.
+Describe the screen in a few short sentences: which screen it is, its main elements and their state (for example filled in, empty, selected or disabled), and anything unexpected, such as an error message, a system dialog, a crash or a loading indicator.
+Describe only what is visible. Answer in plain text.
+        `.trim();
+            const answer = yield this.callProvider(prompt, screenshotBase64);
+            if (answer === RATE_LIMITED)
+                throw new Error('The AI provider is rate-limited');
+            return answer;
+        });
+    }
     /**
      * Heals a broken locator using deep LLM reasoning (Tier 5)
      */

package/lib/src/services/CleanupService.js

@@ -25,6 +25,7 @@ const logger_1 = __importDefault(require("../logger"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../config");
+const labSettings_1 = require("./settings/labSettings");
 const recordingCleanup_1 = require("./recording/recordingCleanup");
 /** Subdirectory holding composite (multi-device) outputs, keyed by group id. */
 const GROUPS_DIR = '_groups';
@@ -34,6 +35,8 @@ let CleanupService = class CleanupService {
     }
     /**
      * Orchestrates build + session + recording cleanup based on retention policy.
+     * The build retention window, the build cap and the asset purge are the ones
+     * saved on the dashboard's Maintenance page, else `pluginArgs`'.
      *
      * Phases:
      *  1. Purge old builds (by age AND count cap) together with their sessions.
@@ -44,7 +47,9 @@ let CleanupService = class CleanupService {
      */
     runCleanup(pluginArgs) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { buildCleanupDays = 30, buildCleanupMaxCount = 100, deleteBuildAssets = true, } = pluginArgs;
+            // What the Maintenance page saved wins over the startup options, and is
+            // read here, at each run, so a change needs no restart. See labSettings.ts.
+            const { buildCleanupDays, buildCleanupMaxCount, deleteBuildAssets } = yield (0, labSettings_1.loadEffectiveSettings)(pluginArgs);
             this.log.info(`Starting cleanup: Retention = ${buildCleanupDays} days, Max Builds = ${buildCleanupMaxCount}, Purge Assets = ${deleteBuildAssets}`);
             const expirationDate = new Date();
             expirationDate.setDate(expirationDate.getDate() - buildCleanupDays);

package/lib/src/services/InterceptorService.js

@@ -72,6 +72,10 @@ const SessionArchive_1 = require("./interceptor/SessionArchive");
 const PortAllocator_1 = require("./PortAllocator");
 const SocketServer_1 = require("./SocketServer");
 const SocketEvents_1 = require("../enums/SocketEvents");
+const adbForPhone_1 = require("./network/adbForPhone");
+const PhoneNetworkLedger_1 = require("./network/PhoneNetworkLedger");
+const phoneNetworkLock_1 = require("./network/phoneNetworkLock");
+const xenonProxy_1 = require("./network/xenonProxy");
 const DEFAULT_BUFFER_CAP = 1000;
 const BODY_SPILL_THRESHOLD = 1024 * 1024;
 let InterceptorService = class InterceptorService {
@@ -88,6 +92,10 @@ let InterceptorService = class InterceptorService {
     isActive(sessionId) {
         return this.states.has(sessionId);
     }
+    /** The sessions whose traffic is captured on this server. */
+    sessionIds() {
+        return [...this.states.keys()];
+    }
     start(sessionId, device, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;
@@ -143,7 +151,7 @@ let InterceptorService = class InterceptorService {
             catch (err) {
                 this.logger.warn(`Cert install (${installMode}) failed for ${device.udid}: ${err.message}. HTTPS interception may not work.`);
             }
-            yield adapter.setProxy(device.udid, host, port);
+            const previousProxy = yield this.pointPhoneAtProxy(sessionId, device.udid, host, port, routing.reverseEstablished);
             const state = {
                 sessionId,
                 device,
@@ -155,6 +163,7 @@ let InterceptorService = class InterceptorService {
                 certInstalledFilename: certFilename,
                 startedAt: Date.now(),
                 reverseEstablished: routing.reverseEstablished,
+                previousProxy,
             };
             this.states.set(sessionId, state);
             this.emit({ type: 'session_started', sessionId, port, host }, device.udid);
@@ -167,12 +176,7 @@ let InterceptorService = class InterceptorService {
             if (!state)
                 return;
             this.states.delete(sessionId);
-            try {
-                yield this.getAndroidAdapter().clearProxy(state.device.udid);
-            }
-            catch (err) {
-                this.logger.warn(`Clear proxy failed for ${state.device.udid}: ${err.message}`);
-            }
+            yield this.putPhoneProxyBack(state);
             if (state.reverseEstablished) {
                 try {
                     yield this.getAndroidAdapter().removeReverse(state.device.udid, state.port);
@@ -284,15 +288,68 @@ let InterceptorService = class InterceptorService {
             requests: state.buffer.list(),
         };
     }
+    /**
+     * Points the whole phone at the session's proxy, and returns the proxy the
+     * phone had (null: none) for stop() to put back. The change is written down
+     * before it is made, so a restart after a crash can undo it
+     * (PhoneNetworkLedger, PhoneNetworkRestore).
+     *
+     * A previous proxy that is a capture an earlier run left behind (this
+     * machine, a capture port, nothing answering) is not the phone's own: it
+     * counts as none, so the end of this session doesn't put a dead proxy back.
+     */
+    pointPhoneAtProxy(sessionId, udid, host, port, reverseEstablished) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const adapter = this.getAndroidAdapter();
+            const setting = `${host}:${port}`;
+            return yield (0, phoneNetworkLock_1.withPhoneNetworkLock)(udid, () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                let previous = null;
+                try {
+                    const read = yield adapter.readProxy(udid);
+                    const leftover = read === setting ||
+                        (yield (0, xenonProxy_1.isDeadCaptureProxy)(read, typedi_1.Container.get(PortAllocator_1.PortAllocator).rangeOf('proxy')));
+                    if (leftover) {
+                        this.logger.info(`[${sessionId}] ${udid} had a proxy left by an earlier capture (${read})`);
+                    }
+                    previous = (0, xenonProxy_1.isUnsetProxy)(read) || leftover ? null : read;
+                }
+                catch (err) {
+                    this.logger.warn(`Could not read the proxy of ${udid}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+                }
+                yield typedi_1.Container.get(PhoneNetworkLedger_1.PhoneNetworkLedger).note(sessionId, udid, {
+                    proxy: Object.assign({ set: setting, previous }, (reverseEstablished ? { reversePort: port } : {})),
+                });
+                yield adapter.setProxy(udid, host, port);
+                return previous;
+            }));
+        });
+    }
+    /**
+     * Puts back the proxy the phone had before the session. A phone that can't
+     * be reached keeps the change written down, and is put back at its next
+     * session or at this server's next start.
+     */
+    putPhoneProxyBack(state) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const udid = state.device.udid;
+            yield (0, phoneNetworkLock_1.withPhoneNetworkLock)(udid, () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                try {
+                    yield this.getAndroidAdapter().restoreProxy(udid, state.previousProxy);
+                    yield typedi_1.Container.get(PhoneNetworkLedger_1.PhoneNetworkLedger).settle(state.sessionId, 'proxy');
+                }
+                catch (err) {
+                    this.logger.warn(`Could not put back the proxy of ${udid} after session ${state.sessionId}: ` +
+                        `${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}. Xenon tries again at the phone's next session and when it restarts.`);
+                }
+            }));
+        });
+    }
     getAndroidAdapter() {
         if (this.androidAdapter)
             return this.androidAdapter;
-        const provider = (udid) => __awaiter(this, void 0, void 0, function* () {
-            const { default: AndroidDeviceManager } = yield Promise.resolve().then(() => __importStar(require('../device-managers/AndroidDeviceManager')));
-            const mgr = typedi_1.Container.get(AndroidDeviceManager);
-            return yield mgr.getAdbForDevice(udid);
-        });
-        this.androidAdapter = new AndroidProxyAdapter_1.AndroidProxyAdapter(provider);
+        this.androidAdapter = new AndroidProxyAdapter_1.AndroidProxyAdapter(adbForPhone_1.adbForPhone);
         return this.androidAdapter;
     }
     // Establishes how the device will reach the host-side MITM proxy.

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,7 @@ 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");
 let OrphanSweeper = class OrphanSweeper {
     constructor() {
         this.log = logger_1.default.scope('OrphanSweeper');
@@ -69,6 +70,10 @@ 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');
                     // 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;