@xenon-device-management/xenon 1.1.0

package/lib/src/logger.js

@@ -0,0 +1,225 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XenonLogger = void 0;
+exports.redactSecrets = redactSecrets;
+const support_1 = require("@appium/support");
+/**
+ * Keys whose values must never appear in log output.
+ * Case-insensitive substring matching is used so 'myApiKey' and 'API_KEY' both match.
+ */
+const SENSITIVE_KEY_PATTERNS = [
+    'apikey',
+    'api_key',
+    'secret',
+    'password',
+    'token',
+    'accesstoken',
+    'refreshtoken',
+    'dburl',
+    'databaseurl',
+    'clientsecret',
+    'privatekey',
+    'auth',
+    'credentials',
+    'secretkey',
+];
+const REDACTED = '***REDACTED***';
+function isSensitiveKey(key) {
+    const lower = key.toLowerCase().replace(/[_-]/g, '');
+    return SENSITIVE_KEY_PATTERNS.some((p) => lower.includes(p));
+}
+/**
+ * Deep-clone an object, replacing values of sensitive keys with ***REDACTED***.
+ * Safe to call before JSON.stringify for logging.
+ */
+function redactSecrets(obj) {
+    if (obj === null || obj === undefined) {
+        return obj;
+    }
+    // Deep Intelligence: also redact keys from strings if they look like our API keys
+    if (typeof obj === 'string') {
+        let result = obj;
+        // Common pattern for Gemini/OpenAI/Anthropic keys in logs
+        const keyPatterns = [/AIza[a-zA-Z0-9-_]{35}/g, /sk-[a-zA-Z0-9]{32,}/g];
+        for (const pattern of keyPatterns) {
+            result = result.split(pattern).join(REDACTED);
+        }
+        return result;
+    }
+    if (typeof obj !== 'object') {
+        return obj;
+    }
+    const seen = new WeakSet();
+    const redact = (value) => {
+        if (value === null || value === undefined)
+            return value;
+        if (typeof value === 'string') {
+            let s = value;
+            const keyPatterns = [/AIza[a-zA-Z0-9-_]{35}/g, /sk-[a-zA-Z0-9]{32,}/g];
+            for (const pattern of keyPatterns) {
+                s = s.replace(pattern, REDACTED);
+            }
+            return s;
+        }
+        if (typeof value !== 'object')
+            return value;
+        if (seen.has(value)) {
+            return '[Circular]';
+        }
+        seen.add(value);
+        if (Array.isArray(value)) {
+            return value.map((item) => redact(item));
+        }
+        const result = {};
+        for (const [key, v] of Object.entries(value)) {
+            if (isSensitiveKey(key)) {
+                result[key] = REDACTED;
+            }
+            else {
+                result[key] = redact(v);
+            }
+        }
+        return result;
+    };
+    return redact(obj);
+}
+/**
+ * Enterprise-grade logger for Xenon.
+ * Wraps @appium/support logger with contextual capabilities.
+ */
+class XenonLogger {
+    constructor(prefix = 'xenon') {
+        this.context = '';
+        this.baseLogger = support_1.logger.getLogger(prefix);
+    }
+    /**
+     * Configure global logger settings
+     */
+    static configure(options) {
+        if (options.enableJsonLogging !== undefined) {
+            this.isJsonLogging = options.enableJsonLogging;
+        }
+    }
+    /**
+     * Creates a sub-logger with a specific component scope.
+     * Example: log.scope('DeviceManager') -> [DeviceManager] Info Message
+     */
+    scope(name) {
+        const scoped = new XenonLogger();
+        scoped.baseLogger = this.baseLogger;
+        scoped.context = `[${name}] `;
+        return scoped;
+    }
+    /**
+     * Attaches session context to the logger.
+     * Example: log.withSession('abc-123') -> [abc-123] Message
+     */
+    withSession(sessionId, udid) {
+        const sessionLogger = new XenonLogger();
+        sessionLogger.baseLogger = this.baseLogger;
+        const udidPart = udid ? `:${udid}` : '';
+        sessionLogger.context = `${this.context}[${sessionId}${udidPart}] `;
+        return sessionLogger;
+    }
+    logMessage(level, message, ...args) {
+        const redactedMessage = redactSecrets(message);
+        const redactedArgs = args.map((arg) => redactSecrets(arg));
+        if (XenonLogger.isJsonLogging) {
+            const logEntry = {
+                timestamp: new Date().toISOString(),
+                level,
+                scope: this.context.trim() || 'root',
+                message: this.format(redactedMessage),
+                args: redactedArgs.length ? redactedArgs : undefined,
+            };
+            this.baseLogger.info(JSON.stringify(logEntry));
+        }
+        else {
+            this.baseLogger[level](`${this.context}${this.format(redactedMessage)}`, ...redactedArgs);
+        }
+    }
+    info(message, ...args) {
+        this.logMessage('info', message, ...args);
+    }
+    warn(message, ...args) {
+        this.logMessage('warn', message, ...args);
+    }
+    error(message, ...args) {
+        this.logMessage('error', message, ...args);
+    }
+    debug(message, ...args) {
+        this.logMessage('debug', message, ...args);
+    }
+    /**
+     * Enterprise Audit entry.
+     */
+    audit(action, actor = 'system', details = {}) {
+        const redactedDetails = redactSecrets(details);
+        const detailStr = Object.keys(redactedDetails).length
+            ? ` | Details: ${JSON.stringify(redactedDetails)}`
+            : '';
+        this.baseLogger.info(`[AUDIT] ${this.context}${action} | Actor: ${actor}${detailStr}`);
+    }
+    /**
+     * Performance instrumentation.
+     */
+    monitor(label, task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const start = Date.now();
+            try {
+                this.debug(`[PERF] Start: ${label}`);
+                const result = yield task();
+                const elapsed = Date.now() - start;
+                this.debug(`[PERF] End: ${label} | Elapsed: ${elapsed}ms`);
+                return result;
+            }
+            catch (err) {
+                const elapsed = Date.now() - start;
+                this.error(`[PERF] Failed: ${label} | Elapsed: ${elapsed}ms | Error: ${err.message}`);
+                throw err;
+            }
+        });
+    }
+    format(message) {
+        if (typeof message === 'object') {
+            try {
+                return JSON.stringify(message);
+            }
+            catch (e) {
+                return String(message);
+            }
+        }
+        return String(message);
+    }
+    banner(version, nodeId) {
+        const splash = `
+\x1b[36m
+  __  __   ______   __   __   ______   __   __    
+ /\\_\\_\\_\\ /\\  ___\\ /\\ "-.\\ \\ /\\  __ \\ /\\ "-.\\ \\   
+ \\/_/\\_\\/_\\\\ \\  __\\ \\ \\ \\-.  \\\\ \\ \\/\\ \\\\ \\ \\-.  \\  
+   /\\_\\_\\_\\ \\ \\_____\\\\ \\_\\\\"\\_\\\\ \\_____\\\\ \\_\\\\"\\_\\ 
+   \\/_/_/_/  \\/_____/ \\/_/ \\/_/ \\/_____/ \\/_/ \\/_/ 
+\x1b[0m
+ :: \x1b[32mXenon Mobile Infrastructure\x1b[0m ::       (v${version})
+
+ [Node ID: ${nodeId}]
+ [Status:  Operational]
+ -------------------------------------------------------------------
+`;
+        this.baseLogger.info(splash);
+    }
+}
+exports.XenonLogger = XenonLogger;
+XenonLogger.isJsonLogging = process.env.XENON_JSON_LOGGING === 'true';
+// Initial main instance
+const mainLogger = new XenonLogger('xenon');
+exports.default = mainLogger;

package/lib/src/plugin.js

@@ -0,0 +1,244 @@
+"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.XenonPlugin = void 0;
+/* eslint-disable no-prototype-builtins */
+require("reflect-metadata");
+const index_1 = __importDefault(require("./commands/index"));
+const base_plugin_1 = __importDefault(require("@appium/base-plugin"));
+const device_service_1 = require("./data-service/device-service");
+const typedi_1 = require("typedi");
+const logger_1 = __importStar(require("./logger"));
+const ip_1 = __importDefault(require("ip"));
+const SessionStatus_1 = require("./types/SessionStatus");
+const AICommandService_1 = require("./services/AICommandService");
+const TracingService_1 = require("./services/TracingService");
+const CommandInterceptor_1 = require("./interceptors/CommandInterceptor");
+const SessionLifecycleService_1 = require("./services/SessionLifecycleService");
+const ServerManager_1 = require("./services/ServerManager");
+const IPluginArgs_1 = require("./interfaces/IPluginArgs");
+const NodeDevices_1 = __importDefault(require("./device-managers/NodeDevices"));
+const SessionManager_1 = require("./sessions/SessionManager");
+const event_manager_1 = require("./dashboard/event-manager");
+const asset_manager_1 = require("./dashboard/asset-manager");
+const session_service_1 = require("./dashboard/services/session-service");
+const DEVICE_MANAGER_LOCK_NAME = 'DeviceManager';
+class XenonPlugin extends base_plugin_1.default {
+    constructor(pluginName, cliArgs) {
+        super(pluginName, cliArgs);
+        this.xenonLog = logger_1.default.scope('Plugin');
+        this.pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs);
+        this.aiCommandService = typedi_1.Container.get(AICommandService_1.AICommandService);
+        this.xenonLog.debug(`📱 Plugin Args: ${JSON.stringify(cliArgs)}`);
+        this.pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs, this.cliArgs);
+        logger_1.XenonLogger.configure({ enableJsonLogging: this.pluginArgs.enableJsonLogging });
+        if (this.pluginArgs.bindHostOrIp === undefined) {
+            this.pluginArgs.bindHostOrIp = ip_1.default.address();
+        }
+    }
+    /**
+     * Intercepts all commands for local sessions to capture logs
+     */
+    handle(next, driver, commandName, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).handle(next, driver, commandName, args, this.pluginArgs, XenonPlugin.IS_HUB);
+        });
+    }
+    onUnexpectedShutdown(driver, _cause) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const sessionId = driver.sessionId;
+            const deviceFilter = {
+                session_id: sessionId ? sessionId : undefined,
+                udid: driver.caps && driver.caps.udid ? driver.caps.udid : undefined,
+            };
+            if (this.pluginArgs.hub !== undefined) {
+                yield new NodeDevices_1.default(this.pluginArgs.hub, this.pluginArgs.tlsRejectUnauthorized).unblockDevice(deviceFilter);
+            }
+            else {
+                yield (0, device_service_1.unblockDeviceMatchingFilter)(deviceFilter);
+            }
+            logger_1.default.info(`Unblocking device mapped with filter ${JSON.stringify(deviceFilter)} onUnexpectedShutdown from server`);
+            if (XenonPlugin.IS_HUB && this.pluginArgs.enableDashboard && sessionId) {
+                const sessionLog = this.xenonLog.withSession(sessionId, (_a = driver.caps) === null || _a === void 0 ? void 0 : _a.udid);
+                sessionLog.info('Unexpected shutdown for session, updating dashboard...');
+                const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+                if (session && session.isVideoRecordingInProgress()) {
+                    try {
+                        const videoData = yield session.stopVideoRecording(driver);
+                        if (videoData) {
+                            let videoPath = videoData;
+                            // Principal Heuristic: If it's data (>1000 chars), save it. If it's short, it's a path.
+                            if (videoData.length > 1000) {
+                                videoPath = (0, asset_manager_1.saveVideoRecording)(sessionId, videoData);
+                            }
+                            yield (0, session_service_1.updateSessionDetails)(sessionId, { video_recording: videoPath });
+                        }
+                    }
+                    catch (err) {
+                        logger_1.default.debug(`[${sessionId}] rescue-video: Failed: ${err.message}`);
+                    }
+                }
+                yield event_manager_1.DASHBORD_EVENT_MANAGER.onSessionStopped(sessionId, SessionStatus_1.SessionStatus.FAILED, 'Driver shut down unexpectedly');
+                typedi_1.Container.get(TracingService_1.TracingService).endSpan(sessionId, 'ERROR', {
+                    'xenon.session.stop_reason': 'Unexpected shutdown',
+                });
+            }
+        });
+    }
+    static updateServer(expressApp, httpServer, cliArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield typedi_1.Container.get(ServerManager_1.ServerManager).updateServer(expressApp, httpServer, cliArgs);
+            XenonPlugin.IS_HUB = ServerManager_1.ServerManager.IS_HUB;
+        });
+    }
+    createSession(next, driver, jwpDesCaps, jwpReqCaps, caps) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield typedi_1.Container.get(SessionLifecycleService_1.SessionLifecycleService).createSession(next, driver, caps);
+        });
+    }
+    deleteSession(next, driver, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield typedi_1.Container.get(SessionLifecycleService_1.SessionLifecycleService).deleteSession(next, sessionId || (driver === null || driver === void 0 ? void 0 : driver.sessionId));
+        });
+    }
+    analyzeScreen(driver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.aiCommandService.analyzeScreen(driver);
+        });
+    }
+    assertVisualState(driver, instruction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.aiCommandService.assertVisualState(driver, instruction);
+        });
+    }
+    omniScan(driver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.aiCommandService.omniScan(driver);
+        });
+    }
+    testAiLocator(driver, locator) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.aiCommandService.testAiLocator(driver, locator);
+        });
+    }
+    /**
+     * Omni-Click: OCR-driven smart click by visible text.
+     * Accepts an object payload for compatibility with common plugin patterns.
+     */
+    omniClick(driver, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.aiCommandService.omniClick(driver, payload);
+        });
+    }
+    /**
+     * UI Scan Export: returns UI metadata JSON derived from screenshot OCR + lightweight heuristics.
+     */
+    uiScanExport(driver, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.aiCommandService.uiScanExport(driver, payload);
+        });
+    }
+    /**
+     * Smart Tap: Xenon-native, self-explanatory alias of omniClick.
+     */
+    smartTap(driver, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.aiCommandService.smartTap(driver, payload);
+        });
+    }
+    /**
+     * UI Inventory: Xenon-native, self-explanatory alias of uiScanExport.
+     */
+    uiInventory(driver, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.aiCommandService.uiInventory(driver, payload);
+        });
+    }
+}
+exports.XenonPlugin = XenonPlugin;
+XenonPlugin.nodeBasePath = '';
+XenonPlugin.newMethodMap = {
+    '/session/:sessionId/xenon/analyze': {
+        POST: { command: 'analyzeScreen' },
+    },
+    '/session/:sessionId/xenon/assert': {
+        POST: { command: 'assertVisualState' },
+    },
+    '/session/:sessionId/xenon/omni-scan': {
+        GET: { command: 'omniScan' },
+    },
+    '/session/:sessionId/xenon/test-locator': {
+        POST: { command: 'testAiLocator' },
+    },
+    // Xenon Omni-Interaction: Enterprise-grade AI/OCR actions
+    '/session/:sessionId/xenon/omni-click': {
+        POST: { command: 'omniClick' },
+    },
+    // Xenon Smart Interaction: clearer, primary name (alias of omniClick)
+    '/session/:sessionId/xenon/smart-tap': {
+        POST: { command: 'smartTap' },
+    },
+    // Xenon UI Scan: Rich OCR-driven UI metadata export
+    '/session/:sessionId/xenon/ui-scan-export': {
+        POST: { command: 'uiScanExport' },
+    },
+    // Xenon UI Inventory: clearer, primary name (alias of uiScanExport)
+    '/session/:sessionId/xenon/ui-inventory': {
+        POST: { command: 'uiInventory' },
+    },
+    // Compatibility aliases (Lens-style client code can keep working)
+    // These do NOT change Xenon's public naming; they are optional shims.
+    '/session/:sessionId/plugin/ai-appium-lens/aiClick': {
+        POST: { command: 'smartTap' },
+    },
+    '/session/:sessionId/plugin/ai-appium-lens/fetchUIElementsMetadataJson': {
+        POST: { command: 'uiInventory' },
+    },
+};
+XenonPlugin.IS_HUB = false;
+Object.assign(XenonPlugin.prototype, index_1.default);

package/lib/src/prisma.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prisma = void 0;
+const client_1 = require("@prisma/client");
+const config_1 = require("./config");
+exports.prisma = new client_1.PrismaClient({
+    datasources: {
+        db: {
+            url: config_1.config.databaseUrl,
+        },
+    },
+});