@xenon-device-management/xenon 2.2.0 → 2.4.0

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

@@ -8,15 +8,45 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NODE_CONTROL_TIMEOUT_MS = exports.ANSWERED_HERE = exports.NODE_FORWARDED_CONTROL = void 0;
+exports.NODE_INSTALL_TIMEOUT_MS = exports.NODE_CONTROL_TIMEOUT_MS = exports.ANSWERED_HERE_FOR_NODES = exports.ANSWERED_HERE = exports.NODE_FORWARDED_CONTROL = void 0;
 exports.safeNodeOrigin = safeNodeOrigin;
 exports.nodeControlUrl = nodeControlUrl;
 exports.isOtherServersPhone = isOtherServersPhone;
 exports.nodePhoneControl = nodePhoneControl;
+exports.installFileOnNode = installFileOnNode;
+exports.screenshotFromNode = screenshotFromNode;
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+const stream_1 = require("stream");
 const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../../logger"));
 const PluginContext_1 = require("../../PluginContext");
@@ -24,7 +54,10 @@ const localDeviceHosts_1 = require("../../device-managers/localDeviceHosts");
 const actor_1 = require("../../services/device-access/actor");
 const hubSessionToken_1 = require("../../gateway/hubSessionToken");
 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");
 /**
@@ -66,6 +99,8 @@ exports.NODE_FORWARDED_CONTROL = [
     'POST stream/stop',
     // The MJPEG stream itself: relayed for as long as the viewer watches.
     'GET stream',
+    // The upload is streamed on as it came: nothing here reads it first.
+    'POST upload-install',
 ];
 /**
  * Answered by this server's own handler.
@@ -77,19 +112,36 @@ exports.NODE_FORWARDED_CONTROL = [
  *   which get a ticket of the node's own.
  */
 exports.ANSWERED_HERE = ['GET appium-session', 'POST stream/ticket'];
-// Not on either list, and why, so nobody adds them as a plain forward:
-// - upload-install is a multipart upload;
-// - install-repository-app installs a file from this server's app library,
-//   which the node doesn't have;
-// - install takes a path, which names a file on one machine only;
-// - omni-scan and test-locator run this server's AI settings on a
-//   screenshot.
+/**
+ * Answered by this server's own handler for a node's phone (a cloud
+ * provider's is refused), which does its part here and asks the node for
+ * the rest:
+ * - install-repository-app: the app is in this server's library, checked
+ *   against the caller's teams here, and sent to the node's upload-install
+ *   (installFileOnNode).
+ * - omni-scan, test-locator: Omni-Vision runs here, with this server's AI
+ *   settings, on the node's screenshot (screenshotFromNode).
+ */
+exports.ANSWERED_HERE_FOR_NODES = [
+    'POST install-repository-app',
+    'GET omni-scan',
+    'POST test-locator',
+];
+// Not on any list, so refused: install takes a path, which names a file on
+// one machine only.
 /**
  * A node that hasn't started answering in this long is treated as gone. Once
  * it has, the answer may take as long as it takes: a stream lasts as long as
  * its viewer.
  */
 exports.NODE_CONTROL_TIMEOUT_MS = 60000;
