@xenon-device-management/xenon 1.1.0

package/lib/src/device-managers/android/AndroidStreamService.js

@@ -0,0 +1,370 @@
+"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 });
+const child_process_1 = require("child_process");
+const http_1 = __importDefault(require("http"));
+const logger_1 = __importDefault(require("../../logger"));
+const helpers_1 = require("../../helpers");
+const device_store_1 = require("../../data-service/device-store");
+const device_service_1 = require("../../data-service/device-service");
+const DeviceLockManager_1 = require("./DeviceLockManager");
+const typedi_1 = require("typedi");
+const ResourceIsolationService_1 = require("../../services/ResourceIsolationService");
+// FFmpeg is optional - only used for raw-to-JPEG conversion
+let FFMPEG_PATH = null;
+try {
+    // Dynamic require for optional dependency
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    FFMPEG_PATH = require('@ffmpeg-installer/ffmpeg').path;
+}
+catch (_a) {
+    // ffmpeg not installed - streaming will be unavailable
+}
+let AndroidStreamService = class AndroidStreamService {
+    constructor() {
+        this.sessions = new Map();
+        this.startPromises = new Map();
+        this.startWatchdog();
+    }
+    startWatchdog() {
+        setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            const now = Date.now();
+            for (const [udid, session] of this.sessions.entries()) {
+                if (session.status === 'running') {
+                    if (now - session.lastViewerAt > 600000 && session.viewerCount === 0) {
+                        logger_1.default.info(`[${udid}] Stopping idle stream (No active viewers for 600s)`);
+                        this.stopStream(udid);
+                    }
+                }
+            }
+        }), 3600000);
+    }
+    captureLoop(udid, session) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`[${udid}] Background capture loop started.`);
+            while (session.status === 'running' || session.status === 'starting') {
+                if (session.viewerCount === 0 && session.status === 'running') {
+                    yield new Promise((r) => setTimeout(r, 1000));
+                    continue;
+                }
+                // Respect device interaction lock
+                if (DeviceLockManager_1.deviceLock.isLocked(udid)) {
+                    yield new Promise((r) => setTimeout(r, 150));
+                    continue;
+                }
+                try {
+                    const startTime = Date.now();
+                    // High-Speed Binary Snapshot
+                    const screenshot = yield DeviceLockManager_1.deviceLock.acquire(udid, () => __awaiter(this, void 0, void 0, function* () {
+                        return yield new Promise((resolve, reject) => {
+                            const isolationService = typedi_1.Container.get(ResourceIsolationService_1.ResourceIsolationService);
+                            const { command, args } = isolationService.wrapSpawn('adb', ['-s', udid, 'exec-out', 'screencap'], 'Performance');
+                            const proc = (0, child_process_1.spawn)(command, args);
+                            const chunks = [];
+                            proc.stdout.on('data', (c) => chunks.push(c));
+                            proc.on('close', (code) => {
+                                if (code === 0)
+                                    resolve(Buffer.concat(chunks));
+                                else
+                                    reject(new Error(`ADB Exit ${code}`));
+                            });
+                            proc.on('error', reject);
+                            setTimeout(() => {
+                                proc.kill();
+                                reject(new Error('ADB Timeout (15s)'));
+                            }, 15000);
+                        });
+                    }));
+                    if (screenshot.length > 16) {
+                        const w = screenshot.readInt32LE(0);
+                        const h = screenshot.readInt32LE(4);
+                        const fmt = screenshot.readInt32LE(8);
+                        // Auto-detect header size (16 for modern Android, 12 for legacy)
+                        const headerSize = w * h * 4 + 16 === screenshot.length ? 16 : 12;
+                        const pixels = screenshot.slice(headerSize);
+                        if (pixels.length >= w * h * 4) {
+                            // Sanity check: Extreme small images or weird ratios are often corrupted buffers
+                            if (w < 100 || h < 100 || w > 8000 || h > 8000) {
+                                logger_1.default.debug(`[${udid}] Suspicious frame detected (${w}x${h}). Skipping.`);
+                                continue;
+                            }
+                            const pixFmt = fmt === 1 ? 'rgba' : 'rgb565';
+                            // Optimization: Downscale to 720p maximum width for efficiency
+                            let targetW = w;
+                            let targetH = h;
+                            if (w > 720) {
+                                targetW = 720;
+                                targetH = Math.round((h / w) * targetW);
+                            }
+                            // FFmpeg requires even dimensions for some encoders/filters
+                            if (targetW % 2 !== 0)
+                                targetW--;
+                            if (targetH % 2 !== 0)
+                                targetH--;
+                            session.latestFrame = yield this.convertRawToJpeg(pixels, w, h, targetW, targetH, pixFmt);
+                            if (!session.latestFrameTimestamp) {
+                                logger_1.default.info(`[${udid}] First Android frame successfully captured and converted.`);
+                            }
+                            session.latestFrameTimestamp = Date.now();
+                        }
+                    }
+                    else {
+                        logger_1.default.warn(`[${udid}] Received empty or tiny screenshot (${screenshot.length} bytes). Is the screen 'flag_secure'?`);
+                    }
+                    const elapsed = Date.now() - startTime;
+                    const delay = Math.max(5, 70 - elapsed); // Target ~14 FPS
+                    yield new Promise((r) => setTimeout(r, delay));
+                }
+                catch (e) {
+                    logger_1.default.debug(`[${udid}] Capture failure: ${e.message}`);
+                    yield new Promise((r) => setTimeout(r, 1000));
+                }
+            }
+            logger_1.default.info(`[${udid}] Background capture loop stopped.`);
+        });
+    }
+    startStream(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.startPromises.has(udid))
+                return this.startPromises.get(udid);
+            const performStartup = () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const existing = this.sessions.get(udid);
+                    if (existing && (existing.status === 'running' || existing.status === 'starting')) {
+                        return { mjpegPort: existing.mjpegPort };
+                    }
+                    const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+                    if (!device)
+                        throw new Error(`Device ${udid} not found in DB`);
+                    const mjpegPort = yield (0, helpers_1.getFreePort)();
+                    // Aggressive cleanup: Kill any process already using this port
+                    try {
+                        const { exec } = require('child_process');
+                        const { promisify } = require('util');
+                        const execPromise = promisify(exec);
+                        const { stdout } = yield execPromise(`lsof -ti :${mjpegPort}`);
+                        const pids = stdout.trim().split('\n');
+                        for (const pid of pids) {
+                            if (pid) {
+                                logger_1.default.debug(`[${udid}] Killing stale process ${pid} on port ${mjpegPort}`);
+                                yield execPromise(`kill -9 ${pid}`);
+                            }
+                        }
+                    }
+                    catch (e) {
+                        /* ignore */
+                    }
+                    const session = {
+                        udid,
+                        mjpegPort,
+                        server: null,
+                        status: 'starting',
+                        lastViewerAt: Date.now(),
+                        viewerCount: 0,
+                    };
+                    this.sessions.set(udid, session);
+                    session.server = http_1.default.createServer((req, res) => {
+                        session.viewerCount++;
+                        session.lastViewerAt = Date.now();
+                        res.writeHead(200, {
+                            'Content-Type': 'multipart/x-mixed-replace; boundary="BoundaryString"',
+                            'Cache-Control': 'no-cache',
+                            Connection: 'close',
+                            Pragma: 'no-cache',
+                        });
+                        const lastFrameTime = 0;
+                        const writeFrame = () => __awaiter(this, void 0, void 0, function* () {
+                            // Principle: Handle both starting and running states to avoid race conditions
+                            if (session.status === 'stopped' ||
+                                session.status === 'error' ||
+                                res.writableEnded ||
+                                !res.writable)
+                                return;
+                            if (session.latestFrame) {
+                                try {
+                                    res.write('--BoundaryString\r\n');
+                                    res.write('Content-Type: image/jpeg\r\n');
+                                    res.write(`Content-Length: ${session.latestFrame.length}\r\n\r\n`);
+                                    res.write(session.latestFrame);
+                                    res.write('\r\n');
+                                }
+                                catch (e) {
+                                    return; // Stop if socket broke
+                                }
+                            }
+                            setTimeout(writeFrame, 60);
+                        });
+                        writeFrame();
+                        req.on('close', () => {
+                            session.viewerCount = Math.max(0, session.viewerCount - 1);
+                            session.lastViewerAt = Date.now();
+                        });
+                    });
+                    session.server.listen(mjpegPort, '127.0.0.1');
+                    // Principal Resilience: Wait for port to be actually listening
+                    // This prevents FFMPEG race conditions where it tries to connect before the socket is open
+                    const tcpPortUsed = require('tcp-port-used');
+                    try {
+                        yield tcpPortUsed.waitUntilUsed(mjpegPort, 200, 2000);
+                        logger_1.default.info(`[${udid}] MJPEG stream confirmed active on port ${mjpegPort}`);
+                    }
+                    catch (e) {
+                        logger_1.default.warn(`[${udid}] MJPEG port check timed out, proceeding anyway: ${e}`);
+                    }
+                    session.status = 'running';
+                    this.captureLoop(udid, session);
+                    // Principal Resilience: Wait for the FIRST FRAME to be captured
+                    // FFMPEG often fails to "open" the input if there is no data immediately available
+                    const firstFrameStartTime = Date.now();
+                    const firstFrameTimeout = 5000;
+                    let frameCount = 0;
+                    while (Date.now() - firstFrameStartTime < firstFrameTimeout) {
+                        if (session.latestFrame) {
+                            frameCount++;
+                            if (frameCount >= 1)
+                                break; // We have at least one frame ready to serve
+                        }
+                        yield new Promise((r) => setTimeout(r, 200));
+                    }
+                    if (!session.latestFrame) {
+                        logger_1.default.warn(`[${udid}] Stream started but no frames captured after ${firstFrameTimeout}ms. Downstream video might be unstable.`);
+                    }
+                    else {
+                        logger_1.default.info(`[${udid}] MJPEG stream primed with first frame.`);
+                    }
+                    // Update device info in store to ensure other services (like VideoPipeline) can find the port
+                    const updatedDevice = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+                    if (updatedDevice) {
+                        yield device_store_1.DeviceStoreFactory.getStore().updateDevice(udid, updatedDevice.host, {
+                            mjpegServerPort: mjpegPort,
+                        });
+                    }
+                    return { mjpegPort };
+                }
+                catch (error) {
+                    logger_1.default.error(`[${udid}] Stream failed to start: ${error.message}`);
+                    this.stopStream(udid);
+                    throw error;
+                }
+                finally {
+                    this.startPromises.delete(udid);
+                }
+            });
+            const promise = performStartup();
+            this.startPromises.set(udid, promise);
+            return promise;
+        });
+    }
+    stopStream(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const session = this.sessions.get(udid);
+            if (session) {
+                session.status = 'stopped';
+                if (session.server) {
+                    session.server.close();
+                    session.server = null;
+                }
+                // Principal Fix: Only release the device lock if THIS STREAM SERVICE owns it.
+                // If an Appium automation session owns the lock, don't touch it.
+                try {
+                    const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+                    if (device && ((_a = device.session_id) === null || _a === void 0 ? void 0 : _a.startsWith('manual_'))) {
+                        logger_1.default.info(`[${udid}] Stream Stop: Releasing manual control lock.`);
+                        yield (0, device_service_1.unblockDevice)(udid, device.host);
+                    }
+                    else if (device && device.busy) {
+                        logger_1.default.info(`[${udid}] Stream Stop: Device busy with session ${device.session_id}. NOT releasing lock.`);
+                    }
+                }
+                catch (e) {
+                    /* Ignore unblocking failure on stop */
+                }
+                this.sessions.delete(udid);
+                logger_1.default.info(`[${udid}] Stream terminated.`);
+            }
+        });
+    }
+    getStreamStatus(udid) {
+        return this.sessions.get(udid);
+    }
+    updateViewerCount(udid, delta) {
+        const session = this.sessions.get(udid);
+        if (session) {
+            session.viewerCount = Math.max(0, session.viewerCount + delta);
+            session.lastViewerAt = Date.now();
+        }
+    }
+    cleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const udid of this.sessions.keys()) {
+                yield this.stopStream(udid);
+            }
+        });
+    }
+    convertRawToJpeg(pixels, srcW, srcH, dstW, dstH, pixFmt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                if (!FFMPEG_PATH)
+                    return reject(new Error('No FFmpeg on path'));
+                const isolationService = typedi_1.Container.get(ResourceIsolationService_1.ResourceIsolationService);
+                const { command, args } = isolationService.wrapSpawn(FFMPEG_PATH, [
+                    '-f',
+                    'rawvideo',
+                    '-pixel_format',
+                    pixFmt,
+                    '-video_size',
+                    `${srcW}x${srcH}`,
+                    '-i',
+                    'pipe:0',
+                    '-vf',
+                    `scale=${dstW}:-1`,
+                    '-f',
+                    'mjpeg',
+                    '-q:v',
+                    '8', // Goldilocks quality for low lag
+                    '-frames:v',
+                    '1',
+                    'pipe:1',
+                ], 'Performance');
+                const ff = (0, child_process_1.spawn)(command, args);
+                const output = [];
+                ff.stdout.on('data', (d) => output.push(d));
+                ff.on('close', (code) => {
+                    if (code === 0)
+                        resolve(Buffer.concat(output));
+                    else
+                        reject(new Error(`FFmpeg exit ${code}`));
+                });
+                ff.on('error', reject);
+                ff.stdin.write(pixels);
+                ff.stdin.end();
+            });
+        });
+    }
+};
+AndroidStreamService = __decorate([
+    (0, typedi_1.Service)({ name: 'AndroidStreamService' }),
+    __metadata("design:paramtypes", [])
+], AndroidStreamService);
+exports.default = AndroidStreamService;

