@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/src/services/logcat/deviceLogBook.js

@@ -91,13 +91,14 @@ const keyOf = (r) => `${r.pid} ${r.tid} ${r.level} ${r.tag} ${r.message}`;
 const isError = (r) => r.level === 'E' || r.level === 'F';
 class DeviceLogBook {
     constructor(opts) {
-        var _a, _b;
+        var _a, _b, _c;
         this.kept = 0;
         this.leftOut = 0;
         this.limitNoted = false;
         this.clock = opts.clock;
-        this.lineLimit = (_a = opts.lineLimit) !== null && _a !== void 0 ? _a : exports.DEVICE_LOG_LINE_LIMIT;
-        this.errorLimit = (_b = opts.errorLimit) !== null && _b !== void 0 ? _b : exports.DEVICE_LOG_ERROR_LIMIT;
+        this.format = (_a = opts.format) !== null && _a !== void 0 ? _a : formatThreadtime;
+        this.lineLimit = (_b = opts.lineLimit) !== null && _b !== void 0 ? _b : exports.DEVICE_LOG_LINE_LIMIT;
+        this.errorLimit = (_c = opts.errorLimit) !== null && _c !== void 0 ? _c : exports.DEVICE_LOG_ERROR_LIMIT;
         // A record at `ts` was logged at ts + zoneShift + skew by this server's
         // clock (timeOf); it counts from WINDOW_SLACK_MS before `since`.
         const first = opts.since - exports.WINDOW_SLACK_MS - this.clock.zoneShiftMs - this.clock.skewMs;
@@ -126,7 +127,7 @@ class DeviceLogBook {
         const room = this.kept < this.lineLimit || (isError(rec) && this.kept < this.lineLimit + this.errorLimit);
         if (room) {
             this.kept += 1;
-            out.push({ message: formatThreadtime(rec), timestamp: this.timeOf(rec) });
+            out.push({ message: this.format(rec), timestamp: this.timeOf(rec) });
         }
         else {
             this.leftOut += 1;

package/lib/src/services/logcat/iosDriverLog.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IosAppLines = exports.iosLineText = void 0;
+exports.iosLineLevel = iosLineLevel;
+exports.recordFromDriverLog = recordFromDriverLog;
+exports.bufferedDriverLog = bufferedDriverLog;
+exports.isDriverLog = isDriverLog;
+// A real iPhone's syslog line: "Oct  5 20:31:40 iPhone SpringBoard(FrontBoard)[57] <Notice>: …".
+const SYSLOG_LEVEL = /<(Fault|Error|Warning|Notice|Default|Info|Debug)>:/;
+// A simulator's compact line: "2026-10-05 20:31:40.123 E  SpringBoard[1234:5678] …".
+const COMPACT_LEVEL = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+\s+(Df|Db|E|F|I|A)\s/;
+const SYSLOG_LETTERS = {
+    Fault: 'F',
+    Error: 'E',
+    Warning: 'W',
+    Notice: 'I',
+    Default: 'I',
+    Info: 'I',
+    Debug: 'D',
+};
+const COMPACT_LETTERS = {
+    F: 'F',
+    E: 'E',
+    Df: 'I',
+    I: 'I',
+    A: 'I',
+    Db: 'D',
+};
+/** The level an iOS log line carries, as a logcat letter; `I` when it carries none. */
+function iosLineLevel(message) {
+    var _a, _b;
+    const syslog = (_a = SYSLOG_LEVEL.exec(message)) === null || _a === void 0 ? void 0 : _a[1];
+    if (syslog)
+        return SYSLOG_LETTERS[syslog];
+    const compact = (_b = COMPACT_LEVEL.exec(message)) === null || _b === void 0 ? void 0 : _b[1];
+    if (compact)
+        return COMPACT_LETTERS[compact];
+    return 'I';
+}
+// What `log stream` prints before its first line: not the device's.
+const STREAM_BANNER = /^(Filtering the log data using |Timestamp\s+Ty\s+Process)/;
+/**
+ * A driver entry as a record for the session's book, or null for what isn't
+ * a device line. A line without a level of its own (a message's continuation)
+ * is kept, as `I`.
+ */
+function recordFromDriverLog(entry) {
+    if (!entry || typeof entry.message !== 'string')
+        return null;
+    const message = entry.message.replace(/\s+$/, '');
+    if (!message || STREAM_BANNER.test(message))
+        return null;
+    const ts = Number(entry.timestamp);
+    return {
+        ts: Number.isFinite(ts) ? ts : Date.now(),
+        pid: 0,
+        tid: 0,
+        level: iosLineLevel(message),
+        tag: '',
+        message,
+    };
+}
+/** An iOS record's row text: the line as the phone or simulator printed it. */
+const iosLineText = (rec) => rec.message;
+exports.iosLineText = iosLineText;
+/**
+ * The lines the driver's log already holds, oldest first, without taking
+ * them: the ones from the create, before Xenon could listen. Reads the
+ * driver's internals (`logs`, an LRU cache keyed by arrival, and
+ * `_deserializeEntry`, as its own `getLogs()` does), so any other shape gives
+ * nothing rather than an error.
+ */
+function bufferedDriverLog(driverLog) {
+    var _a;
+    const log = driverLog;
+    if (typeof ((_a = log === null || log === void 0 ? void 0 : log.logs) === null || _a === void 0 ? void 0 : _a.rvalues) !== 'function' || typeof log._deserializeEntry !== 'function') {
+        return [];
+    }
+    try {
+        const out = [];
+        for (const value of log.logs.rvalues())
+            out.push(log._deserializeEntry(value));
+        return out;
+    }
+    catch (_b) {
+        return [];
+    }
+}
+/** Whether `value` can be listened to as a driver log. */
+function isDriverLog(value) {
+    const v = value;
+    return typeof (v === null || v === void 0 ? void 0 : v.on) === 'function' && typeof (v === null || v === void 0 ? void 0 : v.removeListener) === 'function';
+}
+// A line's process, the library that logged it and its pid: an iPhone's
+// "… Rabindras-iPhone Edge(UIKitCore)[8788] <Notice>: …" or a simulator's
+// "2026-10-05 20:31:40.123 Df Shop[4127:8812] (UIKitCore) …".
+const SYSLOG_HEADER = /^\w{3}\s+\d+ \d\d:\d\d:\d\d \S+ ([^\s[(]+)(?:\(([^)]*)\))?\[(\d+)\]/;
+const COMPACT_HEADER = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d+\s+\S+\s+([^\s[]+)\[(\d+)(?::\d+)?\](?:\s+\(([^)]*)\))?/;
+function headerOf(message) {
+    const syslog = SYSLOG_HEADER.exec(message);
+    if (syslog)
+        return { name: syslog[1], sender: syslog[2] || undefined, pid: syslog[3] };
+    const compact = COMPACT_HEADER.exec(message);
+    if (compact)
+        return { name: compact[1], sender: compact[3] || undefined, pid: compact[2] };
+    return null;
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Which of an iPhone's or simulator's lines a session keeps: what the app
+ * under test's own code logs, every error and fault inside its process, what
+ * the phone's app manager says about it (its launch, its state, how it
+ * ended), the crash reports and memory kills that name it, and every fault.
+ *
+ * A phone logs hundreds of lines a second. Measured on an iPhone 14 Plus
+ * (iOS 26.5): about 53,000 in a one-minute session, which filled the
+ * 10,000-line limit during the create. Keeping the app's whole process wasn't
+ * enough either: Edge's process logged about 110 lines a second, of which
+ * its own code wrote 5 in 8,839. The rest was Apple's frameworks inside it
+ * (UIKit, Network, CFNetwork, WebKit), so their ordinary lines are left out
+ * and their errors kept. Only `runningboardd` and `SpringBoard` are kept for
+ * naming the app: about twenty other daemons each log every change of its
+ * state ("Received state update for 8723 (app<…"), 3,000 lines in 78 s.
+ *
+ * The app's process is learnt from the lines: the phone announces it by
+ * bundle id and pid (`app<com.example.shop(…)>:4127`, `pid: 4127 bundleID:
+ * com.example.shop`), and the lines of that pid give its executable's name,
+ * so a crash report or a memory kill that names it (`Shop[4127]`, `[Shop]`,
+ * `corpse[4127]`) is kept too. A line with no header of its own continues
+ * the one before.
+ */
+// The processes whose lines about the app say how it lives and ends: its
+// launch, assertions and exit with its reason (RunningBoard), its scenes and
+// windows (SpringBoard).
+const APP_MANAGERS = new Set(['runningboardd', 'SpringBoard']);
+class IosAppLines {
+    constructor(bundleId) {
+        this.bundleId = bundleId;
+        this.pids = new Set();
+        this.names = new Set();
+        this.lastKept = false;
+        const id = escapeRegExp(bundleId);
+        this.pidAnnounced = [
+            new RegExp(`app<${id}[^>]*>:(\\d+)`, 'g'),
+            new RegExp(`pid:? (\\d+),? bundleID:? ${id}\\b`, 'g'),
+        ];
+    }
+    /** Learns the app's pid and executable from a line, without deciding on it. */
+    learn(message) {
+        if (message.includes(this.bundleId)) {
+            for (const re of this.pidAnnounced) {
+                for (const m of message.matchAll(re))
+                    this.pids.add(m[1]);
+            }
+        }
+        const header = headerOf(message);
+        if (header && this.pids.has(header.pid))
+            this.names.add(header.name);
+    }
+    /** Whether the session keeps the line. */
+    keeps(message, level) {
+        this.learn(message);
+        const header = headerOf(message);
+        if (!header)
+            return this.lastKept;
+        const { name, sender, pid } = header;
+        const inApp = this.pids.has(pid) || this.names.has(name);
+        const keep = level === 'F' ||
+            (inApp && (level === 'E' || !sender || this.names.has(sender))) ||
+            (APP_MANAGERS.has(name) && message.includes(this.bundleId)) ||
+            (!inApp &&
+                ([...this.names].some((n) => message.includes(`${n}[`) || message.includes(`[${n}]`)) ||
+                    [...this.pids].some((p) => message.includes(`[${p}]`))));
+        this.lastKept = keep;
+        return keep;
+    }
+}
+exports.IosAppLines = IosAppLines;

package/lib/src/services/logcat/nodeDeviceLogs.js

@@ -0,0 +1,91 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeDeviceLogsSupport = exports.UNCLAIMED_MS = exports.NODE_DEVICE_LOGS_KEEP_AFTER_END_MS = exports.NODE_DEVICE_LOG_PAGE = exports.NODE_DEVICE_LOGS_HEADER = exports.NODE_DEVICE_LOGS_ROUTE = void 0;
+exports.readNodeDeviceLogsReply = readNodeDeviceLogsReply;
+exports.nodeDeviceLogsSourceOf = nodeDeviceLogsSourceOf;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const SessionType_1 = __importDefault(require("../../enums/SessionType"));
+const nodeAsk_1 = require("../../gateway/nodeAsk");
+/** Where a node serves a session's device log lines, under `/xenon/api`. */
+exports.NODE_DEVICE_LOGS_ROUTE = '/node/sessions/:sessionId/device-logs';
+/** On every answer of that route, so a hub can tell a node that has it. */
+exports.NODE_DEVICE_LOGS_HEADER = 'x-xenon-node-device-logs';
+/** Lines in one answer. */
+exports.NODE_DEVICE_LOG_PAGE = 2000;
+/** How long a node keeps an ended session's lines for its hub's last ask. */
+exports.NODE_DEVICE_LOGS_KEEP_AFTER_END_MS = 10 * 60000;
+/**
+ * A node stops recording a session no hub has asked about this long after
+ * it started: its hub doesn't collect (its dashboard is off, the default) or
+ * is older. A hub that collects asks as soon as the session is created.
+ */
+exports.UNCLAIMED_MS = 2 * 60000;
+const STATES = ['recording', 'ended', 'off'];
+/**
+ * The line, field by field, or null when it isn't one: one malformed row
+ * would fail every later write of the session's lines (a failed batch goes
+ * back to the front of the buffer).
+ */
+function lineOf(v) {
+    if (!v || typeof v !== 'object')
+        return null;
+    if (!Number.isSafeInteger(v.seq) || v.seq < 1)
+        return null;
+    if (typeof v.message !== 'string')
+        return null;
+    if (typeof v.timestamp !== 'number' || !Number.isFinite(v.timestamp))
+        return null;
+    return { seq: v.seq, message: v.message, timestamp: v.timestamp };
+}
+function deviceLogsAnswerOf(value) {
+    if (!value || !STATES.includes(value.state) || !Array.isArray(value.lines))
+        return null;
+    return {
+        state: value.state,
+        lines: value.lines.map(lineOf).filter((x) => !!x),
+        more: value.more === true,
+    };
+}
+function readNodeDeviceLogsReply(status, headers, data) {
+    return (0, nodeAsk_1.readNodeReply)(exports.NODE_DEVICE_LOGS_HEADER, status, headers, data, deviceLogsAnswerOf);
+}
+/**
+ * The session as a NodeDeviceLogsSource, when it runs on a node. A cloud
+ * provider's session (CloudSession) and this server's own (LocalSession)
+ * inherit the methods from RemoteSession, so the type decides.
+ */
+function nodeDeviceLogsSourceOf(session) {
+    var _a;
+    const s = session;
+    return s &&
+        ((_a = s.getType) === null || _a === void 0 ? void 0 : _a.call(s)) === SessionType_1.default.REMOTE &&
+        typeof s.nodeDeviceLogs === 'function' &&
+        typeof s.nodeOrigin === 'function'
+        ? s
+        : undefined;
+}
+/** Hub side: which nodes lack the route (an older Xenon). Their sessions have no Device logs. */
+let NodeDeviceLogsSupport = class NodeDeviceLogsSupport extends nodeAsk_1.OlderNodes {
+    constructor() {
+        super(...arguments);
+        this.logger = logger_1.default.scope('DeviceLogs');
+    }
+    warning(origin, status) {
+        return (`Node ${origin} has no session device log route (answered ${status}): an older Xenon. ` +
+            'Its sessions have no device logs here. Upgrade the node.');
+    }
+};
+exports.NodeDeviceLogsSupport = NodeDeviceLogsSupport;
+exports.NodeDeviceLogsSupport = NodeDeviceLogsSupport = __decorate([
+    (0, typedi_1.Service)()
+], NodeDeviceLogsSupport);

package/lib/src/services/metrics/nodeMetrics.js

@@ -9,12 +9,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeMetricsSupport = exports.NODE_METRICS_RECHECK_MS = exports.KEEP_AFTER_END_MS = exports.NODE_METRICS_HEADER = exports.NODE_METRICS_ROUTE = void 0;
+exports.NodeMetricsSupport = exports.KEEP_AFTER_END_MS = exports.NODE_METRICS_HEADER = exports.NODE_METRICS_ROUTE = void 0;
 exports.readNodeMetricsReply = readNodeMetricsReply;
 exports.nodeMetricsSourceOf = nodeMetricsSourceOf;
 const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../../logger"));
 const SessionType_1 = __importDefault(require("../../enums/SessionType"));
+const nodeAsk_1 = require("../../gateway/nodeAsk");
 /** Where a node serves a session's figures, under `/xenon/api`. */
 exports.NODE_METRICS_ROUTE = '/node/sessions/:sessionId/metrics';
 /** On every answer of that route, so a hub can tell a node that has it. */
@@ -41,33 +42,20 @@ function sampleOf(v) {
         return null;
     return { at: v.at, deviceCpuPct, deviceMemMb, deviceMemTotalMb, appCpuPct, appMemMb, appId };
 }
-function readNodeMetricsReply(status, headers, data) {
+function metricsAnswerOf(value) {
     var _a;
-    if (!(headers === null || headers === void 0 ? void 0 : headers[exports.NODE_METRICS_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 value = data === null || data === void 0 ? void 0 : data.value;
-    if (status === 200 && value && STATES.includes(value.state) && Array.isArray(value.samples)) {
-        return {
-            kind: 'answer',
-            answer: {
-                platform: String((_a = value.platform) !== null && _a !== void 0 ? _a : ''),
-                state: value.state,
-                samples: value.samples
-                    .map(sampleOf)
-                    .filter((x) => x !== null),
-            },
-        };
-    }
-    return { kind: 'unavailable', reason: `answered ${status}` };
+    if (!value || !STATES.includes(value.state) || !Array.isArray(value.samples))
+        return null;
+    return {
+        platform: String((_a = value.platform) !== null && _a !== void 0 ? _a : ''),
+        state: value.state,
+        samples: value.samples
+            .map(sampleOf)
+            .filter((x) => x !== null),
+    };
+}
+function readNodeMetricsReply(status, headers, data) {
+    return (0, nodeAsk_1.readNodeReply)(exports.NODE_METRICS_HEADER, status, headers, data, metricsAnswerOf);
 }
 /**
  * The session as a NodeMetricsSource, when it runs on a node. A cloud
@@ -84,35 +72,18 @@ function nodeMetricsSourceOf(session) {
         ? s
         : undefined;
 }
-/** How long the hub leaves a node without the route alone before asking it again. */
-exports.NODE_METRICS_RECHECK_MS = 10 * 60000;
 /**
  * Hub side: which nodes lack the route (an older Xenon). Their sessions show
  * no figures; the hub says so once per node, and asks again after
- * NODE_METRICS_RECHECK_MS, so a node upgraded in place is picked up.
+ * OLDER_NODE_RECHECK_MS, so a node upgraded in place is picked up.
  */
-let NodeMetricsSupport = class NodeMetricsSupport {
+let NodeMetricsSupport = class NodeMetricsSupport extends nodeAsk_1.OlderNodes {
     constructor() {
+        super(...arguments);
         this.logger = logger_1.default.scope('NodeMetrics');
-        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.NODE_METRICS_RECHECK_MS);
-        if (this.warned.has(origin))
-            return;
-        this.warned.add(origin);
-        this.logger.warn(`Node ${origin} has no session metrics route (answered ${status}): an older Xenon. ` +
+    warning(origin, status) {
+        return (`Node ${origin} has no session metrics route (answered ${status}): an older Xenon. ` +
             'Its sessions show no CPU or memory. Upgrade the node.');
     }
 };

package/lib/src/services/selector-health/SelectorVisibilityResolver.js

@@ -0,0 +1,121 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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.SelectorVisibilityResolver = exports.SELECTOR_VISIBILITY_LOOKUP_TIMEOUT_MS = exports.SELECTOR_VISIBILITY_TTL_MS = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const sessionVisibility_1 = require("../device-access/sessionVisibility");
+const access_1 = require("./access");
+/**
+ * How long an answer is reused. A selector event is rare, but a verification
+ * run can send several at once, each to every dashboard connected.
+ */
+exports.SELECTOR_VISIBILITY_TTL_MS = 5000;
+/** A lookup that takes longer answers no for that event, and isn't cached. */
+exports.SELECTOR_VISIBILITY_LOOKUP_TIMEOUT_MS = 2000;
+const MAX_ENTRIES = 10000;
+/**
+ * Whether a dashboard caller may see a selector, for the `selector_*` live
+ * events: Selector Health's own rule (`access.ts`), a selector healed in at
+ * least one session the caller may see. Admins see every selector and are
+ * never asked about.
+ *
+ * Answers are cached for {@link SELECTOR_VISIBILITY_TTL_MS} per viewer (user
+ * and teams, so a member's tabs share one) and selector, and a viewer's
+ * sessions are read once for all their selectors. Concurrent questions share
+ * one lookup. A lookup that fails, or outlasts
+ * {@link SELECTOR_VISIBILITY_LOOKUP_TIMEOUT_MS}, answers no and isn't cached.
+ */
+let SelectorVisibilityResolver = class SelectorVisibilityResolver {
+    // An interface-typed parameter emits `Object`, which TypeDI leaves alone; a
+    // function-typed one would make Container.get throw.
+    constructor(deps = {}) {
+        this.deps = deps;
+        this.scopes = new Map();
+        this.answers = new Map();
+    }
+    /** Never rejects. */
+    canSee(key, viewer) {
+        var _a;
+        const who = JSON.stringify([(_a = viewer.userId) !== null && _a !== void 0 ? _a : null, Array.from(new Set(viewer.teamIds)).sort()]);
+        const answer = this.cached(this.answers, JSON.stringify([who, key.strategy, key.selector]), () => __awaiter(this, void 0, void 0, function* () {
+            const scope = yield this.cached(this.scopes, who, () => this.sessionScope(viewer));
+            return this.healedIn(key, scope);
+        }));
+        return answer.catch((err) => {
+            var _a;
+            logger_1.default.warn(`[SelectorVisibility] could not tell who may see ${key.strategy}=${key.selector}: ` +
+                `${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}; its event went to admins only`);
+            return false;
+        });
+    }
+    cached(map, key, load) {
+        const entry = map.get(key);
+        if (entry &&
+            (entry.settledAt === undefined || this.now() - entry.settledAt < exports.SELECTOR_VISIBILITY_TTL_MS)) {
+            return entry.value;
+        }
+        const fresh = { value: Promise.resolve(undefined) };
+        fresh.value = this.bounded(load).then((value) => {
+            fresh.settledAt = this.now();
+            return value;
+        }, (err) => {
+            if (map.get(key) === fresh)
+                map.delete(key);
+            throw err;
+        });
+        if (map.size >= MAX_ENTRIES && !map.has(key))
+            map.clear();
+        map.set(key, fresh);
+        return fresh.value;
+    }
+    bounded(load) {
+        var _a;
+        const timeoutMs = (_a = this.deps.lookupTimeoutMs) !== null && _a !== void 0 ? _a : exports.SELECTOR_VISIBILITY_LOOKUP_TIMEOUT_MS;
+        let timer;
+        const timedOut = new Promise((_, reject) => {
+            var _a;
+            timer = setTimeout(() => reject(new Error(`took over ${timeoutMs} ms`)), timeoutMs);
+            (_a = timer.unref) === null || _a === void 0 ? void 0 : _a.call(timer);
+        });
+        const lookup = new Promise((resolve) => resolve(load()));
+        return Promise.race([lookup, timedOut]).finally(() => clearTimeout(timer));
+    }
+    sessionScope(viewer) {
+        if (this.deps.sessionScope)
+            return this.deps.sessionScope(viewer);
+        return (0, sessionVisibility_1.visibleSessionWhere)(viewer);
+    }
+    healedIn(key, scope) {
+        var _a;
+        return ((_a = this.deps.healedIn) !== null && _a !== void 0 ? _a : access_1.canSeeSelector)(key, scope);
+    }
+    now() {
+        return this.deps.now ? this.deps.now() : Date.now();
+    }
+};
+exports.SelectorVisibilityResolver = SelectorVisibilityResolver;
+exports.SelectorVisibilityResolver = SelectorVisibilityResolver = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [Object])
+], SelectorVisibilityResolver);

package/lib/src/services/token/JwtKeyService.js

@@ -51,7 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtKeyService = void 0;
+exports.JwtKeyService = exports.JWT_CLOCK_TOLERANCE_SEC = void 0;
 const typedi_1 = require("typedi");
 const jose = __importStar(require("jose"));
 const crypto_1 = require("crypto");
@@ -59,6 +59,12 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const KEY_FILE = 'xenon-jwt-private.pem';
 const ISSUER = process.env.XENON_JWT_ISSUER || 'xenon-hub';
+/**
+ * How long past `exp` verify() still takes a token (spec §7.1: ±60 s skew,
+ * mirrors appium-mcp-auth). A dashboard socket on a bearer token closes then,
+ * when REST stops taking it (SocketServer).
+ */
+exports.JWT_CLOCK_TOLERANCE_SEC = 60;
 /**
  * RS256 signing key for hub-issued JWTs (REST/MCP tokens, stream tickets).
  * Key material lives on disk (0600), never in the database. `kid` is derived
@@ -119,7 +125,7 @@ let JwtKeyService = class JwtKeyService {
             const { payload } = yield jose.jwtVerify(token, this.publicKey, {
                 issuer: ISSUER,
                 audience: opts.audience,
-                clockTolerance: 60, // spec §7.1: ±60 s skew, mirrors appium-mcp-auth
+                clockTolerance: exports.JWT_CLOCK_TOLERANCE_SEC,
             });
             return payload;
         });

package/lib/src/services/token/mcpTokenTtl.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MCP_TOKEN_TTL_SEC = void 0;
+exports.mcpTokenTtlSec = mcpTokenTtlSec;
+const logger_1 = __importDefault(require("../../logger"));
+exports.DEFAULT_MCP_TOKEN_TTL_SEC = 86400;
+/**
+ * The lifetime of the xenon-mcp tokens and session tokens POST /auth/token
+ * mints, in seconds: XENON_MCP_TOKEN_TTL_SEC, a whole number above 0, else a
+ * day. Through 2.15 any other value (`abc`) gave every such token a NaN
+ * lifetime; it now warns and keeps the default.
+ */
+function mcpTokenTtlSec(raw = process.env.XENON_MCP_TOKEN_TTL_SEC, warn = (message) => logger_1.default.warn(message)) {
+    var _a;
+    const text = (_a = raw === null || raw === void 0 ? void 0 : raw.trim()) !== null && _a !== void 0 ? _a : '';
+    if (text === '')
+        return exports.DEFAULT_MCP_TOKEN_TTL_SEC;
+    const seconds = /^\d+$/.test(text) ? Number(text) : NaN;
+    if (Number.isSafeInteger(seconds) && seconds > 0)
+        return seconds;
+    warn(`XENON_MCP_TOKEN_TTL_SEC is "${raw}", not a whole number of seconds above 0. ` +
+        `The tokens it sets the lifetime of last ${exports.DEFAULT_MCP_TOKEN_TTL_SEC} s, the default.`);
+    return exports.DEFAULT_MCP_TOKEN_TTL_SEC;
+}

package/lib/src/sessions/LocalSession.js

@@ -109,6 +109,26 @@ class LocalSession extends RemoteSession_1.RemoteSession {
             };
         });
     }
+    /**
+     * The device log the session's driver captures (XCUITest's
+     * `logs.syslog`), for the session's Device logs (SessionDeviceLogs).
+     * Undefined for a driver that keeps none, or a session that skips log
+     * capture.
+     */
+    deviceLog() {
+        var _a, _b, _c, _d, _e, _f;
+        const sessionDriver = ((_c = (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.sessions) === null || _b === void 0 ? void 0 : _b[this.sessionId]) === null || _c === void 0 ? void 0 : _c.proxydriver) ||
+            ((_e = (_d = this.driver) === null || _d === void 0 ? void 0 : _d.sessions) === null || _e === void 0 ? void 0 : _e[this.sessionId]);
+        return (_f = sessionDriver === null || sessionDriver === void 0 ? void 0 : sessionDriver.logs) === null || _f === void 0 ? void 0 : _f.syslog;
+    }
+    /** The bundle id of the app under test, as the session's driver has it (XCUITest's `opts.bundleId`). */
+    appUnderTest() {
+        var _a, _b, _c, _d, _e, _f;
+        const sessionDriver = ((_c = (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.sessions) === null || _b === void 0 ? void 0 : _b[this.sessionId]) === null || _c === void 0 ? void 0 : _c.proxydriver) ||
+            ((_e = (_d = this.driver) === null || _d === void 0 ? void 0 : _d.sessions) === null || _e === void 0 ? void 0 : _e[this.sessionId]);
+        const bundleId = (_f = sessionDriver === null || sessionDriver === void 0 ? void 0 : sessionDriver.opts) === null || _f === void 0 ? void 0 : _f.bundleId;
+        return typeof bundleId === 'string' && bundleId ? bundleId : undefined;
+    }
     /**
      * A local session's driver is in this process, so ask it directly instead of
      * looping back over HTTP. The loopback works, but it re-enters the Appium
@@ -246,7 +266,7 @@ class LocalSession extends RemoteSession_1.RemoteSession {
     // Override to use proper Appium URL for video commands
     startVideoRecording(options, driverOverride) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             logger_1.default.info(`[LocalSession] Starting video recording for session ${this.sessionId}`);
             // Principal Intelligence: For local sessions, try to call the driver directly.
             // We try driverOverride first (e.g. from onUnexpectedShutdown), then search the session map, then this.driver.
@@ -291,6 +311,14 @@ class LocalSession extends RemoteSession_1.RemoteSession {
                     const result = yield typedi_1.Container.get(AndroidStreamService_1.default).startStream(device.udid);
                     mjpegPort = result.mjpegPort;
                 }
+                else if (device.platform === 'ios' && !device.realDevice) {
+                    // A simulator's WebDriverAgent is the driver's, and serves the picture
+                    // on this Mac at the session's mjpegServerPort. The stream service is
+                    // an iPhone's (go-ios, iproxy over USB): on a simulator it forwarded
+                    // nothing, and no video was written.
+                    mjpegPort =
+                        Number((_d = this.getCapabilities()) === null || _d === void 0 ? void 0 : _d.mjpegServerPort) || device.mjpegServerPort || undefined;
+                }
                 else if (device.platform === 'ios') {
                     const result = yield typedi_1.Container.get(IOSStreamService_1.default).startStream(device.udid);
                     mjpegPort = result.mjpegPort;