@xenon-device-management/xenon 1.1.0

package/lib/src/sessions/RemoteSession.js

@@ -0,0 +1,287 @@
+"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.RemoteSession = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = __importDefault(require("../logger"));
+const SessionType_1 = __importDefault(require("../enums/SessionType"));
+const XenonSession_1 = require("./XenonSession");
+class RemoteSession extends XenonSession_1.XenonSession {
+    constructor(options) {
+        super(options);
+        this.isVideoAvailable = false;
+        this.baseUrl = options.baseUrl;
+    }
+    isVideoRecordingInProgress() {
+        return this.isVideoAvailable;
+    }
+    getType() {
+        return SessionType_1.default.REMOTE;
+    }
+    getScreenShot() {
+        return (0, axios_1.default)({
+            method: 'get',
+            url: `${this.baseUrl}/session/${this.sessionId}/screenshot`,
+        }).then((response) => (response.data ? response.data.value : ''));
+    }
+    stopVideoRecording(_driver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g;
+            logger_1.default.info(`[RemoteSession] stopVideoRecording called for session ${this.sessionId}. isVideoAvailable: ${this.isVideoAvailable}`);
+            try {
+                const response = yield (0, axios_1.default)({
+                    method: 'post',
+                    url: `${this.baseUrl}/session/${this.sessionId}/appium/stop_recording_screen`,
+                    data: {},
+                });
+                const dataLen = ((_b = (_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.length) || 0;
+                logger_1.default.info(`[RemoteSession] stopVideoRecording response status: ${response.status}, data length: ${dataLen}`);
+                return response.status === 200 && ((_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.value) ? (_d = response === null || response === void 0 ? void 0 : response.data) === null || _d === void 0 ? void 0 : _d.value : '';
+            }
+            catch (err) {
+                logger_1.default.warn(`[RemoteSession] stopVideoRecording error: ${err.message}, trying anyway to retrieve video...`);
+                // Even if there's an error, try to get the video data
+                try {
+                    const retryResponse = yield (0, axios_1.default)({
+                        method: 'post',
+                        url: `${this.baseUrl}/session/${this.sessionId}/appium/stop_recording_screen`,
+                        data: {},
+                    });
+                    const retryDataLen = ((_f = (_e = retryResponse === null || retryResponse === void 0 ? void 0 : retryResponse.data) === null || _e === void 0 ? void 0 : _e.value) === null || _f === void 0 ? void 0 : _f.length) || 0;
+                    logger_1.default.info(`[RemoteSession] stopVideoRecording retry succeeded, data length: ${retryDataLen}`);
+                    return ((_g = retryResponse === null || retryResponse === void 0 ? void 0 : retryResponse.data) === null || _g === void 0 ? void 0 : _g.value) || '';
+                }
+                catch (retryErr) {
+                    logger_1.default.error(`[RemoteSession] stopVideoRecording retry also failed: ${retryErr.message}`);
+                    return '';
+                }
+            }
+        });
+    }
+    stopPerformanceRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            logger_1.default.info(`[RemoteSession] stopPerformanceRecording called for session ${this.sessionId}`);
+            try {
+                const response = yield (0, axios_1.default)({
+                    method: 'post',
+                    url: `${this.baseUrl}/session/${this.sessionId}/execute/sync`,
+                    data: {
+                        script: 'mobile: stopPerfRecord',
+                        args: [
+                            {
+                                profileName: 'Time Profiler',
+                            },
+                        ],
+                    },
+                });
+                return response.status === 200 && ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.value) ? (_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.value : null;
+            }
+            catch (err) {
+                logger_1.default.warn(`[RemoteSession] stopPerformanceRecording failed: ${err.message}`);
+                return null;
+            }
+        });
+    }
+    startPerformanceRecording() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`[RemoteSession] startPerformanceRecording called for session ${this.sessionId}`);
+            try {
+                yield (0, axios_1.default)({
+                    method: 'post',
+                    url: `${this.baseUrl}/session/${this.sessionId}/execute/sync`,
+                    data: {
+                        script: 'mobile: startPerfRecord',
+                        args: [
+                            {
+                                profileName: 'Time Profiler',
+                                timeout: 1800000, // 30 mins
+                            },
+                        ],
+                    },
+                });
+            }
+            catch (err) {
+                logger_1.default.warn(`[RemoteSession] startPerformanceRecording failed: ${err.message}`);
+            }
+        });
+    }
+    startVideoRecording(options, _driver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = this.getDevice();
+            let resolution = (options === null || options === void 0 ? void 0 : options.resolution) ? options.resolution.replace('x', ':') : undefined;
+            let size = (options === null || options === void 0 ? void 0 : options.resolution) ? options.resolution.replace(':', 'x') : undefined;
+            // Principal Intelligence: Auto-detect orientation based on device dimensions
+            // to prevent squashed/stretched videos.
+            if (!resolution && device.screenWidth && device.screenHeight) {
+                const w = parseInt(device.screenWidth);
+                const h = parseInt(device.screenHeight);
+                logger_1.default.info(`[RemoteSession] Auto-detected device dimensions: ${w}x${h} for session ${this.sessionId}`);
+                if (h > w) {
+                    // Portrait device: Use vertical 720p equivalent
+                    resolution = '720:1280';
+                    size = '720x1280';
+                }
+                else {
+                    // Landscape device: Use standard 720p
+                    resolution = '1280:720';
+                    size = '1280x720';
+                }
+            }
+            else if (!resolution) {
+                // Fallback: Default to portrait 720p if dimensions unknown, as most mobile tests are portrait
+                resolution = '720:1280';
+                size = '720x1280';
+            }
+            logger_1.default.info(`[RemoteSession] Starting recording with resolution: ${resolution}, size: ${size}`);
+            return (0, axios_1.default)({
+                method: 'post',
+                url: `${this.baseUrl}/session/${this.sessionId}/appium/start_recording_screen`,
+                data: {
+                    options: {
+                        videoType: 'libx264',
+                        videoFps: 10,
+                        /* Force video scale to ensure width/height are divisible by 2 (ffmpeg requirement) */
+                        videoScale: resolution,
+                        videoSize: size,
+                        timeLimit: 1800, // 30 min
+                    },
+                },
+            })
+                .then((response) => {
+                // Set flag to true if response is successful (status 200 or 2xx)
+                this.isVideoAvailable = response.status >= 200 && response.status < 300;
+                const status = response.status;
+                logger_1.default.info(`[RemoteSession] startVideoRecording response status: ${status}, isVideoAvailable: ${this.isVideoAvailable}`);
+            })
+                .catch((error) => {
+                logger_1.default.error('[RemoteSession] startVideoRecording error:', error.message);
+                this.isVideoAvailable = false;
+                throw error;
+            });
+        });
+    }
+    getLiveVideoUrl() {
+        const url = new URL(this.baseUrl);
+        const capabilities = this.getCapabilities();
+        if (capabilities['mjpegServerPort'] && !isNaN(capabilities['mjpegServerPort'])) {
+            return `${url.origin}/xenon/api/session/${this.sessionId}/live_video`;
+        }
+        else {
+            return null;
+        }
+    }
+    checkHealth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (!this.sessionId) {
+                return {
+                    isHealthy: false,
+                    errorType: XenonSession_1.HealthErrorType.NONE,
+                    message: 'No session ID assigned',
+                };
+            }
+            // Identify the root Appium URL (strip /wd-internal if present)
+            const appiumUrl = this.baseUrl.replace(/\/wd-internal$/, '');
+            try {
+                // 1️⃣ Safe, read-only, lightweight probe: GET /session/{id}/timeouts
+                // This is a W3C standard command that all Appium drivers should register.
+                const response = yield (0, axios_1.default)({
+                    method: 'get',
+                    url: `${this.baseUrl}/session/${this.sessionId}/timeouts`,
+                    timeout: 5000,
+                });
+                return {
+                    isHealthy: response.status >= 200 && response.status < 300,
+                    errorType: XenonSession_1.HealthErrorType.NONE,
+                    statusCode: response.status,
+                };
+            }
+            catch (err) {
+                const status = (_a = err.response) === null || _a === void 0 ? void 0 : _a.status;
+                const message = err.message || 'Unknown error';
+                const errorData = ((_c = (_b = err.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.value) || ((_d = err.response) === null || _d === void 0 ? void 0 : _d.data);
+                const errorJson = JSON.stringify(errorData || {}).toLowerCase();
+                // 2️⃣ Failure Classification & Fallback Logic
+                if (status === 404) {
+                    // Distinguish between "Session Not Found" and "Command Not Found"
+                    // Appium 2 returns "No route found" or "unknown command" for unsupported endpoints.
+                    const isUnsupported = errorJson.includes('unknown command') || errorJson.includes('no route found');
+                    const isInvalidSession = errorJson.includes('invalid session id');
+                    if (isUnsupported) {
+                        logger_1.default.info('[RemoteSession] Probe endpoint unsupported on this driver, but driver is responsive. Classifying as HEALTHY.');
+                        return {
+                            isHealthy: true,
+                            errorType: XenonSession_1.HealthErrorType.UNSUPPORTED_ENDPOINT,
+                            message: 'Probe endpoint unsupported but driver is alive',
+                        };
+                    }
+                    if (isInvalidSession) {
+                        logger_1.default.error(`[RemoteSession] Session ${this.sessionId} definitively GONE (Invalid Session ID).`);
+                        return {
+                            isHealthy: false,
+                            errorType: XenonSession_1.HealthErrorType.SESSION_NOT_FOUND,
+                            message: 'Invalid Session ID',
+                            statusCode: 404,
+                        };
+                    }
+                    logger_1.default.warn(`[RemoteSession] Session ${this.sessionId} probe returned 404. Performing server status fallback...`);
+                    // Fallback: Verify Appium server is alive
+                    try {
+                        const statusRes = yield axios_1.default.get(`${appiumUrl}/status`, { timeout: 3000 });
+                        if (statusRes.status === 200) {
+                            // If server is alive but we got a raw 404 with no specific error,
+                            // it's likely the session is gone in Appium 2 (where /sessions list check is unsupported).
+                            return {
+                                isHealthy: false,
+                                errorType: XenonSession_1.HealthErrorType.SESSION_NOT_FOUND,
+                                message: 'Session likely gone (Server alive but 404 on session path)',
+                                statusCode: 404,
+                            };
+                        }
+                    }
+                    catch (serverErr) {
+                        logger_1.default.error(`[RemoteSession] Appium server REACHABILITY FAILED: ${serverErr.message}`);
+                        return {
+                            isHealthy: false,
+                            errorType: XenonSession_1.HealthErrorType.SERVER_UNREACHABLE,
+                            message: `Server unreachable: ${serverErr.message}`,
+                        };
+                    }
+                }
+                if (status >= 500) {
+                    return {
+                        isHealthy: false,
+                        errorType: XenonSession_1.HealthErrorType.DRIVER_ERROR,
+                        message: `Driver internal error: ${message}`,
+                        statusCode: status,
+                    };
+                }
+                if (err.code === 'ECONNREFUSED' || err.code === 'ETIMEDOUT') {
+                    return {
+                        isHealthy: false,
+                        errorType: XenonSession_1.HealthErrorType.SERVER_UNREACHABLE,
+                        message: `Connection failed: ${err.code}`,
+                    };
+                }
+                return {
+                    isHealthy: false,
+                    errorType: XenonSession_1.HealthErrorType.TIMEOUT,
+                    message: `Probe timed out: ${message}`,
+                };
+            }
+        });
+    }
+}
+exports.RemoteSession = RemoteSession;

