@xenon-device-management/xenon 1.1.0

package/lib/src/interceptors/CommandInterceptor.js

@@ -0,0 +1,524 @@
+"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.CommandInterceptor = void 0;
+const typedi_1 = require("typedi");
+const TracingService_1 = require("../services/TracingService");
+const event_manager_1 = require("../dashboard/event-manager");
+const SessionManager_1 = require("../sessions/SessionManager");
+const HealingOrchestrator_1 = require("../services/healing/HealingOrchestrator");
+const HealEtalonService_1 = require("../services/healing/HealEtalonService");
+const OmniVisionService_1 = require("../services/omni-vision/OmniVisionService");
+const AICommandService_1 = require("../services/AICommandService");
+const logger_1 = __importDefault(require("../logger"));
+let CommandInterceptor = class CommandInterceptor {
+    constructor() {
+        this.log = logger_1.default.scope('CommandInterceptor');
+        this.learningSessions = new Set();
+    }
+    handle(next, driver, commandName, args, pluginArgs, isHub) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const IGNORED_COMMANDS = ['getScreenshot', 'stopRecordingScreen', 'startRecordingScreen'];
+            if (IGNORED_COMMANDS.includes(commandName))
+                return yield next();
+            const sessionId = driver.sessionId || args[args.length - 1];
+            const tracingService = typedi_1.Container.get(TracingService_1.TracingService);
+            let span;
+            if (isHub && sessionId) {
+                span = tracingService.startCommandSpan(sessionId, commandName, {
+                    'xenon.command.args': JSON.stringify(args),
+                });
+            }
+            if (commandName === 'createSession' || commandName === 'deleteSession') {
+                try {
+                    return yield next();
+                }
+                finally {
+                    if (span)
+                        tracingService.endSpan(`${sessionId}:${commandName}`);
+                }
+            }
+            try {
+                if (sessionId) {
+                    const { updateCmdExecutedTime } = yield Promise.resolve().then(() => __importStar(require('../data-service/device-service')));
+                    yield updateCmdExecutedTime(sessionId);
+                    if (commandName === 'execute') {
+                        const script = typeof args[0] === 'string' ? args[0] : '';
+                        let scriptArgs = args[1];
+                        // Appium executeScript puts script arguments in args[1] as an array.
+                        // Dig into it to find our payload object.
+                        if (Array.isArray(scriptArgs)) {
+                            if (scriptArgs.length > 0 &&
+                                typeof scriptArgs[0] === 'object' &&
+                                scriptArgs[0] !== null) {
+                                scriptArgs = scriptArgs[0];
+                            }
+                            else if (scriptArgs.length === 0) {
+                                scriptArgs = {};
+                            }
+                        }
+                        const aiCommand = script.replace(/^(xe|xenon)\s*:\s*/, '').trim();
+                        if (aiCommand === 'smartTap' || aiCommand === 'omniClick') {
+                            this.log.info(`[Interceptor] Routing AI command: ${script} with payload: ${JSON.stringify(scriptArgs)}`);
+                            const payload = typeof scriptArgs === 'object' && scriptArgs !== null ? scriptArgs : {};
+                            return yield typedi_1.Container.get(AICommandService_1.AICommandService).smartTap(driver, payload);
+                        }
+                        if (aiCommand === 'uiInventory' || aiCommand === 'uiScanExport') {
+                            this.log.info(`[Interceptor] Routing AI command: ${script} with payload: ${JSON.stringify(scriptArgs)}`);
+                            const payload = typeof scriptArgs === 'object' && scriptArgs !== null ? scriptArgs : {};
+                            return yield typedi_1.Container.get(AICommandService_1.AICommandService).uiInventory(driver, payload);
+                        }
+                        if (aiCommand === 'analyzeScreen' || aiCommand === 'omniScan') {
+                            this.log.info(`[Interceptor] Routing AI command: ${script}`);
+                            return yield typedi_1.Container.get(AICommandService_1.AICommandService).analyzeScreen(driver);
+                        }
+                        if (aiCommand === 'visualTap') {
+                            this.log.info(`[Interceptor] Routing AI command: ${script} with payload: ${JSON.stringify(scriptArgs)}`);
+                            const payload = typeof scriptArgs === 'object' && scriptArgs !== null ? scriptArgs : {};
+                            return yield typedi_1.Container.get(AICommandService_1.AICommandService).visualTap(driver, payload);
+                        }
+                        if (aiCommand === 'assertVisualState') {
+                            this.log.info(`[Interceptor] Routing AI command: ${script} with payload: ${JSON.stringify(scriptArgs)}`);
+                            const instruction = typeof scriptArgs === 'string'
+                                ? scriptArgs
+                                : typeof scriptArgs === 'object' && (scriptArgs === null || scriptArgs === void 0 ? void 0 : scriptArgs.instruction)
+                                    ? scriptArgs.instruction
+                                    : '';
+                            return yield typedi_1.Container.get(AICommandService_1.AICommandService).assertVisualState(driver, instruction);
+                        }
+                    }
+                    const shouldProceed = yield event_manager_1.DASHBORD_EVENT_MANAGER.beforeSessionCommand(sessionId, commandName, { body: { script: args[0], args: args[1] } }, {
+                        status: () => ({ json: (d) => d }),
+                        setHeader: () => { },
+                        getHeader: () => { },
+                    });
+                    if (shouldProceed === false) {
+                        return null;
+                    }
+                }
+                // --- OMNI-VISION: PROACTIVE SEARCH ---
+                const strategy = args[0];
+                const selector = args[1];
+                if (['findElement', 'findElements'].includes(commandName) &&
+                    ['-custom:ai-icon', '-custom:ai-text'].includes(strategy)) {
+                    return yield this.handleOmniVisionSearch(sessionId, driver, commandName, strategy, selector);
+                }
+                // --- OMNI-VISION: VIRTUAL ELEMENT INTERACTION ---
+                const elementCommands = [
+                    'click',
+                    'getElementRect',
+                    'getElementLocation',
+                    'getElementSize',
+                    'getText',
+                    'setValue',
+                    'elementDisplayed',
+                    'elementEnabled',
+                ];
+                if (elementCommands.includes(commandName)) {
+                    const elementId = args[0];
+                    if (typeof elementId === 'string' &&
+                        (elementId.startsWith('omni_') ||
+                            elementId.startsWith('healed_ocr') ||
+                            elementId.startsWith('healed_visual'))) {
+                        return yield this.handleVirtualElementCommand(sessionId, driver, commandName, elementId, args[1]);
+                    }
+                }
+                const response = yield next();
+                if (isHub && !!pluginArgs.enableDashboard && SessionManager_1.SESSION_MANAGER.isValidSession(sessionId)) {
+                    try {
+                        yield event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(sessionId, commandName, driver, {
+                            body: args,
+                            method: 'POST',
+                            path: `/${commandName}`,
+                            originalUrl: `/${commandName}`,
+                        }, {}, JSON.stringify({ value: response, sessionId }));
+                        if (commandName === 'findElement' &&
+                            response &&
+                            pluginArgs.enableSelfHealing !== false) {
+                            this.triggerLearning(driver, args, response, sessionId);
+                        }
+                    }
+                    catch (postCommandErr) {
+                        this.log.warn(`[Interceptor] Post-command hooks failed: ${postCommandErr.message}`);
+                    }
+                }
+                return response;
+            }
+            catch (error) {
+                if (this.isNoSuchElementError(error) &&
+                    ['findElement', 'findElements'].includes(commandName) &&
+                    pluginArgs.enableSelfHealing !== false) {
+                    const healed = yield typedi_1.Container.get(HealingOrchestrator_1.HealingOrchestrator).attemptHealing(sessionId, driver, args[0], args[1]);
+                    if (healed) {
+                        yield this.logHealingEvent(sessionId, commandName, driver, args, healed);
+                        let finalId = healed.id;
+                        // OCR/Visual AI tiers return virtual IDs with rect coordinates
+                        // We need to resolve a REAL element that Appium can interact with
+                        if (healed.id.startsWith('healed_') && healed.rect) {
+                            // REGISTER the virtual element for subsequent state checks
+                            typedi_1.Container.get(OmniVisionService_1.OmniVisionService).addVirtualElement({
+                                id: healed.id,
+                                rect: healed.rect,
+                                confidence: healed.confidence,
+                                text: healed.message,
+                            });
+                            this.log.info(`[Interceptor] Visual healing returned coordinates. Resolving real element at (${healed.rect.x}, ${healed.rect.y})...`);
+                            let resolved = false;
+                            // Strategy 1: Try to find element at the center of the detected area
+                            try {
+                                const cx = Math.round(healed.rect.x + healed.rect.width / 2);
+                                const cy = Math.round(healed.rect.y + healed.rect.height / 2);
+                                const touchEl = yield driver.findElement('-ios class chain', `**/XCUIElementTypeAny[\`rect.x <= ${cx} AND rect.x + rect.width >= ${cx} AND rect.y <= ${cy} AND rect.y + rect.height >= ${cy}\`]`);
+                                if (touchEl) {
+                                    finalId =
+                                        touchEl.ELEMENT || touchEl['element-6066-11e4-a52e-4f735466cecf'] || finalId;
+                                    resolved = !!finalId && !finalId.startsWith('healed_');
+                                }
+                            }
+                            catch (e) {
+                                // Strategy 1 failed
+                            }
+                            // Strategy 2: Use coordinate tap action (W3C Actions API)
+                            if (!resolved) {
+                                this.log.info('[Interceptor] Falling back to coordinate-based tap for visual healing');
+                                try {
+                                    const cx = Math.round(healed.rect.x + healed.rect.width / 2);
+                                    const cy = Math.round(healed.rect.y + healed.rect.height / 2);
+                                    yield driver.performActions([
+                                        {
+                                            type: 'pointer',
+                                            id: 'xenon-heal-tap',
+                                            parameters: { pointerType: 'touch' },
+                                            actions: [
+                                                { type: 'pointerMove', duration: 0, x: cx, y: cy },
+                                                { type: 'pointerDown', button: 0 },
+                                                { type: 'pause', duration: 100 },
+                                                { type: 'pointerUp', button: 0 },
+                                            ],
+                                        },
+                                    ]);
+                                    yield driver.releaseActions();
+                                    this.log.info(`[Interceptor] ✅ Visual healing: tapped at (${cx}, ${cy})`);
+                                    // Return the virtual ID — the tap already happened
+                                }
+                                catch (tapErr) {
+                                    this.log.error(`[Interceptor] Coordinate tap failed: ${tapErr.message}`);
+                                }
+                            }
+                        }
+                        const elementResponse = {
+                            ELEMENT: finalId,
+                            'element-6066-11e4-a52e-4f735466cecf': finalId,
+                        };
+                        return commandName === 'findElement' ? elementResponse : [elementResponse];
+                    }
+                }
+                if (isHub && !!pluginArgs.enableDashboard && sessionId) {
+                    yield event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(sessionId, commandName, driver, {
+                        body: args,
+                        method: 'POST',
+                        path: `/${commandName}`,
+                        originalUrl: `/${commandName}`,
+                    }, {}, JSON.stringify({ value: { error: error.message || error }, sessionId }));
+                }
+                throw error;
+            }
+            finally {
+                if (isHub && sessionId && span)
+                    tracingService.endSpan(`${sessionId}:${commandName}`);
+            }
+        });
+    }
+    isNoSuchElementError(error) {
+        var _a;
+        return (error.name === 'NoSuchElementError' ||
+            ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('NoSuchElement')) ||
+            error.status === 7);
+    }
+    handleOmniVisionSearch(sessionId, driver, commandName, strategy, selector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const omniService = typedi_1.Container.get(OmniVisionService_1.OmniVisionService);
+            let results = [];
+            if (strategy === '-custom:ai-text')
+                results = yield omniService.findByText(driver, selector);
+            else if (strategy === '-custom:ai-icon') {
+                const match = yield omniService.findByIcon(driver, selector);
+                if (match)
+                    results = [match];
+            }
+            const appiumResults = results.map((r) => ({
+                ELEMENT: r.id,
+                'element-6066-11e4-a52e-4f735466cecf': r.id,
+            }));
+            if (commandName === 'findElement') {
+                if (appiumResults.length === 0)
+                    throw new Error('NoSuchElement: AI Vision failed to find matching element');
+                return appiumResults[0];
+            }
+            return appiumResults;
+        });
+    }
+    handleVirtualElementCommand(sessionId, driver, commandName, elementId, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const omniService = typedi_1.Container.get(OmniVisionService_1.OmniVisionService);
+            const element = omniService.getVirtualElement(elementId);
+            if (!element)
+                throw new Error(`NoSuchElement: Virtual element ${elementId} not found`);
+            const centerX = Math.round(element.rect.x + element.rect.width / 2);
+            const centerY = Math.round(element.rect.y + element.rect.height / 2);
+            switch (commandName) {
+                case 'click':
+                    yield driver.performActions([
+                        {
+                            type: 'pointer',
+                            id: 'finger1',
+                            parameters: { pointerType: 'touch' },
+                            actions: [
+                                { type: 'pointerMove', duration: 0, x: centerX, y: centerY },
+                                { type: 'pointerDown', button: 0 },
+                                { type: 'pause', duration: 100 },
+                                { type: 'pointerUp', button: 0 },
+                            ],
+                        },
+                    ]);
+                    return null;
+                case 'getElementRect':
+                    return element.rect;
+                case 'getElementLocation':
+                    return { x: element.rect.x, y: element.rect.y };
+                case 'getElementSize':
+                    return { width: element.rect.width, height: element.rect.height };
+                case 'elementDisplayed':
+                case 'elementEnabled':
+                    return true;
+                case 'getText':
+                    return element.text || '';
+                case 'setValue':
+                    yield driver.performActions([
+                        {
+                            type: 'pointer',
+                            id: 'finger1',
+                            parameters: { pointerType: 'touch' },
+                            actions: [
+                                { type: 'pointerMove', duration: 0, x: centerX, y: centerY },
+                                { type: 'pointerDown', button: 0 },
+                                { type: 'pause', duration: 100 },
+                                { type: 'pointerUp', button: 0 },
+                            ],
+                        },
+                    ]);
+                    try {
+                        return yield driver.setValue(elementId, value);
+                    }
+                    catch (e) {
+                        this.log.error(`setValue failed for virtual element ${elementId} on session ${sessionId}: ${e.message}`);
+                        throw e;
+                    }
+                default:
+                    throw new Error(`Command ${commandName} not supported for visual elements`);
+            }
+        });
+    }
+    triggerLearning(driver, args, response, sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.learningSessions.has(sessionId))
+                return;
+            this.learningSessions.add(sessionId);
+            const strategy = args[0];
+            const selector = args[1];
+            const elementId = response.ELEMENT || response['element-6066-11e4-a52e-4f735466cecf'];
+            if (!elementId || typeof selector !== 'string') {
+                this.learningSessions.delete(sessionId);
+                return;
+            }
+            (() => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const etalonService = typedi_1.Container.get(HealEtalonService_1.HealEtalonService);
+                    // CRITICAL PERFORMANCE OPTIMIZATION:
+                    // Only trigger the heavy metadata collection if we don't already have an etalon for this selector.
+                    // Collecting page source and element rects for every single action is too CPU-intensive.
+                    const existing = yield etalonService.getSignature(selector);
+                    if (existing) {
+                        this.log.debug(`[Learning] Etalon already exists for selector: ${selector}. Skipping...`);
+                        return;
+                    }
+                    const anchors = [
+                        'content-desc',
+                        'resource-id',
+                        'text',
+                        'name',
+                        'id',
+                        'hint',
+                        'label',
+                        'value', // iOS-specific identity attributes
+                    ];
+                    const nodeAttrs = [];
+                    for (const attr of anchors) {
+                        try {
+                            const val = yield driver.getElementAttribute(elementId, attr);
+                            if (val)
+                                nodeAttrs.push({ name: attr, value: val });
+                        }
+                        catch (e) {
+                            // Silently ignore: attribute may not exist or be inaccessible
+                        }
+                    }
+                    // Capture spatial coordinates from element rect for position-based healing
+                    try {
+                        const rect = yield driver.getElementRect(elementId);
+                        if (rect) {
+                            if (rect.x !== undefined)
+                                nodeAttrs.push({ name: 'x', value: String(Math.round(rect.x)) });
+                            if (rect.y !== undefined)
+                                nodeAttrs.push({ name: 'y', value: String(Math.round(rect.y)) });
+                            if (rect.width !== undefined)
+                                nodeAttrs.push({ name: 'width', value: String(Math.round(rect.width)) });
+                            if (rect.height !== undefined)
+                                nodeAttrs.push({ name: 'height', value: String(Math.round(rect.height)) });
+                        }
+                    }
+                    catch (e) {
+                        // Silently ignore: rect capture is optional
+                    }
+                    let nodeName = 'XCUIElementTypeAny'; // Default for IOS, will be overridden
+                    try {
+                        if (typeof driver.getElementTagName === 'function') {
+                            nodeName = (yield driver.getElementTagName(elementId)) || nodeName;
+                        }
+                        else if (typeof driver.getName === 'function') {
+                            nodeName = (yield driver.getName(elementId)) || nodeName;
+                        }
+                        else {
+                            // Check if it's android or ios to provide a better default
+                            const caps = yield driver.getCapabilities();
+                            const platform = (caps.platformName || caps.platform || 'ios').toLowerCase();
+                            nodeName = platform === 'android' ? 'android.view.View' : 'XCUIElementTypeAny';
+                        }
+                    }
+                    catch (e) {
+                        this.log.debug(`[Learning] Failed to get tag name for element ${elementId}. Using default.`);
+                    }
+                    // Final safety check to ensure nodeName is a valid string
+                    if (!nodeName)
+                        nodeName = 'Unknown';
+                    // Path capture logic
+                    let resiliotreePathJson = null;
+                    try {
+                        const { JSDOMParser, Path } = yield Promise.resolve().then(() => __importStar(require('resiliotree')));
+                        const pageSource = yield driver.getPageSource();
+                        const rootNode = new JSDOMParser().parse(pageSource);
+                        const foundNode = this.findMatchingNode(rootNode, nodeName, nodeAttrs);
+                        if (foundNode) {
+                            const pathNodes = [];
+                            let curr = foundNode;
+                            while (curr) {
+                                pathNodes.unshift(curr);
+                                curr = curr.parent;
+                            }
+                            resiliotreePathJson = new Path(pathNodes).toJSON();
+                        }
+                    }
+                    catch (e) {
+                        // Silently ignore: path capture is optional for learning
+                    }
+                    yield etalonService.saveSignature(strategy, selector, { nodeName, attributes: nodeAttrs }, resiliotreePathJson);
+                }
+                catch (err) {
+                    this.log.debug(`[Learning] Failed: ${err.message}`);
+                }
+                finally {
+                    this.learningSessions.delete(sessionId);
+                }
+            }))();
+        });
+    }
+    findMatchingNode(root, tag, attributes) {
+        const attrMap = new Map(attributes.map((a) => [a.name.toLowerCase(), a.value]));
+        const queue = [root];
+        while (queue.length > 0) {
+            const node = queue.shift();
+            if (node.tag.toLowerCase() === tag.toLowerCase()) {
+                let matchCount = 0;
+                for (const [name, value] of attrMap) {
+                    if (node.otherAttributes.get(name) === value ||
+                        node.id === value ||
+                        node.classes.has(value))
+                        matchCount++;
+                }
+                if (matchCount > 0)
+                    return node;
+            }
+            if (node.children)
+                queue.push(...node.children);
+        }
+        return null;
+    }
+    logHealingEvent(sessionId, commandName, driver, args, healed) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield event_manager_1.DASHBORD_EVENT_MANAGER.afterSessionCommand(sessionId, commandName, driver, {
+                body: args,
+                method: 'POST',
+                path: `/${commandName}`,
+                originalUrl: `/${commandName}`,
+            }, {}, JSON.stringify({ value: { ELEMENT: healed.id }, sessionId }), {
+                originalSelector: args[1],
+                healedSelector: healed.recommendedSelector,
+                confidence: healed.confidence,
+            });
+        });
+    }
+};
+exports.CommandInterceptor = CommandInterceptor;
+exports.CommandInterceptor = CommandInterceptor = __decorate([
+    (0, typedi_1.Service)()
+], CommandInterceptor);

