@xenon-device-management/xenon 1.1.0

package/lib/src/services/ResourceIsolationService.js

@@ -0,0 +1,122 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceIsolationService = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const os_1 = __importDefault(require("os"));
+/**
+ * ResourceIsolationService
+ * Provides abstraction for OS-level process sandboxing and priority management.
+ * Prevents "Noisy Neighbor" issues in high-density device farms.
+ */
+let ResourceIsolationService = class ResourceIsolationService {
+    constructor() {
+        this.isMac = os_1.default.platform() === 'darwin';
+        this.isLinux = os_1.default.platform() === 'linux';
+    }
+    /**
+     * Wraps a command string with OS-level isolation/priority prefixes.
+     * @param command The base command to execute
+     * @param profile The desired isolation profile
+     * @returns The wrapped command
+     */
+    wrapCommand(command, profile) {
+        if (profile === 'Performance')
+            return command; // Default, no wrap needed
+        if (this.isMac) {
+            return this.wrapMacOS(command, profile);
+        }
+        if (this.isLinux) {
+            return this.wrapLinux(command, profile);
+        }
+        return command;
+    }
+    /**
+     * Specialized wrapper for child_process.spawn
+     */
+    wrapSpawn(command, args, profile) {
+        if (profile === 'Performance')
+            return { command, args };
+        if (this.isMac) {
+            if (profile === 'Economy') {
+                return { command: 'taskpolicy', args: ['-c', 'background', command, ...args] };
+            }
+            if (profile === 'Guaranteed') {
+                return { command: 'nice', args: ['-n', '-5', command, ...args] };
+            }
+        }
+        if (this.isLinux) {
+            if (profile === 'Economy') {
+                return { command: 'nice', args: ['-n', '19', command, ...args] };
+            }
+            if (profile === 'Guaranteed') {
+                return { command: 'nice', args: ['-n', '-10', command, ...args] };
+            }
+        }
+        return { command, args };
+    }
+    /**
+     * macOS version using taskpolicy
+     * -c background: Moves process to background throttled state
+     * -p <pid>: Can also be used, but we wrap the spawn.
+     */
+    wrapMacOS(command, profile) {
+        if (profile === 'Economy') {
+            // taskpolicy -c background is the most effective way to throttle CPU/IO on Mac
+            logger_1.default.debug('🛡️ Resource Isolation: Throttling command to background (Economy)');
+            return `taskpolicy -c background ${command}`;
+        }
+        if (profile === 'Guaranteed') {
+            // MacOS doesn't have a simple "High priority" CLI wrapper for spawn easily
+            // without sudo, but we can use 'nice'
+            logger_1.default.debug('🛡️ Resource Isolation: Assigning high priority (Guaranteed)');
+            return `nice -n -5 ${command}`;
+        }
+        return command;
+    }
+    /**
+     * Linux version using nice/renice
+     * Priority -20 (Highest) to 19 (Lowest)
+     */
+    wrapLinux(command, profile) {
+        if (profile === 'Economy') {
+            logger_1.default.debug('🛡️ Resource Isolation: Throttling command (Economy)');
+            return `nice -n 19 ${command}`;
+        }
+        if (profile === 'Guaranteed') {
+            logger_1.default.debug('🛡️ Resource Isolation: Assigning high priority (Guaranteed)');
+            return `nice -n -10 ${command}`;
+        }
+        return command;
+    }
+    /**
+     * Get numeric priority value for libraries that support it
+     */
+    getPriority(profile) {
+        switch (profile) {
+            case 'Economy':
+                return 19;
+            case 'Guaranteed':
+                return -10;
+            default:
+                return 0;
+        }
+    }
+};
+exports.ResourceIsolationService = ResourceIsolationService;
+exports.ResourceIsolationService = ResourceIsolationService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], ResourceIsolationService);

package/lib/src/services/SecurityService.js

@@ -0,0 +1,120 @@
+"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 __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.SecurityService = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const os_1 = __importDefault(require("os"));
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+let SecurityService = class SecurityService {
+    constructor() {
+        this.algorithm = 'aes-256-gcm';
+        this.ivLength = 12;
+        this.saltLength = 16;
+        this.tagLength = 16;
+        this.keyLength = 32;
+        this.iterations = 10000;
+        this.encryptionKey = null;
+    }
+    /**
+     * Derives a machine-unique encryption key.
+     * Uses hostname and MAC addresses to create a stable, unique seed.
+     */
+    getMachineSecret() {
+        const interfaces = os_1.default.networkInterfaces();
+        const macs = Object.values(interfaces)
+            .flat()
+            .filter((iface) => iface && !iface.internal)
+            .map((iface) => iface.mac)
+            .sort()
+            .join(':');
+        return `${os_1.default.hostname()}-${macs}-xenon-v1`;
+    }
+    getEncryptionKey(salt) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.encryptionKey && salt.length === 0)
+                return this.encryptionKey;
+            return new Promise((resolve, reject) => {
+                crypto_1.default.pbkdf2(this.getMachineSecret(), salt, this.iterations, this.keyLength, 'sha256', (err, derivedKey) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(derivedKey);
+                });
+            });
+        });
+    }
+    encrypt(text) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!text)
+                    return text;
+                const salt = crypto_1.default.randomBytes(this.saltLength);
+                const iv = crypto_1.default.randomBytes(this.ivLength);
+                const key = yield this.getEncryptionKey(salt);
+                const cipher = crypto_1.default.createCipheriv(this.algorithm, key, iv);
+                const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+                const tag = cipher.getAuthTag();
+                // Format: salt:iv:tag:encrypted
+                return Buffer.concat([salt, iv, tag, encrypted]).toString('base64');
+            }
+            catch (err) {
+                logger_1.default.error(`Encryption failed: ${err.message}`);
+                throw new Error('Security Error: Failed to encrypt sensitive data.');
+            }
+        });
+    }
+    decrypt(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (!data || (!data.includes('==') && data.length < 50))
+                    return data; // Primitive check if it's already plain text
+                const buffer = Buffer.from(data, 'base64');
+                const salt = buffer.subarray(0, this.saltLength);
+                const iv = buffer.subarray(this.saltLength, this.saltLength + this.ivLength);
+                const tag = buffer.subarray(this.saltLength + this.ivLength, this.saltLength + this.ivLength + this.tagLength);
+                const encrypted = buffer.subarray(this.saltLength + this.ivLength + this.tagLength);
+                const key = yield this.getEncryptionKey(salt);
+                const decipher = crypto_1.default.createDecipheriv(this.algorithm, key, iv);
+                decipher.setAuthTag(tag);
+                const decrypted = Buffer.concat([
+                    decipher.update(encrypted),
+                    decipher.final(),
+                ]);
+                return decrypted.toString('utf8');
+            }
+            catch (err) {
+                // If decryption fails, it might be legacy plain text.
+                // In production, we should log this but maybe return the original for migration?
+                // For now, let's assume if it fails it's either corrupt or plain text.
+                logger_1.default.debug(`Decryption failed (possibly plain text): ${err.message}`);
+                return data;
+            }
+        });
+    }
+};
+exports.SecurityService = SecurityService;
+exports.SecurityService = SecurityService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], SecurityService);