+/**
+ * An install is answered when it is done, which can take minutes (a large
+ * app, a slow phone): its node gets this long to start answering instead.
+ */
+exports.NODE_INSTALL_TIMEOUT_MS = 15 * 60000;
+/** Forwarded actions that are installs, and get NODE_INSTALL_TIMEOUT_MS. */
+const INSTALLS = ['POST upload-install'];
 // Cloud metadata endpoints — never proxy to these regardless of caller.
 const FORBIDDEN_PROXY_HOSTS = new Set([
     '169.254.169.254', // AWS/Azure/GCP IMDS
@@ -166,10 +218,16 @@ function refuse(res, error, message) {
     return res.status(501).json({ success: false, error, message });
 }
 function nodePhoneControl(deps = {}) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f, _g;
     const findDevice = (_a = deps.findDevice) !== null && _a !== void 0 ? _a : controlDevice_1.findControlDeviceInStore;
-    const timeoutMs = (_b = deps.timeoutMs) !== null && _b !== void 0 ? _b : exports.NODE_CONTROL_TIMEOUT_MS;
-    const markNodeBusy = (_c = deps.markNodeBusy) !== null && _c !== void 0 ? _c : ((udid, host) => device_store_1.DeviceStoreFactory.getStore().markNodeBusy(udid, host));
+    const activeRecordingFor = (_b = deps.activeRecordingFor) !== null && _b !== void 0 ? _b : ((udid) => typedi_1.Container.get(recording_store_1.RecordingStore).activeRecordingFor(udid));
+    const forwardDeps = {
+        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* () {
             var _a;
@@ -201,30 +259,53 @@ function nodePhoneControl(deps = {}) {
             if (device.cloud) {
                 return refuse(res, 'not_available_for_cloud_phone', "This phone is a cloud provider's. Device control isn't available for it here.");
             }
+            if (exports.ANSWERED_HERE_FOR_NODES.includes(key))
+                return next();
             const node = originOf(device.host);
             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.`);
             }
-            return forward(req, res, { udid, device, node, timeoutMs, markNodeBusy });
+            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);
         });
     };
 }
-function forward(req, res, target) {
+const defaultControlToken = (grant) => typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).controlTokenFor(grant);
+/**
+ * The headers of a call to the phone's node, signed for the caller. Null
+ * token when this server can't sign (it warns once): the call goes without,
+ * which a node with auth disabled accepts and one with auth enabled refuses.
+ */
+function signedHeaders(req, udid, device, controlToken) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f;
-        const { udid, device, node, timeoutMs } = target;
-        const url = nodeControlUrl(device.host, req);
-        if (!url)
-            return res.status(400).json({ error: 'Unsafe device host' });
+        var _a;
         const actor = (0, actor_1.resolveActor)(req);
         const headers = {
             accept: (_a = req.headers.accept) !== null && _a !== void 0 ? _a : 'application/json',
             'accept-encoding': 'identity',
         };
-        // Null when this server can't sign (it warns once): the call goes without,
-        // which a node with auth disabled accepts and one with auth enabled refuses.
         const token = actor.userId
-            ? yield typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).controlTokenFor({
+            ? yield controlToken({
                 userId: actor.userId,
                 isAdmin: actor.isAdmin,
                 udid,
@@ -233,44 +314,42 @@ function forward(req, res, target) {
             : null;
         if (token)
             headers[hubSessionToken_1.HUB_TOKEN_HEADER] = token;
-        let body;
-        if (req.method !== 'GET' && req.method !== 'HEAD') {
-            body = Buffer.from(JSON.stringify((_b = req.body) !== null && _b !== void 0 ? _b : {}));
-            headers['content-type'] = 'application/json';
-        }
+        return headers;
+    });
+}
+/**
+ * Send one call to the node and relay its answer to `res`. A node that can't
+ * be reached is 502, and one that hasn't started answering in `timeoutMs` is
+ * 504; once it has, the answer takes as long as it takes. `onAnswer` sees the
+ * node's answer first and may reply itself (returning true). Sent once: a
+ * retry after a slow node's timeout or 5xx could land the same tap twice.
+ */
+function relayNodeCall(res, call, onAnswer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
         const controller = new AbortController();
         let timedOut = false;
         const timer = setTimeout(() => {
             timedOut = true;
             controller.abort();
-        }, timeoutMs);
+        }, call.timeoutMs);
         // The caller left: stop waiting for the node on their behalf.
         const onClose = () => {
             if (!res.writableFinished)
                 controller.abort();
         };
         res.on('close', onClose);
-        logger_1.default.debug(`Forwarding ${req.method} ${(0, controlDevice_1.controlAction)(req)} for ${udid} to node ${node}`);
         try {
             const upstream = yield (0, forwardToNode_1.sendToNode)({
-                url,
-                method: req.method,
-                headers,
-                body,
+                url: call.url,
+                method: call.method,
+                headers: call.headers,
+                body: call.body,
                 signal: controller.signal,
             });
-            // The node has answered: from here the answer takes as long as it takes.
             clearTimeout(timer);
-            const status = (_c = upstream.statusCode) !== null && _c !== void 0 ? _c : 502;
-            if (req.method === 'POST' && (0, controlDevice_1.controlAction)(req) === 'stream/start' && status < 300) {
-                // The node holds the phone for the preview now, and says so in its
-                // next report, up to an interval away. Until then this server could
-                // hand the phone to a session the node would refuse.
-                yield target.markNodeBusy(udid, device.host).catch((e) => {
-                    var _a;
-                    logger_1.default.warn(`nodePhoneControl: could not mark ${udid} busy for its node: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
-                });
-            }
+            if (onAnswer && (yield onAnswer(upstream)))
+                return;
             yield (0, forwardToNode_1.relayAnswer)(upstream, res, false);
         }
         catch (e) {
@@ -281,15 +360,15 @@ function forward(req, res, target) {
                 res.status(504).json({
                     success: false,
                     error: 'node_timeout',
-                    message: `Node ${node} didn't answer within ${Math.round(timeoutMs / 1000)} s.`,
+                    message: `Node ${call.node} didn't answer within ${Math.round(call.timeoutMs / 1000)} s.`,
                 });
             }
             else {
-                logger_1.default.warn(`nodePhoneControl: node ${node} unreachable for ${udid}: ${(_d = e === null || e === void 0 ? void 0 : e.message) !== null && _d !== void 0 ? _d : e}`);
+                logger_1.default.warn(`nodePhoneControl: node ${call.node} unreachable for ${call.udid}: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
                 res.status(502).json({
                     success: false,
                     error: 'node_unreachable',
-                    message: `Xenon could not reach node ${node} for this phone: ${(_f = (_e = e === null || e === void 0 ? void 0 : e.code) !== null && _e !== void 0 ? _e : e === null || e === void 0 ? void 0 : e.message) !== null && _f !== void 0 ? _f : e}`,
+                    message: `Xenon could not reach node ${call.node} for this phone: ${(_c = (_b = e === null || e === void 0 ? void 0 : e.code) !== null && _b !== void 0 ? _b : e === null || e === void 0 ? void 0 : e.message) !== null && _c !== void 0 ? _c : e}`,
                 });
             }
         }
@@ -299,3 +378,166 @@ function forward(req, res, target) {
         }
     });
 }
+function forward(req, res, target, deps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { udid, device, node } = target;
+        const url = nodeControlUrl(device.host, req);
+        if (!url)
+            return res.status(400).json({ error: 'Unsafe device host' });
+        const key = `${req.method} ${(0, controlDevice_1.controlAction)(req)}`;
+        const actor = (0, actor_1.resolveActor)(req);
+        const headers = yield signedHeaders(req, udid, device, deps.controlToken);
+        let body;
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            const type = req.headers['content-type'];
+            if (typeof type === 'string' && type.toLowerCase().startsWith('multipart/')) {
+                // An upload, streamed on as it came: the route's own parser runs after
+                // this, so nothing here has read it.
+                body = req;
+                headers['content-type'] = type;
+                if (req.headers['content-length'])
+                    headers['content-length'] = req.headers['content-length'];
+            }
+            else {
+                body = Buffer.from(JSON.stringify((_a = req.body) !== null && _a !== void 0 ? _a : {}));
+                headers['content-type'] = 'application/json';
+            }
+        }
+        logger_1.default.debug(`Forwarding ${key} for ${udid} to node ${node}`);
+        const timeoutMs = INSTALLS.includes(key) ? deps.installTimeoutMs : deps.timeoutMs;
+        yield relayNodeCall(res, { url, method: req.method, headers, body, timeoutMs, node, udid }, (upstream) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const status = (_a = upstream.statusCode) !== null && _a !== void 0 ? _a : 502;
+            if (key === 'POST stream/start' && status < 300) {
+                // The node holds the phone for the preview now, and says so in its
+                // next report, up to an interval away. Until then this server could
+                // hand the phone to a session the node would refuse, and would show
+                // no holder. The node writes the same hold for the same user.
+                const hold = actor.userId ? (0, manualLock_1.formatManualLock)(actor.userId, udid) : undefined;
+                yield deps.markNodeBusy(udid, device.host, hold).catch((e) => {
+                    var _a;
+                    logger_1.default.warn(`nodePhoneControl: could not mark ${udid} busy for its node: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
+                });
+            }
+            if (status === 409) {
+                yield relayRefusal(yield (0, forwardToNode_1.readAnswer)(upstream), res, deps.describeHolder);
+                return true;
+            }
+            return false;
+        }));
+    });
+}
+/**
+ * A file as a multipart upload in one field, streamed from disk, with its
+ * length known so the node's parser can apply its limit up front.
+ */
+function multipartFile(field, file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const boundary = `----xenon-${(0, crypto_1.randomBytes)(12).toString('hex')}`;
+        const name = file.name.replace(/["\\\r\n]/g, '_');
+        const head = Buffer.from(`--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="${field}"; filename="${name}"\r\n` +
+            'Content-Type: application/octet-stream\r\n\r\n');
+        const tail = Buffer.from(`\r\n--${boundary}--\r\n`);
+        const { size } = yield fs_1.default.promises.stat(file.path);
+        const stream = stream_1.Readable.from((function () {
+            return __asyncGenerator(this, arguments, function* () {
+                yield yield __await(head);
+                yield __await(yield* __asyncDelegator(__asyncValues(fs_1.default.createReadStream(file.path))));
+                yield yield __await(tail);
+            });
+        })());
+        return {
+            type: `multipart/form-data; boundary=${boundary}`,
+            length: head.length + size + tail.length,
+            stream,
+        };
+    });
+}
+/**
+ * Install a file of this server's on another server's phone: sent to the
+ * node's upload-install as a multipart upload, signed for the caller, and
+ * the node's answer relayed. install-repository-app's, for an app from this
+ * server's library, which the node doesn't have. The file's name keeps the
+ * extension the node's installer reads.
+ */
+function installFileOnNode(req_1, res_1, udid_1, device_1, file_1) {
+    return __awaiter(this, arguments, void 0, function* (req, res, udid, device, file, deps = {}) {
+        var _a, _b;
+        const origin = safeNodeOrigin(device.host);
+        if (!origin) {
+            res.status(400).json({ error: 'Unsafe device host' });
+            return;
+        }
+        const headers = yield signedHeaders(req, udid, device, (_a = deps.controlToken) !== null && _a !== void 0 ? _a : defaultControlToken);
+        const upload = yield multipartFile('app', file);
+        headers['content-type'] = upload.type;
+        headers['content-length'] = upload.length;
+        logger_1.default.info(`Sending ${file.name} to node ${origin} to install on ${udid}`);
+        yield relayNodeCall(res, {
+            url: `${origin}/xenon/api/control/${encodeURIComponent(udid)}/upload-install`,
+            method: 'POST',
+            headers,
+            body: upload.stream,
+            timeoutMs: (_b = deps.timeoutMs) !== null && _b !== void 0 ? _b : exports.NODE_INSTALL_TIMEOUT_MS,
+            node: origin,
+            udid,
+        });
+    });
+}
+/**
+ * The node's screenshot of another server's phone, base64, for work this
+ * server does on it: Omni-Vision, with this server's AI settings. Throws when
+ * the node doesn't give one.
+ */
+function screenshotFromNode(req_1, udid_1, device_1) {
+    return __awaiter(this, arguments, void 0, function* (req, udid, device, deps = {}) {
+        var _a, _b, _c;
+        const origin = safeNodeOrigin(device.host);
+        if (!origin)
+            throw new Error('Unsafe device host');
+        const headers = yield signedHeaders(req, udid, device, (_a = deps.controlToken) !== null && _a !== void 0 ? _a : defaultControlToken);
+        headers.accept = 'application/json';
+        const answer = yield (0, forwardToNode_1.readAnswer)(yield (0, forwardToNode_1.sendToNode)({
+            url: `${origin}/xenon/api/control/${encodeURIComponent(udid)}/screenshot`,
+            method: 'GET',
+            headers,
+            signal: AbortSignal.timeout((_b = deps.timeoutMs) !== null && _b !== void 0 ? _b : exports.NODE_CONTROL_TIMEOUT_MS),
+        }));
+        if (answer.status !== 200) {
+            throw new Error(`Node ${origin} answered ${answer.status} for a screenshot`);
+        }
+        const shot = (_c = JSON.parse(answer.body.toString('utf8'))) === null || _c === void 0 ? void 0 : _c.screenshot;
+        if (typeof shot !== 'string' || !shot)
+            throw new Error(`Node ${origin} sent no screenshot`);
+        return shot;
+    });
+}
+const HOLDER_REFUSALS = new Set(['device_held_by_another_user', 'device_in_use_by_session']);
+/**
+ * A node's 409, with the holder's name filled in when the node could only
+ * give their id: its database has no rows for this server's users, so it
+ * says "another user". The wording is denyBody's, as for this server's own
+ * refusals. Anything else is passed on as it came.
+ */
+function relayRefusal(answer, res, describeHolder) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let refusal;
+        try {
+            refusal = JSON.parse(answer.body.toString('utf8'));
+        }
+        catch (_b) {
+            return (0, forwardToNode_1.sendAnswer)(res, answer);
+        }
+        const holderId = (_a = refusal === null || refusal === void 0 ? void 0 : refusal.holder) === null || _a === void 0 ? void 0 : _a.userId;
+        if (!HOLDER_REFUSALS.has(refusal === null || refusal === void 0 ? void 0 : refusal.error) || typeof holderId !== 'string' || refusal.holder.name) {
+            return (0, forwardToNode_1.sendAnswer)(res, answer);
+        }
+        const name = yield describeHolder(holderId).catch(() => null);
+        if (!name)
+            return (0, forwardToNode_1.sendAnswer)(res, answer);
+        res.status(409).json(Object.assign(Object.assign({}, refusal), (0, deviceAccessPolicy_1.denyBody)(refusal.error, holderId, name)));
+    });
+}

