@xenon-device-management/xenon 2.14.0 → 2.15.0

package/lib/test/unit/dashboard-events-device-logs.spec.js

@@ -0,0 +1,207 @@
+"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 sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const event_manager_1 = require("../../src/dashboard/event-manager");
+const assets = __importStar(require("../../src/dashboard/asset-manager"));
+const sessionService = __importStar(require("../../src/dashboard/services/session-service"));
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const SessionMetricsService_1 = require("../../src/services/metrics/SessionMetricsService");
+const SessionDeviceLogs_1 = require("../../src/services/logcat/SessionDeviceLogs");
+const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const TracingService_1 = require("../../src/services/TracingService");
+const MetricsService_1 = require("../../src/services/MetricsService");
+const device_store_1 = require("../../src/data-service/device-store");
+const PluginContext_1 = require("../../src/PluginContext");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const pendingSessions = __importStar(require("../../src/data-service/pending-sessions-service"));
+const deviceService = __importStar(require("../../src/data-service/device-service"));
+const deviceUtils = __importStar(require("../../src/device-utils"));
+const config_1 = require("../../src/config");
+const prisma_1 = require("../../src/prisma");
+const container_registration_1 = require("../helpers/container-registration");
+const loki_stores_1 = require("../helpers/loki-stores");
+/**
+ * A session's device log is recorded from about when its phone was given to
+ * it, once the session's row exists (the lines point at it), and written to
+ * the end however the session ends: every ending reaches onSessionStopped.
+ */
+describe('EventManager: an Android session’s device log', () => {
+    let restore;
+    let deviceLogs;
+    let order;
+    beforeEach(() => {
+        restore = (0, container_registration_1.saveRegistrations)(SessionDeviceLogs_1.SessionDeviceLogs, SessionMetricsService_1.SessionMetricsService, SocketServer_1.SocketServer);
+        order = [];
+        deviceLogs = {
+            start: sinon_1.default.stub().callsFake(() => __awaiter(void 0, void 0, void 0, function* () { return order.push('device logs'); })),
+            stop: sinon_1.default.stub().resolves(),
+        };
+        typedi_1.Container.set(SessionDeviceLogs_1.SessionDeviceLogs, deviceLogs);
+        typedi_1.Container.set(SessionMetricsService_1.SessionMetricsService, {
+            appliesTo: () => false,
+            start: sinon_1.default.stub(),
+            stop: sinon_1.default.stub().resolves(),
+        });
+        typedi_1.Container.set(SocketServer_1.SocketServer, {
+            emitToDashboard: sinon_1.default.stub(),
+            emitToDashboardForDevices: sinon_1.default.stub().resolves(),
+            hasScopedDashboard: sinon_1.default.stub().returns(false),
+        });
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        restore();
+    });
+    it("starts once the session's row is written, from when the phone was given to it", () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(assets, 'prepareDirectory');
+        sinon_1.default.stub(sessionService, 'getOrCreateNewBuild').resolves({ id: 'b-logs' });
+        sinon_1.default.stub(TracingService_1.TracingService.prototype, 'getTraceId').returns('t-1');
+        sinon_1.default.stub(MetricsService_1.MetricsService.prototype, 'incrementSessionStart');
+        sinon_1.default.stub(prisma_1.prisma.session, 'create').callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            order.push('row');
+            return {};
+        }));
+        const session = {
+            getId: () => 's-logs-1',
+            getCapabilities: () => ({ platformName: 'Android' }),
+            getLiveVideoUrl: () => null,
+            apiKeyId: null,
+            userId: null,
+            allocatedAt: 1700000000000,
+        };
+        const device = { udid: 'phone-l', platform: 'android', host: 'h', name: 'S9', sdk: '10' };
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted({}, session, device);
+        (0, chai_1.expect)(order).to.deep.equal(['row', 'device logs']);
+        (0, chai_1.expect)(deviceLogs.start.firstCall.args[0]).to.deep.equal({
+            sessionId: 's-logs-1',
+            device,
+            since: 1700000000000,
+        });
+    }));
+    it('writes it to the end when the session stops, even one no longer in memory', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(SessionManager_1.SESSION_MANAGER, 'getSession').returns(undefined);
+        sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({ getDevices: () => __awaiter(void 0, void 0, void 0, function* () { return []; }) });
+        sinon_1.default
+            .stub(prisma_1.prisma.session, 'findFirst')
+            .resolves({ id: 's-logs-2', status: 'running', device_udid: 'phone-l' });
+        sinon_1.default.stub(prisma_1.prisma.session, 'update').resolves({});
+        sinon_1.default.stub(prisma_1.prisma.sessionLog, 'findFirst').resolves(null);
+        let statusWritten = false;
+        prisma_1.prisma.session.update.callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            statusWritten = true;
+            return {};
+        }));
+        deviceLogs.stop.callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            // The session page reads the device log again once the session has
+            // ended: by then every line is written.
+            (0, chai_1.expect)(statusWritten, 'the session was marked ended first').to.equal(false);
+        }));
+        yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped('s-logs-2');
+        (0, chai_1.expect)(deviceLogs.stop.calledOnceWithExactly('s-logs-2')).to.equal(true);
+        (0, chai_1.expect)(statusWritten).to.equal(true);
+    }));
+});
+describe('createSession: when the phone was given to the session', () => {
+    (0, loki_stores_1.useLokiStores)();
+    let context;
+    let saved;
+    let authDisabledBefore;
+    beforeEach(() => {
+        authDisabledBefore = config_1.config.authDisabled;
+        config_1.config.authDisabled = true;
+        context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        saved = { pluginArgs: context.pluginArgs, nodeId: context.nodeId };
+        context.pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs, { bindHostOrIp: '127.0.0.1' });
+        context.nodeId = 'node-here';
+    });
+    afterEach(() => {
+        config_1.config.authDisabled = authDisabledBefore;
+        Object.assign(context, saved);
+        sinon_1.default.restore();
+    });
+    it('is noted on the session, between the allocation and the driver starting', () => __awaiter(void 0, void 0, void 0, function* () {
+        const device = {
+            udid: 'u1',
+            host: 'h1',
+            platform: 'android',
+            nodeId: 'node-here',
+            teamId: null,
+        };
+        let allocatedBy = 0;
+        let driverAt = 0;
+        sinon_1.default.stub(pendingSessions, 'addNewPendingSession').resolves();
+        sinon_1.default.stub(pendingSessions, 'removePendingSession').resolves();
+        sinon_1.default.stub(deviceService, 'updateDeviceProgress').resolves();
+        sinon_1.default.stub(deviceService, 'updatedAllocatedDevice').resolves();
+        sinon_1.default.stub(deviceUtils, 'allocateDeviceForSession').callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            allocatedBy = Date.now();
+            return device;
+        }));
+        const svc = new SessionLifecycleService_1.SessionLifecycleService();
+        const instance = {};
+        sinon_1.default.stub(svc, 'createSessionInstance').returns(instance);
+        sinon_1.default.stub(svc, 'applyPostSessionLogic').resolves();
+        const next = sinon_1.default.stub().callsFake(() => __awaiter(void 0, void 0, void 0, function* () {
+            driverAt = Date.now();
+            // A slow driver start: the session's log still counts from before it.
+            yield new Promise((r) => setTimeout(r, 20));
+            return { value: ['s-alloc', { platformName: 'Android' }] };
+        }));
+        yield svc.createSession(next, {}, {
+            alwaysMatch: { platformName: 'Android', 'appium:automationName': 'UiAutomator2' },
+            firstMatch: [{}],
+        });
+        (0, chai_1.expect)(instance.allocatedAt).to.be.a('number');
+        (0, chai_1.expect)(instance.allocatedAt).to.be.at.least(allocatedBy);
+        (0, chai_1.expect)(instance.allocatedAt).to.be.at.most(driverAt);
+    }));
+});