package/lib/src/services/ServerManager.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 __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 };
+};
+var ServerManager_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerManager = void 0;
+const typedi_1 = require("typedi");
+const uuid_1 = require("uuid");
+const helpers_1 = require("../helpers");
+const ip_1 = __importDefault(require("ip"));
+const logger_1 = __importDefault(require("../logger"));
+// enable resolveJsonModule in tsconfig must be true for this to work
+const package_json_1 = __importDefault(require("../../package.json"));
+const IPluginArgs_1 = require("../interfaces/IPluginArgs");
+const config_service_1 = require("../data-service/config-service");
+const PluginContext_1 = require("../PluginContext");
+const device_store_1 = require("../data-service/device-store");
+const device_utils_1 = require("../device-utils");
+const app_1 = require("../app");
+const wd_command_proxy_1 = require("../proxy/wd-command-proxy");
+const appium_adb_1 = require("appium-adb");
+const ChromeDriverManager_1 = __importDefault(require("../device-managers/ChromeDriverManager"));
+const AndroidDeviceManager_1 = __importDefault(require("../device-managers/AndroidDeviceManager"));
+const IOSDeviceManager_1 = __importDefault(require("../device-managers/IOSDeviceManager"));
+const device_managers_1 = require("../device-managers");
+const pluginArgs_1 = require("../data-service/pluginArgs");
+const NodeDevices_1 = __importDefault(require("../device-managers/NodeDevices"));
+const SocketServer_1 = require("./SocketServer");
+const SocketClient_1 = require("./SocketClient");
+const TracingService_1 = require("./TracingService");
+const plugin_1 = require("../plugin");
+let ServerManager = ServerManager_1 = class ServerManager {
+    constructor() {
+        this.logger = logger_1.default.scope('ServerManager');
+    }
+    updateServer(expressApp, httpServer, cliArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.debug(`📱 Update server with CLI Args: ${JSON.stringify((0, helpers_1.redactSecrets)(cliArgs))}`);
+            const pluginArgs = yield this.resolvePluginArgs(cliArgs);
+            const nodeId = (0, uuid_1.v4)();
+            logger_1.default.banner(package_json_1.default.version, nodeId);
+            // Standardize static variable initialization
+            plugin_1.XenonPlugin.NODE_ID = nodeId;
+            plugin_1.XenonPlugin.port = cliArgs.port;
+            plugin_1.XenonPlugin.nodeBasePath = cliArgs.basePath || '';
+            const context = typedi_1.Container.get(PluginContext_1.PluginContext);
+            context.setContext(pluginArgs, cliArgs.port, nodeId, cliArgs.basePath || '');
+            yield this.syncDatabaseAndAIConfig(pluginArgs);
+            yield this.initializeCoreSubsystems(pluginArgs);
+            this.registerRoutes(expressApp, cliArgs, pluginArgs);
+            yield this.bootEmulators(pluginArgs);
+            this.registerDependenciesInContainer(pluginArgs, cliArgs, nodeId);
+            yield this.setupHubOrNode(pluginArgs, cliArgs, httpServer, nodeId);
+            yield this.setupMaintenanceCrons(pluginArgs);
+            // Principal Cleaning: Attempt to recover remote sessions before marking as failed
+            const { SessionManager } = yield Promise.resolve().then(() => __importStar(require('../sessions/SessionManager')));
+            const sessionManager = typedi_1.Container.get(SessionManager);
+            const recoveredCount = yield sessionManager.recoverActiveSessions(nodeId, plugin_1.XenonPlugin.nodeBasePath);
+            const recoveredSessionIds = sessionManager.getAllSessions().map((s) => s.getId());
+            if (recoveredCount > 0) {
+                logger_1.default.info(`🔄 Successfully recovered ${recoveredCount} remote sessions`);
+            }
+            // Cleanup any remaining zombie sessions
+            const { cleanupZombieSessions } = yield Promise.resolve().then(() => __importStar(require('../dashboard/services/session-service')));
+            yield cleanupZombieSessions(recoveredSessionIds);
+            // Initial device discovery poll to start managers and trackers
+            yield (0, device_utils_1.updateDeviceList)(pluginArgs.bindHostOrIp, pluginArgs.hub, pluginArgs.tlsRejectUnauthorized);
+            // remove stale devices
+            yield (0, device_utils_1.removeStaleDevices)(pluginArgs.bindHostOrIp, pluginArgs.tlsRejectUnauthorized);
+            this.logger.info(`🚀 Xenon will be served at http://${pluginArgs.bindHostOrIp}:${cliArgs.port}/xenon with id ${nodeId}`);
+        });
+    }
+    resolvePluginArgs(cliArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pluginConfigs = cliArgs.plugin;
+            const pluginArgs = Object.assign({}, IPluginArgs_1.DefaultPluginArgs, ((pluginConfigs === null || pluginConfigs === void 0 ? void 0 : pluginConfigs['xenon']) || {}));
+            try {
+                const persistedConfig = yield typedi_1.Container.get(config_service_1.ConfigService).loadConfig();
+                if (persistedConfig && Object.keys(persistedConfig).length > 0) {
+                    this.logger.info('Loading persisted configuration', persistedConfig);
+                    Object.assign(pluginArgs, persistedConfig);
+                }
+            }
+            catch (err) {
+                this.logger.warn(`Failed to load persisted config: ${err}`);
+            }
+            if (pluginArgs.bindHostOrIp === undefined) {
+                pluginArgs.bindHostOrIp = ip_1.default.address();
+            }
+            return pluginArgs;
+        });
+    }
+    syncDatabaseAndAIConfig(pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { updateConfig } = yield Promise.resolve().then(() => __importStar(require('../config')));
+            const update = {};
+            if (pluginArgs.databaseProvider) {
+                update.databaseProvider = pluginArgs.databaseProvider;
+                process.env.XENON_DB_PROVIDER = pluginArgs.databaseProvider;
+            }
+            if (pluginArgs.databaseUrl) {
+                update.databaseUrl = pluginArgs.databaseUrl;
+                process.env.DATABASE_URL = pluginArgs.databaseUrl;
+            }
+            if (pluginArgs.aiProvider) {
+                update.aiProvider = pluginArgs.aiProvider;
+                process.env.XENON_AI_PROVIDER = pluginArgs.aiProvider;
+            }
+            if (pluginArgs.aiModel) {
+                update.aiModel = pluginArgs.aiModel;
+                process.env.XENON_AI_MODEL = pluginArgs.aiModel;
+            }
+            if (pluginArgs.aiBaseUrl) {
+                update.aiBaseUrl = pluginArgs.aiBaseUrl;
+                process.env.XENON_AI_BASE_URL = pluginArgs.aiBaseUrl;
+            }
+            if (pluginArgs.geminiApiKey) {
+                update.geminiApiKey = pluginArgs.geminiApiKey;
+                process.env.GEMINI_API_KEY = pluginArgs.geminiApiKey;
+            }
+            if (pluginArgs.openaiApiKey) {
+                update.openaiApiKey = pluginArgs.openaiApiKey;
+                process.env.OPENAI_API_KEY = pluginArgs.openaiApiKey;
+            }
+            if (pluginArgs.anthropicApiKey) {
+                update.anthropicApiKey = pluginArgs.anthropicApiKey;
+                process.env.ANTHROPIC_API_KEY = pluginArgs.anthropicApiKey;
+            }
+            if (Object.keys(update).length > 0) {
+                this.logger.info('[Plugin] Synchronizing database config', update);
+                updateConfig(update);
+            }
+        });
+    }
+    initializeCoreSubsystems(pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield (0, device_utils_1.initializeStorage)();
+            yield device_store_1.DeviceStoreFactory.getStore().clearStorage();
+        });
+    }
+    registerRoutes(expressApp, cliArgs, pluginArgs) {
+        expressApp.use('/xenon', (0, app_1.createRouter)(pluginArgs));
+        (0, wd_command_proxy_1.registerProxyMiddlware)(expressApp, cliArgs);
+    }
+    bootEmulators(pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (pluginArgs.emulators &&
+                pluginArgs.emulators.length > 0 &&
+                pluginArgs.platform.toLowerCase().includes('android')) {
+                this.logger.info('Emulators will be booted!!');
+                const adb = yield appium_adb_1.ADB.createADB({});
+                const array = pluginArgs.emulators || [];
+                yield Promise.all(array.map((arr) => adb.launchAVD(arr.avdName, arr)));
+            }
+        });
+    }
+    registerDependenciesInContainer(pluginArgs, cliArgs, nodeId) {
+        typedi_1.Container.set('DeviceStore', device_store_1.DeviceStoreFactory.getStore());
+        typedi_1.Container.set('PendingSessionStore', device_store_1.DeviceStoreFactory.getPendingSessionStore());
+        typedi_1.Container.set('CLIArgsStore', device_store_1.DeviceStoreFactory.getCLIArgsStore());
+        typedi_1.Container.set('HealEtalonStore', device_store_1.DeviceStoreFactory.getHealEtalonStore());
+        typedi_1.Container.set('AndroidDeviceManager', typedi_1.Container.get(AndroidDeviceManager_1.default));
+        typedi_1.Container.set('IOSDeviceManager', typedi_1.Container.get(IOSDeviceManager_1.default));
+        const deviceManager = typedi_1.Container.get(device_managers_1.XenonManager);
+        deviceManager.init();
+        // Optional Chrome Download
+        if (pluginArgs.skipChromeDownload === false) {
+            ChromeDriverManager_1.default.create()
+                .then((mgr) => typedi_1.Container.set(ChromeDriverManager_1.default, mgr))
+                .catch((err) => this.logger.error(`Failed to initialize ChromeDriverManager: ${err}`));
+        }
+        (0, pluginArgs_1.addCLIArgs)(cliArgs);
+    }
+    setupHubOrNode(pluginArgs, cliArgs, httpServer, nodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const hubArgument = pluginArgs.hub;
+            if (hubArgument !== undefined) {
+                this.logger.info(`📡 I'm a node and my hub is ${hubArgument}`);
+                yield (0, device_utils_1.setupCronUpdateDeviceList)(pluginArgs.bindHostOrIp, hubArgument, pluginArgs.sendNodeDevicesToHubIntervalMs, pluginArgs.tlsRejectUnauthorized);
+                // Handle graceful shutdown
+                ['SIGINT', 'SIGTERM'].forEach((signal) => {
+                    process.once(signal, () => __awaiter(this, void 0, void 0, function* () {
+                        logger_1.default.info(`Received ${signal}, unregistering node from hub...`);
+                        try {
+                            yield new NodeDevices_1.default(hubArgument, pluginArgs.tlsRejectUnauthorized).unRegisterNode(pluginArgs.bindHostOrIp);
+                        }
+                        catch (err) {
+                            logger_1.default.error(`Error during node unregistration: ${err}`);
+                        }
+                        process.kill(process.pid, signal);
+                    }));
+                });
+                // Initialize Socket Client to connect to Hub
+                const socketClient = typedi_1.Container.get(SocketClient_1.SocketClient);
+                socketClient.initialize(hubArgument, pluginArgs.bindHostOrIp);
+            }
+            else {
+                ServerManager_1.IS_HUB = true;
+                this.logger.info(`🌐 I'm a hub and I'm listening on ${pluginArgs.bindHostOrIp}:${cliArgs.port}`);
+                const socketServer = typedi_1.Container.get(SocketServer_1.SocketServer);
+                socketServer.initialize(httpServer);
+                const tracingService = typedi_1.Container.get(TracingService_1.TracingService);
+                tracingService.initialize();
+            }
+        });
+    }
+    setupMaintenanceCrons(pluginArgs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!((_a = pluginArgs.cloud) === null || _a === void 0 ? void 0 : _a.cloudName)) {
+                // 1. Check for stale nodes
+                yield (0, device_utils_1.setupCronCheckStaleDevices)(pluginArgs.checkStaleDevicesIntervalMs, pluginArgs.bindHostOrIp, pluginArgs.tlsRejectUnauthorized);
+                // 2. Release blocked devices
+                yield (0, device_utils_1.setupCronReleaseBlockedDevices)(pluginArgs.checkBlockedDevicesIntervalMs, pluginArgs.newCommandTimeoutSec);
+                // 3. Clean up pending sessions
+                yield (0, device_utils_1.setupCronCleanPendingSessions)(pluginArgs.checkBlockedDevicesIntervalMs, pluginArgs.deviceAvailabilityTimeoutMs + 10000);
+                // 4. Clean up expired reservations every 1 minute
+                yield (0, device_utils_1.setupCronCleanExpiredReservations)(60000);
+                // 5. Clean up older builds and sessions
+                yield (0, device_utils_1.setupCronCleanupBuilds)(pluginArgs);
+                // 6. Start Health Monitor Service
+                const { HealthMonitorService } = yield Promise.resolve().then(() => __importStar(require('../device-managers/HealthMonitorService')));
+                typedi_1.Container.get(HealthMonitorService).start(pluginArgs);
+                // 7. Start Session Heartbeat Service
+                const { SessionHeartbeatService } = yield Promise.resolve().then(() => __importStar(require('./SessionHeartbeatService')));
+                typedi_1.Container.get(SessionHeartbeatService).start(pluginArgs);
+            }
+        });
+    }
+};
+exports.ServerManager = ServerManager;
+ServerManager.IS_HUB = false;
+exports.ServerManager = ServerManager = ServerManager_1 = __decorate([
+    (0, typedi_1.Service)()
+], ServerManager);