homebridge-config-ui-x 5.9.1-beta.0 → 5.9.1-beta.10

package/dist/modules/plugins/plugins.service.js

@@ -1,4 +1,3 @@
-"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);
@@ -8,66 +7,100 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 };
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
 var PluginsService_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginsService = void 0;
-const node_child_process_1 = require("node:child_process");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
-const node_process_1 = __importDefault(require("node:process"));
-const axios_1 = require("@nestjs/axios");
-const common_1 = require("@nestjs/common");
-const axios_2 = __importDefault(require("axios"));
-const bash_color_1 = require("bash-color");
-const fs_extra_1 = require("fs-extra");
-const lodash_1 = require("lodash");
-const node_cache_1 = __importDefault(require("node-cache"));
-const p_limit_1 = __importDefault(require("p-limit"));
-const rxjs_1 = require("rxjs");
-const semver_1 = require("semver");
-const config_service_1 = require("../../core/config/config.service");
-const logger_service_1 = require("../../core/logger/logger.service");
-const node_pty_service_1 = require("../../core/node-pty/node-pty.service");
-let PluginsService = PluginsService_1 = class PluginsService {
-    constructor(httpService, nodePtyService, logger, configService) {
+import { execSync, fork, spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { constants, existsSync } from 'node:fs';
+import { access, readdir, readFile, realpath, stat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { arch, cpus, platform, userInfo } from 'node:os';
+import { basename, delimiter, dirname, join, resolve, sep, } from 'node:path';
+import process from 'node:process';
+import { HttpService } from '@nestjs/axios';
+import { BadRequestException, Inject, Injectable, InternalServerErrorException, NotFoundException } from '@nestjs/common';
+import axios from 'axios';
+import { cyan, green, red, yellow } from 'bash-color';
+import { createFile, ensureDir, pathExists, pathExistsSync, readJson, remove } from 'fs-extra/esm';
+import _ from 'lodash';
+import NodeCache from 'node-cache';
+import pLimit from 'p-limit';
+import { firstValueFrom } from 'rxjs';
+import { gt, lt, parse, satisfies } from 'semver';
+import { ConfigService } from '../../core/config/config.service.js';
+import { HomebridgeIpcService } from '../../core/homebridge-ipc/homebridge-ipc.service.js';
+import { Logger } from '../../core/logger/logger.service.js';
+import { NodePtyService } from '../../core/node-pty/node-pty.service.js';
+import { ChildBridgesService } from '../child-bridges/child-bridges.service.js';
+const { orderBy, uniq } = _;
+const require = createRequire(import.meta.url);
+let PluginsService = class PluginsService {
+    static { PluginsService_1 = this; }
+    httpService;
+    nodePtyService;
+    logger;
+    configService;
+    homebridgeIpcService;
+    childBridgesService;
+    static PLUGIN_IDENTIFIER_PATTERN = /^(@[\w-]+(\.[\w-]+)*\/)?homebridge-[\w-]+$/;
+    _npm;
+    _paths;
+    get npm() {
+        if (!this._npm) {
+            this._npm = this.getNpmPath();
+        }
+        return this._npm;
+    }
+    get paths() {
+        if (!this._paths) {
+            this._paths = this.getBasePaths();
+        }
+        return this._paths;
+    }
+    static UI_RESTART_DELAY_MS = 5000;
+    installedPlugins;
+    npmPackage;
+    pluginListUrl = 'https://raw.githubusercontent.com/homebridge/plugins/latest/';
+    pluginListFile = `${this.pluginListUrl}assets/plugins-v2.min.json`;
+    pluginListRetryTimeout;
+    hiddenPlugins = [];
+    maintainedPlugins = [];
+    pluginIcons = {};
+    pluginAuthors = {};
+    pluginNames = {};
+    pluginChangelogs = {};
+    newScopePlugins = {};
+    verifiedPlugins = [];
+    verifiedPlusPlugins = [];
+    npmPluginCache = new NodeCache({ stdTTL: 300 });
+    pluginAliasCache = new NodeCache({ stdTTL: 86400 });
+    installedPluginsCache = new NodeCache({ stdTTL: 60 });
+    pluginAliasHints = {
+        'homebridge-broadlink-rm-pro': {
+            pluginAlias: 'BroadlinkRM',
+            pluginType: 'platform',
+        },
+    };
+    constructor(httpService, nodePtyService, logger, configService, homebridgeIpcService, childBridgesService) {
         this.httpService = httpService;
         this.nodePtyService = nodePtyService;
         this.logger = logger;
         this.configService = configService;
-        this.npm = this.getNpmPath();
-        this.paths = this.getBasePaths();
-        this.pluginListUrl = 'https://raw.githubusercontent.com/homebridge/plugins/latest/';
-        this.pluginListFile = `${this.pluginListUrl}assets/plugins-v2.min.json`;
-        this.hiddenPlugins = [];
-        this.maintainedPlugins = [];
-        this.pluginIcons = {};
-        this.pluginAuthors = {};
-        this.pluginNames = {};
-        this.pluginChangelogs = {};
-        this.newScopePlugins = {};
-        this.verifiedPlugins = [];
-        this.verifiedPlusPlugins = [];
-        this.npmPluginCache = new node_cache_1.default({ stdTTL: 300 });
-        this.pluginAliasCache = new node_cache_1.default({ stdTTL: 86400 });
-        this.installedPluginsCache = new node_cache_1.default({ stdTTL: 60 });
-        this.pluginAliasHints = {
-            'homebridge-broadlink-rm-pro': {
-                pluginAlias: 'BroadlinkRM',
-                pluginType: 'platform',
-            },
-        };
+        this.homebridgeIpcService = homebridgeIpcService;
+        this.childBridgesService = childBridgesService;
         this.httpService.axiosRef.interceptors.request.use((config) => {
-            const source = axios_2.default.CancelToken.source();
+            const source = axios.CancelToken.source();
             config.cancelToken = source.token;
             setTimeout(() => {
                 source.cancel('Timeout: request took more than 15 seconds');
             }, 15000);
             return config;
         });
-        this.loadPluginList();
+        this.loadPluginList().catch((err) => {
+            this.logger.error('Failed to load plugin list during initialization:', err);
+        });
         setInterval(this.loadPluginList.bind(this), 60000 * 60 * 12);
     }
     fixDisplayName(plugin) {
@@ -86,12 +119,12 @@ let PluginsService = PluginsService_1 = class PluginsService {
         const modules = await this.getInstalledModules();
         const disabledPlugins = await this.getDisabledPlugins();
         const homebridgePlugins = modules.filter(module => ((module.name.indexOf('homebridge-') === 0) || this.isScopedPlugin(module.name))
-            && (0, fs_extra_1.pathExistsSync)((0, node_path_1.join)(module.installPath, 'package.json')));
-        const limit = (0, p_limit_1.default)((0, node_os_1.cpus)().length);
+            && pathExistsSync(join(module.installPath, 'package.json')));
+        const limit = pLimit(cpus().length);
         await Promise.all(homebridgePlugins.map(async (pkg) => {
             return limit(async () => {
                 try {
-                    const pkgJson = await (0, fs_extra_1.readJson)((0, node_path_1.join)(pkg.installPath, 'package.json'));
+                    const pkgJson = await readJson(join(pkg.installPath, 'package.json'));
                     if (pkgJson.keywords && pkgJson.keywords.includes('homebridge-plugin')) {
                         const plugin = await this.parsePackageJson(pkgJson, pkg.path);
                         plugin.disabled = disabledPlugins.includes(plugin.name);
@@ -120,21 +153,21 @@ let PluginsService = PluginsService_1 = class PluginsService {
     }
     async lookupPlugin(pluginName) {
         if (!PluginsService_1.PLUGIN_IDENTIFIER_PATTERN.test(pluginName)) {
-            throw new common_1.BadRequestException('Invalid plugin name.');
+            throw new BadRequestException('Invalid plugin name.');
         }
         const lookup = await this.searchNpmRegistrySingle(pluginName);
         if (!lookup.length) {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         return lookup[0];
     }
     async getAvailablePluginVersions(pluginName) {
         if (!PluginsService_1.PLUGIN_IDENTIFIER_PATTERN.test(pluginName) && pluginName !== 'homebridge') {
-            throw new common_1.BadRequestException('Invalid plugin name.');
+            throw new BadRequestException('Invalid plugin name.');
         }
         try {
             const fromCache = this.npmPluginCache.get(`lookup-${pluginName}`);
-            const pkg = fromCache || (await (0, rxjs_1.firstValueFrom)((this.httpService.get(`https://registry.npmjs.org/${encodeURIComponent(pluginName).replace(/%40/g, '@')}`, {
+            const pkg = fromCache || (await firstValueFrom((this.httpService.get(`https://registry.npmjs.org/${encodeURIComponent(pluginName).replace(/%40/g, '@')}`, {
                 headers: {
                     accept: 'application/vnd.npm.install-v1+json',
                 },
@@ -156,7 +189,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
             };
         }
         catch (e) {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
     }
     extractTerms(query, separator) {
@@ -210,11 +243,11 @@ let PluginsService = PluginsService_1 = class PluginsService {
         const q = `${normalizedQuery.substring(0, 15)}+keywords:homebridge-plugin+not:deprecated&size=99`;
         let searchResults;
         try {
-            searchResults = (await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://registry.npmjs.org/-/v1/search?text=${q}`))).data;
+            searchResults = (await firstValueFrom(this.httpService.get(`https://registry.npmjs.org/-/v1/search?text=${q}`))).data;
         }
         catch (e) {
             this.logger.error(`Failed to search the npm registry (see https://homebridge.io/w/JJSz6 for help) as ${e.message}.`);
-            throw new common_1.InternalServerErrorException(`Failed to search the npm registry as ${e.message}, see logs.`);
+            throw new InternalServerErrorException(`Failed to search the npm registry as ${e.message}, see logs.`);
         }
         const hiddenPluginsSet = new Set(this.hiddenPlugins);
         const plugins = searchResults.objects
@@ -260,7 +293,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
                 matchGroups[matchType].push(plugin);
             }
         }
-        const orderPlugins = (arr) => (0, lodash_1.orderBy)(arr, ['isHbScoped', 'verifiedPlusPlugin', 'verifiedPlugin', 'lastUpdated'], ['desc', 'desc', 'desc']);
+        const orderPlugins = (arr) => orderBy(arr, ['isHbScoped', 'verifiedPlusPlugin', 'verifiedPlugin', 'lastUpdated'], ['desc', 'desc', 'desc']);
         return [
             ...orderPlugins(matchGroups.exactName),
             ...orderPlugins(matchGroups.exactKeyword),
@@ -272,7 +305,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
     async searchNpmRegistrySingle(query) {
         try {
             const fromCache = this.npmPluginCache.get(`lookup-${query}`);
-            const pkg = fromCache || (await (0, rxjs_1.firstValueFrom)((this.httpService.get(`https://registry.npmjs.org/${encodeURIComponent(query).replace(/%40/g, '@')}`)))).data;
+            const pkg = fromCache || (await firstValueFrom((this.httpService.get(`https://registry.npmjs.org/${encodeURIComponent(query).replace(/%40/g, '@')}`)))).data;
             if (!fromCache) {
                 this.npmPluginCache.set(`lookup-${query}`, pkg, 60);
             }
@@ -343,8 +376,8 @@ let PluginsService = PluginsService_1 = class PluginsService {
         if (action === 'install' && pluginAction.version === 'latest') {
             pluginAction.version = await this.getNpmModuleLatestVersion(pluginAction.name);
         }
-        const userPlatform = (0, node_os_1.platform)();
-        if (this.configService.ui.webroot && (0, semver_1.lt)(pluginAction.version, '5.9.1-alpha.0')) {
+        const userPlatform = platform();
+        if (this.configService.ui.webroot && lt(pluginAction.version, '5.9.1-alpha.0')) {
             throw new Error(`Cannot install HB UI v${pluginAction.version} when a webroot is configured.\n\r`
                 + 'Please either:\n\r'
                 + ' - Remove the configured webroot, restart Homebridge, then try the install again, or\n\r'
@@ -365,20 +398,20 @@ let PluginsService = PluginsService_1 = class PluginsService {
                 return true;
             }
             catch (e) {
-                client.emit('stdout', (0, bash_color_1.yellow)('\r\nBundled update failed. Trying regular update using npm.\r\n\r\n'));
+                client.emit('stdout', yellow('\r\nBundled update failed. Trying regular update using npm.\r\n\r\n'));
             }
         }
-        if ((0, node_os_1.cpus)().length === 1 && (0, node_os_1.arch)() === 'arm') {
-            client.emit('stdout', (0, bash_color_1.yellow)('***************************************************************\r\n'));
-            client.emit('stdout', (0, bash_color_1.yellow)(`Please be patient while ${this.configService.name} updates.\r\n`));
-            client.emit('stdout', (0, bash_color_1.yellow)('This process may take 5-15 minutes to complete on your device.\r\n'));
-            client.emit('stdout', (0, bash_color_1.yellow)('***************************************************************\r\n\r\n'));
+        if (cpus().length === 1 && arch() === 'arm') {
+            client.emit('stdout', yellow('***************************************************************\r\n'));
+            client.emit('stdout', yellow(`Please be patient while ${this.configService.name} updates.\r\n`));
+            client.emit('stdout', yellow('This process may take 5-15 minutes to complete on your device.\r\n'));
+            client.emit('stdout', yellow('***************************************************************\r\n\r\n'));
         }
         const installOptions = [];
-        if (installPath === this.configService.customPluginPath && await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(installPath, '../package.json'))) {
+        if (installPath === this.configService.customPluginPath && await pathExists(resolve(installPath, '../package.json'))) {
             installOptions.push('--save');
         }
-        installPath = (0, node_path_1.resolve)(installPath, '../');
+        installPath = resolve(installPath, '../');
         if (!this.configService.customPluginPath || userPlatform === 'win32' || existingPlugin?.globalInstall === true) {
             installOptions.push('-g');
         }
@@ -411,16 +444,16 @@ let PluginsService = PluginsService_1 = class PluginsService {
                 return true;
             }
             catch (e) {
-                client.emit('stdout', (0, bash_color_1.yellow)('\r\nBundled install / update could not complete. Trying regular install / update using npm.\r\n\r\n'));
+                client.emit('stdout', yellow('\r\nBundled install / update could not complete. Trying regular install / update using npm.\r\n\r\n'));
             }
         }
         const installOptions = [];
         let npmPluginLabel = pluginAction.name;
-        if (installPath === this.configService.customPluginPath && await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(installPath, '../package.json'))) {
+        if (installPath === this.configService.customPluginPath && await pathExists(resolve(installPath, '../package.json'))) {
             installOptions.push('--save');
         }
-        installPath = (0, node_path_1.resolve)(installPath, '../');
-        if (!this.configService.customPluginPath || (0, node_os_1.platform)() === 'win32' || existingPlugin?.globalInstall === true) {
+        installPath = resolve(installPath, '../');
+        if (!this.configService.customPluginPath || platform() === 'win32' || existingPlugin?.globalInstall === true) {
             installOptions.push('-g');
         }
         if (action === 'install') {
@@ -434,9 +467,9 @@ let PluginsService = PluginsService_1 = class PluginsService {
     }
     async getHomebridgePackage() {
         if (this.configService.ui.homebridgePackagePath) {
-            const pkgJsonPath = (0, node_path_1.join)(this.configService.ui.homebridgePackagePath, 'package.json');
-            if (await (0, fs_extra_1.pathExists)(pkgJsonPath)) {
-                return await this.parsePackageJson(await (0, fs_extra_1.readJson)(pkgJsonPath), this.configService.ui.homebridgePackagePath);
+            const pkgJsonPath = join(this.configService.ui.homebridgePackagePath, 'package.json');
+            if (await pathExists(pkgJsonPath)) {
+                return await this.parsePackageJson(await readJson(pkgJsonPath), this.configService.ui.homebridgePackagePath);
             }
             else {
                 this.logger.error(`The Homebridge path ${this.configService.ui.homebridgePackagePath} does not exist.`);
@@ -456,20 +489,20 @@ let PluginsService = PluginsService_1 = class PluginsService {
             throw new Error('Unable To Find Homebridge Installation.');
         }
         const homebridgeModule = homebridgeInstalls[0];
-        const pkgJson = await (0, fs_extra_1.readJson)((0, node_path_1.join)(homebridgeModule.installPath, 'package.json'));
+        const pkgJson = await readJson(join(homebridgeModule.installPath, 'package.json'));
         const homebridge = await this.parsePackageJson(pkgJson, homebridgeModule.path);
         if (!homebridge.latestVersion) {
             return homebridge;
         }
-        const homebridgeVersion = (0, semver_1.parse)(homebridge.installedVersion);
+        const homebridgeVersion = parse(homebridge.installedVersion);
         const installedTag = homebridgeVersion.prerelease[0]?.toString();
         if (!homebridge.updateAvailable) {
-            const shouldCheckBetas = (installedTag && ['alpha', 'beta', 'test'].includes(installedTag) && (0, semver_1.gt)(homebridge.installedVersion, homebridge.latestVersion))
+            const shouldCheckBetas = (installedTag && ['alpha', 'beta', 'test'].includes(installedTag) && gt(homebridge.installedVersion, homebridge.latestVersion))
                 || this.configService.ui.plugins?.alwaysShowBetas;
             if (shouldCheckBetas) {
                 const versions = await this.getAvailablePluginVersions('homebridge');
                 const targetTag = this.configService.ui.plugins?.alwaysShowBetas && !installedTag ? 'beta' : installedTag;
-                if (versions.tags[targetTag] && (0, semver_1.gt)(versions.tags[targetTag], homebridge.installedVersion)) {
+                if (versions.tags[targetTag] && gt(versions.tags[targetTag], homebridge.installedVersion)) {
                     homebridge.latestVersion = versions.tags[targetTag];
                     homebridge.updateAvailable = true;
                     homebridge.updateEngines = versions.versions?.[homebridge.latestVersion]?.engines || null;
@@ -489,16 +522,112 @@ let PluginsService = PluginsService_1 = class PluginsService {
         let installPath = homebridge.installPath;
         const installOptions = [];
         installOptions.push('--omit=dev');
-        if (installPath === this.configService.customPluginPath && await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(installPath, '../package.json'))) {
+        if (installPath === this.configService.customPluginPath && await pathExists(resolve(installPath, '../package.json'))) {
             installOptions.push('--save');
         }
-        installPath = (0, node_path_1.resolve)(installPath, '../');
-        if (homebridge.globalInstall || (0, node_os_1.platform)() === 'win32') {
+        installPath = resolve(installPath, '../');
+        if (homebridge.globalInstall || platform() === 'win32') {
             installOptions.push('-g');
         }
         await this.runNpmCommand([...this.npm, 'install', ...installOptions, `${homebridge.name}@${homebridgeUpdateAction.version}`], installPath, client, homebridgeUpdateAction.termCols, homebridgeUpdateAction.termRows);
         return true;
     }
+    async triggerUpdate(name, version) {
+        let targetVersion = version || 'latest';
+        try {
+            switch (name) {
+                case 'homebridge': {
+                    const homebridge = await this.getHomebridgePackage();
+                    if (targetVersion === 'latest' && homebridge.latestVersion) {
+                        targetVersion = homebridge.latestVersion;
+                    }
+                    break;
+                }
+                case 'homebridge-config-ui-x': {
+                    const uiPackage = await this.getHomebridgeUiPackage();
+                    if (!uiPackage) {
+                        throw new NotFoundException(`Package ${name} is not installed.`);
+                    }
+                    if (targetVersion === 'latest' && uiPackage.latestVersion) {
+                        targetVersion = uiPackage.latestVersion;
+                    }
+                    break;
+                }
+                default: {
+                    if (!PluginsService_1.PLUGIN_IDENTIFIER_PATTERN.test(name)) {
+                        throw new BadRequestException('Invalid package name. Must be "homebridge", "homebridge-config-ui-x", or a valid Homebridge plugin name.');
+                    }
+                    const plugins = await this.getInstalledPlugins();
+                    const plugin = plugins.find(p => p.name === name);
+                    if (!plugin) {
+                        throw new NotFoundException(`Plugin ${name} is not installed.`);
+                    }
+                    if (targetVersion === 'latest' && plugin.latestVersion) {
+                        targetVersion = plugin.latestVersion;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            if (e instanceof NotFoundException) {
+                throw e;
+            }
+            this.logger.error(`Failed to validate package ${name} for update: ${e.message}`);
+            throw new BadRequestException(`Failed to validate package ${name} for update.`);
+        }
+        setImmediate(async () => {
+            try {
+                this.logger.log(`Starting scheduled update for ${name} to version ${targetVersion}`);
+                const mockClient = new EventEmitter();
+                mockClient.on('stdout', (data) => {
+                    this.logger.log(`[${name} update] ${data.toString().trim()}`);
+                });
+                if (name === 'homebridge') {
+                    await this.updateHomebridgePackage({ version: targetVersion }, mockClient);
+                    this.logger.log(`Successfully updated Homebridge to version ${targetVersion}. Performing quick restart of Homebridge process...`);
+                    this.homebridgeIpcService.restartHomebridge();
+                }
+                else if (name === this.configService.name) {
+                    await this.managePlugin('install', { name, version: targetVersion }, mockClient);
+                    this.logger.warn(`homebridge-config-ui-x has been updated, server will restart in ${PluginsService_1.UI_RESTART_DELAY_MS / 1000} seconds...`);
+                    setTimeout(() => {
+                        process.exit(0);
+                    }, PluginsService_1.UI_RESTART_DELAY_MS);
+                }
+                else {
+                    await this.managePlugin('install', { name, version: targetVersion }, mockClient);
+                    this.logger.log(`Successfully updated ${name} to version ${targetVersion}.`);
+                    const childBridgeUsernames = await this.getPluginChildBridgeUsernames(name);
+                    if (childBridgeUsernames.length > 0) {
+                        this.logger.log(`${name} is running in ${childBridgeUsernames.length} child bridge(s). Restarting child bridges: ${childBridgeUsernames.join(', ')}`);
+                        for (const username of childBridgeUsernames) {
+                            this.logger.log(`Restarting child bridge ${username}...`);
+                            this.childBridgesService.restartChildBridge(username);
+                        }
+                    }
+                    else {
+                        this.logger.log(`${name} is not running in a child bridge. Performing quick restart of Homebridge process...`);
+                        this.homebridgeIpcService.restartHomebridge();
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.error(`Failed to update ${name}: ${error.message}`);
+                try {
+                    this.logger.warn('Attempting fallback restart of Homebridge process...');
+                    this.homebridgeIpcService.restartHomebridge();
+                }
+                catch (restartError) {
+                    this.logger.error(`Failed to restart Homebridge: ${restartError.message}`);
+                }
+            }
+        });
+        return {
+            ok: true,
+            name,
+            version: targetVersion,
+        };
+    }
     async getHomebridgeUiPackage() {
         const plugins = await this.getInstalledPlugins();
         return plugins.find((x) => x.name === this.configService.name);
@@ -513,9 +642,9 @@ let PluginsService = PluginsService_1 = class PluginsService {
             if (!npmPkg) {
                 throw new Error('Could not find npm package');
             }
-            const pkgJson = await (0, fs_extra_1.readJson)((0, node_path_1.join)(npmPkg.installPath, 'package.json'));
+            const pkgJson = await readJson(join(npmPkg.installPath, 'package.json'));
             const npm = await this.parsePackageJson(pkgJson, npmPkg.path);
-            npm.showUpdateWarning = (0, semver_1.lt)(npm.installedVersion, '9.5.0');
+            npm.showUpdateWarning = lt(npm.installedVersion, '9.5.0');
             this.npmPackage = npm;
             return npm;
         }
@@ -528,7 +657,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
             && pluginAction.version !== 'latest') {
             try {
                 const repoVersion = pluginAction.name.startsWith('@') ? 'v1.0.0-1' : 'v1.0.0';
-                await (0, rxjs_1.firstValueFrom)(this.httpService.head(`https://github.com/homebridge/plugins/releases/download/${repoVersion}/${pluginAction.name.replace('/', '@')}-${pluginAction.version}.sha256`));
+                await firstValueFrom(this.httpService.head(`https://github.com/homebridge/plugins/releases/download/${repoVersion}/${pluginAction.name.replace('/', '@')}-${pluginAction.version}.sha256`));
                 return true;
             }
             catch (e) {
@@ -540,7 +669,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
         }
     }
     async doPluginBundleUpdate(pluginAction, client) {
-        const pluginUpgradeInstallScriptPath = (0, node_path_1.join)(node_process_1.default.env.UIX_BASE_PATH, 'scripts/upgrade-install-plugin.sh');
+        const pluginUpgradeInstallScriptPath = join(process.env.UIX_BASE_PATH, 'scripts/upgrade-install-plugin.sh');
         await this.runNpmCommand([pluginUpgradeInstallScriptPath, pluginAction.name, pluginAction.version, this.configService.customPluginPath], this.configService.storagePath, client, pluginAction.termCols, pluginAction.termRows);
         return true;
     }
@@ -550,18 +679,18 @@ let PluginsService = PluginsService_1 = class PluginsService {
             '/usr/lib/node_modules',
             '/opt/homebridge/lib/node_modules',
             '/var/packages/homebridge/target/app/lib/node_modules',
-        ].includes((0, node_path_1.dirname)(node_process_1.default.env.UIX_BASE_PATH))
+        ].includes(dirname(process.env.UIX_BASE_PATH))
             && pluginAction.name === this.configService.name
             && !['latest', 'alpha', 'beta'].includes(pluginAction.version)) {
             try {
                 try {
                     const withV = `v${pluginAction.version}`;
-                    await (0, rxjs_1.firstValueFrom)(this.httpService.head(`https://github.com/homebridge/homebridge-config-ui-x/releases/download/${withV}/homebridge-config-ui-x-${pluginAction.version}.tar.gz`));
+                    await firstValueFrom(this.httpService.head(`https://github.com/homebridge/homebridge-config-ui-x/releases/download/${withV}/homebridge-config-ui-x-${pluginAction.version}.tar.gz`));
                     return withV;
                 }
                 catch (e2) {
                     const withoutV = pluginAction.version;
-                    await (0, rxjs_1.firstValueFrom)(this.httpService.head(`https://github.com/homebridge/homebridge-config-ui-x/releases/download/${withoutV}/homebridge-config-ui-x-${pluginAction.version}.tar.gz`));
+                    await firstValueFrom(this.httpService.head(`https://github.com/homebridge/homebridge-config-ui-x/releases/download/${withoutV}/homebridge-config-ui-x-${pluginAction.version}.tar.gz`));
                     return withoutV;
                 }
             }
@@ -575,21 +704,21 @@ let PluginsService = PluginsService_1 = class PluginsService {
         }
     }
     async doUiBundleUpdate(pluginAction, client, githubReleaseName) {
-        const prefix = (0, node_path_1.dirname)((0, node_path_1.dirname)((0, node_path_1.dirname)(node_process_1.default.env.UIX_BASE_PATH)));
-        const upgradeInstallScriptPath = (0, node_path_1.join)(node_process_1.default.env.UIX_BASE_PATH, 'scripts/upgrade-install.sh');
-        await this.runNpmCommand(this.configService.ui.sudo ? ['npm', 'run', 'upgrade-install', '--', pluginAction.version, prefix, githubReleaseName] : [upgradeInstallScriptPath, pluginAction.version, prefix, githubReleaseName], node_process_1.default.env.UIX_BASE_PATH, client, pluginAction.termCols, pluginAction.termRows);
+        const prefix = dirname(dirname(dirname(process.env.UIX_BASE_PATH)));
+        const upgradeInstallScriptPath = join(process.env.UIX_BASE_PATH, 'scripts/upgrade-install.sh');
+        await this.runNpmCommand(this.configService.ui.sudo ? ['npm', 'run', 'upgrade-install', '--', pluginAction.version, prefix, githubReleaseName] : [upgradeInstallScriptPath, pluginAction.version, prefix, githubReleaseName], process.env.UIX_BASE_PATH, client, pluginAction.termCols, pluginAction.termRows);
     }
     async updateSelfOffline(client) {
-        client.emit('stdout', (0, bash_color_1.yellow)(`${this.configService.name} has been scheduled to update on the next container restart.\n\r\n\r`));
+        client.emit('stdout', yellow(`${this.configService.name} has been scheduled to update on the next container restart.\n\r\n\r`));
         await new Promise(res => setTimeout(res, 800));
-        client.emit('stdout', (0, bash_color_1.yellow)('The Docker container will now try and restart.\n\r\n\r'));
+        client.emit('stdout', yellow('The Docker container will now try and restart.\n\r\n\r'));
         await new Promise(res => setTimeout(res, 800));
-        client.emit('stdout', (0, bash_color_1.yellow)('If you have not started the Docker container with ')
-            + (0, bash_color_1.red)('--restart=always') + (0, bash_color_1.yellow)(' you may\n\rneed to manually start the container again.\n\r\n\r'));
+        client.emit('stdout', yellow('If you have not started the Docker container with ')
+            + red('--restart=always') + yellow(' you may\n\rneed to manually start the container again.\n\r\n\r'));
         await new Promise(res => setTimeout(res, 800));
-        client.emit('stdout', (0, bash_color_1.yellow)('This process may take several minutes. Please be patient.\n\r'));
+        client.emit('stdout', yellow('This process may take several minutes. Please be patient.\n\r'));
         await new Promise(res => setTimeout(res, 10000));
-        await (0, fs_extra_1.createFile)('/homebridge/.uix-upgrade-on-restart');
+        await createFile('/homebridge/.uix-upgrade-on-restart');
     }
     async getPluginConfigSchema(pluginName) {
         if (!this.installedPlugins) {
@@ -597,19 +726,19 @@ let PluginsService = PluginsService_1 = class PluginsService {
         }
         const plugin = this.installedPlugins.find(x => x.name === pluginName);
         if (!plugin) {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         if (!plugin.settingsSchema) {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
-        const schemaPath = (0, node_path_1.resolve)(plugin.installPath, pluginName, 'config.schema.json');
-        let configSchema = await (0, fs_extra_1.readJson)(schemaPath);
+        const schemaPath = resolve(plugin.installPath, pluginName, 'config.schema.json');
+        let configSchema = await readJson(schemaPath);
         if (configSchema.dynamicSchemaVersion) {
-            const dynamicSchemaPath = (0, node_path_1.resolve)(this.configService.storagePath, `.${pluginName}-v${configSchema.dynamicSchemaVersion}.schema.json`);
+            const dynamicSchemaPath = resolve(this.configService.storagePath, `.${pluginName}-v${configSchema.dynamicSchemaVersion}.schema.json`);
             this.logger.log(`[${pluginName}] dynamic schema path: ${dynamicSchemaPath}.`);
-            if ((0, fs_extra_1.existsSync)(dynamicSchemaPath)) {
+            if (existsSync(dynamicSchemaPath)) {
                 try {
-                    configSchema = await (0, fs_extra_1.readJson)(dynamicSchemaPath);
+                    configSchema = await readJson(dynamicSchemaPath);
                     this.logger.log(`[${pluginName}] dynamic schema loaded from ${dynamicSchemaPath}.`);
                 }
                 catch (e) {
@@ -695,34 +824,34 @@ let PluginsService = PluginsService_1 = class PluginsService {
         await this.getInstalledPlugins();
         const plugin = this.installedPlugins.find(x => x.name === pluginName);
         if (!plugin) {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
-        const changeLog = (0, node_path_1.resolve)(plugin.installPath, plugin.name, 'CHANGELOG.md');
-        if (await (0, fs_extra_1.pathExists)(changeLog)) {
+        const changeLog = resolve(plugin.installPath, plugin.name, 'CHANGELOG.md');
+        if (await pathExists(changeLog)) {
             return {
-                changelog: await (0, fs_extra_1.readFile)(changeLog, 'utf8'),
+                changelog: await readFile(changeLog, 'utf8'),
             };
         }
         else {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
     }
     async getPluginRelease(pluginName) {
         let latestVersion = null;
         try {
-            const pkg = (await (0, rxjs_1.firstValueFrom)((this.httpService.get(`https://registry.npmjs.org/${encodeURIComponent(pluginName).replace(/%40/g, '@')}`)))).data;
+            const pkg = (await firstValueFrom((this.httpService.get(`https://registry.npmjs.org/${encodeURIComponent(pluginName).replace(/%40/g, '@')}`)))).data;
             latestVersion = pkg['dist-tags'] ? pkg['dist-tags'].latest : null;
         }
         catch (e) {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         switch (pluginName) {
             case 'homebridge':
             case 'homebridge-config-ui-x': {
                 try {
-                    const release = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://api.github.com/repos/homebridge/${pluginName}/releases/latest`));
-                    const tags = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://api.github.com/repos/homebridge/${pluginName}/tags`));
-                    const changelog = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://raw.githubusercontent.com/homebridge/${pluginName}/refs/tags/${tags.data[0].name}/CHANGELOG.md`));
+                    const release = await firstValueFrom(this.httpService.get(`https://api.github.com/repos/homebridge/${pluginName}/releases/latest`));
+                    const tags = await firstValueFrom(this.httpService.get(`https://api.github.com/repos/homebridge/${pluginName}/tags`));
+                    const changelog = await firstValueFrom(this.httpService.get(`https://raw.githubusercontent.com/homebridge/${pluginName}/refs/tags/${tags.data[0].name}/CHANGELOG.md`));
                     return {
                         name: release.data.name,
                         notes: release.data.body,
@@ -743,33 +872,33 @@ let PluginsService = PluginsService_1 = class PluginsService {
                 await this.getInstalledPlugins();
                 const plugin = this.installedPlugins.find(x => x.name === pluginName);
                 if (!plugin) {
-                    throw new common_1.NotFoundException();
+                    throw new NotFoundException();
                 }
                 if (!plugin.links.homepage && !plugin.links.bugs) {
-                    throw new common_1.NotFoundException();
+                    throw new NotFoundException();
                 }
                 const repoMatch = plugin.links.homepage?.match(/https:\/\/github.com\/([^/]+)\/([^/#]+)/);
                 const bugsMatch = plugin.links.bugs?.match(/https:\/\/github.com\/([^/]+)\/([^/#]+)/);
                 let match = repoMatch;
                 if (!repoMatch) {
                     if (!bugsMatch) {
-                        throw new common_1.NotFoundException();
+                        throw new NotFoundException();
                     }
                     match = bugsMatch;
                 }
                 try {
-                    const release = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://api.github.com/repos/${match[1]}/${match[2]}/releases/latest`));
+                    const release = await firstValueFrom(this.httpService.get(`https://api.github.com/repos/${match[1]}/${match[2]}/releases/latest`));
                     const latestTag = release.data.tag_name;
                     const isReleaseMatch = latestVersion?.replace(/[^0-9.]/g, '').includes(release.data.tag_name?.replace(/[^0-9.]/g, ''));
                     const changelogPath = this.pluginChangelogs[pluginName] || '';
                     let changelogData = null;
                     try {
-                        const changelog = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://raw.githubusercontent.com/${match[1]}/${match[2]}/refs/tags/${latestTag}/${changelogPath}CHANGELOG.md`));
+                        const changelog = await firstValueFrom(this.httpService.get(`https://raw.githubusercontent.com/${match[1]}/${match[2]}/refs/tags/${latestTag}/${changelogPath}CHANGELOG.md`));
                         changelogData = changelog.data;
                     }
                     catch {
                         try {
-                            const changelog = (await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://raw.githubusercontent.com/${match[1]}/${match[2]}/refs/tags/${latestTag}/${changelogPath}changelog.md`))).data;
+                            const changelog = (await firstValueFrom(this.httpService.get(`https://raw.githubusercontent.com/${match[1]}/${match[2]}/refs/tags/${latestTag}/${changelogPath}changelog.md`))).data;
                             changelogData = changelog.data;
                         }
                         catch { }
@@ -782,7 +911,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
                     };
                 }
                 catch (e) {
-                    throw new common_1.NotFoundException();
+                    throw new NotFoundException();
                 }
             }
         }
@@ -793,7 +922,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
         }
         const plugin = this.installedPlugins.find(x => x.name === pluginName);
         if (!plugin) {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         const fromCache = this.pluginAliasCache.get(pluginName);
         if (fromCache) {
@@ -811,9 +940,9 @@ let PluginsService = PluginsService_1 = class PluginsService {
         else {
             try {
                 await new Promise((res, rej) => {
-                    const child = (0, node_child_process_1.fork)((0, node_path_1.resolve)(node_process_1.default.env.UIX_BASE_PATH, 'scripts/extract-plugin-alias.js'), {
+                    const child = fork(resolve(process.env.UIX_BASE_PATH, 'scripts/extract-plugin-alias.js'), {
                         env: {
-                            UIX_EXTRACT_PLUGIN_PATH: (0, node_path_1.resolve)(plugin.installPath, plugin.name),
+                            UIX_EXTRACT_PLUGIN_PATH: resolve(plugin.installPath, plugin.name),
                         },
                         stdio: 'ignore',
                     });
@@ -845,24 +974,50 @@ let PluginsService = PluginsService_1 = class PluginsService {
         this.pluginAliasCache.set(pluginName, output);
         return output;
     }
+    async getPluginChildBridgeUsernames(pluginName) {
+        try {
+            const plugin = await this.getPluginAlias(pluginName);
+            if (!plugin.pluginAlias) {
+                return [];
+            }
+            const config = await readJson(this.configService.configPath);
+            const arrayKey = plugin.pluginType === 'accessory' ? 'accessories' : 'platforms';
+            const usernamesSet = new Set();
+            const pluginBlocks = config[arrayKey]?.filter((block) => {
+                const matchesPlugin = block[plugin.pluginType] === plugin.pluginAlias
+                    || block[plugin.pluginType] === `${pluginName}.${plugin.pluginAlias}`;
+                return matchesPlugin && block._bridge?.username;
+            }) || [];
+            for (const block of pluginBlocks) {
+                if (block._bridge?.username) {
+                    usernamesSet.add(block._bridge.username);
+                }
+            }
+            return Array.from(usernamesSet);
+        }
+        catch (e) {
+            this.logger.error(`Failed to get child bridge usernames for ${pluginName}: ${e.message}`);
+            return [];
+        }
+    }
     async getPluginUiMetadata(pluginName) {
         if (!this.installedPlugins) {
             await this.getInstalledPlugins();
         }
         const plugin = this.installedPlugins.find(x => x.name === pluginName);
-        const fullPath = (0, node_path_1.resolve)(plugin.installPath, plugin.name);
-        const schema = await (0, fs_extra_1.readJson)((0, node_path_1.resolve)(fullPath, 'config.schema.json'));
-        const customUiPath = (0, node_path_1.resolve)(fullPath, schema.customUiPath || 'homebridge-ui');
-        const publicPath = (0, node_path_1.resolve)(customUiPath, 'public');
-        const serverPath = (0, node_path_1.resolve)(customUiPath, 'server.js');
+        const fullPath = resolve(plugin.installPath, plugin.name);
+        const schema = await readJson(resolve(fullPath, 'config.schema.json'));
+        const customUiPath = resolve(fullPath, schema.customUiPath || 'homebridge-ui');
+        const publicPath = resolve(customUiPath, 'public');
+        const serverPath = resolve(customUiPath, 'server.js');
         const devServer = plugin.private ? schema.customUiDevServer : null;
-        if (!devServer && !await (0, fs_extra_1.pathExists)(customUiPath)) {
+        if (!devServer && !await pathExists(customUiPath)) {
             throw new Error(`Plugin does not provide a custom UI at expected location: ${customUiPath}`);
         }
-        if (!devServer && !(await (0, fs_extra_1.realpath)(customUiPath)).startsWith(await (0, fs_extra_1.realpath)(fullPath))) {
-            throw new Error(`Custom UI path is outside the plugin root: ${await (0, fs_extra_1.realpath)(customUiPath)}`);
+        if (!devServer && !(await realpath(customUiPath)).startsWith(await realpath(fullPath))) {
+            throw new Error(`Custom UI path is outside the plugin root: ${await realpath(customUiPath)}`);
         }
-        if (await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(publicPath, 'index.html')) || devServer) {
+        if (await pathExists(resolve(publicPath, 'index.html')) || devServer) {
             return {
                 devServer,
                 serverPath,
@@ -874,7 +1029,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
     }
     async getDisabledPlugins() {
         try {
-            const config = await (0, fs_extra_1.readJson)(this.configService.configPath);
+            const config = await readJson(this.configService.configPath);
             if (Array.isArray(config.disabledPlugins)) {
                 return config.disabledPlugins;
             }
@@ -888,14 +1043,14 @@ let PluginsService = PluginsService_1 = class PluginsService {
     }
     async getInstalledScopedModules(requiredPath, scope) {
         try {
-            if ((await (0, fs_extra_1.stat)((0, node_path_1.join)(requiredPath, scope))).isDirectory()) {
-                const scopedModules = await (0, fs_extra_1.readdir)((0, node_path_1.join)(requiredPath, scope));
+            if ((await stat(join(requiredPath, scope))).isDirectory()) {
+                const scopedModules = await readdir(join(requiredPath, scope));
                 return scopedModules
                     .filter(x => x.startsWith('homebridge-'))
                     .map((x) => {
                     return {
-                        name: (0, node_path_1.join)(scope, x).split(node_path_1.sep).join('/'),
-                        installPath: (0, node_path_1.join)(requiredPath, scope, x),
+                        name: join(scope, x).split(sep).join('/'),
+                        installPath: join(requiredPath, scope, x),
                         path: requiredPath,
                     };
                 });
@@ -912,7 +1067,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
     async getInstalledModules() {
         const allModules = [];
         for (const requiredPath of this.paths) {
-            const modules = await (0, fs_extra_1.readdir)(requiredPath);
+            const modules = await readdir(requiredPath);
             for (const module of modules) {
                 try {
                     if (module.charAt(0) === '@') {
@@ -921,7 +1076,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
                     else {
                         allModules.push({
                             name: module,
-                            installPath: (0, node_path_1.join)(requiredPath, module),
+                            installPath: join(requiredPath, module),
                             path: requiredPath,
                         });
                     }
@@ -934,16 +1089,16 @@ let PluginsService = PluginsService_1 = class PluginsService {
         if (allModules.findIndex(x => x.name === 'homebridge-config-ui-x') === -1) {
             allModules.push({
                 name: 'homebridge-config-ui-x',
-                installPath: node_process_1.default.env.UIX_BASE_PATH,
-                path: (0, node_path_1.dirname)(node_process_1.default.env.UIX_BASE_PATH),
+                installPath: process.env.UIX_BASE_PATH,
+                path: dirname(process.env.UIX_BASE_PATH),
             });
         }
         if (allModules.findIndex(x => x.name === 'homebridge') === -1) {
-            if ((0, fs_extra_1.existsSync)((0, node_path_1.join)(node_process_1.default.env.UIX_BASE_PATH, '..', 'homebridge'))) {
+            if (existsSync(join(process.env.UIX_BASE_PATH, '..', 'homebridge'))) {
                 allModules.push({
                     name: 'homebridge',
-                    installPath: (0, node_path_1.join)(node_process_1.default.env.UIX_BASE_PATH, '..', 'homebridge'),
-                    path: (0, node_path_1.dirname)((0, node_path_1.join)(node_process_1.default.env.UIX_BASE_PATH, '..', 'homebridge')),
+                    installPath: join(process.env.UIX_BASE_PATH, '..', 'homebridge'),
+                    path: dirname(join(process.env.UIX_BASE_PATH, '..', 'homebridge')),
                 });
             }
         }
@@ -953,12 +1108,12 @@ let PluginsService = PluginsService_1 = class PluginsService {
         return (name.charAt(0) === '@' && name.split('/').length > 0 && name.split('/')[1].indexOf('homebridge-') === 0);
     }
     getNpmPath() {
-        if ((0, node_os_1.platform)() === 'win32') {
+        if (platform() === 'win32') {
             const windowsNpmPath = [
-                (0, node_path_1.join)(node_process_1.default.env.APPDATA, 'npm/npm.cmd'),
-                (0, node_path_1.join)(node_process_1.default.env.ProgramFiles, 'nodejs/npm.cmd'),
-                (0, node_path_1.join)(node_process_1.default.env.NVM_SYMLINK || `${node_process_1.default.env.ProgramFiles}/nodejs`, 'npm.cmd'),
-            ].filter(fs_extra_1.existsSync);
+                join(process.env.APPDATA, 'npm/npm.cmd'),
+                join(process.env.ProgramFiles, 'nodejs/npm.cmd'),
+                join(process.env.NVM_SYMLINK || `${process.env.ProgramFiles}/nodejs`, 'npm.cmd'),
+            ].filter(existsSync);
             if (windowsNpmPath.length) {
                 return [windowsNpmPath[0]];
             }
@@ -981,33 +1136,33 @@ let PluginsService = PluginsService_1 = class PluginsService {
         }
         else {
             paths = paths.concat(require.main?.paths || []);
-            if (node_process_1.default.env.NODE_PATH) {
-                paths = node_process_1.default.env.NODE_PATH.split(node_path_1.delimiter).filter(p => !!p).concat(paths);
+            if (process.env.NODE_PATH) {
+                paths = process.env.NODE_PATH.split(delimiter).filter(p => !!p).concat(paths);
             }
             else {
-                if (((0, node_os_1.platform)() !== 'win32')) {
+                if ((platform() !== 'win32')) {
                     paths.push('/usr/local/lib/node_modules');
                     paths.push('/usr/lib/node_modules');
                 }
                 paths.push(...this.getNpmPrefixToSearchPaths());
             }
-            paths = paths.filter(x => x !== (0, node_path_1.join)(node_process_1.default.env.UIX_BASE_PATH, 'node_modules'));
+            paths = paths.filter(x => x !== join(process.env.UIX_BASE_PATH, 'node_modules'));
         }
-        return (0, lodash_1.uniq)(paths).filter((requiredPath) => {
-            return (0, fs_extra_1.existsSync)(requiredPath);
+        return uniq(paths).filter((requiredPath) => {
+            return existsSync(requiredPath);
         });
     }
     getNpmPrefixToSearchPaths() {
         const paths = [];
-        if (((0, node_os_1.platform)() === 'win32')) {
-            paths.push((0, node_path_1.join)(node_process_1.default.env.APPDATA, 'npm/node_modules'));
+        if ((platform() === 'win32')) {
+            paths.push(join(process.env.APPDATA, 'npm/node_modules'));
         }
         else {
-            paths.push((0, node_child_process_1.execSync)('/bin/echo -n "$(npm -g prefix)/lib/node_modules"', {
+            paths.push(execSync('/bin/echo -n "$(npm -g prefix)/lib/node_modules"', {
                 env: Object.assign({
                     npm_config_loglevel: 'silent',
                     npm_update_notifier: 'false',
-                }, node_process_1.default.env),
+                }, process.env),
             }).toString('utf8'));
         }
         return paths;
@@ -1030,7 +1185,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
             isHbMaintained: this.maintainedPlugins.includes(pkgJson.name),
             installedVersion: installPath ? (pkgJson.version || '0.0.1') : null,
             globalInstall: (installPath !== this.configService.customPluginPath),
-            settingsSchema: await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(installPath, pkgJson.name, 'config.schema.json')),
+            settingsSchema: await pathExists(resolve(installPath, pkgJson.name, 'config.schema.json')),
             engines: pkgJson.engines,
             installPath,
         };
@@ -1049,20 +1204,20 @@ let PluginsService = PluginsService_1 = class PluginsService {
             const fromCache = this.npmPluginCache.get(plugin.name);
             plugin.updateAvailable = false;
             plugin.updateTag = null;
-            const pkg = fromCache || (await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://registry.npmjs.org/${encodeURIComponent(plugin.name).replace(/%40/g, '@')}/latest`))).data;
+            const pkg = fromCache || (await firstValueFrom(this.httpService.get(`https://registry.npmjs.org/${encodeURIComponent(plugin.name).replace(/%40/g, '@')}/latest`))).data;
             plugin.latestVersion = pkg.version;
-            plugin.updateAvailable = (0, semver_1.gt)(pkg.version, plugin.installedVersion);
+            plugin.updateAvailable = gt(pkg.version, plugin.installedVersion);
             plugin.updateEngines = plugin.updateAvailable ? pkg.engines : null;
             if (!plugin.updateAvailable) {
-                const pluginVersion = (0, semver_1.parse)(plugin.installedVersion);
+                const pluginVersion = parse(plugin.installedVersion);
                 const installedTag = pluginVersion.prerelease[0]?.toString();
                 const shouldCheckBetas = (installedTag
                     && ['alpha', 'beta', 'test'].includes(installedTag)
-                    && (0, semver_1.gt)(plugin.installedVersion, plugin.latestVersion)) || this.configService.ui.plugins?.alwaysShowBetas;
+                    && gt(plugin.installedVersion, plugin.latestVersion)) || this.configService.ui.plugins?.alwaysShowBetas;
                 if (shouldCheckBetas) {
                     const versions = await this.getAvailablePluginVersions(plugin.name);
                     const targetTag = this.configService.ui.plugins?.alwaysShowBetas && !installedTag ? 'beta' : installedTag;
-                    if (versions.tags[targetTag] && (0, semver_1.gt)(versions.tags[targetTag], plugin.installedVersion)) {
+                    if (versions.tags[targetTag] && gt(versions.tags[targetTag], plugin.installedVersion)) {
                         plugin.latestVersion = versions.tags[targetTag];
                         plugin.updateAvailable = true;
                         plugin.updateEngines = versions.versions?.[plugin.latestVersion]?.engines || null;
@@ -1096,7 +1251,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
     }
     async getNpmModuleLatestVersion(npmModuleName) {
         try {
-            const response = await (0, rxjs_1.firstValueFrom)(this.httpService.get(`https://registry.npmjs.org/${npmModuleName}/latest`));
+            const response = await firstValueFrom(this.httpService.get(`https://registry.npmjs.org/${npmModuleName}/latest`));
             return response.data.version;
         }
         catch (e) {
@@ -1113,29 +1268,29 @@ let PluginsService = PluginsService_1 = class PluginsService {
         else {
             let npmInstallPath;
             try {
-                npmInstallPath = (0, node_child_process_1.execSync)('npm root -g').toString().trim();
+                npmInstallPath = execSync('npm root -g').toString().trim();
             }
             catch (e) {
-                npmInstallPath = (0, node_path_1.resolve)(cwd, 'node_modules');
+                npmInstallPath = resolve(cwd, 'node_modules');
             }
             try {
-                await (0, fs_extra_1.access)(npmInstallPath, fs_extra_1.constants.W_OK);
+                await access(npmInstallPath, constants.W_OK);
             }
             catch (e) {
-                client.emit('stdout', (0, bash_color_1.yellow)(`The user "${(0, node_os_1.userInfo)().username}" does not have write access to the target directory:\n\r\n\r`));
+                client.emit('stdout', yellow(`The user "${userInfo().username}" does not have write access to the target directory:\n\r\n\r`));
                 client.emit('stdout', `${npmInstallPath}\n\r\n\r`);
-                client.emit('stdout', (0, bash_color_1.yellow)('This may cause the operation to fail.\n\r'));
-                client.emit('stdout', (0, bash_color_1.yellow)('See the docs for details on how to enable sudo mode:\n\r'));
-                client.emit('stdout', (0, bash_color_1.yellow)('https://github.com/homebridge/homebridge-config-ui-x/wiki/Manual-Configuration#sudo-mode\n\r\n\r'));
+                client.emit('stdout', yellow('This may cause the operation to fail.\n\r'));
+                client.emit('stdout', yellow('See the docs for details on how to enable sudo mode:\n\r'));
+                client.emit('stdout', yellow('https://github.com/homebridge/homebridge-config-ui-x/wiki/Manual-Configuration#sudo-mode\n\r\n\r'));
             }
         }
         this.logger.log(`Running command ${command.join(' ')}.`);
-        if (!(0, semver_1.satisfies)(node_process_1.default.version, `>=${this.configService.minimumNodeVersion}`)) {
-            client.emit('stdout', (0, bash_color_1.yellow)(`Node.js v${this.configService.minimumNodeVersion} higher is required for ${this.configService.name}.\n\r`));
-            client.emit('stdout', (0, bash_color_1.yellow)(`You may experience issues while running on Node.js ${node_process_1.default.version}.\n\r\n\r`));
+        if (!satisfies(process.version, `>=${this.configService.minimumNodeVersion}`)) {
+            client.emit('stdout', yellow(`Node.js v${this.configService.minimumNodeVersion} higher is required for ${this.configService.name}.\n\r`));
+            client.emit('stdout', yellow(`You may experience issues while running on Node.js ${process.version}.\n\r\n\r`));
         }
         const env = {};
-        Object.assign(env, node_process_1.default.env);
+        Object.assign(env, process.env);
         Object.assign(env, {
             npm_config_global_style: 'true',
             npm_config_unsafe_perm: 'true',
@@ -1144,20 +1299,20 @@ let PluginsService = PluginsService_1 = class PluginsService {
             npm_config_foreground_scripts: 'true',
             npm_config_loglevel: 'error',
         });
-        if (command.includes('-g') && (0, node_path_1.basename)(cwd) === 'lib') {
-            cwd = (0, node_path_1.dirname)(cwd);
+        if (command.includes('-g') && basename(cwd) === 'lib') {
+            cwd = dirname(cwd);
             Object.assign(env, {
                 npm_config_prefix: cwd,
             });
         }
-        if ((0, node_os_1.platform)() === 'win32') {
+        if (platform() === 'win32') {
             Object.assign(env, {
                 npm_config_prefix: cwd,
             });
         }
-        client.emit('stdout', (0, bash_color_1.cyan)(`USER: ${(0, node_os_1.userInfo)().username}\n\r`));
-        client.emit('stdout', (0, bash_color_1.cyan)(`DIR: ${cwd}\n\r`));
-        client.emit('stdout', (0, bash_color_1.cyan)(`CMD: ${command.join(' ')}\n\r\n\r`));
+        client.emit('stdout', cyan(`USER: ${userInfo().username}\n\r`));
+        client.emit('stdout', cyan(`DIR: ${cwd}\n\r`));
+        client.emit('stdout', cyan(`CMD: ${command.join(' ')}\n\r\n\r`));
         this.installedPluginsCache.del('installed-plugins');
         await new Promise((res, rej) => {
             const term = this.nodePtyService.spawn(command.shift(), command, {
@@ -1173,7 +1328,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
             term.onExit(({ exitCode }) => {
                 if (exitCode === 0) {
                     clearTimeout(timeoutTimer);
-                    client.emit('stdout', (0, bash_color_1.green)('\n\rOperation succeeded!.\n\r'));
+                    client.emit('stdout', green('\n\rOperation succeeded!.\n\r'));
                     res(null);
                 }
                 else {
@@ -1190,10 +1345,10 @@ let PluginsService = PluginsService_1 = class PluginsService {
         if (!this.configService.customPluginPath) {
             return;
         }
-        if (!await (0, fs_extra_1.pathExists)(this.configService.customPluginPath)) {
+        if (!await pathExists(this.configService.customPluginPath)) {
             this.logger.warn(`Custom plugin directory was removed, re-creating ${this.configService.customPluginPath}.`);
             try {
-                await (0, fs_extra_1.ensureDir)(this.configService.customPluginPath);
+                await ensureDir(this.configService.customPluginPath);
             }
             catch (e) {
                 this.logger.error(`Failed to re-create custom plugin directory as ${e.message}.`);
@@ -1204,10 +1359,10 @@ let PluginsService = PluginsService_1 = class PluginsService {
         if (!this.configService.customPluginPath) {
             return;
         }
-        const offendingPath = (0, node_path_1.resolve)(this.configService.customPluginPath, '@eaDir');
+        const offendingPath = resolve(this.configService.customPluginPath, '@eaDir');
         try {
-            if (!await (0, fs_extra_1.pathExists)(offendingPath)) {
-                await (0, fs_extra_1.remove)(offendingPath);
+            if (!await pathExists(offendingPath)) {
+                await remove(offendingPath);
             }
         }
         catch (e) {
@@ -1220,7 +1375,8 @@ let PluginsService = PluginsService_1 = class PluginsService {
             command.unshift('sudo', '-E', '-n');
         }
         return new Promise((res) => {
-            const child = (0, node_child_process_1.spawn)(command.shift(), command, { shell: true });
+            const fullCommand = command.join(' ');
+            const child = spawn(fullCommand, { shell: true });
             child.on('exit', (code) => {
                 this.logger.log(`Executed npm cache clear command with exit code ${code}.`);
                 res(null);
@@ -1232,7 +1388,7 @@ let PluginsService = PluginsService_1 = class PluginsService {
     async loadPluginList() {
         clearTimeout(this.pluginListRetryTimeout);
         try {
-            const pluginList = (await (0, rxjs_1.firstValueFrom)(this.httpService.get(this.pluginListFile, {
+            const pluginList = (await firstValueFrom(this.httpService.get(this.pluginListFile, {
                 httpsAgent: null,
             })));
             const pluginListData = pluginList.data;
@@ -1282,13 +1438,20 @@ let PluginsService = PluginsService_1 = class PluginsService {
         }
     }
 };
-exports.PluginsService = PluginsService;
-PluginsService.PLUGIN_IDENTIFIER_PATTERN = /^(@[\w-]+(\.[\w-]+)*\/)?homebridge-[\w-]+$/;
-exports.PluginsService = PluginsService = PluginsService_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [axios_1.HttpService,
-        node_pty_service_1.NodePtyService,
-        logger_service_1.Logger,
-        config_service_1.ConfigService])
+PluginsService = PluginsService_1 = __decorate([
+    Injectable(),
+    __param(0, Inject(HttpService)),
+    __param(1, Inject(NodePtyService)),
+    __param(2, Inject(Logger)),
+    __param(3, Inject(ConfigService)),
+    __param(4, Inject(HomebridgeIpcService)),
+    __param(5, Inject(ChildBridgesService)),
+    __metadata("design:paramtypes", [HttpService,
+        NodePtyService,
+        Logger,
+        ConfigService,
+        HomebridgeIpcService,
+        ChildBridgesService])
 ], PluginsService);
+export { PluginsService };
 //# sourceMappingURL=plugins.service.js.map