@xenon-device-management/xenon 2.3.0 → 2.5.0

package/lib/src/app/routers/dashboard.js

@@ -65,6 +65,7 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../../config");
 const sessionVisibility_1 = require("../../services/device-access/sessionVisibility");
 const HealEtalonService_1 = require("../../services/healing/HealEtalonService");
+const sessionInsights_1 = require("./sessionInsights");
 const logger_1 = __importDefault(require("../../logger"));
 const MJPEG_PROXY_CACHE = new Map();
 const authOf = (request) => request.auth;
@@ -100,10 +101,29 @@ function isValidSession(request, response, next) {
         }
     });
 }
+// A `since` that isn't a date is refused, rather than ignored into a list
+// of every session.
+function sinceOf(request, response) {
+    try {
+        return (0, sessionInsights_1.parseSince)(request.query.since);
+    }
+    catch (err) {
+        if (!(err instanceof sessionInsights_1.InvalidSinceError))
+            throw err;
+        response.status(400).json({ error: 'invalid_since', message: err.message });
+        return undefined;
+    }
+}
 function getSessions(request, response) {
     return __awaiter(this, void 0, void 0, function* () {
         const { buildId, query, status, platform } = request.query;
+        const since = sinceOf(request, response);
+        if (since === undefined)
+            return;
         const where = {};
+        if (since) {
+            where.createdAt = { gte: since };
+        }
         if (buildId) {
             where.build_id = buildId;
         }
@@ -132,7 +152,26 @@ function getSessions(request, response) {
             where: visible ? { AND: [where, visible] } : where,
             take: 500,
         });
-        return response.status(200).json(sessions);
+        return response.status(200).json(yield (0, sessionInsights_1.describeSessions)(sessions));
+    });
+}
+// The Sessions page's summary strip: the period since `since` (all time
+// without it) and the one before it, over the sessions the caller may see,
+// of one build when `buildId` is given.
+function getSessionSummary(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const since = sinceOf(request, response);
+        if (since === undefined)
+            return;
+        const { buildId } = request.query;
+        const visible = yield (0, sessionVisibility_1.visibleSessionWhere)(authOf(request));
+        const scope = {
+            AND: [
+                ...(visible ? [visible] : []),
+                ...(typeof buildId === 'string' && buildId ? [{ build_id: buildId }] : []),
+            ],
+        };
+        return response.status(200).json(yield (0, sessionInsights_1.summarizeSessions)(scope, since));
     });
 }
 function getBuilds(request, response) {
@@ -154,7 +193,7 @@ function getBuilds(request, response) {
         });
         const visibleBuilds = visible ? builds.filter((b) => b.sessions.length > 0) : builds;
         // Principal formatting: Add a flat summary object for the frontend
-        const formattedBuilds = visibleBuilds.map((b) => (Object.assign(Object.assign({}, b), { _count: { sessions: b.sessions.length }, sessionCount: b.sessions.length, passedCount: b.sessions.filter((s) => ['success', 'passed'].includes(s.status)).length, failedCount: b.sessions.filter((s) => s.status === 'failed').length, runningCount: b.sessions.filter((s) => s.status === 'running').length, sessions: undefined })));
+        const formattedBuilds = visibleBuilds.map((b) => (Object.assign(Object.assign({}, b), { _count: { sessions: b.sessions.length }, sessionCount: b.sessions.length, passedCount: b.sessions.filter((s) => (0, sessionInsights_1.sessionOutcome)(s.status) === 'passed').length, failedCount: b.sessions.filter((s) => (0, sessionInsights_1.sessionOutcome)(s.status) === 'failed').length, runningCount: b.sessions.filter((s) => (0, sessionInsights_1.sessionOutcome)(s.status) === 'running').length, sessions: undefined })));
         return response.status(200).json(formattedBuilds);
     });
 }
@@ -1074,6 +1113,7 @@ function register(router) {
     router.use('/session/:sessionId', isValidSession);
     router.use((0, roleGuard_1.roleGuard)('MEMBER'));
     router.get('/session', getSessions);
+    router.get('/session-summary', getSessionSummary);
     router.get('/session/:sessionId', getSessionById);
     router.get('/build', getBuilds);
     build_export_1.default.register(router);

package/lib/src/app/routers/nodePhoneControl.js

@@ -57,6 +57,7 @@ const forwardToNode_1 = require("../../gateway/forwardToNode");
 const manualLock_1 = require("../../services/recording/manualLock");
 const SessionOwnerResolver_1 = require("../../services/device-access/SessionOwnerResolver");
 const device_store_1 = require("../../data-service/device-store");
+const recording_store_1 = require("../../services/recording/recording-store");
 const deviceAccessPolicy_1 = require("../../services/device-access/deviceAccessPolicy");
 const controlDevice_1 = require("../../middleware/controlDevice");
 /**
@@ -217,14 +218,15 @@ function refuse(res, error, message) {
     return res.status(501).json({ success: false, error, message });
 }
 function nodePhoneControl(deps = {}) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     const findDevice = (_a = deps.findDevice) !== null && _a !== void 0 ? _a : controlDevice_1.findControlDeviceInStore;
+    const activeRecordingFor = (_b = deps.activeRecordingFor) !== null && _b !== void 0 ? _b : ((udid) => typedi_1.Container.get(recording_store_1.RecordingStore).activeRecordingFor(udid));
     const forwardDeps = {
-        timeoutMs: (_b = deps.timeoutMs) !== null && _b !== void 0 ? _b : exports.NODE_CONTROL_TIMEOUT_MS,
-        installTimeoutMs: (_c = deps.installTimeoutMs) !== null && _c !== void 0 ? _c : exports.NODE_INSTALL_TIMEOUT_MS,
-        markNodeBusy: (_d = deps.markNodeBusy) !== null && _d !== void 0 ? _d : ((udid, host, hold) => device_store_1.DeviceStoreFactory.getStore().markNodeBusy(udid, host, hold)),
-        describeHolder: (_e = deps.describeHolder) !== null && _e !== void 0 ? _e : ((id) => typedi_1.Container.get(SessionOwnerResolver_1.SessionOwnerResolver).displayName(id)),
-        controlToken: (_f = deps.controlToken) !== null && _f !== void 0 ? _f : defaultControlToken,
+        timeoutMs: (_c = deps.timeoutMs) !== null && _c !== void 0 ? _c : exports.NODE_CONTROL_TIMEOUT_MS,
+        installTimeoutMs: (_d = deps.installTimeoutMs) !== null && _d !== void 0 ? _d : exports.NODE_INSTALL_TIMEOUT_MS,
+        markNodeBusy: (_e = deps.markNodeBusy) !== null && _e !== void 0 ? _e : ((udid, host, hold) => device_store_1.DeviceStoreFactory.getStore().markNodeBusy(udid, host, hold)),
+        describeHolder: (_f = deps.describeHolder) !== null && _f !== void 0 ? _f : ((id) => typedi_1.Container.get(SessionOwnerResolver_1.SessionOwnerResolver).displayName(id)),
+        controlToken: (_g = deps.controlToken) !== null && _g !== void 0 ? _g : defaultControlToken,
     };
     return function (req, res, next) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -263,6 +265,27 @@ function nodePhoneControl(deps = {}) {
             if (!exports.NODE_FORWARDED_CONTROL.includes(key)) {
                 return refuse(res, 'not_available_through_hub', `This phone is on node ${node}, and the hub doesn't pass ${action} on to nodes yet.`);
             }
+            if (key === 'POST stream/stop') {
+                // This server may be recording the phone from the node's stream
+                // (nodeRecordingSource.ts). The node doesn't know, and stopping its
+                // stream would cut the recording short: refused as /control refuses a
+                // stop for its own phones being recorded.
+                const recording = yield activeRecordingFor(udid).catch((e) => {
+                    var _a;
+                    logger_1.default.error(`nodePhoneControl: recording lookup failed for ${udid}: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
+                    return undefined;
+                });
+                if (recording === undefined)
+                    return res.status(503).json((0, deviceAccessPolicy_1.ownershipUnavailableBody)());
+                if (recording) {
+                    return res.status(409).json({
+                        success: false,
+                        error: 'device_recording',
+                        message: 'This device is being recorded. Stop the recording first.',
+                        groupId: recording.groupId,
+                    });
+                }
+            }
             return forward(req, res, { udid, device, node }, forwardDeps);
         });
     };

package/lib/src/app/routers/sessionInsights.js

@@ -0,0 +1,221 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSinceError = void 0;
+exports.sessionOutcome = sessionOutcome;
+exports.parseSince = parseSince;
+exports.describeSessions = describeSessions;
+exports.percentile = percentile;
+exports.summarizeSessions = summarizeSessions;
+const typedi_1 = require("typedi");
+const prisma_1 = require("../../prisma");
+const PluginContext_1 = require("../../PluginContext");
+const localDeviceHosts_1 = require("../../device-managers/localDeviceHosts");
+/**
+ * The verdict of a persisted `Session.status`. The dashboard's
+ * `sessionStatusBucket` (web/src/components/builds/derive.ts) is the same
+ * rule, so a build's counts and its rows agree.
+ */
+function sessionOutcome(status) {
+    switch (status) {
+        case 'success':
+        case 'passed':
+        case 'ended':
+            return 'passed';
+        case 'failed':
+        case 'error':
+        case 'timeout':
+            return 'failed';
+        case 'running':
+            return 'running';
+        default:
+            return 'other';
+    }
+}
+class InvalidSinceError extends Error {
+    constructor() {
+        super('since must be an ISO 8601 date');
+    }
+}
+exports.InvalidSinceError = InvalidSinceError;
+/** The `since` query parameter: null when absent; a date, or InvalidSinceError. */
+function parseSince(raw) {
+    if (raw === undefined || raw === '')
+        return null;
+    const at = typeof raw === 'string' ? Date.parse(raw) : NaN;
+    if (!Number.isFinite(at))
+        throw new InvalidSinceError();
+    return new Date(at);
+}
+/**
+ * Each listed session with who ran it (`owner`) and where (`ranOn`): 'here'
+ * for this server, the node's host for another server's phone, null when
+ * that isn't known any more. Four queries for the whole list, never one per
+ * row. Members can't read the users list, so the dashboard can't name owners
+ * itself.
+ */
+function describeSessions(rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [owners, places] = yield Promise.all([ownersOf(rows), placesOf(rows)]);
+        return rows.map((row) => {
+            var _a, _b;
+            return (Object.assign(Object.assign({}, row), { owner: (_a = owners.get(row.id)) !== null && _a !== void 0 ? _a : null, ranOn: (_b = places.get(row.id)) !== null && _b !== void 0 ? _b : null }));
+        });
+    });
+}
+// SessionOwnerResolver.ownerOf's rule, for a list: the row's user, else, for
+// a row written before user_id existed, its key's owner.
+function ownersOf(rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const legacyKeyIds = [
+            ...new Set(rows.filter((r) => !r.user_id && r.api_key_id).map((r) => r.api_key_id)),
+        ];
+        const keyOwner = new Map();
+        if (legacyKeyIds.length > 0) {
+            const keys = yield prisma_1.prisma.apiKey.findMany({
+                where: { id: { in: legacyKeyIds } },
+                select: { id: true, userId: true },
+            });
+            for (const key of keys)
+                keyOwner.set(key.id, key.userId);
+        }
+        const ownerId = (r) => { var _a; return (_a = r.user_id) !== null && _a !== void 0 ? _a : (r.api_key_id ? keyOwner.get(r.api_key_id) : undefined); };
+        const userIds = [...new Set(rows.map(ownerId).filter((id) => !!id))];
+        const users = userIds.length > 0
+            ? yield prisma_1.prisma.user.findMany({
+                where: { id: { in: userIds } },
+                select: { id: true, name: true, email: true },
+            })
+            : [];
+        const byId = new Map(users.map((u) => [u.id, { name: u.name || u.email, email: u.email }]));
+        const out = new Map();
+        for (const row of rows) {
+            const owner = byId.get((_a = ownerId(row)) !== null && _a !== void 0 ? _a : '');
+            if (owner)
+                out.set(row.id, owner);
+        }
+        return out;
+    });
+}
+// Node ids are new on every boot, so a session's node_id names its server
+// only until that server restarts. Past that, its phone's row says where it
+// is: the row of that node id, else the phone's only row. A udid on more than
+// one server (an emulator's) with no row of that node id isn't guessed.
+function placesOf(rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        const nodeIds = [...new Set(rows.map((r) => r.node_id).filter(Boolean))];
+        const udids = [...new Set(rows.map((r) => r.device_udid).filter(Boolean))];
+        if (udids.length === 0 && nodeIds.length === 0)
+            return new Map();
+        const devices = yield prisma_1.prisma.device.findMany({
+            where: { OR: [{ nodeId: { in: nodeIds } }, { udid: { in: udids } }] },
+            select: { udid: true, host: true, nodeId: true },
+        });
+        const local = (0, localDeviceHosts_1.localDeviceHosts)(context.pluginArgs, context.port);
+        const out = new Map();
+        for (const row of rows) {
+            if (row.node_id && row.node_id === context.nodeId) {
+                out.set(row.id, 'here');
+                continue;
+            }
+            const sameUdid = devices.filter((d) => d.udid === row.device_udid);
+            const device = (_a = sameUdid.find((d) => d.nodeId && d.nodeId === row.node_id)) !== null && _a !== void 0 ? _a : (sameUdid.length === 1 ? sameUdid[0] : undefined);
+            if (!device)
+                continue;
+            out.set(row.id, (0, localDeviceHosts_1.isOwnDevice)(local, context.nodeId, device) ? 'here' : hostLabel(device.host));
+        }
+        return out;
+    });
+}
+/** A host as people read it: no scheme, no trailing slash. */
+function hostLabel(host) {
+    return host.replace(/^[a-z][a-z0-9+.-]*:\/\//i, '').replace(/\/+$/, '');
+}
+/**
+ * Durations come from at most this many of the period's newest ended
+ * sessions, so a long period costs one bounded read; past it they are an
+ * estimate from the newest.
+ */
+const DURATION_SAMPLE = 10000;
+/** Nearest-rank percentile of ascending values; null for none. */
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return null;
+    const rank = Math.max(1, Math.ceil((p / 100) * sorted.length));
+    return sorted[rank - 1];
+}
+/**
+ * The Sessions page's summary strip: the period from `since` to now, the
+ * period of the same length before it, and what runs now, over the sessions
+ * `scope` admits (the caller's visibility, and a build when one is chosen).
+ * Without `since` the period is all time and there is none before it.
+ */
+function summarizeSessions(scope_1, since_1) {
+    return __awaiter(this, arguments, void 0, function* (scope, since, now = Date.now()) {
+        const within = (from, to) => {
+            const createdAt = {};
+            if (from)
+                createdAt.gte = from;
+            if (to)
+                createdAt.lt = to;
+            return Object.keys(createdAt).length ? { AND: [scope, { createdAt }] } : scope;
+        };
+        const counts = (where) => __awaiter(this, void 0, void 0, function* () {
+            // groupBy's generated type can't be satisfied with a `where` built at
+            // run time; the result's shape is fixed by `by` and `_count`.
+            const groups = (yield prisma_1.prisma.session.groupBy({
+                by: ['status'],
+                where,
+                _count: { _all: true },
+            }));
+            const out = { total: 0, passed: 0, failed: 0, running: 0 };
+            for (const g of groups) {
+                out.total += g._count._all;
+                const outcome = sessionOutcome(g.status);
+                if (outcome !== 'other')
+                    out[outcome] += g._count._all;
+            }
+            return out;
+        });
+        const current = within(since, null);
+        const previousFrom = since ? new Date(since.getTime() - (now - since.getTime())) : null;
+        const [currentCounts, previous, ended, running] = yield Promise.all([
+            counts(current),
+            since ? counts(within(previousFrom, since)) : Promise.resolve(null),
+            prisma_1.prisma.session.findMany({
+                where: { AND: [current, { endTime: { not: null } }, { status: { not: 'running' } }] },
+                select: { startTime: true, endTime: true },
+                orderBy: { createdAt: 'desc' },
+                take: DURATION_SAMPLE,
+            }),
+            prisma_1.prisma.session.findMany({
+                where: { AND: [scope, { status: 'running' }] },
+                select: { device_udid: true },
+            }),
+        ]);
+        const durations = ended
+            .map((s) => (s.endTime ? s.endTime.getTime() - s.startTime.getTime() : -1))
+            .filter((ms) => ms >= 0)
+            .sort((a, b) => a - b);
+        return {
+            since: since ? since.toISOString() : null,
+            current: Object.assign(Object.assign({}, currentCounts), { medianMs: percentile(durations, 50), p90Ms: percentile(durations, 90) }),
+            previous,
+            runningNow: {
+                sessions: running.length,
+                devices: new Set(running.map((s) => s.device_udid)).size,
+            },
+        };
+    });
+}

