@xenon-device-management/xenon 1.1.0

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

@@ -0,0 +1,351 @@
+"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 node_simctl_1 = __importDefault(require("node-simctl"));
+const lodash_1 = require("lodash");
+const logger_1 = __importDefault(require("../logger"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const typedi_1 = require("typedi");
+const device_store_1 = require("../data-service/device-store");
+const PluginContext_1 = require("../PluginContext");
+const IOSStreamService_1 = __importDefault(require("./ios/IOSStreamService"));
+const IOSDiscoveryService_1 = require("./ios/IOSDiscoveryService");
+const WDAClient_1 = require("./ios/WDAClient");
+const execPromise = (0, util_1.promisify)(child_process_1.exec);
+let IOSDeviceManager = class IOSDeviceManager {
+    constructor(context) {
+        this.context = context;
+        this.log = logger_1.default.scope('IOSManager');
+        this.wdaSoftFailures = new Map();
+        this.WDA_SOFT_FAIL_MAX = 3;
+        if (process.env.NODE_ENV !== 'test') {
+            typedi_1.Container.get(WDAClient_1.WDAClient)
+                .checkRequirements()
+                .catch((e) => {
+                this.log.error(`Failed to verify ideviceinstaller requirements: ${e.message}`);
+            });
+        }
+    }
+    get pluginArgs() {
+        return this.context.pluginArgs;
+    }
+    getDevices(deviceTypes, existingDeviceDetails) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(IOSDiscoveryService_1.IOSDiscoveryService).getDevices(deviceTypes, existingDeviceDetails);
+        });
+    }
+    getConnectedDevices() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(IOSDiscoveryService_1.IOSDiscoveryService).getConnectedDevices();
+        });
+    }
+    getOSVersion(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield typedi_1.Container.get(IOSDiscoveryService_1.IOSDiscoveryService).getDeviceInfo(udid);
+            return device.sdk;
+        });
+    }
+    getDeviceName(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield typedi_1.Container.get(IOSDiscoveryService_1.IOSDiscoveryService).getDeviceInfo(udid);
+            return device.name || 'iPhone';
+        });
+    }
+    // Shims for legacy unit tests
+    getSimulators() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(IOSDiscoveryService_1.IOSDiscoveryService).getSimulators();
+        });
+    }
+    getLocalSims() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(IOSDiscoveryService_1.IOSDiscoveryService).fetchLocalSimulators();
+        });
+    }
+    getAdditionalDeviceInfo(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log.info(`Fetching additional iOS device info for ${device.udid}`);
+            const result = {
+                derivedDataPath: this.prepareDerivedDataPath(this.pluginArgs.derivedDataPath, device.udid, device.realDevice),
+            };
+            const streamStatus = typedi_1.Container.get(IOSStreamService_1.default).getStreamStatus(device.udid);
+            if ((streamStatus === null || streamStatus === void 0 ? void 0 : streamStatus.screenWidth) && (streamStatus === null || streamStatus === void 0 ? void 0 : streamStatus.screenHeight)) {
+                result.screenWidth = String(streamStatus.screenWidth);
+                result.screenHeight = String(streamStatus.screenHeight);
+            }
+            else {
+                const storeDevice = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid: device.udid });
+                if (storeDevice === null || storeDevice === void 0 ? void 0 : storeDevice.screenWidth) {
+                    result.screenWidth = storeDevice.screenWidth;
+                    result.screenHeight = storeDevice.screenHeight;
+                }
+            }
+            return result;
+        });
+    }
+    prepareDerivedDataPath(derivedDataPath, udid, realDevice) {
+        const tmpPath = path_1.default.join(os_1.default.homedir(), `Library/Developer/Xcode/DerivedData/WebDriverAgent-${udid}`);
+        if (derivedDataPath) {
+            const source = realDevice ? derivedDataPath.device : derivedDataPath.simulator;
+            if (source)
+                fs_extra_1.default.copySync(source, tmpPath);
+            else if (!fs_extra_1.default.existsSync(tmpPath))
+                fs_extra_1.default.mkdirSync(tmpPath, { recursive: true });
+            return tmpPath;
+        }
+        return tmpPath;
+    }
+    // WDA Interactions - Delegated to WDAClient
+    tap(udid, x, y) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).tap(udid, x, y);
+        });
+    }
+    swipe(udid, x, y, endX, endY, duration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).swipe(udid, x, y, endX, endY, duration);
+        });
+    }
+    typeText(udid, text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).typeText(udid, text);
+        });
+    }
+    pressKey(udid, keyCode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).pressKey(udid, keyCode);
+        });
+    }
+    getScreenshot(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).getScreenshot(udid);
+        });
+    }
+    getClipboard(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).getClipboard(udid);
+        });
+    }
+    setClipboard(udid, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).setClipboard(udid, content);
+        });
+    }
+    lock(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).lock(udid);
+        });
+    }
+    unlock(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).unlock(udid);
+        });
+    }
+    installApp(udid, appPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).installApp(udid, appPath);
+        });
+    }
+    uninstallApp(udid, bundleId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).uninstallApp(udid, bundleId);
+        });
+    }
+    listApps(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).listApps(udid);
+        });
+    }
+    getLogs(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).getLogs(udid);
+        });
+    }
+    getPageSource(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            this.log.info(`iOS getPageSource on ${udid}`);
+            try {
+                const res = yield typedi_1.Container.get(WDAClient_1.WDAClient).sendWDACommand(udid, 'get', '/source');
+                return ((_a = res === null || res === void 0 ? void 0 : res.data) === null || _a === void 0 ? void 0 : _a.value) || '';
+            }
+            catch (e) {
+                this.log.error(`Failed to get iOS page source for ${udid}: ${e.message}`);
+                return '';
+            }
+        });
+    }
+    checkHealth(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (device.cloud)
+                return { healthStatus: 'Healthy' };
+            try {
+                if (device.realDevice) {
+                    // Collect hardware stats via WDAClient (which uses go-ios if available)
+                    // For simplicity, we'll keep some health check logic here but use the client for WDA status
+                    const isReady = yield typedi_1.Container.get(WDAClient_1.WDAClient).verifyWDAStatus(device.udid);
+                    if (isReady)
+                        return { healthStatus: 'Healthy' };
+                    // Principal Intelligence: If the device is IDLE (not busy) and WDA is down,
+                    // check if this is expected (e.g. watchdog stopped the stream).
+                    if (!device.busy) {
+                        const streamService = typedi_1.Container.get(IOSStreamService_1.default);
+                        const streamStatus = streamService.getStreamStatus(device.udid);
+                        if (!streamStatus ||
+                            (streamStatus.status !== 'running' && streamStatus.status !== 'starting')) {
+                            return { healthStatus: 'Healthy', healthCheckError: 'Idle (WDA Stopped)' };
+                        }
+                    }
+                    return { healthStatus: 'Unhealthy', healthCheckError: 'WDA not responding' };
+                }
+                else {
+                    const simctl = new node_simctl_1.default();
+                    const list = yield simctl.list();
+                    const sim = (0, lodash_1.flatten)(Object.values(list.devices)).find((s) => s.udid === device.udid);
+                    return sim && ['Booted', 'Shutdown'].includes(sim.state)
+                        ? { healthStatus: 'Healthy' }
+                        : { healthStatus: 'Unhealthy', healthCheckError: `Simulator state: ${sim === null || sim === void 0 ? void 0 : sim.state}` };
+                }
+            }
+            catch (err) {
+                return { healthStatus: 'Unhealthy', healthCheckError: err.message };
+            }
+        });
+    }
+    readyForSession(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (device.cloud)
+                return true;
+            this.log.info(`🚀 [SessionStart] Verifying readiness for ${device.udid}...`);
+            const streamService = typedi_1.Container.get(IOSStreamService_1.default);
+            const streamStatus = streamService.getStreamStatus(device.udid);
+            if ((streamStatus === null || streamStatus === void 0 ? void 0 : streamStatus.status) === 'starting') {
+                const start = Date.now();
+                while (Date.now() - start < 30000) {
+                    if (((_a = streamService.getStreamStatus(device.udid)) === null || _a === void 0 ? void 0 : _a.status) === 'running')
+                        return true;
+                    yield new Promise((r) => setTimeout(r, 2000));
+                }
+            }
+            let healthy = yield typedi_1.Container.get(WDAClient_1.WDAClient).verifyWDAStatus(device.udid);
+            if (!healthy) {
+                this.log.warn(`⚠️ [SessionStart] ${device.udid} is UNHEALTHY. Recovering...`);
+                if (yield this.recoverHealth(device)) {
+                    const start = Date.now();
+                    while (Date.now() - start < 15000) {
+                        healthy = yield typedi_1.Container.get(WDAClient_1.WDAClient).verifyWDAStatus(device.udid);
+                        if (healthy)
+                            break;
+                        yield new Promise((r) => setTimeout(r, 2000));
+                    }
+                }
+            }
+            return healthy;
+        });
+    }
+    recoverHealth(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (device.cloud)
+                return true;
+            try {
+                if (device.realDevice) {
+                    if (device.busy && device.session_id)
+                        return false;
+                    const streamService = typedi_1.Container.get(IOSStreamService_1.default);
+                    const streamStatus = streamService.getStreamStatus(device.udid);
+                    // If the stream process is alive, check whether WDA is actually responding.
+                    // A running stream with an unresponsive WDA creates an infinite unhealthy loop
+                    // if we blindly skip recovery.
+                    if (streamStatus &&
+                        (streamStatus.status === 'starting' || streamStatus.status === 'running')) {
+                        // If still starting, give it more time
+                        if (streamStatus.status === 'starting') {
+                            this.log.debug(`[${device.udid}] Stream is starting, waiting for WDA to come up`);
+                            return true;
+                        }
+                        // Stream is running — verify WDA health
+                        const wdaOk = yield typedi_1.Container.get(WDAClient_1.WDAClient).verifyWDAStatus(device.udid);
+                        if (wdaOk) {
+                            this.log.debug(`[${device.udid}] Stream running and WDA healthy, no recovery needed`);
+                            this.wdaSoftFailures.delete(device.udid);
+                            return true;
+                        }
+                        // WDA is down despite stream running. Use soft-failure counter to avoid
+                        // thrashing restarts on transient hiccups.
+                        const failCount = (this.wdaSoftFailures.get(device.udid) || 0) + 1;
+                        this.wdaSoftFailures.set(device.udid, failCount);
+                        if (failCount < this.WDA_SOFT_FAIL_MAX) {
+                            this.log.debug(`[${device.udid}] WDA unresponsive (soft fail ${failCount}/${this.WDA_SOFT_FAIL_MAX}), deferring restart`);
+                            return false; // Report failure so HealthMonitor doesn't claim success
+                        }
+                        // Exceeded threshold — force restart
+                        this.log.warn(`[${device.udid}] WDA unresponsive after ${failCount} checks. Force-restarting stream...`);
+                        this.wdaSoftFailures.delete(device.udid);
+                        try {
+                            yield streamService.stopStream(device.udid);
+                        }
+                        catch (e) {
+                            this.log.debug(`[${device.udid}] Error stopping stream: ${e.message}`);
+                        }
+                        yield new Promise((r) => setTimeout(r, 2000));
+                    }
+                    this.log.info(`🛡️ Auto-recovery for iOS device ${device.udid}...`);
+                    yield streamService.startStream(device.udid);
+                    return true;
+                }
+                else {
+                    const simctl = new node_simctl_1.default();
+                    simctl.udid = device.udid;
+                    try {
+                        yield simctl.shutdownDevice();
+                        yield new Promise((r) => setTimeout(r, 2000));
+                    }
+                    catch (e) {
+                        this.log.error('IOSDeviceManager: Error shutting down iOS device', e);
+                    }
+                    yield simctl.bootDevice();
+                    return true;
+                }
+            }
+            catch (err) {
+                this.log.error(`Auto-recovery failed for ${device.udid}: ${err.message}`);
+                return false;
+            }
+        });
+    }
+    executeShell(udid, command) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return typedi_1.Container.get(WDAClient_1.WDAClient).executeShell(udid, command);
+        });
+    }
+};
+IOSDeviceManager = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [PluginContext_1.PluginContext])
+], IOSDeviceManager);
+exports.default = IOSDeviceManager;

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

