@xenon-device-management/xenon 2.8.3 → 2.9.1

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

@@ -74,7 +74,6 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const tcp_port_used_1 = __importDefault(require("tcp-port-used"));
 const InternalHttpClient_1 = require("../../InternalHttpClient");
 const logger_1 = __importDefault(require("../../logger"));
-const helpers_1 = require("../../helpers");
 const singleFlight_1 = require("../../helpers/singleFlight");
 const PortAllocator_1 = require("../../services/PortAllocator");
 const device_store_1 = require("../../data-service/device-store");
@@ -82,6 +81,7 @@ const ownDeviceRow_1 = require("../ownDeviceRow");
 const iosStreamDiagnostics_1 = require("./iosStreamDiagnostics");
 const tunnelProcess_1 = require("./tunnelProcess");
 const IOSTunnels_1 = require("./IOSTunnels");
+const goIosBinary_1 = require("./goIosBinary");
 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");
@@ -119,11 +119,7 @@ let IOSStreamService = class IOSStreamService {
         this.startFlight = new singleFlight_1.SingleFlight();
         this.recoveryCooldowns = new Map(); // Track last recovery attempt time
         this.RECOVERY_COOLDOWN_MS = 30000; // 30s cooldown between recovery attempts
-        // Port-lease TTL for an active stream. Longer than the watchdog interval (1h),
-        // which refreshes it each tick, so a long-lived stream's port never expires
-        // and gets reallocated to another device; stopStream() releases it explicitly.
-        this.STREAM_PORT_TTL_MS = 90 * 60 * 1000; // 1.5h
-        this.goIOSPath = this.getGoIOSPath();
+        this.goIOSPath = (0, goIosBinary_1.goIosBinaryPath)();
         this.startWatchdog();
     }
     /**
@@ -143,8 +139,8 @@ let IOSStreamService = class IOSStreamService {
                     // its ports to another device mid-stream (TTL > this 1h interval).
                     try {
                         const portAllocator = typedi_2.Container.get(PortAllocator_1.PortAllocator);
-                        yield portAllocator.touch(session.wdaPort, this.STREAM_PORT_TTL_MS);
-                        yield portAllocator.touch(session.mjpegPort, this.STREAM_PORT_TTL_MS);
+                        yield portAllocator.touch(session.wdaPort, IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS);
+                        yield portAllocator.touch(session.mjpegPort, IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS);
                         yield this.tunnels().touch(udid);
                     }
                     catch (_a) {
@@ -223,10 +219,6 @@ let IOSStreamService = class IOSStreamService {
             }
         });
     }
-    getGoIOSPath() {
-        const goIOSDir = (0, helpers_1.cachePath)('goIOS');
-        return path_1.default.join(goIOSDir, 'ios');
-    }
     /**
      * Check if go-ios binary exists
      */
@@ -283,6 +275,10 @@ let IOSStreamService = class IOSStreamService {
         return __awaiter(this, void 0, void 0, function* () {
             if (yield this.appiumSessionMayUse(udid, 'go-ios tunnels'))
                 return;
+            // A tunnel opened for screenshots is live and tracked, not a leftover:
+            // the start's ensure takes it over (IOSTunnels.borrow).
+            if (this.tunnels().isOnDemand(udid))
+                return;
             logger_1.default.debug(`Cleaning up orphan tunnels for ${udid}...`);
             yield this.tunnels().stop(udid);
             // Reap the tunnel process *group* for this udid so the self-forking go-ios
@@ -590,7 +586,7 @@ let IOSStreamService = class IOSStreamService {
                     // guarantee a non-colliding port; the lease is refreshed by the watchdog
                     // and released in stopStream().
                     const portAllocator = typedi_2.Container.get(PortAllocator_1.PortAllocator);
-                    const ttl = { ttlMs: this.STREAM_PORT_TTL_MS };
+                    const ttl = { ttlMs: IOSTunnels_1.IOS_STREAM_LEASE_TTL_MS };
                     // Principal Discovery: attach to the WDA an Appium session runs on this
                     // device instead of launching a second one over it. The one exception
                     // to the rule above: that session's forwarder listens on the Device
@@ -1097,7 +1093,9 @@ let IOSStreamService = class IOSStreamService {
      * server owns no legitimate tunnel — i.e. on fresh boot (orphans from a
      * previous run, or a hard-killed / crashed process whose graceful cleanup
      * never ran) or during full shutdown. This is the catch-all that stops the
-     * self-forking go-ios agent storm from surviving across restarts.
+     * self-forking go-ios agent storm from surviving across restarts. It kills
+     * this process's own go-ios calls too, so boot runs it before device
+     * detection starts (ServerManager.reapLeftoverGoIos).
      */
     reapOrphanTunnels() {
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -18,7 +18,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IOSTunnels = exports.TUNNEL_CHECK_MS = exports.TUNNEL_LEASE_TTL_MS = exports.TUNNEL_READY_POLL_MS = exports.TUNNEL_READY_TIMEOUT_MS = void 0;
+exports.IOSTunnels = exports.TUNNEL_BORROW_IDLE_MS = exports.TUNNEL_CHECK_MS = exports.IOS_STREAM_LEASE_TTL_MS = exports.TUNNEL_READY_POLL_MS = exports.TUNNEL_READY_TIMEOUT_MS = void 0;
 exports.iosVersionOf = iosVersionOf;
 exports.goIosReason = goIosReason;
 /**
@@ -48,27 +48,35 @@ exports.goIosReason = goIosReason;
 const typedi_1 = require("typedi");
 const child_process_1 = require("child_process");
 const http_1 = __importDefault(require("http"));
-const path_1 = __importDefault(require("path"));
 const util_1 = require("util");
 const logger_1 = __importDefault(require("../../logger"));
-const helpers_1 = require("../../helpers");
 const PortAllocator_1 = require("../../services/PortAllocator");
 const ProcessRegistry_1 = require("../../services/ProcessRegistry");
 const ResourceIsolationService_1 = require("../../services/ResourceIsolationService");
 const iosStreamDiagnostics_1 = require("./iosStreamDiagnostics");
+const goIosBinary_1 = require("./goIosBinary");
 const tunnelProcess_1 = require("./tunnelProcess");
 const execPromise = (0, util_1.promisify)(child_process_1.exec);
 /** How long a new tunnel has to answer for its phone before the start goes on without it. */
 exports.TUNNEL_READY_TIMEOUT_MS = 20000;
 exports.TUNNEL_READY_POLL_MS = 500;
 /**
- * A tunnel's port lease: the same as the stream's own ports
- * (IOSStreamService's STREAM_PORT_TTL_MS). The stream watchdog refreshes both
- * every hour, the tunnel's through {@link IOSTunnels.touch}.
+ * How long an iPhone stream's port leases last: its WDA and MJPEG ports
+ * (IOSStreamService) and its tunnel's pair. Longer than the stream watchdog's
+ * hourly tick, which refreshes them (the tunnel's through
+ * {@link IOSTunnels.touch}), so a long stream never loses its ports to another
+ * phone. Stopping the stream or the tunnel releases them.
  */
-exports.TUNNEL_LEASE_TTL_MS = 90 * 60 * 1000;
+exports.IOS_STREAM_LEASE_TTL_MS = 90 * 60 * 1000;
 /** How often running tunnels are checked for a phone that went away. */
 exports.TUNNEL_CHECK_MS = 5000;
+/**
+ * How long a tunnel opened for screenshots stays after the last one: long
+ * enough that a client taking screenshots in a loop pays the start once.
+ */
+exports.TUNNEL_BORROW_IDLE_MS = 2 * 60 * 1000;
+/** How long a phone's iOS version is trusted before `ios info` is asked again. */
+const VERSION_CACHE_MS = 10 * 60 * 1000;
 /** The iOS version `ios info` reports, as a number: 17.2 for "17.2.1" or "iOS 17.2", 0 for none. */
 function iosVersionOf(info) {
     const versionStr = String(info.ProductVersion || info.HumanReadableProductVersionString || '0');
@@ -118,32 +126,51 @@ let IOSTunnels = class IOSTunnels {
         this.log = logger_1.default.scope('IOSTunnels');
         this.tunnels = new Map();
         this.checking = false;
-        this.goIOSPath = path_1.default.join((0, helpers_1.cachePath)('goIOS'), 'ios');
+        this.versionCache = new Map();
+        this.goIOSPath = (0, goIosBinary_1.goIosBinaryPath)();
     }
     /**
-     * The phone's tunnel-info port, starting its tunnel if it has none. Null
-     * for a phone below iOS 17, or whose version can't be read: it needs no
-     * tunnel. Throws when no pair of ports is left, or when the tunnel exits
-     * before it is ready.
+     * The phone's tunnel-info port for its stream, starting its tunnel if it
+     * has none. A tunnel opened for screenshots is taken over: from then on
+     * only the stream's stop ends it. Null for a phone below iOS 17, or whose
+     * version can't be read: it needs no tunnel. Throws when no pair of ports
+     * is left, or when the tunnel exits before it is ready.
      */
     ensure(udid) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const running = this.portFor(udid);
-            if (running !== undefined)
-                return running;
-            let version;
-            try {
-                version = yield this.iosVersion(udid);
-            }
-            catch (e) {
-                this.log.warn(`[${udid}] Could not read the iOS version, so no go-ios tunnel: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
-                return null;
+            return this.open(udid, 'stream');
+        });
+    }
+    /**
+     * The phone's tunnel-info port for a screenshot, which on iOS 17+ is
+     * reached only through the tunnel. A phone that isn't streaming has none,
+     * so one is started; it stays while screenshots keep coming and stops
+     * {@link TUNNEL_BORROW_IDLE_MS} after the last one (checkTunnels). Null and
+     * throws as ensure.
+     */
+    borrow(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.open(udid, 'screenshot');
+        });
+    }
+    /** Whether the phone's tunnel was opened for screenshots and no stream has taken it. */
+    isOnDemand(udid) {
+        const tunnel = this.tunnels.get(udid);
+        return !!tunnel && tunnel.process.exitCode === null && !tunnel.streamOwned;
+    }
+    open(udid, use) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const running = this.tunnels.get(udid);
+            if (running && running.process.exitCode === null) {
+                this.claim(running, use);
+                return running.whenReady;
             }
-            if (version < 17)
+            // A screenshot also asks on a simulator, which has no version to read.
+            const version = yield this.versionOf(udid, use === 'screenshot');
+            if (version === null || version < 17)
                 return null;
             const port = yield this.allocator().acquirePair('tunnel', udid, {
-                ttlMs: exports.TUNNEL_LEASE_TTL_MS,
+                ttlMs: exports.IOS_STREAM_LEASE_TTL_MS,
             });
             let proc;
             try {
@@ -161,7 +188,15 @@ let IOSTunnels = class IOSTunnels {
                 yield this.releasePair(port, udid);
                 throw e;
             }
-            const tunnel = { port, process: proc, ready: false };
+            const tunnel = {
+                port,
+                process: proc,
+                ready: false,
+                whenReady: Promise.resolve(port),
+                streamOwned: false,
+                borrowedUntil: 0,
+            };
+            this.claim(tunnel, use);
             this.tunnels.set(udid, tunnel);
             this.watch();
             // A tunnel whose process ends (go-ios crashed, or something killed it)
@@ -175,16 +210,39 @@ let IOSTunnels = class IOSTunnels {
                 void this.releasePair(port, udid);
             };
             proc.once('exit', ended);
-            proc.once('error', (err) => {
+            // `on`, not `once`: a second 'error' with no listener left would be
+            // thrown, and take the server down. ended() only acts once.
+            proc.on('error', (err) => {
                 this.log.warn(`[${udid}] go-ios tunnel failed: ${err.message}`);
                 ended();
             });
             this.logOutput(udid, tunnel);
-            this.log.info(`[${udid}] iOS ${version}: starting a go-ios tunnel on ${port} (traffic on ${port + 1})`);
-            const polls = exports.TUNNEL_READY_TIMEOUT_MS / exports.TUNNEL_READY_POLL_MS;
-            for (let poll = 0; poll <= polls; poll++) {
-                if (poll > 0)
-                    yield this.sleep(exports.TUNNEL_READY_POLL_MS);
+            this.log.info(`[${udid}] iOS ${version}: starting a go-ios tunnel on ${port} (traffic on ${port + 1})` +
+                (use === 'screenshot' ? ' for screenshots' : ''));
+            // Whoever asks while it starts waits for the same start.
+            tunnel.whenReady = this.waitUntilReady(udid, tunnel);
+            return tunnel.whenReady;
+        });
+    }
+    claim(tunnel, use) {
+        if (use === 'stream')
+            tunnel.streamOwned = true;
+        else
+            tunnel.borrowedUntil = this.now() + exports.TUNNEL_BORROW_IDLE_MS;
+    }
+    waitUntilReady(udid, tunnel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { port, process: proc } = tunnel;
+            // By the clock, not a count of checks: each check can take up to its own
+            // 1 s timeout, which stretched 41 checks to about a minute.
+            const deadline = this.now() + exports.TUNNEL_READY_TIMEOUT_MS;
+            for (let first = true;; first = false) {
+                if (!first) {
+                    const left = deadline - this.now();
+                    if (left <= 0)
+                        break;
+                    yield this.sleep(Math.min(exports.TUNNEL_READY_POLL_MS, left));
+                }
                 if (this.tunnels.get(udid) !== tunnel) {
                     throw new Error(`The go-ios tunnel for ${udid} exited before it was ready (exit code ${proc.exitCode})` +
                         (tunnel.reason ? `: ${tunnel.reason}` : ''));
@@ -206,6 +264,33 @@ let IOSTunnels = class IOSTunnels {
             return port;
         });
     }
+    /**
+     * The phone's iOS version, from `ios info`, kept for VERSION_CACHE_MS: a
+     * screenshot on a phone below iOS 17 would otherwise ask every time. Null
+     * when it can't be read (not cached, so a phone still pairing is asked
+     * again); logged at debug when `quiet`.
+     */
+    versionOf(udid_1) {
+        return __awaiter(this, arguments, void 0, function* (udid, quiet = false) {
+            var _a;
+            const cached = this.versionCache.get(udid);
+            if (cached && this.now() - cached.at < VERSION_CACHE_MS)
+                return cached.version;
+            try {
+                const version = yield this.iosVersion(udid);
+                this.versionCache.set(udid, { version, at: this.now() });
+                return version;
+            }
+            catch (e) {
+                const message = `[${udid}] Could not read the iOS version, so no go-ios tunnel: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`;
+                if (quiet)
+                    this.log.debug(message);
+                else
+                    this.log.warn(message);
+                return null;
+            }
+        });
+    }
     /** The phone's tunnel-info port, while its tunnel runs. */
     portFor(udid) {
         const tunnel = this.tunnels.get(udid);
@@ -253,6 +338,11 @@ let IOSTunnels = class IOSTunnels {
             this.checking = true;
             try {
                 for (const [udid, tunnel] of [...this.tunnels]) {
+                    if (!tunnel.streamOwned && tunnel.borrowedUntil <= this.now()) {
+                        this.log.info(`[${udid}] go-ios tunnel on ${tunnel.port}, opened for screenshots, is idle; stopping it`);
+                        yield this.stop(udid);
+                        continue;
+                    }
                     const info = yield this.tunnelInfo(tunnel.port, udid);
                     if (this.tunnels.get(udid) !== tunnel)
                         continue;
@@ -295,8 +385,8 @@ let IOSTunnels = class IOSTunnels {
             if (!tunnel)
                 return;
             const allocator = this.allocator();
-            yield allocator.touch(tunnel.port, exports.TUNNEL_LEASE_TTL_MS);
-            yield allocator.touch(tunnel.port + 1, exports.TUNNEL_LEASE_TTL_MS);
+            yield allocator.touch(tunnel.port, exports.IOS_STREAM_LEASE_TTL_MS);
+            yield allocator.touch(tunnel.port + 1, exports.IOS_STREAM_LEASE_TTL_MS);
         });
     }
     releasePair(port, udid) {
@@ -400,6 +490,9 @@ let IOSTunnels = class IOSTunnels {
             req.on('error', () => resolve({ state: 'unknown' }));
         });
     }
+    now() {
+        return Date.now();
+    }
     sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }

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

@@ -395,12 +395,20 @@ let WDAClient = WDAClient_1 = class WDAClient {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
             const s = typedi_1.Container.get(IOSStreamService_1.default);
+            let tunnelError;
             if (yield s.isGoIOSAvailable()) {
                 try {
+                    // On iOS 17+ go-ios reaches the screenshot service only through the
+                    // phone's own tunnel, and a phone that isn't streaming has none: open
+                    // one, kept while screenshots keep coming (see IOSTunnels.borrow).
+                    const tunnels = typedi_1.Container.get(IOSTunnels_1.IOSTunnels);
+                    yield tunnels.borrow(udid).catch((e) => {
+                        tunnelError = e;
+                        throw e;
+                    });
                     const p = path_1.default.join(os_1.default.tmpdir(), `screenshot-${udid}.png`);
                     yield execFilePromise(s.goIOSPath, ['screenshot', '--udid', udid, '--output', p], {
-                        // This phone's own go-ios tunnel on iOS 17+ (see IOSTunnels).
-                        env: typedi_1.Container.get(IOSTunnels_1.IOSTunnels).envFor(udid),
+                        env: tunnels.envFor(udid),
                     });
                     const b = yield fs_extra_1.default.readFile(p);
                     yield fs_extra_1.default.remove(p);
@@ -410,8 +418,14 @@ let WDAClient = WDAClient_1 = class WDAClient {
                     this.log.debug(`go-ios screenshot failed for ${udid}: ${e.message}\n${e.stack}`);
                 }
             }
-            const res = yield this.sendWDACommand(udid, 'get', '/screenshot');
-            return ((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.screenshot) || ((_c = res.data) === null || _c === void 0 ? void 0 : _c.value) || '';
+            try {
+                const res = yield this.sendWDACommand(udid, 'get', '/screenshot');
+                return ((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.screenshot) || ((_c = res.data) === null || _c === void 0 ? void 0 : _c.value) || '';
+            }
+            catch (e) {
+                // WebDriverAgent couldn't answer either; the tunnel's reason says more.
+                throw tunnelError !== null && tunnelError !== void 0 ? tunnelError : e;
+            }
         });
     }
     getClipboard(udid) {

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

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goIosBinaryPath = goIosBinaryPath;
+const path_1 = __importDefault(require("path"));
+const helpers_1 = require("../../helpers");
+/**
+ * The go-ios binary Xenon vendors, where src/scripts/install-go-ios.ts puts
+ * it. Every go-ios command Xenon runs uses this one path: the boot and
+ * shutdown reaps find go-ios processes by it.
+ */
+function goIosBinaryPath() {
+    return path_1.default.join((0, helpers_1.cachePath)('goIOS'), 'ios');
+}

package/lib/src/plugin.js

@@ -157,16 +157,8 @@ class XenonPlugin extends base_plugin_1.default {
             catch (err) {
                 logger_1.default.warn(`[plugin] RecordingOrchestrator.recoverOnBoot failed: ${err === null || err === void 0 ? void 0 : err.message}`);
             }
-            // Reap orphan go-ios tunnels left by a previous run or a hard-killed/crashed
-            // process. A fresh server owns no tunnels, so any surviving go-ios agents are
-            // orphans that would otherwise keep self-forking into a runaway process storm.
-            try {
-                const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/ios/IOSStreamService')));
-                yield typedi_1.Container.get(IOSStreamService).reapOrphanTunnels();
-            }
-            catch (err) {
-                logger_1.default.warn(`[plugin] IOSStreamService.reapOrphanTunnels failed: ${err === null || err === void 0 ? void 0 : err.message}`);
-            }
+            // Leftover go-ios is reaped by ServerManager.updateServer, before device
+            // detection starts: here, the reap killed detection's own go-ios calls.
         });
     }
     createSession(next, driver, jwpDesCaps, jwpReqCaps, caps) {

package/lib/src/services/PortAllocator.js

@@ -291,9 +291,16 @@ let PortAllocator = class PortAllocator {
                 .catch(() => undefined);
         });
     }
+    /**
+     * Delete a phone's leases when a session on it ends. Not its go-ios
+     * tunnel's pair: the phone's stream, and so its tunnel, can outlive the
+     * session, and IOSTunnels gives the pair back when the tunnel stops.
+     */
     releaseForUdid(udid) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield prisma_1.prisma.portLease.deleteMany({ where: { leasedToUdid: udid } });
+            yield prisma_1.prisma.portLease.deleteMany({
+                where: { leasedToUdid: udid, purpose: { not: 'tunnel' } },
+            });
         });
     }
     purgeExpired() {

package/lib/src/services/ServerManager.js

@@ -130,6 +130,8 @@ let ServerManager = ServerManager_1 = class ServerManager {
             }
             yield this.syncDatabaseAndAIConfig(pluginArgs);
             yield this.initializeCoreSubsystems(pluginArgs, cliArgs.port);
+            // Before anything below starts go-ios: the reap would kill it too.
+            yield this.reapLeftoverGoIos();
             this.registerRoutes(expressApp, httpServer, cliArgs, pluginArgs);
             yield this.bootEmulators(pluginArgs);
             this.registerDependenciesInContainer(pluginArgs, cliArgs, nodeId);
@@ -364,6 +366,26 @@ let ServerManager = ServerManager_1 = class ServerManager {
             typedi_1.Container.set(ARTIFACT_STORE, new FsArtifactStore(config_1.config.recordingsAssetsPath));
         });
     }
+    /**
+     * Reap what a previous run (or a hard-killed one) left of go-ios: tunnels
+     * whose agents keep self-forking, WebDriverAgent runners and log streams.
+     * It kills every process running the go-ios binary, this process's own
+     * included, so it runs before anything here starts one. It used to run at
+     * the end of boot, after device detection had started, and killed the
+     * `ios info` call detection makes in the background for each plugged-in
+     * iPhone ("Failed to fetch IP via go-ios" at every boot).
+     */
+    reapLeftoverGoIos() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('../device-managers/ios/IOSStreamService')));
+                yield typedi_1.Container.get(IOSStreamService).reapOrphanTunnels();
+            }
+            catch (err) {
+                this.logger.warn(`Reaping go-ios left by a previous run failed: ${err === null || err === void 0 ? void 0 : err.message}`);
+            }
+        });
+    }
     registerRoutes(expressApp, httpServer, cliArgs, pluginArgs) {
         expressApp.use('/xenon', (0, app_1.createRouter)(pluginArgs));
         // The session gateway goes in front of Appium's routes: Xenon's own

package/lib/test/unit/PortAllocator.test.js

@@ -93,7 +93,7 @@ describe('PortAllocator', () => {
         (0, chai_1.expect)(deleteStub.calledWith({ where: { port: 9100 } })).to.be.true;
         (0, chai_1.expect)(createStub.called, 'should allocate a replacement lease').to.be.true;
     }));
-    it('releaseForUdid deletes all leases for that UDID', () => __awaiter(void 0, void 0, void 0, function* () {
+    it("releaseForUdid deletes that UDID's leases", () => __awaiter(void 0, void 0, void 0, function* () {
         deleteManyStub.resolves({ count: 2 });
         const allocator = makeAllocator({ wda: [8100, 8102] });
         yield allocator.releaseForUdid('udid-1');

package/lib/test/unit/boot-go-ios-reap.spec.js

@@ -0,0 +1,80 @@
+"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 });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const plugin_1 = require("../../src/plugin");
+const ServerManager_1 = require("../../src/services/ServerManager");
+const PluginContext_1 = require("../../src/PluginContext");
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const RecordingOrchestrator_1 = require("../../src/services/recording/RecordingOrchestrator");
+const logger_1 = __importDefault(require("../../src/logger"));
+/**
+ * At boot Xenon reaps what a previous run left of go-ios (tunnels whose agents
+ * self-fork, WebDriverAgent runners, log streams). The reap kills every process
+ * running the vendored go-ios binary, so it also kills this process's own
+ * go-ios calls. It used to run last, after device detection had started:
+ * detection asks `ios info` about each plugged-in iPhone in the background,
+ * and those calls were killed ("Failed to fetch IP via go-ios" for every
+ * iPhone, at every boot). It now runs as soon as the database is ready,
+ * before this process starts go-ios at all.
+ */
+describe('reaping go-ios left by a previous run, at boot', () => {
+    let statics;
+    beforeEach(() => {
+        statics = {
+            nodeId: plugin_1.XenonPlugin.NODE_ID,
+            port: plugin_1.XenonPlugin.port,
+            basePath: plugin_1.XenonPlugin.nodeBasePath,
+        };
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+        plugin_1.XenonPlugin.NODE_ID = statics.nodeId;
+        plugin_1.XenonPlugin.port = statics.port;
+        plugin_1.XenonPlugin.nodeBasePath = statics.basePath;
+    });
+    it('runs once the database is ready, before routes and device detection start', () => __awaiter(void 0, void 0, void 0, function* () {
+        const steps = [];
+        const step = (name) => () => {
+            steps.push(name);
+            return Promise.resolve();
+        };
+        const boot = ServerManager_1.ServerManager.prototype;
+        sinon_1.default.stub(boot, 'resolvePluginArgs').resolves({});
+        sinon_1.default.stub(logger_1.default, 'banner');
+        sinon_1.default.stub(PluginContext_1.PluginContext.prototype, 'setContext');
+        sinon_1.default.stub(boot, 'syncDatabaseAndAIConfig').callsFake(step('database config'));
+        sinon_1.default.stub(boot, 'initializeCoreSubsystems').callsFake(step('database and migrations'));
+        sinon_1.default.stub(IOSStreamService_1.default.prototype, 'reapOrphanTunnels').callsFake(step('reap'));
+        // Everything that starts go-ios (device managers, detection, the hub's and
+        // node's discovery crons) comes after the routes; stop there.
+        sinon_1.default.stub(boot, 'registerRoutes').callsFake(() => {
+            steps.push('routes');
+            throw new Error('boot stopped by the test');
+        });
+        const booting = typedi_1.Container.get(ServerManager_1.ServerManager).updateServer({}, null, { port: 4723 });
+        yield booting.then(() => chai_1.expect.fail('the stubbed routes step should have stopped the boot'), (err) => (0, chai_1.expect)(err.message).to.equal('boot stopped by the test'));
+        (0, chai_1.expect)(steps).to.deep.equal(['database config', 'database and migrations', 'reap', 'routes']);
+    }));
+    it('is not left to the plugin, which boots after detection has started', () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(ServerManager_1.ServerManager.prototype, 'updateServer').resolves();
+        sinon_1.default.stub(RecordingOrchestrator_1.RecordingOrchestrator.prototype, 'recoverOnBoot').resolves();
+        const reap = sinon_1.default.stub(IOSStreamService_1.default.prototype, 'reapOrphanTunnels').resolves();
+        yield plugin_1.XenonPlugin.updateServer({}, null, {});
+        (0, chai_1.expect)(reap.called).to.equal(false);
+    }));
+});

package/lib/test/unit/ios-go-ios-tunnel-env.spec.js

@@ -43,13 +43,33 @@ case "$1" in
   syslog) printf '{"msg":"port=%s"}\\n' "$GO_IOS_AGENT_PORT"; exec sleep 5 ;;
 esac
 `;
-/** IOSTunnels as if WITH_TUNNEL's tunnel ran on 12100 and NO_TUNNEL had none. */
+/** iOS 17+, not streaming: it has a tunnel only once one is opened for it. */
+const NEEDS_TUNNEL = 'test-iphone-idle-00008120';
+/**
+ * IOSTunnels as if WITH_TUNNEL's tunnel ran on 12100, NO_TUNNEL needed none
+ * (below iOS 17), and NEEDS_TUNNEL got one on 12102 once borrowed.
+ */
 const tunnels = {
+    borrowed: new Set(),
+    borrowCalls: [],
+    borrowError: undefined,
+    borrow(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.borrowCalls.push(udid);
+            if (this.borrowError)
+                throw this.borrowError;
+            if (udid === NEEDS_TUNNEL)
+                this.borrowed.add(udid);
+            return udid === WITH_TUNNEL ? 12100 : udid === NEEDS_TUNNEL ? 12102 : null;
+        });
+    },
     envFor(udid) {
         const env = Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' });
         delete env.GO_IOS_AGENT_PORT;
         if (udid === WITH_TUNNEL)
             env.GO_IOS_AGENT_PORT = '12100';
+        if (this.borrowed.has(udid))
+            env.GO_IOS_AGENT_PORT = '12102';
         return env;
     },
 };
@@ -63,6 +83,9 @@ describe("go-ios commands find their own phone's tunnel (GO_IOS_AGENT_PORT)", ()
     });
     after(() => fs_1.default.rmSync(dir, { recursive: true, force: true }));
     beforeEach(() => {
+        tunnels.borrowed.clear();
+        tunnels.borrowCalls = [];
+        tunnels.borrowError = undefined;
         const real = typedi_1.Container.get.bind(typedi_1.Container);
         sinon_1.default.stub(typedi_1.Container, 'get').callsFake((token) => {
             if (token === IOSTunnels_1.IOSTunnels)
@@ -88,6 +111,20 @@ describe("go-ios commands find their own phone's tunnel (GO_IOS_AGENT_PORT)", ()
             const png = yield new WDAClient_1.WDAClient().getScreenshot(NO_TUNNEL);
             (0, chai_1.expect)(Buffer.from(png, 'base64').toString()).to.equal('port=');
         }));
+        // On iOS 17+ the screenshot service is reached only through the tunnel,
+        // and a phone that isn't streaming has none.
+        it("opens the phone's tunnel for a screenshot when it has none", () => __awaiter(void 0, void 0, void 0, function* () {
+            const png = yield new WDAClient_1.WDAClient().getScreenshot(NEEDS_TUNNEL);
+            (0, chai_1.expect)(tunnels.borrowCalls).to.deep.equal([NEEDS_TUNNEL]);
+            (0, chai_1.expect)(Buffer.from(png, 'base64').toString()).to.equal('port=12102');
+        }));
+        it("says why, when the tunnel can't start and WebDriverAgent can't answer either", () => __awaiter(void 0, void 0, void 0, function* () {
+            tunnels.borrowError = new Error('The go-ios tunnel for X exited before it was ready (exit code 1): failed to start tunnel: EOF');
+            const client = new WDAClient_1.WDAClient();
+            sinon_1.default.stub(client, 'sendWDACommand').rejects(new Error('connect ECONNREFUSED'));
+            const err = yield client.getScreenshot(NEEDS_TUNNEL).then(() => null, (e) => e);
+            (0, chai_1.expect)(err === null || err === void 0 ? void 0 : err.message).to.match(/exited before it was ready .*failed to start tunnel: EOF/);
+        }));
     });
     describe('the logs read (WDAClient syslog)', () => {
         let client;