@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/src/services/omni-vision/OmniVisionService.js

@@ -1,43 +1,10 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 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 __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 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) {
@@ -52,22 +19,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var OmniVisionService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OmniVisionService = void 0;
+exports.OmniVisionService = exports.MAX_VIRTUAL_ELEMENTS = exports.MAX_VIRTUAL_ELEMENTS_PER_SESSION = void 0;
 const typedi_1 = require("typedi");
-const tesseract_js_1 = __importStar(require("tesseract.js"));
+const tesseract_js_1 = require("tesseract.js");
+const ocrData_1 = require("../ocr/ocrData");
 const sharp_1 = __importDefault(require("sharp"));
 const AIService_1 = require("../AIService");
 const logger_1 = __importDefault(require("../../logger"));
 const crypto_1 = __importDefault(require("crypto"));
 const ocrTextMatch_1 = require("./ocrTextMatch");
 const screenScale_1 = require("./screenScale");
+/**
+ * How many virtual elements Xenon keeps, for one session and in all. The
+ * oldest go first: a test acts on what it found last, and a command on an
+ * element that went answers "no such element".
+ */
+exports.MAX_VIRTUAL_ELEMENTS_PER_SESSION = 1000;
+exports.MAX_VIRTUAL_ELEMENTS = 10000;
 // Mobile UIs have sparse text on complex backgrounds - reduce contrast to preserve readability
 const DEFAULT_CONTRAST = 1.2; // Slightly above 1.0 for mild enhancement (was 0.8 which was too aggressive)
 const UPSCALE_THRESHOLD = 800; // Only upscale very small images (was 1500)
 let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
     constructor() {
         this.logger = logger_1.default.scope('OmniVision');
-        this.virtualElementStore = new Map();
+        /**
+         * The virtual elements tests may still act on, by id, each with the session
+         * that found it, oldest first. Through 2.14 every element ever found stayed
+         * here until the server restarted, and any session could act on another's.
+         */
+        this.elements = new Map();
+        this.bySession = new Map();
         this.sharedWorker = null;
         this.workerBusy = false;
         this.uiLensCache = new Map();
@@ -77,7 +58,7 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
             if (this.sharedWorker)
                 return this.sharedWorker;
             this.logger.info('Initializing persistent OCR worker with explicit configuration...');
-            const worker = yield tesseract_js_1.default.createWorker('eng');
+            const worker = yield (0, ocrData_1.createOcrWorker)();
             // PSM.SPARSE_TEXT is optimized for irregular text layouts like mobile UIs
             // AUTO mode assumes document structure which fails on sparse mobile screens
             yield worker.setParameters({
@@ -385,6 +366,21 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
     wordBoxes(words) {
         return words.map((w) => this.normalizeWordBBox(w)).filter(Boolean);
     }
+    /** Where `text` is among OCR's words, read with over 60% confidence, in reading order. */
+    textMatches(words, text) {
+        return (0, ocrTextMatch_1.findText)(this.wordBoxes(words), String(text !== null && text !== void 0 ? text : '')).filter((m) => m.confidence > 60);
+    }
+    /**
+     * Where `text` is on a screenshot, matched as `-custom:ai-text` matches it:
+     * in the screenshot's pixels, in reading order. Self-healing's OCR tier
+     * uses it. Throws when OCR fails.
+     */
+    findTextInScreenshot(screenshotBase64, text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { words } = yield this.performOcr(Buffer.from(screenshotBase64, 'base64'));
+            return this.textMatches(words, text);
+        });
+    }
     /**
      * Proactive OCR Search: Finds elements matching text even if not in XML.
      *
@@ -407,20 +403,16 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
                     this.logger.warn(`OCR proactive search yielded no words. Text content: "${ocrText.trim().substring(0, 100)}..."`);
                     return [];
                 }
-                const matches = (0, ocrTextMatch_1.findText)(this.wordBoxes(words), String(text !== null && text !== void 0 ? text : '')).filter((m) => m.confidence > 60);
+                const matches = this.textMatches(words, text);
                 if (matches.length === 0)
                     return [];
                 const scale = yield (0, screenScale_1.screenScaleOf)(driver, screenshot);
-                return matches.map((m) => {
-                    const el = {
-                        id: `omni_ocr_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`,
-                        text: m.text,
-                        rect: (0, screenScale_1.toDriverRect)({ x: m.x0, y: m.y0, width: m.x1 - m.x0, height: m.y1 - m.y0 }, scale),
-                        confidence: m.confidence / 100,
-                    };
-                    this.virtualElementStore.set(el.id, el);
-                    return el;
-                });
+                return matches.map((m) => ({
+                    id: `omni_ocr_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`,
+                    text: m.text,
+                    rect: (0, screenScale_1.toDriverRect)({ x: m.x0, y: m.y0, width: m.x1 - m.x0, height: m.y1 - m.y0 }, scale),
+                    confidence: m.confidence / 100,
+                }));
             }
             catch (err) {
                 this.logger.error(`OCR proactive search failed: ${err.message}`);
@@ -443,13 +435,11 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
                     // The AI answers in the screenshot's pixels; the rect is the driver's
                     // (points on iOS), like a real element's.
                     const scale = yield (0, screenScale_1.screenScaleOf)(driver, screenshot);
-                    const el = {
-                        id: `omni_ai_${Date.now()}`,
+                    return {
+                        id: `omni_ai_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`,
                         rect: (0, screenScale_1.toDriverRect)({ x: coordinates.x - 20, y: coordinates.y - 20, width: 40, height: 40 }, scale),
                         confidence: 0.85,
                     };
-                    this.virtualElementStore.set(el.id, el);
-                    return el;
                 }
             }
             catch (err) {
@@ -505,11 +495,48 @@ let OmniVisionService = OmniVisionService_1 = class OmniVisionService {
             }
         });
     }
-    addVirtualElement(element) {
-        this.virtualElementStore.set(element.id, element);
+    /**
+     * Keep `element` for `sessionId`, whose test was handed its id (a
+     * `-custom:ai-*` find, a heal), until the session ends (`forgetSession`)
+     * or the limits push it out. A find doesn't keep what it finds: device
+     * control's locator test only shows the ids, and a tap uses its element at
+     * once.
+     */
+    remember(sessionId, element) {
+        this.drop(element.id);
+        this.elements.set(element.id, { element, sessionId });
+        let ids = this.bySession.get(sessionId);
+        if (!ids) {
+            ids = new Set();
+            this.bySession.set(sessionId, ids);
+        }
+        ids.add(element.id);
+        if (ids.size > exports.MAX_VIRTUAL_ELEMENTS_PER_SESSION)
+            this.drop(ids.values().next().value);
+        if (this.elements.size > exports.MAX_VIRTUAL_ELEMENTS)
+            this.drop(this.elements.keys().next().value);
+    }
+    /** The element, when `sessionId` found it and still has it. */
+    getVirtualElement(id, sessionId) {
+        const held = this.elements.get(id);
+        return held && held.sessionId === sessionId ? held.element : undefined;
+    }
+    /** Drop every element a session found: it has ended (sessionMemory.ts). */
+    forgetSession(sessionId) {
+        var _a;
+        for (const id of (_a = this.bySession.get(sessionId)) !== null && _a !== void 0 ? _a : [])
+            this.elements.delete(id);
+        this.bySession.delete(sessionId);
     }
-    getVirtualElement(id) {
-        return this.virtualElementStore.get(id);
+    drop(id) {
+        const held = this.elements.get(id);
+        if (!held)
+            return;
+        this.elements.delete(id);
+        const ids = this.bySession.get(held.sessionId);
+        ids === null || ids === void 0 ? void 0 : ids.delete(id);
+        if (ids && ids.size === 0)
+            this.bySession.delete(held.sessionId);
     }
     /**
      * Omni-Click: Find a target by OCR text and click its center using W3C actions.

package/lib/src/services/passwordResetLink.js

@@ -1,25 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetLinkBase = resetLinkBase;
 exports.buildResetLink = buildResetLink;
+exports.requestBase = requestBase;
+exports.describeLifetime = describeLifetime;
 exports.resetEmail = resetEmail;
+const config_1 = require("../config");
+const publicUrl_1 = require("./publicUrl");
 /**
- * The URL a reset token is redeemed at. Built from the request so it matches
- * the host the caller reached the server on (honouring a TLS-terminating
- * proxy's x-forwarded-proto). The raw token is a credential for the account
- * until it expires or is used: never log the result.
+ * Where a password reset link points, and the email that carries it. The raw
+ * token in a link is a credential for the account until it expires or is
+ * used: never log the result.
  *
  * The token goes in the fragment (#), not the path. Browsers never send the
  * fragment to the server, so opening the link can't put the token in any
  * server-side log. As a path segment it was logged on every open: Appium's
  * [HTTP] request line and Xenon's UI-fallback line both record the URL.
  */
-function buildResetLink(req, rawToken) {
+/**
+ * The address a link Xenon sends (by email, or to the log fallback) points
+ * at: this server's address from XENON_PUBLIC_URL (publicServerBase), or
+ * null when it is unset or not a usable address.
+ *
+ * Never the request's Host header. Through 2.14 the link was built from it,
+ * so anyone could ask for a reset of someone else's account naming a host of
+ * their own (a matching Origin passes the CSRF check), and Xenon emailed the
+ * victim a genuine link to that host, which handed over the token.
+ */
+function resetLinkBase(cfg = config_1.config) {
+    return (0, publicUrl_1.publicServerBase)(cfg);
+}
+/** The reset page for `rawToken`, under `base` (resetLinkBase, or requestBase). */
+function buildResetLink(base, rawToken) {
+    return `${base}/xenon/reset-password#${rawToken}`;
+}
+/**
+ * The address the caller reached this server on, honouring a TLS-terminating
+ * proxy's x-forwarded-proto. Only for a link handed back to the signed-in
+ * administrator who asked for it (POST /users/:id/reset-link when it can't be
+ * emailed): they see where it points before passing it on, and hold the token
+ * anyway. Never for a link Xenon sends to someone else.
+ */
+function requestBase(req) {
     const proto = req.secure || req.headers['x-forwarded-proto'] === 'https' ? 'https' : 'http';
     const host = req.headers.host || 'localhost';
-    return `${proto}://${host}/xenon/reset-password#${rawToken}`;
+    return `${proto}://${host}`;
+}
+/** "1 hour", "30 minutes", "2 hours": a reset link's lifetime, for the email. */
+function describeLifetime(ms) {
+    const minutes = Math.max(1, Math.round(ms / 60000));
+    if (minutes % 60 === 0) {
+        const hours = minutes / 60;
+        return `${hours} hour${hours === 1 ? '' : 's'}`;
+    }
+    return `${minutes} minute${minutes === 1 ? '' : 's'}`;
 }
-/** The reset email, shared by self-service and admin-issued resets. */
-function resetEmail(user, link) {
+/**
+ * The reset email, shared by self-service and admin-issued resets. `ttlMs` is
+ * how long the link lasts (PasswordResetService.ttlMs(), from
+ * XENON_RESET_TOKEN_TTL_MS): the email said "1 hour" whatever it was.
+ */
+function resetEmail(user, link, ttlMs) {
     return {
         to: user.email,
         subject: 'Reset your Xenon password',
@@ -27,6 +68,6 @@ function resetEmail(user, link) {
             `Someone requested a password reset for your Xenon account. ` +
             `If that was you, click the link below to choose a new password:\n\n` +
             `${link}\n\n` +
-            `This link expires in 1 hour. If you did not request this, ignore this email — no action is needed.\n`,
+            `This link expires in ${describeLifetime(ttlMs)}. If you did not request this, ignore this email — no action is needed.\n`,
     };
 }

package/lib/src/services/passwordResetMode.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.passwordResetMode = passwordResetMode;
+const passwordResetLink_1 = require("./passwordResetLink");
 function passwordResetMode(cfg) {
-    return cfg.smtpUrl && cfg.smtpUrl.trim() ? 'email' : 'admin';
+    const smtp = !!(cfg.smtpUrl && cfg.smtpUrl.trim());
+    return smtp && (0, passwordResetLink_1.resetLinkBase)(cfg) !== null ? 'email' : 'admin';
 }

package/lib/src/services/publicUrl.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.publicServerBase = publicServerBase;
+const config_1 = require("../config");
+/**
+ * XENON_PUBLIC_URL: the address people reach this Xenon server at, such as
+ * https://xenon.example.com or http://lab-mac:4723. Links Xenon hands out
+ * (password reset links, a device's dashboard_link) are built from it, never
+ * from the request's Host header, which whoever sends the request chooses.
+ *
+ * The dashboard's own address is taken too: a trailing `/xenon` or `/xenon/`
+ * is dropped, so `http://localhost:4723/xenon/` gives `http://localhost:4723`.
+ * Kept as given it built `/xenon/xenon/reset-password`, which the dashboard
+ * sends to its sign-in page, losing the token.
+ *
+ * Any other path is refused: the dashboard loads its pages, scripts and API
+ * from `/xenon` on the server's root (its base path is fixed at build time),
+ * so it can't be served under a reverse-proxy prefix, and a link under one
+ * wouldn't open. So are an address that isn't http(s), and one with a query,
+ * fragment or user name (a fragment would swallow a reset token).
+ *
+ * Returns the origin (scheme, host and port, no trailing slash), or null when
+ * the variable is unset or not such an address.
+ */
+function publicServerBase(cfg = config_1.config) {
+    var _a;
+    const raw = (_a = cfg.publicUrl) === null || _a === void 0 ? void 0 : _a.trim();
+    if (!raw)
+        return null;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch (_b) {
+        return null;
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:')
+        return null;
+    if (url.search || url.hash || url.username || url.password)
+        return null;
+    const path = url.pathname.replace(/\/+$/, '');
+    if (path !== '' && path !== '/xenon')
+        return null;
+    return url.origin;
+}

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/session/sessionIdentity.js

@@ -21,9 +21,11 @@ function resolveSessionIdentity(input) {
         if (!input.sessionToken)
             return NONE;
         // Attribution is decoupled from enforcement: a token that does not verify is
-        // IGNORED here, never rejected. assertSessionTokenGate remains the only
-        // decider of whether the session is admitted. That separation is what lets a
-        // valid token identify its caller even when the gate is switched off.
+        // IGNORED here, never rejected. Whether the session is admitted is decided
+        // by the caller: assertSessionTokenGate for a session with no valid
+        // credentials, and authorizeSessionRequest's `sessions` scope check for a
+        // token that verifies. That separation is what lets a valid token identify
+        // its caller even when the gate is switched off.
         try {
             const payload = yield input.verify(input.sessionToken);
             const sub = payload === null || payload === void 0 ? void 0 : payload.sub;

package/lib/src/services/session/shutdownReason.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UNEXPECTED_SHUTDOWN_REASON = void 0;
+exports.unexpectedShutdownReason = unexpectedShutdownReason;
+/** The reason recorded when Appium ends a session and gives no cause of its own. */
+exports.UNEXPECTED_SHUTDOWN_REASON = 'Driver shut down unexpectedly';
+/**
+ * The failure reason of a session Appium ended by itself
+ * (`XenonPlugin.onUnexpectedShutdown`): the message of the cause Appium
+ * passed, else UNEXPECTED_SHUTDOWN_REASON.
+ *
+ * Appium's new-command timeout is the usual cause, and its message ("New
+ * Command Timeout of 60 seconds expired. Try customizing the timeout using
+ * the 'newCommandTimeout' desired capability") is what files the session
+ * under TIMEOUT. A driver that gives up on itself passes its own error, such
+ * as base-driver's "The driver was unexpectedly shut down!". The umbrella's
+ * placeholder for a missing cause, "Unknown error", says nothing, so it gets
+ * the fallback too. Through 2.14 every such session was recorded with the
+ * fixed reason, which no failure pattern matches, so an idle session was
+ * filed UNKNOWN.
+ */
+function unexpectedShutdownReason(cause) {
+    const message = typeof cause === 'string' ? cause : cause === null || cause === void 0 ? void 0 : cause.message;
+    const text = typeof message === 'string' ? message.trim() : '';
+    return text && text !== 'Unknown error' ? text : exports.UNEXPECTED_SHUTDOWN_REASON;
+}