@xenon-device-management/xenon 1.1.0

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

@@ -0,0 +1,68 @@
+"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 ChromeDriverManager_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+const chromeUtils_1 = require("../chromeUtils");
+const appium_chromedriver_1 = require("appium-chromedriver");
+const typedi_1 = require("typedi");
+let ChromeDriverManager = ChromeDriverManager_1 = class ChromeDriverManager {
+    constructor(client, osInfo, mapping, tempDirectory) {
+        this.client = client;
+        this.osInfo = osInfo;
+        this.mapping = mapping;
+        this.tempDirectory = tempDirectory;
+    }
+    static create() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const shouldParseNotes = true;
+            const tmpRoot = (0, chromeUtils_1.getModuleRoot)();
+            const osInfo = yield (0, chromeUtils_1.getOsInfo)();
+            const client = new appium_chromedriver_1.ChromedriverStorageClient({
+                chromedriverDir: yield (0, chromeUtils_1.getChromedriverBinaryPath)(tmpRoot),
+            });
+            const mapping = yield client.retrieveMapping(shouldParseNotes);
+            return new ChromeDriverManager_1(client, osInfo, mapping, tmpRoot);
+        });
+    }
+    downloadChromeDriver(version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const osInfo1 = this.osInfo;
+            const synchronizedDrivers = yield this.client.syncDrivers({
+                osInfo1,
+                minBrowserVersion: [yield (0, chromeUtils_1.formatCdVersion)(version)],
+            });
+            const synchronizedDriversMapping = synchronizedDrivers.reduce((acc, x) => {
+                const { version, minBrowserVersion } = this.mapping[x];
+                acc[version] = minBrowserVersion;
+                return acc;
+            }, {});
+            const versions = Object.keys(synchronizedDriversMapping);
+            const fallBackVersion = `v${versions[versions.length - 1]}`;
+            const newVersion = Object.keys(synchronizedDriversMapping).find((k) => synchronizedDriversMapping[k] === version);
+            const latestVersion = newVersion !== null && newVersion !== undefined ? `v${newVersion}` : `v${fallBackVersion}`;
+            return `${yield (0, chromeUtils_1.getChromedriverBinaryPath)(this.tempDirectory)}/chromedriver_${this.osInfo.name}${this.osInfo.arch}_${latestVersion}`;
+        });
+    }
+};
+ChromeDriverManager = ChromeDriverManager_1 = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], ChromeDriverManager);
+exports.default = ChromeDriverManager;

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

