@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/src/generated/client/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "prisma-client-ec1ae6fb328d1bc102086acd1f77e77477081d17b653d7f5092f083d0c8a4d34",
+  "name": "prisma-client-51d1df0b46f05c51a020cdf82ebc5860c67366c00fe846037d4445f0f8195b4a",
   "main": "index.js",
   "types": "index.d.ts",
   "browser": "index-browser.js",

package/lib/src/generated/client/schema.prisma

@@ -307,6 +307,9 @@ model LocatorEtalon {
   strategy   String
   attributes String
   nodeName   String
+  /// The element's path through the page source when the selector last
+  /// worked (JSON, resilioPath.ts), for the Resilio healing tier.
+  path       String?
   lastSeen   DateTime @default(now())
   createdAt  DateTime @default(now())
   updatedAt  DateTime @updatedAt

package/lib/src/generated/client/wasm.js

@@ -353,6 +353,7 @@ exports.Prisma.LocatorEtalonScalarFieldEnum = {
   strategy: 'strategy',
   attributes: 'attributes',
   nodeName: 'nodeName',
+  path: 'path',
   lastSeen: 'lastSeen',
   createdAt: 'createdAt',
   updatedAt: 'updatedAt'

package/lib/src/helpers/outboundProxy.js

@@ -0,0 +1,219 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.outboundProxyFor = outboundProxyFor;
+exports.envProxyFor = envProxyFor;
+exports.proxyAgentFor = proxyAgentFor;
+exports.socketProxyAgentFor = socketProxyAgentFor;
+exports.axiosProxyConfig = axiosProxyConfig;
+const typedi_1 = require("typedi");
+const http_proxy_agent_1 = require("http-proxy-agent");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const logger_1 = __importDefault(require("../logger"));
+const PluginContext_1 = require("../PluginContext");
+/**
+ * The proxy for one of Xenon's own calls to another server (a hub's to its
+ * nodes and to a cloud provider, a node's to its hub, and the rest of
+ * Xenon's internal calls), one rule whichever client makes the call:
+ *
+ * 1. None for a host `no_proxy` / `NO_PROXY` names (envProxyFor's list).
+ * 2. The `proxy` plugin option when it is set, for http and https alike,
+ *    except for a loopback host (`localhost`, 127.x, ::1): a proxy elsewhere
+ *    can't reach this machine's loopback.
+ * 3. Else the environment's proxy for the URL's scheme (envProxyFor).
+ *
+ * Through 2.15 the option reached one call, the create a hub sends to a node
+ * or a cloud provider; that session's commands, screenshots and heartbeats,
+ * device control, the sockets and a node's calls to its hub took the
+ * environment's proxy instead, or none.
+ */
+function outboundProxyFor(target, opts = {}) {
+    var _a, _b;
+    const url = toUrl(target);
+    const scheme = schemeOf(url);
+    if (!scheme)
+        return undefined;
+    const env = (_a = opts.env) !== null && _a !== void 0 ? _a : process.env;
+    if (namedByNoProxy(url, env))
+        return undefined;
+    const option = 'option' in opts ? opts.option : pluginProxyOption();
+    const configured = proxyOptionUrl(option, (_b = opts.warn) !== null && _b !== void 0 ? _b : warnOnce);
+    if (configured && !isLoopback(url.hostname))
+        return configured;
+    return schemeProxy(scheme, env);
+}
+/**
+ * The environment's proxy for a URL, by the rule axios (0.27's http adapter)
+ * applies to Xenon's axios calls:
+ * - `http_proxy` or `HTTP_PROXY` for an http URL, `https_proxy` or
+ *   `HTTPS_PROXY` for an https one, the lower-case name first (ws and wss
+ *   count as http and https);
+ * - none when `no_proxy` or `NO_PROXY` (the lower-case name first; a
+ *   comma-separated list) has `*`, the URL's host name, or a suffix of it
+ *   starting with a dot (`.lab.example`). An entry is a host name only: one
+ *   with a port matches nothing, as in axios.
+ *
+ * Through 2.15 a command forwarded to a node took HTTP_PROXY or HTTPS_PROXY
+ * whatever its scheme and ignored NO_PROXY, the live-preview and logcat
+ * sockets ignored every proxy, and so did a node fetching its hub's keys.
+ */
+function envProxyFor(target, env = process.env) {
+    const url = toUrl(target);
+    const scheme = schemeOf(url);
+    if (!scheme || namedByNoProxy(url, env))
+        return undefined;
+    return schemeProxy(scheme, env);
+}
+/**
+ * An agent sending an HTTP request for `target` through its proxy, or
+ * undefined to go straight there: the request in absolute form to the proxy
+ * for an http URL, a CONNECT tunnel for an https one.
+ */
+function proxyAgentFor(target, tls = {}) {
+    const proxy = outboundProxyFor(target);
+    if (!proxy)
+        return undefined;
+    const url = toUrl(target);
+    return url.protocol === 'https:' ? new TunnelAgent(proxy, tls) : new http_proxy_agent_1.HttpProxyAgent(proxy);
+}
+/**
+ * An agent opening a WebSocket for `target` (ws or wss) through its proxy, or
+ * undefined to go straight there. Always a CONNECT tunnel: an upgrade sent to
+ * a proxy in absolute form is not reliably passed on.
+ */
+function socketProxyAgentFor(target, tls = {}) {
+    const proxy = outboundProxyFor(target);
+    return proxy ? new TunnelAgent(proxy, tls) : undefined;
+}
+/**
+ * An axios request's proxy settings for `target`: through its proxy's agent,
+ * or none. Either way `proxy: false`, since the decision is made here, by
+ * outboundProxyFor; axios's own lookup reads the environment only. With no
+ * proxy, the caller's own agents stay.
+ */
+function axiosProxyConfig(target, tls = {}) {
+    const agent = proxyAgentFor(target, tls);
+    return agent ? { proxy: false, httpAgent: agent, httpsAgent: agent } : { proxy: false };
+}
+/**
+ * A CONNECT tunnel that checks the server behind it as the caller asked.
+ * HttpsProxyAgent's own options are for the connection to the proxy; the
+ * tunnelled TLS takes the request's, which axios doesn't fill in. So through
+ * 2.15 `tlsRejectUnauthorized` never reached a node or cloud provider that a
+ * proxy stood in front of.
+ */
+class TunnelAgent extends https_proxy_agent_1.HttpsProxyAgent {
+    constructor(proxy, targetTls) {
+        super(proxy);
+        this.targetTls = targetTls;
+    }
+    connect(req, opts) {
+        const _super = Object.create(null, {
+            connect: { get: () => super.connect }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const tls = this.targetTls.rejectUnauthorized === undefined
+                ? {}
+                : { rejectUnauthorized: this.targetTls.rejectUnauthorized };
+            return _super.connect.call(this, req, Object.assign(Object.assign({}, opts), tls));
+        });
+    }
+}
+/**
+ * The `proxy` option as a proxy URL: a string as it is (http:// added when
+ * it names no scheme), or `{ protocol, host, port, auth: { username,
+ * password } }` (protocol http by default, credentials escaped). One that
+ * names no host is no proxy, said once.
+ */
+function proxyOptionUrl(option, warn) {
+    var _a, _b;
+    if (option === undefined || option === null || option === '')
+        return undefined;
+    if (typeof option === 'string') {
+        const text = option.trim();
+        if (text === '')
+            return undefined;
+        return hasScheme(text) ? text : `http://${text}`;
+    }
+    const value = option;
+    if (typeof option !== 'object' || typeof value.host !== 'string' || value.host.trim() === '') {
+        warn(`The proxy option ${JSON.stringify(option)} names no host, so it is not used: ` +
+            "Xenon's calls to other servers take the environment's proxy, if any.");
+        return undefined;
+    }
+    const protocol = typeof value.protocol === 'string' && value.protocol !== ''
+        ? value.protocol.replace(/:$/, '')
+        : 'http';
+    const port = value.port === undefined || value.port === null ? '' : `:${value.port}`;
+    const username = (_a = value.auth) === null || _a === void 0 ? void 0 : _a.username;
+    const password = (_b = value.auth) === null || _b === void 0 ? void 0 : _b.password;
+    const credentials = typeof username === 'string' && username !== ''
+        ? `${encodeURIComponent(username)}${typeof password === 'string' ? `:${encodeURIComponent(password)}` : ''}@`
+        : '';
+    return `${protocol}://${credentials}${value.host.trim()}${port}`;
+}
+const warned = new Set();
+function warnOnce(message) {
+    if (warned.has(message))
+        return;
+    warned.add(message);
+    logger_1.default.warn(message);
+}
+function pluginProxyOption() {
+    var _a;
+    try {
+        return (_a = typedi_1.Container.get(PluginContext_1.PluginContext).pluginArgs) === null || _a === void 0 ? void 0 : _a.proxy;
+    }
+    catch (_b) {
+        return undefined;
+    }
+}
+function toUrl(target) {
+    return typeof target === 'string' ? new URL(target) : target;
+}
+function schemeOf(url) {
+    const scheme = url.protocol.replace(/:$/, '').replace(/^ws(s?)$/, 'http$1');
+    return scheme === 'http' || scheme === 'https' ? scheme : undefined;
+}
+function hostOf(url) {
+    return url.hostname.replace(/^\[(.*)\]$/, '$1');
+}
+function namedByNoProxy(url, env) {
+    const noProxy = env.no_proxy || env.NO_PROXY;
+    if (!noProxy)
+        return false;
+    const host = hostOf(url);
+    return noProxy
+        .split(',')
+        .map((entry) => entry.trim())
+        .some((entry) => entry !== '' &&
+        (entry === '*' || entry === host || (entry.startsWith('.') && host.endsWith(entry))));
+}
+function schemeProxy(scheme, env) {
+    const proxy = env[`${scheme}_proxy`] || env[`${scheme.toUpperCase()}_PROXY`];
+    if (!proxy)
+        return undefined;
+    return hasScheme(proxy) ? proxy : `http://${proxy}`;
+}
+function hasScheme(text) {
+    return /^[a-z][a-z0-9+.-]*:\/\//i.test(text);
+}
+function isLoopback(hostname) {
+    const host = hostname.replace(/^\[(.*)\]$/, '$1').toLowerCase();
+    return (host === 'localhost' ||
+        host.endsWith('.localhost') ||
+        /^127(\.\d{1,3}){3}$/.test(host) ||
+        host === '::1' ||
+        host === '0:0:0:0:0:0:0:1');
+}

package/lib/src/index.js

@@ -68,6 +68,12 @@ const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         // Bounded so a hung driver can't hold up systemd (default 90s timeout).
         const { ShutdownCoordinator } = yield Promise.resolve().then(() => __importStar(require('./services/ShutdownCoordinator')));
         yield typedi_1.Container.get(ShutdownCoordinator).drain(15000);
+        // Telemetry next, as early as it can be: on SIGTERM Appium exits before
+        // Phase 2 (see the 'exit' hook below), and placed last it never ran. What
+        // the OTel exporters still hold is sent, and the spans of sessions still
+        // running on a node or at a cloud provider end, saying so. Lines logged
+        // after this aren't exported.
+        yield shutDownTelemetry(3000);
         const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/ios/IOSStreamService')));
         const { default: AndroidStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/android/AndroidStreamService')));
         const { LogcatStreamService } = yield Promise.resolve().then(() => __importStar(require('./device-managers/android/LogcatStreamService')));
@@ -94,11 +100,26 @@ const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
         logger_1.default.error(`❌ [Xenon] Cleanup failed: ${err.message}`);
     }
     finally {
+        // When the drain threw, the telemetry wasn't shut down above. A second
+        // call does nothing.
+        yield shutDownTelemetry(1000);
         // Principal Delay: Wait 2 seconds before hard-exiting to allow
         // other async handlers (like hub unregistration) to finish.
         setTimeout(() => process.exit(0), 2000);
     }
 });
+function shutDownTelemetry(budgetMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        try {
+            const { TracingService } = yield Promise.resolve().then(() => __importStar(require('./services/TracingService')));
+            yield typedi_1.Container.get(TracingService).shutdownWithin(budgetMs);
+        }
+        catch (err) {
+            logger_1.default.warn(`[Xenon] Telemetry shutdown failed: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    });
+}
 process.on('SIGINT', cleanup);
 process.on('SIGTERM', cleanup);
 // Last-resort synchronous net for every long-lived sidecar.