@xenon-device-management/xenon 2.1.0 → 2.2.0

package/lib/src/app/ws/h264StreamWs.js

@@ -18,6 +18,7 @@ exports.attachH264Ws = attachH264Ws;
 const ws_1 = require("ws");
 const logger_1 = __importDefault(require("../../logger"));
 const upgradeRouter_1 = require("./upgradeRouter");
+const nodeSocketRelay_1 = require("./nodeSocketRelay");
 /**
  * Authenticated H.264 video WebSocket.
  *
@@ -62,6 +63,7 @@ function attachH264Ws(server, deps) {
     function upgrade(req, socket, head) {
         const parsed = parseH264WsPath(req.url);
         wss.handleUpgrade(req, socket, head, (ws) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
             // Register cleanup BEFORE the awaits below. redeem + startStream can take
             // seconds; if the client disconnects during that window we must still
             // remove it from the multiplexer — otherwise clientCount stays inflated
@@ -74,20 +76,44 @@ function attachH264Ws(server, deps) {
             };
             ws.on('close', onClose);
             ws.on('error', onClose);
+            let actor;
             try {
-                yield deps.redeem(parsed.ticket, parsed.udid);
+                actor = yield deps.redeem(parsed.ticket, parsed.udid);
             }
-            catch (_a) {
+            catch (_d) {
                 try {
                     ws.close(1008, 'unauthorized');
                 }
-                catch (_b) {
+                catch (_e) {
                     /* noop */
                 }
                 return;
             }
             if (closed)
                 return; // disconnected during redeem
