@xenon-device-management/xenon 2.13.2 → 2.14.0

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appleFamilyOf = appleFamilyOf;
+/** Whichever of the two words a name carries; iPad first, as "iPad" holds no "iPhone". */
+function familyInName(name) {
+    const lower = (name !== null && name !== void 0 ? name : '').toLowerCase();
+    if (lower.includes('ipad'))
+        return 'ipad';
+    if (lower.includes('iphone'))
+        return 'iphone';
+    return undefined;
+}
+/**
+ * Whether a phone is an iPhone or an iPad, or neither (an Android device, an
+ * Apple TV). Read from what the phone reports, in order of how far it can be
+ * trusted:
+ *
+ *  1. its model, lockdown's ProductType ("iPhone17,3", "iPad13,4");
+ *  2. its form factor, which a simulator gets from its own name and a real
+ *     phone from its DeviceClass;
+ *  3. its marketing name, then its name, for a row written before the
+ *     identity columns existed.
+ *
+ * A real phone's own name is whatever its owner typed ("QA-Phone-3", or
+ * "iPhone spare" for an iPad), so it is the last resort, not the first.
+ */
+function appleFamilyOf(device) {
+    var _a, _b, _c;
+    if (((_a = device.platform) !== null && _a !== void 0 ? _a : '').toLowerCase() !== 'ios')
+        return undefined;
+    const model = (_b = device.model) !== null && _b !== void 0 ? _b : '';
+    if (/^iPhone/i.test(model))
+        return 'iphone';
+    if (/^iPad/i.test(model))
+        return 'ipad';
+    if (device.formFactor === 'phone')
+        return 'iphone';
+    if (device.formFactor === 'tablet')
+        return 'ipad';
+    if (device.formFactor === 'tv')
+        return undefined;
+    return (_c = familyInName(device.marketingName)) !== null && _c !== void 0 ? _c : familyInName(device.name);
+}

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

@@ -20,6 +20,10 @@ class XenonDatabase {
     static get DeviceModel() {
         return XenonDatabase.getDeviceModel();
     }
+    /** Each phone's saved settings (deviceSettings.ts), by udid and host. */
+    static get DeviceSettingsModel() {
+        return XenonDatabase.getDeviceSettingsModel();
+    }
     static get PendingSessionsModel() {
         return XenonDatabase.getPendingSessionsModel();
     }
@@ -49,6 +53,12 @@ class XenonDatabase {
             return db.getCollection('devices') || db.addCollection('devices');
         });
     }
+    static getDeviceSettingsModel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield XenonDatabase.getDB();
+            return db.getCollection('device-settings') || db.addCollection('device-settings');
+        });
+    }
     static getPendingSessionsModel() {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield XenonDatabase.getDB();
@@ -63,6 +73,7 @@ class XenonDatabase {
     }
     static initCollections(db) {
         db.addCollection('devices');
+        db.addCollection('device-settings');
         db.addCollection('pending-sessions');
         db.addCollection('cliArgs');
     }

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

@@ -81,8 +81,13 @@ function removeDevice(devices_1) {
             const team = socket.hasScopedDashboard()
                 ? yield typedi_1.Container.get(DeviceTeamResolver_1.DeviceTeamResolver).resolve(device.udid)
                 : undefined;
+            // The callers hold a udid and a host. The device_offline webhook promises
+            // its name and platform too, so read them while the row still exists.
+            const known = yield store
+                .findDevice({ udid: device.udid, host: device.host })
+                .catch(() => null);
             yield store.removeDevices({ udid: device.udid, host: device.host }, options);
-            typedi_1.Container.get(NotificationService_1.NotificationService).dispatchEvent('device_offline', device);
+            typedi_1.Container.get(NotificationService_1.NotificationService).dispatchEvent('device_offline', Object.assign(Object.assign({}, known), device));
             void socket.emitToDashboardForDevices('device_removed', device, deviceScope(device.udid, (team === null || team === void 0 ? void 0 : team.known) ? team.teamId : undefined));
         }
     });

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

@@ -15,6 +15,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeviceStoreFactory = void 0;
 const deviceFieldOwners_1 = require("./deviceFieldOwners");
 const deviceClaims_1 = require("./deviceClaims");
