@xenon-device-management/xenon 2.7.0 → 2.8.0

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

@@ -0,0 +1,376 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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.IOSTunnels = exports.TUNNEL_CHECK_MS = exports.TUNNEL_LEASE_TTL_MS = exports.TUNNEL_READY_POLL_MS = exports.TUNNEL_READY_TIMEOUT_MS = void 0;
+exports.iosVersionOf = iosVersionOf;
+/**
+ * One go-ios tunnel per iOS 17+ phone, each on its own leased pair of ports.
+ *
+ * On iOS 17 and later, the go-ios commands Xenon runs against a phone's
+ * services (`runwda`, `ostrace`, `syslog`, `screenshot`) reach it through a
+ * tunnel, which they find through that tunnel's info API. Through 2.7 every
+ * tunnel took go-ios's default ports (60105 for the API, 60106 for the
+ * traffic), so a second iPhone's stream killed the first one's tunnel.
+ *
+ * Each phone now gets `tunnel start --udid <phone> --tunnel-info-port <P>`,
+ * an isolated per-device agent: P from the `tunnel` port range, and P + 1,
+ * which go-ios derives for the phone's traffic. A command finds its phone's
+ * tunnel through GO_IOS_AGENT_PORT, set by {@link IOSTunnels.envFor}.
+ *
+ * go-ios does not end an agent when its phone is unplugged. The agent only
+ * drops the phone's tunnel, and on the replug starts a new one on its next
+ * traffic port, P + 2, then P + 3: the next phone's leased pair. So a tunnel
+ * whose phone went away, or whose traffic port moved, is stopped
+ * ({@link IOSTunnels.checkTunnels}, every few seconds), and the phone's next
+ * stream start makes a new one on a fresh pair.
+ *
+ * This is mechanism only. When a tunnel may be stopped (never under a live
+ * Appium session) is IOSStreamService's decision.
+ */
+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 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}.
+ */
+exports.TUNNEL_LEASE_TTL_MS = 90 * 60 * 1000;
+/** How often running tunnels are checked for a phone that went away. */
+exports.TUNNEL_CHECK_MS = 5000;
+/** 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');
+    const match = versionStr.match(/(\d+\.?\d*)/);
+    return match ? parseFloat(match[0]) : 0;
+}
+/** An answer that puts the phone's traffic anywhere but its leased P + 1. */
+function moved(info, port) {
+    return info.state === 'up' && info.userspacePort !== undefined && info.userspacePort !== port + 1;
+}
+let IOSTunnels = class IOSTunnels {
+    constructor() {
+        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');
+    }
+    /**
+     * 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.
+     */
+    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;
+            }
+            if (version < 17)
+                return null;
+            const port = yield this.allocator().acquirePair('tunnel', udid, {
+                ttlMs: exports.TUNNEL_LEASE_TTL_MS,
+            });
+            let proc;
+            try {
+                proc = this.spawnTunnel(udid, [
+                    'tunnel',
+                    'start',
+                    '--udid',
+                    udid,
+                    '--userspace',
+                    '--tunnel-info-port',
+                    String(port),
+                ]);
+            }
+            catch (e) {
+                yield this.releasePair(port, udid);
+                throw e;
+            }
+            const tunnel = { port, process: proc, ready: false };
+            this.tunnels.set(udid, tunnel);
+            this.watch();
+            // A tunnel whose process ends (go-ios crashed, or something killed it)
+            // gives its ports back, and the phone's next start gets a new one. An
+            // unplug doesn't end it: see checkTunnels.
+            const ended = () => {
+                if (this.tunnels.get(udid) !== tunnel)
+                    return;
+                this.tunnels.delete(udid);
+                this.unwatchIfIdle();
+                void this.releasePair(port, udid);
+            };
+            proc.once('exit', ended);
+            proc.once('error', (err) => {
+                this.log.warn(`[${udid}] go-ios tunnel failed: ${err.message}`);
+                ended();
+            });
+            this.logOutput(udid, proc);
+            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);
+                if (this.tunnels.get(udid) !== tunnel) {
+                    throw new Error(`The go-ios tunnel for ${udid} exited before it was ready (exit code ${proc.exitCode})`);
+                }
+                const info = yield this.tunnelInfo(port, udid);
+                if (moved(info, port)) {
+                    // A first attempt failed and go-ios retried on its next port, which
+                    // may be another phone's.
+                    yield this.stop(udid);
+                    throw new Error(`The go-ios tunnel for ${udid} came up on port ${info.userspacePort}, not its leased ${port + 1}, so it was stopped`);
+                }
+                if (info.state === 'up') {
+                    tunnel.ready = true;
+                    this.log.info(`[${udid}] go-ios tunnel ready on ${port}`);
+                    return port;
+                }
+            }
+            this.log.warn(`[${udid}] go-ios tunnel on ${port} not ready after ${exports.TUNNEL_READY_TIMEOUT_MS / 1000}s, proceeding anyway`);
+            return port;
+        });
+    }
+    /** The phone's tunnel-info port, while its tunnel runs. */
+    portFor(udid) {
+        const tunnel = this.tunnels.get(udid);
+        return tunnel && tunnel.process.exitCode === null ? tunnel.port : undefined;
+    }
+    /**
+     * The environment for a go-ios command about this phone: today's, plus
+     * GO_IOS_AGENT_PORT while the phone has a tunnel, so the command finds that
+     * tunnel and not go-ios's default 60105.
+     */
+    envFor(udid) {
+        const env = Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' });
+        const port = this.portFor(udid);
+        if (port !== undefined)
+            env.GO_IOS_AGENT_PORT = String(port);
+        return env;
+    }
+    /** Stop the phone's tunnel and give its ports back. Other phones' tunnels are untouched. */
+    stop(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tunnel = this.tunnels.get(udid);
+            if (!tunnel)
+                return;
+            this.tunnels.delete(udid);
+            this.unwatchIfIdle();
+            this.killGroup(tunnel.process.pid);
+            yield this.releasePair(tunnel.port, udid);
+        });
+    }
+    /**
+     * Stop each tunnel whose phone has gone, and give its ports back. go-ios
+     * keeps a per-device agent running when its phone is unplugged and, on the
+     * replug, starts the tunnel on its next traffic port: the next phone's
+     * pair. So a tunnel that had its phone and now answers 404, or that answers
+     * on a traffic port other than P + 1, is stopped. Either way the phone's
+     * stream has already lost it, and its next start makes a new one.
+     *
+     * An agent that doesn't answer is left alone: a busy agent isn't a gone
+     * phone, and one whose process died is handled by its exit.
+     */
+    checkTunnels() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.checking)
+                return;
+            this.checking = true;
+            try {
+                for (const [udid, tunnel] of [...this.tunnels]) {
+                    const info = yield this.tunnelInfo(tunnel.port, udid);
+                    if (this.tunnels.get(udid) !== tunnel)
+                        continue;
+                    if (moved(info, tunnel.port)) {
+                        this.log.warn(`[${udid}] go-ios moved the phone's tunnel from port ${tunnel.port + 1} to ${info.userspacePort} (it reconnected); stopping it`);
+                    }
+                    else if (info.state === 'gone' && tunnel.ready) {
+                        this.log.warn(`[${udid}] go-ios tunnel on ${tunnel.port} lost its phone (unplugged?); stopping it and freeing its ports`);
+                    }
+                    else {
+                        if (info.state === 'up')
+                            tunnel.ready = true;
+                        continue;
+                    }
+                    yield this.stop(udid);
+                }
+            }
+            finally {
+                this.checking = false;
+            }
+        });
+    }
+    watch() {
+        var _a, _b;
+        if (this.watcher)
+            return;
+        this.watcher = setInterval(() => void this.checkTunnels(), exports.TUNNEL_CHECK_MS);
+        (_b = (_a = this.watcher).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    unwatchIfIdle() {
+        if (this.tunnels.size > 0 || !this.watcher)
+            return;
+        clearInterval(this.watcher);
+        this.watcher = undefined;
+    }
+    /** Keep the phone's tunnel ports leased. The stream watchdog calls this hourly. */
+    touch(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tunnel = this.tunnels.get(udid);
+            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);
+        });
+    }
+    releasePair(port, udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const allocator = this.allocator();
+                yield allocator.release(port, udid);
+                yield allocator.release(port + 1, udid);
+            }
+            catch (e) {
+                this.log.warn(`[${udid}] Could not release tunnel ports ${port}-${port + 1}: ${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}`);
+            }
+        });
+    }
+    /**
+     * go-ios's output, at debug. Its repeated warning about a connected
+     * pre-iOS 17 phone (which needs no tunnel) is logged once per phone.
+     */
+    logOutput(udid, proc) {
+        var _a, _b;
+        (_a = proc.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => this.log.debug(`Tunnel [${udid}]: ${data}`));
+        const loggedUnsupported = new Set();
+        (_b = proc.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
+            const text = String(data);
+            const { unsupported, udid: targetUdid } = (0, iosStreamDiagnostics_1.classifyTunnelStderr)(text);
+            if (unsupported) {
+                const key = targetUdid !== null && targetUdid !== void 0 ? targetUdid : 'unknown';
+                if (!loggedUnsupported.has(key)) {
+                    loggedUnsupported.add(key);
+                    this.log.debug(`Tunnel [${udid}]: device ${key} is pre-iOS 17 and needs no tunnel; suppressing repeated go-ios warnings`);
+                }
+                return;
+            }
+            this.log.debug(`Tunnel Err [${udid}]: ${text}`);
+        });
+    }
+    // ---------------------------------------------------------------------
+    // Seams. Overridden by tests; the defaults are the real thing.
+    // ---------------------------------------------------------------------
+    iosVersion(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { stdout } = yield execPromise(`"${this.goIOSPath}" info --udid ${udid}`, {
+                env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
+            });
+            return iosVersionOf(JSON.parse(stdout));
+        });
+    }
+    /**
+     * Detached, so the tunnel leads its own process group and its self-forking
+     * agent children die with it (see ./tunnelProcess).
+     */
+    spawnTunnel(udid, args) {
+        const wrapped = typedi_1.Container.get(ResourceIsolationService_1.ResourceIsolationService).wrapSpawn(this.goIOSPath, args, 'Performance');
+        const proc = (0, child_process_1.spawn)(wrapped.command, wrapped.args, (0, tunnelProcess_1.tunnelSpawnOptions)(Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' })));
+        typedi_1.Container.get(ProcessRegistry_1.ProcessRegistry).track({ kind: 'other', udid, process: proc });
+        return proc;
+    }
+    /**
+     * What the tunnel's agent on `port` says about the phone. go-ios answers
+     * `GET /tunnel/<udid>` with 404 until it has the phone's tunnel, then 200
+     * with the tunnel, `userspaceTunPort` included.
+     */
+    tunnelInfo(port, udid) {
+        return new Promise((resolve) => {
+            const req = http_1.default.get({
+                host: '127.0.0.1',
+                port,
+                path: `/tunnel/${encodeURIComponent(udid)}`,
+                timeout: 1000,
+                agent: false,
+            }, (res) => {
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    resolve(res.statusCode === 404 ? { state: 'gone' } : { state: 'unknown' });
+                    return;
+                }
+                let body = '';
+                res.setEncoding('utf8');
+                res.on('data', (chunk) => (body += chunk));
+                res.on('end', () => {
+                    var _a;
+                    let userspacePort;
+                    try {
+                        const value = (_a = JSON.parse(body)) === null || _a === void 0 ? void 0 : _a.userspaceTunPort;
+                        if (typeof value === 'number')
+                            userspacePort = value;
+                    }
+                    catch (_b) {
+                        // A 200 without JSON still says the tunnel is up.
+                    }
+                    resolve({ state: 'up', userspacePort });
+                });
+                res.on('error', () => resolve({ state: 'unknown' }));
+            });
+            req.on('timeout', () => req.destroy());
+            req.on('error', () => resolve({ state: 'unknown' }));
+        });
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    killGroup(pid) {
+        (0, tunnelProcess_1.killProcessGroup)(pid);
+    }
+    allocator() {
+        return typedi_1.Container.get(PortAllocator_1.PortAllocator);
+    }
+};
+exports.IOSTunnels = IOSTunnels;
+exports.IOSTunnels = IOSTunnels = __decorate([
+    (0, typedi_1.Service)()
+], IOSTunnels);

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

@@ -26,6 +26,7 @@ const logger_1 = __importDefault(require("../../logger"));
 const typedi_1 = require("typedi");
 const ProcessRegistry_1 = require("../../services/ProcessRegistry");
 const IOSStreamService_1 = __importDefault(require("./IOSStreamService"));
+const IOSTunnels_1 = require("./IOSTunnels");
 const device_store_1 = require("../../data-service/device-store");
 const child_process_1 = require("child_process");
 const util_1 = require("util");
@@ -398,7 +399,8 @@ let WDAClient = WDAClient_1 = class WDAClient {
                 try {
                     const p = path_1.default.join(os_1.default.tmpdir(), `screenshot-${udid}.png`);
                     yield execFilePromise(s.goIOSPath, ['screenshot', '--udid', udid, '--output', p], {
-                        env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
+                        // This phone's own go-ios tunnel on iOS 17+ (see IOSTunnels).
+                        env: typedi_1.Container.get(IOSTunnels_1.IOSTunnels).envFor(udid),
                     });
                     const b = yield fs_extra_1.default.readFile(p);
                     yield fs_extra_1.default.remove(p);
@@ -763,7 +765,8 @@ let WDAClient = WDAClient_1 = class WDAClient {
         }
         this.log.info(`[LogStream] Starting persistent syslog for ${udid}: ${command} ${args.join(' ')}`);
         const proc = (0, child_process_1.spawn)(command, args, {
-            env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
+            // This phone's own go-ios tunnel on iOS 17+ (see IOSTunnels).
+            env: typedi_1.Container.get(IOSTunnels_1.IOSTunnels).envFor(udid),
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         typedi_1.Container.get(ProcessRegistry_1.ProcessRegistry).track({ kind: 'log-tailer', udid, process: proc });

package/lib/src/services/PortAllocator.js

@@ -31,6 +31,7 @@ const DEFAULT_RANGES = {
     mjpeg: [9100, 9199],
     system: [10100, 10199],
     proxy: [11100, 11199],
+    tunnel: [12100, 12199],
 };
 /** Loopback and wildcard, in both families. See isOsFree. */
 const PROBE_HOSTS = ['127.0.0.1', '::1', '0.0.0.0', '::'];
@@ -145,6 +146,70 @@ let PortAllocator = class PortAllocator {
             }
         });
     }
+    /**
+     * Lease two adjacent ports, an even P and P + 1, and return P. A go-ios
+     * tunnel needs both: P for its tunnel-info API, and P + 1, which go-ios
+     * itself picks for the phone's traffic.
+     *
+     * Both must be free in the lease table, whatever purpose holds them, and at
+     * the OS. A half-taken pair is given back before the next one is tried.
+     */
+    acquirePair(purpose_1, udid_1) {
+        return __awaiter(this, arguments, void 0, function* (purpose, udid, opts = {}) {
+            var _a;
+            const [start, end] = this.ranges[purpose];
+            const ttlMs = (_a = opts.ttlMs) !== null && _a !== void 0 ? _a : 60 * 60 * 1000;
+            const now = Date.now();
+            yield prisma_1.prisma.portLease.deleteMany({ where: { expiresAt: { lt: now } } });
+            const active = yield prisma_1.prisma.portLease.findMany({
+                where: { port: { gte: start, lte: end } },
+                select: { port: true },
+            });
+            const taken = new Set(active.map((l) => l.port));
+            const lease = {
+                purpose,
+                leasedToUdid: udid,
+                leasedToPid: opts.pid,
+                leasedAt: now,
+                expiresAt: now + ttlMs,
+            };
+            for (let port = start + (start % 2); port + 1 <= end; port += 2) {
+                if (taken.has(port) || taken.has(port + 1))
+                    continue;
+                const leased = [];
+                try {
+                    for (const p of [port, port + 1]) {
+                        yield prisma_1.prisma.portLease.create({ data: Object.assign({ port: p }, lease) });
+                        leased.push(p);
+                    }
+                }
+                catch (err) {
+                    yield this.releaseAll(leased, udid);
+                    if (err.code === 'P2002')
+                        continue;
+                    throw err;
+                }
+                if ((yield this.isOsFree(port)) && (yield this.isOsFree(port + 1))) {
+                    this.log.debug(`Leased ports ${port}-${port + 1} (${purpose}) to ${udid}`);
+                    return port;
+                }
+                yield this.releaseAll(leased, udid);
+            }
+            throw new PortRangeExhaustedError(purpose);
+        });
+    }
+    /** Delete every lease of `purpose`. At boot, when nothing of this server holds one. */
+    releasePurpose(purpose) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield prisma_1.prisma.portLease.deleteMany({ where: { purpose } });
+        });
+    }
+    releaseAll(ports, udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const port of ports)
+                yield this.release(port, udid);
+        });
+    }
     /**
      * Soft-block a port so the next `acquire` for the same purpose skips it.
      * Used when bind fails (EADDRINUSE) even though our lease owned the number —

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

@@ -0,0 +1,154 @@
+"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 events_1 = require("events");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const IOSStreamService_1 = __importDefault(require("../../src/device-managers/ios/IOSStreamService"));
+const IOSLogStreamService_1 = require("../../src/device-managers/ios/IOSLogStreamService");
+const IOSTunnels_1 = require("../../src/device-managers/ios/IOSTunnels");
+const WDAClient_1 = require("../../src/device-managers/ios/WDAClient");
+const device_store_1 = require("../../src/data-service/device-store");
+const ProcessRegistry_1 = require("../../src/services/ProcessRegistry");
+/**
+ * On iOS 17+ a go-ios command finds its phone's tunnel through
+ * GO_IOS_AGENT_PORT. Each phone has its own tunnel now, so each command has
+ * to carry its own phone's port, or it reaches go-ios's default 60105, where
+ * no tunnel listens.
+ *
+ * `go-ios` here is a shell script that reports the port it was run with.
+ */
+const WITH_TUNNEL = 'test-iphone-tunnel-00008150';
+const NO_TUNNEL = 'test-iphone-plain-00008110';
+const FAKE_GO_IOS = `#!/bin/sh
+# Stands in for go-ios: reports the GO_IOS_AGENT_PORT it was run with.
+case "$1" in
+  screenshot) printf 'port=%s' "$GO_IOS_AGENT_PORT" > "$5" ;;
+  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. */
+const tunnels = {
+    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';
+        return env;
+    },
+};
+describe("go-ios commands find their own phone's tunnel (GO_IOS_AGENT_PORT)", () => {
+    let dir;
+    let goIOS;
+    before(() => {
+        dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'xenon-fake-goios-'));
+        goIOS = path_1.default.join(dir, 'ios');
+        fs_1.default.writeFileSync(goIOS, FAKE_GO_IOS, { mode: 0o755 });
+    });
+    after(() => fs_1.default.rmSync(dir, { recursive: true, force: true }));
+    beforeEach(() => {
+        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)
+                return tunnels;
+            if (token === IOSStreamService_1.default) {
+                return { goIOSPath: goIOS, isGoIOSAvailable: () => __awaiter(void 0, void 0, void 0, function* () { return true; }) };
+            }
+            if (token === ProcessRegistry_1.ProcessRegistry)
+                return { track: () => 'tracked' };
+            return real(token);
+        });
+        sinon_1.default.stub(device_store_1.DeviceStoreFactory, 'getStore').returns({
+            findDevice: (_a) => __awaiter(void 0, [_a], void 0, function* ({ udid }) { return ({ udid, realDevice: true }); }),
+        });
+    });
+    afterEach(() => sinon_1.default.restore());
+    describe("device control's screenshot (WDAClient)", () => {
+        it("runs go-ios screenshot with the phone's tunnel port", () => __awaiter(void 0, void 0, void 0, function* () {
+            const png = yield new WDAClient_1.WDAClient().getScreenshot(WITH_TUNNEL);
+            (0, chai_1.expect)(Buffer.from(png, 'base64').toString()).to.equal('port=12100');
+        }));
+        it('runs it with no tunnel port for a phone that has no tunnel', () => __awaiter(void 0, void 0, void 0, function* () {
+            const png = yield new WDAClient_1.WDAClient().getScreenshot(NO_TUNNEL);
+            (0, chai_1.expect)(Buffer.from(png, 'base64').toString()).to.equal('port=');
+        }));
+    });
+    describe('the logs read (WDAClient syslog)', () => {
+        let client;
+        beforeEach(() => {
+            client = new WDAClient_1.WDAClient();
+        });
+        afterEach(() => {
+            client.stopLogStream(WITH_TUNNEL);
+            client.stopLogStream(NO_TUNNEL);
+        });
+        /** The first line the phone's syslog yields; the first read starts it. */
+        function firstLine(udid) {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (let i = 0; i < 50; i++) {
+                    const lines = yield client.getLogs(udid);
+                    if (lines)
+                        return lines;
+                    yield new Promise((resolve) => setTimeout(resolve, 100));
+                }
+                return '';
+            });
+        }
+        it("runs go-ios syslog with the phone's tunnel port", () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield firstLine(WITH_TUNNEL)).to.equal('port=12100');
+        }));
+        it('runs it with no tunnel port for a phone that has no tunnel', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)(yield firstLine(NO_TUNNEL)).to.equal('port=');
+        }));
+    });
+    describe('the live logs pane (IOSLogStreamService ostrace)', () => {
+        class CapturingLogs extends IOSLogStreamService_1.IOSLogStreamService {
+            constructor() {
+                super(...arguments);
+                this.spawned = [];
+            }
+            goIOSPath() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return goIOS;
+                });
+            }
+            spawnProcess(command, args, env) {
+                this.spawned.push({ command, args, env });
+                const proc = new events_1.EventEmitter();
+                proc.stdout = new events_1.EventEmitter();
+                proc.stderr = new events_1.EventEmitter();
+                return proc;
+            }
+        }
+        it("runs go-ios ostrace with the phone's tunnel port", () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const logs = new CapturingLogs();
+            yield logs.spawnOstrace(WITH_TUNNEL, {});
+            (0, chai_1.expect)(logs.spawned[0].args[0]).to.equal('ostrace');
+            (0, chai_1.expect)((_a = logs.spawned[0].env) === null || _a === void 0 ? void 0 : _a.GO_IOS_AGENT_PORT).to.equal('12100');
+        }));
+        it('runs it with no tunnel port for a phone that has no tunnel', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const logs = new CapturingLogs();
+            yield logs.spawnOstrace(NO_TUNNEL, {});
+            (0, chai_1.expect)(logs.spawned[0].env, 'an environment is passed').to.not.equal(undefined);
+            (0, chai_1.expect)((_a = logs.spawned[0].env) === null || _a === void 0 ? void 0 : _a.GO_IOS_AGENT_PORT).to.equal(undefined);
+        }));
+    });
+});