@xenon-device-management/xenon 1.1.0

package/lib/src/services/InspectorService.js

@@ -0,0 +1,395 @@
+"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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+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.InspectorService = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const PluginContext_1 = require("../PluginContext");
+const fast_xml_parser_1 = require("fast-xml-parser");
+let InspectorService = class InspectorService {
+    constructor(context) {
+        this.context = context;
+        this.log = logger_1.default.scope('Inspector');
+        this.parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '',
+            parseAttributeValue: true,
+        });
+    }
+    getSnapshot(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.log.info(`Generating deep snapshot for device: ${udid}`);
+                // 1. Get Device Manager
+                const device = yield typedi_1.Container.get('DeviceStore').findDevice({ udid });
+                if (!device)
+                    throw new Error(`Device ${udid} not found`);
+                let manager;
+                if (device.platform === 'android') {
+                    manager = typedi_1.Container.get('AndroidDeviceManager');
+                }
+                else {
+                    manager = typedi_1.Container.get('IOSDeviceManager');
+                }
+                // 2. Parallel Capture (Native Source + Screenshot)
+                const [screenshotBase64, xmlSource] = yield Promise.all([
+                    manager.getScreenshot
+                        ? manager.getScreenshot(udid)
+                        : Promise.reject('Screenshot not supported'),
+                    manager.getPageSource
+                        ? manager.getPageSource(udid)
+                        : Promise.reject('Page source not supported'),
+                ]);
+                // 3. Ensure Metadata (Lazy load dimensions if missing)
+                if (!device.screenWidth || !device.screenHeight) {
+                    try {
+                        if (manager.getAdditionalDeviceInfo) {
+                            const additional = yield manager.getAdditionalDeviceInfo(device);
+                            Object.assign(device, additional);
+                            // Update store asynchronously
+                            typedi_1.Container.get('DeviceStore')
+                                .updateDevice(udid, device.host, additional)
+                                .catch(() => { });
+                        }
+                    }
+                    catch (e) {
+                        this.log.warn(`Failed to lazy-load dimensions for ${udid}: ${e}`);
+                    }
+                }
+                // 4. Parse Native Hierarchy
+                const hierarchy = this.parseXmlHierarchy(xmlSource, device.platform);
+                return {
+                    udid,
+                    platform: device.platform,
+                    timestamp: new Date().toISOString(),
+                    screenshot: screenshotBase64,
+                    hierarchy,
+                    metadata: {
+                        screenWidth: parseInt(device.screenWidth || '0') || 393, // Fallback to common iPhone width
+                        screenHeight: parseInt(device.screenHeight || '0') || 852,
+                    },
+                };
+            }
+            catch (err) {
+                this.log.error(`Failed to generate deep snapshot for ${udid}: ${err.message}`);
+                throw err;
+            }
+        });
+    }
+    parseXmlHierarchy(xml, platform) {
+        var _a;
+        try {
+            const jsonObj = this.parser.parse(xml);
+            if (platform === 'android') {
+                // Android hierarchy usually starts with <hierarchy>
+                const root = ((_a = jsonObj.hierarchy) === null || _a === void 0 ? void 0 : _a.node) || jsonObj.hierarchy;
+                return this.transformAndroidNode(root, '');
+            }
+            else {
+                // iOS hierarchy usually starts with <AppiumAUT>
+                const root = jsonObj.AppiumAUT || jsonObj;
+                return this.transformIosNode(root, '');
+            }
+        }
+        catch (e) {
+            this.log.error(`Failed to parse XML hierarchy: ${e.message}`);
+            return {
+                name: 'root',
+                type: 'error',
+                rect: { x: 0, y: 0, width: 0, height: 0 },
+                xpath: '/',
+                children: [],
+                attributes: {},
+                suggestedLocators: [],
+                suggestedActions: [],
+            };
+        }
+    }
+    transformAndroidNode(node, root) {
+        var _a;
+        const type = node.class || 'Unknown';
+        const name = node.resourceId || node.text || type.split('.').pop() || 'node';
+        const bounds = this.parseAndroidBounds(node.bounds || '[0,0][0,0]');
+        const xpath = node.xpath || ''; // Placeholder for now, real xpath handled by generator
+        const children = Array.isArray(node.node)
+            ? node.node.map((c) => this.transformAndroidNode(c, root))
+            : node.node
+                ? [this.transformAndroidNode(node.node, root)]
+                : [];
+        const attributes = {};
+        Object.entries(node).forEach(([key, value]) => {
+            // Filter out internal structural keys and non-primitive values
+            if (key !== 'node' &&
+                key !== 'xpath' &&
+                (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')) {
+                attributes[key] = value;
+            }
+        });
+        const nodeObj = {
+            name,
+            type,
+            text: node.text,
+            rect: bounds,
+            xpath,
+            suggestedLocators: [],
+            suggestedActions: [],
+            children,
+            attributes,
+        };
+        nodeObj.suggestedLocators = this.generateLocators(nodeObj, 'android', root || node);
+        nodeObj.suggestedActions = this.generateActions(nodeObj);
+        nodeObj.xpath = ((_a = nodeObj.suggestedLocators.find((l) => l.strategy === 'xpath')) === null || _a === void 0 ? void 0 : _a.value) || '/';
+        return nodeObj;
+    }
+    transformIosNode(node, root) {
+        var _a;
+        const type = Object.keys(node).find((k) => k.startsWith('XCUIElement')) || 'Unknown';
+        const data = node[type];
+        const name = (data === null || data === void 0 ? void 0 : data.name) || (data === null || data === void 0 ? void 0 : data.label) || type;
+        const rect = {
+            x: (data === null || data === void 0 ? void 0 : data.x) || 0,
+            y: (data === null || data === void 0 ? void 0 : data.y) || 0,
+            width: (data === null || data === void 0 ? void 0 : data.width) || 0,
+            height: (data === null || data === void 0 ? void 0 : data.height) || 0,
+        };
+        const children = [];
+        Object.keys(data || {}).forEach((key) => {
+            if (key.startsWith('XCUIElement')) {
+                const childData = data[key];
+                if (Array.isArray(childData)) {
+                    childData.forEach((c) => children.push(this.transformIosNode({ [key]: c }, root)));
+                }
+                else {
+                    children.push(this.transformIosNode({ [key]: childData }, root));
+                }
+            }
+        });
+        const attributes = {};
+        Object.entries(data || {}).forEach(([key, value]) => {
+            // Filter out nested element keys (XCUIElement...) and non-primitive values
+            if (!key.startsWith('XCUIElement') &&
+                (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')) {
+                attributes[key] = value;
+            }
+        });
+        const nodeObj = {
+            name,
+            type,
+            text: (data === null || data === void 0 ? void 0 : data.label) || (data === null || data === void 0 ? void 0 : data.value),
+            rect,
+            xpath: '',
+            suggestedLocators: [],
+            suggestedActions: [],
+            children,
+            attributes,
+        };
+        nodeObj.suggestedLocators = this.generateLocators(nodeObj, 'ios', root || node);
+        nodeObj.suggestedActions = this.generateActions(nodeObj);
+        nodeObj.xpath = ((_a = nodeObj.suggestedLocators.find((l) => l.strategy === 'xpath')) === null || _a === void 0 ? void 0 : _a.value) || '/';
+        return nodeObj;
+    }
+    generateActions(node) {
+        const actions = [];
+        const type = node.type.toLowerCase();
+        // Common clickable elements
+        if (type.includes('button') ||
+            type.includes('imageview') ||
+            type.includes('icon') ||
+            node.attributes.clickable === 'true' ||
+            node.attributes.enabled === 'true') {
+            actions.push({
+                action: 'click',
+                snippet: 'await element.click();',
+                description: 'Performs a single tap interaction',
+            });
+        }
+        // Common input elements
+        if (type.includes('edit') ||
+            type.includes('textfield') ||
+            type.includes('input') ||
+            type.includes('search')) {
+            actions.push({
+                action: 'sendKeys',
+                snippet: 'await element.sendKeys("value");',
+                description: 'Inputs text into the element',
+            });
+            actions.push({
+                action: 'clear',
+                snippet: 'await element.clear();',
+                description: 'Clears the text content',
+            });
+        }
+        return actions;
+    }
+    generateLocators(node, platform, root) {
+        const suggestions = [];
+        // 1. Accessibility ID - GOLD STANDARD
+        // Android: content-desc | iOS: name/accessibility-id
+        const contentDesc = node.attributes.contentDescription || node.attributes['content-desc'];
+        const iosName = node.attributes.name || node.attributes.label;
+        if (contentDesc || iosName) {
+            const val = contentDesc || iosName;
+            suggestions.push({
+                strategy: 'accessibility id',
+                value: val,
+                unique: this.checkUniqueness(root, 'accessibility id', val),
+                score: 100,
+            });
+        }
+        // 2. Resource ID / ID
+        // Android: resource-id | iOS: identifier/name
+        const resId = node.attributes.resourceId || node.attributes['resource-id'] || node.attributes.identifier;
+        if (resId) {
+            suggestions.push({
+                strategy: 'id',
+                value: resId,
+                unique: this.checkUniqueness(root, 'id', resId),
+                score: 95,
+            });
+        }
+        // 3. Platform Specific - Performance Tier
+        if (platform === 'ios') {
+            // iOS Predicate String - High Performance
+            const predicate = `type == "${node.type}" AND label == "${node.text || node.label || ''}"`;
+            if (node.text || node.label) {
+                suggestions.push({
+                    strategy: '-ios predicate string',
+                    value: predicate,
+                    unique: true,
+                    score: 90,
+                });
+            }
+            // iOS Class Chain - High Precision
+            const classChain = `**/${node.type}[` +
+                (node.attributes.name
+                    ? `name == "${node.attributes.name}"`
+                    : `label == "${node.text || ''}"`) +
+                `]`;
+            suggestions.push({
+                strategy: '-ios class chain',
+                value: classChain,
+                unique: true,
+                score: 85,
+            });
+        }
+        else {
+            // Android UIAutomator - Reliable Native
+            if (resId) {
+                suggestions.push({
+                    strategy: '-android uiautomator',
+                    value: `new UiSelector().resourceId("${resId}")`,
+                    unique: true,
+                    score: 88,
+                });
+            }
+            if (node.text) {
+                suggestions.push({
+                    strategy: '-android uiautomator',
+                    value: `new UiSelector().text("${node.text}")`,
+                    unique: this.checkUniqueness(root, 'text', node.text),
+                    score: 80,
+                });
+            }
+        }
+        // 4. XPath - Stable Semantic version
+        // Use tag name from the last part of Class name
+        const tagName = node.type.includes('.') ? node.type.split('.').pop() : node.type;
+        if (resId) {
+            suggestions.push({
+                strategy: 'xpath',
+                value: `//${tagName}[@resource-id="${resId}"]`,
+                unique: true,
+                score: 70,
+            });
+        }
+        else if (node.text) {
+            suggestions.push({
+                strategy: 'xpath',
+                value: `//${tagName}[@text="${node.text}"]`,
+                unique: this.checkUniqueness(root, 'xpath', `//${tagName}[@text="${node.text}"]`),
+                score: 60,
+            });
+        }
+        else if (contentDesc) {
+            suggestions.push({
+                strategy: 'xpath',
+                value: `//${tagName}[@content-desc="${contentDesc}"]`,
+                unique: true,
+                score: 65,
+            });
+        }
+        return suggestions;
+    }
+    checkUniqueness(root, strategy, value) {
+        let matches = 0;
+        const search = (n) => {
+            const node = n.node || n;
+            if (strategy === 'id') {
+                if (node.resourceId === value || node['resource-id'] === value || node.identifier === value)
+                    matches++;
+            }
+            else if (strategy === 'accessibility id') {
+                if (node.accessibilityId === value ||
+                    node['content-desc'] === value ||
+                    node.contentDescription === value ||
+                    node.name === value)
+                    matches++;
+            }
+            else if (strategy === 'text') {
+                if (node.text === value || node.label === value)
+                    matches++;
+            }
+            if (matches > 1)
+                return;
+            const children = n.node || [];
+            if (Array.isArray(children))
+                children.forEach(search);
+            else if (n.children && Array.isArray(n.children))
+                n.children.forEach(search);
+            else if (children && typeof children === 'object')
+                search(children);
+        };
+        search(root);
+        return matches === 1;
+    }
+    parseAndroidBounds(boundsStr) {
+        const matches = /\[(\d+),(\d+)\]\[(\d+),(\d+)\]/.exec(boundsStr);
+        if (matches) {
+            const x1 = parseInt(matches[1]);
+            const y1 = parseInt(matches[2]);
+            const x2 = parseInt(matches[3]);
+            const y2 = parseInt(matches[4]);
+            return { x: x1, y: y1, width: x2 - x1, height: y2 - y1 };
+        }
+        return { x: 0, y: 0, width: 0, height: 0 };
+    }
+};
+exports.InspectorService = InspectorService;
+exports.InspectorService = InspectorService = __decorate([
+    (0, typedi_1.Service)(),
+    __param(0, (0, typedi_1.Inject)()),
+    __metadata("design:paramtypes", [PluginContext_1.PluginContext])
+], InspectorService);

package/lib/src/services/MetricsService.js

@@ -0,0 +1,134 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsService = void 0;
+const typedi_1 = require("typedi");
+const SessionManager_1 = require("../sessions/SessionManager");
+const device_store_1 = require("../data-service/device-store");
+const prisma_1 = require("../prisma");
+const logger_1 = __importDefault(require("../logger"));
+let MetricsService = class MetricsService {
+    constructor() {
+        this.CONFIG_ID = 'metrics';
+    }
+    incrementMetric(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const config = yield prisma_1.prisma.webConfig.findUnique({
+                    where: { name },
+                });
+                const currentValue = config ? parseInt(config.value) : 0;
+                yield prisma_1.prisma.webConfig.upsert({
+                    where: { name },
+                    update: { value: (currentValue + 1).toString() },
+                    create: { id: name, name, value: '1' },
+                });
+            }
+            catch (error) {
+                const msg = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : String(error);
+                logger_1.default.error(`[MetricsService] Failed to increment ${name}: ${msg}`, error);
+            }
+        });
+    }
+    getMetric(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const config = yield prisma_1.prisma.webConfig.findUnique({
+                    where: { name },
+                });
+                return config ? parseInt(config.value) : 0;
+            }
+            catch (error) {
+                return 0;
+            }
+        });
+    }
+    incrementSessionStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.incrementMetric('metric_session_starts');
+        });
+    }
+    incrementSessionSuccess() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.incrementMetric('metric_session_successes');
+        });
+    }
+    incrementSessionFailure() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.incrementMetric('metric_session_failures');
+        });
+    }
+    incrementHealingAttempt() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.incrementMetric('metric_healing_attempts');
+        });
+    }
+    incrementHealingSuccess() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.incrementMetric('metric_healing_successes');
+        });
+    }
+    getMetrics() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sessions = SessionManager_1.SESSION_MANAGER.getStats();
+            const devices = yield device_store_1.DeviceStoreFactory.getStore().getAllDevices();
+            const totalDevices = devices.length;
+            const busyDevices = devices.filter((d) => d.busy).length;
+            const offlineDevices = devices.filter((d) => d.offline).length;
+            // Fetch persisted counters
+            const [sessionStarts, sessionSuccesses, sessionFailures, healingAttempts, healingSuccesses] = yield Promise.all([
+                this.getMetric('metric_session_starts'),
+                this.getMetric('metric_session_successes'),
+                this.getMetric('metric_session_failures'),
+                this.getMetric('metric_healing_attempts'),
+                this.getMetric('metric_healing_successes'),
+            ]);
+            const lines = [
+                '# HELP xenon_sessions_total Total number of sessions across all time',
+                '# TYPE xenon_sessions_total counter',
+                `xenon_sessions_total{status="started"} ${sessionStarts}`,
+                `xenon_sessions_total{status="success"} ${sessionSuccesses}`,
+                `xenon_sessions_total{status="failure"} ${sessionFailures}`,
+                '# HELP xenon_sessions_active Current active sessions in the hub',
+                '# TYPE xenon_sessions_active gauge',
+                `xenon_sessions_active ${sessions.total}`,
+                '# HELP xenon_devices_total Total managed devices in the fleet',
+                '# TYPE xenon_devices_total gauge',
+                `xenon_devices_total ${totalDevices}`,
+                '# HELP xenon_devices_busy Current devices in active use',
+                '# TYPE xenon_devices_busy gauge',
+                `xenon_devices_busy ${busyDevices}`,
+                '# HELP xenon_devices_offline Devices currently not reachable',
+                '# TYPE xenon_devices_offline gauge',
+                `xenon_devices_offline ${offlineDevices}`,
+                '# HELP xenon_healing_total AI self-healing operations',
+                '# TYPE xenon_healing_total counter',
+                `xenon_healing_total{status="attempt"} ${healingAttempts}`,
+                `xenon_healing_total{status="success"} ${healingSuccesses}`,
+            ];
+            return lines.join('\n') + '\n';
+        });
+    }
+};
+exports.MetricsService = MetricsService;
+exports.MetricsService = MetricsService = __decorate([
+    (0, typedi_1.Service)()
+], MetricsService);