@xenon-device-management/xenon 1.1.0

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

@@ -0,0 +1,84 @@
+"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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareDirectory = prepareDirectory;
+exports.saveScreenShot = saveScreenShot;
+exports.saveVideoRecording = saveVideoRecording;
+exports.savePerformanceTrace = savePerformanceTrace;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const uuid_1 = require("uuid");
+const logger_1 = __importDefault(require("../logger"));
+const SCREENSHOT_DIRECTORY = 'screenshots';
+const VIDEO_DIRECTORY = 'video';
+const PERFORMANCE_DIRECTORY = 'performance';
+function prepareDirectory(sessionId) {
+    [SCREENSHOT_DIRECTORY, VIDEO_DIRECTORY, PERFORMANCE_DIRECTORY].forEach((folder) => {
+        fs.mkdirSync(path.join(config_1.config.sessionAssetsPath, sessionId, folder), { recursive: true });
+    });
+}
+function saveScreenShot(sessionId, screenshotBase64String) {
+    const directory = path.join(config_1.config.sessionAssetsPath, sessionId, SCREENSHOT_DIRECTORY);
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, { recursive: true });
+    }
+    const assetPath = path.join(sessionId, SCREENSHOT_DIRECTORY, `${(0, uuid_1.v4)()}.png`);
+    const fullPath = path.join(config_1.config.sessionAssetsPath, assetPath);
+    fs.writeFileSync(fullPath, screenshotBase64String, 'base64');
+    logger_1.default.info(`[AssetManager] Saved screenshot for session ${sessionId} at ${fullPath}`);
+    return assetPath;
+}
+function saveVideoRecording(sessionId, videoBase64String) {
+    const directory = path.join(config_1.config.sessionAssetsPath, sessionId, VIDEO_DIRECTORY);
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, { recursive: true });
+    }
+    const assetPath = path.join(sessionId, VIDEO_DIRECTORY, `${sessionId}.mp4`);
+    fs.writeFileSync(path.join(config_1.config.sessionAssetsPath, assetPath), videoBase64String, 'base64');
+    return assetPath;
+}
+function savePerformanceTrace(sessionId, traceBase64String) {
+    const directory = path.join(config_1.config.sessionAssetsPath, sessionId, PERFORMANCE_DIRECTORY);
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, { recursive: true });
+    }
+    const assetPath = path.join(sessionId, PERFORMANCE_DIRECTORY, `${sessionId}.zip`);
+    fs.writeFileSync(path.join(config_1.config.sessionAssetsPath, assetPath), traceBase64String, 'base64');
+    return assetPath;
+}

package/lib/src/dashboard/commands.js

