@xenon-device-management/xenon 2.7.0 → 2.8.0

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

@@ -67,6 +67,7 @@ const singleFlight_1 = require("../../helpers/singleFlight");
 const LogcatMultiplexer_1 = require("../android/LogcatMultiplexer");
 const ostraceParse_1 = require("../../services/logcat/ostraceParse");
 const LogcatStreamService_1 = require("../android/LogcatStreamService");
+const IOSTunnels_1 = require("./IOSTunnels");
 /**
  * Which slice of os_trace to stream. These are pushed down to `go-ios ostrace`
  * rather than applied after the fact, because the unfiltered firehose cannot be
@@ -318,7 +319,9 @@ let IOSLogStreamService = class IOSLogStreamService {
             // measured against an iPhone 14, every value tried — bare name, full path,
             // altered case — returned 0 lines, while `--level` alone returned 48,195
             // and `--pid` returned 58,960 for that same process.
-            const proc = this.spawnProcess(goIOS, args);
+            // On iOS 17+ ostrace reaches the phone through the phone's own go-ios
+            // tunnel, found through GO_IOS_AGENT_PORT (see IOSTunnels).
+            const proc = this.spawnProcess(goIOS, args, typedi_1.Container.get(IOSTunnels_1.IOSTunnels).envFor(udid));
             // A ChildProcess emitting 'error' with no listener crashes the process.
             proc.on('error', (e) => logger_1.default.warn(`[${udid}] ostrace process error: ${e.message}`));
             (_b = proc.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (d) => logger_1.default.debug(`[${udid}] ostrace: ${d.toString().trim()}`));
@@ -337,8 +340,8 @@ let IOSLogStreamService = class IOSLogStreamService {
             return typedi_1.Container.get(IOSStreamService).goIOSPath;
         });
     }
-    spawnProcess(command, args) {
-        return (0, child_process_1.spawn)(command, args);
+    spawnProcess(command, args, env) {
+        return (0, child_process_1.spawn)(command, args, { env });
     }
     /**
      * Executable → bundle id for the installed apps.

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

@@ -81,6 +81,7 @@ const device_store_1 = require("../../data-service/device-store");
 const ownDeviceRow_1 = require("../ownDeviceRow");
 const iosStreamDiagnostics_1 = require("./iosStreamDiagnostics");
 const tunnelProcess_1 = require("./tunnelProcess");
+const IOSTunnels_1 = require("./IOSTunnels");
 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");
@@ -108,13 +109,6 @@ function shouldStopIdleIosStream(use) {
 function heldByAppiumSession(device) {
     return !!(device === null || device === void 0 ? void 0 : device.busy) && !!device.session_id && !(0, manualLock_1.isManualLock)(device.session_id);
 }
-/**
- * The ports go-ios's tunnel process listens on: its tunnel-info API
- * (`GO_IOS_AGENT_PORT`, default 60105) and the first phone's userspace tunnel
- * (API port + 1). On iOS 17+ every go-ios command that talks to the phone,
- * `runwda` included, goes through that process.
- */
-const GO_IOS_AGENT_PORTS = [60105, 60106];
 /** A start refused a restart because an Appium session holds the phone. */
 class StreamRestartRefused extends Error {
 }