package/lib/src/services/recording/RecordingOrchestrator.js

@@ -70,6 +70,7 @@ const concurrency_gate_1 = require("./concurrency-gate");
 const device_service_1 = require("../../data-service/device-service");
 const device_store_1 = require("../../data-service/device-store");
 const manualLock_1 = require("./manualLock");
+const nodeRecordingSource_1 = require("./nodeRecordingSource");
 const ensureMjpegForRecording_1 = require("./ensureMjpegForRecording");
 const probeDuration_1 = require("./probeDuration");
 const annotationImage_1 = require("./annotationImage");
@@ -136,13 +137,15 @@ class RecordingError extends Error {
 exports.RecordingError = RecordingError;
 let RecordingOrchestrator = class RecordingOrchestrator {
     constructor(deps = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         /**
          * Recording ids currently being closed out. Both the user-initiated stop and
          * an ffmpeg self-exit finalize rows, and they can land at the same instant —
          * this keeps exactly one of them doing it.
          */
         this.finalizing = new Set();
+        /** The relays node phones' recordings read, by recording id, until finalized. */
+        this.nodeSources = new Map();
         this._deps = {
             busyPrecheck: (_a = deps.busyPrecheck) !== null && _a !== void 0 ? _a : typedi_1.Container.get(busy_precheck_1.BusyPrecheck),
             store: (_b = deps.store) !== null && _b !== void 0 ? _b : typedi_1.Container.get(recording_store_1.RecordingStore),
@@ -153,8 +156,9 @@ let RecordingOrchestrator = class RecordingOrchestrator {
         this.blockDeviceFn = (_f = deps.blockDeviceFn) !== null && _f !== void 0 ? _f : device_service_1.blockDevice;
         this.unblockDeviceFn = (_g = deps.unblockDeviceFn) !== null && _g !== void 0 ? _g : device_service_1.unblockDevice;
         this.ensureMjpegPortFn = (_h = deps.ensureMjpegPortFn) !== null && _h !== void 0 ? _h : ensureMjpegForRecording_1.ensureMjpegForRecording;
-        this.probeDurationMsFn = (_j = deps.probeDurationMsFn) !== null && _j !== void 0 ? _j : probeDuration_1.probeVideoDurationMs;
-        this.now = (_k = deps.now) !== null && _k !== void 0 ? _k : Date.now;
+        this.nodeSourceFn = (_j = deps.nodeSourceFn) !== null && _j !== void 0 ? _j : ((udid, actorId) => (0, nodeRecordingSource_1.recordingSourceFor)(udid, actorId));
+        this.probeDurationMsFn = (_k = deps.probeDurationMsFn) !== null && _k !== void 0 ? _k : probeDuration_1.probeVideoDurationMs;
+        this.now = (_l = deps.now) !== null && _l !== void 0 ? _l : Date.now;
     }
     get busyPrecheck() {
         return this._deps.busyPrecheck;
@@ -267,7 +271,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                 const host = deviceHosts[udid];
                 const filePath = typedi_1.Container.get(ArtifactStore_1.ARTIFACT_STORE).resolve(id, 'video', `${id}.mp4`);
                 try {
-                    const mjpegPort = yield this.ensureMjpegPortFn(udid);
+                    const mjpegPort = yield this.sourcePort(id, udid, actorId);
                     mjpegPorts[udid] = mjpegPort;
                     yield this.store.create({
                         id,
@@ -294,6 +298,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                 }
                 catch (err) {
                     recLog.error(`Failed to start recording for ${udid}: ${err === null || err === void 0 ? void 0 : err.message}`);
+                    yield this.closeNodeSource(id);
                     // Mark this one failed but continue with the rest of the group.
                     try {
                         yield this.store.finalize(id, {
@@ -392,6 +397,8 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                 status = 'FAILED';
                 failReason = (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : 'ffmpeg_stop_failed';
             }
+            // Its ffmpeg is done reading; a group's composite stops before this.
+            yield this.closeNodeSource(r.id);
             // How long the video actually is, not how long the session was open. Those
             // agree only while capture keeps up: a recording whose device died at 26s
             // and was stopped 5 minutes later reported 5m36s for a 35s file (#204).
@@ -804,7 +811,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
             }
             const filePath = typedi_1.Container.get(ArtifactStore_1.ARTIFACT_STORE).resolve(recordingId, 'video', `${recordingId}.mp4`);
             try {
-                const mjpegPort = yield this.ensureMjpegPortFn(udid);
+                const mjpegPort = yield this.sourcePort(recordingId, udid, actorId);
                 yield this.store.create({
                     id: recordingId,
                     groupId,
@@ -829,6 +836,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
             }
             catch (err) {
                 recLog.error(`Failed to add device ${udid} to group ${groupId}: ${err === null || err === void 0 ? void 0 : err.message}`);
+                yield this.closeNodeSource(recordingId);
                 this.gate.release(recordingId);
                 yield this.tryUnblock(udid, host);
                 try {
@@ -940,6 +948,32 @@ let RecordingOrchestrator = class RecordingOrchestrator {
             }
         });
     }
+    /**
+     * The loopback port a recording reads: this server's own phone's MJPEG
+     * stream, or, for another server's phone, a relay to its node's, kept until
+     * the recording is finalized (nodeRecordingSource.ts).
+     */
+    sourcePort(recordingId, udid, actorId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const relay = yield this.nodeSourceFn(udid, actorId);
+            if (!relay)
+                return this.ensureMjpegPortFn(udid);
+            this.nodeSources.set(recordingId, relay);
+            return relay.port;
+        });
+    }
+    closeNodeSource(recordingId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const relay = this.nodeSources.get(recordingId);
+            if (!relay)
+                return;
+            this.nodeSources.delete(recordingId);
+            yield relay.close().catch((err) => {
+                var _a;
+                recLog.warn(`Closing the node relay of ${recordingId} failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            });
+        });
+    }
     tryUnblock(udid, host) {
         return __awaiter(this, void 0, void 0, function* () {
             try {

package/lib/src/services/recording/busy-precheck.js

@@ -64,7 +64,7 @@ let BusyPrecheck = class BusyPrecheck {
      */
     findBusy(udids, actorId, actorApiKeyId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             const store = this.storeProvider();
             const out = [];
             for (const udid of udids) {
@@ -81,7 +81,10 @@ let BusyPrecheck = class BusyPrecheck {
                 }
                 if (!device.busy)
                     continue;
-                const blockId = (_a = device.session_id) !== null && _a !== void 0 ? _a : undefined;
+                // This server's own hold, else, on a hub, a node phone's preview hold
+                // its node reports (nodeHold): session_id is the hub's and stays empty
+                // for it, which read as unknown and refused the holder their own phone.
+                const blockId = (_b = (_a = device.session_id) !== null && _a !== void 0 ? _a : device.nodeHold) !== null && _b !== void 0 ? _b : undefined;
                 const lock = (0, manualLock_1.inspectManualLock)(blockId, actorId, udid);
                 // Single source of truth for "is this lock mine" — the same helper
                 // /control's guard, stream/start and stream/stop use. Checking only

package/lib/src/services/recording/nodeRecordingSource.js

@@ -0,0 +1,156 @@
+"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 });
+exports.NODE_STREAM_READY_TIMEOUT_MS = void 0;
+exports.openNodeMjpegRelay = openNodeMjpegRelay;
+exports.recordingSourceFor = recordingSourceFor;
+const http_1 = __importDefault(require("http"));
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const hubSessionToken_1 = require("../../gateway/hubSessionToken");
+const forwardToNode_1 = require("../../gateway/forwardToNode");
+const nodePhoneControl_1 = require("../../app/routers/nodePhoneControl");
+const controlDevice_1 = require("../../middleware/controlDevice");
+const relayLog = logger_1.default.scope('NodeRecordingSource');
+/**
+ * How long a node's phone has to start streaming: an iPhone's WebDriverAgent
+ * and tunnel take tens of seconds on a cold start.
+ */
+exports.NODE_STREAM_READY_TIMEOUT_MS = 90000;
+const defaultControlToken = (grant) => typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).controlTokenFor(grant);
+/**
+ * A node's phone, recorded on this server: a loopback server whose every
+ * connection gets the node's MJPEG stream (`GET /control/<udid>/stream`),
+ * signed afresh for the recording's user. ffmpeg reads it like one of this
+ * server's own phones, and reconnects on any hiccup; the hub's control token
+ * lasts a minute and a recording much longer, so each connection signs again.
+ * The node counts the connection as a viewer, so its idle release leaves the
+ * stream running for as long as the recording reads it. Loopback only, like
+ * this server's own phones' MJPEG servers.
+ */
+function openNodeMjpegRelay(target_1) {
+    return __awaiter(this, arguments, void 0, function* (target, deps = {}) {
+        var _a, _b;
+        const { udid, host, actorId } = target;
+        const origin = (0, nodePhoneControl_1.safeNodeOrigin)(host);
+        if (!origin)
+            throw new Error(`Unsafe device host for ${udid}`);
+        const controlToken = (_a = deps.controlToken) !== null && _a !== void 0 ? _a : defaultControlToken;
+        const url = `${origin}/xenon/api/control/${encodeURIComponent(udid)}/stream`;
+        const headers = () => __awaiter(this, void 0, void 0, function* () {
+            const token = yield controlToken({ userId: actorId, isAdmin: false, udid, host });
+            return Object.assign({ accept: '*/*', 'accept-encoding': 'identity' }, (token ? { [hubSessionToken_1.HUB_TOKEN_HEADER]: token } : {}));
+        });
+        // As local recording starts the phone's stream before ffmpeg, the node's
+        // must be sending frames before the port is handed out. Its GET stream
+        // starts the stream; an iPhone's takes seconds. Otherwise the video began
+        // late, and every mark on it, timed from ffmpeg's start, was off by that.
+        yield untilStreaming(url, yield headers(), (_b = deps.readyTimeoutMs) !== null && _b !== void 0 ? _b : exports.NODE_STREAM_READY_TIMEOUT_MS);
+        const server = http_1.default.createServer((_req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const controller = new AbortController();
+            res.on('close', () => controller.abort());
+            try {
+                const upstream = yield (0, forwardToNode_1.sendToNode)({
+                    url,
+                    method: 'GET',
+                    headers: yield headers(),
+                    signal: controller.signal,
+                });
+                const type = upstream.headers['content-type'];
+                res.writeHead((_a = upstream.statusCode) !== null && _a !== void 0 ? _a : 502, Object.assign(Object.assign({}, (type ? { 'content-type': type } : {})), { 'cache-control': 'no-cache' }));
+                upstream.on('error', () => res.destroy());
+                upstream.pipe(res);
+            }
+            catch (err) {
+                if (res.headersSent) {
+                    res.destroy();
+                    return;
+                }
+                relayLog.warn(`[${udid}] node ${origin} stream unavailable: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
+                res.writeHead(502, { 'content-type': 'text/plain' });
+                res.end(`node unreachable: ${(_d = (_c = err === null || err === void 0 ? void 0 : err.code) !== null && _c !== void 0 ? _c : err === null || err === void 0 ? void 0 : err.message) !== null && _d !== void 0 ? _d : err}`);
+            }
+        }));
+        yield new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const { port } = server.address();
+        relayLog.info(`[${udid}] recording relay for node ${origin} on 127.0.0.1:${port}`);
+        return {
+            port,
+            close: () => new Promise((resolve) => {
+                var _a;
+                (_a = server.closeAllConnections) === null || _a === void 0 ? void 0 : _a.call(server);
+                server.close(() => resolve());
+            }),
+        };
+    });
+}
+/**
+ * Resolves once the node's stream sends its first bytes; throws when the node
+ * refuses it, ends it first, or sends nothing within `timeoutMs`.
+ */
+function untilStreaming(url, headers, timeoutMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const controller = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+        try {
+            const upstream = yield (0, forwardToNode_1.sendToNode)({ url, method: 'GET', headers, signal: controller.signal });
+            if (((_a = upstream.statusCode) !== null && _a !== void 0 ? _a : 502) !== 200) {
+                const answer = yield (0, forwardToNode_1.readAnswer)(upstream);
+                throw new Error(`the node answered ${answer.status} for the stream: ${answer.body.toString('utf8').slice(0, 200)}`);
+            }
+            yield new Promise((resolve, reject) => {
+                upstream.once('data', () => resolve());
+                upstream.once('end', () => reject(new Error("the node's stream ended before its first frame")));
+                upstream.once('error', reject);
+            });
+        }
+        catch (err) {
+            if (timedOut) {
+                throw new Error(`the node's stream sent no first frame within ${Math.round(timeoutMs / 1000)} s`);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+            controller.abort();
+        }
+    });
+}
+/**
+ * The recording source for a phone: a relay to its node for another server's
+ * phone, null for this server's own (or an unknown) phone, which the caller
+ * reads locally as before. A cloud provider's phone can't be recorded here.
+ */
+function recordingSourceFor(udid_1, actorId_1) {
+    return __awaiter(this, arguments, void 0, function* (udid, actorId, deps = {}) {
+        var _a;
+        const findDevice = (_a = deps.findDevice) !== null && _a !== void 0 ? _a : controlDevice_1.findControlDeviceInStore;
+        const device = yield findDevice(udid);
+        if (!device || !(0, nodePhoneControl_1.isOtherServersPhone)(device))
+            return null;
+        if (device.cloud) {
+            throw new Error(`${udid} is a cloud provider's phone and can't be recorded here.`);
+        }
+        return openNodeMjpegRelay({ udid, host: device.host, actorId }, deps);
+    });
+}