@xenon-device-management/xenon 2.16.0 → 2.17.1

package/lib/test/unit/install-scripts.spec.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const root = path_1.default.join(__dirname, '..', '..');
+const readJson = (file) => JSON.parse(fs_1.default.readFileSync(file, 'utf8'));
+/**
+ * npm 12 runs a dependency's install scripts only when the project installing
+ * it allows them (`allowScripts` in its package.json), and skips the rest with
+ * a warning. Appium installs a plugin with npm into its own home, whose
+ * package.json allows nothing, so every install script in Xenon's tree is
+ * skipped there and `appium plugin install` still reports success.
+ *
+ * Through 2.17 passwords were hashed with `bcrypt`, whose native binary only
+ * its `install` script downloads. Installed with npm 12, the plugin then
+ * failed to load: "Cannot find module .../bcrypt/lib/binding/napi-v3/bcrypt_lib.node".
+ *
+ * Each package here has an install script and works without it, for the
+ * reason given, checked with npm 12. A new one needs its own reason, checked
+ * the same way, or a replacement that needs no script.
+ */
+const WORKS_WITHOUT_ITS_SCRIPT = {
+    '@ffmpeg-installer/*': 'chmod u+x ffmpeg: every platform package ships ffmpeg executable already',
+    '@prisma/client': 'generates the default client in node_modules/.prisma; Xenon imports its own (src/generated/client)',
+    '@prisma/engines': "downloads Prisma's engines: the schema engine is fetched on its first use at startup, " +
+        'and the generated client carries its query engines',
+    '@scarf/scarf': "swagger-ui-dist's install analytics",
+    'appium-chromedriver': 'downloads a Chromedriver; Xenon downloads its own when needed (ChromeDriverManager)',
+    prisma: 'warns about incompatible older Prisma packages',
+    protobufjs: 'warns about a dependent pinned to another version scheme',
+    sharp: 'checks for its prebuilt binary, which comes in an @img/sharp-* package with no script',
+    'tesseract.js': 'prints an Open Collective notice',
+};
+const matches = (key, name) => key.endsWith('/*') ? name.startsWith(key.slice(0, -1)) : name === key;
+const nameOf = (id) => id.slice(0, id.lastIndexOf('@'));
+/** Where Node would find `name` from `from`: its node_modules, then each parent's. */
+function packageDir(name, from) {
+    for (let dir = from;; dir = path_1.default.dirname(dir)) {
+        const candidate = path_1.default.join(dir, 'node_modules', name, 'package.json');
+        if (fs_1.default.existsSync(candidate))
+            return path_1.default.dirname(candidate);
+        if (path_1.default.dirname(dir) === dir)
+            return undefined;
+    }
+}
+/**
+ * Every package Xenon runs with (its dependencies, theirs, and so on, as
+ * installed) that has an install script: `preinstall`, `install` or
+ * `postinstall`, or a `binding.gyp`, which npm builds with `node-gyp rebuild`
+ * when no script says otherwise. An optional dependency for another platform
+ * isn't installed, and is left out.
+ */
+function packagesWithInstallScripts() {
+    const found = new Map();
+    const seen = new Set();
+    const runtimeDeps = (pkg) => Object.keys(Object.assign(Object.assign({}, pkg.dependencies), pkg.optionalDependencies));
+    const queue = runtimeDeps(readJson(path_1.default.join(root, 'package.json'))).map((name) => ({
+        name,
+        from: root,
+    }));
+    for (let next = queue.shift(); next; next = queue.shift()) {
+        const { name, from } = next;
+        const dir = packageDir(name, from);
+        if (!dir || seen.has(dir))
+            continue;
+        seen.add(dir);
+        const pkg = readJson(path_1.default.join(dir, 'package.json'));
+        const scripts = ['preinstall', 'install', 'postinstall']
+            .filter((hook) => { var _a; return (_a = pkg.scripts) === null || _a === void 0 ? void 0 : _a[hook]; })
+            .map((hook) => `${hook}: ${pkg.scripts[hook]}`);
+        if (scripts.length === 0 && fs_1.default.existsSync(path_1.default.join(dir, 'binding.gyp'))) {
+            scripts.push('binding.gyp: node-gyp rebuild');
+        }
+        if (scripts.length > 0)
+            found.set(`${pkg.name}@${pkg.version}`, scripts.join(' | '));
+        queue.push(...runtimeDeps(pkg).map((dep) => ({ name: dep, from: dir })));
+    }
+    return found;
+}
+describe('install scripts in the runtime dependency tree', () => {
+    const found = packagesWithInstallScripts();
+    const keys = Object.keys(WORKS_WITHOUT_ITS_SCRIPT);
+    it('belong only to packages that work without them, since npm 12 skips them', () => {
+        const unexplained = [...found]
+            .filter(([id]) => !keys.some((key) => matches(key, nameOf(id))))
+            .map(([id, scripts]) => `${id} (${scripts})`);
+        (0, chai_1.expect)(unexplained).to.deep.equal([]);
+    });
+    it('name no package the tree no longer has', () => {
+        const names = [...found.keys()].map(nameOf);
+        const stale = keys.filter((key) => !names.some((name) => matches(key, name)));
+        (0, chai_1.expect)(stale).to.deep.equal([]);
+    });
+});

package/lib/test/unit/interceptor/CertManager.spec.js

@@ -46,6 +46,9 @@ const chai_1 = require("chai");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const sinon = __importStar(require("sinon"));
 const node_forge_1 = require("node-forge");
 const CertManager_1 = require("../../../src/services/interceptor/CertManager");
 describe('CertManager', () => {
@@ -98,4 +101,90 @@ describe('CertManager', () => {
         (0, chai_1.expect)(fname).to.match(/^[0-9a-f]{8}\.0$/);
         (0, chai_1.expect)(typeof ca.subjectHash).to.equal('string');
     }));
+    describe('serial number', () => {
+        // The serial was Date.now() in hex padded to 16 digits: always 00 00 01 ...,
+        // an INTEGER with illegal leading zeros. OpenSSL 3 (Node's included), Go
+        // and BoringSSL refuse such a certificate outright.
+        it('is a CA OpenSSL can load', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ca = yield new CertManager_1.CertManager(dir).ensure();
+            (0, chai_1.expect)(() => new crypto_1.X509Certificate(fs.readFileSync(ca.certPath))).to.not.throw();
+        }));
+        it('is positive, minimally encoded and at least 64 random bits', () => __awaiter(void 0, void 0, void 0, function* () {
+            const ca = yield new CertManager_1.CertManager(dir).ensure();
+            const serial = new crypto_1.X509Certificate(fs.readFileSync(ca.certPath)).serialNumber;
+            const first = parseInt(serial.slice(0, 2), 16);
+            (0, chai_1.expect)(first, 'no leading zero byte').to.be.greaterThan(0);
+            (0, chai_1.expect)(first, 'not negative').to.be.lessThan(0x80);
+            (0, chai_1.expect)(serial.length / 2)
+                .to.be.at.least(8)
+                .and.at.most(20);
+        }));
+        it('differs between two CAs generated in the same millisecond', () => __awaiter(void 0, void 0, void 0, function* () {
+            const other = fs.mkdtempSync(path.join(os.tmpdir(), 'xenon-cert-'));
+            const clock = sinon.useFakeTimers({ now: 1760000000000, toFake: ['Date'] });
+            try {
+                const a = yield new CertManager_1.CertManager(dir).ensure();
+                const b = yield new CertManager_1.CertManager(other).ensure();
+                (0, chai_1.expect)(new crypto_1.X509Certificate(fs.readFileSync(a.certPath)).serialNumber).to.not.equal(new crypto_1.X509Certificate(fs.readFileSync(b.certPath)).serialNumber);
+            }
+            finally {
+                clock.restore();
+                fs.rmSync(other, { recursive: true, force: true });
+            }
+        }));
+        it('replaces a CA an earlier version wrote with the bad serial', () => __awaiter(void 0, void 0, void 0, function* () {
+            writeCa(dir, '000001a10d75af19');
+            const ca = yield new CertManager_1.CertManager(dir).ensure();
+            (0, chai_1.expect)(() => new crypto_1.X509Certificate(fs.readFileSync(ca.certPath))).to.not.throw();
+        }));
+        it('keeps a CA OpenSSL can load', () => __awaiter(void 0, void 0, void 0, function* () {
+            writeCa(dir, '1a10d75af19a2b3c');
+            const before = fs.readFileSync(path.join(dir, 'certs', 'ca.pem'), 'utf8');
+            yield new CertManager_1.CertManager(dir).ensure();
+            (0, chai_1.expect)(fs.readFileSync(path.join(dir, 'certs', 'ca.pem'), 'utf8')).to.equal(before);
+        }));
+    });
+    describe('Android file name', () => {
+        // Android looks a system CA up by <subject_hash_old>.0. The name was
+        // openssl's, else a SHA-1 of the PEM, which names no certificate: with the
+        // bad serial openssl couldn't load the CA, so the fallback always ran.
+        it("is OpenSSL's subject_hash_old, with no openssl binary on the PATH", function () {
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    (0, child_process_1.execFileSync)('openssl', ['version'], { stdio: 'ignore' });
+                }
+                catch (_a) {
+                    this.skip();
+                }
+                const ca = yield new CertManager_1.CertManager(dir).ensure();
+                const expected = (0, child_process_1.execFileSync)('openssl', ['x509', '-inform', 'PEM', '-subject_hash_old', '-noout', '-in', ca.certPath], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+                (0, chai_1.expect)(ca.subjectHash).to.equal(expected);
+                const pathBefore = process.env.PATH;
+                process.env.PATH = '';
+                try {
+                    (0, chai_1.expect)(new CertManager_1.CertManager(dir).androidCertFilename()).to.equal(`${expected}.0`);
+                }
+                finally {
+                    process.env.PATH = pathBefore;
+                }
+            });
+        });
+    });
 });
