@xenon-device-management/xenon 2.16.0 → 2.17.1

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

@@ -60,9 +60,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamRestartRefused = exports.IOS_IDLE_STOP_MS = void 0;
+exports.SimulatorPreviewNeedsTest = exports.SIMULATOR_PREVIEW_NEEDS_TEST = exports.StreamRestartRefused = exports.IOS_IDLE_STOP_MS = void 0;
 exports.shouldStopIdleIosStream = shouldStopIdleIosStream;
 exports.heldByAppiumSession = heldByAppiumSession;
+exports.isIosSimulator = isIosSimulator;
+exports.simulatorPreviewRefusal = simulatorPreviewRefusal;
 const typedi_1 = require("typedi");
 const ProcessRegistry_1 = require("../../services/ProcessRegistry");
 const child_process_1 = require("child_process");
@@ -82,6 +84,7 @@ const iosStreamDiagnostics_1 = require("./iosStreamDiagnostics");
 const tunnelProcess_1 = require("./tunnelProcess");
 const IOSTunnels_1 = require("./IOSTunnels");
 const goIosBinary_1 = require("./goIosBinary");
+const appiumUmbrella_1 = require("../../sessions/appiumUmbrella");
 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");
@@ -113,9 +116,39 @@ function heldByAppiumSession(device) {
 class StreamRestartRefused extends Error {
 }
 exports.StreamRestartRefused = StreamRestartRefused;
+/** Why a simulator shows no live preview: for testers, on the device page and its tile. */
+exports.SIMULATOR_PREVIEW_NEEDS_TEST = "A simulator's screen shows here only while a test runs on it.";
+/** A simulator's preview was asked for while no test runs on it. */
+class SimulatorPreviewNeedsTest extends Error {
+    constructor() {
+        super(exports.SIMULATOR_PREVIEW_NEEDS_TEST);
+    }
+}
+exports.SimulatorPreviewNeedsTest = SimulatorPreviewNeedsTest;
+/**
+ * An iOS or tvOS simulator's row. `realDevice` is false only there among
+ * Apple rows (discovery writes it, the store reads a missing one as true); an
+ * Android emulator's is false too.
+ */
+function isIosSimulator(device) {
+    return (device === null || device === void 0 ? void 0 : device.realDevice) === false && (device.platform === 'ios' || device.platform === 'tvos');
+}
+/**
+ * Why this phone can't be previewed now, or undefined when it can: a
+ * simulator no Appium session holds.
+ */
+function simulatorPreviewRefusal(device) {
+    if (!isIosSimulator(device))
+        return undefined;
+    return heldByAppiumSession(device) ? undefined : exports.SIMULATOR_PREVIEW_NEEDS_TEST;
+}
+/** How many ended sessions a simulator preview remembers, to refuse a start mid-teardown. */
+const ENDED_SESSIONS_KEPT = 200;
 let IOSStreamService = class IOSStreamService {
     constructor() {
         this.sessions = new Map();
+        /** Sessions whose simulator previews have ended (endSimulatorPreviews), newest last. */
+        this.endedSimulatorSessions = new Set();
         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
@@ -411,6 +444,10 @@ let IOSStreamService = class IOSStreamService {
             const session = this.sessions.get(udid);
             if (!session || session.status !== 'running')
                 return false;
+            // A simulator's preview has no process of its own to check or heal: the
+            // picture is its session's, and the preview ends with it.
+            if (session.simulatorSession)
+                return true;
             // 1. Process Check: verify child processes haven't exited
             const isWdaAlive = session.wdaProcess && session.wdaProcess.exitCode === null;
             const isWdaIproxyAlive = session.forwardWDAProcess && session.forwardWDAProcess.exitCode === null;
@@ -453,6 +490,9 @@ let IOSStreamService = class IOSStreamService {
     }
     startStream(udid) {
         return __awaiter(this, void 0, void 0, function* () {
+            const device = yield (0, ownDeviceRow_1.findOwnDevice)(udid);
+            if (isIosSimulator(device))
+                return this.startSimulatorStream(udid, device);
             // Check if stream is already running - avoid unnecessary restarts
             const existingSession = this.sessions.get(udid);
             if (existingSession && existingSession.status === 'running') {
@@ -811,6 +851,82 @@ let IOSStreamService = class IOSStreamService {
             return this.startFlight.run(udid, performStartup);
         });
     }
+    /**
+     * A simulator's preview is its running test's picture. The XCUITest
+     * driver's WDA serves it on this Mac at the session's mjpegServerPort, so
+     * this starts nothing (go-ios, iproxy and runwda reach only an iPhone) and
+     * leases no port (the session's are its own). With no test running there
+     * is nothing to show: refused in plain words, with no cool-down, since a
+     * test may start any moment.
+     *
+     * Through 2.15 a simulator went through the iPhone's start. With no test it
+     * failed, and left its iproxy forwards on the ports it had leased to the
+     * simulator: a test started meanwhile was given those ports and its WDA
+     * couldn't open them. With a test it read the picture through a forward
+     * that carries nothing, so a Live devices tile stayed empty.
+     */
+    startSimulatorStream(udid, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let sessionId = simulatorPreviewRefusal(device) ? undefined : ((_a = device.session_id) !== null && _a !== void 0 ? _a : undefined);
+            // An ended test's row can still name it while its phone is being released.
+            if (sessionId && this.endedSimulatorSessions.has(sessionId))
+                sessionId = undefined;
+            // Only the ports of a session Appium has now: the row's would outlive it.
+            const driver = sessionId ? typedi_2.Container.get(appiumUmbrella_1.AppiumUmbrella).driverOptions(sessionId) : undefined;
+            const wdaPort = Number(driver === null || driver === void 0 ? void 0 : driver.wdaLocalPort);
+            const mjpegPort = Number(driver === null || driver === void 0 ? void 0 : driver.mjpegServerPort);
+            const existing = this.sessions.get(udid);
+            if (!sessionId || !wdaPort || !mjpegPort) {
+                if (existing)
+                    yield this.stopStream(udid);
+                throw new SimulatorPreviewNeedsTest();
+            }
+            if ((existing === null || existing === void 0 ? void 0 : existing.simulatorSession) === sessionId && existing.status === 'running') {
+                return { wdaPort: existing.wdaPort, mjpegPort: existing.mjpegPort };
+            }
+            // An earlier test's preview, or anything else held for this simulator.
+            if (existing)
+                yield this.stopStream(udid);
+            this.sessions.set(udid, {
+                udid,
+                wdaProcess: null,
+                forwardWDAProcess: null,
+                forwardMJPEGProcess: null,
+                tunnelPort: null,
+                wdaPort,
+                mjpegPort,
+                status: 'running',
+                startedAt: new Date(),
+                lastViewerAt: Date.now(),
+                viewerCount: 0,
+                simulatorSession: sessionId,
+            });
+            logger_1.default.info(`[${udid}] Simulator preview: the picture of session ${sessionId} (port ${mjpegPort})`);
+            return { wdaPort, mjpegPort };
+        });
+    }
+    /**
+     * End the simulator previews that show this session's picture. Called
+     * however the session ends (forgetSessionMemory): the driver's WDA may
+     * outlive it, but no test runs any more.
+     */
+    endSimulatorPreviews(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.endedSimulatorSessions.add(sessionId);
+            if (this.endedSimulatorSessions.size > ENDED_SESSIONS_KEPT) {
+                const oldest = this.endedSimulatorSessions.values().next().value;
+                if (oldest !== undefined)
+                    this.endedSimulatorSessions.delete(oldest);
+            }
+            for (const [udid, session] of this.sessions.entries()) {
+                if (session.simulatorSession !== sessionId)
+                    continue;
+                logger_1.default.info(`[${udid}] Simulator preview ends with session ${sessionId}`);
+                yield this.stopStream(udid);
+            }
+        });
+    }
     killStaleProcesses(udid, wdaPort, mjpegPort) {
         return __awaiter(this, void 0, void 0, function* () {
             logger_1.default.info(`Cleaning up stale processes for ${udid} (Ports: ${wdaPort}, ${mjpegPort})`);
@@ -879,10 +995,16 @@ let IOSStreamService = class IOSStreamService {
      */
     stopStream(udid_1) {
         return __awaiter(this, arguments, void 0, function* (udid, opts = {}) {
-            var _a;
             const session = this.sessions.get(udid);
             if (!session)
                 return;
+            // A simulator's preview started nothing and leased no port: the ports and
+            // WDA are its session's. Only the entry goes (and a manual hold, below).
+            if (session.simulatorSession) {
+                this.sessions.delete(udid);
+                yield this.releaseManualHold(udid);
+                return;
+            }
             if (opts.forViewer &&
                 session.wdaProcess &&
                 (yield this.appiumSessionMayUse(udid, "the stream's WDA and go-ios tunnel"))) {
@@ -902,22 +1024,7 @@ let IOSStreamService = class IOSStreamService {
             // 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 && ((_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);
-                }
-                else if (device && device.busy) {
-                    logger_1.default.info(`Stream Stop: Device ${udid} is busy with session ${device.session_id}. NOT releasing lock.`);
-                }
-            }
-            catch (e) {
-                logger_1.default.error(`Failed to check/release lock during stream stop for ${udid}: ${e}`);
-            }
+            yield this.releaseManualHold(udid);
             // Also clean up any orphan processes (belt and suspenders)
             yield this.cleanupOrphanTunnels(udid);
             // Release the port leases so the allocator can reuse these ports for other
@@ -933,6 +1040,28 @@ let IOSStreamService = class IOSStreamService {
             this.sessions.delete(udid);
         });
     }
+    /**
+     * Release the phone's manual hold (a preview's, a recording's), never an
+     * Appium session's claim: that session_id is a real id, not `manual_...`.
+     */
+    releaseManualHold(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const device = yield (0, ownDeviceRow_1.findOwnDevice)(udid);
+                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);
+                }
+                else if (device && device.busy) {
+                    logger_1.default.info(`Stream Stop: Device ${udid} is busy with session ${device.session_id}. NOT releasing lock.`);
+                }
+            }
+            catch (e) {
+                logger_1.default.error(`Failed to check/release lock during stream stop for ${udid}: ${e}`);
+            }
+        });
+    }
     updateWDASettings(wdaPort) {
         return __awaiter(this, void 0, void 0, function* () {
             const urls = [`http://127.0.0.1:${wdaPort}/appium/settings`];

package/lib/src/device-utils.js

@@ -45,7 +45,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDeviceTypeFromApp = void 0;
+exports.BOOT_PROBE = exports.getDeviceTypeFromApp = void 0;
 exports.isAndroid = isAndroid;
 exports.deviceType = deviceType;
 exports.isIOS = isIOS;
@@ -59,6 +59,8 @@ exports.setUtilizationTime = setUtilizationTime;
 exports.getDeviceFiltersFromCapability = getDeviceFiltersFromCapability;
 exports.getRunningSessionsCount = getRunningSessionsCount;
 exports.updateDeviceList = updateDeviceList;
+exports.syncLocalDevices = syncLocalDevices;
+exports.reportDevicesToHub = reportDevicesToHub;
 exports.refreshSimulatorState = refreshSimulatorState;
 exports.setupCronCheckStaleDevices = setupCronCheckStaleDevices;
 exports.removeStaleDevices = removeStaleDevices;
@@ -275,8 +277,17 @@ function allocateDeviceForSession(capability_1, deviceTimeOutMs_1, deviceQueryIn
         // We have a locked device here
         if (device !== null) {
             const lockedDevice = device;
-            // Principal Health Check Integration: Ensure device is READY before allocation
-            if (!lockedDevice.cloud) {
+            // Ready for a session: asked only of a phone this server drives. The
+            // check is this machine's (an iPhone's WebDriverAgent on 127.0.0.1, and a
+            // go-ios stream started to recover it). Another server's phone, a node's
+            // on a hub, is checked by that server when it allocates the phone the hub
+            // pins. Through 2.15 the hub checked it too: with the node on another
+            // machine nothing answered and the session was refused as unhealthy, and
+            // with both on one Mac the hub started a WebDriverAgent of its own on the
+            // node's iPhone.
+            const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+            const ownPhone = (0, localDeviceHosts_1.isOwnDevice)((0, localDeviceHosts_1.localDeviceHosts)(context.pluginArgs, context.port), context.nodeId, lockedDevice);
+            if (!lockedDevice.cloud && ownPhone) {
                 const platform = lockedDevice.platform.toLowerCase();
                 const managers = yield getDeviceManager().deviceInstances();
                 const manager = managers.find((m) => {
@@ -521,6 +532,19 @@ function getRunningSessionsCount() {
     });
 }
 function updateDeviceList(local, hubArgument, tlsRejectUnauthorized) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { devices, gone } = yield syncLocalDevices(local);
+        if (hubArgument) {
+            yield reportDevicesToHub(hubArgument, devices, gone, tlsRejectUnauthorized);
+        }
+        return devices;
+    });
+}
+/**
+ * This server's own phones: what discovery reports now is written to the
+ * table, and its own rows discovery no longer reports are removed (`gone`).
+ */
+function syncLocalDevices(local) {
     return __awaiter(this, void 0, void 0, function* () {
         const allExistingDevices = yield (0, device_service_1.getAllDevices)();
         const devices = yield getDeviceManager().getDevices(allExistingDevices);
@@ -538,28 +562,31 @@ function updateDeviceList(local, hubArgument, tlsRejectUnauthorized) {
             logger_1.default.info(`Removing ${staleLocalDevices.length} stale devices/simulators no longer discovered on this host.`);
             yield (0, device_service_1.removeDevice)(staleLocalDevices.map((d) => ({ udid: d.udid, host: d.host })));
         }
-        if (hubArgument) {
-            if (yield (0, helpers_1.isXenonRunning)(hubArgument, tlsRejectUnauthorized)) {
-                const nodeDevices = new NodeDevices_1.default(hubArgument, {
-                    tlsRejectUnauthorized,
-                    hubAccessKey: config_1.config.hubAccessKey,
-                    hubToken: config_1.config.hubToken,
-                });
-                try {
-                    yield nodeDevices.postDevicesToHub(devices, 'add');
-                    if (staleLocalDevices.length > 0) {
-                        yield nodeDevices.postDevicesToHub(staleLocalDevices, 'remove');
-                    }
-                }
-                catch (error) {
-                    logger_1.default.error(`Cannot send device list update. Reason: ${error}`);
+        return { devices, gone: staleLocalDevices };
+    });
+}
+/** A node tells its hub the phones it has, and the ones it no longer has. */
+function reportDevicesToHub(hubArgument, devices, gone, tlsRejectUnauthorized) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (yield (0, helpers_1.isXenonRunning)(hubArgument, tlsRejectUnauthorized)) {
+            const nodeDevices = new NodeDevices_1.default(hubArgument, {
+                tlsRejectUnauthorized,
+                hubAccessKey: config_1.config.hubAccessKey,
+                hubToken: config_1.config.hubToken,
+            });
+            try {
+                yield nodeDevices.postDevicesToHub(devices, 'add');
+                if (gone.length > 0) {
+                    yield nodeDevices.postDevicesToHub(gone, 'remove');
                 }
             }
-            else {
-                logger_1.default.warn(`Not sending device update since hub ${hubArgument} is not running`);
+            catch (error) {
+                logger_1.default.error(`Cannot send device list update. Reason: ${error}`);
             }
         }
-        return devices;
+        else {
+            logger_1.default.warn(`Not sending device update since hub ${hubArgument} is not running`);
+        }
     });
 }
 function refreshSimulatorState(pluginArgs, hostPort) {
@@ -581,11 +608,21 @@ function setupCronCheckStaleDevices(intervalMs, local, tlsRejectUnauthorized) {
         }), intervalMs);
     });
 }
+/**
+ * How a start asks another server whether it is alive: once, for at most 5 s.
+ * Appium opens its port only once every plugin's updateServer has finished,
+ * and the client's own way (four 30 s tries) held it closed for two minutes
+ * when a row named a host that drops packets. A live server answers in
+ * milliseconds; one that answers slower has its phones dropped and reports
+ * them again at its next report.
+ */
+exports.BOOT_PROBE = { timeoutMs: 5000, retry: false };
 /**
  * Remove devices where the host is not alive nor defined.
  * @param local the hosts this server files its own phones under
+ * @param probe how each host is asked (the client's own way when not given)
  */
-function removeStaleDevices(local, tlsRejectUnauthorized) {
+function removeStaleDevices(local, tlsRejectUnauthorized, probe) {
     return __awaiter(this, void 0, void 0, function* () {
         const allDevices = yield (0, device_service_1.getAllDevices)();
         const nodeId = typedi_1.Container.get(PluginContext_1.PluginContext).nodeId;
@@ -602,13 +639,13 @@ function removeStaleDevices(local, tlsRejectUnauthorized) {
         const aliveHosts = (yield Promise.allSettled(nodeHosts.map((host) => __awaiter(this, void 0, void 0, function* () {
             return {
                 host: host,
-                alive: yield (0, helpers_1.isXenonRunning)(host, tlsRejectUnauthorized),
+                alive: yield (0, helpers_1.isXenonRunning)(host, tlsRejectUnauthorized, probe),
             };
         }))));
         const aliveCloudHosts = (yield Promise.allSettled(cloudHosts.map((host) => __awaiter(this, void 0, void 0, function* () {
             return {
                 host: host,
-                alive: yield (0, helpers_1.isAppiumRunningAt)(host, tlsRejectUnauthorized),
+                alive: yield (0, helpers_1.isAppiumRunningAt)(host, tlsRejectUnauthorized, probe),
             };
         }))));
         // summarize alive hosts

package/lib/src/gateway/internalCall.js

@@ -4,8 +4,10 @@ exports.INTERNAL_CALL_MARKER = exports.INTERNAL_CALL_HEADER = void 0;
 exports.internalCallHeaders = internalCallHeaders;
 exports.hasInternalCallSecret = hasInternalCallSecret;
 exports.isInternalCall = isInternalCall;
+exports.isInsideInternalCall = isInsideInternalCall;
 exports.internalCallBaseUrl = internalCallBaseUrl;
 exports.createInternalCallLayer = createInternalCallLayer;
+const async_hooks_1 = require("async_hooks");
 const crypto_1 = require("crypto");
 const appiumBasePath_1 = require("../app/appiumBasePath");
 /**
@@ -27,11 +29,20 @@ const appiumBasePath_1 = require("../app/appiumBasePath");
  * The secret never leaves the process: it is sent only to this server's own
  * address, with any HTTP proxy bypassed, and the gateway removes the header
  * before anything after it sees the request.
+ *
+ * Such a call is never one of the test's commands. The rest of its request
+ * runs in an async context the plugin can read (`isInsideInternalCall`), since
+ * the plugin's `handle`, deep inside Appium's route, is never given the
+ * request. Through 2.16 it couldn't tell, so the dashboard recorded the call
+ * as the session's own: a performance recording's stop the driver refused at
+ * the end of an iPhone session (through 2.15, of every simulator session)
+ * failed a session whose commands had all passed.
  */
 exports.INTERNAL_CALL_HEADER = 'x-xenon-internal';
 exports.INTERNAL_CALL_MARKER = '/wd-internal';
 const SECRET = Buffer.from((0, crypto_1.randomBytes)(32).toString('base64url'));
 const INTERNAL = Symbol('xenon.internalCall');
+const internalCalls = new async_hooks_1.AsyncLocalStorage();
 /** The headers a loopback call to this process's own server carries. */
 function internalCallHeaders() {
     return { [exports.INTERNAL_CALL_HEADER]: SECRET.toString() };
@@ -48,6 +59,19 @@ function hasInternalCallSecret(headers) {
 function isInternalCall(req) {
     return !!req && req[INTERNAL] === true;
 }
+/**
+ * Whether this code runs for a request the internal-call layer accepted: the
+ * plugin's `handle` and the driver's command under it, which never see the
+ * request itself.
+ *
+ * Read it where a command enters the plugin (CommandInterceptor.handle). It
+ * also holds in whatever the driver starts during the call and runs later (a
+ * timer, a socket's callback): base-driver's new-command timer, restarted at
+ * the call's end, fires inside it, and so does an idle session's shutdown.
+ */
+function isInsideInternalCall() {
+    return internalCalls.getStore() === true;
+}
 /**
  * Where a local session's loopback calls go: this server, under its base
  * path, marked `/wd-internal`. A wildcard bind address is reached on 127.0.0.1.
@@ -80,11 +104,15 @@ function createInternalCallLayer(basePath) {
         req.originalUrl = req.url;
         return true;
     }
-    // One call to next() for every outcome: Appium's 404 carries a stack trace,
-    // and a second call site would make a refused /wd-internal request's answer
-    // differ from any other unknown route's by that one frame.
+    // Every request this layer leaves alone goes on through the one call to
+    // next() below: Appium's 404 carries a stack trace, and a second call site
+    // would make a refused /wd-internal request's answer differ from any other
+    // unknown route's by that one frame. An accepted call goes on inside its
+    // context, down to the plugin's handle (isInsideInternalCall).
     return function xenonInternalCalls(req, _res, next) {
-        accept(req);
-        next();
+        if (accept(req))
+            internalCalls.run(true, next);
+        else
+            next();
     };
 }

package/lib/src/gateway/nodeAsk.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OlderNodes = exports.OLDER_NODE_RECHECK_MS = void 0;
+exports.readNodeReply = readNodeReply;
+/**
+ * The node's answer at a route whose answers carry `header`. `answerOf` reads
+ * a 200's `value`, or returns null when it isn't one.
+ */
+function readNodeReply(header, status, headers, data, answerOf) {
+    if (!(headers === null || headers === void 0 ? void 0 : headers[header])) {
+        // An older node answers its login's 401, an unknown route's 404, or a
+        // catch-all's 2xx. Anything else without the header (a proxy's 502 in
+        // front of a node) is an outage: ask again, never give the node up.
+        if (status === 401 || status === 404 || (status >= 200 && status < 300)) {
+            return { kind: 'unsupported', status };
+        }
+        return { kind: 'unavailable', reason: `answered ${status}` };
+    }
+    if (status === 404)
+        return { kind: 'refused' };
+    const answer = status === 200 ? answerOf(data === null || data === void 0 ? void 0 : data.value) : null;
+    if (answer !== null)
+        return { kind: 'answer', answer };
+    return { kind: 'unavailable', reason: `answered ${status}` };
+}
+/** How long a hub leaves a node without a route alone before asking it again. */
+exports.OLDER_NODE_RECHECK_MS = 10 * 60000;
+/**
+ * Hub side: which nodes lack a route (an older Xenon). Their sessions go
+ * without what the route serves; the hub says so once per node, and asks
+ * again after OLDER_NODE_RECHECK_MS, so a node upgraded in place is picked
+ * up without restarting the hub.
+ */
+class OlderNodes {
+    constructor() {
+        this.now = () => Date.now();
+        this.unsupportedUntil = new Map();
+        this.warned = new Set();
+    }
+    shouldAsk(origin) {
+        const until = this.unsupportedUntil.get(origin);
+        if (until === undefined)
+            return true;
+        if (until > this.now())
+            return false;
+        this.unsupportedUntil.delete(origin);
+        return true;
+    }
+    unsupported(origin, status) {
+        this.unsupportedUntil.set(origin, this.now() + exports.OLDER_NODE_RECHECK_MS);
+        if (this.warned.has(origin))
+            return;
+        this.warned.add(origin);
+        this.logger.warn(this.warning(origin, status));
+    }
+}
+exports.OlderNodes = OlderNodes;

package/lib/src/gateway/nodeSessionDeviceLogs.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeSessionDeviceLogsHandler = nodeSessionDeviceLogsHandler;
+exports.registerNodeSessionDeviceLogs = registerNodeSessionDeviceLogs;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const config_1 = require("../config");
+const commandAuth_1 = require("../middleware/commandAuth");
+const nodeDeviceLogs_1 = require("../services/logcat/nodeDeviceLogs");
+const NodeDeviceLogStore_1 = require("../services/logcat/NodeDeviceLogStore");
+const hubSessionToken_1 = require("./hubSessionToken");
+const nodeSessionMetrics_1 = require("./nodeSessionMetrics");
+const nodeSessionStatus_1 = require("./nodeSessionStatus");
+function nodeSessionDeviceLogsHandler(deps) {
+    return (req, res) => {
+        var _a, _b;
+        res.setHeader(nodeDeviceLogs_1.NODE_DEVICE_LOGS_HEADER, '1');
+        const sessionId = String((_b = (_a = req.params) === null || _a === void 0 ? void 0 : _a.sessionId) !== null && _b !== void 0 ? _b : '');
+        (0, nodeSessionStatus_1.answerForHub)(deps, req, res, sessionId, 'Session device logs', () => { var _a; return res.status(200).json({ value: deps.read(sessionId, (0, nodeSessionMetrics_1.parseAfter)((_a = req.query) === null || _a === void 0 ? void 0 : _a.after)) }); });
+    };
+}
+/** A node's route, ahead of its login, like the session-status route. A hub or standalone server has none. */
+function registerNodeSessionDeviceLogs(router, pluginArgs) {
+    if (pluginArgs.hub === undefined)
+        return;
+    router.get(nodeDeviceLogs_1.NODE_DEVICE_LOGS_ROUTE, nodeSessionDeviceLogsHandler({
+        hubTokens: new hubSessionToken_1.HubSessionTokenVerifier(pluginArgs.hub),
+        enforced: () => (0, commandAuth_1.commandAuthEnabled)() && config_1.config.authDisabled !== true,
+        read: (sessionId, after) => typedi_1.Container.get(NodeDeviceLogStore_1.NodeDeviceLogStore).read(sessionId, after),
+        logger: logger_1.default.scope('NodeSessionDeviceLogs'),
+    }));
+}

package/lib/src/gateway/sessionGateway.js

@@ -168,10 +168,15 @@ function createHubRouting(deps) {
                     yield deleteRemote(req, res, sessionId, location);
                     return;
                 }
-                yield deps
-                    .touch(sessionId)
-                    .catch((error) => logger.warn(`Could not record activity for session ${sessionId}: ${(0, commandAuth_1.summarize)(error)}`));
-                const hooks = location.session && !location.cloud ? deps.dashboard : undefined;
+                // Xenon's own call (internalCall.ts) is never one of the test's
+                // commands: it isn't the session's activity, nor in its record.
+                const own = (0, internalCall_1.isInternalCall)(req);
+                if (!own) {
+                    yield deps
+                        .touch(sessionId)
+                        .catch((error) => logger.warn(`Could not record activity for session ${sessionId}: ${(0, commandAuth_1.summarize)(error)}`));
+                }
+                const hooks = location.session && !location.cloud && !own ? deps.dashboard : undefined;
                 const command = hooks
                     ? deps.commandName(`${deps.basePath}/session/${sessionId}${rest.split('?')[0]}`, req.method)
                     : undefined;

package/lib/src/helpers/index.js

@@ -176,15 +176,18 @@ function stripAppiumPrefixes(caps) {
     }
     return strippedCaps;
 }
-function isXenonRunning(host, tlsRejectUnauthorized) {
-    return __awaiter(this, void 0, void 0, function* () {
+function probeConfig(probe) {
+    return Object.assign(Object.assign({}, (probe.timeoutMs !== undefined ? { timeout: probe.timeoutMs } : {})), (probe.retry === false ? { retry: false } : {}));
+}
+function isXenonRunning(host_1, tlsRejectUnauthorized_1) {
+    return __awaiter(this, arguments, void 0, function* (host, tlsRejectUnauthorized, probe = {}) {
         try {
             const client = InternalHttpClient_1.InternalHttpClient.getClient(tlsRejectUnauthorized);
             // /health is the one /xenon/api route with no login. The hub probes its
             // nodes, and a node its hub, without credentials, so a login-only route
             // (/status) called a server with auth on dead: the hub pruned its node's
             // phones, and the node never registered with its hub.
-            yield client.get(`${host}/xenon/api/health`);
+            yield client.get(`${host}/xenon/api/health`, probeConfig(probe));
             return true;
         }
         catch (error) {
@@ -193,11 +196,11 @@ function isXenonRunning(host, tlsRejectUnauthorized) {
         }
     });
 }
-function isAppiumRunningAt(url, tlsRejectUnauthorized) {
-    return __awaiter(this, void 0, void 0, function* () {
+function isAppiumRunningAt(url_1, tlsRejectUnauthorized_1) {
+    return __awaiter(this, arguments, void 0, function* (url, tlsRejectUnauthorized, probe = {}) {
         try {
             const client = InternalHttpClient_1.InternalHttpClient.getClient(tlsRejectUnauthorized);
-            yield client.get(`${url}/status`);
+            yield client.get(`${url}/status`, probeConfig(probe));
             return true;
         }
         catch (error) {

package/lib/src/interceptors/CommandInterceptor.js

@@ -70,6 +70,7 @@ const waitFor_1 = require("../services/autowait/waitFor");
 const SelfHealingSwitch_1 = require("../services/settings/SelfHealingSwitch");
 const xenonScripts_1 = require("./xenonScripts");
 const healReport_1 = require("../gateway/healReport");
+const internalCall_1 = require("../gateway/internalCall");
 const W3C_ELEMENT_KEY = 'element-6066-11e4-a52e-4f735466cecf';
 /**
  * The commands the interceptor answers itself for an element Xenon found in a
@@ -116,6 +117,15 @@ let CommandInterceptor = class CommandInterceptor {
             const IGNORED_COMMANDS = ['getScreenshot', 'stopRecordingScreen', 'startRecordingScreen'];
             if (IGNORED_COMMANDS.includes(commandName))
                 return yield next();
+            // Xenon's own call to the session (a LocalSession's loopback, when its
+            // in-process call failed; gateway/internalCall.ts) goes straight to the
+            // driver. It isn't one of the test's commands: it isn't recorded with
+            // them, so it can't decide the session's status, and it doesn't reset
+            // Xenon's idle clock. Through 2.16 a performance recording's stop the
+            // driver refused at the end was recorded as a failed `execute`, and the
+            // session ended failed.
+            if ((0, internalCall_1.isInsideInternalCall)())
+                return yield next();
             const sessionId = driver.sessionId || args[args.length - 1];
             const tracingService = typedi_1.Container.get(TracingService_1.TracingService);
             const spanId = `${sessionId}:${commandName}`;

package/lib/src/plugin.js

@@ -68,6 +68,7 @@ const appiumUmbrella_1 = require("./sessions/appiumUmbrella");
 const LiveSessionOwners_1 = require("./services/device-access/LiveSessionOwners");
 const sessionMemory_1 = require("./sessions/sessionMemory");
 const SessionMetricsService_1 = require("./services/metrics/SessionMetricsService");
+const SessionDeviceLogs_1 = require("./services/logcat/SessionDeviceLogs");
 const PhoneNetworkRestore_1 = require("./services/network/PhoneNetworkRestore");
 const config_1 = require("./config");
 const SessionManager_1 = require("./sessions/SessionManager");
@@ -120,8 +121,10 @@ class XenonPlugin extends base_plugin_1.default {
                     reason: (0, shutdownReason_1.unexpectedShutdownReason)(cause),
                 });
             }
-            if (sessionId)
+            if (sessionId) {
                 yield typedi_1.Container.get(SessionMetricsService_1.SessionMetricsService).stop(sessionId);
+                yield typedi_1.Container.get(SessionDeviceLogs_1.SessionDeviceLogs).stop(sessionId);
+            }
             // Appium's new-command timeout ends a session here, not in deleteSession:
             // the phone's network (profile, interceptor proxy) and the capture are
             // put back before the phone is released.