package/lib/src/sessions/SessionManager.js

@@ -0,0 +1,238 @@
+"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 __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.SESSION_MANAGER = exports.SessionManager = void 0;
+const typedi_1 = require("typedi");
+const prisma_1 = require("../prisma");
+const logger_1 = __importDefault(require("../logger"));
+const RemoteSession_1 = require("./RemoteSession");
+const CloudSession_1 = require("./CloudSession");
+const device_store_1 = require("../data-service/device-store");
+const helpers_1 = require("../helpers");
+const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
+/**
+ * SessionManager with persistence and recovery capabilities.
+ *
+ * Key Design Decisions:
+ * 1. LocalSessions CANNOT be recovered (Appium driver dies with the hub).
+ *    On recovery, orphaned local sessions are marked as failed.
+ * 2. RemoteSessions and CloudSessions CAN be recovered because they only
+ *    need sessionId and baseUrl to continue proxying commands.
+ * 3. Session state is persisted to SQLite via Prisma for durability.
+ */
+let SessionManager = class SessionManager {
+    constructor() {
+        this.sessionMap = new Map();
+        this.log = logger_1.default.scope('SessionManager');
+    }
+    /**
+     * Add a session to the in-memory map.
+     * Note: Session is already persisted to DB via event-manager.onSessionCreated
+     */
+    addSession(sessionId, session) {
+        this.sessionMap.set(sessionId, session);
+        this.log.debug(`Added session ${sessionId} to memory (total: ${this.sessionMap.size})`);
+    }
+    /**
+     * Remove a session from the in-memory map.
+     */
+    removeSession(sessionId) {
+        this.sessionMap.delete(sessionId);
+        this.log.debug(`Removed session ${sessionId} from memory (total: ${this.sessionMap.size})`);
+    }
+    isValidSession(sessionId) {
+        return this.sessionMap.has(sessionId);
+    }
+    getSession(sessionId) {
+        return this.sessionMap.get(sessionId);
+    }
+    getAllSessions() {
+        return Array.from(this.sessionMap.values());
+    }
+    getSessionCount() {
+        return this.sessionMap.size;
+    }
+    /**
+     * Recover active sessions from the database after hub restart.
+     *
+     * @param currentNodeId - The ID of the current hub node
+     * @param nodeBasePath - The base path for WebDriver URLs
+     *
+     * Strategy:
+     * - Sessions on THIS node (LocalSessions) are marked as failed because
+     *   the Appium driver is gone.
+     * - Sessions on REMOTE nodes are recovered as RemoteSessions.
+     * - Sessions on CLOUD providers are recovered as CloudSessions.
+     */
+    recoverActiveSessions(currentNodeId, nodeBasePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log.info('🔄 Attempting to recover active sessions from database...');
+            try {
+                // Find all sessions that are still "running" (not ended)
+                const activeSessions = yield prisma_1.prisma.session.findMany({
+                    where: {
+                        status: 'running',
+                        endTime: null,
+                    },
+                });
+                if (activeSessions.length === 0) {
+                    this.log.info('✅ No active sessions to recover.');
+                    return 0;
+                }
+                this.log.info(`📋 Found ${activeSessions.length} active sessions in database.`);
+                let recoveredCount = 0;
+                let failedCount = 0;
+                for (const dbSession of activeSessions) {
+                    try {
+                        // Get the device associated with this session
+                        const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({
+                            udid: dbSession.device_udid,
+                        });
+                        if (!device) {
+                            this.log.warn(`⚠️ Session ${dbSession.id}: Device ${dbSession.device_udid} not found. Marking as failed.`);
+                            yield this.markSessionAsFailed(dbSession.id, 'Device not found after hub restart');
+                            failedCount++;
+                            continue;
+                        }
+                        // Check if this session was on THE CURRENT NODE (LocalSession)
+                        const isLocalSession = dbSession.node_id === currentNodeId || device.nodeId === currentNodeId;
+                        if (isLocalSession) {
+                            // LocalSessions cannot be recovered - the Appium driver is gone
+                            this.log.warn(`⏹️ Session ${dbSession.id}: Was a LocalSession on this node. Marking as failed (driver lost).`);
+                            yield this.markSessionAsFailed(dbSession.id, 'Hub restarted - local Appium driver session was lost');
+                            // Also unblock the device
+                            yield device_store_1.DeviceStoreFactory.getStore().updateDevice(device.udid, device.host, {
+                                busy: false,
+                                session_id: undefined,
+                            });
+                            failedCount++;
+                            continue;
+                        }
+                        // Parse session capabilities from JSON
+                        let sessionResponse = {};
+                        try {
+                            sessionResponse = JSON.parse(dbSession.session_capabilities || '{}');
+                        }
+                        catch (e) {
+                            this.log.warn(`Session ${dbSession.id}: Could not parse session_capabilities`);
+                        }
+                        let desiredCaps = {};
+                        try {
+                            desiredCaps = JSON.parse(dbSession.desired_capabilities || '{}');
+                        }
+                        catch (e) {
+                            this.log.warn(`Session ${dbSession.id}: Could not parse desired_capabilities`);
+                        }
+                        const xenonCapabilities = (0, XenonCapabilityManager_1.getXenonCapabilities)({
+                            alwaysMatch: desiredCaps,
+                            firstMatch: [{}],
+                        });
+                        const baseUrl = (0, helpers_1.nodeUrl)(device, nodeBasePath);
+                        // Create the appropriate session type
+                        let recoveredSession;
+                        if (device.cloud) {
+                            // CloudSession
+                            recoveredSession = new CloudSession_1.CloudSession({
+                                sessionId: dbSession.id,
+                                device: device,
+                                sessionResponse: sessionResponse,
+                                xenonOption: xenonCapabilities,
+                                baseUrl: baseUrl,
+                            });
+                            this.log.info(`☁️ Recovered CloudSession ${dbSession.id} on ${device.cloud}`);
+                        }
+                        else {
+                            // RemoteSession
+                            recoveredSession = new RemoteSession_1.RemoteSession({
+                                sessionId: dbSession.id,
+                                device: device,
+                                sessionResponse: sessionResponse,
+                                xenonOption: xenonCapabilities,
+                                baseUrl: baseUrl,
+                            });
+                            this.log.info(`🌐 Recovered RemoteSession ${dbSession.id} on node ${device.nodeId}`);
+                        }
+                        // Add to in-memory map
+                        this.addSession(dbSession.id, recoveredSession);
+                        recoveredCount++;
+                    }
+                    catch (sessionErr) {
+                        this.log.error(`❌ Failed to recover session ${dbSession.id}: ${sessionErr.message}`);
+                        yield this.markSessionAsFailed(dbSession.id, `Recovery failed: ${sessionErr.message}`);
+                        failedCount++;
+                    }
+                }
+                this.log.info(`✅ Session recovery complete. Recovered: ${recoveredCount}, Failed: ${failedCount}`);
+                return recoveredCount;
+            }
+            catch (err) {
+                this.log.error(`❌ Session recovery error: ${err.message}`);
+                return 0;
+            }
+        });
+    }
+    /**
+     * Mark a session as failed in the database
+     */
+    markSessionAsFailed(sessionId, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield prisma_1.prisma.session.update({
+                    where: { id: sessionId },
+                    data: {
+                        status: 'failed',
+                        endTime: new Date(),
+                        failure_reason: reason,
+                        failure_category: 'HUB_RESTART',
+                    },
+                });
+            }
+            catch (err) {
+                this.log.error(`Failed to mark session ${sessionId} as failed: ${err.message}`);
+            }
+        });
+    }
+    /**
+     * Get statistics about current sessions
+     */
+    getStats() {
+        const byType = {
+            local: 0,
+            remote: 0,
+            cloud: 0,
+        };
+        for (const session of Array.from(this.sessionMap.values())) {
+            const type = session.getType().toLowerCase();
+            byType[type] = (byType[type] || 0) + 1;
+        }
+        return {
+            total: this.sessionMap.size,
+            byType,
+        };
+    }
+};
+exports.SessionManager = SessionManager;
+exports.SessionManager = SessionManager = __decorate([
+    (0, typedi_1.Service)()
+], SessionManager);
+// Export singleton for backward compatibility
+// New code should use Container.get(SessionManager)
+const typedi_2 = require("typedi");
+exports.SESSION_MANAGER = typedi_2.Container.get(SessionManager);

package/lib/src/sessions/XenonSession.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XenonSession = exports.HealthErrorType = exports.SessionHealthState = void 0;
+var SessionHealthState;
+(function (SessionHealthState) {
+    SessionHealthState["HEALTHY"] = "HEALTHY";
+    SessionHealthState["DEGRADED"] = "DEGRADED";
+    SessionHealthState["SUSPECT"] = "SUSPECT";
+    SessionHealthState["DEAD"] = "DEAD";
+})(SessionHealthState || (exports.SessionHealthState = SessionHealthState = {}));
+var HealthErrorType;
+(function (HealthErrorType) {
+    HealthErrorType["NONE"] = "NONE";
+    HealthErrorType["UNSUPPORTED_ENDPOINT"] = "UNSUPPORTED_ENDPOINT";
+    HealthErrorType["SESSION_NOT_FOUND"] = "SESSION_NOT_FOUND";
+    HealthErrorType["SERVER_UNREACHABLE"] = "SERVER_UNREACHABLE";
+    HealthErrorType["DRIVER_ERROR"] = "DRIVER_ERROR";
+    HealthErrorType["TIMEOUT"] = "TIMEOUT";
+})(HealthErrorType || (exports.HealthErrorType = HealthErrorType = {}));
+class XenonSession {
+    constructor(options) {
+        this.options = options;
+        this.isStopping = false;
+        this.healthState = SessionHealthState.HEALTHY;
+        this.sessionId = options.sessionId;
+        this.xenonOption = options.xenonOption;
+    }
+    getId() {
+        return this.sessionId;
+    }
+    getDevice() {
+        return this.options.device;
+    }
+    getDeviceFarmOptions() {
+        return this.xenonOption;
+    }
+    getCapabilities() {
+        return this.options.sessionResponse;
+    }
+    getXenonOption(option, defaultValue = undefined) {
+        return this.xenonOption[option] ? this.xenonOption[option] : defaultValue;
+    }
+}
+exports.XenonSession = XenonSession;

package/lib/src/types/CLIArgs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/types/CloudArgs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });