@xenon-device-management/xenon 2.1.0 → 2.3.0

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

@@ -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,6 +295,19 @@ class LokiDeviceStore {
             return true;
         });
     }
+    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 });
+            if (!device)
+                return;
+            device.nodeBusy = true;
+            device.busy = true;
+            if (hold)
+                device.nodeHold = hold;
+            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,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.
  *
@@ -94,5 +97,34 @@ 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
+ * 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/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,6 +386,14 @@ class PrismaDeviceStore {
             return cleared.count > 0;
         });
     }
+    markNodeBusy(udid, host, hold) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.device.updateMany({
+                where: { udid, host },
+                data: Object.assign({ nodeBusy: true, busy: true }, (hold ? { nodeHold: hold } : {})),
+            });
+        });
+    }
     resetMetrics() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.prisma.device.updateMany({

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

@@ -54,6 +54,8 @@ 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");
 const appium_adb_1 = require("appium-adb");
@@ -80,6 +82,28 @@ 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
+ * 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 +173,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 +512,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`);
@@ -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/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/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) {