@xenon-device-management/xenon 1.1.0

package/lib/src/dashboard/event-manager.js

@@ -0,0 +1,699 @@
+"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.DASHBORD_EVENT_MANAGER = exports.DashboardEventManager = void 0;
+const SessionManager_1 = require("../sessions/SessionManager");
+const prisma_1 = require("../prisma");
+const logger_1 = __importDefault(require("../logger"));
+const session_service_1 = require("./services/session-service");
+const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
+const lodash_1 = __importDefault(require("lodash"));
+const helpers_1 = require("../helpers");
+const asset_manager_1 = require("./asset-manager");
+const commands_1 = require("./commands");
+const SessionStatus_1 = require("../types/SessionStatus");
+const appium_ios_device_1 = require("appium-ios-device");
+const AndroidAppProfiler_1 = require("../profiling/AndroidAppProfiler");
+const appium_adb_1 = require("appium-adb");
+const config_1 = require("../config");
+const helpers_2 = require("../helpers");
+const typedi_1 = require("typedi");
+const device_managers_1 = require("../device-managers");
+const AndroidDeviceManager_1 = __importDefault(require("../device-managers/AndroidDeviceManager"));
+const SocketServer_1 = require("../services/SocketServer");
+const TracingService_1 = require("../services/TracingService");
+const MetricsService_1 = require("../services/MetricsService");
+const SocketEvents_1 = require("../enums/SocketEvents");
+const typedi_2 = require("typedi");
+let DashboardEventManager = class DashboardEventManager {
+    constructor() {
+        // private SCREENSHOT_FOR_COMMANDS = ['click', 'setUrl', 'setValue', 'performActions'];
+        // Store syslog services for real iOS devices
+        this.syslogServices = new Map();
+        // Map session ID to UDID for cleanup
+        this.sessionToUdid = new Map();
+        // Map session ID to device info
+        this.sessionToDevice = new Map();
+        // Store app profilers for Android sessions
+        this.appProfilers = new Map();
+        // Track last log line for each session (for device logs)
+        this.lastLogLine = new Map();
+        // Track start time for each command to calculate duration
+        this.commandStartTime = new Map();
+        // Idempotency Guard: Prevents double-invocation of onSessionStopped by racing actors
+        this.stoppingSessionIds = new Set();
+    }
+    onSessionStarted(capabilities, session, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Store device info for this session
+            this.sessionToDevice.set(session.getId(), device);
+            const createOptions = {
+                id: session.getId(),
+            };
+            // create directory to store screenshots, videos and log files for the session
+            (0, asset_manager_1.prepareDirectory)(session.getId());
+            // Initialize app profiling for Android sessions
+            const { is_profiling_available, device_info } = yield this.startAppProfiling(session.getId(), device, session.getCapabilities());
+            // If iOS real device, start performance recording (Time Profiler)
+            // Note: This only works on real devices with XCUITest driver 4.5+
+            let isIosProfilingStarted = false;
+            if (device.platform.toLowerCase() === 'ios' && device.realDevice === true) {
+                logger_1.default.info(`[Profiling] Starting iOS performance recording for session ${session.getId()}`);
+                try {
+                    yield session.startPerformanceRecording();
+                    isIosProfilingStarted = true;
+                    logger_1.default.info(`[Profiling] ✅ iOS performance recording started for ${session.getId()}`);
+                }
+                catch (err) {
+                    logger_1.default.warn(`[Profiling] Failed to start iOS performance recording: ${err.message}`);
+                    // Not a fatal error - profiling is optional
+                }
+            }
+            // start video recording is now handled in plugin.ts createSession to avoid double calls
+            const videoMsg = `📹 Video recording capability for session ${session.getId()}: ${capabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.VIDEO_RECORDING]}`;
+            logger_1.default.info(videoMsg);
+            const buildName = capabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.BUILD_NAME] || 'Default Build';
+            const build = yield (0, session_service_1.getOrCreateNewBuild)(buildName);
+            const sessionResponse = lodash_1.default.assign({}, session.getCapabilities());
+            const tracingService = typedi_1.Container.get(TracingService_1.TracingService);
+            const traceId = tracingService.getTraceId(session.getId());
+            const createData = {
+                id: session.getId(),
+                build: build.id ? { connect: { id: build.id } } : undefined,
+                name: capabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.SESSION_NAME] || undefined,
+                desired_capabilities: JSON.stringify(sessionResponse.desired || {}),
+                session_capabilities: JSON.stringify(lodash_1.default.omit(sessionResponse, 'desired')),
+                node_id: device.nodeId || '',
+                has_live_video: session.getLiveVideoUrl() !== null,
+                video_recording_enabled: capabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.VIDEO_RECORDING] === true,
+                is_profiling_available: is_profiling_available || isIosProfilingStarted,
+                device_info: device_info ? JSON.stringify(device_info) : null,
+                device_udid: device.udid || '',
+                device_platform: device.platform || '',
+                device_version: device.sdk || '',
+                device_name: device.name,
+                trace_id: traceId,
+                status: 'running', // Principal Polish: Set status explicitly
+            };
+            yield prisma_1.prisma.session.create({
+                data: createData,
+            });
+            // Emit session started event
+            typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard(SocketEvents_1.SocketEvents.SESSION_STARTED, Object.assign(Object.assign({}, createData), { status: 'running', build_name: buildName }));
+            // Increment Metrics
+            typedi_1.Container.get(MetricsService_1.MetricsService).incrementSessionStart();
+        });
+    }
+    onSessionStopped(sessionId, status, failureReason) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            // Idempotency Guard: If this session is already being stopped by another actor
+            // (heartbeat, stream watchdog, plugin.deleteSession), skip to avoid double-cleanup.
+            if (this.stoppingSessionIds.has(sessionId)) {
+                logger_1.default.info(`⏭️ onSessionStopped already in progress for ${sessionId}. Skipping duplicate call.`);
+                return;
+            }
+            this.stoppingSessionIds.add(sessionId);
+            try {
+                logger_1.default.info(`🟢 onSessionStopped called for session ${sessionId}`);
+                // Video recording is now handled in plugin.ts deleteSession() before the session is deleted
+                // This ensures we can call stop_recording_screen while the session is still active
+                // Here we just handle the session status update
+                const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+                if (session) {
+                    logger_1.default.info(`Session ${sessionId} found in SESSION_MANAGER`);
+                    // Save Android profiling data before cleanup
+                    yield this.saveAppProfilingData(sessionId);
+                    // iOS profiling is now handled in plugin.ts deleteSession() before the session is deleted
+                    // This ensures we can call mobile: stopPerfRecord while the driver is still alive
+                    // Clean up syslog service for real iOS devices
+                    const udid = this.sessionToUdid.get(sessionId);
+                    if (udid) {
+                        try {
+                            this.syslogServices.delete(udid);
+                            this.sessionToUdid.delete(sessionId);
+                            logger_1.default.info(`Cleaned up syslog service for device ${udid}`);
+                        }
+                        catch (err) {
+                            logger_1.default.debug(`Error cleaning up syslog service info: ${err}`);
+                        }
+                    }
+                    // Clean up last log line tracking
+                    this.lastLogLine.delete(sessionId);
+                    // Principal Resource Management: Unblock device immediately
+                    const device = this.sessionToDevice.get(sessionId);
+                    if (device) {
+                        const { unblockDevice } = yield Promise.resolve().then(() => __importStar(require('../data-service/device-service')));
+                        try {
+                            yield unblockDevice(device.udid, device.host);
+                            logger_1.default.info(`🔓 [${sessionId}] Device ${device.udid} released.`);
+                        }
+                        catch (unblockErr) {
+                            const msg = (_a = unblockErr === null || unblockErr === void 0 ? void 0 : unblockErr.message) !== null && _a !== void 0 ? _a : String(unblockErr);
+                            logger_1.default.error(`⚠️ Failed to unblock device ${device.udid} for session ${sessionId}: ${msg}`, unblockErr);
+                        }
+                    }
+                    else {
+                        const { unblockDeviceMatchingFilter } = yield Promise.resolve().then(() => __importStar(require('../data-service/device-service')));
+                        try {
+                            yield unblockDeviceMatchingFilter({ session_id: sessionId });
+                            logger_1.default.info(`🔓 [${sessionId}] Device released via session_id fallback.`);
+                        }
+                        catch (unblockErr) {
+                            const msg = (_b = unblockErr === null || unblockErr === void 0 ? void 0 : unblockErr.message) !== null && _b !== void 0 ? _b : String(unblockErr);
+                            logger_1.default.error(`⚠️ Failed to unblock device for session ${sessionId}: ${msg}`, unblockErr);
+                        }
+                    }
+                    // Final local cleanup to prevent state leaks
+                    this.sessionToDevice.delete(sessionId);
+                    this.lastLogLine.delete(sessionId);
+                    const orphanUdid = this.sessionToUdid.get(sessionId);
+                    if (orphanUdid) {
+                        this.sessionToUdid.delete(sessionId);
+                        this.syslogServices.delete(orphanUdid);
+                    }
+                }
+                else {
+                    logger_1.default.warn(`⚠️ Session ${sessionId} not found in SESSION_MANAGER`);
+                    // Fallback: If session not in manager, attempt to unblock by session_id in store
+                    const { unblockDeviceMatchingFilter } = yield Promise.resolve().then(() => __importStar(require('../data-service/device-service')));
+                    try {
+                        yield unblockDeviceMatchingFilter({ session_id: sessionId });
+                        logger_1.default.info(`🔓 [${sessionId}] Orphaned device released via session_id fallback.`);
+                    }
+                    catch (unblockErr) {
+                        const msg = (_c = unblockErr === null || unblockErr === void 0 ? void 0 : unblockErr.message) !== null && _c !== void 0 ? _c : String(unblockErr);
+                        logger_1.default.error(`⚠️ Failed to unblock device for orphaned session ${sessionId}: ${msg}`, unblockErr);
+                    }
+                    finally {
+                        this.sessionToDevice.delete(sessionId);
+                        this.lastLogLine.delete(sessionId);
+                        const orphanUdid = this.sessionToUdid.get(sessionId);
+                        if (orphanUdid) {
+                            this.sessionToUdid.delete(sessionId);
+                            this.syslogServices.delete(orphanUdid);
+                        }
+                    }
+                }
+                const sessionEntry = yield (0, session_service_1.getSessionById)(sessionId);
+                if (sessionEntry) {
+                    logger_1.default.info(`Session ${sessionId} current status: ${sessionEntry.status}`);
+                    const updateData = {
+                        endTime: new Date(),
+                        has_live_video: false,
+                    };
+                    // Principal Intelligence: Determined final status based on command history
+                    if (status) {
+                        updateData['status'] = status;
+                        if (failureReason)
+                            updateData['failure_reason'] = failureReason;
+                    }
+                    else if (sessionEntry.status === SessionStatus_1.SessionStatus.RUNNING ||
+                        !sessionEntry.status ||
+                        sessionEntry.status === SessionStatus_1.SessionStatus.UNMARKED) {
+                        // Check if any command failed in this session
+                        const failedCommand = yield prisma_1.prisma.sessionLog.findFirst({
+                            where: { session_id: sessionId, is_error: true },
+                            orderBy: { createdAt: 'desc' },
+                        });
+                        if (failedCommand) {
+                            updateData['status'] = SessionStatus_1.SessionStatus.FAILED;
+                            updateData['failure_reason'] =
+                                failedCommand.response && failedCommand.response.includes('error')
+                                    ? ((_d = (0, helpers_1.safeParseJson)(failedCommand.response).value) === null || _d === void 0 ? void 0 : _d.error) ||
+                                        `Command failed: ${failedCommand.command_name}`
+                                    : `Command failed: ${failedCommand.command_name}`;
+                            logger_1.default.info(`Session ${sessionId} marked as FAILED due to error in command: ${failedCommand.command_name}`);
+                        }
+                        else {
+                            updateData['status'] = SessionStatus_1.SessionStatus.SUCCESS;
+                            logger_1.default.info(`Session ${sessionId} marked as SUCCESS`);
+                        }
+                    }
+                    else {
+                        // Principal Reliability: If the session already has a terminal status,
+                        // ensure we still use that status for metrics and events below.
+                        updateData['status'] = sessionEntry.status;
+                    }
+                    yield (0, session_service_1.updateSessionDetails)(sessionId, updateData);
+                    logger_1.default.info(`✅ Session ${sessionId} updated successfully`);
+                    // 🟢 Socket Events must happen AFTER DB update and MUST include a status
+                    // to ensure the UI row changes from 'RUNNING' to its final state.
+                    typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard(SocketEvents_1.SocketEvents.SESSION_STOPPED, {
+                        id: sessionId,
+                        status: updateData.status || sessionEntry.status || SessionStatus_1.SessionStatus.SUCCESS,
+                        failure_reason: updateData.failure_reason || sessionEntry.failure_reason,
+                    });
+                    // Principal Analytics: Increment Metrics AFTER emission
+                    if (updateData.status === SessionStatus_1.SessionStatus.SUCCESS) {
+                        typedi_1.Container.get(MetricsService_1.MetricsService).incrementSessionSuccess();
+                    }
+                    else if (updateData.status === SessionStatus_1.SessionStatus.FAILED) {
+                        typedi_1.Container.get(MetricsService_1.MetricsService).incrementSessionFailure();
+                    }
+                    // Principal Triage: If session failed, perform intelligent failure analysis
+                    if (updateData.status === SessionStatus_1.SessionStatus.FAILED) {
+                        try {
+                            const { analyzeSessionFailure } = yield Promise.resolve().then(() => __importStar(require('./services/failure-analysis-service')));
+                            yield analyzeSessionFailure(sessionId);
+                        }
+                        catch (analysisErr) {
+                            logger_1.default.warn(`⚠️ Failure analysis skipped for ${sessionId}: ${analysisErr.message}`);
+                        }
+                    }
+                }
+                else {
+                    logger_1.default.warn(`⚠️ Session ${sessionId} not found in database`);
+                }
+            }
+            finally {
+                // Always release the idempotency lock so future cleanup calls
+                // (e.g., manual recovery) can proceed if needed.
+                this.stoppingSessionIds.delete(sessionId);
+            }
+        });
+    }
+    beforeSessionCommand(sessionId, commandName, request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (commandName) {
+                this.commandStartTime.set(`${sessionId}:${commandName}`, Date.now());
+                logger_1.default.debug(`[EventManager] beforeSessionCommand: sessionId=${sessionId}, commandName=${commandName}`);
+            }
+            // Principal Interception: Handle Xenon-specific commands regardless of session state in memory
+            if (commandName === 'execute') {
+                const script = ((_a = request.body) === null || _a === void 0 ? void 0 : _a.script) || (Array.isArray(request.body) ? request.body[0] : undefined);
+                if (script && commands_1.dashboardCommands.isDashboardCommand(script)) {
+                    logger_1.default.info(`[EventManager] Intercepting Xenon command: ${script} for session ${sessionId}`);
+                    yield commands_1.dashboardCommands.process(sessionId, request, response);
+                    return false;
+                }
+                else if (script && script.includes(':')) {
+                    logger_1.default.debug(`[EventManager] Custom command ${script} not handled by Xenon. Passing to driver.`);
+                }
+            }
+            const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+            if (!session) {
+                logger_1.default.debug(`[EventManager] No session object found in memory for ${sessionId}. Allowing command ${commandName} to proceed.`);
+                return true;
+            }
+            if (commandName === 'deleteSession') {
+                // Video recording is handled in onSessionStoped() called after deleteSession
+                // No need to handle it here to avoid race conditions
+            }
+            return true;
+        });
+    }
+    afterSessionCommand(sessionId, commandName, driver, request, response, responseBody, healingInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+            if (session) {
+                try {
+                    // Save device logs (only if driver is available)
+                    if (driver) {
+                        yield this.saveDeviceLogs(sessionId, driver);
+                    }
+                    // Save command log
+                    const parsedResponse = (0, helpers_1.safeParseJson)(responseBody);
+                    const isSuccessResponse = !((_a = parsedResponse === null || parsedResponse === void 0 ? void 0 : parsedResponse.value) === null || _a === void 0 ? void 0 : _a.error);
+                    const tracingService = typedi_1.Container.get(TracingService_1.TracingService);
+                    const spanId = tracingService.getSpanId(`${session.getId()}:${commandName}`);
+                    const traceId = tracingService.getTraceId(session.getId());
+                    const startTime = this.commandStartTime.get(`${sessionId}:${commandName}`);
+                    const duration = startTime ? Date.now() - startTime : null;
+                    const logEntry = {
+                        session_id: session.getId(),
+                        command_name: commandName || null,
+                        body: JSON.stringify(request.body),
+                        response: responseBody,
+                        is_success: isSuccessResponse,
+                        is_error: !isSuccessResponse,
+                        method: request.method,
+                        title: this.getTitleFromCommandName(commandName),
+                        subtitle: '',
+                        screenshot: null,
+                        url: request.originalUrl,
+                        is_healed: !!healingInfo,
+                        original_selector: (healingInfo === null || healingInfo === void 0 ? void 0 : healingInfo.originalSelector) || null,
+                        healed_selector: (healingInfo === null || healingInfo === void 0 ? void 0 : healingInfo.healedSelector) || null,
+                        healing_confidence: (healingInfo === null || healingInfo === void 0 ? void 0 : healingInfo.confidence) || null,
+                        span_id: spanId,
+                        trace_id: traceId,
+                        duration: duration,
+                    };
+                    // Increment Healing Metrics
+                    if (healingInfo) {
+                        typedi_1.Container.get(MetricsService_1.MetricsService).incrementHealingAttempt();
+                        if (isSuccessResponse) {
+                            typedi_1.Container.get(MetricsService_1.MetricsService).incrementHealingSuccess();
+                        }
+                    }
+                    if (startTime) {
+                        this.commandStartTime.delete(`${sessionId}:${commandName}`);
+                    }
+                    // Take screenshots for specific commands (like click, setValue, etc.)
+                    // OR on failure if SCREENSHOT_ON_FAILURE capability is enabled
+                    const shouldTakeScreenshotForCommand = commandName && config_1.config.takeScreenshotsFor.indexOf(commandName) >= 0;
+                    const screenShotCapability = session.getXenonOption(XenonCapabilityManager_1.XENON_CAPABILITIES.SCREENSHOT_ON_FAILURE, false);
+                    const screenshotEveryCommandCapability = session.getXenonOption(XenonCapabilityManager_1.XENON_CAPABILITIES.SCREENSHOT_ON_EVERY_COMMAND, false);
+                    const shouldTakeScreenshotOnFailure = !lodash_1.default.isNil(screenShotCapability) &&
+                        screenShotCapability.toString() === 'true' &&
+                        !isSuccessResponse;
+                    const shouldTakeScreenshotOnEveryCommand = !lodash_1.default.isNil(screenshotEveryCommandCapability) &&
+                        screenshotEveryCommandCapability.toString() === 'true';
+                    if (shouldTakeScreenshotForCommand ||
+                        shouldTakeScreenshotOnFailure ||
+                        shouldTakeScreenshotOnEveryCommand) {
+                        let screenshotBase64 = null;
+                        try {
+                            // Principal Intelligence: Always prefer session.getScreenShot() because it contains
+                            // platform-specific optimizations (like direct, high-speed ADB capture for Android).
+                            screenshotBase64 = yield session.getScreenShot();
+                        }
+                        catch (err) {
+                            logger_1.default.warn(`[Dashboard] Session-level screenshot failed for ${sessionId}: ${err.message}. Trying direct driver...`);
+                            if (driver) {
+                                try {
+                                    screenshotBase64 = yield (0, helpers_2.takeScreenshot)(driver);
+                                }
+                                catch (driverErr) {
+                                    logger_1.default.error(`[Dashboard] Driver screenshot also failed: ${driverErr.message}`);
+                                }
+                            }
+                        }
+                        if (screenshotBase64) {
+                            logEntry['screenshot'] = (0, asset_manager_1.saveScreenShot)(session.getId(), screenshotBase64);
+                        }
+                    }
+                    yield prisma_1.prisma.sessionLog.create({
+                        data: logEntry,
+                    });
+                    // Emit command log event to dashboard
+                    typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard(SocketEvents_1.SocketEvents.SESSION_COMMAND, Object.assign({ session_id: session.getId() }, logEntry));
+                }
+                catch (err) {
+                    logger_1.default.error(`[Dashboard] Failed to process command telemetry for ${sessionId}: ${err.message}`);
+                }
+            }
+        });
+    }
+    onSessionLog(sessionId, logEntry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield prisma_1.prisma.log.create({
+                data: {
+                    session_id: sessionId,
+                    log_type: logEntry.level.toUpperCase(),
+                    message: logEntry.message,
+                    timestamp: new Date(),
+                },
+            });
+        });
+    }
+    getTitleFromCommandName(commandName) {
+        if (commandName) {
+            return commandName.replace(/([A-Z])/g, ' $1').replace(/^./, function (str) {
+                return str.toUpperCase();
+            });
+        }
+        return undefined;
+    }
+    getDeviceLogs(driver, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!driver || !driver.caps || !driver.caps.automationName) {
+                    return [];
+                }
+                const automationName = driver.caps.automationName.toLowerCase();
+                // Get device info for this session
+                const device = this.sessionToDevice.get(sessionId);
+                // Use Appium driver's extractLogs method for proper log extraction
+                if (automationName === 'xcuitest' && typeof driver.extractLogs === 'function') {
+                    try {
+                        // Check if this is a real iOS device using device.realDevice property
+                        const isRealDevice = (device === null || device === void 0 ? void 0 : device.realDevice) === true;
+                        logger_1.default.debug(`Device info for session ${sessionId} - isRealDevice: ${isRealDevice}, deviceType: ${device === null || device === void 0 ? void 0 : device.deviceType}, UDID: ${device === null || device === void 0 ? void 0 : device.udid}`);
+                        if (isRealDevice) {
+                            // For real iOS devices, use appium-ios-device syslog service
+                            const udid = driver.caps.udid;
+                            // Track session to UDID mapping for cleanup
+                            this.sessionToUdid.set(sessionId, udid);
+                            // If we don't have a syslog service for this device yet, start one
+                            if (!this.syslogServices.has(udid)) {
+                                try {
+                                    const syslogService = yield appium_ios_device_1.services.startSyslogService(udid);
+                                    const logs = [];
+                                    // Start listening to logs and buffer them
+                                    syslogService.start((logLine) => {
+                                        logs.push(logLine);
+                                    });
+                                    // Store the service and logs
+                                    this.syslogServices.set(udid, { service: syslogService, logs });
+                                    logger_1.default.info(`Started syslog service for real iOS device ${udid}`);
+                                }
+                                catch (err) {
+                                    logger_1.default.debug(`Could not start syslog service for real device: ${err}`);
+                                    return [];
+                                }
+                            }
+                            // Return the buffered logs
+                            const deviceData = this.syslogServices.get(udid);
+                            if (deviceData && deviceData.logs) {
+                                const currentLogs = [...deviceData.logs];
+                                // Clear the buffer after retrieving
+                                deviceData.logs.length = 0;
+                                return currentLogs.map((logLine) => ({ message: logLine, timestamp: Date.now() }));
+                            }
+                            return [];
+                        }
+                        // For iOS simulators, extract syslog
+                        const logs = yield driver.extractLogs('syslog');
+                        return Array.isArray(logs) ? logs : [];
+                    }
+                    catch (err) {
+                        logger_1.default.debug(`Could not extract syslog: ${err}`);
+                        return [];
+                    }
+                }
+                else if (automationName === 'uiautomator2' || (device === null || device === void 0 ? void 0 : device.platform) === 'android') {
+                    try {
+                        if (typeof driver.extractLogs === 'function') {
+                            const logs = yield driver.extractLogs('logcat');
+                            if (Array.isArray(logs) && logs.length > 0) {
+                                return logs;
+                            }
+                        }
+                    }
+                    catch (err) {
+                        logger_1.default.debug(`Could not extract logcat via driver: ${err}. Trying direct ADB...`);
+                    }
+                    // Principal Intelligence: Fallback to direct ADB logs if driver fails or returns nothing
+                    if (device === null || device === void 0 ? void 0 : device.udid) {
+                        try {
+                            const deviceManager = typedi_1.Container.get(device_managers_1.XenonManager);
+                            const androidManager = (yield deviceManager.deviceInstances()).find((m) => m instanceof AndroidDeviceManager_1.default);
+                            if (androidManager) {
+                                const rawLogs = yield androidManager.getLogs(device.udid);
+                                if (rawLogs && typeof rawLogs === 'string') {
+                                    const logLines = rawLogs.split('\n').filter((l) => l.trim().length > 0);
+                                    // Convert string lines to expected format (last 100 lines to avoid DB bloat)
+                                    return logLines.slice(-100).map((line) => ({
+                                        message: line,
+                                        timestamp: Date.now(),
+                                        level: 'INFO',
+                                    }));
+                                }
+                            }
+                        }
+                        catch (adbErr) {
+                            logger_1.default.debug(`Direct ADB log fetch failed for ${device.udid}: ${adbErr.message}`);
+                        }
+                    }
+                }
+                return [];
+            }
+            catch (error) {
+                logger_1.default.error(`Error getting device logs: ${error}`);
+                return [];
+            }
+        });
+    }
+    saveDeviceLogs(sessionId, driver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const logs = yield this.getDeviceLogs(driver, sessionId);
+                if (!logs || logs.length === 0) {
+                    return;
+                }
+                const lastLine = this.lastLogLine.get(sessionId) || 0;
+                const newLogs = logs.slice(lastLine);
+                if (newLogs.length === 0) {
+                    return;
+                }
+                this.lastLogLine.set(sessionId, logs.length);
+                // Save device logs to database
+                const logEntries = newLogs.map((logItem) => ({
+                    session_id: sessionId,
+                    log_type: 'DEVICE',
+                    message: typeof logItem === 'string' ? logItem : logItem.message || JSON.stringify(logItem),
+                    timestamp: logItem.timestamp ? new Date(logItem.timestamp) : new Date(),
+                }));
+                if (logEntries.length > 0) {
+                    for (const logEntry of logEntries) {
+                        yield prisma_1.prisma.log.create({
+                            data: logEntry,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                logger_1.default.error(`Error saving device logs: ${error.message}`);
+            }
+        });
+    }
+    startAppProfiling(sessionId, device, sessionCapabilities) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Only support Android profiling
+            if (device.platform.toLowerCase() !== 'android') {
+                return { is_profiling_available: false };
+            }
+            // Check if we have an app package
+            const appPackage = (sessionCapabilities === null || sessionCapabilities === void 0 ? void 0 : sessionCapabilities.appPackage) || (sessionCapabilities === null || sessionCapabilities === void 0 ? void 0 : sessionCapabilities['appium:appPackage']);
+            if (!appPackage) {
+                logger_1.default.info(`[Profiling] No app package found for session ${sessionId}, skipping profiling`);
+                return { is_profiling_available: false };
+            }
+            try {
+                // Principal Intelligence: Use the Properly configured ADB from the manager
+                // instead of a naked instance, to avoid 'defaultArgs not iterable' crashes.
+                const deviceManager = typedi_1.Container.get(device_managers_1.XenonManager);
+                const androidManager = (yield deviceManager.deviceInstances()).find((m) => m instanceof AndroidDeviceManager_1.default);
+                let adb;
+                if (androidManager) {
+                    adb = yield androidManager.getAdbForDevice(device.udid);
+                }
+                else {
+                    adb = yield appium_adb_1.ADB.createADB({});
+                }
+                // Create app profiler
+                const profiler = new AndroidAppProfiler_1.AndroidAppProfiler({
+                    adb,
+                    deviceUDID: device.udid,
+                    appPackage,
+                });
+                // Get device info and start capture
+                const device_info = yield profiler.getDeviceInfo();
+                yield profiler.startCapture();
+                // Store profiler for this session
+                this.appProfilers.set(sessionId, profiler);
+                logger_1.default.info(`[Profiling] Started app profiling for session ${sessionId}`);
+                return {
+                    is_profiling_available: true,
+                    device_info,
+                };
+            }
+            catch (err) {
+                logger_1.default.error(`[Profiling] Error initializing app profiler for session ${sessionId}: ${err.message}`);
+                return { is_profiling_available: false };
+            }
+        });
+    }
+    saveAppProfilingData(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const profiler = this.appProfilers.get(sessionId);
+            if (!profiler) {
+                return;
+            }
+            try {
+                // Stop capture
+                yield profiler.stopCapture();
+                // Get logs
+                const logs = profiler.getLogs();
+                if (logs.length === 0) {
+                    logger_1.default.info(`[Profiling] No profiling data to save for session ${sessionId}`);
+                    return;
+                }
+                // Save to database
+                const profilingEntries = logs.map((log) => ({
+                    session_id: sessionId,
+                    cpu: log.cpu,
+                    memory: log.memory,
+                    total_cpu_used: log.total_cpu_used.toString(),
+                    total_memory_used: log.total_memory_used.toString(),
+                    raw_cpu_log: log.raw_cpu_log,
+                    raw_memory_log: log.raw_memory_log,
+                    timestamp: new Date(log.timestamp),
+                }));
+                // Batch insert profiling data
+                for (const entry of profilingEntries) {
+                    yield prisma_1.prisma.profiling.create({
+                        data: entry,
+                    });
+                }
+                logger_1.default.info(`[Profiling] Saved ${profilingEntries.length} profiling entries for session ${sessionId}`);
+            }
+            catch (err) {
+                logger_1.default.error(`[Profiling] Error saving profiling data for session ${sessionId}: ${err.message}`);
+            }
+            finally {
+                // Clean up profiler
+                this.appProfilers.delete(sessionId);
+            }
+        });
+    }
+};
+exports.DashboardEventManager = DashboardEventManager;
+exports.DashboardEventManager = DashboardEventManager = __decorate([
+    (0, typedi_2.Service)()
+], DashboardEventManager);
+exports.DASHBORD_EVENT_MANAGER = typedi_1.Container.get(DashboardEventManager);