@xenon-device-management/xenon 2.0.0 → 2.1.0

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

@@ -13,6 +13,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceStoreFactory = void 0;
+const deviceFieldOwners_1 = require("./deviceFieldOwners");
+const deviceClaims_1 = require("./deviceClaims");
 const logger_1 = __importDefault(require("../logger"));
 const semver_1 = __importDefault(require("semver"));
 const db_1 = require("./db");
@@ -153,19 +155,37 @@ class LokiDeviceStore {
             });
         });
     }
-    updateDevices(filter, updateFn) {
+    touchSession(sessionId, at) {
         return __awaiter(this, void 0, void 0, function* () {
-            (yield db_1.XenonDatabase.DeviceModel).chain().find(filter).update(updateFn);
+            (yield db_1.XenonDatabase.DeviceModel)
+                .chain()
+                .find({ session_id: sessionId })
+                .update((device) => {
+                device.lastCmdExecutedAt = at;
+            });
         });
     }
-    addDevices(devices) {
-        return __awaiter(this, void 0, void 0, function* () {
+    addDevices(devices_1) {
+        return __awaiter(this, arguments, void 0, function* (devices, options = {}) {
             const deviceModel = yield db_1.XenonDatabase.DeviceModel;
             const added = [];
             for (const device of devices) {
                 const existing = deviceModel.findOne({ udid: device.udid, host: device.host });
+                // A node's report (PrismaDeviceStore.addNodeReport has the rule).
+                const nodeBusy = device.busy === true;
+                if (existing && options.nodeReport) {
+                    Object.assign(existing, (0, deviceFieldOwners_1.pickNodeReportFields)(device), { nodeBusy });
+                    if (nodeBusy)
+                        existing.busy = true;
+                    else if ((0, deviceClaims_1.isUnheld)(existing))
+                        existing.busy = false;
+                    deviceModel.update(existing);
+                    continue;
+                }
                 if (!existing) {
-                    const cleanDevice = Object.assign({}, device);
+                    const cleanDevice = options.nodeReport
+                        ? Object.assign(Object.assign({}, (0, deviceFieldOwners_1.pickNodeReportFields)(device)), { udid: device.udid, host: device.host, busy: nodeBusy, nodeBusy })
+                        : Object.assign({}, device);
                     if (cleanDevice.host === undefined)
                         cleanDevice.host = 'Local';
                     if (cleanDevice.userBlocked === undefined)
@@ -185,14 +205,24 @@ class LokiDeviceStore {
             return added;
         });
     }
+    // Loki's find() matches a host exactly already, so `exactHost` changes nothing here.
     removeDevices(filter) {
         return __awaiter(this, void 0, void 0, function* () {
             (yield db_1.XenonDatabase.DeviceModel).chain().find(filter).remove();
         });
     }
-    clearStorage() {
+    clearStorage(onlyHosts) {
         return __awaiter(this, void 0, void 0, function* () {
-            (yield db_1.XenonDatabase.DeviceModel).removeDataOnly();
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            if (onlyHosts) {
+                model
+                    .chain()
+                    .find({ host: { $in: [...onlyHosts] } })
+                    .remove();
+            }
+            else {
+                model.removeDataOnly();
+            }
         });
     }
     findDevice(filter) {
@@ -205,8 +235,8 @@ class LokiDeviceStore {
             return (yield db_1.XenonDatabase.DeviceModel).find(filter);
         });
     }
-    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 prisma_1.prisma.lease.findMany({
                 where: { status: 'active' },
@@ -216,12 +246,53 @@ class LokiDeviceStore {
             const devices = yield this.getDevices(filterOptions);
             const available = devices.find((d) => !d.busy && !d.userBlocked && !blockedKeys.has(`${d.udid}@${d.host}`));
             if (available) {
-                yield this.updateDevice(available.udid, available.host, { busy: true });
+                yield this.updateDevice(available.udid, available.host, Object.assign({ busy: true }, (options.claim ? { claimedAt: Date.now(), claimSessionId: null } : {})));
                 return available;
             }
             return null;
         });
     }
+    claimForSession(udid, host, claimedAt, sessionId, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            const device = model.findOne({ udid, host });
+            if (!device || device.claimSessionId != null)
+                return false;
+            if (device.claimedAt != null && device.claimedAt !== claimedAt)
+                return false;
+            Object.assign(device, update, {
+                busy: true,
+                claimSessionId: sessionId,
+                claimedAt: claimedAt !== null && claimedAt !== void 0 ? claimedAt : Date.now(),
+            });
+            model.update(device);
+            return true;
+        });
+    }
+    releaseClaim(udid, host, ref, update) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield db_1.XenonDatabase.DeviceModel;
+            const device = model.findOne({ udid, host });
+            if (!device || !(0, deviceClaims_1.holdsClaim)(device, ref))
+                return false;
+            Object.assign(device, update, deviceClaims_1.CLAIM_RESET);
+            if ((0, deviceClaims_1.isUnheld)(device))
+                device.busy = false;
+            model.update(device);
+            return true;
+        });
+    }
+    releaseLeaseLock(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 === null || device === void 0 ? void 0 : device.busy) || !(0, deviceClaims_1.isUnheld)(device))
+                return false;
+            device.busy = false;
+            model.update(device);
+            return true;
+        });
+    }
     resetMetrics() {
         return __awaiter(this, void 0, void 0, function* () {
             (yield db_1.XenonDatabase.DeviceModel)

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAIM_RESET = exports.UNHELD = exports.NO_CLAIM = exports.PENDING_CLAIM_TIMEOUT_MS = void 0;
+exports.isPendingClaim = isPendingClaim;
+exports.pendingClaimExpired = pendingClaimExpired;
+exports.claimWhere = claimWhere;
+exports.holdsClaim = holdsClaim;
+exports.hasNoClaim = hasNoClaim;
+exports.isUnheld = isUnheld;
+/**
+ * Why a phone is busy, on the server that allocates it.
+ *
+ * Allocation reads `busy` (findAndLockDevice takes a phone only where it is
+ * false, in one conditional update). On a hub a node's phone is busy for one
+ * of two reasons, each kept in its own columns so neither can erase the
+ * other:
+ *
+ * - **The claim**, this server's: `claimedAt` (when allocation took the phone)
+ *   and `claimSessionId` (the session's id, written when the session exists).
+ *   A claim with no session id yet is *pending*: its session is being
+ *   created, which can take minutes on a first driver install.
+ * - **The node's report**: `nodeBusy`, what the node last said
+ *   (`POST /xenon/api/register`). Always false for a phone this server drives.
+ *
+ * `busy` is claim OR report. No write that can clear it reads the row first:
+ *
+ * - A node reporting its phone free clears `busy` only where nothing of the
+ *   hub's holds it (UNHELD: no claim, and no hold such as a preview or a
+ *   recording in `session_id`), in one conditional update. A report sent
+ *   before the hub's claim (every 30 s by default) can no longer undo it.
+ * - A release names the claim it ends (ClaimRef): a session's id, or when a
+ *   pending claim was taken. A stale release, for a session that ended while
+ *   the phone went on to another, matches nothing. Then `busy` is cleared
+ *   only where nothing else holds the phone (UNHELD), again one conditional
+ *   update: a node still reporting it busy keeps it busy.
+ * - The idle sweeper leaves a pending claim alone until
+ *   PENDING_CLAIM_TIMEOUT_MS, whatever the new-command timeout.
+ *
+ * A server with no nodes (standalone, or a node itself) never has `nodeBusy`
+ * set, so `busy` is its claim as it always was.
+ *
+ * Only a session's allocation takes a claim. A lease locks with `busy` alone,
+ * as before; a manual hold (a preview, a recording) writes `session_id`.
+ */
+/**
+ * How long a claim may wait for its session to be created before the idle
+ * sweeper frees it: a create that never finished (the hub restarted during
+ * it, or it hung). Well past a create's own budget: the phone's wait
+ * (`deviceAvailabilityTimeoutMs`) comes before the claim, and a first
+ * UiAutomator2 or WebDriverAgent install fits in a few minutes.
+ */
+exports.PENDING_CLAIM_TIMEOUT_MS = 10 * 60000;
+/** A claim whose session is still being created. */
+function isPendingClaim(device) {
+    return device.claimedAt != null && device.claimSessionId == null;
+}
+/** A pending claim older than PENDING_CLAIM_TIMEOUT_MS. */
+function pendingClaimExpired(device, now) {
+    return isPendingClaim(device) && now - device.claimedAt > exports.PENDING_CLAIM_TIMEOUT_MS;
+}
+/** Prisma `where` (beside udid and host) for the claim `ref` names. */
+function claimWhere(ref) {
+    if ('sessionId' in ref) {
+        return {
+            OR: [{ claimSessionId: ref.sessionId }, { claimSessionId: null, session_id: ref.sessionId }],
+        };
+    }
+    if (ref.claimedAt == null)
+        return { claimSessionId: null, claimedAt: null, session_id: null };
+    return { claimSessionId: null, claimedAt: ref.claimedAt };
+}
+/** claimWhere as a predicate, for the in-memory store. */
+function holdsClaim(device, ref) {
+    if ('sessionId' in ref) {
+        return (device.claimSessionId === ref.sessionId ||
+            (device.claimSessionId == null && device.session_id === ref.sessionId));
+    }
+    if (device.claimSessionId != null)
+        return false;
+    if (ref.claimedAt == null)
+        return device.claimedAt == null && device.session_id == null;
+    return device.claimedAt === ref.claimedAt;
+}
+/** No claim of this server's on the phone, pending or not. */
+exports.NO_CLAIM = { claimSessionId: null, claimedAt: null };
+function hasNoClaim(device) {
+    return device.claimSessionId == null && device.claimedAt == null;
+}
+/**
+ * Nothing holds the phone: no claim, no session or manual hold, and no node
+ * reporting it busy. Only then may a release clear `busy`.
+ */
+exports.UNHELD = Object.assign(Object.assign({}, exports.NO_CLAIM), { session_id: null, nodeBusy: false });
+function isUnheld(device) {
+    return hasNoClaim(device) && device.session_id == null && device.nodeBusy !== true;
+}
+/** 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

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DISCOVERY_FIELDS = void 0;
+exports.NODE_REPORT_FIELDS = exports.DISCOVERY_FIELDS = void 0;
 exports.pickDiscoveryFields = pickDiscoveryFields;
+exports.pickNodeReportFields = pickNodeReportFields;
 exports.discoveryChanges = discoveryChanges;
 const lodash_1 = __importDefault(require("lodash"));
 /**
@@ -12,12 +13,21 @@ const lodash_1 = __importDefault(require("lodash"));
  *
  * The periodic device sync reads every row, spends seconds in adb or simctl,
  * then writes each phone back. For a phone it already knows it may write only
- * what discovery itself observes (`discovery`). Every `runtime` column has
+ * what discovery itself observes (`discovery`). Every other column has
  * another writer: a session's lock, a preview's hold, an admin's block,
  * reservation or team, a counter, the health check. A sync that read the row
  * before one of those writes would put the old value back. That erased a live
  * preview hold on the lab, and could hand a phone in a session to a second one.
  *
+ * A hub also stores its nodes' phones, from each node's report
+ * (`POST /xenon/api/register`, NODE_REPORT_FIELDS). The report carries what
+ * the node observes of its own phone: `discovery`, and `observed` (its health,
+ * which only the server driving the phone can check). It never writes a
+ * `runtime` column: the hub's claim for a session, and the settings the hub
+ * owns for the phone (team, tags, reservation, block). Whether the node says
+ * the phone is busy goes to `nodeBusy` (`report`), never to `busy`
+ * (deviceClaims.ts).
+ *
  * Typed over every column, so a new column won't compile until it is placed.
  */
 const OWNER = {
@@ -59,8 +69,9 @@ const OWNER = {
     newCommandTimeout: 'runtime',
     owningSessionId: 'runtime',
     lockedAt: 'runtime',
+    claimSessionId: 'runtime',
+    claimedAt: 'runtime',
     userBlocked: 'runtime',
-    offline: 'runtime',
     reservationReason: 'runtime',
     reservedBy: 'runtime',
     reservedUntil: 'runtime',
@@ -68,14 +79,16 @@ const OWNER = {
     tags: 'runtime',
     totalUtilizationTimeMilliSec: 'runtime',
     total_session_count: 'runtime',
-    totalHealedCount: 'runtime',
     dashboard_link: 'runtime',
-    healthStatus: 'runtime',
-    healthCheckError: 'runtime',
-    lastHealthCheckAt: 'runtime',
-    batteryLevel: 'runtime',
-    thermalStatus: 'runtime',
-    storageFree: 'runtime',
+    offline: 'observed',
+    totalHealedCount: 'observed',
+    healthStatus: 'observed',
+    healthCheckError: 'observed',
+    lastHealthCheckAt: 'observed',
+    batteryLevel: 'observed',
+    thermalStatus: 'observed',
+    storageFree: 'observed',
+    nodeBusy: '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'));
@@ -83,6 +96,15 @@ exports.DISCOVERY_FIELDS = new Set(Object.keys(OWNER).filter((column) => OWNER[c
 function pickDiscoveryFields(data) {
     return lodash_1.default.pickBy(data, (_value, key) => exports.DISCOVERY_FIELDS.has(key));
 }
+/**
+ * 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`.
+ */
+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. */
+function pickNodeReportFields(data) {
+    return lodash_1.default.pickBy(data, (_value, key) => exports.NODE_REPORT_FIELDS.has(key));
+}
 /**
  * What a sync writes to a phone it already knows: the discovery columns whose
  * value differs from `known`, the row the sync started from. Discovery hands

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,44 @@ 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;
+        });
+    }
     resetMetrics() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.prisma.device.updateMany({

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

@@ -77,6 +77,7 @@ 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");
 let AndroidDeviceManager = class AndroidDeviceManager {
@@ -196,7 +197,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 +268,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 +473,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,
@@ -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;