package/lib/test/unit/dashboard-plugin-link.spec.js

@@ -0,0 +1,213 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 sinon_1 = __importDefault(require("sinon"));
+const express_1 = __importDefault(require("express"));
+const loopbackRequest_1 = __importDefault(require("../helpers/loopbackRequest"));
+const index_1 = require("../../src/app/index");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const InternalHttpClient_1 = require("../../src/InternalHttpClient");
+const config_1 = require("../../src/config");
+const device_store_1 = require("../../src/data-service/device-store");
+const dashboardPluginLink_1 = require("../../src/app/dashboardPluginLink");
+const grid_1 = __importDefault(require("../../src/app/routers/grid"));
+// The store grid.ts took when it was loaded (it keeps the one it got then).
+const gridStore = device_store_1.DeviceStoreFactory.getStore();
+/**
+ * Where Xenon looks for the appium-dashboard-plugin, and the `dashboard_link`
+ * it hands back with each device.
+ *
+ * Through 2.14 both came from the Host header of the first /xenon/api request
+ * after startup, before the login (a GET /xenon/api/health was enough):
+ * Xenon sent a GET to `<that host>/dashboard/api/ping`, and if the answer had
+ * `pong`, kept `<that host>/dashboard` for the life of the process. From then
+ * on every device list fetched `<that host>/dashboard/api/sessions`, and gave
+ * every user a `dashboard_link` to that host. A forged Host made Xenon call a
+ * server of the sender's choosing (blind SSRF) and point everyone at it.
+ *
+ * Both now come from configuration: the plugin is reached on this server's own
+ * address and port, and the link is `/dashboard` under XENON_PUBLIC_URL, or a
+ * path on the server the dashboard is open on.
+ */
+describe('the dashboard-plugin link never comes from a request', () => {
+    const EVIL = 'attacker.example:8080';
+    let calls;
+    let authDisabledBefore;
+    let publicUrlBefore;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        authDisabledBefore = config_1.config.authDisabled;
+        publicUrlBefore = config_1.config.publicUrl;
+        config_1.config.authDisabled = true;
+        calls = [];
+        sinon_1.default.stub(InternalHttpClient_1.InternalHttpClient, 'get').callsFake(((url) => __awaiter(void 0, void 0, void 0, function* () {
+            calls.push(url);
+            if (url.endsWith('/dashboard/api/ping'))
+                return { pong: true };
+            return { result: { rows: [] } };
+        })));
+        sinon_1.default
+            .stub(gridStore, 'getAllDevices')
+            .resolves([{ udid: 'phone-1', host: 'http://127.0.0.1:4723', platform: 'android' }]);
+    }));
+    afterEach(() => {
+        config_1.config.authDisabled = authDisabledBefore;
+        config_1.config.publicUrl = publicUrlBefore;
+        sinon_1.default.restore();
+    });
+    // This server's own address, as ServerManager passes it from Appium's CLI
+    // arguments. InternalHttpClient is stubbed, so nothing is sent anywhere.
+    function app() {
+        const a = (0, express_1.default)();
+        a.use('/xenon', (0, index_1.createRouter)(Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { bindHostOrIp: '127.0.0.1' }), {
+            address: '0.0.0.0',
+            port: 4999,
+        }));
+        return a;
+    }
+    // The old check was a layer ahead of the login, first on the router, so a
+    // public request was enough: GET /xenon/api/health with a forged Host made
+    // Xenon ping that host. Now a public request makes no outbound call at all.
+    it('asks nothing of anyone for a public request, whatever Host it names', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, loopbackRequest_1.default)(app()).get('/xenon/api/health').set('Host', EVIL);
+        (0, chai_1.expect)(calls).to.deep.equal([]);
+    }));
+    // Lets the middleware's ping (started by a request, never awaited by one)
+    // finish.
+    const settle = () => new Promise((resolve) => setImmediate(resolve));
+    // The middleware ServerManager installs, with the device list, on a router
+    // of their own: the process-wide /xenon router may already answer /device
+    // from a layer another spec put ahead of it.
+    describe('the device list', () => {
+        function gridApp(ownServer) {
+            const r = express_1.default.Router();
+            r.use((req, _res, next) => {
+                req.auth = {
+                    kind: 'user-session',
+                    userId: 'u1',
+                    role: 'SUPER_ADMIN',
+                    scopes: 'admin',
+                };
+                next();
+            });
+            r.use((0, dashboardPluginLink_1.dashboardPluginMiddlewareFor)(ownServer));
+            grid_1.default.register(r, Object.assign({}, IPluginArgs_1.DefaultPluginArgs));
+            const a = (0, express_1.default)();
+            a.use('/xenon/api', r);
+            return a;
+        }
+        /** A first request starts the ping; the second sees what it found. */
+        function devices(a) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield (0, loopbackRequest_1.default)(a).get('/xenon/api/device').set('Host', EVIL);
+                yield settle();
+                return (0, loopbackRequest_1.default)(a).get('/xenon/api/device').set('Host', EVIL);
+            });
+        }
+        it("fetches the plugin's sessions from this server, never the request's host", () => __awaiter(void 0, void 0, void 0, function* () {
+            yield devices(gridApp({ address: '0.0.0.0', port: 4999 }));
+            (0, chai_1.expect)(calls.length, 'the ping and the sessions fetch ran').to.be.greaterThan(1);
+            (0, chai_1.expect)(calls[0]).to.equal('http://127.0.0.1:4999/dashboard/api/ping');
+            for (const url of calls.slice(1)) {
+                (0, chai_1.expect)(url).to.match(/^http:\/\/127\.0\.0\.1:4999\/dashboard\/api\/sessions\?/);
+            }
+        }));
+        it('links a device to /dashboard under XENON_PUBLIC_URL, or on the server it is open on', () => __awaiter(void 0, void 0, void 0, function* () {
+            config_1.config.publicUrl = 'https://xenon.example.com';
+            const withPublic = yield devices(gridApp({ port: 4999 }));
+            const phone = withPublic.body.find((d) => d.udid === 'phone-1');
+            (0, chai_1.expect)(phone.dashboard_link).to.match(/^https:\/\/xenon\.example\.com\/dashboard\?device_udid=phone-1&/);
+            config_1.config.publicUrl = undefined;
+            const without = yield devices(gridApp({ port: 4999 }));
+            (0, chai_1.expect)(without.body.find((d) => d.udid === 'phone-1').dashboard_link).to.match(/^\/dashboard\?device_udid=phone-1&/);
+        }));
+        // Appium serves HTTPS with --ssl-certificate-path and --ssl-key-path. A
+        // plain-HTTP ping got ECONNRESET, retried three times (about 4 s) while
+        // every signed-in request waited on it, every 30 s once the back-off
+        // capped, and the plugin's link was lost.
+        it('pings over HTTPS when Appium serves it, once, with a short time limit', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield devices(gridApp({ address: '0.0.0.0', port: 4999, tls: true }));
+            const ping = InternalHttpClient_1.InternalHttpClient.get.firstCall;
+            (0, chai_1.expect)(ping.args[0]).to.equal('https://127.0.0.1:4999/dashboard/api/ping');
+            (0, chai_1.expect)(ping.args[1]).to.include({ retry: false, timeout: dashboardPluginLink_1.DASHBOARD_PING_TIMEOUT_MS });
+            (0, chai_1.expect)(dashboardPluginLink_1.DASHBOARD_PING_TIMEOUT_MS).to.be.at.most(2000);
+        }));
+    });
+    describe('dashboardPluginMiddleware', () => {
+        const run = (mw_1, ...args_1) => __awaiter(void 0, [mw_1, ...args_1], void 0, function* (mw, host = EVIL) {
+            const req = { headers: { host }, get: () => host, protocol: 'http' };
+            yield new Promise((resolve) => mw(req, {}, resolve));
+            return req;
+        });
+        it('reaches the plugin on the server it is given, whatever the request', () => __awaiter(void 0, void 0, void 0, function* () {
+            const got = [];
+            const mw = (0, dashboardPluginLink_1.dashboardPluginMiddleware)({
+                ownServerOrigin: 'http://127.0.0.1:4723',
+                get: (url) => __awaiter(void 0, void 0, void 0, function* () {
+                    got.push(url);
+                    return { pong: true };
+                }),
+                publicBase: () => null,
+            });
+            yield run(mw);
+            yield settle();
+            const req = yield run(mw);
+            (0, chai_1.expect)(got).to.deep.equal(['http://127.0.0.1:4723/dashboard/api/ping']);
+            (0, chai_1.expect)(req['dashboard-plugin-url']).to.equal('http://127.0.0.1:4723/dashboard');
+            (0, chai_1.expect)(req['dashboard-plugin-link']).to.equal('/dashboard');
+            yield run(mw, 'other.example');
+            (0, chai_1.expect)(got, 'pinged once, while it answers').to.have.length(1);
+        }));
+        // A request never waits for the ping: one the plugin doesn't answer
+        // (a hung server, the wrong scheme) would hold every signed-in request.
+        it('never holds a request while the ping is out', () => __awaiter(void 0, void 0, void 0, function* () {
+            const mw = (0, dashboardPluginLink_1.dashboardPluginMiddleware)({
+                ownServerOrigin: 'http://127.0.0.1:4723',
+                get: () => new Promise(() => undefined),
+            });
+            const outcome = yield Promise.race([
+                run(mw).then(() => 'answered'),
+                new Promise((resolve) => setTimeout(() => resolve('held'), 200)),
+            ]);
+            (0, chai_1.expect)(outcome).to.equal('answered');
+        }));
+        it('backs off after a failed ping, and links nothing meanwhile', () => __awaiter(void 0, void 0, void 0, function* () {
+            let t = 0;
+            const get = sinon_1.default.stub().rejects(new Error('ECONNREFUSED'));
+            const mw = (0, dashboardPluginLink_1.dashboardPluginMiddleware)({
+                ownServerOrigin: 'http://127.0.0.1:4723',
+                get,
+                now: () => t,
+            });
+            yield run(mw);
+            yield settle();
+            const req = yield run(mw);
+            (0, chai_1.expect)(req['dashboard-plugin-url']).to.equal('');
+            (0, chai_1.expect)(req['dashboard-plugin-link']).to.equal('');
+            (0, chai_1.expect)(get.callCount, 'no second ping inside the back-off').to.equal(1);
+            t = 1000;
+            yield run(mw);
+            (0, chai_1.expect)(get.callCount).to.equal(2);
+        }));
+        it('finds the server on 127.0.0.1 for a wildcard bind address, over HTTPS when asked', () => {
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('0.0.0.0', 4723)).to.equal('http://127.0.0.1:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)(undefined, 4723)).to.equal('http://127.0.0.1:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('::', 4723)).to.equal('http://127.0.0.1:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('10.0.0.5', 4723)).to.equal('http://10.0.0.5:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('fe80::1', 4723)).to.equal('http://[fe80::1]:4723');
+            (0, chai_1.expect)((0, dashboardPluginLink_1.ownServerOrigin)('0.0.0.0', 4723, true)).to.equal('https://127.0.0.1:4723');
+        });
+    });
+});

