@xenon-device-management/xenon 2.0.0 → 2.2.0

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

@@ -52,6 +52,7 @@ const semver = __importStar(require("semver"));
 const logger_1 = __importDefault(require("../logger"));
 const deviceColumns_1 = require("./deviceColumns");
 const deviceFieldOwners_1 = require("./deviceFieldOwners");
+const deviceClaims_1 = require("./deviceClaims");
 /** Logged once per key, so a chatty node doesn't flood the log. */
 const droppedDeviceKeys = new Set();
 class PrismaDeviceStore {
@@ -75,8 +76,8 @@ class PrismaDeviceStore {
         }
     }
     toIDevice(device) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-        return Object.assign(Object.assign({}, device), { cloud: this.safeParse(device.cloud, 'cloud', device.udid), capability: this.safeParse(device.capability, 'capability', device.udid), chromeDriverPath: this.safeParse(device.chromeDriverPath, 'chromeDriverPath', device.udid), tags: this.safeParse(device.tags, 'tags', device.udid), platform: (device.platform || 'android'), name: device.name || 'unknown', state: device.state || 'available', sdk: device.sdk || 'unknown', deviceType: device.deviceType || 'real', busy: (_a = device.busy) !== null && _a !== void 0 ? _a : false, userBlocked: (_b = device.userBlocked) !== null && _b !== void 0 ? _b : false, realDevice: (_c = device.realDevice) !== null && _c !== void 0 ? _c : true, lastHealthCheckAt: (_d = device.lastHealthCheckAt) !== null && _d !== void 0 ? _d : undefined, healthStatus: (_e = device.healthStatus) !== null && _e !== void 0 ? _e : 'Healthy', healthCheckError: (_f = device.healthCheckError) !== null && _f !== void 0 ? _f : undefined, batteryLevel: (_g = device.batteryLevel) !== null && _g !== void 0 ? _g : undefined, thermalStatus: (_h = device.thermalStatus) !== null && _h !== void 0 ? _h : undefined, storageFree: (_j = device.storageFree) !== null && _j !== void 0 ? _j : undefined, sessionProgress: (_k = device.sessionProgress) !== null && _k !== void 0 ? _k : '', totalHealedCount: (_l = device.totalHealedCount) !== null && _l !== void 0 ? _l : 0 });
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        return Object.assign(Object.assign({}, device), { cloud: this.safeParse(device.cloud, 'cloud', device.udid), capability: this.safeParse(device.capability, 'capability', device.udid), chromeDriverPath: this.safeParse(device.chromeDriverPath, 'chromeDriverPath', device.udid), tags: this.safeParse(device.tags, 'tags', device.udid), platform: (device.platform || 'android'), name: device.name || 'unknown', state: device.state || 'available', sdk: device.sdk || 'unknown', deviceType: device.deviceType || 'real', busy: (_a = device.busy) !== null && _a !== void 0 ? _a : false, userBlocked: (_b = device.userBlocked) !== null && _b !== void 0 ? _b : false, realDevice: (_c = device.realDevice) !== null && _c !== void 0 ? _c : true, lastHealthCheckAt: (_d = device.lastHealthCheckAt) !== null && _d !== void 0 ? _d : undefined, healthStatus: (_e = device.healthStatus) !== null && _e !== void 0 ? _e : 'Healthy', healthCheckError: (_f = device.healthCheckError) !== null && _f !== void 0 ? _f : undefined, batteryLevel: (_g = device.batteryLevel) !== null && _g !== void 0 ? _g : undefined, thermalStatus: (_h = device.thermalStatus) !== null && _h !== void 0 ? _h : undefined, storageFree: (_j = device.storageFree) !== null && _j !== void 0 ? _j : undefined, sessionProgress: (_k = device.sessionProgress) !== null && _k !== void 0 ? _k : '', totalHealedCount: (_l = device.totalHealedCount) !== null && _l !== void 0 ? _l : 0, nodeBusy: (_m = device.nodeBusy) !== null && _m !== void 0 ? _m : false });
     }
     fromIDevice(device) {
         const data = Object.assign({}, device);
@@ -208,17 +209,12 @@ class PrismaDeviceStore {
             logger_1.default.debug(`[PrismaStore] Update device ${udid} at ${host}: ${result.count} records affected`);
         });
     }