@@ -0,0 +1,325 @@
+"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 __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.HealthMonitorService = void 0;
+const typedi_1 = require("typedi");
+const index_1 = require("./index");
+const device_store_1 = require("../data-service/device-store");
+const logger_1 = __importDefault(require("../logger"));
+const schedule = __importStar(require("node-schedule"));
+const web_config_service_1 = require("../data-service/web-config-service");
+const SessionManager_1 = require("../sessions/SessionManager");
+const EventBus_1 = require("../services/EventBus");
+let HealthMonitorService = class HealthMonitorService {
+    constructor(webConfigService) {
+        this.webConfigService = webConfigService;
+        this.log = logger_1.default.scope('HealthMonitor');
+        this.recoveringDevices = new Set();
+        this.lastWebConfig = {};
+        this.healthHistory = new Map();
+    }
+    start(pluginArgs) {
+        this.pluginArgs = pluginArgs;
+        this.stop();
+        // Do NOT run checkAllDevices immediately on startup.
+        // Devices are freshly discovered and presumed healthy.
+        // The first check will fire after the configured interval (default: 24h).
+        this.setupMonitor(pluginArgs, false);
+        // Delay config polling to avoid restarting the monitor during startup
+        this.configPollInterval = setInterval(() => this.pollWebConfig(), 60000); // Poll every minute
+    }
+    pollWebConfig() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const webConfig = yield this.webConfigService.getConfig();
+                // Merge web config with plugin args to get current effective settings
+                const currentEffectiveArgs = Object.assign(Object.assign({}, this.pluginArgs), webConfig);
+                // Check if interval-related settings actually changed
+                const lastEffectiveArgs = Object.assign(Object.assign({}, this.pluginArgs), this.lastWebConfig);
+                const hasChanged = currentEffectiveArgs.healthCheckIntervalMs !== lastEffectiveArgs.healthCheckIntervalMs ||
+                    currentEffectiveArgs.healthCheckSchedule !== lastEffectiveArgs.healthCheckSchedule;
+                if (hasChanged) {
+                    this.log.info('Detected health check configuration changes, restarting monitor...');
+                    this.setupMonitor(currentEffectiveArgs, false); // Don't run immediately on config refresh
+                }
+                this.lastWebConfig = webConfig;
+            }
+            catch (err) {
+                this.log.error(`Failed to poll web config: ${err.message}`);
+            }
+        });
+    }
+    setupMonitor(args, runImmediately = true) {
+        const intervalMs = args.healthCheckIntervalMs || 86400000;
+        const scheduleStr = args.healthCheckSchedule;
+        if (this.interval)
+            clearInterval(this.interval);
+        if (this.job)
+            this.job.cancel();
+        if (scheduleStr) {
+            this.log.info(`Scheduling Health Monitor (Cron: ${scheduleStr})`);
+            this.job = schedule.scheduleJob(scheduleStr, () => this.checkAllDevices());
+        }
+        else {
+            this.log.info(`Starting Health Monitor Service (Interval: ${intervalMs}ms)`);
+            this.interval = setInterval(() => this.checkAllDevices(), intervalMs);
+        }
+        if (runImmediately) {
+            this.checkAllDevices();
+        }
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+        if (this.job) {
+            this.job.cancel();
+            this.job = undefined;
+        }
+        if (this.configPollInterval) {
+            clearInterval(this.configPollInterval);
+            this.configPollInterval = undefined;
+        }
+    }
+    checkAllDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const store = device_store_1.DeviceStoreFactory.getStore();
+                const devices = yield store.getAllDevices();
+                const manager = typedi_1.Container.get(index_1.XenonManager);
+                const instances = yield manager.deviceInstances();
+                for (const device of devices) {
+                    // Only check devices managed by this node
+                    if (device.cloud)
+                        continue;
+                    // Principal Intelligence: Health monitor must detect "Zombie Busy" devices.
+                    // A device is a Zombie if it's marked busy in DB but NOT found in Hub's session map
+                    // AND not currently streaming to a manual viewer.
+                    if (device.busy) {
+                        const hasActiveSession = SessionManager_1.SESSION_MANAGER.isValidSession(device.session_id || '');
+                        const isManualStream = (_a = device.session_id) === null || _a === void 0 ? void 0 : _a.startsWith('manual_');
+                        // NEW: Check for active manual streams (dashboard viewers)
+                        let hasActiveManualStream = false;
+                        try {
+                            if (['ios', 'tvos'].includes(device.platform)) {
+                                yield Promise.resolve().then(() => __importStar(require('./ios/IOSStreamService')));
+                                const iosStream = typedi_1.Container.get('IOSStreamService');
+                                const streamStatus = iosStream.getStreamStatus(device.udid);
+                                hasActiveManualStream = !!(streamStatus &&
+                                    (streamStatus.status === 'running' || streamStatus.status === 'starting'));
+                            }
+                            else if (device.platform === 'android') {
+                                yield Promise.resolve().then(() => __importStar(require('./android/AndroidStreamService')));
+                                const androidStream = typedi_1.Container.get('AndroidStreamService');
+                                const streamStatus = androidStream.getStreamStatus(device.udid);
+                                hasActiveManualStream = !!(streamStatus &&
+                                    (streamStatus.status === 'running' || streamStatus.status === 'starting'));
+                            }
+                        }
+                        catch (e) {
+                            /* Stream service not available */
+                        }
+                        if (hasActiveSession || hasActiveManualStream || isManualStream) {
+                            logger_1.default.debug(`[HealthMonitor] Skipping check for busy device ${device.udid} (Active: Session=${!!hasActiveSession}, Manual=${isManualStream}, Stream=${hasActiveManualStream})`);
+                            continue;
+                        }
+                        else {
+                            this.log.info(`[HealthMonitor] 🧟 Zombie busy device detected ${device.udid}. Last session ${device.session_id} is not in memory and no manual stream found. Proceeding with health check.`);
+                        }
+                    }
+                    const deviceManager = instances.find((inst) => {
+                        if (device.platform === 'android')
+                            return inst.constructor.name === 'AndroidDeviceManager';
+                        if (['ios', 'tvos'].includes(device.platform))
+                            return inst.constructor.name === 'IOSDeviceManager';
+                        return false;
+                    });
+                    if (deviceManager && deviceManager.checkHealth) {
+                        try {
+                            const health = yield deviceManager.checkHealth(device);
+                            const updateData = Object.assign(Object.assign({}, health), { lastHealthCheckAt: Date.now() });
+                            // Principal Fix: If this was a zombie busy device, reset its busy status
+                            // so it can be recovered and utilized again.
+                            // Double-check: Must NOT be an active session AND NOT an active stream/manual control
+                            const hasSessionNow = SessionManager_1.SESSION_MANAGER.isValidSession(device.session_id || '');
+                            const isManualNow = (_b = device.session_id) === null || _b === void 0 ? void 0 : _b.startsWith('manual_');
+                            if (device.busy && !hasSessionNow && !isManualNow) {
+                                // Re-check stream status immediately before reclaiming
+                                let hasStreamNow = false;
+                                try {
+                                    if (['ios', 'tvos'].includes(device.platform)) {
+                                        hasStreamNow = !!typedi_1.Container.get('IOSStreamService').getStreamStatus(device.udid);
+                                    }
+                                    else if (device.platform === 'android') {
+                                        hasStreamNow = !!typedi_1.Container.get('AndroidStreamService').getStreamStatus(device.udid);
+                                    }
+                                }
+                                catch (e) {
+                                    /* ignore */
+                                }
+                                if (!hasStreamNow) {
+                                    this.log.info(`[HealthMonitor] Reclaiming zombie device ${device.udid}`);
+                                    updateData.busy = false;
+                                    updateData.session_id = undefined;
+                                }
+                                else {
+                                    this.log.debug(`[HealthMonitor] Cancelled reclamation for ${device.udid} - stream appeared.`);
+                                    continue;
+                                }
+                            }
+                            yield store.updateDevice(device.udid, device.host, updateData);
+                            // Principal Intelligence: Predictive Failure Analysis
+                            // Track trends and emit anomalies before they become critical failures.
+                            this.trackAndAnalyzeAnomaly(device, health);
+                            if (health.healthStatus !== 'Healthy') {
+                                this.log.warn(`Device ${device.udid} is UNHEALTHY: ${health.healthCheckError}`);
+                                const key = `${device.udid}-${device.host}`;
+                                if (!this.recoveringDevices.has(key)) {
+                                    this.recoveringDevices.add(key);
+                                    this.log.info(`🛠️ Triggering background recovery for ${device.udid}...`);
+                                    // Fire and forget recovery to not block the monitor loop
+                                    if (deviceManager.recoverHealth) {
+                                        deviceManager
+                                            .recoverHealth(device)
+                                            .then((success) => {
+                                            if (success) {
+                                                this.log.info(`✅ Recovery successful for ${device.udid}`);
+                                            }
+                                            else {
+                                                this.log.error(`❌ Recovery failed for ${device.udid}`);
+                                            }
+                                            this.recoveringDevices.delete(key);
+                                        })
+                                            .catch((e) => {
+                                            this.log.error(`Critical error during recovery for ${device.udid}: ${e.message}`);
+                                            this.recoveringDevices.delete(key);
+                                        });
+                                    }
+                                    else {
+                                        this.log.warn(`No recovery method implemented for ${device.udid}`);
+                                        this.recoveringDevices.delete(key);
+                                    }
+                                }
+                            }
+                        }
+                        catch (err) {
+                            this.log.error(`Health check failed for ${device.udid}: ${err.message}`);
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                this.log.error(`Global health check loop failed: ${err.message}`);
+            }
+        });
+    }
+    /**
+     * Predictive Intelligence: Analyzes health trends to detect anomalies.
+     * Emits 'device:anomaly' event if a potential failure is predicted.
+     */
+    trackAndAnalyzeAnomaly(device, currentHealth) {
+        const key = `${device.udid}-${device.host}`;
+        const history = this.healthHistory.get(key) || [];
+        // Add current entry to history
+        history.push({
+            time: Date.now(),
+            battery: currentHealth.batteryLevel,
+            thermal: currentHealth.thermalStatus,
+        });
+        // Keep last 10 entries (~5 minutes if checking every 30s)
+        if (history.length > 10)
+            history.shift();
+        this.healthHistory.set(key, history);
+        if (history.length < 2)
+            return;
+        const previous = history[history.length - 2];
+        const current = history[history.length - 1];
+        // 1. Thermal Anomaly: Normal -> Hot or Hot -> Critical
+        if (previous.thermal !== current.thermal && current.thermal !== 'Normal') {
+            this.log.warn(`⚠️ [Anomaly] Thermal spike detected on ${device.udid}: ${previous.thermal} -> ${current.thermal}`);
+            EventBus_1.EVENT_BUS.emit('device:anomaly', {
+                udid: device.udid,
+                host: device.host,
+                type: 'thermal_spike',
+                previous: previous.thermal,
+                current: current.thermal,
+                severity: current.thermal === 'Critical' ? 'high' : 'medium',
+            });
+        }
+        // 2. Battery Anomaly: Rapid drain (>5% since last check)
+        if (previous.battery !== undefined && current.battery !== undefined) {
+            const drain = previous.battery - current.battery;
+            if (drain >= 5) {
+                this.log.warn(`⚠️ [Anomaly] Rapid battery drain on ${device.udid}: -${drain}% since last check`);
+                EventBus_1.EVENT_BUS.emit('device:anomaly', {
+                    udid: device.udid,
+                    host: device.host,
+                    type: 'battery_drain',
+                    drainValue: drain,
+                    currentLevel: current.battery,
+                    severity: current.battery < 20 ? 'high' : 'medium',
+                });
+            }
+        }
+    }
+};
+exports.HealthMonitorService = HealthMonitorService;
+exports.HealthMonitorService = HealthMonitorService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [web_config_service_1.WebConfigService])
+], HealthMonitorService);