package/lib/test/unit/device-log-book.spec.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const deviceLogBook_1 = require("../../src/services/logcat/deviceLogBook");
+const logcatParse_1 = require("../../src/services/logcat/logcatParse");
+const pad = (n, w = 2) => String(n).padStart(w, '0');
+/** A threadtime line logged at `at` by this machine's local clock. */
+function lineAt(at, level = 'I', msg = 'hello', tag = 'Tag', pid = 4127) {
+    const t = new Date(at);
+    return (`${pad(t.getMonth() + 1)}-${pad(t.getDate())} ${pad(t.getHours())}:${pad(t.getMinutes())}:` +
+        `${pad(t.getSeconds())}.${pad(t.getMilliseconds(), 3)}  ${pid}  ${pid} ${level} ${tag}: ${msg}`);
+}
+function recAt(at, level = 'I', msg = 'hello', tag = 'Tag') {
+    const rec = (0, logcatParse_1.parseThreadtimeLine)(lineAt(at, level, msg, tag), new Date(at));
+    if (!rec)
+        throw new Error('not a line');
+    return rec;
+}
+// The dashboard's own reading of a device log line (web log-derive.ts).
+const DASHBOARD_THREADTIME = /^\d{2}-\d{2}\s+\d{2}:\d{2}:\d{2}\.\d+\s+\d+\s+\d+\s+([VDIWEF])\s/;
+// Mid-January, midday: no daylight-saving change within hours of it.
+const T0 = new Date(2026, 0, 15, 12, 0, 0, 0).getTime();
+describe('DeviceLogBook', () => {
+    describe('formatThreadtime', () => {
+        it('prints a record as logcat printed it, so it parses back the same', () => {
+            const line = '01-15 12:00:00.120  4127  4130 E AndroidRuntime: FATAL EXCEPTION: main';
+            const rec = (0, logcatParse_1.parseThreadtimeLine)(line, new Date(T0));
+            const printed = (0, deviceLogBook_1.formatThreadtime)(rec);
+            (0, chai_1.expect)(printed).to.equal(line);
+            (0, chai_1.expect)((0, logcatParse_1.parseThreadtimeLine)(printed, new Date(T0))).to.deep.equal(rec);
+        });
+        it("pads a short tag to logcat's eight columns, and the dashboard reads its level", () => {
+            var _a;
+            const printed = (0, deviceLogBook_1.formatThreadtime)(recAt(T0, 'F', 'boom', 'DEBUG'));
+            (0, chai_1.expect)(printed).to.match(/ F DEBUG {3}: boom$/);
+            (0, chai_1.expect)((_a = DASHBOARD_THREADTIME.exec(printed)) === null || _a === void 0 ? void 0 : _a[1]).to.equal('F');
+        });
+        it('keeps a wrapped message whole', () => {
+            const rec = Object.assign(Object.assign({}, recAt(T0)), { message: 'first\nwrapped remainder' });
+            (0, chai_1.expect)((0, deviceLogBook_1.formatThreadtime)(rec)).to.match(/Tag {5}: first\nwrapped remainder$/);
+        });
+    });
+    describe('the session window', () => {
+        it('keeps lines from shortly before the phone was given to the session, and not before', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            (0, chai_1.expect)(book.add(recAt(T0 - deviceLogBook_1.WINDOW_SLACK_MS - 1))).to.deep.equal([]);
+            (0, chai_1.expect)(book.add(recAt(T0 - deviceLogBook_1.WINDOW_SLACK_MS))).to.have.length(1);
+            (0, chai_1.expect)(book.add(recAt(T0 + 60000))).to.have.length(1);
+        });
+        it('stamps each line with its own time, and keeps the text the phone printed', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            const [row] = book.add(recAt(T0 + 1234, 'W', 'low memory'));
+            (0, chai_1.expect)(row.timestamp.getTime()).to.equal(T0 + 1234);
+            (0, chai_1.expect)(row.message).to.equal(lineAt(T0 + 1234, 'W', 'low memory').replace('Tag:', 'Tag     :'));
+        });
+        it('reads a phone in another time zone at the moment it logged, not hours off', () => {
+            // The phone is 5 h 30 min ahead: its 17:30 is this server's 12:00.
+            const ahead = 5.5 * 3600000;
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: { zoneShiftMs: -ahead, skewMs: 0 } });
+            // Printed an hour before the session by the phone's clock: left out.
+            (0, chai_1.expect)(book.add(recAt(T0 + ahead - 3600000))).to.deep.equal([]);
+            const [row] = book.add(recAt(T0 + ahead + 5000));
+            (0, chai_1.expect)(row.timestamp.getTime()).to.equal(T0 + 5000);
+            // The text is the phone's own, as it printed it.
+            (0, chai_1.expect)(row.message).to.match(/^01-15 17:30:05\.000 /);
+        });
+        it("cuts and stamps by this server's clock when the phone's runs behind", () => {
+            // The phone's clock is 40 s slow: a line it stamps 30 s before the
+            // session came 10 s after the session began, and one it stamps 43 s
+            // before came 3 s before.
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: { zoneShiftMs: 0, skewMs: 40000 } });
+            (0, chai_1.expect)(book.add(recAt(T0 - 43000))).to.deep.equal([]);
+            const [row] = book.add(recAt(T0 - 30000));
+            (0, chai_1.expect)(row.timestamp.getTime()).to.equal(T0 + 10000);
+            // The text keeps the time the phone printed.
+            (0, chai_1.expect)(row.message).to.match(/^01-15 11:59:30\.000 /);
+        });
+        it("ignores the stream's own notes", () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            (0, chai_1.expect)(book.add(Object.assign(Object.assign({}, recAt(T0)), { tag: 'xenon', synthetic: true }))).to.deep.equal([]);
+        });
+    });
+    describe('after an interruption', () => {
+        it('counts only lines newer than the last it saw, by content at that millisecond', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            book.add(recAt(T0 + 1000, 'I', 'one'));
+            book.add(recAt(T0 + 2000, 'E', 'stack line 1'));
+            book.add(recAt(T0 + 2000, 'E', 'stack line 2'));
+            const [note] = book.interrupted(new Date(T0 + 3000));
+            (0, chai_1.expect)(note.message).to.equal("Xenon: The phone's log was interrupted. Lines may be missing from here.");
+            // The new stream's history repeats what was kept...
+            (0, chai_1.expect)(book.add(recAt(T0 + 1000, 'I', 'one'))).to.deep.equal([]);
+            (0, chai_1.expect)(book.add(recAt(T0 + 2000, 'E', 'stack line 1'))).to.deep.equal([]);
+            (0, chai_1.expect)(book.add(recAt(T0 + 2000, 'E', 'stack line 2'))).to.deep.equal([]);
+            // ...and has a line of that same millisecond that hadn't arrived yet.
+            (0, chai_1.expect)(book.add(recAt(T0 + 2000, 'E', 'stack line 3'))).to.have.length(1);
+            (0, chai_1.expect)(book.add(recAt(T0 + 4000, 'I', 'after'))).to.have.length(1);
+            (0, chai_1.expect)(book.keptLines).to.equal(5);
+        });
+        it('keeps the session window when nothing had arrived yet', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            book.interrupted(new Date(T0));
+            (0, chai_1.expect)(book.add(recAt(T0 - 60000))).to.deep.equal([]);
+            (0, chai_1.expect)(book.add(recAt(T0))).to.have.length(1);
+        });
+    });
+    describe('the limit', () => {
+        it('keeps every line up to the limit, then errors only, then nothing, and says so', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({
+                since: T0,
+                clock: deviceLogBook_1.UNKNOWN_CLOCK,
+                lineLimit: 3,
+                errorLimit: 2,
+            });
+            const kept = [];
+            const add = (level, msg, at) => kept.push(...book.add(recAt(T0 + at, level, msg)).map((r) => r.message));
+            add('D', 'a', 1);
+            add('I', 'b', 2);
+            add('W', 'c', 3);
+            add('I', 'chatter', 4); // past the limit: left out, after the note
+            add('E', 'FATAL EXCEPTION: main', 5);
+            add('D', 'more chatter', 6);
+            add('F', 'abort', 7);
+            add('E', 'one error too many', 8);
+            (0, chai_1.expect)(kept.map((m) => m.replace(/^.*Tag {5}: /, ''))).to.deep.equal([
+                'a',
+                'b',
+                'c',
+                'Xenon: This session reached 3 device log lines. From here on, only errors are kept.',
+                'FATAL EXCEPTION: main',
+                'abort',
+            ]);
+            (0, chai_1.expect)(book.finish(new Date(T0 + 9)).map((r) => r.message)).to.deep.equal([
+                "Xenon: 3 device log lines were left out to keep this session's log within its limit.",
+            ]);
+        });
+        it('says nothing at the end when nothing was left out', () => {
+            const book = new deviceLogBook_1.DeviceLogBook({ since: T0, clock: deviceLogBook_1.UNKNOWN_CLOCK });
+            book.add(recAt(T0));
+            (0, chai_1.expect)(book.finish(new Date(T0))).to.deep.equal([]);
+        });
+        it('is 10,000 lines, then 2,000 errors', () => {
+            (0, chai_1.expect)(deviceLogBook_1.DEVICE_LOG_LINE_LIMIT).to.equal(10000);
+            (0, chai_1.expect)(deviceLogBook_1.DEVICE_LOG_ERROR_LIMIT).to.equal(2000);
+        });
+    });
+    describe('parseDeviceClock', () => {
+        const fields = (at) => {
+            const t = new Date(at);
+            return `${pad(t.getMonth() + 1)}-${pad(t.getDate())}.${pad(t.getHours())}:${pad(t.getMinutes())}:${pad(t.getSeconds())}`;
+        };
+        it("finds a phone's time zone against this server's, to the quarter hour", () => {
+            const secs = Math.floor(T0 / 1000);
+            const ahead = 5.5 * 3600000;
+            // The phone prints its local time, 5 h 30 min ahead of this server's.
+            const out = `${secs}.348157848.${fields(secs * 1000 + ahead)}\n`;
+            const clock = (0, deviceLogBook_1.parseDeviceClock)(out, T0 + 300);
+            (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.zoneShiftMs).to.equal(-ahead);
+            (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.skewMs).to.equal(300 - 348);
+        });
+        it('finds a phone in the same zone, its clock 2.8 s slow, as the lab S9+ was', () => {
+            const secs = Math.floor(T0 / 1000) - 3;
+            const clock = (0, deviceLogBook_1.parseDeviceClock)(`${secs}.200000000.${fields(secs * 1000)}`, T0);
+            (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.zoneShiftMs).to.equal(0);
+            (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.skewMs).to.equal(2800);
+        });
+        it("takes the middle of the second when the phone's date prints no nanoseconds", () => {
+            const secs = Math.floor(T0 / 1000) + 7;
+            for (const nanos of ['%N', 'N', '']) {
+                const clock = (0, deviceLogBook_1.parseDeviceClock)(`${secs}.${nanos}.${fields(secs * 1000)}`, T0);
+                (0, chai_1.expect)(clock === null || clock === void 0 ? void 0 : clock.skewMs, nanos).to.equal(-7500);
+            }
+        });
+        it("is null for anything that isn't the date it asked for", () => {
+            (0, chai_1.expect)((0, deviceLogBook_1.parseDeviceClock)('', T0)).to.equal(null);
+            (0, chai_1.expect)((0, deviceLogBook_1.parseDeviceClock)('date: bad format', T0)).to.equal(null);
+            (0, chai_1.expect)((0, deviceLogBook_1.parseDeviceClock)('%s.%N.%m-%d.%H:%M:%S', T0)).to.equal(null);
+        });
+    });
+});