-    updateDevices(filter, updateFn) {
+    touchSession(sessionId, at) {
         return __awaiter(this, void 0, void 0, function* () {
-            const devices = yield this.prisma.device.findMany({ where: filter });
-            for (const d of devices) {
-                const idv = this.toIDevice(d);
-                updateFn(idv);
-                yield this.prisma.device.update({
-                    where: { udid_host: { udid: d.udid, host: d.host } },
-                    data: this.fromIDevice(idv),
-                });
-            }
+            yield this.prisma.device.updateMany({
+                where: { session_id: sessionId },
+                data: { lastCmdExecutedAt: at },
+            });
         });
     }
     addDevices(devices_1) {
@@ -232,31 +228,63 @@ class PrismaDeviceStore {
             const known = new Set(existing.map((d) => `${d.udid}@${d.host}`));
             const added = [];
             for (const device of devices) {
-                const data = this.fromIDevice(device);
-                // Use upsert to avoid race conditions and unique constraint errors. A
-                // phone already here gets only its discovery columns (AddDevicesOptions).
-                const d = yield this.prisma.device.upsert({
-                    where: { udid_host: { udid: device.udid, host: device.host } },
-                    update: options.mirror ? data : (0, deviceFieldOwners_1.pickDiscoveryFields)(data),
-                    create: data,
-                });
+                const d = options.nodeReport
+                    ? yield this.addNodeReport(device)
+                    : yield this.prisma.device.upsert({
+                        // Use upsert to avoid race conditions and unique constraint errors. A
+                        // phone already here gets only its discovery columns (AddDevicesOptions).
+                        where: { udid_host: { udid: device.udid, host: device.host } },
+                        update: (0, deviceFieldOwners_1.pickDiscoveryFields)(this.fromIDevice(device)),
+                        create: this.fromIDevice(device),
+                    });
                 if (!known.has(`${device.udid}@${device.host}`))
                     added.push(this.toIDevice(d));
             }
             return added;
         });
     }