@@ -151,6 +145,7 @@ let IOSStreamService = class IOSStreamService {
                         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 this.tunnels().touch(udid);
                     }
                     catch (_a) {
                         /* best-effort lease refresh */
@@ -270,128 +265,38 @@ let IOSStreamService = class IOSStreamService {
         });
     }
     /**
-     * Check if tunnel is needed (iOS 17+) and ensure it's running
-     */
-    ensureTunnel(udid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            try {
-                const { stdout } = yield execPromise(`"${this.goIOSPath}" info --udid ${udid}`, {
-                    env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
-                });
-                const info = JSON.parse(stdout);
-                const versionStr = String(info.ProductVersion || info.HumanReadableProductVersionString || '0');
-                // Extract the first numeric sequence (e.g., "15.8.6" or "iOS 17.2")
-                const versionMatch = versionStr.match(/(\d+\.?\d*)/);
-                const version = versionMatch ? parseFloat(versionMatch[0]) : 0;
-                if (version >= 17) {
-                    logger_1.default.info(`iOS ${version} detected for ${udid} (Raw: "${versionStr}"). Starting tunnel...`);
-                    // Check if already running in our session tracker
-                    const existing = [...this.sessions.values()].find((s) => s.udid === udid && s.tunnelProcess && s.tunnelProcess.exitCode === null);
-                    if (existing && existing.tunnelProcess)
-                        return existing.tunnelProcess;
-                    // CRITICAL: Kill any orphan tunnel processes before starting new one
-                    // This prevents 'address already in use' errors from stale processes
-                    yield this.cleanupOrphanTunnels(udid);
-                    const isolationService = typedi_2.Container.get(ResourceIsolationService_1.ResourceIsolationService);
-                    const { command, args } = isolationService.wrapSpawn(this.goIOSPath, ['tunnel', 'start', '--udid', udid, '--userspace'], 'Performance');
-                    // detached: the go-ios tunnel leads its own process group so its
-                    // self-forking agent children are reaped as a group on cleanup instead
-                    // of orphaning into a runaway respawn storm. See ./tunnelProcess.
-                    const tunnelProcess = (0, child_process_1.spawn)(command, args, (0, tunnelProcess_1.tunnelSpawnOptions)(Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' })));
-                    typedi_2.Container.get(ProcessRegistry_1.ProcessRegistry).track({ kind: 'other', udid, process: tunnelProcess });
-                    (_a = tunnelProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => logger_1.default.debug(`Tunnel [${udid}]: ${data}`));
-                    // go-ios repeatedly warns about any connected pre-iOS-17 device (which
-                    // needs no tunnel). Log that once — attributed to the real target udid,
-                    // not this tunnel's owner — and suppress the rest to avoid log spam.
-                    const loggedUnsupported = new Set();
-                    (_b = tunnelProcess.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);
-                                logger_1.default.debug(`Tunnel [${udid}]: device ${key} is pre-iOS 17 and needs no tunnel; suppressing repeated go-ios warnings`);
-                            }
-                            return;
-                        }
-                        logger_1.default.debug(`Tunnel Err [${udid}]: ${text}`);
-                    });
-                    // Wait for tunnel to establish by checking the go-ios agent port
-                    logger_1.default.info('Waiting for tunnel agent on port 60105 to be ready...');
-                    let tunnelReady = false;
-                    const tunnelTimeout = 15000;
-                    const subStartTime = Date.now();
-                    while (Date.now() - subStartTime < tunnelTimeout) {
-                        try {
-                            tunnelReady = yield tcp_port_used_1.default.check(60105, '127.0.0.1');
-                            if (tunnelReady)
-                                break;
-                        }
-                        catch (e) {
-                            /* ignore */
-                        }
-                        yield new Promise((resolve) => setTimeout(resolve, 1000));
-                    }
-                    if (!tunnelReady) {
-                        logger_1.default.warn(`Tunnel agent port 60105 not ready after ${tunnelTimeout / 1000}s, proceeding anyway...`);
-                    }
-                    else {
-                        logger_1.default.info('Tunnel agent is ready. Settling for 2s...');
-                        yield new Promise((resolve) => setTimeout(resolve, 2000));
-                        logger_1.default.info('Tunnel agent settled.');
-                    }
-                    return tunnelProcess;
-                }
-            }
-            catch (error) {
-                logger_1.default.warn(`Failed to check version or start tunnel for ${udid}: ${error}`);
-            }
-            return null;
-        });
-    }
-    /**
-     * Kill go-ios tunnel processes left over from earlier runs, so a new tunnel
-     * can bind the agent's ports ('address already in use' otherwise).
+     * Clear this phone's go-ios leftovers before a start: the tunnel IOSTunnels
+     * tracks for it, then any untracked go-ios process for it from an earlier
+     * run. Never another phone's. Each phone's tunnel has its own ports, so
+     * nothing is killed by port. Through 2.7 this also kill -9'd whatever
+     * listened on go-ios's default ports, 60105 and 60106, which was another
+     * iPhone's live tunnel.
      *
      * Never while an Appium session holds the phone. That session may be
      * driving a WDA go-ios launched (iOSCapabilities points a session at the
      * stream's WDA whenever a stream runs), and on iOS 17+ that WDA reaches the
-     * phone through the tunnel listening on these ports. Nothing here can tell
-     * that tunnel from an orphan, so the sweep waits for the next stop or start
-     * after the session ends; a restart reaps every go-ios process at boot.
+     * phone through the phone's tunnel. Nothing here can tell that tunnel from
+     * an orphan, so the sweep waits for the next stop or start after the
+     * session ends; a restart reaps every go-ios process at boot.
      */
     cleanupOrphanTunnels(udid) {
         return __awaiter(this, void 0, void 0, function* () {
             if (yield this.appiumSessionMayUse(udid, 'go-ios tunnels'))
                 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
             // agent children (whose argv carries no udid, so a udid-scoped pkill can't
             // see them) die with their parent instead of orphaning. Group-scoped, so a
             // second device's tunnel is left untouched. See ./tunnelProcess.
             yield (0, tunnelProcess_1.reapTunnelsForUdid)(udid, execPromise);
-            // Whatever still listens on the go-ios agent's ports.
-            for (const port of GO_IOS_AGENT_PORTS) {
-                try {
-                    const { stdout } = yield execPromise(`lsof -ti :${port}`);
-                    const pids = stdout.trim().split('\n');
-                    for (const pid of pids) {
-                        if (pid) {
-                            logger_1.default.debug(`Killing orphan process ${pid} on go-ios agent port ${port}`);
-                            yield execPromise(`kill -9 ${pid}`);
-                        }
-                    }
-                }
-                catch (err) {
-                    /* ignore - lsof returns 1 if no port found */
-                }
-            }
             // Small delay to ensure OS releases sockets
             yield new Promise((resolve) => setTimeout(resolve, 500));
         });
     }
+    tunnels() {
+        return typedi_2.Container.get(IOSTunnels_1.IOSTunnels);
+    }
     /**
      * Whether an Appium session may be using what the caller is about to kill:
      * one holds the phone, or the phone's row can't be read, in which case
@@ -741,7 +646,7 @@ let IOSStreamService = class IOSStreamService {
                             wdaProcess: null,
                             forwardWDAProcess: null,
                             forwardMJPEGProcess,
-                            tunnelProcess: null,
+                            tunnelPort: null,
                             wdaPort,
                             mjpegPort,
                             status: 'running',
@@ -762,7 +667,7 @@ let IOSStreamService = class IOSStreamService {
                         wdaProcess: null,
                         forwardWDAProcess: null,
                         forwardMJPEGProcess: null,
-                        tunnelProcess: null,
+                        tunnelPort: null,
                         wdaPort,
                         mjpegPort,
                         status: 'starting',
@@ -794,8 +699,8 @@ let IOSStreamService = class IOSStreamService {
                             logger_1.default.warn(`📱 Artisan WDA: Failed to provision WDA to ${udid}: ${e}`);
                         }
                     }
-                    // 2. Ensure tunnel for iOS 17+
-                    session.tunnelProcess = yield this.ensureTunnel(udid);
+                    // 2. The phone's own go-ios tunnel, for iOS 17+ (see IOSTunnels)
+                    session.tunnelPort = yield this.tunnels().ensure(udid);
                     // 2. Start Port Forwarding using iproxy (more reliable on Mac)
                     logger_1.default.info(`Forwarding ${udid}: ${wdaPort}->8100, ${mjpegPort}->9100 using iproxy`);
                     const isolationService = typedi_2.Container.get(ResourceIsolationService_1.ResourceIsolationService);
@@ -830,7 +735,9 @@ let IOSStreamService = class IOSStreamService {
                         udid,
                     ], 'Performance'); // WDA deserves Performance mode
                     session.wdaProcess = (0, child_process_1.spawn)(wdaSpawn.command, wdaSpawn.args, {
-                        env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
+                        // GO_IOS_AGENT_PORT: runwda reaches this phone through its own
+                        // tunnel, not go-ios's default 60105.
+                        env: this.tunnels().envFor(udid),
                     });
                     typedi_2.Container.get(ProcessRegistry_1.ProcessRegistry).track({ kind: 'wda', udid, process: session.wdaProcess });
                     const logDir = path_1.default.join(os_1.default.tmpdir(), 'xenon-logs');
@@ -1027,7 +934,7 @@ let IOSStreamService = class IOSStreamService {
      */
     stopStream(udid_1) {
         return __awaiter(this, arguments, void 0, function* (udid, opts = {}) {
-            var _a, _b;
+            var _a;
             const session = this.sessions.get(udid);
             if (!session)
                 return;
@@ -1036,9 +943,7 @@ let IOSStreamService = class IOSStreamService {
                 (yield this.appiumSessionMayUse(udid, "the stream's WDA and go-ios tunnel"))) {
                 return;
             }
-            // Kill sidecar processes. The go-ios tunnel is detached (its own process
-            // group), so reap the whole group — a plain p.kill() would leave the
-            // self-forking agent children behind to respawn. See ./tunnelProcess.
+            // Kill sidecar processes.
             [session.wdaProcess, session.forwardWDAProcess, session.forwardMJPEGProcess].forEach((p) => {
                 if (p)
                     try {
@@ -1048,13 +953,16 @@ let IOSStreamService = class IOSStreamService {
                         // ignore
                     }
             });
-            (0, tunnelProcess_1.killProcessGroup)((_a = session.tunnelProcess) === null || _a === void 0 ? void 0 : _a.pid);
+            // This stream's go-ios tunnel: its whole process group and its port pair.
+            // A stream attached to an Appium session's WDA started none.
+            if (session.tunnelPort != null)
+                yield this.tunnels().stop(udid);
             // Principal Fix: Only release the device lock if THIS STREAM SERVICE owns it.
             // The lock could belong to an Appium automation session (session_id is a real UUID).
             // We should only unblock if it's a manual control lock (session_id starts with 'manual_').
             try {
                 const device = yield (0, ownDeviceRow_1.findOwnDevice)(udid);
-                if (device && ((_b = device.session_id) === null || _b === void 0 ? void 0 : _b.startsWith('manual_'))) {
+                if (device && ((_a = device.session_id) === null || _a === void 0 ? void 0 : _a.startsWith('manual_'))) {
                     logger_1.default.info(`Stream Stop: Releasing manual control lock for ${udid}`);
                     yield (0, device_service_1.unblockDevice)(udid, device.host);
                 }
@@ -1185,7 +1093,7 @@ let IOSStreamService = class IOSStreamService {
      */
     reapOrphanTunnels() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b;
             try {
                 const reaped = yield (0, tunnelProcess_1.reapAllOrphanTunnels)(this.goIOSPath, execPromise);
                 if (reaped > 0) {
@@ -1195,6 +1103,14 @@ let IOSStreamService = class IOSStreamService {
             catch (err) {
                 logger_1.default.warn(`[IOSStreamService] Orphan tunnel reap failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
             }
+            // Every go-ios process is gone, so no tunnel holds its ports. A lease left
+            // by an earlier run would otherwise keep its pair for up to 1.5 hours.
+            try {
+                yield typedi_2.Container.get(PortAllocator_1.PortAllocator).releasePurpose('tunnel');
+            }
+            catch (err) {
+                logger_1.default.warn(`[IOSStreamService] Releasing tunnel port leases failed: ${(_b = err === null || err === void 0 ? void 0 : err.message) !== null && _b !== void 0 ? _b : err}`);
+            }
         });
     }
     /**