+            // Another server's phone: its node streams it, relayed from here.
+            let upstream = null;
+            try {
+                upstream = (_b = (yield ((_a = deps.nodeSocket) === null || _a === void 0 ? void 0 : _a.call(deps, parsed.udid, actor)))) !== null && _b !== void 0 ? _b : null;
+            }
+            catch (e) {
+                const refused = e instanceof nodeSocketRelay_1.NodeSocketRefused;
+                logger_1.default.warn(`[${parsed.udid}] H.264 WS from its node failed: ${(_c = e === null || e === void 0 ? void 0 : e.message) !== null && _c !== void 0 ? _c : e}`);
+                try {
+                    ws.close(refused ? 1008 : 1011, refused ? 'refused by the node' : 'node unreachable');
+                }
+                catch (_f) {
+                    /* noop */
+                }
+                return;
+            }
+            if (upstream) {
+                if (closed)
+                    return void upstream.terminate();
+                (0, nodeSocketRelay_1.relaySocket)(ws, upstream, maxBuffered);
+                logger_1.default.info(`[${parsed.udid}] H.264 WS client connected, relayed from its node`);
+                return;
+            }
             let mux;
             try {
                 mux = yield deps.startStream(parsed.udid);
@@ -97,7 +123,7 @@ function attachH264Ws(server, deps) {
                 try {
                     ws.close(1011, 'stream failed');
                 }
-                catch (_c) {
+                catch (_g) {
                     /* noop */
                 }
                 return;

package/lib/src/app/ws/logcatWs.js

@@ -17,6 +17,7 @@ exports.attachLogcatWs = attachLogcatWs;
 const ws_1 = require("ws");
 const logger_1 = __importDefault(require("../../logger"));
 const upgradeRouter_1 = require("./upgradeRouter");
+const nodeSocketRelay_1 = require("./nodeSocketRelay");
 const ostraceParse_1 = require("../../services/logcat/ostraceParse");
 const LOGCAT_PATH_RE = /^\/xenon\/api\/control\/([^/]+)\/logcat$/;
 /** Parse the logcat stream upgrade path; returns null for any non-matching URL. */
@@ -68,7 +69,7 @@ function attachLogcatWs(server, deps) {
     function upgrade(req, socket, head) {
         const parsed = parseLogcatWsPath(req.url);
         wss.handleUpgrade(req, socket, head, (ws) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d, _e;
             // Register cleanup BEFORE the awaits below. redeem + authorize +
             // startStream can together take seconds; a client that disconnects in
             // that window must still be removed from the multiplexer once it's
@@ -86,11 +87,11 @@ function attachLogcatWs(server, deps) {
             try {
                 actor = yield deps.redeem(parsed.ticket, parsed.udid);
             }
-            catch (_c) {
+            catch (_f) {
                 try {
                     ws.close(1008, 'unauthorized');
                 }
-                catch (_d) {
+                catch (_g) {
                     /* noop */
                 }
                 return;
@@ -110,7 +111,7 @@ function attachLogcatWs(server, deps) {
                 try {
                     ws.close(1011, 'ownership unavailable');
                 }
-                catch (_e) {
+                catch (_h) {
                     /* noop */
                 }
                 return;
@@ -135,13 +136,41 @@ function attachLogcatWs(server, deps) {
                 try {
                     ws.close(1008, unresolvable ? 'device not found' : 'device held by another user');
                 }
-                catch (_f) {
+                catch (_j) {
                     /* noop */
                 }
                 return;
             }
             if (closed)
                 return; // disconnected during authorize
+            // Another server's phone: its node streams the log, relayed from here.
+            // The node keeps the replay, the drop markers and the close codes.
+            let upstream = null;
+            try {
+                upstream =
+                    (_c = (yield ((_b = deps.nodeSocket) === null || _b === void 0 ? void 0 : _b.call(deps, parsed.udid, actor, {
+                        levels: parsed.levels,
+                        process: parsed.process,
+                    })))) !== null && _c !== void 0 ? _c : null;
+            }
+            catch (e) {
+                const refused = e instanceof nodeSocketRelay_1.NodeSocketRefused;
+                logger_1.default.warn(`[${parsed.udid}] logcat WS from its node failed: ${(_d = e === null || e === void 0 ? void 0 : e.message) !== null && _d !== void 0 ? _d : e}`);
+                try {
+                    ws.close(refused ? 1008 : 1011, refused ? 'refused by the node' : 'node unreachable');
+                }
+                catch (_k) {
+                    /* noop */
+                }
+                return;
+            }
+            if (upstream) {
+                if (closed)
+                    return void upstream.terminate();
+                (0, nodeSocketRelay_1.relaySocket)(ws, upstream, maxBuffered);
+                logger_1.default.info(`[${parsed.udid}] logcat WS client connected, relayed from its node`);
+                return;
+            }
             let mux;
             let effectiveLevels;
             try {
@@ -153,11 +182,11 @@ function attachLogcatWs(server, deps) {
                 effectiveLevels = started.levels;
             }
             catch (e) {
-                logger_1.default.warn(`[${parsed.udid}] logcat WS start failed: ${(_b = e === null || e === void 0 ? void 0 : e.message) !== null && _b !== void 0 ? _b : e}`);
+                logger_1.default.warn(`[${parsed.udid}] logcat WS start failed: ${(_e = e === null || e === void 0 ? void 0 : e.message) !== null && _e !== void 0 ? _e : e}`);
                 try {
                     ws.close(1011, 'stream failed');
                 }
-                catch (_g) {
+                catch (_l) {
                     /* noop */
                 }
                 return;

package/lib/src/app/ws/nodeSocketRelay.js

@@ -0,0 +1,167 @@
+"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.RELAY_HIGH_WATER_BYTES = exports.NODE_SOCKET_TIMEOUT_MS = exports.NodeSocketRefused = void 0;
+exports.openNodeSocket = openNodeSocket;
+exports.relaySocket = relaySocket;
+const typedi_1 = require("typedi");
+const ws_1 = require("ws");
+const logger_1 = __importDefault(require("../../logger"));
+const hubSessionToken_1 = require("../../gateway/hubSessionToken");
+const forwardToNode_1 = require("../../gateway/forwardToNode");
+const controlDevice_1 = require("../../middleware/controlDevice");
+const nodePhoneControl_1 = require("../routers/nodePhoneControl");
+/**
+ * The live preview's H.264 socket and the logcat socket, for another server's
+ * phone. The viewer's ticket is this server's (stream/ticket is answered
+ * here, after the team check) and is redeemed here; the socket itself is the
+ * node's, opened with a ticket the node mints for the same user, and relayed.
+ * The node keeps doing what it does for its own viewers: the multiplexer,
+ * the replay, the slow-viewer drops and the idle release.
+ */
+/** The node, or this server's own rule, refused: the viewer gets 1008. */
+class NodeSocketRefused extends Error {
+}
+exports.NodeSocketRefused = NodeSocketRefused;
+/** How long the node has to mint its ticket and open its socket. */
+exports.NODE_SOCKET_TIMEOUT_MS = 15000;
+/** Unwritten bytes to the viewer beyond which reading from the node pauses. */
+exports.RELAY_HIGH_WATER_BYTES = 4 * 1024 * 1024;
+/**
+ * The node's socket for another server's phone, open and paused until
+ * relaySocket reads it; null for this server's own phone, which the caller
+ * serves itself. Throws NodeSocketRefused when the phone is a cloud
+ * provider's or the node refuses the user, and any other error when the node
+ * can't be reached.
+ */
+function openNodeSocket(request_1) {
+    return __awaiter(this, arguments, void 0, function* (request, deps = {}) {
+        var _a, _b, _c, _d;
+        const findDevice = (_a = deps.findDevice) !== null && _a !== void 0 ? _a : controlDevice_1.findControlDeviceInStore;
+        const controlToken = (_b = deps.controlToken) !== null && _b !== void 0 ? _b : ((grant) => typedi_1.Container.get(hubSessionToken_1.HubSessionTokenIssuer).controlTokenFor(grant));
+        const timeoutMs = (_c = deps.timeoutMs) !== null && _c !== void 0 ? _c : exports.NODE_SOCKET_TIMEOUT_MS;
+        const { udid, actor, path } = request;
+        const device = yield findDevice(udid);
+        if (!device || !(0, nodePhoneControl_1.isOtherServersPhone)(device))
+            return null;
+        if (device.cloud)
+            throw new NodeSocketRefused("a cloud provider's phone");
+        const origin = (0, nodePhoneControl_1.safeNodeOrigin)(device.host);
+        if (!origin)
+            throw new NodeSocketRefused('unsafe device host');
+        const token = yield controlToken({
+            userId: actor.actorId,
+            isAdmin: !!actor.isAdmin,
+            udid,
+            host: device.host,
+        });
+        const base = `/xenon/api/control/${encodeURIComponent(udid)}`;
+        const answer = yield (0, forwardToNode_1.readAnswer)(yield (0, forwardToNode_1.sendToNode)({
+            url: `${origin}${base}/stream/ticket`,
+            method: 'POST',
+            headers: Object.assign({ accept: 'application/json', 'content-type': 'application/json' }, (token ? { [hubSessionToken_1.HUB_TOKEN_HEADER]: token } : {})),
+            body: Buffer.from('{}'),
+            signal: AbortSignal.timeout(timeoutMs),
+        }));
+        if (answer.status >= 400 && answer.status < 500) {
+            throw new NodeSocketRefused(`the node answered ${answer.status} for a ticket`);
+        }
+        if (answer.status >= 300)
+            throw new Error(`the node answered ${answer.status} for a ticket`);
+        const ticket = (_d = JSON.parse(answer.body.toString('utf8'))) === null || _d === void 0 ? void 0 : _d.ticket;
+        if (typeof ticket !== 'string')
+            throw new Error('the node sent no ticket');
+        const query = new URLSearchParams(request.query);
+        query.set('ticket', ticket);
+        const url = `${origin.replace(/^http/, 'ws')}${base}/${path}?${query}`;
+        const socket = new ws_1.WebSocket(url, { handshakeTimeout: timeoutMs, perMessageDeflate: false });
+        yield new Promise((resolve, reject) => {
+            socket.once('open', () => {
+                // Paused until something reads it: the node sends H.264's config
+                // packet and logcat's replay as soon as it opens, and a message with
+                // no listener yet is lost. relaySocket resumes it.
+                socket.pause();
+                resolve();
+            });
+            socket.once('error', reject);
+        });
+        logger_1.default.info(`[${udid}] ${path} socket opened on node ${origin}`);
+        return socket;
+    });
+}
+/** A close code a server may send. 1005, 1006 and 1015 only describe a close. */
+function isSendable(code) {
+    return ((code >= 1000 && code <= 1014 && ![1004, 1005, 1006].includes(code)) ||
+        (code >= 3000 && code <= 4999));
+}
+function closeWith(ws, code, reason) {
+    if (ws.readyState === ws_1.WebSocket.CLOSING || ws.readyState === ws_1.WebSocket.CLOSED)
+        return;
+    try {
+        if (code === 1005)
+            ws.close();
+        // The node's connection dropped with no close: the viewer retries.
+        else if (!isSendable(code))
+            ws.close(1011, 'node connection lost');
+        else
+            ws.close(code, reason.toString());
+    }
+    catch (_a) {
+        ws.terminate();
+    }
+}
+/**
+ * Relay `viewer` to and from `node` until either closes. Messages pass
+ * unchanged, binary or text as they came, and the node's close code and
+ * reason reach the viewer. While more than `highWaterBytes` sent to the
+ * viewer are still unwritten, reading from the node pauses: the node then
+ * sees a slow viewer and applies its own rule, rather than this server
+ * buffering without bound.
+ */
+function relaySocket(viewer, node, highWaterBytes = exports.RELAY_HIGH_WATER_BYTES) {
+    let unwritten = 0;
+    let paused = false;
+    node.on('message', (data, isBinary) => {
+        if (viewer.readyState !== ws_1.WebSocket.OPEN)
+            return;
+        const size = data.length;
+        unwritten += size;
+        viewer.send(data, { binary: isBinary }, () => {
+            unwritten -= size;
+            if (paused && unwritten <= highWaterBytes / 2) {
+                paused = false;
+                node.resume();
+            }
+        });
+        if (!paused && unwritten > highWaterBytes) {
+            paused = true;
+            node.pause();
+        }
+    });
+    viewer.on('message', (data, isBinary) => {
+        if (node.readyState === ws_1.WebSocket.OPEN)
+            node.send(data, { binary: isBinary });
+    });
+    node.on('close', (code, reason) => closeWith(viewer, code, reason));
+    viewer.on('close', () => {
+        if (node.readyState === ws_1.WebSocket.OPEN || node.readyState === ws_1.WebSocket.CONNECTING) {
+            node.close(1000);
+        }
+    });
+    // A 'close' follows each; nothing more to do here.
+    node.on('error', () => undefined);
+    viewer.on('error', () => undefined);
+    // openNodeSocket hands the node's socket over paused; read it now.
+    node.resume();
+}

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

@@ -293,6 +293,17 @@ class LokiDeviceStore {
             return true;
         });
     }
+    markNodeBusy(udid, host) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            const device = model.findOne({ udid, host });
+            if (!device)
+                return;
+            device.nodeBusy = true;
+            device.busy = true;
+            model.update(device);
+        });
+    }
     resetMetrics() {
         return __awaiter(this, void 0, void 0, function* () {
             (yield db_1.XenonDatabase.DeviceModel)

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

@@ -7,6 +7,7 @@ exports.claimWhere = claimWhere;
 exports.holdsClaim = holdsClaim;
 exports.hasNoClaim = hasNoClaim;
 exports.isUnheld = isUnheld;
+exports.heldHere = heldHere;
 /**
  * Why a phone is busy, on the server that allocates it.
  *
@@ -94,5 +95,22 @@ exports.UNHELD = Object.assign(Object.assign({}, exports.NO_CLAIM), { session_id
 function isUnheld(device) {
     return hasNoClaim(device) && device.session_id == null && device.nodeBusy !== true;
 }
+/**
+ * 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
+ * phone busy only by the node's report (`nodeBusy`), a preview the node
+ * holds say: this server knows no holder for it, and the node, which does,
+ * judges every call forwarded there with its own guard. An ownership check
+ * reads this, not `busy`, or it fails closed on every such phone, refusing
+ * the preview's own holder. A server with no nodes never has nodeBusy, so
+ * for it this is `busy`.
+ */
+function heldHere(device) {
+    if (!device.busy)
+        return false;
+    if (device.nodeBusy !== true)
+        return true;
+    return device.session_id != null || device.claimedAt != null || device.claimSessionId != null;
+}
 /** What ending a claim resets: the claim, and the session's bookkeeping. */
 exports.CLAIM_RESET = Object.assign(Object.assign({}, exports.NO_CLAIM), { session_id: null, lastCmdExecutedAt: null, sessionStartTime: 0, newCommandTimeout: null, sessionProgress: '', owningSessionId: null, lockedAt: null });

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

@@ -386,6 +386,14 @@ class PrismaDeviceStore {
             return cleared.count > 0;
         });
     }
+    markNodeBusy(udid, host) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.device.updateMany({
+                where: { udid, host },
+                data: { nodeBusy: true, busy: true },
+            });
+        });
+    }
     resetMetrics() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.prisma.device.updateMany({

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.includesAndroidDevice = includesAndroidDevice;
 const displayState_1 = require("./android/displayState");
 const networkAddresses_1 = require("../helpers/networkAddresses");
 const appium_adb_1 = require("appium-adb");
@@ -80,6 +81,21 @@ const deviceIdentity_1 = require("./deviceIdentity");
 const localDeviceHosts_1 = require("./localDeviceHosts");
 const PluginContext_1 = require("../PluginContext");
 const typedi_2 = require("typedi");
+/**
+ * Whether a server set to `androidDeviceType` serves this phone: real phones,
+ * emulators ('simulated'), or both, and with `bootedEmulators` only the
+ * emulators that are up. Discovery and a plugged phone (onDeviceAdded) both
+ * ask this, so a phone the server excludes is never added by either.
+ */
+function includesAndroidDevice(device, androidDeviceType, bootedEmulators) {
+    if (androidDeviceType === 'real')
+        return device.deviceType === 'real';
+    if (androidDeviceType === 'simulated' && device.deviceType !== 'emulator')
+        return false;
+    if (bootedEmulators && device.deviceType === 'emulator')
+        return device.state === 'device';
+    return true;
+}
 let AndroidDeviceManager = class AndroidDeviceManager {
     constructor(context) {
         this.context = context;
@@ -149,33 +165,7 @@ let AndroidDeviceManager = class AndroidDeviceManager {
                     devices = yield this.fetchAndroidDevices(existingDeviceDetails, this.pluginArgs);
                     logger_1.default.info(`Found ${devices.length} android devices`);
                 }
-                if (deviceTypes.androidDeviceType === 'real') {
-                    return devices.filter((device) => {
-                        console.log(`Filtering device ${device.udid}, type: ${device.deviceType}, expected real`);
-                        return device.deviceType === 'real';
-                    });
-                }
-                else if (deviceTypes.androidDeviceType === 'simulated') {
-                    const simulated = devices.filter((device) => {
-                        return device.deviceType === 'emulator';
-                    });
-                    if (this.pluginArgs.bootedEmulators) {
-                        return simulated.filter((device) => device.state === 'device');
-                    }
-                    return simulated;
-                    // return both real and simulated (emulated) devices
-                }
-                else {
-                    if (this.pluginArgs.bootedEmulators) {
-                        return devices.filter((device) => {
-                            if (device.deviceType === 'emulator') {
-                                return device.state === 'device';
-                            }
-                            return true;
-                        });
-                    }
-                    return devices;
-                }
+                return devices.filter((device) => includesAndroidDevice(device, deviceTypes.androidDeviceType, this.pluginArgs.bootedEmulators));
             }
             catch (e) {
                 logger_1.default.error(`Error while getting android devices. Error: ${e instanceof Error ? e.message : e}`);
@@ -514,6 +504,16 @@ let AndroidDeviceManager = class AndroidDeviceManager {
                     return;
                 }
                 this.cancelAbort(newDevice.udid);
+                // Discovery's rule, before anything is leased or written: a phone of a
+                // kind this server doesn't serve was listed (and could be allocated)
+                // until the next sync pruned it. A phone that can't say goes on to
+                // deviceInfo, which needs the same property and skips it.
+                const realDevice = yield this.isRealDevice(originalADB, newDevice.udid).catch(() => undefined);
+                if (realDevice !== undefined &&
+                    !includesAndroidDevice({ deviceType: realDevice ? 'real' : 'emulator', state: newDevice.state }, this.pluginArgs.androidDeviceType, this.pluginArgs.bootedEmulators)) {
+                    logger_1.default.info(`Device ${newDevice.udid} is ${realDevice ? 'a real phone' : 'an emulator'}, and androidDeviceType is ${this.pluginArgs.androidDeviceType}. Ignoring`);
+                    return;
+                }
                 const trackedDevice = yield this.deviceInfo(newDevice, originalADB, this.pluginArgs, this.hostPort);
                 if (!trackedDevice) {
                     logger_1.default.info(`Cannot get device info for ${newDevice.udid}. Skipping`);

package/lib/src/device-managers/android/AndroidH264StreamService.js

@@ -91,6 +91,8 @@ let AndroidH264StreamService = class AndroidH264StreamService {
         this.startWatchdog();
     }
     startWatchdog() {
+        // unref()ed below: the server's listener keeps the process alive; this only
+        // needs to fire while it runs.
         setInterval(() => {
             const now = Date.now();
             for (const [udid, s] of this.sessions.entries()) {
@@ -111,7 +113,7 @@ let AndroidH264StreamService = class AndroidH264StreamService {
                     void this.stop(udid).then(() => (0, previewHold_1.releaseIdlePreviewHold)(udid));
                 }
             }
-        }, 60000);
+        }, 60000).unref();
     }
     getMultiplexer(udid) {
         var _a;
@@ -150,7 +152,13 @@ let AndroidH264StreamService = class AndroidH264StreamService {
                     session.capture = yield this.openCapture(udid, onPacket, source);
                     // Give the first keyframe/config a moment so callers get a ready stream,
                     // but never block start-up indefinitely.
-                    yield Promise.race([firstConfig, new Promise((r) => setTimeout(r, 3000))]);
+                    let cap;
+                    try {
+                        yield Promise.race([firstConfig, new Promise((r) => (cap = setTimeout(r, 3000)))]);
+                    }
+                    finally {
+                        clearTimeout(cap);
+                    }
                     return mux;
                 }
                 catch (e) {

package/lib/src/device-managers/android/AndroidStreamService.js

@@ -81,6 +81,8 @@ let AndroidStreamService = class AndroidStreamService {
         this.startWatchdog();
     }
     startWatchdog() {
+        // unref()ed below: the server's listener keeps the process alive; this only
+        // needs to fire while it runs.
         setInterval(() => __awaiter(this, void 0, void 0, function* () {
             const now = Date.now();
             for (const [udid, session] of this.sessions.entries()) {
@@ -93,7 +95,7 @@ let AndroidStreamService = class AndroidStreamService {
             }
             // Every minute, not every hour: an hourly check left an abandoned
             // preview hold in place for up to 70 minutes. The loop is in memory.
-        }), 60000);
+        }), 60000).unref();
     }
     /**
      * Resolve the actual adb binary path (and remote-host args) via the same

package/lib/src/device-managers/ios/IOSStreamService.js

@@ -138,7 +138,9 @@ let IOSStreamService = class IOSStreamService {
     startWatchdog() {
         // Every minute, and cheap: an unwatched preview's hold was held for good,
         // because the only idle check ran hourly and kept every busy device.
-        setInterval(() => void this.sweepIdle(), 60000);
+        // unref()ed: the server's listener keeps the process alive; these only
+        // need to fire while it runs.
+        setInterval(() => void this.sweepIdle(), 60000).unref();
         // Hourly: port leases and the stream health check, which probes WDA.
         setInterval(() => __awaiter(this, void 0, void 0, function* () {
             for (const [udid, session] of this.sessions.entries()) {
@@ -187,7 +189,7 @@ let IOSStreamService = class IOSStreamService {
                     }
                 }
             }
-        }), 3600000); // 1hr interval for background stability
+        }), 3600000).unref(); // 1hr interval for background stability
     }
     /**
      * Stop streams nobody has watched for 10 minutes, which releases an

package/lib/src/middleware/deviceAccessGuard.js

@@ -21,6 +21,7 @@ const controlDevice_1 = require("./controlDevice");
 const SessionOwnerResolver_1 = require("../services/device-access/SessionOwnerResolver");
 const deviceAccessPolicy_1 = require("../services/device-access/deviceAccessPolicy");
 const actor_1 = require("../services/device-access/actor");
+const deviceClaims_1 = require("../data-service/deviceClaims");
 const STATE_CHANGING = new Set(['POST', 'PUT', 'DELETE', 'PATCH']);
 /**
  * Mutations under /control that this guard must NOT handle.
@@ -129,7 +130,9 @@ function deviceAccessGuard(deps = {}) {
             }
             const decision = (0, deviceAccessPolicy_1.evaluateDeviceAccess)({
                 udid,
-                busy: !!device.busy,
+                // Not device.busy: a node's phone busy only by its node's report is
+                // the node's to judge (heldHere).
+                busy: (0, deviceClaims_1.heldHere)(device),
                 sessionId: device.session_id,
                 sessionOwnerUserId,
                 actorUserId: actor.userId,

package/lib/src/services/ServerManager.js

@@ -63,6 +63,7 @@ const networkAddresses_1 = require("../helpers/networkAddresses");
 const logger_1 = __importDefault(require("../logger"));
 const h264StreamWs_1 = require("../app/ws/h264StreamWs");
 const logcatWs_1 = require("../app/ws/logcatWs");
+const nodeSocketRelay_1 = require("../app/ws/nodeSocketRelay");
 const upgradeRouter_1 = require("../app/ws/upgradeRouter");
 const StreamTicketService_1 = require("./token/StreamTicketService");
 const AndroidH264StreamService_1 = __importDefault(require("../device-managers/android/AndroidH264StreamService"));
@@ -147,6 +148,8 @@ let ServerManager = ServerManager_1 = class ServerManager {
                     // streaming.androidH264 config itself, so this WS auto-start honours a
                     // { source: 'screenrecord' } rollback just like the REST stream/start.
                     startStream: (udid) => typedi_1.Container.get(AndroidH264StreamService_1.default).start(udid),
+                    // A node's phone is streamed by its node and relayed from here.
+                    nodeSocket: (udid, actor) => (0, nodeSocketRelay_1.openNodeSocket)({ udid, actor, path: 'stream/h264' }),
                 });
                 // Continuous logcat WebSocket (Android; replaces the 3s dump-poll).
                 // A route of the upgrade router: only /logcat upgrades reach it.
@@ -191,6 +194,16 @@ let ServerManager = ServerManager_1 = class ServerManager {
                         // server-side level filter applies.
                         return { mux: yield typedi_1.Container.get(LogcatStreamService_1.LogcatStreamService).start(udid) };
                     }),
+                    // A node's phone: its node streams the log, with the same filter.
+                    nodeSocket: (udid, actor, filter) => {
+                        var _a;
+                        return (0, nodeSocketRelay_1.openNodeSocket)({
+                            udid,
+                            actor,
+                            path: 'logcat',
+                            query: new URLSearchParams(Object.assign(Object.assign({}, (((_a = filter.levels) === null || _a === void 0 ? void 0 : _a.length) ? { levels: filter.levels.join(',') } : {})), (filter.process ? { process: filter.process } : {}))),
+                        });
+                    },
                 });
             }
             // Principal Cleaning: Attempt to recover remote sessions before marking as failed

package/lib/src/services/device-access/ticketActorAccess.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTicketActorAuthorizer = makeTicketActorAuthorizer;
 const manualLock_1 = require("../recording/manualLock");
 const deviceAccessPolicy_1 = require("./deviceAccessPolicy");
+const deviceClaims_1 = require("../../data-service/deviceClaims");
 /**
  * Build the ownership check for a caller authenticated by a stream ticket.
  *
@@ -54,7 +55,8 @@ function makeTicketActorAuthorizer(deps) {
                 : null;
             return (0, deviceAccessPolicy_1.evaluateDeviceAccess)({
                 udid,
-                busy: !!device.busy,
+                // heldHere, as deviceAccessGuard reads it.
+                busy: (0, deviceClaims_1.heldHere)(device),
                 sessionId: device.session_id,
                 sessionOwnerUserId,
                 // The ticket's actorId is a User id — see StreamTicketService.

package/lib/src/services/lease/LeaseOrphanSweeper.js

@@ -36,11 +36,13 @@ const logger_1 = __importDefault(require("../../logger"));
  */
 function leaseReapReason(lease, now) {
     var _a;
+    // The end time first: past it, heartbeats are refused, so a lease that
+    // expired has missed its heartbeats too by the next sweep.
+    if (lease.expiresAt < now)
+        return `expired at ${new Date(lease.expiresAt).toISOString()}`;
     const thresholdMs = ((_a = lease.heartbeatSeconds) !== null && _a !== void 0 ? _a : 30) * 1000 * 3;
     if (lease.lastHeartbeatAt + thresholdMs < now)
         return 'missed heartbeats';
-    if (lease.expiresAt < now)
-        return `expired at ${new Date(lease.expiresAt).toISOString()}`;
     return null;
 }
 let LeaseOrphanSweeper = class LeaseOrphanSweeper {