+function writeCa(dir, serialHex) {
+    fs.mkdirSync(path.join(dir, 'certs'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'keys'), { recursive: true });
+    const keys = node_forge_1.pki.rsa.generateKeyPair(1024);
+    const cert = node_forge_1.pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+    cert.serialNumber = serialHex;
+    cert.validity.notBefore = new Date(Date.now() - 60000);
+    cert.validity.notAfter = new Date(Date.now() + 365 * 24 * 3600000);
+    const attrs = [{ name: 'commonName', value: 'Xenon MITM Root CA' }];
+    cert.setSubject(attrs);
+    cert.setIssuer(attrs);
+    cert.setExtensions([{ name: 'basicConstraints', cA: true, critical: true }]);
+    cert.sign(keys.privateKey, node_forge_1.md.sha256.create());
+    fs.writeFileSync(path.join(dir, 'certs', 'ca.pem'), node_forge_1.pki.certificateToPem(cert), 'utf8');
+    fs.writeFileSync(path.join(dir, 'keys', 'ca.private.key'), node_forge_1.pki.privateKeyToPem(keys.privateKey));
+}

package/lib/test/unit/internal-call.spec.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
+const http_1 = __importDefault(require("http"));
 const path_1 = __importDefault(require("path"));
 const sinon_1 = __importDefault(require("sinon"));
 const express_1 = __importDefault(require("express"));
@@ -166,6 +167,104 @@ describe('internal calls (/wd-internal with the per-process secret)', () => {
                 }
                 (0, chai_1.expect)(ran).to.deep.equal([]);
             }));
