@xenon-device-management/xenon 2.2.0 → 2.4.0

package/lib/src/generated/client/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "prisma-client-2fecbe6024329bf05b69cdf448f1b687e32645450beda6a210a882d44a7ffb8d",
+  "name": "prisma-client-631e8540dfbb77c390eb0db189885974a87d3fa754d038cb48bcc6a9f3489314",
   "main": "index.js",
   "types": "index.d.ts",
   "browser": "index-browser.js",

package/lib/src/generated/client/schema.prisma

@@ -204,6 +204,10 @@ model Device {
   // On a hub, what the phone's node last reported: busy there. `busy` is the
   // claim OR this. Always false for a phone this server drives.
   nodeBusy                     Boolean? @default(false)
+  // On a hub, who holds the phone there: the preview hold (manual_<user>_<udid>)
+  // in the node's report of its session_id, else null. Shown, never judged:
+  // the node decides access. Always null for a phone this server drives.
+  nodeHold                     String?
 
   @@id([udid, host])
   @@index([owningSessionId])

package/lib/src/generated/client/wasm.js

@@ -285,7 +285,8 @@ exports.Prisma.DeviceScalarFieldEnum = {
   teamId: 'teamId',
   claimSessionId: 'claimSessionId',
   claimedAt: 'claimedAt',
-  nodeBusy: 'nodeBusy'
+  nodeBusy: 'nodeBusy',
+  nodeHold: 'nodeHold'
 };
 
 exports.Prisma.PendingSessionScalarFieldEnum = {

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);
+    });
+}

package/lib/test/unit/AndroidDeviceManager.spec.js

@@ -166,6 +166,18 @@ describe('Android Device Manager', () => {
         (0, chai_1.expect)(devices.length).to.be.equal(1);
         (0, chai_1.expect)(devices[0]).to.have.property('udid', 'emulator-7777');
     }));
+    // adb install answers when the phone has installed the app, and appium-adb
+    // cut every adbExec at 20 s (adbExecTimeout): an install that took longer
+    // was reported as failed though it had worked.
+    it('gives adb install as long as an install takes, not adbExec’s 20 s', () => __awaiter(void 0, void 0, void 0, function* () {
+        const manager = (0, test_container_1.createTestAndroidManager)({ platform: 'android' });
+        const adbExec = sandbox.stub().resolves('Success');
+        sandbox.stub(manager, 'getAdb').resolves({ adbInstance: { adbExec } });
+        yield manager.installApp('p1', '/tmp/app.apk');
+        (0, chai_1.expect)(adbExec.firstCall.args[0]).to.deep.equal(['-s', 'p1', 'install', '-r', '/tmp/app.apk']);
+        (0, chai_1.expect)(adbExec.firstCall.args[1]).to.deep.equal({ timeout: AndroidDeviceManager_1.ANDROID_INSTALL_TIMEOUT_MS });
+        (0, chai_1.expect)(AndroidDeviceManager_1.ANDROID_INSTALL_TIMEOUT_MS).to.be.at.least(5 * 60000);
+    }));
     // A phone adb reports as plugged (and every phone connected when the server
     // starts) went through onDeviceAdded with no androidDeviceType check: a
     // hub set to emulators only listed a real phone until its next sync pruned

package/lib/test/unit/busy-precheck.spec.js

@@ -99,6 +99,38 @@ describe('BusyPrecheck', () => {
         const out = yield pc.findBusy(['U1'], 'actor-1');
         (0, chai_1.expect)(out[0]).to.deep.include({ udid: 'U1', reason: 'manual_other', blockId: 'manual_U1' });
     }));