@@ -0,0 +1,82 @@
+"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 });
+const logger_1 = __importDefault(require("../logger"));
+const InternalHttpClient_1 = require("../InternalHttpClient");
+class NodeDevices {
+    constructor(host, tlsRejectUnauthorized) {
+        this.host = host;
+        this.tlsRejectUnauthorized = tlsRejectUnauthorized;
+    }
+    postDevicesToHub(devices, arg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // DeviceWithPath -> new device
+            // DeviceUpdate -> removed device
+            logger_1.default.info(`Updating remote android devices ${this.host}/xenon/api/register`);
+            try {
+                const client = InternalHttpClient_1.InternalHttpClient.getClient(this.tlsRejectUnauthorized);
+                yield client.post(`${this.host}/xenon/api/register`, devices, {
+                    params: {
+                        type: arg,
+                    },
+                });
+                if (arg === 'add') {
+                    logger_1.default.info(`Pushed devices to hub ${JSON.stringify(devices)}`);
+                }
+                else {
+                    logger_1.default.info(`Removed device and pushed information to hub ${JSON.stringify(devices)}`);
+                }
+            }
+            catch (error) {
+                logger_1.default.error(`Unable to push devices update to hub. Reason: ${error}`);
+            }
+        });
+    }
+    unblockDevice(filter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Unblocking device ${this.host}/xenon/api/unblock`);
+            try {
+                const client = InternalHttpClient_1.InternalHttpClient.getClient(this.tlsRejectUnauthorized);
+                yield client.post(`${this.host}/xenon/api/unblock`, filter, {
+                    params: {
+                        type: 'unblock',
+                    },
+                });
+                logger_1.default.info(`Unblocked device with filter: ${JSON.stringify(filter)}`);
+            }
+            catch (error) {
+                logger_1.default.error(`Unable to unblock device. Reason: ${error}`);
+            }
+        });
+    }
+    unRegisterNode(host) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`Unregistering node ${this.host}/xenon/api/register`);
+            try {
+                const client = InternalHttpClient_1.InternalHttpClient.getClient(this.tlsRejectUnauthorized);
+                yield client.post(`${this.host}/xenon/api/register`, [], {
+                    params: {
+                        type: 'unregister',
+                        host,
+                    },
+                });
+                logger_1.default.info(`Unregistered node ${host} from hub`);
+            }
+            catch (error) {
+                logger_1.default.error(`Unable to unregister node from hub. Reason: ${error}`);
+            }
+        });
+    }
+}
+exports.default = NodeDevices;