package/lib/src/device-managers/android/DeviceLockManager.js

@@ -0,0 +1,45 @@
+"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.deviceLock = exports.DeviceLockManager = void 0;
+const async_lock_1 = __importDefault(require("async-lock"));
+const typedi_1 = require("typedi");
+let DeviceLockManager = class DeviceLockManager {
+    constructor() {
+        this.lock = new async_lock_1.default();
+    }
+    acquire(udid, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.lock.acquire(udid, fn);
+        });
+    }
+    isLocked(udid) {
+        return this.lock.isBusy(udid);
+    }
+};
+exports.DeviceLockManager = DeviceLockManager;
+exports.DeviceLockManager = DeviceLockManager = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], DeviceLockManager);
+exports.deviceLock = typedi_1.Container.get(DeviceLockManager);

package/lib/src/device-managers/cloud/CapabilityManager.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Cloud_1 = __importDefault(require("../../enums/Cloud"));
+class CapabilityManager {
+    constructor(capabilities, freeDevice) {
+        this.capabilities = capabilities;
+        this.freeDevice = freeDevice;
+    }
+    getCapability() {
+        if (this.freeDevice.capability) {
+            const entries = Object.entries(this.freeDevice.capability);
+            entries.map(([key, val]) => {
+                this.capabilities.alwaysMatch[`appium:${key}`] = val;
+            });
+        }
+        if (this.freeDevice.cloud.toLowerCase() === Cloud_1.default.PCLOUDY) {
+            this.capabilities.alwaysMatch['appium:pCloudy_ApiKey'] = process.env.CLOUD_KEY;
+            this.capabilities.alwaysMatch['appium:pCloudy_Username'] = process.env.CLOUD_USERNAME;
+        }
+        return this.capabilities;
+    }
+}
+exports.default = CapabilityManager;