+            /**
+             * The plugin's handle, deep inside Appium's route, is never given the
+             * request, so an accepted call's context is how it knows the command
+             * is Xenon's own and not the test's.
+             */
+            describe('the plugin can tell an internal call from a test’s command', () => {
+                let seen;
+                let release;
+                function labSeeing() {
+                    return __awaiter(this, void 0, void 0, function* () {
+                        seen = [];
+                        release = undefined;
+                        const app = makeExpress();
+                        app.use(express_1.default.json());
+                        // A route that, like Appium's, answers after awaiting the driver.
+                        app.get('/wd/hub/session/:sessionId/source', (req, res) => __awaiter(this, void 0, void 0, function* () {
+                            if (req.query.hold)
+                                yield new Promise((resolve) => (release = resolve));
+                            yield new Promise((resolve) => setTimeout(resolve, 5));
+                            seen.push({ url: req.originalUrl, inside: (0, internalCall_1.isInsideInternalCall)() });
+                            res.json({ value: '<page/>' });
+                        }));
+                        (0, registerCommandAuth_1.registerCommandAuth)(app, { basePath: '/wd/hub' }, {
+                            enabled: () => false,
+                            authDisabled: () => false,
+                            verifier: new commandCaller_1.CommandCallerVerifier({
+                                verifyKeyPair: sinon_1.default.stub().resolves(null),
+                                verifyBearer: sinon_1.default.stub().resolves(null),
+                            }),
+                            ownerOf,
+                            logger: { info: () => undefined, warn: () => undefined, error: () => undefined },
+                        });
+                        app.use((_req, res) => res.status(404).json(UNKNOWN_ROUTE));
+                        return loopback.serve(app);
+                    });
+                }
+                it('inside an accepted call, across the route’s awaits', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const app = yield labSeeing();
+                    yield (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/wd-internal/session/s1/source')
+                        .set((0, internalCall_1.internalCallHeaders)());
+                    (0, chai_1.expect)(seen).to.deep.equal([{ url: '/wd/hub/session/s1/source', inside: true }]);
+                    (0, chai_1.expect)((0, internalCall_1.isInsideInternalCall)(), 'outside any request').to.equal(false);
+                }));
+                it('never for a test’s command, a refused call, or a request after one', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const app = yield labSeeing();
+                    yield (0, loopbackRequest_1.default)(app).get('/wd/hub/session/s1/source').set((0, internalCall_1.internalCallHeaders)());
+                    yield (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/wd-internal/session/s1/source')
+                        .set((0, internalCall_1.internalCallHeaders)())
+                        .expect(200);
+                    yield (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/wd-internal/session/s1/source')
+                        .set(internalCall_1.INTERNAL_CALL_HEADER, 'not-the-secret')
+                        .expect(404);
+                    yield (0, loopbackRequest_1.default)(app).get('/wd/hub/session/s1/source').expect(200);
+                    (0, chai_1.expect)(seen.map((s) => s.inside)).to.deep.equal([false, true, false]);
+                }));
+                it('never for a request on the same kept-alive connection after one', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const server = yield labSeeing();
+                    const port = server.address().port;
+                    const agent = new http_1.default.Agent({ keepAlive: true, maxSockets: 1 });
+                    const get = (path, headers) => new Promise((resolve, reject) => {
+                        const req = http_1.default.get({ host: '127.0.0.1', port, path, headers, agent }, (res) => {
+                            res.resume();
+                            res.on('end', () => resolve(req.reusedSocket));
+                        });
+                        req.on('error', reject);
+                    });
+                    try {
+                        yield get('/wd/hub/wd-internal/session/s1/source', (0, internalCall_1.internalCallHeaders)());
+                        (0, chai_1.expect)(yield get('/wd/hub/session/s1/source', {}), 'the socket was reused').to.equal(true);
+                    }
+                    finally {
+                        agent.destroy();
+                    }
+                    (0, chai_1.expect)(seen.map((s) => s.inside)).to.deep.equal([true, false]);
+                }));
+                it('never for a test’s command running alongside one', () => __awaiter(void 0, void 0, void 0, function* () {
+                    const app = yield labSeeing();
+                    const internal = (0, loopbackRequest_1.default)(app)
+                        .get('/wd/hub/wd-internal/session/s1/source?hold=1')
+                        .set((0, internalCall_1.internalCallHeaders)())
+                        .then((r) => r);
+                    for (let i = 0; i < 100 && !release; i++)
+                        yield new Promise((r) => setTimeout(r, 10));
+                    const held = release;
+                    if (!held)
+                        throw new Error('the internal call never reached its route');
+                    yield (0, loopbackRequest_1.default)(app).get('/wd/hub/session/s1/source').expect(200);
+                    held();
+                    yield internal;
+                    (0, chai_1.expect)(seen).to.deep.equal([
+                        { url: '/wd/hub/session/s1/source', inside: false },
+                        { url: '/wd/hub/session/s1/source?hold=1', inside: true },
+                    ]);
+                }));
+            });
             it('puts the internal-call layer ahead of the session layer, both ahead of the routes', () => __awaiter(void 0, void 0, void 0, function* () {
                 const { raw } = yield lab();
                 const stack = (0, insertBeforeRoutes_1.routerStackOf)(raw);

package/lib/test/unit/internal-calls-session-record.spec.js

@@ -0,0 +1,312 @@
+"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 __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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const http_1 = __importDefault(require("http"));
+const sinon_1 = __importDefault(require("sinon"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const plugin_1 = require("../../src/plugin");
+const registerCommandAuth_1 = require("../../src/app/registerCommandAuth");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const LocalSession_1 = require("../../src/sessions/LocalSession");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const NotificationService_1 = require("../../src/services/NotificationService");
+const AIService_1 = require("../../src/services/AIService");
+const failure_analysis_service_1 = require("../../src/dashboard/services/failure-analysis-service");
+const deviceService = __importStar(require("../../src/data-service/device-service"));
+const SessionStatus_1 = require("../../src/types/SessionStatus");
+const scratch_database_1 = require("../helpers/scratch-database");
+const loki_stores_1 = require("../helpers/loki-stores");
+const appium_umbrella_1 = require("../helpers/appium-umbrella");
+/**
+ * Xenon's own calls to a session it runs, in Appium 3's own server(): Appium's
+ * umbrella driver with Xenon's plugin and the production session gateway, on
+ * a dashboard-on server, over a scratch database.
+ *
+ * A LocalSession asks its driver in-process first. When that fails it asks
+ * again over HTTP, at `<basePath>/wd-internal/session/<id>/...` with the
+ * per-process secret (gateway/internalCall.ts), and that request goes through
+ * Appium's route, the umbrella and the plugin's `handle` like a test's.
+ * Through 2.16 the plugin couldn't tell: the marker was on the Express request,
+ * which `handle` is never given. So a performance recording's stop the driver
+ * refused at the end of a session was recorded as a failed `execute` of the
+ * session, and the session, whose own commands had all passed, ended failed:
+ * "marked as FAILED due to error in command: execute", the driver's refusal
+ * as its reason, failure analysis, a `session_failed` webhook. Observed on a
+ * simulator on 2026-10-05 (2.16 no longer stops one there, #503); on an
+ * iPhone whenever the recording's start failed.
+ */
+const SESSION = 'internal-calls-session';
+const UDID = 'iphone-1';
+const BASE = '/wd/hub';
+const REFUSAL = 'No Time Profiler recording was started on this device';
+const quiet = { info: () => undefined, warn: () => undefined, error: () => undefined };
+/** An iPhone driver as far as these calls go: it refuses the performance recording. */
+function iPhoneLikeDriverClass() {
+    const { BaseDriver, errors } = (0, appium_umbrella_1.appiumBaseDriver)();
+    return class IPhoneLikeDriver extends BaseDriver {
+        constructor() {
+            super(...arguments);
+            this.calls = [];
+            this.pageSourceFailures = 0;
+        }
+        getUrl() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.calls.push('getUrl');
+                return 'https://app.example/';
+            });
+        }
+        execute(script) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.calls.push(`execute ${script}`);
+                if (script === 'mobile: startPerfRecord' || script === 'mobile: stopPerfRecord') {
+                    throw new errors.UnknownError(REFUSAL);
+                }
+                return null;
+            });
+        }
+        getPageSource() {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.calls.push('getPageSource');
+                if (this.pageSourceFailures > 0) {
+                    this.pageSourceFailures--;
+                    throw new errors.UnknownError('The page source took too long');
+                }
+                if (this.held)
+                    yield this.held;
+                return '<XCUIElementTypeApplication name="Shop"/>';
+            });
+        }
+        /** Commands waiting in base-driver's queue, read as base-driver reads it. */
+        queued() {
+            var _a, _b, _c, _d;
+            return (_d = (_c = (_b = (_a = this.commandsQueueGuard) === null || _a === void 0 ? void 0 : _a.queues) === null || _b === void 0 ? void 0 : _b[BaseDriver.name]) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+        }
+    };
+}
+describe('Xenon’s own calls to a session (/wd-internal), in Appium 3’s own server()', function () {
+    this.timeout(60000);
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    (0, loki_stores_1.usePrismaStores)();
+    let appiumLogs;
+    let server;
+    let url;
+    let inner;
+    let session;
+    let notified;
+    let isHubBefore;
+    before(() => {
+        appiumLogs = (0, appium_umbrella_1.quietAppiumLogs)();
+    });
+    after(() => appiumLogs.restore());
+    beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+        // A hub or a standalone server, with the dashboard recording its sessions.
+        isHubBefore = plugin_1.XenonPlugin.IS_HUB;
+        plugin_1.XenonPlugin.IS_HUB = true;
+        notified = sinon_1.default.stub(NotificationService_1.NotificationService.prototype, 'notifySessionFailed').resolves();
+        // A failed session's analysis never reaches an AI provider from here.
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'isEnabled').returns(false);
+        yield scratch.db.sessionLog.deleteMany({});
+        yield scratch.db.log.deleteMany({});
+        yield scratch.db.session.deleteMany({});
+        const baseDriver = (0, appium_umbrella_1.appiumBaseDriver)();
+        const umbrella = (0, appium_umbrella_1.umbrellaWith)([[plugin_1.XenonPlugin, 'xenon']]);
+        umbrella.args.plugin = { xenon: { enableDashboard: true } };
+        server = yield baseDriver.server({
+            routeConfiguringFunction: baseDriver.routeConfiguringFunction(umbrella),
+            port: 0,
+            hostname: '127.0.0.1',
+            basePath: BASE,
+            cliArgs: { basePath: BASE },
+            serverUpdaters: [
+                (app) => (0, registerCommandAuth_1.registerSessionGateway)(app, { basePath: BASE }, (0, registerCommandAuth_1.commandAuthDeps)({ enabled: () => false, authDisabled: () => false, logger: quiet })),
+            ],
+        });
+        const port = server.address().port;
+        url = `http://127.0.0.1:${port}`;
+        // Where a LocalSession's loopback calls go: the server it runs on.
+        Object.assign(umbrella.opts, { address: '127.0.0.1', port, basePath: BASE });
+        // The session as Appium holds it once created.
+        const Driver = iPhoneLikeDriverClass();
+        inner = new Driver({}, false);
+        inner.sessionId = SESSION;
+        inner.caps = { platformName: 'iOS', automationName: appium_umbrella_1.FAKE_AUTOMATION, udid: UDID };
+        inner.newCommandTimeoutMs = 0;
+        umbrella.sessions[SESSION] = inner;
+        // ... and as Xenon records it.
+        yield scratch.db.session.create({
+            data: {
+                id: SESSION,
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'node-1',
+                has_live_video: false,
+                device_udid: UDID,
+                device_platform: 'ios',
+                device_version: '18.0',
+            },
+        });
+        session = new LocalSession_1.LocalSession({
+            sessionId: SESSION,
+            device: { udid: UDID, platform: 'ios', realDevice: true, host: url },
+            sessionResponse: {},
+            xenonOption: {},
+            driver: umbrella,
+        });
+        SessionManager_1.SESSION_MANAGER.addSession(SESSION, session);
+    }));
+    afterEach(() => __awaiter(this, void 0, void 0, function* () {
+        SessionManager_1.SESSION_MANAGER.removeSession(SESSION);
+        plugin_1.XenonPlugin.IS_HUB = isHubBefore;
+        sinon_1.default.restore();
+        server.closeAllConnections();
+        yield new Promise((resolve) => http_1.default.Server.prototype.close.call(server, () => resolve()));
+    }));
+    /** The session's recorded commands, oldest first. */
+    function recorded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rows = yield scratch.db.sessionLog.findMany({
+                where: { session_id: SESSION },
+                orderBy: { createdAt: 'asc' },
+            });
+            return rows.map((row) => ({ command: row.command_name, failed: row.is_error }));
+        });
+    }
+    /** The session's end as every ending reaches it, and what its row says then. */
+    function end() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(SESSION);
+            const row = yield scratch.db.session.findUniqueOrThrow({ where: { id: SESSION } });
+            return { status: row.status, reason: row.failure_reason };
+        });
+    }
+    /** Waits for a condition the test can't be told about. */
+    function until(condition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let i = 0; i < 200 && !condition(); i++)
+                yield new Promise((r) => setTimeout(r, 10));
+            (0, chai_1.expect)(condition(), 'waited 2 s').to.equal(true);
+        });
+    }
+    /** A command the test sends, through the public route. */
+    const testCommand = () => (0, loopbackRequest_1.default)(url).get(`${BASE}/session/${SESSION}/url`);
+    it('a performance recording’s stop the driver refuses doesn’t fail a session whose commands all passed', () => __awaiter(this, void 0, void 0, function* () {
+        yield testCommand().expect(200);
+        (0, chai_1.expect)(yield session.stopPerformanceRecording()).to.equal(null);
+        // The stop was asked in-process, then over the loopback, which reached the driver.
+        (0, chai_1.expect)(inner.calls).to.deep.equal([
+            'getUrl',
+            'execute mobile: stopPerfRecord',
+            'execute mobile: stopPerfRecord',
+        ]);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([{ command: 'getUrl', failed: false }]);
+        (0, chai_1.expect)(yield end()).to.deep.equal({ status: SessionStatus_1.SessionStatus.SUCCESS, reason: null });
+        (0, chai_1.expect)(notified.called, 'a session_failed webhook').to.equal(false);
+    }));
+    it('nor does a refused start of the recording, at the session’s first moments', () => __awaiter(this, void 0, void 0, function* () {
+        yield session.startPerformanceRecording();
+        (0, chai_1.expect)(inner.calls).to.deep.equal([
+            'execute mobile: startPerfRecord',
+            'execute mobile: startPerfRecord',
+        ]);
+        yield testCommand().expect(200);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([{ command: 'getUrl', failed: false }]);
+        (0, chai_1.expect)(yield end()).to.deep.equal({ status: SessionStatus_1.SessionStatus.SUCCESS, reason: null });
+    }));
+    it('a page source read over the loopback is not put in the session’s command log', () => __awaiter(this, void 0, void 0, function* () {
+        inner.pageSourceFailures = 1;
+        (0, chai_1.expect)(yield session.getPageSource()).to.equal('<XCUIElementTypeApplication name="Shop"/>');
+        (0, chai_1.expect)(inner.calls).to.deep.equal(['getPageSource', 'getPageSource']);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([]);
+    }));
+    it('a page source read that fails over the loopback too is not a failed command of the session', () => __awaiter(this, void 0, void 0, function* () {
+        inner.pageSourceFailures = 2;
+        yield session.getPageSource().then(() => chai_1.expect.fail('the read succeeded'), (error) => { var _a; return (0, chai_1.expect)((_a = error.response) === null || _a === void 0 ? void 0 : _a.status).to.equal(500); });
+        (0, chai_1.expect)(inner.calls).to.deep.equal(['getPageSource', 'getPageSource']);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([]);
+        (0, chai_1.expect)(yield end()).to.deep.equal({ status: SessionStatus_1.SessionStatus.SUCCESS, reason: null });
+    }));
+    it('isn’t the session’s activity: only the test’s commands reset its idle clock', () => __awaiter(this, void 0, void 0, function* () {
+        const touched = sinon_1.default.stub(deviceService, 'updateCmdExecutedTime').resolves();
+        inner.pageSourceFailures = 1;
+        yield session.stopPerformanceRecording();
+        yield session.getPageSource();
+        (0, chai_1.expect)(inner.calls).to.have.length(4);
+        (0, chai_1.expect)(touched.called).to.equal(false);
+        yield testCommand().expect(200);
+        (0, chai_1.expect)(touched.calledOnceWith(SESSION)).to.equal(true);
+    }));
+    it('a test’s command queued in the driver behind one is recorded, as the test’s', () => __awaiter(this, void 0, void 0, function* () {
+        let release = () => { };
+        inner.held = new Promise((resolve) => (release = resolve));
+        inner.pageSourceFailures = 1;
+        // Xenon's read reaches the driver over the loopback and holds its queue.
+        const read = session.getPageSource();
+        yield until(() => inner.calls.length === 2);
+        // The test's command waits in the driver's queue behind it, and runs when
+        // Xenon's read lets go.
+        const command = testCommand().then((res) => res);
+        yield until(() => inner.queued() === 1);
+        release();
+        (0, chai_1.expect)(yield read).to.equal('<XCUIElementTypeApplication name="Shop"/>');
+        (0, chai_1.expect)((yield command).status).to.equal(200);
+        (0, chai_1.expect)(inner.calls).to.deep.equal(['getPageSource', 'getPageSource', 'getUrl']);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([{ command: 'getUrl', failed: false }]);
+    }));
+    it('the same refusal of the test’s own command is recorded and fails the session, as before', () => __awaiter(this, void 0, void 0, function* () {
+        yield (0, loopbackRequest_1.default)(url)
+            .post(`${BASE}/session/${SESSION}/execute/sync`)
+            .send({ script: 'mobile: stopPerfRecord', args: [{ profileName: 'Time Profiler' }] })
+            .expect(500);
+        (0, chai_1.expect)(yield recorded()).to.deep.equal([{ command: 'execute', failed: true }]);
+        (0, chai_1.expect)(yield end()).to.deep.equal({ status: SessionStatus_1.SessionStatus.FAILED, reason: REFUSAL });
+        (0, chai_1.expect)(notified.calledOnce, 'a session_failed webhook').to.equal(true);
+        // The analysis the failure started ends with the test, not after it.
+        yield (0, failure_analysis_service_1.explainSessionFailure)(SESSION);
+    }));
+});