package/lib/src/data-service/device-store.js

@@ -173,8 +173,9 @@ class LokiDeviceStore {
                 const existing = deviceModel.findOne({ udid: device.udid, host: device.host });
                 // A node's report (PrismaDeviceStore.addNodeReport has the rule).
                 const nodeBusy = device.busy === true;
+                const nodeHold = (0, deviceClaims_1.nodeHoldOf)(device.session_id);
                 if (existing && options.nodeReport) {
-                    Object.assign(existing, (0, deviceFieldOwners_1.pickNodeReportFields)(device), { nodeBusy });
+                    Object.assign(existing, (0, deviceFieldOwners_1.pickNodeReportFields)(device), { nodeBusy, nodeHold });
                     if (nodeBusy)
                         existing.busy = true;
                     else if ((0, deviceClaims_1.isUnheld)(existing))
@@ -184,7 +185,8 @@ class LokiDeviceStore {
                 }
                 if (!existing) {
                     const cleanDevice = options.nodeReport
-                        ? Object.assign(Object.assign({}, (0, deviceFieldOwners_1.pickNodeReportFields)(device)), { udid: device.udid, host: device.host, busy: nodeBusy, nodeBusy })
+                        ? Object.assign(Object.assign({}, (0, deviceFieldOwners_1.pickNodeReportFields)(device)), { udid: device.udid, host: device.host, busy: nodeBusy, nodeBusy,
+                            nodeHold })
                         : Object.assign({}, device);
                     if (cleanDevice.host === undefined)
                         cleanDevice.host = 'Local';
@@ -293,7 +295,7 @@ class LokiDeviceStore {
             return true;
         });
     }
-    markNodeBusy(udid, host) {
+    markNodeBusy(udid, host, hold) {
         return __awaiter(this, void 0, void 0, function* () {
             const model = yield db_1.XenonDatabase.DeviceModel;
             const device = model.findOne({ udid, host });
@@ -301,6 +303,8 @@ class LokiDeviceStore {
                 return;
             device.nodeBusy = true;
             device.busy = true;
+            if (hold)
+                device.nodeHold = hold;
             model.update(device);
         });
     }

package/lib/src/data-service/deviceClaims.js

@@ -7,7 +7,9 @@ exports.claimWhere = claimWhere;
 exports.holdsClaim = holdsClaim;
 exports.hasNoClaim = hasNoClaim;
 exports.isUnheld = isUnheld;
+exports.nodeHoldOf = nodeHoldOf;
 exports.heldHere = heldHere;
+const manualLock_1 = require("../services/recording/manualLock");
 /**
  * Why a phone is busy, on the server that allocates it.
  *
@@ -95,6 +97,18 @@ exports.UNHELD = Object.assign(Object.assign({}, exports.NO_CLAIM), { session_id
 function isUnheld(device) {
     return hasNoClaim(device) && device.session_id == null && device.nodeBusy !== true;
 }
+/**
+ * Who holds a node's phone there, from the node's report of it: its
+ * `session_id` when that is a preview hold (`manual_<user>_<udid>`), else
+ * null. A session the node runs is not a hold. The hub keeps it as
+ * `nodeHold`, apart from its own `session_id`, and shows it; the node decides
+ * access, so a stale value can change a label and nothing else.
+ */
+function nodeHoldOf(reportedSessionId) {
+    return typeof reportedSessionId === 'string' && (0, manualLock_1.isManualLock)(reportedSessionId)
+        ? reportedSessionId
+        : null;
+}
 /**
  * Busy for a reason this server has on record: its claim, a session or hold
  * in `session_id`, or plain `busy` on a phone of its own. False for a node's

package/lib/src/data-service/deviceFieldOwners.js

@@ -89,6 +89,7 @@ const OWNER = {
     thermalStatus: 'observed',
     storageFree: 'observed',
     nodeBusy: 'report',
+    nodeHold: 'report',
 };
 /** The columns a sync may write to a phone it already knows. */
 exports.DISCOVERY_FIELDS = new Set(Object.keys(OWNER).filter((column) => OWNER[column] === 'discovery'));
@@ -98,7 +99,8 @@ function pickDiscoveryFields(data) {
 }
 /**
  * The columns a hub takes from a node's report of a phone: what the node
- * observes of it. Not `nodeBusy`, which the hub sets from the report's `busy`.
+ * observes of it. Not `nodeBusy` and `nodeHold`, which the hub sets from the
+ * report's `busy` and `session_id` (deviceClaims.ts nodeHoldOf).
  */
 exports.NODE_REPORT_FIELDS = new Set(Object.keys(OWNER).filter((column) => OWNER[column] === 'discovery' || OWNER[column] === 'observed'));
 /** Only the columns of `data` a hub takes from a node's report. */

package/lib/src/data-service/prisma-store.js

@@ -254,7 +254,7 @@ class PrismaDeviceStore {
         return __awaiter(this, void 0, void 0, function* () {
             const { udid, host } = device;
             const nodeBusy = device.busy === true;
-            const reported = Object.assign(Object.assign({}, (0, deviceFieldOwners_1.pickNodeReportFields)(this.fromIDevice(device))), { nodeBusy });
+            const reported = Object.assign(Object.assign({}, (0, deviceFieldOwners_1.pickNodeReportFields)(this.fromIDevice(device))), { nodeBusy, nodeHold: (0, deviceClaims_1.nodeHoldOf)(device.session_id) });
             const row = yield this.prisma.device.upsert({
                 where: { udid_host: { udid, host } },
                 update: nodeBusy ? Object.assign(Object.assign({}, reported), { busy: true }) : reported,
@@ -386,11 +386,11 @@ class PrismaDeviceStore {
             return cleared.count > 0;
         });
     }
-    markNodeBusy(udid, host) {
+    markNodeBusy(udid, host, hold) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.prisma.device.updateMany({
                 where: { udid, host },
-                data: { nodeBusy: true, busy: true },
+                data: Object.assign({ nodeBusy: true, busy: true }, (hold ? { nodeHold: hold } : {})),
             });
         });
     }

package/lib/src/device-managers/AndroidDeviceManager.js

@@ -54,6 +54,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANDROID_INSTALL_TIMEOUT_MS = void 0;
 exports.includesAndroidDevice = includesAndroidDevice;
 const displayState_1 = require("./android/displayState");
 const networkAddresses_1 = require("../helpers/networkAddresses");
@@ -81,6 +82,13 @@ const deviceIdentity_1 = require("./deviceIdentity");
 const localDeviceHosts_1 = require("./localDeviceHosts");
 const PluginContext_1 = require("../PluginContext");
 const typedi_2 = require("typedi");
+/**
+ * How long `adb install` may take. It answers when the phone has installed
+ * the app, which for a large app on a slow phone is minutes; appium-adb's
+ * own limit (adbExecTimeout, 20 s) reported such installs as failed though
+ * they had worked. Within the 15 minutes a hub gives a node's install.
+ */
+exports.ANDROID_INSTALL_TIMEOUT_MS = 10 * 60000;
 /**
  * Whether a server set to `androidDeviceType` serves this phone: real phones,
  * emulators ('simulated'), or both, and with `bootedEmulators` only the
@@ -784,7 +792,9 @@ let AndroidDeviceManager = class AndroidDeviceManager {
             const { adbInstance } = yield this.getAdb();
             if (!adbInstance)
                 throw new Error('ADB is not available');
-            yield adbInstance.adbExec(['-s', udid, 'install', '-r', appPath]);
+            yield adbInstance.adbExec(['-s', udid, 'install', '-r', appPath], {
+                timeout: exports.ANDROID_INSTALL_TIMEOUT_MS,
+            });
         });
     }
     uninstallApp(udid, bundleId) {

package/lib/src/gateway/forwardToNode.js

@@ -74,12 +74,19 @@ function sendToNode(request) {
     const url = new URL(request.url);
     const lib = url.protocol === 'https:' ? https_1.default : http_1.default;
     const headers = Object.assign({}, request.headers);
-    if (request.body)
-        headers['content-length'] = request.body.length;
+    const body = request.body;
+    if (Buffer.isBuffer(body))
+        headers['content-length'] = body.length;
     return new Promise((resolve, reject) => {
         const outgoing = lib.request(url, { method: request.method, headers, agent: proxyAgentFor(url), signal: request.signal }, resolve);
         outgoing.on('error', reject);
-        outgoing.end(request.body);
+        if (body && !Buffer.isBuffer(body)) {
+            body.on('error', (err) => outgoing.destroy(err));
+            body.pipe(outgoing);
+        }
+        else {
+            outgoing.end(body);
+        }
     });
 }
 function copyResponseHeaders(upstream, res) {