-    removeDevices(filter) {
+    /**
+     * A node's report of one phone (AddDevicesOptions.nodeReport). The node's
+     * `busy` goes to `nodeBusy`. Busy there makes the phone busy here; free
+     * there frees it only where this hub holds no claim, in one conditional
+     * update, so a report the node sent before the hub claimed the phone can't
+     * undo the claim.
+     */
+    addNodeReport(device) {
         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 row = yield this.prisma.device.upsert({
+                where: { udid_host: { udid, host } },
+                update: nodeBusy ? Object.assign(Object.assign({}, reported), { busy: true }) : reported,
+                create: Object.assign(Object.assign({}, reported), { udid, host, busy: nodeBusy }),
+            });
+            if (nodeBusy)
+                return row;
+            // Nothing of the hub's may hold it either: a claim, or a hold such as a
+            // preview or a recording (session_id), exactly as a release checks.
+            yield this.prisma.device.updateMany({
+                where: Object.assign({ udid, host, busy: true }, deviceClaims_1.UNHELD),
+                data: { busy: false },
+            });
+            return row;
+        });
+    }
+    removeDevices(filter_1) {
+        return __awaiter(this, arguments, void 0, function* (filter, options = {}) {
             // Principal Fix: Support partial host matching (e.g., "192.168.0.100" should match "http://192.168.0.100:4723")
             // This is necessary because the device tracker passes the raw IP, not the full URL.
+            // `exactHost` turns it off, for a caller that names rows by their own host.
             const whereClause = {};
             if (filter.udid) {
                 whereClause.udid = filter.udid;
             }
             if (filter.host) {
                 // Use Prisma's `contains` for partial matching if host doesn't look like a full URL
-                if (filter.host.startsWith('http://') || filter.host.startsWith('https://')) {
+                if (options.exactHost ||
+                    filter.host.startsWith('http://') ||
+                    filter.host.startsWith('https://')) {
                     whereClause.host = filter.host;
                 }
                 else {
@@ -266,9 +294,9 @@ class PrismaDeviceStore {
             yield this.prisma.device.deleteMany({ where: whereClause });
         });
     }
-    clearStorage() {
+    clearStorage(onlyHosts) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.prisma.device.deleteMany();
+            yield this.prisma.device.deleteMany(onlyHosts ? { where: { host: { in: [...onlyHosts] } } } : undefined);
         });
     }
     findDevice(filter) {
@@ -283,8 +311,8 @@ class PrismaDeviceStore {
             return devices.map((d) => this.toIDevice(d));
         });
     }
-    findAndLockDevice(filterOptions) {
-        return __awaiter(this, void 0, void 0, function* () {
+    findAndLockDevice(filterOptions_1) {
+        return __awaiter(this, arguments, void 0, function* (filterOptions, options = {}) {
             // Phase 2: exclude devices held by an active lease.
             const activeLeases = yield this.prisma.lease.findMany({
                 where: { status: 'active' },
@@ -298,6 +326,7 @@ class PrismaDeviceStore {
                 if (blockedKeys.has(`${device.udid}@${device.host}`)) {
                     continue;
                 }
+                const now = Date.now();
                 const result = yield this.prisma.device.updateMany({
                     where: {
                         udid: device.udid,
@@ -305,11 +334,7 @@ class PrismaDeviceStore {
                         busy: false, // Double check it's still free
                         offline: false,
                     },
-                    data: {
-                        busy: true,
-                        lastCmdExecutedAt: Date.now(),
-                        sessionStartTime: Date.now(),
-                    },
+                    data: Object.assign({ busy: true, lastCmdExecutedAt: now, sessionStartTime: now }, (options.claim ? { claimedAt: now, claimSessionId: null } : {})),
                 });
                 if (result.count === 1) {
                     logger_1.default.info(`[PrismaStore] Successfully locked device ${device.udid} atomically`);
@@ -323,6 +348,52 @@ class PrismaDeviceStore {
             return null;
         });
     }
+    claimForSession(udid, host, claimedAt, sessionId, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The pending claim this phone was allocated with, or none left at all
+            // (released while the session was created, and not taken since).
+            const ours = claimedAt == null ? [{ claimedAt: null }] : [{ claimedAt }, { claimedAt: null }];
+            const result = yield this.prisma.device.updateMany({
+                where: { udid, host, claimSessionId: null, OR: ours },
+                data: Object.assign(Object.assign({}, this.fromIDevice(update)), { busy: true, claimSessionId: sessionId, claimedAt: claimedAt !== null && claimedAt !== void 0 ? claimedAt : Date.now() }),
+            });
+            return result.count > 0;
+        });
+    }
+    releaseClaim(udid, host, ref, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ended = yield this.prisma.device.updateMany({
+                where: Object.assign({ udid, host }, (0, deviceClaims_1.claimWhere)(ref)),
+                data: Object.assign(Object.assign({}, this.fromIDevice(update)), deviceClaims_1.CLAIM_RESET),
+            });
+            if (ended.count === 0)
+                return false;
+            // Not `busy: false` with the step above: a node reporting the phone busy,
+            // or a hold taken since, keeps it busy.
+            yield this.prisma.device.updateMany({
+                where: Object.assign({ udid, host, busy: true }, deviceClaims_1.UNHELD),
+                data: { busy: false },
+            });
+            return true;
+        });
+    }
+    releaseLeaseLock(udid, host) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cleared = yield this.prisma.device.updateMany({
+                where: Object.assign({ udid, host, busy: true }, deviceClaims_1.UNHELD),
+                data: { busy: false },
+            });
+            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");
@@ -77,8 +78,24 @@ const Devices_1 = __importDefault(require("./cloud/Devices"));
 const DeviceLockManager_1 = require("./android/DeviceLockManager");
 const androidIdentity_1 = require("./android/androidIdentity");
 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;
@@ -148,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}`);
@@ -196,7 +187,11 @@ let AndroidDeviceManager = class AndroidDeviceManager {
                             adbInstance.adbRemoteHost === null
                                 ? this.pluginArgs.bindHostOrIp
                                 : adbInstance.adbRemoteHost;
-                        const existingDevice = existingDeviceDetails.find((dev) => dev.udid === device.udid && dev.host.includes(this.pluginArgs.bindHostOrIp));
+                        // This server's own row for the phone: the exact host deviceInfo
+                        // would write. A node on this machine shares the IP, so its row
+                        // for the same phone must not be taken for ours.
+                        const ownHost = (0, localDeviceHosts_1.androidDeviceHost)(this.pluginArgs, this.hostPort, adbInstance);
+                        const existingDevice = existingDeviceDetails.find((dev) => dev.udid === device.udid && dev.host === ownHost);
                         if (existingDevice) {
                             if (device.state === 'device') {
                                 logger_1.default.debug(`Android Device details for ${device.udid} already available and online`);
@@ -263,16 +258,7 @@ let AndroidDeviceManager = class AndroidDeviceManager {
             }
             // Optional: a device that can't say still registers, as before.
             const identity = yield this.getIdentity(adbInstance, device.udid, realDevice);
-            let host;
-            if (adbInstance.adbHost != null) {
-                host = `http://${adbInstance.adbHost}:${adbInstance.adbPort}`;
-            }
-            else if (pluginArgs.remoteMachineProxyIP !== undefined) {
-                host = `http://${pluginArgs.remoteMachineProxyIP}:${hostPort}`;
-            }
-            else {
-                host = `http://${pluginArgs.bindHostOrIp}:${hostPort}`;
-            }
+            const host = (0, localDeviceHosts_1.androidDeviceHost)(pluginArgs, hostPort, adbInstance);
             return Object.assign({ adbRemoteHost: (_a = adbInstance.adbRemoteHost) !== null && _a !== void 0 ? _a : undefined, adbPort: adbInstance.adbPort, systemPort, sdk: sdk !== null && sdk !== void 0 ? sdk : 'unknown', realDevice, name: name !== null && name !== void 0 ? name : 'unknown', busy: false, state: device.state, udid: device.udid, platform: 'android', deviceType: realDevice ? 'real' : 'emulator', host, totalUtilizationTimeMilliSec: totalUtilizationTimeMilliSec, sessionStartTime: 0, userBlocked: false, ip: (0, networkAddresses_1.sanitizeDeviceNetworkIp)(yield this.getDeviceIp(adbInstance, device.udid)), cpuArchitecture: yield this.getCpuArchitecture(adbInstance, device.udid) }, identity);
         });
     }
@@ -477,9 +463,7 @@ let AndroidDeviceManager = class AndroidDeviceManager {
             const adbRemote = pluginArgs.adbRemote;
             if (adbRemote !== undefined && adbRemote.length > 0) {
                 const promises = adbRemote.map((value) => __awaiter(this, void 0, void 0, function* () {
-                    const adbRemoteValue = value.split(':');
-                    const adbHost = adbRemoteValue[0];
-                    const adbPort = parseInt(adbRemoteValue[1]) || 5037;
+                    const { adbHost, adbPort } = (0, localDeviceHosts_1.parseAdbRemote)(value);
                     const cloneAdb = originalADB.clone({
                         remoteAdbHost: adbHost,
                         adbPort,
@@ -520,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`);
@@ -577,10 +571,14 @@ let AndroidDeviceManager = class AndroidDeviceManager {
     }
     onDeviceRemoved(device, pluginArgs) {
         return __awaiter(this, void 0, void 0, function* () {
+            // The host onDeviceAdded files the phone under (deviceInfo with the local
+            // adb). Exact: a bare IP is matched as a substring by the store and by
+            // the hub, and would also take another server's row with this udid.
             const clonedDevice = {
                 udid: device['id'],
-                host: pluginArgs.bindHostOrIp,
+                host: (0, localDeviceHosts_1.androidDeviceHost)(pluginArgs, this.hostPort),
                 state: device.type,
+                nodeId: this.nodeId,
             };
             if (pluginArgs.hub != undefined) {
                 const nodeDevices = new NodeDevices_1.default(pluginArgs.hub, {

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

@@ -63,6 +63,9 @@ const schedule = __importStar(require("node-schedule"));
 const web_config_service_1 = require("../data-service/web-config-service");
 const SessionManager_1 = require("../sessions/SessionManager");
 const EventBus_1 = require("../services/EventBus");
+const deviceClaims_1 = require("../data-service/deviceClaims");
+const PluginContext_1 = require("../PluginContext");
+const localDeviceHosts_1 = require("./localDeviceHosts");
 let HealthMonitorService = class HealthMonitorService {
     constructor(webConfigService) {
         this.webConfigService = webConfigService;
@@ -145,14 +148,26 @@ let HealthMonitorService = class HealthMonitorService {
                 const devices = yield store.getAllDevices();
                 const manager = typedi_1.Container.get(index_1.XenonManager);
                 const instances = yield manager.deviceInstances();
+                const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+                const local = (0, localDeviceHosts_1.localDeviceHosts)(context.pluginArgs, context.port);
                 for (const device of devices) {
-                    // Only check devices managed by this node
-                    if (device.cloud)
+                    // Only this server's own phones. A hub keeps its nodes' phones in the
+                    // same table; its adb can't reach them, so each came back unhealthy,
+                    // was written over the node's report, "recovered" and, when busy with
+                    // a session not in this hub's memory, reclaimed. Their node checks them.
+                    if (device.cloud || !(0, localDeviceHosts_1.isOwnDevice)(local, context.nodeId, device))
                         continue;
                     // Principal Intelligence: Health monitor must detect "Zombie Busy" devices.
                     // A device is a Zombie if it's marked busy in DB but NOT found in Hub's session map
                     // AND not currently streaming to a manual viewer.
                     if (device.busy) {
+                        // Not a zombie: a session still being created on it (its session is
+                        // in no map yet; the claim has its own timeout), or, on a hub, a
+                        // node reporting it busy there (deviceClaims.ts).
+                        if (((0, deviceClaims_1.isPendingClaim)(device) && !(0, deviceClaims_1.pendingClaimExpired)(device, Date.now())) ||
+                            device.nodeBusy) {
+                            continue;
+                        }
                         const hasActiveSession = SessionManager_1.SESSION_MANAGER.isValidSession(device.session_id || '');
                         const isManualStream = (_a = device.session_id) === null || _a === void 0 ? void 0 : _a.startsWith('manual_');
                         // NEW: Check for active manual streams (dashboard viewers)

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

@@ -99,7 +99,11 @@ let IOSDeviceManager = class IOSDeviceManager {
                 result.screenHeight = String(streamStatus.screenHeight);
             }
             else {
-                const storeDevice = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid: device.udid });
+                // This phone's own row: another server's for the same udid is not it.
+                const storeDevice = yield device_store_1.DeviceStoreFactory.getStore().findDevice({
+                    udid: device.udid,
+                    host: device.host,
+                });
                 if (storeDevice === null || storeDevice === void 0 ? void 0 : storeDevice.screenWidth) {
                     result.screenWidth = storeDevice.screenWidth;
                     result.screenHeight = storeDevice.screenHeight;

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

@@ -67,13 +67,18 @@ class NodeDevices {
             }
         });
     }
-    unRegisterNode(host) {
+    /**
+     * Ask the hub to forget this node's phones filed under `host`. With the
+     * node's id the hub takes every phone this node reported, whatever its
+     * host; it never takes another server's (grid.ts, removeNodeDevices).
+     */
+    unRegisterNode(host, nodeId) {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.default.info(`Unregistering node ${this.host}/xenon/api/register`);
             try {
                 const client = InternalHttpClient_1.InternalHttpClient.getClient(this.tlsRejectUnauthorized);
                 yield client.post(`${this.host}/xenon/api/register`, [], {
-                    params: { type: 'unregister', host },
+                    params: Object.assign({ type: 'unregister', host }, (nodeId ? { nodeId } : {})),
                     headers: this.nodeHeaders(),
                 });
                 logger_1.default.info(`Unregistered node ${host} from hub`);

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

@@ -57,7 +57,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../../logger"));
-const device_store_1 = require("../../data-service/device-store");
+const ownDeviceRow_1 = require("../ownDeviceRow");
 const H264Multiplexer_1 = require("./H264Multiplexer");
 const h264NalParser_1 = require("./h264NalParser");
 const androidH264Config_1 = require("../../app/routers/androidH264Config");
@@ -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) {
@@ -266,7 +274,7 @@ let AndroidH264StreamService = class AndroidH264StreamService {
     startScrcpyOrThrow(udid, onPacket) {
         return __awaiter(this, void 0, void 0, function* () {
             const { ScrcpyServerSession, scrcpyMaxSizeFromDims } = yield Promise.resolve().then(() => __importStar(require('./ScrcpyServerSession')));
-            const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+            const device = yield (0, ownDeviceRow_1.findOwnDevice)(udid);
             const maxSize = scrcpyMaxSizeFromDims(Number(device === null || device === void 0 ? void 0 : device.screenWidth), Number(device === null || device === void 0 ? void 0 : device.screenHeight));
             const parser = new h264NalParser_1.H264NalParser();
             const session = new ScrcpyServerSession(udid);
@@ -405,7 +413,7 @@ let AndroidH264StreamService = class AndroidH264StreamService {
     resolveCaptureSize(udid) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+                const device = yield (0, ownDeviceRow_1.findOwnDevice)(udid);
                 const sw = Number(device === null || device === void 0 ? void 0 : device.screenWidth);
                 const sh = Number(device === null || device === void 0 ? void 0 : device.screenHeight);
                 if (Number.isFinite(sw) && Number.isFinite(sh) && sw > 0 && sh > 0) {

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

@@ -59,6 +59,7 @@ const http_1 = __importDefault(require("http"));
 const sharp_1 = __importDefault(require("sharp"));
 const logger_1 = __importDefault(require("../../logger"));
 const device_store_1 = require("../../data-service/device-store");
+const ownDeviceRow_1 = require("../ownDeviceRow");
 const DeviceLockManager_1 = require("./DeviceLockManager");
 const typedi_1 = require("typedi");
 const ResourceIsolationService_1 = require("../../services/ResourceIsolationService");
@@ -80,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()) {
@@ -92,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
@@ -272,7 +275,7 @@ let AndroidStreamService = class AndroidStreamService {
                             `(${decision.reason}); discarding it and starting fresh.`);
                         yield this.disposeSession(udid, existing);
                     }
-                    const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+                    const device = yield (0, ownDeviceRow_1.findOwnDevice)(udid);
                     if (!device)
                         throw new Error(`Device ${udid} not found in DB`);
                     // Resolve the real adb binary once, up front, so the capture loop never
@@ -315,7 +318,7 @@ let AndroidStreamService = class AndroidStreamService {
                             catch (_d) {
                                 /* ignore */
                             }
-                            yield portAllocator.release(mjpegPort).catch(() => undefined);
+                            yield portAllocator.release(mjpegPort, udid).catch(() => undefined);
                             yield portAllocator.blockPort(mjpegPort, 'mjpeg').catch(() => undefined);
                         }
                     }
@@ -346,7 +349,7 @@ let AndroidStreamService = class AndroidStreamService {
                         logger_1.default.info(`[${udid}] MJPEG stream primed with first frame.`);
                     }
                     // Update device info in store to ensure other services (like VideoPipeline) can find the port
-                    const updatedDevice = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+                    const updatedDevice = yield (0, ownDeviceRow_1.findOwnDevice)(udid);
                     if (updatedDevice) {
                         yield device_store_1.DeviceStoreFactory.getStore().updateDevice(udid, updatedDevice.host, {
                             mjpegServerPort: mjpegPort,
@@ -393,7 +396,7 @@ let AndroidStreamService = class AndroidStreamService {
             if (this.sessions.get(udid) === session)
                 this.sessions.delete(udid);
             try {
-                yield typedi_1.Container.get(PortAllocator_1.PortAllocator).release(session.mjpegPort);
+                yield typedi_1.Container.get(PortAllocator_1.PortAllocator).release(session.mjpegPort, udid);
             }
             catch (e) {
                 logger_1.default.warn(`[${udid}] Failed to release mjpeg port lease while restarting stream: ${e}`);
@@ -420,7 +423,7 @@ let AndroidStreamService = class AndroidStreamService {
                 // 'mjpeg' lease is released here — the device-level 'system' port (leased
                 // by AndroidDeviceManager) belongs to the device lifecycle, not the stream.
                 try {
-                    yield typedi_1.Container.get(PortAllocator_1.PortAllocator).release(session.mjpegPort);
+                    yield typedi_1.Container.get(PortAllocator_1.PortAllocator).release(session.mjpegPort, udid);
                 }
                 catch (e) {
                     logger_1.default.warn(`[${udid}] Failed to release mjpeg port lease on stop: ${e}`);

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

@@ -16,7 +16,7 @@ exports.mayReleasePreviewHold = mayReleasePreviewHold;
 exports.releaseIdlePreviewHold = releaseIdlePreviewHold;
 const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../../logger"));
-const device_store_1 = require("../../data-service/device-store");
+const ownDeviceRow_1 = require("../ownDeviceRow");
 const device_service_1 = require("../../data-service/device-service");
 const manualLock_1 = require("../../services/recording/manualLock");
 const recording_store_1 = require("../../services/recording/recording-store");
@@ -43,7 +43,7 @@ function releaseIdlePreviewHold(udid) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d, _e;
         try {
-            const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+            const device = yield (0, ownDeviceRow_1.findOwnDevice)(udid);
             if (!device)
                 return false;
             // eslint-disable-next-line @typescript-eslint/no-var-requires