@@ -0,0 +1,284 @@
+"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 __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.dashboardCommands = exports.DashboardCommands = void 0;
+const session_service_1 = require("./services/session-service");
+const prisma_1 = require("../prisma");
+const logger_1 = __importDefault(require("../logger"));
+const lodash_1 = __importDefault(require("lodash"));
+const SessionManager_1 = require("../sessions/SessionManager");
+const asset_manager_1 = require("./asset-manager");
+class DashboardCommands {
+    isDashboardCommand(commandName) {
+        return commandName.startsWith('xenon') || commandName.startsWith('xe');
+    }
+    process(sessionId, request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { script } = request.body;
+            logger_1.default.info(`[DashboardCommands] Processing command: ${script}`);
+            if (!script) {
+                return this.sendSuccessResponse(response);
+            }
+            const commandName = script.split(':')[1];
+            logger_1.default.info(`[DashboardCommands] Parsed command name: ${commandName}`);
+            if (commandName && commandName.trim()) {
+                const trimmedCommand = commandName.trim();
+                logger_1.default.info(`[DashboardCommands] Trimmed command: ${trimmedCommand}`);
+                switch (trimmedCommand) {
+                    case 'setSessionName':
+                        logger_1.default.info('[DashboardCommands] Executing setSessionName');
+                        return yield this.setSessionName(sessionId, request, response);
+                    case 'setSessionStatus':
+                        logger_1.default.info('[DashboardCommands] Executing setSessionStatus');
+                        return yield this.setSessionStatus(sessionId, request, response);
+                    case 'debug':
+                        logger_1.default.info('[DashboardCommands] Executing debug command');
+                        return yield this.debug(sessionId, request, response);
+                    case 'captureEvidence':
+                        logger_1.default.info('[DashboardCommands] Executing captureEvidence');
+                        return yield this.captureEvidence(sessionId, request, response);
+                    case 'addTag':
+                        logger_1.default.info('[DashboardCommands] Executing addTag');
+                        return yield this.addTag(sessionId, request, response);
+                    default:
+                        logger_1.default.warn(`[DashboardCommands] Unknown command: ${trimmedCommand}`);
+                        return this.sendSuccessResponse(response);
+                }
+            }
+            return this.sendSuccessResponse(response);
+        });
+    }
+    sendSuccessResponse(response) {
+        return response.status(200).json({ value: null });
+    }
+    /* Commands */
+    /**
+     * Set the name of current test(session)
+     *
+     * driver.executeScript("xenon: setSessionName", "MyTestName")
+     * or
+     * driver.executeScript("xenon: setSessionName", {"name": "MyTestName"})
+     */
+    setSessionName(sessionId, request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { args } = request.body;
+            yield (0, session_service_1.updateSessionDetails)(sessionId, {
+                name: typeof args[0] === 'object' && args[0].name ? args[0].name : args[0],
+            });
+            return this.sendSuccessResponse(response);
+        });
+    }
+    /**
+     * Update the status of the session
+     *
+     * driver.executeScript("xenon: setSessionStatus", {"status": "passed/failed", "reason": "optional reason"})
+     */
+    setSessionStatus(sessionId, request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { args } = request.body;
+            let statusArg = {};
+            if (lodash_1.default.isArray(args)) {
+                if (typeof args[0] === 'object') {
+                    statusArg = args[0];
+                }
+                else {
+                    // Handle positional: executeScript("xe:setSessionStatus", "failed", "reason")
+                    statusArg = {
+                        status: args[0],
+                        reason: args[1],
+                    };
+                }
+            }
+            else if (typeof args === 'object') {
+                statusArg = args;
+            }
+            // Normalize input
+            const inputStatus = (statusArg.status || '').toLowerCase();
+            const validStatuses = ['success', 'failed', 'passed'];
+            if (!validStatuses.includes(inputStatus)) {
+                logger_1.default.warn(`[DashboardCommands] Invalid status: ${statusArg.status}. Valid: ${validStatuses.join(', ')}`);
+                return this.sendSuccessResponse(response);
+            }
+            // Normalize 'passed' to 'success' for consistency with SessionStatus enum
+            const normalizedStatus = inputStatus === 'passed' ? 'success' : inputStatus;
+            yield (0, session_service_1.updateSessionDetails)(sessionId, {
+                status: normalizedStatus,
+                failure_reason: statusArg.reason || undefined,
+            });
+            // --- REAL-TIME UI UPDATE ---
+            // Principal Speed: Emit a socket event so the dashboard row updates immediately.
+            const { SocketServer } = yield Promise.resolve().then(() => __importStar(require('../services/SocketServer')));
+            const { Container } = yield Promise.resolve().then(() => __importStar(require('typedi')));
+            const { SocketEvents } = yield Promise.resolve().then(() => __importStar(require('../enums/SocketEvents')));
+            Container.get(SocketServer).emitToDashboard(SocketEvents.SESSION_STOPPED, {
+                id: sessionId,
+                status: normalizedStatus,
+                failure_reason: args.reason || undefined,
+            });
+            return this.sendSuccessResponse(response);
+        });
+    }
+    /**
+     * Add debug logs to the session
+     *
+     * driver.executeScript("xenon: debug", {"message": "Debug message"})
+     * or
+     * driver.executeScript("xenon: debug", "Debug message")
+     */
+    debug(sessionId, request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { args } = request.body;
+            const logData = lodash_1.default.isArray(args) ? args[0] : args;
+            // Support both string and object format
+            const message = typeof logData === 'string' ? logData : logData.message || JSON.stringify(logData);
+            yield prisma_1.prisma.log.create({
+                data: {
+                    session_id: sessionId,
+                    log_type: 'DEBUG',
+                    message: message,
+                },
+            });
+            return this.sendSuccessResponse(response);
+        });
+    }
+    /**
+     * Capture evidence (screenshot) with optional reason/label
+     *
+     * driver.executeScript("xenon: captureEvidence", {"reason": "Login failed", "label": "error_state"})
+     * or
+     * driver.executeScript("xenon: captureEvidence", "Checkpoint reached")
+     */
+    captureEvidence(sessionId, request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { args } = request.body;
+            const evidenceData = lodash_1.default.isArray(args) ? args[0] : args;
+            const reason = typeof evidenceData === 'string' ? evidenceData : evidenceData.reason || 'Manual capture';
+            const label = typeof evidenceData === 'object' ? evidenceData.label : undefined;
+            try {
+                const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+                if (!session) {
+                    logger_1.default.warn(`[DashboardCommands] captureEvidence: Session ${sessionId} not found`);
+                    return this.sendSuccessResponse(response);
+                }
+                const screenshotBase64 = yield session.getScreenShot();
+                if (screenshotBase64) {
+                    const screenshotPath = (0, asset_manager_1.saveScreenShot)(sessionId, screenshotBase64);
+                    // Log the evidence capture
+                    yield prisma_1.prisma.sessionLog.create({
+                        data: {
+                            session_id: sessionId,
+                            command_name: 'captureEvidence',
+                            body: JSON.stringify({ reason, label }),
+                            response: JSON.stringify({ captured: true }),
+                            is_success: true,
+                            is_error: false,
+                            method: 'POST',
+                            title: 'Evidence Captured',
+                            subtitle: reason,
+                            screenshot: screenshotPath,
+                            url: '/execute/sync',
+                        },
+                    });
+                    logger_1.default.info(`[DashboardCommands] Evidence captured for ${sessionId}: ${reason}`);
+                }
+            }
+            catch (err) {
+                logger_1.default.error(`[DashboardCommands] captureEvidence failed: ${err.message}`);
+            }
+            return this.sendSuccessResponse(response);
+        });
+    }
+    /**
+     * Add searchable tags to the session
+     *
+     * driver.executeScript("xenon: addTag", {"tag": "regression"})
+     * or
+     * driver.executeScript("xenon: addTag", "smoke-test")
+     */
+    addTag(sessionId, request, response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { args } = request.body;
+            const tagData = lodash_1.default.isArray(args) ? args[0] : args;
+            const newTag = typeof tagData === 'string' ? tagData : tagData.tag;
+            if (!newTag) {
+                logger_1.default.warn('[DashboardCommands] addTag: No tag provided');
+                return this.sendSuccessResponse(response);
+            }
+            try {
+                // Get current session to append tag
+                const session = yield prisma_1.prisma.session.findUnique({
+                    where: { id: sessionId },
+                    select: { tags: true },
+                });
+                // Parse existing tags or initialize empty array
+                let existingTags = [];
+                if (session === null || session === void 0 ? void 0 : session.tags) {
+                    try {
+                        existingTags = JSON.parse(session.tags);
+                    }
+                    catch (_a) {
+                        existingTags = [];
+                    }
+                }
+                // Add new tag if not already present
+                if (!existingTags.includes(newTag)) {
+                    existingTags.push(newTag);
+                    yield (0, session_service_1.updateSessionDetails)(sessionId, {
+                        tags: JSON.stringify(existingTags),
+                    });
+                    logger_1.default.info(`[DashboardCommands] Tag added to ${sessionId}: ${newTag}`);
+                }
+            }
+            catch (err) {
+                logger_1.default.error(`[DashboardCommands] addTag failed: ${err.message}`);
+            }
+            return this.sendSuccessResponse(response);
+        });
+    }
+}
+exports.DashboardCommands = DashboardCommands;
+exports.dashboardCommands = new DashboardCommands();