@xenon-device-management/xenon 1.1.0

package/lib/src/enums/Platform.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var DevicePlatform;
+(function (DevicePlatform) {
+    DevicePlatform["ANDROID"] = "android";
+    DevicePlatform["IOS"] = "ios";
+    DevicePlatform["BOTH"] = "both";
+})(DevicePlatform || (DevicePlatform = {}));
+exports.default = DevicePlatform;

package/lib/src/enums/SessionType.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var SessionType;
+(function (SessionType) {
+    SessionType["LOCAL"] = "local";
+    SessionType["REMOTE"] = "remote";
+    SessionType["CLOUD"] = "cloud";
+})(SessionType || (SessionType = {}));
+exports.default = SessionType;

package/lib/src/enums/SocketEvents.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XENON_PROTOCOL_VERSION = exports.SocketEvents = void 0;
+var SocketEvents;
+(function (SocketEvents) {
+    SocketEvents["HANDSHAKE"] = "handshake";
+    SocketEvents["REGISTER_NODE"] = "register_node";
+    SocketEvents["REGISTER_DASHBOARD"] = "register_dashboard";
+    SocketEvents["NODE_CONNECTED"] = "node_connected";
+    SocketEvents["NODE_DISCONNECTED"] = "node_disconnected";
+    SocketEvents["SESSION_STARTED"] = "session_started";
+    SocketEvents["SESSION_STOPPED"] = "session_stopped";
+    SocketEvents["SESSION_COMMAND"] = "session_command";
+})(SocketEvents || (exports.SocketEvents = SocketEvents = {}));
+exports.XENON_PROTOCOL_VERSION = '1.0.0';

package/lib/src/helpers/UniversalMjpegProxy.js