package/lib/src/device-managers/cloud/Devices.js

@@ -0,0 +1,86 @@
+"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 });
+/* eslint-disable no-prototype-builtins */
+const Cloud_1 = __importDefault(require("../../enums/Cloud"));
+const CloudSchema_1 = require("../../types/CloudSchema");
+const logger_1 = __importDefault(require("../../logger"));
+const jsonschema_1 = require("jsonschema");
+const uuid_1 = require("uuid");
+class Devices {
+    constructor(cloudArgs, deviceState, platform) {
+        this.devices = cloudArgs.devices;
+        this.deviceState = deviceState;
+        this.platform = platform;
+        this.cloud = cloudArgs;
+        this.validateSchema(CloudSchema_1.defaultSchema);
+    }
+    getDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devicesByPlatform = this.devices.filter((value) => value.platform === this.platform);
+            let cloudDeviceProperties;
+            const result = devicesByPlatform.map((d) => {
+                if (this.isBrowserStack()) {
+                    this.validateSchema(CloudSchema_1.browserStackSchema);
+                    cloudDeviceProperties = {
+                        name: d.deviceName,
+                        sdk: d['os_version'],
+                    };
+                }
+                if (this.isSauceLabs() || this.isLambdaTest() || this.isHeadSpin()) {
+                    this.validateSchema(CloudSchema_1.sauceOrLambdaSchema);
+                    cloudDeviceProperties = {
+                        name: d.deviceName,
+                        sdk: d.platformVersion,
+                    };
+                }
+                if (this.isPCloudy()) {
+                    this.validateSchema(CloudSchema_1.pCloudySchema);
+                    cloudDeviceProperties = {
+                        name: (d === null || d === void 0 ? void 0 : d.pCloudy_DeviceFullName) || (d === null || d === void 0 ? void 0 : d.pCloudy_DeviceManufacturer),
+                        sdk: (d === null || d === void 0 ? void 0 : d.pCloudy_DeviceVersion) || (d === null || d === void 0 ? void 0 : d.platformVersion),
+                    };
+                }
+                return Object.assign({}, ...devicesByPlatform, Object.assign({ host: this.cloud.url, busy: false, udid: (0, uuid_1.v4)(), userBlocked: false, deviceType: 'real', capability: d, cloud: this.cloud.cloudName }, cloudDeviceProperties));
+            });
+            this.deviceState.push(...result);
+            return this.deviceState;
+        });
+    }
+    validateSchema(schema) {
+        const v = new jsonschema_1.Validator();
+        const validationResult = v.validate(this.cloud, schema);
+        if (validationResult.errors.length) {
+            throw new Error(`🔴 Invalid server config ${validationResult.errors} 🔴`);
+        }
+        else
+            logger_1.default.info('Loading devices from server config');
+    }
+    isBrowserStack() {
+        return this.cloud.cloudName.toLowerCase() === Cloud_1.default.BROWSERSTACK;
+    }
+    isPCloudy() {
+        return this.cloud.cloudName.toLowerCase() === Cloud_1.default.PCLOUDY;
+    }
+    isLambdaTest() {
+        return this.cloud.cloudName.toLowerCase() === Cloud_1.default.LAMBDATEST;
+    }
+    isSauceLabs() {
+        return this.cloud.cloudName.toLowerCase() === Cloud_1.default.SAUCELABS;
+    }
+    isHeadSpin() {
+        return this.cloud.cloudName.toLowerCase() === Cloud_1.default.HEADSPIN;
+    }
+}
+exports.default = Devices;

package/lib/src/device-managers/iOSTracker.js

@@ -0,0 +1,44 @@
+"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.IosTracker = void 0;
+const usbmux_1 = __importDefault(require("usbmux"));
+const typedi_1 = require("typedi");
+let IosTracker = class IosTracker {
+    constructor() {
+        this.listener = new usbmux_1.default.createListener();
+    }
+    getListener() {
+        return this.listener;
+    }
+    stop() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.listener.end();
+        });
+    }
+};
+exports.IosTracker = IosTracker;
+exports.IosTracker = IosTracker = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], IosTracker);

package/lib/src/device-managers/index.js

@@ -0,0 +1,89 @@
+"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.XenonManager = void 0;
+const AndroidDeviceManager_1 = __importDefault(require("./AndroidDeviceManager"));
+const IOSDeviceManager_1 = __importDefault(require("./IOSDeviceManager"));
+const logger_1 = __importDefault(require("../logger"));
+const typedi_1 = require("typedi");
+const PluginContext_1 = require("../PluginContext");
+let XenonManager = class XenonManager {
+    constructor(context) {
+        this.context = context;
+        this.log = logger_1.default.scope('XenonManager');
+        this.deviceManagers = [];
+    }
+    /**
+     * Initializes the managers based on the platform requested.
+     * This allows for lazy initialization after the PluginContext is ready.
+     */
+    init() {
+        this.deviceManagers = [];
+        const platform = this.context.pluginArgs.platform.toLowerCase();
+        if (platform === 'both') {
+            this.deviceManagers.push(typedi_1.Container.get(AndroidDeviceManager_1.default));
+            this.deviceManagers.push(typedi_1.Container.get(IOSDeviceManager_1.default));
+        }
+        else if (platform === 'android') {
+            this.deviceManagers.push(typedi_1.Container.get(AndroidDeviceManager_1.default));
+        }
+        else if (platform === 'ios') {
+            this.deviceManagers.push(typedi_1.Container.get(IOSDeviceManager_1.default));
+        }
+        this.log.info(`Initialized with ${this.deviceManagers.length} device managers`);
+    }
+    getDevices(existingDeviceDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = [];
+            // Auto-init if not already done
+            if (this.deviceManagers.length === 0) {
+                this.init();
+            }
+            for (const deviceManager of this.deviceManagers) {
+                devices.push(...(yield deviceManager.getDevices({
+                    androidDeviceType: this.context.pluginArgs.androidDeviceType,
+                    iosDeviceType: this.context.pluginArgs.iosDeviceType,
+                }, existingDeviceDetails || [])).map((device) => {
+                    return Object.assign(Object.assign({}, device), { nodeId: !device.cloud ? this.context.nodeId : undefined });
+                }));
+            }
+            return devices;
+        });
+    }
+    getMaxSessionCount() {
+        return this.context.pluginArgs.maxSessions;
+    }
+    deviceInstances() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.deviceManagers.length === 0) {
+                this.init();
+            }
+            return this.deviceManagers;
+        });
+    }
+};
+exports.XenonManager = XenonManager;
+exports.XenonManager = XenonManager = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [PluginContext_1.PluginContext])
+], XenonManager);