@xenon-device-management/xenon 1.1.0

package/lib/src/services/SessionLifecycleService.js

@@ -0,0 +1,572 @@
+"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 __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.SessionLifecycleService = void 0;
+const typedi_1 = require("typedi");
+const uuid_1 = require("uuid");
+const lodash_1 = __importDefault(require("lodash"));
+const axios_1 = __importDefault(require("axios"));
+const https_proxy_agent_1 = require("https-proxy-agent");
+const http_proxy_agent_1 = require("http-proxy-agent");
+const logger_1 = __importDefault(require("../logger"));
+const helpers_1 = require("../helpers");
+const InternalHttpClient_1 = require("../InternalHttpClient");
+const PluginContext_1 = require("../PluginContext");
+const CapabilityValidator_1 = require("../validators/CapabilityValidator");
+const device_service_1 = require("../data-service/device-service");
+const pending_sessions_service_1 = require("../data-service/pending-sessions-service");
+const device_utils_1 = require("../device-utils");
+const TracingService_1 = require("./TracingService");
+const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
+const CircuitBreaker_1 = require("../data-service/CircuitBreaker");
+const wd_command_proxy_1 = require("../proxy/wd-command-proxy");
+const device_store_1 = require("../data-service/device-store");
+const LocalSession_1 = require("../sessions/LocalSession");
+const CloudSession_1 = require("../sessions/CloudSession");
+const RemoteSession_1 = require("../sessions/RemoteSession");
+const SessionManager_1 = require("../sessions/SessionManager");
+const event_manager_1 = require("../dashboard/event-manager");
+const session_service_1 = require("../dashboard/services/session-service");
+const SessionType_1 = __importDefault(require("../enums/SessionType"));
+const async_lock_1 = __importDefault(require("async-lock"));
+const commandsQueueGuard = new async_lock_1.default();
+let SessionLifecycleService = class SessionLifecycleService {
+    constructor() {
+        this.logger = logger_1.default.scope('SessionLifecycleService');
+    }
+    createSession(next, driver, caps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+            const pluginArgs = context.pluginArgs;
+            this.logger.debug(`📱 pluginArgs: ${JSON.stringify(pluginArgs)}`);
+            this.logger.debug(`Receiving session request at host: ${pluginArgs.bindHostOrIp}`);
+            const pendingSessionId = (0, uuid_1.v4)();
+            this.logger.debug(`📱 Creating temporary session capability_id: ${pendingSessionId}`);
+            const { alwaysMatch: requiredCaps = {}, firstMatch: allFirstMatchCaps = [{}] } = caps;
+            const strippedRequiredCaps = (0, helpers_1.stripAppiumPrefixes)(requiredCaps);
+            const strippedFirstMatchCaps = (0, helpers_1.stripAppiumPrefixes)(allFirstMatchCaps[0]);
+            try {
+                const mergedCaps = Object.assign({}, strippedFirstMatchCaps, strippedRequiredCaps);
+                typedi_1.Container.get(CapabilityValidator_1.CapabilityValidator).validate(mergedCaps);
+            }
+            catch (err) {
+                this.logger.error(`❌ Session validation failed: ${err.message}`);
+                throw err;
+            }
+            const app = strippedRequiredCaps['app'] || strippedFirstMatchCaps['app'];
+            if (app && typeof app === 'string' && !app.includes('/') && !app.includes('\\')) {
+                const { APP_SERVICE } = yield Promise.resolve().then(() => __importStar(require('../dashboard/services/app-service')));
+                const appDetails = yield APP_SERVICE.getAppById(app);
+                if (appDetails) {
+                    const appUrl = `http://${pluginArgs.bindHostOrIp}:${context.port}/xenon/api/apps/${appDetails.id}/download`;
+                    this.logger.info(`📱 Resolved app ID ${app} to ${appUrl}`);
+                    if (requiredCaps['app'])
+                        requiredCaps['app'] = appUrl;
+                    if (allFirstMatchCaps[0]['app'])
+                        allFirstMatchCaps[0]['app'] = appUrl;
+                    if (caps.alwaysMatch && caps.alwaysMatch['app'])
+                        caps.alwaysMatch['app'] = appUrl;
+                    if (caps.alwaysMatch && caps.alwaysMatch['appium:app'])
+                        caps.alwaysMatch['appium:app'] = appUrl;
+                    if (caps.firstMatch && caps.firstMatch[0]) {
+                        if (caps.firstMatch[0]['app'])
+                            caps.firstMatch[0]['app'] = appUrl;
+                        if (caps.firstMatch[0]['appium:app'])
+                            caps.firstMatch[0]['appium:app'] = appUrl;
+                    }
+                }
+            }
+            const firstMatch = Array.isArray(caps.firstMatch) && caps.firstMatch.length > 0 ? caps.firstMatch[0] : {};
+            yield (0, pending_sessions_service_1.addNewPendingSession)(Object.assign(Object.assign({}, Object.assign({}, firstMatch, caps.alwaysMatch)), { capability_id: pendingSessionId, createdAt: new Date().getTime() }));
+            const lockName = this.getLockName(caps);
+            this.logger.debug(`📱 Acquiring lock: ${lockName}`);
+            const device = yield commandsQueueGuard.acquire(lockName, () => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    return yield (0, device_utils_1.allocateDeviceForSession)(caps, pluginArgs.deviceAvailabilityTimeoutMs, pluginArgs.deviceAvailabilityQueryIntervalMs, pluginArgs);
+                }
+                catch (err) {
+                    yield (0, pending_sessions_service_1.removePendingSession)(pendingSessionId);
+                    throw err;
+                }
+            }));
+            yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'Allocating node resources...');
+            let session;
+            const isRemoteOrCloudSession = !device.nodeId || device.nodeId !== context.nodeId;
+            this.logger.debug(`device.host: ${device.host} and pluginArgs.bindHostOrIp: ${pluginArgs.bindHostOrIp}`);
+            if (isRemoteOrCloudSession) {
+                this.logger.debug(`📱 Forwarding session request to ${device.host}`);
+                yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'Forwarding to remote node...');
+                session = yield this.forwardSessionRequest(device, caps);
+            }
+            else {
+                this.logger.debug('📱 Creating session on the same node');
+                yield this.handleLocalWDAProvisioning(device, caps);
+                yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'Finalizing session bootstrap...');
+                session = yield next();
+            }
+            this.logger.debug('📱 Session response: ', JSON.stringify(session));
+            this.logger.debug(`📱 Removing pending session with capability_id: ${pendingSessionId}`);
+            yield (0, pending_sessions_service_1.removePendingSession)(pendingSessionId);
+            if (this.isCreateSessionResponseInternal(session)) {
+                yield this.finalizeSession(session, device, caps, driver, isRemoteOrCloudSession);
+            }
+            else {
+                yield this.handleSessionFailure(session, device, isRemoteOrCloudSession);
+            }
+            return session;
+        });
+    }
+    handleLocalWDAProvisioning(device, caps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (device.platform === 'ios' && device.realDevice) {
+                const { APP_SERVICE } = yield Promise.resolve().then(() => __importStar(require('../dashboard/services/app-service')));
+                const wdaApp = yield APP_SERVICE.getWDAApp();
+                const { default: IOSStreamService } = yield Promise.resolve().then(() => __importStar(require('../device-managers/ios/IOSStreamService')));
+                const streamService = typedi_1.Container.get(IOSStreamService);
+                const streamStatus = streamService.getStreamStatus(device.udid);
+                const isWdaActive = streamStatus && (streamStatus.status === 'running' || streamStatus.status === 'starting');
+                if (!isWdaActive && wdaApp && (yield Promise.resolve().then(() => __importStar(require('fs-extra')))).existsSync(wdaApp.filepath)) {
+                    this.logger.info(`📱 Artisan WDA: Signed artifact found for ${device.udid}`);
+                    yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'Provisioning WDA artifact...');
+                    if (device.derivedDataPath) {
+                        try {
+                            const fs = yield Promise.resolve().then(() => __importStar(require('fs-extra')));
+                            if (fs.existsSync(device.derivedDataPath)) {
+                                yield fs.remove(device.derivedDataPath);
+                            }
+                        }
+                        catch (e) {
+                            this.logger.warn(`⚠️ Artisan WDA: Failed to clear cache: ${e.message}`);
+                        }
+                    }
+                    try {
+                        const streamInfo = yield streamService.startStream(device.udid);
+                        const wdaUrl = `http://127.0.0.1:${streamInfo.wdaPort}`;
+                        yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'WDA active, finalizing session...');
+                        yield new Promise((resolve) => setTimeout(resolve, 2000));
+                        const bundleId = yield streamService.detectWDABundleId(device.udid);
+                        this.injectWDAUrl(caps, wdaUrl, bundleId);
+                    }
+                    catch (err) {
+                        this.logger.warn(`⚠️ Artisan WDA: Pre-session boot failed: ${err.message}`);
+                        yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'Provisioning failed, falling back...');
+                    }
+                }
+                else if (isWdaActive) {
+                    const wdaUrl = `http://127.0.0.1:${streamStatus.wdaPort}`;
+                    this.injectWDAUrl(caps, wdaUrl);
+                }
+                const hasWdaUrl = lodash_1.default.has(caps.alwaysMatch, 'appium:webDriverAgentUrl') ||
+                    lodash_1.default.has(caps.firstMatch[0], 'appium:webDriverAgentUrl');
+                if (!hasWdaUrl) {
+                    yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'Initializing WebDriverAgent (Xcode)...');
+                }
+            }
+            else if (device.platform === 'android') {
+                yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'Initializing UIAutomator2...');
+            }
+        });
+    }
+    injectWDAUrl(caps, wdaUrl, bundleId) {
+        if (caps.alwaysMatch) {
+            caps.alwaysMatch['appium:webDriverAgentUrl'] = wdaUrl;
+            caps.alwaysMatch['appium:usePreinstalledWDA'] = true;
+            if (bundleId)
+                caps.alwaysMatch['appium:updatedWDABundleId'] = bundleId;
+            delete caps.alwaysMatch['appium:derivedDataPath'];
+            delete caps.alwaysMatch['appium:usePrebuiltWDA'];
+            delete caps.alwaysMatch['appium:wdaLocalPort'];
+            delete caps.alwaysMatch['appium:mjpegServerPort'];
+        }
+        if (caps.firstMatch && caps.firstMatch[0]) {
+            caps.firstMatch[0]['appium:webDriverAgentUrl'] = wdaUrl;
+            caps.firstMatch[0]['appium:usePreinstalledWDA'] = true;
+            if (bundleId)
+                caps.firstMatch[0]['appium:updatedWDABundleId'] = bundleId;
+            delete caps.firstMatch[0]['appium:derivedDataPath'];
+            delete caps.firstMatch[0]['appium:usePrebuiltWDA'];
+            delete caps.firstMatch[0]['appium:wdaLocalPort'];
+            delete caps.firstMatch[0]['appium:mjpegServerPort'];
+        }
+    }
+    finalizeSession(session, device, caps, driver, isRemote) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const sessionId = session.value[0];
+            const sessionResponse = session.value[1];
+            const requestedCaps = Object.assign({}, ((_a = caps.firstMatch) === null || _a === void 0 ? void 0 : _a[0]) || {}, caps.alwaysMatch || {});
+            sessionResponse.desired = requestedCaps;
+            const xenonCapabilities = (0, XenonCapabilityManager_1.getXenonCapabilities)(caps);
+            const tracingService = typedi_1.Container.get(TracingService_1.TracingService);
+            const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+            if (this.isHub(context.pluginArgs)) {
+                const sessionName = (xenonCapabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.SESSION_NAME] ||
+                    sessionId);
+                tracingService.startSessionSpan(sessionId, sessionName, {
+                    'xenon.build_name': xenonCapabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.BUILD_NAME],
+                    'xenon.platform': device.platform,
+                    'xenon.udid': device.udid,
+                });
+            }
+            yield (0, device_service_1.updatedAllocatedDevice)(device, {
+                busy: true,
+                session_id: sessionId,
+                lastCmdExecutedAt: new Date().getTime(),
+                sessionStartTime: new Date().getTime(),
+                sessionProgress: 'Session Active',
+            });
+            if (isRemote) {
+                typedi_1.Container.get(CircuitBreaker_1.CircuitBreaker).recordSuccess(device.host);
+                (0, wd_command_proxy_1.addProxyHandler)(sessionId, device.host);
+            }
+            const freshDevice = yield this.getFreshDevice(device);
+            const sessionInstance = this.createSessionInstance(sessionId, freshDevice, sessionResponse, xenonCapabilities, driver);
+            yield this.applyPostSessionLogic(sessionInstance, xenonCapabilities, freshDevice);
+        });
+    }
+    getFreshDevice(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const store = device_store_1.DeviceStoreFactory.getStore();
+                const updatedDevice = yield store.findDevice({ udid: device.udid, host: device.host });
+                return updatedDevice || device;
+            }
+            catch (err) {
+                this.logger.debug(`📱 Could not refresh device: ${err.message}`);
+                return device;
+            }
+        });
+    }
+    createSessionInstance(sessionId, device, response, caps, driver) {
+        const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+        const sessionOptions = {
+            sessionId,
+            device,
+            sessionResponse: response,
+            xenonOption: caps,
+        };
+        const nodeWebdriverUrl = (0, helpers_1.nodeUrl)(device, context.nodeBasePath);
+        if (device.nodeId === context.nodeId) {
+            return new LocalSession_1.LocalSession(Object.assign(Object.assign({}, sessionOptions), { driver }));
+        }
+        else if (device.cloud) {
+            return new CloudSession_1.CloudSession(Object.assign(Object.assign({}, sessionOptions), { baseUrl: nodeWebdriverUrl }));
+        }
+        else {
+            return new RemoteSession_1.RemoteSession(Object.assign(Object.assign({}, sessionOptions), { baseUrl: nodeWebdriverUrl }));
+        }
+    }
+    applyPostSessionLogic(session, caps, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+            const networkProfile = caps[XenonCapabilityManager_1.XENON_CAPABILITIES.NETWORK_PROFILE];
+            if (networkProfile) {
+                const { NetworkConditioningService } = yield Promise.resolve().then(() => __importStar(require('./NetworkConditioningService')));
+                yield typedi_1.Container.get(NetworkConditioningService).applyProfile(session.getId(), device, networkProfile);
+            }
+            const isDashboardEnabled = !!context.pluginArgs.enableDashboard;
+            const shouldSaveLogs = session.getType() !== SessionType_1.default.CLOUD;
+            const isVideoRecordingEnabled = caps[XenonCapabilityManager_1.XENON_CAPABILITIES.VIDEO_RECORDING];
+            this.logger.info(`📹 Video recording enabled for session ${session.getId()}: ${isVideoRecordingEnabled}`);
+            if (isVideoRecordingEnabled) {
+                const resolution = caps[XenonCapabilityManager_1.XENON_CAPABILITIES.VIDEO_RESOLUTION] || undefined;
+                try {
+                    this.logger.info(`📹 Starting video recording for session ${session.getId()}...`);
+                    yield session.startVideoRecording({ resolution });
+                    this.logger.info(`📹 Video recording started successfully for ${session.getId()}`);
+                }
+                catch (err) {
+                    this.logger.warn(`⚠️ Failed to start video recording for ${session.getId()}: ${err.message}`);
+                }
+            }
+            if ((isDashboardEnabled && shouldSaveLogs) || (isVideoRecordingEnabled && shouldSaveLogs)) {
+                SessionManager_1.SESSION_MANAGER.addSession(session.getId(), session);
+                if (this.isHub(context.pluginArgs) && isDashboardEnabled) {
+                    yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStarted(caps, session, device);
+                }
+            }
+        });
+    }
+    handleSessionFailure(session, device, isRemote) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, device_service_1.unblockDevice)(device.udid, device.host);
+            yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, '');
+            if (isRemote) {
+                typedi_1.Container.get(CircuitBreaker_1.CircuitBreaker).recordFailure(device.host);
+            }
+            this.throwProperError(session, device.host);
+        });
+    }
+    forwardSessionRequest(device, caps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+            const remoteUrl = `${(0, helpers_1.nodeUrl)(device, context.nodeBasePath)}/session`;
+            const config = {
+                method: 'post',
+                url: remoteUrl,
+                headers: { 'Content-Type': 'application/json' },
+                data: { capabilities: caps },
+            };
+            if (context.pluginArgs.proxy) {
+                this.logger.info(`Added proxy to axios config: ${JSON.stringify(context.pluginArgs.proxy)}`);
+                const proxyUrl = typeof context.pluginArgs.proxy === 'string'
+                    ? context.pluginArgs.proxy
+                    : `http://${context.pluginArgs.proxy.host}:${context.pluginArgs.proxy.port}`;
+                config.httpsAgent = new https_proxy_agent_1.HttpsProxyAgent(proxyUrl, {
+                    rejectUnauthorized: context.pluginArgs.tlsRejectUnauthorized,
+                });
+                config.httpAgent = new http_proxy_agent_1.HttpProxyAgent(proxyUrl, {
+                    rejectUnauthorized: context.pluginArgs.tlsRejectUnauthorized,
+                });
+                config.proxy = false;
+            }
+            const createdSession = yield this.invokeSessionRequest(config, context.pluginArgs.tlsRejectUnauthorized);
+            if (createdSession instanceof Error) {
+                return createdSession;
+            }
+            // Detect W3C-style error payloads that invokeSessionRequest returned as data
+            const val = createdSession === null || createdSession === void 0 ? void 0 : createdSession.value;
+            if (Object.prototype.hasOwnProperty.call(createdSession, 'error') ||
+                (val && val.error) ||
+                (val && typeof val.message === 'string' && !val.sessionId)) {
+                const errorDetail = createdSession.error || (val === null || val === void 0 ? void 0 : val.error) || (val === null || val === void 0 ? void 0 : val.message) || 'Unknown W3C error';
+                return new Error(`W3C session creation failed on ${device.host}: ${typeof errorDetail === 'object' ? JSON.stringify(errorDetail) : errorDetail}`);
+            }
+            // Only build the success tuple for genuine W3C success payloads
+            if (!(val === null || val === void 0 ? void 0 : val.sessionId)) {
+                return new Error(`Invalid session response from ${device.host}: missing sessionId`);
+            }
+            return {
+                protocol: 'W3C',
+                value: [val.sessionId, val.capabilities, 'W3C'],
+            };
+        });
+    }
+    invokeSessionRequest(config, tlsRejectUnauthorized) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const client = InternalHttpClient_1.InternalHttpClient.getClient(tlsRejectUnauthorized);
+                const response = yield client.request(config);
+                return response.data;
+            }
+            catch (error) {
+                if (axios_1.default.isAxiosError(error)) {
+                    const axiosError = error;
+                    if (axiosError.response) {
+                        return axiosError.response.data;
+                    }
+                }
+                return error;
+            }
+        });
+    }
+    isW3CNewSessionResponse(something) {
+        return (something &&
+            typeof something === 'object' &&
+            (Object.prototype.hasOwnProperty.call(something, 'value') ||
+                Object.prototype.hasOwnProperty.call(something, 'error')));
+    }
+    isCreateSessionResponseInternal(something) {
+        return (something &&
+            typeof something === 'object' &&
+            Object.prototype.hasOwnProperty.call(something, 'value') &&
+            Array.isArray(something.value) &&
+            (something.value.length === 2 || something.value.length === 3) &&
+            typeof something.value[0] === 'string' &&
+            typeof something.value[1] === 'object' &&
+            (something.value.length === 2 ||
+                typeof something.value[2] === 'string' ||
+                something.value[2] === undefined));
+    }
+    throwProperError(session, host) {
+        if (session instanceof Error) {
+            throw session;
+        }
+        else if (session &&
+            typeof session === 'object' &&
+            Object.prototype.hasOwnProperty.call(session, 'error')) {
+            let errorMessage = session.error;
+            if (typeof errorMessage === 'object') {
+                errorMessage = JSON.stringify(errorMessage);
+            }
+            throw new Error(`Failed to create session on node ${host}. Error: ${errorMessage}`);
+        }
+        else {
+            throw new Error(`Failed to create session on node ${host}. Unknown error.`);
+        }
+    }
+    getLockName(caps) {
+        var _a, _b, _c, _d;
+        const platform = (_d = (((_a = caps.alwaysMatch) === null || _a === void 0 ? void 0 : _a.platformName) || ((_c = (_b = caps.firstMatch) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.platformName))) === null || _d === void 0 ? void 0 : _d.toLowerCase();
+        if (platform === 'ios')
+            return 'ios-lock';
+        if (platform === 'android')
+            return 'android-lock';
+        return 'default-lock';
+    }
+    deleteSession(next, sessionId, status, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (sessionId) {
+                yield (0, device_service_1.unblockDeviceMatchingFilter)({ session_id: sessionId });
+                this.logger.info(`📱 Unblocking the device that is blocked for session ${sessionId}`);
+            }
+            const session = sessionId ? SessionManager_1.SESSION_MANAGER.getSession(sessionId) : undefined;
+            if (session) {
+                session.isStopping = true;
+                session.stoppedAt = Date.now();
+                yield this.finalizeCleanup(session, status, reason);
+            }
+            let timeoutId;
+            try {
+                // Principal Protection: Wrap the driver deletion with a timeout.
+                // If the underlying driver (WDA/ADB) hangs during shutdown, we don't want
+                // our session lifecycle to be stuck 'RUNNING' forever.
+                const deletionTimeout = new Promise((_, reject) => {
+                    timeoutId = setTimeout(() => reject(new Error('Deletion timed out')), 30000);
+                });
+                const response = yield Promise.race([next(), deletionTimeout]);
+                clearTimeout(timeoutId);
+                return response;
+            }
+            catch (err) {
+                clearTimeout(timeoutId);
+                this.logger.warn(`⚠️ Internal deleteSession failed or timed out: ${err.message}. Continuing cleanup anyway.`);
+                return null;
+            }
+            finally {
+                if (sessionId) {
+                    const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+                    if (session) {
+                        const device = session.getDevice();
+                        try {
+                            const { NetworkConditioningService } = yield Promise.resolve().then(() => __importStar(require('./NetworkConditioningService')));
+                            yield typedi_1.Container.get(NetworkConditioningService).reset(sessionId, device);
+                        }
+                        catch (resetErr) {
+                            this.logger.warn(`⚠️ NetworkConditioningService.reset failed for session ${sessionId}: ${resetErr.message}`);
+                        }
+                    }
+                    yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(sessionId, status, reason);
+                    SessionManager_1.SESSION_MANAGER.removeSession(sessionId);
+                    try {
+                        const { getSessionById } = yield Promise.resolve().then(() => __importStar(require('../dashboard/services/session-service')));
+                        const sessionData = yield getSessionById(sessionId);
+                        if (sessionData && (sessionData.status === 'failed' || sessionData.failure_reason)) {
+                            const { NotificationService } = yield Promise.resolve().then(() => __importStar(require('./NotificationService')));
+                            yield typedi_1.Container.get(NotificationService).dispatchEvent('session_failed', sessionData);
+                        }
+                    }
+                    catch (err) {
+                        /* ignore notification errors */
+                    }
+                }
+            }
+        });
+    }
+    finalizeCleanup(session, status, reason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const sessionId = session.getId();
+            const device = session.getDevice();
+            // 1. iOS Profiling Archival
+            if (device && ((_a = device.platform) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === 'ios') {
+                this.logger.info(`[${sessionId}] Stopping iOS profiling for asset archival`);
+                try {
+                    const traceBase64 = yield session.stopPerformanceRecording();
+                    if (traceBase64) {
+                        const { savePerformanceTrace } = yield Promise.resolve().then(() => __importStar(require('../dashboard/asset-manager')));
+                        const tracePath = savePerformanceTrace(sessionId, traceBase64);
+                        yield (0, session_service_1.updateSessionDetails)(sessionId, { performance_trace: tracePath });
+                        this.logger.info(`✅ [${sessionId}] iOS profiling trace saved at ${tracePath}`);
+                    }
+                }
+                catch (err) {
+                    this.logger.warn(`⚠️ [${sessionId}] iOS profiling capture failed: ${err.message}`);
+                }
+            }
+            // 2. Intelligent Video Archival
+            if (session.isVideoRecordingInProgress()) {
+                this.logger.info(`[${sessionId}] Stopping video recording for asset archival`);
+                try {
+                    const videoData = yield session.stopVideoRecording();
+                    if (videoData) {
+                        try {
+                            const { saveVideoRecording } = yield Promise.resolve().then(() => __importStar(require('../dashboard/asset-manager')));
+                            let videoPath = videoData;
+                            // Principal Efficiency: If it's a relative path from our pipeline, use it.
+                            // If it's base64 (older Appium drivers), save it to disk.
+                            if (videoData.length > 1000) {
+                                videoPath = saveVideoRecording(sessionId, videoData);
+                            }
+                            yield (0, session_service_1.updateSessionDetails)(sessionId, { video_recording: videoPath });
+                            this.logger.info(`✅ [${sessionId}] Video recording archived at ${videoPath}`);
+                        }
+                        catch (saveErr) {
+                            this.logger.error(`❌ [${sessionId}] Failed to process video asset: ${saveErr.message}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    this.logger.warn(`⚠️ [${sessionId}] Failed to stop video recording: ${error.message}`);
+                }
+            }
+        });
+    }
+    isHub(args) {
+        return !args.hub;
+    }
+};
+exports.SessionLifecycleService = SessionLifecycleService;
+exports.SessionLifecycleService = SessionLifecycleService = __decorate([
+    (0, typedi_1.Service)()
+], SessionLifecycleService);

package/lib/src/services/SocketClient.js

@@ -0,0 +1,71 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketClient = void 0;
+const socket_io_client_1 = require("socket.io-client");
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const SocketEvents_1 = require("../enums/SocketEvents");
+let SocketClient = class SocketClient {
+    constructor() {
+        this.socket = null;
+        this.hubUrl = null;
+        this.nodeHost = null;
+    }
+    initialize(hubUrl, nodeHost) {
+        this.hubUrl = hubUrl;
+        this.nodeHost = nodeHost;
+        // Remove wd/hub if present in hubUrl
+        const normalizedHubUrl = hubUrl.replace(/\/wd\/hub$/, '');
+        logger_1.default.info(`[SocketClient] Connecting to Hub WebSocket: ${normalizedHubUrl}`);
+        this.socket = (0, socket_io_client_1.io)(normalizedHubUrl, {
+            reconnection: true,
+            reconnectionAttempts: Infinity,
+            reconnectionDelay: 1000,
+            reconnectionDelayMax: 5000,
+        });
+        this.socket.on('connect', () => {
+            var _a, _b, _c;
+            logger_1.default.info(`[SocketClient] Connected to Hub: ${(_a = this.socket) === null || _a === void 0 ? void 0 : _a.id}`);
+            // 1. Send Handshake
+            (_b = this.socket) === null || _b === void 0 ? void 0 : _b.emit(SocketEvents_1.SocketEvents.HANDSHAKE, {
+                version: SocketEvents_1.XENON_PROTOCOL_VERSION,
+                host: this.nodeHost,
+                timestamp: Date.now(),
+            });
+            // 2. Register Node
+            (_c = this.socket) === null || _c === void 0 ? void 0 : _c.emit(SocketEvents_1.SocketEvents.REGISTER_NODE, { host: this.nodeHost });
+        });
+        this.socket.on('disconnect', (reason) => {
+            logger_1.default.warn(`[SocketClient] Disconnected from Hub: ${reason}`);
+        });
+        this.socket.on('connect_error', (error) => {
+            logger_1.default.error(`[SocketClient] Connection error: ${error.message}`);
+        });
+    }
+    emit(event, data) {
+        var _a;
+        if ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected) {
+            this.socket.emit(event, data);
+        }
+        else {
+            logger_1.default.debug(`[SocketClient] Cannot emit ${event}: Socket not connected`);
+        }
+    }
+    isConnected() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.connected) || false;
+    }
+};
+exports.SocketClient = SocketClient;
+exports.SocketClient = SocketClient = __decorate([
+    (0, typedi_1.Service)()
+], SocketClient);