@@ -0,0 +1,273 @@
+"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 __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) {
+        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.UniversalMjpegProxy = void 0;
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
+const logger_1 = __importDefault(require("../logger"));
+/**
+ * Universal MJPEG Proxy
+ *
+ * Principal Design: Handling WDA's inconsistent MJPEG behavior.
+ * Some WDA versions/configurations send standard HTTP MJPEG streams,
+ * while others (especially over high-performance ports) might send raw boundaries
+ * without the initial HTTP/1.1 response status line.
+ *
+ * This proxy sniffs high-level response headers and gracefully handles raw streams
+ * by injecting consistent HTTP headers for the client browser.
+ */
+class UniversalMjpegProxy {
+    constructor(mjpegUrl) {
+        this.boundary = 'BoundaryString';
+        this.globalResponseHeaders = {
+            'Cache-Control': 'no-cache, private, no-store, must-revalidate, max-stale=0, post-check=0, pre-check=0',
+            Pragma: 'no-cache',
+            Connection: 'keep-alive',
+            Expires: '0',
+            'Content-Type': 'multipart/x-mixed-replace; boundary="BoundaryString"',
+            'Access-Control-Allow-Origin': '*',
+        };
+        this.clients = new Set();
+        this.sourceRequest = null;
+        this.isConnected = false;
+        this.reconnectionTimeout = null;
+        this.isStopped = false;
+        /**
+         * Principal Resilience: Retry limits with exponential backoff.
+         * Without these, the proxy retries every 500ms FOREVER, flooding logs
+         * and wasting CPU after a session ends or the server shuts down.
+         */
+        this.consecutiveRetries = 0;
+        this.mjpegUrl = mjpegUrl;
+    }
+    get url() {
+        return this.mjpegUrl;
+    }
+    proxyRequest(req, res) {
+        res.writeHead(200, this.globalResponseHeaders);
+        this.clients.add(res);
+        logger_1.default.debug(`[MjpegProxy] New client joined stream: ${this.mjpegUrl}. Total clients: ${this.clients.size}`);
+        req.on('close', () => {
+            this.clients.delete(res);
+            logger_1.default.debug(`[MjpegProxy] Client left stream. Remaining: ${this.clients.size}`);
+            if (this.clients.size === 0) {
+                this.stopSource();
+            }
+        });
+        if (!this.isConnected) {
+            this.startSource();
+        }
+    }
+    startSource() {
+        const url = new url_1.URL(this.mjpegUrl);
+        const options = {
+            hostname: url.hostname,
+            port: url.port,
+            path: url.pathname + url.search,
+            method: 'GET',
+        };
+        logger_1.default.info(`[MjpegProxy] Connecting to source: ${this.mjpegUrl}`);
+        this.sourceRequest = http_1.default.get(options, (sourceRes) => {
+            if (sourceRes.statusCode !== 200) {
+                logger_1.default.error(`[MjpegProxy] Source returned non-200 status: ${sourceRes.statusCode}`);
+                this.reconnect();
+                return;
+            }
+            this.isConnected = true;
+            this.consecutiveRetries = 0; // Reset on successful connection
+            // Standard MJPEG
+            sourceRes.on('data', (chunk) => {
+                this.broadcast(chunk);
+            });
+            sourceRes.on('end', () => {
+                logger_1.default.warn(`[MjpegProxy] Source stream ended: ${this.mjpegUrl}`);
+                this.reconnect();
+            });
+            sourceRes.on('error', (err) => {
+                logger_1.default.error(`[MjpegProxy] Source stream error: ${err.message}`);
+                this.reconnect();
+            });
+        });
+        this.sourceRequest.on('error', (err) => {
+            if (this.isStopped)
+                return;
+            // Principal Insight: Handle HPE_INVALID_CONSTANT (Parse Error)
+            // If Node's HTTP parser fails, it's likely a raw stream without HTTP headers.
+            if (err.code === 'HPE_INVALID_CONSTANT' || err.message.includes('Parse Error')) {
+                logger_1.default.info('[MjpegProxy] Detected raw (head-less) MJPEG stream from source. Switching to Raw Mode.');
+                this.startRawSource();
+            }
+            else {
+                logger_1.default.error(`[MjpegProxy] Connection error: ${err.message}`);
+                this.reconnect();
+            }
+        });
+    }
+    /**
+     * Raw Source Mode
+     * Directly connects via TCP socket to bypass Node's strict HTTP parser.
+     */
+    startRawSource() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const net = yield Promise.resolve().then(() => __importStar(require('net')));
+            const url = new url_1.URL(this.mjpegUrl);
+            const socket = net.connect({
+                host: url.hostname,
+                port: parseInt(url.port || '80'),
+            }, () => {
+                logger_1.default.info(`[MjpegProxy] Raw MJPEG socket connected to ${url.hostname}:${url.port}`);
+                this.isConnected = true;
+                this.consecutiveRetries = 0; // Reset on successful connection
+                // Some MJPEG servers expect a GET request even if they don't send valid HTTP headers back
+                socket.write(`GET ${url.pathname}${url.search} HTTP/1.1\r\nHost: ${url.hostname}\r\n\r\n`);
+            });
+            socket.on('data', (chunk) => {
+                this.broadcast(chunk);
+            });
+            socket.on('end', () => {
+                logger_1.default.warn('[MjpegProxy] Raw source ended.');
+                this.reconnect();
+            });
+            socket.on('error', (err) => {
+                if (this.isStopped)
+                    return;
+                logger_1.default.error(`[MjpegProxy] Raw socket error: ${err.message}`);
+                this.reconnect();
+            });
+            this.sourceRequest = { abort: () => socket.destroy() };
+        });
+    }
+    broadcast(chunk) {
+        for (const client of this.clients) {
+            try {
+                client.write(chunk);
+            }
+            catch (e) {
+                this.clients.delete(client);
+            }
+        }
+    }
+    stopSource(reason = 'intentional') {
+        if (!this.sourceRequest && !this.isConnected)
+            return;
+        logger_1.default.info(`[MjpegProxy] Stopping source (${reason}): ${this.mjpegUrl}`);
+        if (this.sourceRequest) {
+            try {
+                this.sourceRequest.abort();
+            }
+            catch (e) {
+                /* ignore */
+            }
+            this.sourceRequest = null;
+        }
+        this.isConnected = false;
+    }
+    /**
+     * Explicitly stop the proxy and disconnect all clients.
+     * Prevents any future reconnection attempts.
+     */
+    stop() {
+        if (this.isStopped)
+            return;
+        this.isStopped = true;
+        if (this.reconnectionTimeout) {
+            clearTimeout(this.reconnectionTimeout);
+            this.reconnectionTimeout = null;
+        }
+        this.stopSource('proxy stopped');
+        logger_1.default.info(`[MjpegProxy] Terminating ${this.clients.size} client connections for ${this.mjpegUrl}`);
+        for (const client of this.clients) {
+            try {
+                client.end();
+            }
+            catch (e) {
+                /* ignore */
+            }
+        }
+        this.clients.clear();
+    }
+    reconnect() {
+        if (this.isStopped)
+            return;
+        // If no clients, we should NOT reconnect
+        if (this.clients.size === 0) {
+            this.stopSource('no active clients');
+            return;
+        }
+        // Principal Fix: Enforce maximum retry limit with exponential backoff.
+        // Without this, the proxy retries every 500ms FOREVER after a session
+        // ends or the server shuts down, flooding logs and wasting CPU.
+        // Peek-ahead check: will the next attempt exceed the limit?
+        if (this.consecutiveRetries + 1 > UniversalMjpegProxy.MAX_RETRIES) {
+            logger_1.default.warn(`[MjpegProxy] Max retries (${UniversalMjpegProxy.MAX_RETRIES}) reached for ${this.mjpegUrl}. Giving up and disconnecting clients.`);
+            this.stop();
+            return;
+        }
+        // Guard: if a reconnection is already scheduled, don't schedule another
+        // and don't inflate the retry counter.
+        if (this.reconnectionTimeout)
+            return;
+        // Only increment when a real reconnection will be scheduled.
+        this.consecutiveRetries++;
+        this.stopSource('reconnecting');
+        // Exponential backoff: 500ms, 1s, 2s, 4s, 8s, 10s (capped)
+        const delayMs = Math.min(UniversalMjpegProxy.BASE_RETRY_MS * Math.pow(2, this.consecutiveRetries - 1), UniversalMjpegProxy.MAX_RETRY_MS);
+        if (this.clients.size > 0) {
+            logger_1.default.info(`[MjpegProxy] Retry ${this.consecutiveRetries}/${UniversalMjpegProxy.MAX_RETRIES} in ${delayMs}ms...`);
+            this.reconnectionTimeout = setTimeout(() => {
+                this.reconnectionTimeout = null;
+                if (this.clients.size > 0 && !this.isStopped) {
+                    this.startSource();
+                }
+            }, delayMs);
+        }
+    }
+}
+exports.UniversalMjpegProxy = UniversalMjpegProxy;
+UniversalMjpegProxy.MAX_RETRIES = 10;
+UniversalMjpegProxy.BASE_RETRY_MS = 500;
+UniversalMjpegProxy.MAX_RETRY_MS = 10000;

package/lib/src/helpers/index.js

@@ -0,0 +1,229 @@
+"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.redactSecrets = void 0;
+exports.asyncForEach = asyncForEach;
+exports.spinWith = spinWith;
+exports.isMac = isMac;
+exports.cachePath = cachePath;
+exports.isWindows = isWindows;
+exports.checkIfPathIsAbsolute = checkIfPathIsAbsolute;
+exports.getFreePort = getFreePort;
+exports.nodeUrl = nodeUrl;
+exports.isPortBusy = isPortBusy;
+exports.hasHubArgument = hasHubArgument;
+exports.hasCloudArgument = hasCloudArgument;
+exports.stripAppiumPrefixes = stripAppiumPrefixes;
+exports.isXenonRunning = isXenonRunning;
+exports.isAppiumRunningAt = isAppiumRunningAt;
+exports.safeParseJson = safeParseJson;
+exports.takeScreenshot = takeScreenshot;
+/* eslint-disable no-prototype-builtins */
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const tcp_port_used_1 = __importDefault(require("tcp-port-used"));
+const get_port_1 = __importDefault(require("get-port"));
+const lodash_1 = __importDefault(require("lodash"));
+const logger_1 = __importDefault(require("../logger"));
+const Cloud_1 = __importDefault(require("../enums/Cloud"));
+const normalize_url_1 = __importDefault(require("normalize-url"));
+const ora_1 = __importDefault(require("ora"));
+const async_wait_until_1 = __importDefault(require("async-wait-until"));
+const InternalHttpClient_1 = require("../InternalHttpClient");
+const logger_2 = require("../logger");
+Object.defineProperty(exports, "redactSecrets", { enumerable: true, get: function () { return logger_2.redactSecrets; } });
+const APPIUM_VENDOR_PREFIX = 'appium:';
+const XENON_PREFIXES = ['xe:'];
+function asyncForEach(array, callback) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (let index = 0; index < array.length; index++) {
+            yield callback(array[index], index, array);
+        }
+    });
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function spinWith(msg_1, fn_1) {
+    return __awaiter(this, arguments, void 0, function* (msg, fn, callback = (_msg) => { }) {
+        const spinner = (0, ora_1.default)(msg).start();
+        yield (0, async_wait_until_1.default)(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield fn();
+                spinner.succeed();
+                return res;
+            }
+            catch (err) {
+                spinner.fail();
+                if (callback)
+                    callback(msg);
+                return false;
+            }
+        }), {
+            intervalBetweenAttempts: 2000,
+            timeout: 60 * 1000,
+        });
+    });
+}
+function isMac() {
+    return os_1.default.type() === 'Darwin';
+}
+function cachePath(folder) {
+    return path_1.default.join(os_1.default.homedir(), '.cache', 'xenon', folder);
+}
+function isWindows() {
+    return os_1.default.type() === 'win32';
+}
+function checkIfPathIsAbsolute(configPath) {
+    return path_1.default.isAbsolute(configPath);
+}
+function getFreePort() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield (0, get_port_1.default)();
+    });
+}
+function nodeUrl(device, basePath = '') {
+    const host = (0, normalize_url_1.default)(device.host, { removeTrailingSlash: false });
+    if (device.cloud) {
+        if (device.cloud.toLowerCase() === Cloud_1.default.PCLOUDY) {
+            return `${host}/wd/hub`;
+        }
+        else if (device.cloud.toLowerCase() === Cloud_1.default.HEADSPIN) {
+            return `${host}`;
+        }
+        else {
+            return `https://${process.env.CLOUD_USERNAME}:${process.env.CLOUD_KEY}@${new URL(device.host).host}/wd/hub`;
+        }
+    }
+    // hardcoded the `/wd/hub` for now. This can be fetch from serverArgs.basePath
+    return `${host}${basePath || ''}`;
+}
+function isPortBusy(port) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (!port) {
+                return false;
+            }
+            return yield tcp_port_used_1.default.check(port);
+        }
+        catch (err) {
+            return false;
+        }
+    });
+}
+function hasHubArgument(cliArgs) {
+    return lodash_1.default.has(cliArgs, 'plugin["xenon"].hub');
+}
+function hasCloudArgument(cliArgs) {
+    return lodash_1.default.has(cliArgs, 'plugin["xenon"].cloud');
+}
+// Standard, non-prefixed capabilities (see https://www.w3.org/TR/webdriver/#dfn-table-of-standard-capabilities)
+const STANDARD_CAPS = [
+    'browserName',
+    'browserVersion',
+    'platformName',
+    'acceptInsecureCerts',
+    'pageLoadStrategy',
+    'proxy',
+    'setWindowRect',
+    'timeouts',
+    'unhandledPromptBehavior',
+];
+function isStandardCap(cap) {
+    return !!lodash_1.default.find(STANDARD_CAPS, (standardCap) => standardCap.toLowerCase() === `${cap}`.toLowerCase());
+}
+// If the 'appium:' or Xenon prefixes were provided, strip them out (W3C Extension Capabilities)
+// (NOTE: Method is destructive and mutates contents of caps)
+function stripAppiumPrefixes(caps) {
+    const allPrefixes = [APPIUM_VENDOR_PREFIX, ...XENON_PREFIXES];
+    const keys = lodash_1.default.keys(caps);
+    const prefixedCaps = keys.filter((cap) => allPrefixes.some((prefix) => cap.startsWith(prefix)));
+    const nonPrefixedCaps = lodash_1.default.difference(keys, prefixedCaps);
+    // initialize this with the k/v pairs of the non-prefixed caps
+    const strippedCaps = /** @type {import('@appium/types').Capabilities<C>} */ lodash_1.default.pick(caps, nonPrefixedCaps);
+    const badPrefixedCaps = [];
+    // Strip prefixes
+    for (const prefixedCap of prefixedCaps) {
+        const activePrefix = allPrefixes.find((p) => prefixedCap.startsWith(p));
+        const strippedCapName = prefixedCap.substring(activePrefix.length);
+        // If it's standard capability that was prefixed, add it to an array of incorrectly prefixed capabilities
+        if (activePrefix === APPIUM_VENDOR_PREFIX && isStandardCap(strippedCapName)) {
+            badPrefixedCaps.push(strippedCapName);
+            if (lodash_1.default.isNil(strippedCaps[strippedCapName])) {
+                strippedCaps[strippedCapName] = caps[prefixedCap];
+            }
+            else {
+                logger_1.default.warn(`Ignoring capability '${prefixedCap}=${caps[prefixedCap]}' and ` +
+                    `using capability '${strippedCapName}=${strippedCaps[strippedCapName]}'`);
+            }
+        }
+        else {
+            strippedCaps[strippedCapName] = caps[prefixedCap];
+        }
+    }
+    // If we found standard caps that were incorrectly prefixed, throw an exception (e.g.: don't accept 'appium:platformName', only accept just 'platformName')
+    if (badPrefixedCaps.length > 0) {
+        logger_1.default.warn(`The capabilities ${JSON.stringify(badPrefixedCaps)} are standard capabilities and do not require "appium:" prefix`);
+    }
+    return strippedCaps;
+}
+function isXenonRunning(host, tlsRejectUnauthorized) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const client = InternalHttpClient_1.InternalHttpClient.getClient(tlsRejectUnauthorized);
+            yield client.get(`${host}/xenon/api/status`);
+            return true;
+        }
+        catch (error) {
+            logger_1.default.info(`Xenon is not running at ${host}. Error: ${error}`);
+            return false;
+        }
+    });
+}
+function isAppiumRunningAt(url, tlsRejectUnauthorized) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const client = InternalHttpClient_1.InternalHttpClient.getClient(tlsRejectUnauthorized);
+            yield client.get(`${url}/status`);
+            return true;
+        }
+        catch (error) {
+            logger_1.default.info(`Appium is not running at ${url}. Error: ${error}`);
+            return false;
+        }
+    });
+}
+function safeParseJson(jsonString) {
+    try {
+        return JSON.parse(jsonString);
+    }
+    catch (err) {
+        return jsonString;
+    }
+}
+function takeScreenshot(driver) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Use driver's native getScreenshot method
+            const screenshot = yield driver.getScreenshot();
+            if (screenshot && typeof screenshot === 'string') {
+                return screenshot;
+            }
+            logger_1.default.warn('Screenshot did not return expected base64 string');
+            return null;
+        }
+        catch (error) {
+            logger_1.default.error(`Failed to take screenshot: ${error.message}`);
+            return null;
+        }
+    });
+}