+const appleFamily_1 = require("./appleFamily");
+const deviceSettings_1 = require("./deviceSettings");
+const lodash_1 = __importDefault(require("lodash"));
 const logger_1 = __importDefault(require("../logger"));
 const semver_1 = __importDefault(require("semver"));
 const db_1 = require("./db");
@@ -63,6 +66,10 @@ class LokiDeviceStore {
                     if (!nameRegex.test(device.name || ''))
                         return false;
                 }
+                // iPhone / iPad Filter (see appleFamilyOf)
+                if (filterOptions.appleFamily && (0, appleFamily_1.appleFamilyOf)(device) !== filterOptions.appleFamily) {
+                    return false;
+                }
                 // UDID Filter
                 if (filterOptions.udid) {
                     if (Array.isArray(filterOptions.udid)) {
@@ -147,6 +154,16 @@ class LokiDeviceStore {
     }
     updateDevice(udid, host, updateData) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Saved for the phone first, as PrismaDeviceStore.updateDevice does.
+            const settings = lodash_1.default.cloneDeep(lodash_1.default.omitBy((0, deviceFieldOwners_1.pickSettingFields)(updateData), (v) => v === undefined));
+            if (Object.keys(settings).length > 0) {
+                const model = yield db_1.XenonDatabase.DeviceSettingsModel;
+                const saved = model.findOne({ udid, host });
+                if (saved)
+                    model.update(Object.assign(saved, settings));
+                else
+                    model.insert(Object.assign({ udid, host, userBlocked: false }, settings));
+            }
             (yield db_1.XenonDatabase.DeviceModel)
                 .chain()
                 .find({ udid, host })
@@ -167,7 +184,10 @@ class LokiDeviceStore {
     }
     addDevices(devices_1) {
         return __awaiter(this, arguments, void 0, function* (devices, options = {}) {
+            var _a;
             const deviceModel = yield db_1.XenonDatabase.DeviceModel;
+            const settingsModel = yield db_1.XenonDatabase.DeviceSettingsModel;
+            const now = Date.now();
             const added = [];
             for (const device of devices) {
                 const existing = deviceModel.findOne({ udid: device.udid, host: device.host });
@@ -184,10 +204,13 @@ class LokiDeviceStore {
                     continue;
                 }
                 if (!existing) {
+                    // The phone's saved settings, as PrismaDeviceStore.addDevices.
+                    const saved = settingsModel.findOne({ udid: device.udid, host: (_a = device.host) !== null && _a !== void 0 ? _a : 'Local' });
+                    const start = saved ? (0, deviceSettings_1.restoredColumns)(saved, now) : {};
                     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(Object.assign({}, (0, deviceFieldOwners_1.pickNodeReportFields)(device)), start), { udid: device.udid, host: device.host, busy: nodeBusy, nodeBusy,
                             nodeHold })
-                        : Object.assign({}, device);
+                        : Object.assign(Object.assign({}, device), start);
                     if (cleanDevice.host === undefined)
                         cleanDevice.host = 'Local';
                     if (cleanDevice.userBlocked === undefined)
@@ -227,6 +250,43 @@ class LokiDeviceStore {
             }
         });
     }
+    adoptSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            const settingsModel = yield db_1.XenonDatabase.DeviceSettingsModel;
+            let adopted = 0;
+            for (const device of (yield db_1.XenonDatabase.DeviceModel).find()) {
+                if (!(0, deviceSettings_1.hasSettings)(device, now))
+                    continue;
+                if (settingsModel.findOne({ udid: device.udid, host: device.host }))
+                    continue;
+                settingsModel.insert(Object.assign(Object.assign({}, (0, deviceFieldOwners_1.pickSettingFields)(device)), { userBlocked: device.userBlocked === true, udid: device.udid, host: device.host }));
+                adopted++;
+            }
+            return adopted;
+        });
+    }
+    forgetSettings(onlyHosts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = yield db_1.XenonDatabase.DeviceSettingsModel;
+            if (onlyHosts) {
+                model
+                    .chain()
+                    .find({ host: { $in: [...onlyHosts] } })
+                    .remove();
+            }
+            else {
+                model.removeDataOnly();
+            }
+        });
+    }
+    findSavedPhones(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield db_1.XenonDatabase.DeviceSettingsModel)
+                .find({ udid })
+                .map((saved) => ({ udid: saved.udid, host: saved.host }));
+        });
+    }
     findDevice(filter) {
         return __awaiter(this, void 0, void 0, function* () {
             return (yield db_1.XenonDatabase.DeviceModel).findOne(filter);

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

@@ -9,6 +9,8 @@ exports.hasNoClaim = hasNoClaim;
 exports.isUnheld = isUnheld;
 exports.nodeHoldOf = nodeHoldOf;
 exports.heldHere = heldHere;
+exports.countsTowardMaxSessions = countsTowardMaxSessions;
+exports.sessionCap = sessionCap;
 const manualLock_1 = require("../services/recording/manualLock");
 /**
  * Why a phone is busy, on the server that allocates it.
@@ -126,5 +128,40 @@ function heldHere(device) {
         return true;
     return device.session_id != null || device.claimedAt != null || device.claimSessionId != null;
 }
+/**
+ * Whether a busy phone uses one of `maxSessions`' slots: an Appium session
+ * runs on it, or is being created on it.
+ *
+ * - **Counts:** this server's claim, pending (the session is being created) or
+ *   with its session id; an Appium session's id in `session_id`; on a hub, a
+ *   node's phone the node reports busy, unless the node says that is a preview.
+ * - **Does not count:** a live preview or a recording (`manual_...` in
+ *   `session_id`), and a phone an SDK lease holds that has no session on it
+ *   (`busy` alone, see above). Neither is an Appium session, and a person
+ *   watching three phones must not stop tests running on a fourth. A session
+ *   started on a leased phone claims it, so it counts like any other.
+ *
+ * `busy` alone is not enough: until this existed the cap counted every busy
+ * phone, and compared with `===`.
+ */
+function countsTowardMaxSessions(device) {
+    if (!device.busy)
+        return false;
+    if (device.claimedAt != null || device.claimSessionId != null)
+        return true;
+    if (device.session_id != null)
+        return !(0, manualLock_1.isManualLock)(device.session_id);
+    return device.nodeBusy === true && !device.nodeHold;
+}
+/**
+ * The `maxSessions` setting as a limit: undefined (no limit) unless it is a
+ * positive number. 0 or less would hold every session back for ever, which
+ * nobody sets on purpose.
+ */
+function sessionCap(maxSessions) {
+    return typeof maxSessions === 'number' && Number.isFinite(maxSessions) && maxSessions >= 1
+        ? maxSessions
+        : undefined;
+}
 /** 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,7 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NODE_REPORT_FIELDS = exports.DISCOVERY_FIELDS = void 0;
+exports.NODE_REPORT_FIELDS = exports.DISCOVERY_FIELDS = exports.SETTING_FIELDS = void 0;
+exports.pickSettingFields = pickSettingFields;
 exports.pickDiscoveryFields = pickDiscoveryFields;
 exports.pickNodeReportFields = pickNodeReportFields;
 exports.discoveryChanges = discoveryChanges;
@@ -23,11 +24,15 @@ const lodash_1 = __importDefault(require("lodash"));
  * (`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`
+ * `runtime` column (the hub's claim for a session) or a `setting`. Whether the
+ * node says the phone is busy goes to `nodeBusy` (`report`), never to `busy`
  * (deviceClaims.ts).
  *
+ * A `setting` is what people give the phone: an admin its team, tags and
+ * maintenance, a member a reservation. Those are also saved apart from the
+ * row (DeviceSetting, deviceSettings.ts), which is deleted whenever the phone
+ * goes, and a new row for the phone starts from them.
+ *
  * Typed over every column, so a new column won't compile until it is placed.
  */
 const OWNER = {
@@ -71,13 +76,6 @@ const OWNER = {
     lockedAt: 'runtime',
     claimSessionId: 'runtime',
     claimedAt: 'runtime',
-    userBlocked: 'runtime',
-    reservationReason: 'runtime',
-    reservedBy: 'runtime',
-    reservedByUserId: 'runtime',
-    reservedUntil: 'runtime',
-    teamId: 'runtime',
-    tags: 'runtime',
     totalUtilizationTimeMilliSec: 'runtime',
     total_session_count: 'runtime',
     dashboard_link: 'runtime',
@@ -91,7 +89,23 @@ const OWNER = {
     storageFree: 'observed',
     nodeBusy: 'report',
     nodeHold: 'report',
+    teamId: 'setting',
+    tags: 'setting',
+    userBlocked: 'setting',
+    reservationReason: 'setting',
+    reservedBy: 'setting',
+    reservedByUserId: 'setting',
+    reservedUntil: 'setting',
 };
+/**
+ * The settings people give a phone, saved apart from its row (DeviceSetting
+ * has exactly these columns, besides its key).
+ */
+exports.SETTING_FIELDS = Object.keys(OWNER).filter((column) => OWNER[column] === 'setting');
+/** Only the setting columns of `data`. */
+function pickSettingFields(data) {
+    return lodash_1.default.pick(data, exports.SETTING_FIELDS);
+}
 /** 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'));
 /** Only the discovery columns of `data`. */

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

@@ -0,0 +1,79 @@
+"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.restoredColumns = restoredColumns;
+exports.settingsDiffer = settingsDiffer;
+exports.hasSettings = hasSettings;
+exports.resetDevicesAtBoot = resetDevicesAtBoot;
+const localDeviceHosts_1 = require("../device-managers/localDeviceHosts");
+const logger_1 = __importDefault(require("../logger"));
+const deviceFieldOwners_1 = require("./deviceFieldOwners");
+/**
+ * The setting columns a new row for the phone starts with: all of them, so
+ * what was cleared stays cleared, and a reservation only while it holds.
+ */
+function restoredColumns(saved, now) {
+    var _a, _b, _c, _d, _e;
+    const holds = typeof saved.reservedUntil === 'number' && saved.reservedUntil > now;
+    return {
+        teamId: (_a = saved.teamId) !== null && _a !== void 0 ? _a : null,
+        // A copy: the in-memory store keeps the array itself.
+        tags: Array.isArray(saved.tags) ? [...saved.tags] : ((_b = saved.tags) !== null && _b !== void 0 ? _b : null),
+        userBlocked: saved.userBlocked === true,
+        reservationReason: holds ? ((_c = saved.reservationReason) !== null && _c !== void 0 ? _c : null) : null,
+        reservedBy: holds ? ((_d = saved.reservedBy) !== null && _d !== void 0 ? _d : null) : null,
+        reservedByUserId: holds ? ((_e = saved.reservedByUserId) !== null && _e !== void 0 ? _e : null) : null,
+        reservedUntil: holds ? saved.reservedUntil : null,
+    };
+}
+/** Whether two sets of setting columns differ (restoredColumns' shape). */
+function settingsDiffer(a, b) {
+    return deviceFieldOwners_1.SETTING_FIELDS.some((field) => JSON.stringify(a[field]) !== JSON.stringify(b[field]));
+}
+function hasTags(tags) {
+    if (tags == null)
+        return false;
+    if (Array.isArray(tags))
+        return tags.length > 0;
+    return tags !== '' && tags !== '[]';
+}
+/** Whether a row carries a setting that is worth keeping (adoptSettings). */
+function hasSettings(row, now) {
+    return (row.teamId != null ||
+        row.userBlocked === true ||
+        hasTags(row.tags) ||
+        (typeof row.reservedUntil === 'number' && row.reservedUntil > now));
+}
+/**
+ * The device table as a server starts. It forgets the phones
+ * devicesClearedAtBoot names, but first saves the settings of rows that have
+ * none saved (rows written through 2.13 kept them only on the row). With
+ * `removeDevicesFromDatabaseBeforeRunningThePlugin`, the saved settings of
+ * those phones are forgotten with them.
+ */
+function resetDevicesAtBoot(store, args, local) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cleared = (0, localDeviceHosts_1.devicesClearedAtBoot)(args, local);
+        const adopted = yield store.adoptSettings();
+        if (adopted > 0) {
+            logger_1.default.info(`Saved the team, tags, maintenance or reservation of ${adopted} phone(s)`);
+        }
+        if (args.removeDevicesFromDatabaseBeforeRunningThePlugin) {
+            yield store.forgetSettings(cleared);
+            logger_1.default.info('removeDevicesFromDatabaseBeforeRunningThePlugin is on: forgot the saved settings of ' +
+                (cleared ? "this server's own phones" : 'every phone'));
+        }
+        yield store.clearStorage(cleared);
+    });
+}

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

@@ -41,6 +41,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -53,8 +64,13 @@ const logger_1 = __importDefault(require("../logger"));
 const deviceColumns_1 = require("./deviceColumns");
 const deviceFieldOwners_1 = require("./deviceFieldOwners");
 const deviceClaims_1 = require("./deviceClaims");
+const appleFamily_1 = require("./appleFamily");
+const deviceSettings_1 = require("./deviceSettings");
 /** Logged once per key, so a chatty node doesn't flood the log. */
 const droppedDeviceKeys = new Set();
+const keyOf = (d) => `${d.udid}@${d.host}`;
+/** Prisma's `select` for a phone's key and its setting columns. */
+const SETTINGS_SELECT = Object.fromEntries(['udid', 'host', ...deviceFieldOwners_1.SETTING_FIELDS].map((field) => [field, true]));
 class PrismaDeviceStore {
     get prisma() {
         return typedi_1.Container.get(prisma_service_1.PrismaService).client;
@@ -104,7 +120,7 @@ class PrismaDeviceStore {
     }
     getDevices(filterOptions) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             const where = {};
             if (filterOptions.platform) {
                 where.platform = filterOptions.platform;
@@ -191,6 +207,22 @@ class PrismaDeviceStore {
                     return filterOptions.tags.every((tag) => d.tags.includes(tag));
                 });
             }
+            // `appium:iPhoneOnly` / `appium:iPadOnly`. Read from the phone's model and
+            // form factor first, not its name: see appleFamilyOf.
+            if (filterOptions.appleFamily) {
+                results = results.filter((d) => (0, appleFamily_1.appleFamilyOf)(d) === filterOptions.appleFamily);
+            }
+            // A name filter, as the in-memory store has always applied it: a part of
+            // the phone's name. Case does not matter, and a phone's marketing name
+            // ("iPhone 16 Pro") counts as much as the name its owner gave it.
+            const wanted = (_b = filterOptions.name) === null || _b === void 0 ? void 0 : _b.trim().toLowerCase();
+            if (wanted) {
+                results = results.filter((d) => {
+                    var _a, _b;
+                    return ((_a = d.name) !== null && _a !== void 0 ? _a : '').toLowerCase().includes(wanted) ||
+                        ((_b = d.marketingName) !== null && _b !== void 0 ? _b : '').toLowerCase().includes(wanted);
+                });
+            }
             return results;
         });
     }
@@ -202,6 +234,16 @@ class PrismaDeviceStore {
     updateDevice(udid, host, update) {
         return __awaiter(this, void 0, void 0, function* () {
             const data = this.fromIDevice(update);
+            // Saved first: a row created meanwhile reads them after this, or is
+            // corrected by addDevices' second look (settleRestored).
+            const settings = (0, deviceFieldOwners_1.pickSettingFields)(data);
+            if (Object.keys(settings).length > 0) {
+                yield this.prisma.deviceSetting.upsert({
+                    where: { udid_host: { udid, host } },
+                    create: Object.assign({ udid, host }, settings),
+                    update: settings,
+                });
+            }
             const result = yield this.prisma.device.updateMany({
                 where: { udid, host },
                 data,
@@ -209,6 +251,21 @@ class PrismaDeviceStore {
             logger_1.default.debug(`[PrismaStore] Update device ${udid} at ${host}: ${result.count} records affected`);
         });
     }
+    /** The settings saved for these phones, by `udid@host`. */
+    savedSettings(phones) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (phones.length === 0)
+                return new Map();
+            const rows = yield this.prisma.deviceSetting.findMany({
+                where: { OR: phones.map(({ udid, host }) => ({ udid, host })) },
+                select: SETTINGS_SELECT,
+            });
+            return new Map(rows.map((r) => [
+                keyOf(r),
+                r,
+            ]));
+        });
+    }
     touchSession(sessionId, at) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.prisma.device.updateMany({
@@ -225,22 +282,58 @@ class PrismaDeviceStore {
                 where: { OR: devices.map((d) => ({ udid: d.udid, host: d.host })) },
                 select: { udid: true, host: true },
             });
-            const known = new Set(existing.map((d) => `${d.udid}@${d.host}`));
+            const known = new Set(existing.map((d) => keyOf(d)));
+            const fresh = devices.filter((d) => !known.has(keyOf(d)));
+            // A new row starts from the phone's saved settings, in the write that
+            // creates it: it is never listed, even for a moment, outside its team.
+            const saved = yield this.savedSettings(fresh);
+            const now = Date.now();
+            const started = new Map();
             const added = [];
             for (const device of devices) {
+                const key = keyOf(device);
+                const was = known.has(key) ? undefined : saved.get(key);
+                const start = was ? (0, deviceSettings_1.restoredColumns)(was, now) : {};
+                if (was)
+                    started.set(key, start);
                 const d = options.nodeReport
-                    ? yield this.addNodeReport(device)
+                    ? yield this.addNodeReport(device, start)
                     : 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),
+                        create: Object.assign(Object.assign({}, this.fromIDevice(device)), start),
                     });
-                if (!known.has(`${device.udid}@${device.host}`))
+                if (!known.has(key))
                     added.push(this.toIDevice(d));
             }
-            return added;
+            return this.settleRestored(added, started, now);
+        });
+    }
+    /**
+     * A second look at the settings of the rows just created. A setting saved
+     * between the read above and the create (updateDevice saves before it
+     * writes the row, and found no row to write) would otherwise be missing
+     * from the new row until the phone came back again. Rows that need it are
+     * corrected and read again; the others are returned as they are.
+     */
+    settleRestored(added, started, now) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const saved = yield this.savedSettings(added);
+            return Promise.all(added.map((device) => __awaiter(this, void 0, void 0, function* () {
+                const latest = saved.get(keyOf(device));
+                if (!latest)
+                    return device;
+                const columns = (0, deviceSettings_1.restoredColumns)(latest, now);
+                const before = started.get(keyOf(device));
+                if (before && !(0, deviceSettings_1.settingsDiffer)(before, columns))
+                    return device;
+                const where = { udid: device.udid, host: device.host };
+                yield this.prisma.device.updateMany({ where, data: columns });
+                const row = yield this.prisma.device.findUnique({ where: { udid_host: where } });
+                return row ? this.toIDevice(row) : device;
+            })));
         });
     }
     /**
@@ -250,7 +343,7 @@ class PrismaDeviceStore {
      * update, so a report the node sent before the hub claimed the phone can't
      * undo the claim.
      */
-    addNodeReport(device) {
+    addNodeReport(device, start) {
         return __awaiter(this, void 0, void 0, function* () {
             const { udid, host } = device;
             const nodeBusy = device.busy === true;
@@ -258,7 +351,8 @@ class PrismaDeviceStore {
             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 }),
+                // The hub's own settings for the phone, never the report's.
+                create: Object.assign(Object.assign(Object.assign({}, reported), start), { udid, host, busy: nodeBusy }),
             });
             if (nodeBusy)
                 return row;
@@ -299,6 +393,54 @@ class PrismaDeviceStore {
             yield this.prisma.device.deleteMany(onlyHosts ? { where: { host: { in: [...onlyHosts] } } } : undefined);
         });
     }
+    adoptSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            const rows = (yield this.prisma.device.findMany({
+                where: {
+                    OR: [
+                        { teamId: { not: null } },
+                        { userBlocked: true },
+                        { tags: { notIn: ['', '[]'] } },
+                        { reservedUntil: { gt: now } },
+                    ],
+                },
+                select: SETTINGS_SELECT,
+            }));
+            const candidates = rows.filter((row) => (0, deviceSettings_1.hasSettings)(row, now));
+            if (candidates.length === 0)
+                return 0;
+            const saved = yield this.savedSettings(candidates);
+            let adopted = 0;
+            for (let _a of candidates) {
+                const { udid, host } = _a, settings = __rest(_a, ["udid", "host"]);
+                if (saved.has(keyOf({ udid, host })))
+                    continue;
+                const data = (0, deviceFieldOwners_1.pickSettingFields)(settings);
+                yield this.prisma.deviceSetting.upsert({
+                    where: { udid_host: { udid, host } },
+                    create: Object.assign(Object.assign({}, data), { userBlocked: settings.userBlocked === true, udid, host }),
+                    // Saved meanwhile: that one is newer.
+                    update: {},
+                });
+                adopted++;
+            }
+            return adopted;
+        });
+    }
+    forgetSettings(onlyHosts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.deviceSetting.deleteMany(onlyHosts ? { where: { host: { in: [...onlyHosts] } } } : undefined);
+        });
+    }
+    findSavedPhones(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.prisma.deviceSetting.findMany({
+                where: { udid },
+                select: { udid: true, host: true },
+            });
+        });
+    }
     findDevice(filter) {
         return __awaiter(this, void 0, void 0, function* () {
             const device = yield this.prisma.device.findFirst({ where: filter });