+    // On a hub, a node's phone held by a preview has the holder in nodeHold,
+    // from the node's report; session_id is the hub's own and stays empty.
+    // Read as unknown, the user's own preview kept them from recording it.
+    it('reads a node phone’s preview hold from nodeHold: mine to take over, another user’s not', () => __awaiter(void 0, void 0, void 0, function* () {
+        const pc = precheck(withDevices({
+            MINE: {
+                udid: 'MINE',
+                busy: true,
+                nodeBusy: true,
+                session_id: null,
+                nodeHold: 'manual_alice_MINE',
+            },
+            THEIRS: {
+                udid: 'THEIRS',
+                busy: true,
+                nodeBusy: true,
+                session_id: null,
+                nodeHold: 'manual_bob_THEIRS',
+            },
+            NODE_SESSION: {
+                udid: 'NODE_SESSION',
+                busy: true,
+                nodeBusy: true,
+                session_id: null,
+                nodeHold: null,
+            },
+        }));
+        (0, chai_1.expect)(yield pc.findBusy(['MINE', 'THEIRS', 'NODE_SESSION'], 'alice')).to.deep.equal([
+            { udid: 'THEIRS', reason: 'manual_other', blockId: 'manual_bob_THEIRS' },
+            { udid: 'NODE_SESSION', reason: 'unknown' },
+        ]);
+    }));
     it('returns reason=unknown for missing devices', () => __awaiter(void 0, void 0, void 0, function* () {
         const pc = precheck(withDevices({}));
         const out = yield pc.findBusy(['MISSING']);

package/lib/test/unit/hub-node-control-forward.spec.js

@@ -73,6 +73,7 @@ const container_registration_1 = require("../helpers/container-registration");
 const scratch_database_1 = require("../helpers/scratch-database");
 const loopbackServer_1 = require("../helpers/loopbackServer");
 const InspectorService_1 = require("../../src/services/InspectorService");
+const OmniVisionService_1 = require("../../src/services/omni-vision/OmniVisionService");
 const http_1 = __importDefault(require("http"));
 const AndroidStreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidStreamService"));
 const AndroidH264StreamService_1 = __importDefault(require("../../src/device-managers/android/AndroidH264StreamService"));
@@ -130,7 +131,11 @@ class AndroidDeviceManager {
             this.at('executeShell');
             return 'uid=2000(shell)';
         });
-        this.installApp = () => __awaiter(this, void 0, void 0, function* () { return this.at('installApp'); });
+        this.installedBytes = [];
+        this.installApp = (_udid, appPath) => __awaiter(this, void 0, void 0, function* () {
+            this.at('installApp');
+            this.installedBytes.push(fs_1.default.readFileSync(appPath, 'utf8'));
+        });
     }
     at(name) {
         this.calls.push(`${typedi_1.Container.get(PluginContext_1.PluginContext).nodeId}:${name}`);
@@ -155,7 +160,7 @@ describe('the hub’s device control on a node’s phone', () => {
         dirs = [fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-control-keys-'))];
         hubKeys = new JwtKeyService_1.JwtKeyService();
         yield hubKeys.init(dirs[0]);
-        restore = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer, device_managers_1.XenonManager, SessionOwnerResolver_1.SessionOwnerResolver, LiveSessionOwners_1.LiveSessionOwners, InspectorService_1.InspectorService);
+        restore = (0, container_registration_1.saveRegistrations)(JwtKeyService_1.JwtKeyService, hubSessionToken_1.HubSessionTokenIssuer, device_managers_1.XenonManager, SessionOwnerResolver_1.SessionOwnerResolver, LiveSessionOwners_1.LiveSessionOwners, InspectorService_1.InspectorService, OmniVisionService_1.OmniVisionService);
         typedi_1.Container.set(JwtKeyService_1.JwtKeyService, hubKeys);
         typedi_1.Container.set(hubSessionToken_1.HubSessionTokenIssuer, new hubSessionToken_1.HubSessionTokenIssuer());
         typedi_1.Container.set(SessionOwnerResolver_1.SessionOwnerResolver, new SessionOwnerResolver_1.SessionOwnerResolver());
@@ -388,16 +393,10 @@ describe('the hub’s device control on a node’s phone', () => {
             (0, chai_1.expect)(res.body).to.include({ status: 'success', sessionId: 's-1' });
             (0, chai_1.expect)(nodeSaw('appium-session')).to.have.length(0);
         }));
-        // Not passed on yet: uploads need a relayed body, an app from the hub's
-        // library isn't on the node, and a path is a path on one machine.
-        // Omni's AI settings are the hub's. Anything added later is refused the
-        // same way until it is on the list.
+        // Not passed on: a path is a path on one machine. Anything added later is
+        // refused the same way until it is on a list.
         const REFUSED = [
             ['post', 'install', { appPath: '/tmp/app.apk' }],
-            ['post', 'install-repository-app', { appId: 'app-1' }],
-            ['post', 'upload-install'],
-            ['get', 'omni-scan'],
-            ['post', 'test-locator', { strategy: '-custom:ai-text', selector: 'OK' }],
             ['post', 'an-action-added-later'],
         ];
         describe('the live preview', () => {
@@ -493,6 +492,63 @@ describe('the hub’s device control on a node’s phone', () => {
                 yield preview('post', 'stream/stop').expect(200);
             }));
         });
+        describe('apps and Omni-Vision', () => {
+            it('installs an upload on the node, streamed through the hub', () => __awaiter(void 0, void 0, void 0, function* () {
+                const res = yield (0, loopbackRequest_1.default)(hubApp)
+                    .post('/xenon/api/control/phone-1/upload-install')
+                    .set('x-test-user', 'alice')
+                    .attach('app', Buffer.from('uploaded-apk'), 'build-42.apk');
+                (0, chai_1.expect)(res.status, res.text).to.equal(200);
+                (0, chai_1.expect)(res.body.success).to.equal(true);
+                (0, chai_1.expect)(manager.calls).to.deep.equal(['node-1:installApp']);
+                (0, chai_1.expect)(manager.installedBytes).to.deep.equal(['uploaded-apk']);
+            }));
+            it('installs an app from the hub’s library on the node, sending the file there', () => __awaiter(void 0, void 0, void 0, function* () {
+                const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-library-'));
+                dirs.push(dir);
+                const file = path_1.default.join(dir, 'stored-app');
+                fs_1.default.writeFileSync(file, 'library-apk');
+                const app = yield scratch.db.app.create({
+                    data: {
+                        name: 'Library App',
+                        filename: 'library-app.apk',
+                        filepath: file,
+                        mimetype: 'application/vnd.android.package-archive',
+                        size: 11,
+                    },
+                });
+                const res = yield asAlice('post', 'install-repository-app', { appId: app.id });
+                (0, chai_1.expect)(res.status, res.text).to.equal(200);
+                (0, chai_1.expect)(manager.calls).to.deep.equal(['node-1:installApp']);
+                (0, chai_1.expect)(manager.installedBytes).to.deep.equal(['library-apk']);
+                const upload = nodeSaw('upload-install');
+                (0, chai_1.expect)(upload).to.have.length(1);
+                (0, chai_1.expect)(String(upload[0].headers['content-type'])).to.match(/^multipart\/form-data/);
+            }));
+            it('runs Omni-Vision here, on the node’s screenshot', () => __awaiter(void 0, void 0, void 0, function* () {
+                const seen = [];
+                typedi_1.Container.set(OmniVisionService_1.OmniVisionService, {
+                    analyzeScreen: (driver) => __awaiter(void 0, void 0, void 0, function* () {
+                        seen.push(`scan:${(yield driver.getScreenshot()).length}`);
+                        return { elements: [] };
+                    }),
+                    findByText: (driver, text) => __awaiter(void 0, void 0, void 0, function* () {
+                        seen.push(`text:${text}:${(yield driver.getScreenshot()).length}`);
+                        return [{ text }];
+                    }),
+                });
+                const scan = yield asAlice('get', 'omni-scan');
+                (0, chai_1.expect)(scan.status, scan.text).to.equal(200);
+                const locator = yield asAlice('post', 'test-locator', {
+                    strategy: '-custom:ai-text',
+                    selector: 'Sign in',
+                });
+                (0, chai_1.expect)(locator.status, locator.text).to.equal(200);
+                (0, chai_1.expect)(locator.body.value).to.deep.equal([{ text: 'Sign in' }]);
+                (0, chai_1.expect)(seen).to.deep.equal(['scan:200', 'text:Sign in:200']);
+                (0, chai_1.expect)(manager.calls).to.deep.equal(['node-1:getScreenshot', 'node-1:getScreenshot']);
+            }));
+        });
         it('refuses the rest, naming the node, and runs none of it on the hub', () => __awaiter(void 0, void 0, void 0, function* () {
             for (const [method, action, body] of REFUSED) {
                 const res = yield asAlice(method, action, body);

package/lib/test/unit/hub-node-race.spec.js

@@ -381,8 +381,13 @@ describe('The hub/node busy race', function () {
             yield scratch.db.device.create({ data: nodePhone('s9') });
             // The node answered a forwarded stream/start: it holds the phone now,
             // though its last report said free.
-            yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('s9', NODE);
-            (0, chai_1.expect)(yield row('s9')).to.include({ busy: true, nodeBusy: true, session_id: null });
+            yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('s9', NODE, 'manual_u1_s9');
+            (0, chai_1.expect)(yield row('s9')).to.include({
+                busy: true,
+                nodeBusy: true,
+                nodeHold: 'manual_u1_s9',
+                session_id: null,
+            });
             let session;
             try {
                 session = yield (0, device_utils_1.allocateDeviceForSession)(caps('s9'), 200, 50, pluginArgs);
@@ -393,7 +398,7 @@ describe('The hub/node busy race', function () {
             (0, chai_1.expect)(session, 'not handed to a session').to.be.an('error');
             // The preview ended, and the node says so.
             yield report(nodePhone('s9', { busy: false }));
-            (0, chai_1.expect)(yield row('s9')).to.include({ busy: false, nodeBusy: false });
+            (0, chai_1.expect)(yield row('s9')).to.include({ busy: false, nodeBusy: false, nodeHold: null });
         }));
         it('touches no other server’s row for the same udid', () => __awaiter(this, void 0, void 0, function* () {
             yield scratch.db.device.create({ data: nodePhone('s9') });
@@ -401,6 +406,27 @@ describe('The hub/node busy race', function () {
             (0, chai_1.expect)(yield row('s9')).to.include({ busy: false, nodeBusy: false });
         }));
     });
+    // The node's report is its own row, session_id included. A preview's hold
+    // there (manual_<user>_<udid>) is who holds the phone, which the hub shows
+    // (nodeHold); session_id itself stays the hub's.
+    describe('who holds a node’s phone', () => {
+        it('is the node’s preview hold, from its report, until the node lets the phone go', () => __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.device.create({ data: nodePhone('s9') });
+            yield report(nodePhone('s9', { busy: true, session_id: 'manual_u1_s9' }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ nodeHold: 'manual_u1_s9', session_id: null });
+            yield report(nodePhone('s9', { busy: false, session_id: null }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ nodeHold: null, busy: false });
+        }));
+        it('is not a session the node runs', () => __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.device.create({ data: nodePhone('s9') });
+            yield report(nodePhone('s9', { busy: true, session_id: 'appium-9' }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ nodeHold: null, nodeBusy: true, session_id: null });
+        }));
+        it('is taken from the report of a phone the hub didn’t know yet', () => __awaiter(this, void 0, void 0, function* () {
+            yield report(nodePhone('s9', { busy: true, session_id: 'manual_u1_s9' }));
+            (0, chai_1.expect)(yield row('s9')).to.include({ nodeHold: 'manual_u1_s9', busy: true });
+        }));
+    });
     describe('a standalone server', () => {
         it('allocates, runs and frees its own phone as before', () => __awaiter(this, void 0, void 0, function* () {
             yield scratch.db.device.create({

package/lib/test/unit/mark-node-busy-loki.spec.js

@@ -38,14 +38,27 @@ describe('markNodeBusy (in-memory store)', () => {
         const model = yield db_1.XenonDatabase.DeviceModel;
         model.insert(phone(NODE));
         model.insert(phone('http://10.0.0.8:4725'));
-        yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('mark-node-busy-s9', NODE);
+        yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('mark-node-busy-s9', NODE, 'manual_u1_s9');
         const rows = model.find({ udid: 'mark-node-busy-s9' });
-        const byHost = Object.fromEntries(rows.map((r) => [r.host, [r.busy, r.nodeBusy]]));
+        const byHost = Object.fromEntries(rows.map((r) => { var _a; return [r.host, [r.busy, r.nodeBusy, (_a = r.nodeHold) !== null && _a !== void 0 ? _a : null]]; }));
         (0, chai_1.expect)(byHost).to.deep.equal({
-            [NODE]: [true, true],
-            'http://10.0.0.8:4725': [false, false],
+            [NODE]: [true, true, 'manual_u1_s9'],
+            'http://10.0.0.8:4725': [false, false, null],
         });
     }));
+    it('takes the holder from a node’s report: a preview hold, not a session', () => __awaiter(void 0, void 0, void 0, function* () {
+        const model = yield db_1.XenonDatabase.DeviceModel;
+        model.insert(phone(NODE));
+        const store = device_store_1.DeviceStoreFactory.getStore();
+        const reported = (session_id, busy) => store.addDevices([Object.assign(Object.assign({}, phone(NODE)), { busy, session_id })], { nodeReport: true });
+        const hold = () => model.findOne({ udid: 'mark-node-busy-s9', host: NODE }).nodeHold;
+        yield reported('manual_u1_mark-node-busy-s9', true);
+        (0, chai_1.expect)(hold()).to.equal('manual_u1_mark-node-busy-s9');
+        yield reported('appium-9', true);
+        (0, chai_1.expect)(hold()).to.equal(null);
+        yield reported(null, false);
+        (0, chai_1.expect)(hold()).to.equal(null);
+    }));
     it('does nothing for a phone it doesn’t have', () => __awaiter(void 0, void 0, void 0, function* () {
         yield device_store_1.DeviceStoreFactory.getStore().markNodeBusy('mark-node-busy-s9', NODE);
         (0, chai_1.expect)((yield db_1.XenonDatabase.DeviceModel).find({ udid: 'mark-node-busy-s9' })).to.deep.equal([]);