package/lib/src/index.js

@@ -0,0 +1,95 @@
+"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 __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) {
+        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.XenonPlugin = void 0;
+require("reflect-metadata");
+const plugin_1 = require("./plugin");
+Object.defineProperty(exports, "XenonPlugin", { enumerable: true, get: function () { return plugin_1.XenonPlugin; } });
+const ffmpeg_1 = require("@ffmpeg-installer/ffmpeg");
+const logger_1 = __importDefault(require("./logger"));
+const typedi_1 = require("typedi");
+// Add FFMPEG to path for appium to record video of the session
+process.env.PATH = process.env.PATH + ':' + ffmpeg_1.path.replace(/ffmpeg$/g, '');
+/**
+ * Global Lifecycle Orchestrator
+ * Ensures that whenever the Appium process is terminated (SIGINT, SIGTERM),
+ * all spawned sidecar processes (go-ios, iproxy, tunnels) are killed.
+ */
+const cleanup = () => __awaiter(void 0, void 0, void 0, function* () {
+    logger_1.default.info('🚀 [Xenon] Shutdown signal received. Performing graceful cleanup...');
+    try {
+        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 { stopAllTimers } = yield Promise.resolve().then(() => __importStar(require('./device-utils')));
+        const { VideoPipelineService } = yield Promise.resolve().then(() => __importStar(require('./services/VideoPipelineService')));
+        // Shutdown all independent MJPEG streams, tunnels, and video recordings
+        stopAllTimers();
+        yield typedi_1.Container.get(IOSStreamService).cleanup();
+        yield typedi_1.Container.get(AndroidStreamService).cleanup();
+        yield typedi_1.Container.get(VideoPipelineService).cleanup();
+        logger_1.default.info('✅ [Xenon] Infrastructure components sanitized. Safe to exit.');
+    }
+    catch (err) {
+        logger_1.default.error(`❌ [Xenon] Cleanup failed: ${err.message}`);
+    }
+    finally {
+        // Principal Delay: Wait 2 seconds before hard-exiting to allow
+        // other async handlers (like hub unregistration) to finish.
+        setTimeout(() => process.exit(0), 2000);
+    }
+});
+process.on('SIGINT', cleanup);
+process.on('SIGTERM', cleanup);
+process.on('unhandledRejection', (reason, promise) => {
+    logger_1.default.error('❌ [Xenon] Unhandled Rejection at:', promise, 'reason:', reason);
+});
+process.on('uncaughtException', (err) => {
+    logger_1.default.error('❌ [Xenon] Uncaught Exception:', err);
+    // Give logger time to flush before exiting
+    setTimeout(() => process.exit(1), 1000);
+});
+exports.default = plugin_1.XenonPlugin;