package/lib/src/interfaces/ICloudManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/interfaces/IDevice.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/interfaces/IDeviceFilterOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/interfaces/IDeviceManager.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/interfaces/IOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/interfaces/IPluginArgs.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultPluginArgs = void 0;
+/* eslint-disable */
+/**
+ * This file was automatically generated by json-schema-to-typescript.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and run "npm run build:schema" to regenerate this file.
+ */
+const ip_1 = __importDefault(require("ip"));
+exports.DefaultPluginArgs = {
+    platform: 'both',
+    iosDeviceType: 'both',
+    androidDeviceType: 'both',
+    skipChromeDownload: true,
+    hub: undefined,
+    maxSessions: 8,
+    derivedDataPath: undefined,
+    adbRemote: [],
+    remoteMachineProxyIP: undefined,
+    proxy: undefined,
+    emulators: [],
+    simulators: [],
+    deviceAvailabilityTimeoutMs: 300000,
+    deviceAvailabilityQueryIntervalMs: 10000,
+    sendNodeDevicesToHubIntervalMs: 30000,
+    checkStaleDevicesIntervalMs: 30000,
+    checkBlockedDevicesIntervalMs: 30000,
+    newCommandTimeoutSec: 60,
+    cloud: undefined,
+    bindHostOrIp: ip_1.default.address(),
+    enableDashboard: false,
+    bootedSimulators: false,
+    healthCheckIntervalMs: 86400000,
+    healthCheckSchedule: undefined,
+    removeDevicesFromDatabaseBeforeRunningThePlugin: false,
+    databaseProvider: undefined,
+    databaseUrl: undefined,
+    aiProvider: undefined,
+    aiModel: undefined,
+    aiBaseUrl: undefined,
+    geminiApiKey: undefined,
+    openaiApiKey: undefined,
+    anthropicApiKey: undefined,
+    enableSelfHealing: true,
+    buildCleanupDays: 30,
+    buildCleanupMaxCount: 100,
+    buildCleanupSchedule: '0 0 * * *',
+    deleteBuildAssets: true,
+    sessionHeartbeatIntervalMs: 30000,
+    enableJsonLogging: false,
+};

package/lib/src/interfaces/ISessionCapability.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });