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

package/dist/modules/server/server.service.js

@@ -1,113 +1,86 @@
-"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 __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); }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerService = void 0;
-const node_buffer_1 = require("node:buffer");
-const node_child_process_1 = require("node:child_process");
-const node_crypto_1 = require("node:crypto");
-const node_path_1 = require("node:path");
-const node_process_1 = __importDefault(require("node:process"));
-const node_stream_1 = require("node:stream");
-const node_tls_1 = require("node:tls");
-const node_util_1 = require("node:util");
-const hap_types_1 = require("@homebridge/hap-client/dist/hap-types");
-const common_1 = require("@nestjs/common");
-const fs_extra_1 = require("fs-extra");
-const node_cache_1 = __importDefault(require("node-cache"));
-const systeminformation_1 = require("systeminformation");
-const tcp_port_used_1 = require("tcp-port-used");
-const config_service_1 = require("../../core/config/config.service");
-const homebridge_ipc_service_1 = require("../../core/homebridge-ipc/homebridge-ipc.service");
-const logger_service_1 = require("../../core/logger/logger.service");
-const ssl_cert_generator_service_1 = require("../../core/ssl/ssl-cert-generator.service");
-const accessories_service_1 = require("../accessories/accessories.service");
-const config_editor_service_1 = require("../config-editor/config-editor.service");
-const pump = (0, node_util_1.promisify)(node_stream_1.pipeline);
+import { Buffer } from 'node:buffer';
+import { exec, spawn } from 'node:child_process';
+import { createPrivateKey, createPublicKey, X509Certificate } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { readdir, unlink } from 'node:fs/promises';
+import { extname, join, resolve } from 'node:path';
+import process from 'node:process';
+import { pipeline } from 'node:stream';
+import { createSecureContext } from 'node:tls';
+import { promisify } from 'node:util';
+import { Categories } from '@homebridge/hap-client/dist/hap-types.js';
+import { BadRequestException, Inject, Injectable, InternalServerErrorException, NotFoundException, ServiceUnavailableException, } from '@nestjs/common';
+import { pathExists, readJson, remove, writeJson } from 'fs-extra/esm';
+import NodeCache from 'node-cache';
+import { networkInterfaces } from 'systeminformation';
+import { check as tcpCheck } from 'tcp-port-used';
+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 { SslCertGeneratorService } from '../../core/ssl/ssl-cert-generator.service.js';
+import { AccessoriesService } from '../accessories/accessories.service.js';
+import { ConfigEditorService } from '../config-editor/config-editor.service.js';
+const pump = promisify(pipeline);
 let ServerService = class ServerService {
+    configService;
+    configEditorService;
+    accessoriesService;
+    homebridgeIpcService;
+    logger;
+    serverServiceCache = new NodeCache({ stdTTL: 300 });
+    accessoryId;
+    accessoryInfoPath;
+    setupCode = null;
+    paired = false;
     constructor(configService, configEditorService, accessoriesService, homebridgeIpcService, logger) {
         this.configService = configService;
         this.configEditorService = configEditorService;
         this.accessoriesService = accessoriesService;
         this.homebridgeIpcService = homebridgeIpcService;
         this.logger = logger;
-        this.serverServiceCache = new node_cache_1.default({ stdTTL: 300 });
-        this.setupCode = null;
-        this.paired = false;
         this.accessoryId = this.configService.homebridgeConfig.bridge.username.split(':').join('');
-        this.accessoryInfoPath = (0, node_path_1.join)(this.configService.storagePath, 'persist', `AccessoryInfo.${this.accessoryId}.json`);
+        this.accessoryInfoPath = join(this.configService.storagePath, 'persist', `AccessoryInfo.${this.accessoryId}.json`);
     }
     async deleteSingleDeviceAccessories(id, cachedAccessoriesDir, protocol = 'both') {
         if (protocol === 'hap' || protocol === 'both') {
-            const cachedAccessories = (0, node_path_1.join)(cachedAccessoriesDir, `cachedAccessories.${id}`);
-            const cachedAccessoriesBackup = (0, node_path_1.join)(cachedAccessoriesDir, `.cachedAccessories.${id}.bak`);
-            if (await (0, fs_extra_1.pathExists)(cachedAccessories)) {
-                await (0, fs_extra_1.unlink)(cachedAccessories);
+            const cachedAccessories = join(cachedAccessoriesDir, `cachedAccessories.${id}`);
+            const cachedAccessoriesBackup = join(cachedAccessoriesDir, `.cachedAccessories.${id}.bak`);
+            if (await pathExists(cachedAccessories)) {
+                await unlink(cachedAccessories);
                 this.logger.warn(`Bridge ${id} HAP accessory removal: removed ${cachedAccessories}.`);
             }
-            if (await (0, fs_extra_1.pathExists)(cachedAccessoriesBackup)) {
-                await (0, fs_extra_1.unlink)(cachedAccessoriesBackup);
+            if (await pathExists(cachedAccessoriesBackup)) {
+                await unlink(cachedAccessoriesBackup);
                 this.logger.warn(`Bridge ${id} HAP accessory removal: removed ${cachedAccessoriesBackup}.`);
             }
         }
         if (protocol === 'matter' || protocol === 'both') {
             const deviceId = id.split(':').join('').toUpperCase();
-            const matterPath = (0, node_path_1.join)(this.configService.storagePath, 'matter', deviceId);
-            if (await (0, fs_extra_1.pathExists)(matterPath)) {
-                await (0, fs_extra_1.remove)(matterPath);
+            const matterPath = join(this.configService.storagePath, 'matter', deviceId);
+            if (await pathExists(matterPath)) {
+                await remove(matterPath);
                 this.logger.warn(`Bridge ${id} Matter accessory removal: removed Matter bridge storage at ${matterPath}.`);
             }
         }
     }
     async deleteSingleDevicePairing(id, resetPairingInfo) {
-        const persistPath = (0, node_path_1.join)(this.configService.storagePath, 'persist');
-        const accessoryInfo = (0, node_path_1.join)(persistPath, `AccessoryInfo.${id}.json`);
-        const identifierCache = (0, node_path_1.join)(persistPath, `IdentifierCache.${id}.json`);
+        const persistPath = join(this.configService.storagePath, 'persist');
+        const accessoryInfo = join(persistPath, `AccessoryInfo.${id}.json`);
+        const identifierCache = join(persistPath, `IdentifierCache.${id}.json`);
         const deviceId = id.includes(':') ? id.split(':').join('').toUpperCase() : id.toUpperCase();
-        const matterPath = (0, node_path_1.join)(this.configService.storagePath, 'matter', deviceId);
+        const matterPath = join(this.configService.storagePath, 'matter', deviceId);
         try {
             const configFile = await this.configEditorService.getConfigFile();
             const username = id.includes(':') ? id.toUpperCase() : id.match(/.{1,2}/g)?.join(':').toUpperCase() || id.toUpperCase();
@@ -152,16 +125,16 @@ let ServerService = class ServerService {
         catch (e) {
             this.logger.error(`Failed to reset username and pin for child bridge ${id} as ${e.message}.`);
         }
-        if (await (0, fs_extra_1.pathExists)(accessoryInfo)) {
-            await (0, fs_extra_1.unlink)(accessoryInfo);
+        if (await pathExists(accessoryInfo)) {
+            await unlink(accessoryInfo);
             this.logger.warn(`Bridge ${id} reset: removed ${accessoryInfo}.`);
         }
-        if (await (0, fs_extra_1.pathExists)(identifierCache)) {
-            await (0, fs_extra_1.unlink)(identifierCache);
+        if (await pathExists(identifierCache)) {
+            await unlink(identifierCache);
             this.logger.warn(`Bridge ${id} reset: removed ${identifierCache}.`);
         }
-        if (await (0, fs_extra_1.pathExists)(matterPath)) {
-            await (0, fs_extra_1.remove)(matterPath);
+        if (await pathExists(matterPath)) {
+            await remove(matterPath);
             this.logger.warn(`Bridge ${id} reset: removed Matter bridge storage at ${matterPath}.`);
         }
         await this.deleteDeviceAccessories(id);
@@ -177,7 +150,7 @@ let ServerService = class ServerService {
         setTimeout(() => {
             if (this.configService.ui.restart) {
                 this.logger.log(`Executing restart command ${this.configService.ui.restart}.`);
-                (0, node_child_process_1.exec)(this.configService.ui.restart, (err) => {
+                exec(this.configService.ui.restart, (err) => {
                     if (err) {
                         this.logger.log('Restart command exited with an error, failed to restart Homebridge.');
                     }
@@ -185,7 +158,7 @@ let ServerService = class ServerService {
             }
             else {
                 this.logger.log('Sending SIGTERM to process...');
-                node_process_1.default.kill(node_process_1.default.pid, 'SIGTERM');
+                process.kill(process.pid, 'SIGTERM');
             }
         }, 500);
         return { ok: true, command: this.configService.ui.restart, restartingUI: true };
@@ -205,33 +178,33 @@ let ServerService = class ServerService {
         }
         this.logger.warn(`Homebridge bridge reset: new username ${configFile.bridge.username} and new pin ${configFile.bridge.pin}.`);
         await this.configEditorService.updateConfigFile(configFile);
-        await (0, fs_extra_1.remove)((0, node_path_1.resolve)(this.configService.storagePath, 'accessories'));
-        await (0, fs_extra_1.remove)((0, node_path_1.resolve)(this.configService.storagePath, 'persist'));
+        await remove(resolve(this.configService.storagePath, 'accessories'));
+        await remove(resolve(this.configService.storagePath, 'persist'));
         const deviceId = oldUsername.split(':').join('').toUpperCase();
-        const matterPath = (0, node_path_1.join)(this.configService.storagePath, 'matter', deviceId);
-        if (await (0, fs_extra_1.pathExists)(matterPath)) {
-            await (0, fs_extra_1.remove)(matterPath);
+        const matterPath = join(this.configService.storagePath, 'matter', deviceId);
+        if (await pathExists(matterPath)) {
+            await remove(matterPath);
             this.logger.warn(`Bridge ${oldUsername} reset: removed Matter bridge storage at ${matterPath}.`);
         }
         this.logger.log('Homebridge bridge reset: accessories and persist directories were removed.');
     }
     async getDevicePairings() {
-        const persistPath = (0, node_path_1.join)(this.configService.storagePath, 'persist');
-        const devices = (await (0, fs_extra_1.readdir)(persistPath))
+        const persistPath = join(this.configService.storagePath, 'persist');
+        const devices = (await readdir(persistPath))
             .filter(x => x.match(/AccessoryInfo\.([A-Fa-f0-9]+)\.json$/));
         const configFile = await this.configEditorService.getConfigFile();
         const hapDevices = await Promise.all(devices.map(async (x) => {
             return await this.getDevicePairingById(x.split('.')[1], configFile);
         }));
-        const matterExternalDevices = await this.getMatterExternalAccessories(configFile, hapDevices);
+        const matterExternalDevices = await this.getMatterExternalAccessories(hapDevices);
         return [...hapDevices, ...matterExternalDevices].sort((a, b) => a.name.localeCompare(b.name));
     }
-    async getMatterExternalAccessories(configFile, hapDevices) {
-        const matterPath = (0, node_path_1.join)(this.configService.storagePath, 'matter');
-        if (!await (0, fs_extra_1.pathExists)(matterPath)) {
+    async getMatterExternalAccessories(hapDevices) {
+        const matterPath = join(this.configService.storagePath, 'matter');
+        if (!await pathExists(matterPath)) {
             return [];
         }
-        const matterDirs = (await (0, fs_extra_1.readdir)(matterPath))
+        const matterDirs = (await readdir(matterPath))
             .filter(x => x.match(/^[A-F0-9]{12}$/));
         const matterExternalDevices = [];
         for (const deviceId of matterDirs) {
@@ -244,19 +217,19 @@ let ServerService = class ServerService {
                 if (deviceId.toUpperCase() === mainBridgeId) {
                     continue;
                 }
-                const accessoriesPath = (0, node_path_1.join)(matterPath, deviceId, 'accessories.json');
-                if (!await (0, fs_extra_1.pathExists)(accessoriesPath)) {
+                const accessoriesPath = join(matterPath, deviceId, 'accessories.json');
+                if (!await pathExists(accessoriesPath)) {
                     continue;
                 }
-                const accessories = await (0, fs_extra_1.readJson)(accessoriesPath);
+                const accessories = await readJson(accessoriesPath);
                 if (!Array.isArray(accessories) || accessories.length === 0) {
                     continue;
                 }
                 const accessory = accessories[0];
-                const commissioningPath = (0, node_path_1.join)(matterPath, deviceId, 'commissioning.json');
+                const commissioningPath = join(matterPath, deviceId, 'commissioning.json');
                 let commissioned = false;
-                if (await (0, fs_extra_1.pathExists)(commissioningPath)) {
-                    const commissioningInfo = await (0, fs_extra_1.readJson)(commissioningPath);
+                if (await pathExists(commissioningPath)) {
+                    const commissioningInfo = await readJson(commissioningPath);
                     commissioned = commissioningInfo.commissioned || false;
                 }
                 const device = {
@@ -284,13 +257,13 @@ let ServerService = class ServerService {
         return matterExternalDevices;
     }
     async getDevicePairingById(deviceId, configFile = null) {
-        const persistPath = (0, node_path_1.join)(this.configService.storagePath, 'persist');
+        const persistPath = join(this.configService.storagePath, 'persist');
         let device;
         try {
-            device = await (0, fs_extra_1.readJson)((0, node_path_1.join)(persistPath, `AccessoryInfo.${deviceId}.json`));
+            device = await readJson(join(persistPath, `AccessoryInfo.${deviceId}.json`));
         }
         catch (e) {
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         if (!configFile) {
             configFile = await this.configEditorService.getConfigFile();
@@ -302,7 +275,7 @@ let ServerService = class ServerService {
             .concat([{ _bridge: configFile.bridge }])
             .find((block) => block._bridge?.username?.toUpperCase() === username.toUpperCase());
         try {
-            device._category = Object.entries(hap_types_1.Categories).find(([, value]) => value === device.category)[0].toLowerCase();
+            device._category = Object.entries(Categories).find(([, value]) => value === device.category)[0].toLowerCase();
         }
         catch (e) {
             device._category = 'Other';
@@ -343,7 +316,7 @@ let ServerService = class ServerService {
             const pluginBlock = pluginBlocks.find((block) => block._bridge?.matter);
             if (!pluginBlock) {
                 this.logger.error(`Failed to find Matter configuration for child bridge ${id}.`);
-                throw new common_1.NotFoundException(`Matter configuration not found for bridge ${id}`);
+                throw new NotFoundException(`Matter configuration not found for bridge ${id}`);
             }
             if ('accessory' in pluginBlock) {
                 this.logger.warn(`Removing Matter configuration from accessory-based plugin block for bridge ${id}. Matter is only supported for platform-based plugins.`);
@@ -353,18 +326,18 @@ let ServerService = class ServerService {
             await this.configEditorService.updateConfigFile(configFile);
         }
         catch (e) {
-            if (e instanceof common_1.NotFoundException) {
+            if (e instanceof NotFoundException) {
                 throw e;
             }
             this.logger.error(`Failed to remove Matter configuration for child bridge ${id} as ${e.message}.`);
-            throw new common_1.InternalServerErrorException(`Failed to remove Matter configuration: ${e.message}`);
+            throw new InternalServerErrorException(`Failed to remove Matter configuration: ${e.message}`);
         }
         this.logger.warn(`Shutting down Homebridge before removing Matter storage for bridge ${id}...`);
         await this.homebridgeIpcService.restartAndWaitForClose();
         const deviceId = id.includes(':') ? id.split(':').join('').toUpperCase() : id.toUpperCase();
-        const matterPath = (0, node_path_1.join)(this.configService.storagePath, 'matter', deviceId);
-        if (await (0, fs_extra_1.pathExists)(matterPath)) {
-            await (0, fs_extra_1.remove)(matterPath);
+        const matterPath = join(this.configService.storagePath, 'matter', deviceId);
+        if (await pathExists(matterPath)) {
+            await remove(matterPath);
             this.logger.warn(`Bridge ${id} Matter storage removed at ${matterPath}.`);
         }
         return { ok: true };
@@ -385,13 +358,13 @@ let ServerService = class ServerService {
     async deleteDeviceAccessories(id) {
         this.logger.warn(`Shutting down Homebridge before removing accessories for paired bridge ${id}...`);
         await this.homebridgeIpcService.restartAndWaitForClose();
-        const cachedAccessoriesDir = (0, node_path_1.join)(this.configService.storagePath, 'accessories');
+        const cachedAccessoriesDir = join(this.configService.storagePath, 'accessories');
         await this.deleteSingleDeviceAccessories(id, cachedAccessoriesDir);
     }
     async deleteDevicesAccessories(bridges) {
         this.logger.warn(`Shutting down Homebridge before removing accessories for paired bridges ${bridges.map(x => x.id).join(', ')}...`);
         await this.homebridgeIpcService.restartAndWaitForClose();
-        const cachedAccessoriesDir = (0, node_path_1.join)(this.configService.storagePath, 'accessories');
+        const cachedAccessoriesDir = join(this.configService.storagePath, 'accessories');
         for (const { id, protocol } of bridges) {
             try {
                 await this.deleteSingleDeviceAccessories(id, cachedAccessoriesDir, protocol || 'both');
@@ -402,12 +375,12 @@ let ServerService = class ServerService {
         }
     }
     async getCachedAccessories() {
-        const cachedAccessoriesDir = (0, node_path_1.join)(this.configService.storagePath, 'accessories');
-        const cachedAccessoryFiles = (await (0, fs_extra_1.readdir)(cachedAccessoriesDir))
+        const cachedAccessoriesDir = join(this.configService.storagePath, 'accessories');
+        const cachedAccessoryFiles = (await readdir(cachedAccessoriesDir))
             .filter(x => x.match(/^cachedAccessories\.([A-F,0-9]+)$/) || x === 'cachedAccessories');
         const cachedAccessories = [];
         await Promise.all(cachedAccessoryFiles.map(async (x) => {
-            const accessories = await (0, fs_extra_1.readJson)((0, node_path_1.join)(cachedAccessoriesDir, x));
+            const accessories = await readJson(join(cachedAccessoriesDir, x));
             for (const accessory of accessories) {
                 accessory.$cacheFile = x;
                 cachedAccessories.push(accessory);
@@ -417,19 +390,19 @@ let ServerService = class ServerService {
     }
     async deleteCachedAccessory(uuid, cacheFile) {
         cacheFile = cacheFile || 'cachedAccessories';
-        const cachedAccessoriesPath = (0, node_path_1.resolve)(this.configService.storagePath, 'accessories', cacheFile);
+        const cachedAccessoriesPath = resolve(this.configService.storagePath, 'accessories', cacheFile);
         this.logger.warn(`Shutting down Homebridge before removing cached accessory ${uuid}...`);
         await this.homebridgeIpcService.restartAndWaitForClose();
-        const cachedAccessories = await (0, fs_extra_1.readJson)(cachedAccessoriesPath);
+        const cachedAccessories = await readJson(cachedAccessoriesPath);
         const accessoryIndex = cachedAccessories.findIndex(x => x.UUID === uuid);
         if (accessoryIndex > -1) {
             cachedAccessories.splice(accessoryIndex, 1);
-            await (0, fs_extra_1.writeJson)(cachedAccessoriesPath, cachedAccessories);
+            await writeJson(cachedAccessoriesPath, cachedAccessories);
             this.logger.warn(`Removed cached accessory with UUID ${uuid} from file ${cacheFile}.`);
         }
         else {
             this.logger.error(`Cannot find cached accessory with UUID ${uuid} from file ${cacheFile}.`);
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         return { ok: true };
     }
@@ -445,8 +418,8 @@ let ServerService = class ServerService {
             accessoriesByCacheFile.get(accessoryCacheFile).push({ uuid });
         }
         for (const [cacheFile, accessories] of accessoriesByCacheFile.entries()) {
-            const cachedAccessoriesPath = (0, node_path_1.resolve)(this.configService.storagePath, 'accessories', cacheFile);
-            const cachedAccessories = await (0, fs_extra_1.readJson)(cachedAccessoriesPath);
+            const cachedAccessoriesPath = resolve(this.configService.storagePath, 'accessories', cacheFile);
+            const cachedAccessories = await readJson(cachedAccessoriesPath);
             for (const { uuid } of accessories) {
                 try {
                     const accessoryIndex = cachedAccessories.findIndex(x => x.UUID === uuid);
@@ -462,53 +435,53 @@ let ServerService = class ServerService {
                     this.logger.error(`Failed to remove cached accessory with UUID ${uuid} from file ${cacheFile} as ${e.message}.`);
                 }
             }
-            await (0, fs_extra_1.writeJson)(cachedAccessoriesPath, cachedAccessories);
+            await writeJson(cachedAccessoriesPath, cachedAccessories);
         }
         return { ok: true };
     }
     async deleteAllCachedAccessories() {
-        const cachedAccessoriesDir = (0, node_path_1.join)(this.configService.storagePath, 'accessories');
-        const cachedAccessoryPaths = (await (0, fs_extra_1.readdir)(cachedAccessoriesDir))
+        const cachedAccessoriesDir = join(this.configService.storagePath, 'accessories');
+        const cachedAccessoryPaths = (await readdir(cachedAccessoriesDir))
             .filter(x => x.match(/cachedAccessories\.([A-F,0-9]+)/) || x === 'cachedAccessories' || x === '.cachedAccessories.bak')
-            .map(x => (0, node_path_1.resolve)(cachedAccessoriesDir, x));
-        const cachedAccessoriesPath = (0, node_path_1.resolve)(this.configService.storagePath, 'accessories', 'cachedAccessories');
+            .map(x => resolve(cachedAccessoriesDir, x));
+        const cachedAccessoriesPath = resolve(this.configService.storagePath, 'accessories', 'cachedAccessories');
         await this.homebridgeIpcService.restartAndWaitForClose();
         this.logger.warn('Shutting down Homebridge before removing cached accessories');
         try {
             this.logger.log('Clearing all HAP cached accessories...');
             for (const thisCachedAccessoriesPath of cachedAccessoryPaths) {
-                if (await (0, fs_extra_1.pathExists)(thisCachedAccessoriesPath)) {
-                    await (0, fs_extra_1.unlink)(thisCachedAccessoriesPath);
+                if (await pathExists(thisCachedAccessoriesPath)) {
+                    await unlink(thisCachedAccessoriesPath);
                     this.logger.warn(`Removed ${thisCachedAccessoriesPath}.`);
                 }
             }
-            const matterDir = (0, node_path_1.join)(this.configService.storagePath, 'matter');
-            if (await (0, fs_extra_1.pathExists)(matterDir)) {
+            const matterDir = join(this.configService.storagePath, 'matter');
+            if (await pathExists(matterDir)) {
                 this.logger.log('Clearing all Matter cached accessories...');
-                await (0, fs_extra_1.remove)(matterDir);
+                await remove(matterDir);
                 this.logger.warn(`Removed Matter storage directory at ${matterDir}.`);
             }
         }
         catch (e) {
             this.logger.error(`Failed to clear all cached accessories at ${cachedAccessoriesPath} as ${e.message}.`);
             console.error(e);
-            throw new common_1.InternalServerErrorException('Failed to clear Homebridge accessory cache - see logs.');
+            throw new InternalServerErrorException('Failed to clear Homebridge accessory cache - see logs.');
         }
         return { ok: true };
     }
     async getMatterAccessories() {
-        const matterDir = (0, node_path_1.join)(this.configService.storagePath, 'matter');
-        if (!await (0, fs_extra_1.pathExists)(matterDir)) {
+        const matterDir = join(this.configService.storagePath, 'matter');
+        if (!await pathExists(matterDir)) {
             return [];
         }
-        const matterBridges = (await (0, fs_extra_1.readdir)(matterDir))
+        const matterBridges = (await readdir(matterDir))
             .filter(x => x.match(/^[A-F0-9]+$/));
         const matterAccessories = [];
         await Promise.all(matterBridges.map(async (deviceId) => {
             try {
-                const accessoriesPath = (0, node_path_1.join)(matterDir, deviceId, 'accessories.json');
-                if (await (0, fs_extra_1.pathExists)(accessoriesPath)) {
-                    const accessories = await (0, fs_extra_1.readJson)(accessoriesPath);
+                const accessoriesPath = join(matterDir, deviceId, 'accessories.json');
+                if (await pathExists(accessoriesPath)) {
+                    const accessories = await readJson(accessoriesPath);
                     if (Array.isArray(accessories)) {
                         for (const accessory of accessories) {
                             accessory.$deviceId = deviceId;
@@ -525,23 +498,23 @@ let ServerService = class ServerService {
         return matterAccessories;
     }
     async deleteMatterAccessory(deviceId, uuid) {
-        const matterAccessoriesPath = (0, node_path_1.join)(this.configService.storagePath, 'matter', deviceId, 'accessories.json');
-        if (!await (0, fs_extra_1.pathExists)(matterAccessoriesPath)) {
+        const matterAccessoriesPath = join(this.configService.storagePath, 'matter', deviceId, 'accessories.json');
+        if (!await pathExists(matterAccessoriesPath)) {
             this.logger.error(`Matter accessories file not found for bridge ${deviceId}`);
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         this.logger.warn(`Shutting down Homebridge before removing Matter accessory ${uuid} from bridge ${deviceId}...`);
         await this.homebridgeIpcService.restartAndWaitForClose();
-        const matterAccessories = await (0, fs_extra_1.readJson)(matterAccessoriesPath);
+        const matterAccessories = await readJson(matterAccessoriesPath);
         const accessoryIndex = matterAccessories.findIndex(x => x.uuid === uuid);
         if (accessoryIndex > -1) {
             matterAccessories.splice(accessoryIndex, 1);
-            await (0, fs_extra_1.writeJson)(matterAccessoriesPath, matterAccessories, { spaces: 2 });
+            await writeJson(matterAccessoriesPath, matterAccessories, { spaces: 2 });
             this.logger.warn(`Removed Matter accessory with UUID ${uuid} from bridge ${deviceId}.`);
         }
         else {
             this.logger.error(`Cannot find Matter accessory with UUID ${uuid} in bridge ${deviceId}.`);
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         return { ok: true };
     }
@@ -556,13 +529,13 @@ let ServerService = class ServerService {
             accessoriesByBridge.get(deviceId).push({ uuid });
         }
         for (const [deviceId, bridgeAccessories] of accessoriesByBridge.entries()) {
-            const matterAccessoriesPath = (0, node_path_1.join)(this.configService.storagePath, 'matter', deviceId, 'accessories.json');
+            const matterAccessoriesPath = join(this.configService.storagePath, 'matter', deviceId, 'accessories.json');
             try {
-                if (!await (0, fs_extra_1.pathExists)(matterAccessoriesPath)) {
+                if (!await pathExists(matterAccessoriesPath)) {
                     this.logger.error(`Matter accessories file not found for bridge ${deviceId}`);
                     continue;
                 }
-                const matterAccessories = await (0, fs_extra_1.readJson)(matterAccessoriesPath);
+                const matterAccessories = await readJson(matterAccessoriesPath);
                 for (const { uuid } of bridgeAccessories) {
                     try {
                         const accessoryIndex = matterAccessories.findIndex(x => x.uuid === uuid);
@@ -578,7 +551,7 @@ let ServerService = class ServerService {
                         this.logger.error(`Failed to remove Matter accessory with UUID ${uuid} from bridge ${deviceId} as ${e.message}.`);
                     }
                 }
-                await (0, fs_extra_1.writeJson)(matterAccessoriesPath, matterAccessories, { spaces: 2 });
+                await writeJson(matterAccessoriesPath, matterAccessories, { spaces: 2 });
             }
             catch (e) {
                 this.logger.error(`Failed to process Matter accessories for bridge ${deviceId} as ${e.message}.`);
@@ -591,16 +564,16 @@ let ServerService = class ServerService {
             return this.setupCode;
         }
         else {
-            if (!await (0, fs_extra_1.pathExists)(this.accessoryInfoPath)) {
+            if (!await pathExists(this.accessoryInfoPath)) {
                 return null;
             }
-            const accessoryInfo = await (0, fs_extra_1.readJson)(this.accessoryInfoPath);
+            const accessoryInfo = await readJson(this.accessoryInfoPath);
             this.setupCode = this.generateSetupCode(accessoryInfo);
             return this.setupCode;
         }
     }
     generateSetupCode(accessoryInfo) {
-        const buffer = node_buffer_1.Buffer.allocUnsafe(8);
+        const buffer = Buffer.allocUnsafe(8);
         let valueLow = Number.parseInt(accessoryInfo.pincode.replace(/-/g, ''), 10);
         const valueHigh = accessoryInfo.category >> 1;
         valueLow |= 1 << 28;
@@ -618,10 +591,10 @@ let ServerService = class ServerService {
         return `X-HM://${encodedPayload}${accessoryInfo.setupID}`;
     }
     async getBridgePairingInformation() {
-        if (!await (0, fs_extra_1.pathExists)(this.accessoryInfoPath)) {
-            return new common_1.ServiceUnavailableException('Pairing Information Not Available Yet');
+        if (!await pathExists(this.accessoryInfoPath)) {
+            return new ServiceUnavailableException('Pairing Information Not Available Yet');
         }
-        const accessoryInfo = await (0, fs_extra_1.readJson)(this.accessoryInfoPath);
+        const accessoryInfo = await readJson(this.accessoryInfoPath);
         return {
             displayName: accessoryInfo.displayName,
             pincode: accessoryInfo.pincode,
@@ -631,7 +604,7 @@ let ServerService = class ServerService {
     }
     async getSystemNetworkInterfaces() {
         const fromCache = this.serverServiceCache.get('network-interfaces');
-        const interfaces = fromCache || (await (0, systeminformation_1.networkInterfaces)()).filter((adapter) => {
+        const interfaces = fromCache || (await networkInterfaces()).filter((adapter) => {
             return !adapter.internal
                 && (adapter.ip4 || (adapter.ip6));
         });
@@ -685,7 +658,7 @@ let ServerService = class ServerService {
         const max = this.configService.homebridgeConfig.ports?.end ?? 60000;
         const randomPort = () => Math.floor(Math.random() * (max - min + 1) + min);
         let port = randomPort();
-        while (await (0, tcp_port_used_1.check)(port)) {
+        while (await tcpCheck(port)) {
             port = randomPort();
         }
         return { port };
@@ -708,11 +681,11 @@ let ServerService = class ServerService {
             }
         }
         for (let port = min; port <= max; port += 1) {
-            if (!usedMatterPorts.has(port) && !await (0, tcp_port_used_1.check)(port)) {
+            if (!usedMatterPorts.has(port) && !await tcpCheck(port)) {
                 return { port };
             }
         }
-        throw new common_1.InternalServerErrorException('No available ports in the Matter port range (5530-5541)');
+        throw new InternalServerErrorException('No available ports in the Matter port range (5530-5541)');
     }
     async getHomebridgePort() {
         const config = await this.configEditorService.getConfigFile();
@@ -734,7 +707,7 @@ let ServerService = class ServerService {
     }
     async setHomebridgeName(name) {
         if (!name || !(/^[\p{L}\p{N}][\p{L}\p{N} ']*[\p{L}\p{N}]$/u).test(name)) {
-            throw new common_1.BadRequestException('Invalid name');
+            throw new BadRequestException('Invalid name');
         }
         const config = await this.configEditorService.getConfigFile();
         config.bridge.name = name;
@@ -742,7 +715,7 @@ let ServerService = class ServerService {
     }
     async setHomebridgePort(port) {
         if (!port || typeof port !== 'number' || !Number.isInteger(port) || port < 1025 || port > 65533) {
-            throw new common_1.BadRequestException('Invalid port number');
+            throw new BadRequestException('Invalid port number');
         }
         const config = await this.configEditorService.getConfigFile();
         config.bridge.port = port;
@@ -757,19 +730,19 @@ let ServerService = class ServerService {
             delete value.end;
         }
         if ('start' in value && (typeof value.start !== 'number' || value.start < 1025 || value.start > 65533)) {
-            throw new common_1.BadRequestException('Port start must be a number between 1025 and 65533.');
+            throw new BadRequestException('Port start must be a number between 1025 and 65533.');
         }
         if ('end' in value && (typeof value.end !== 'number' || value.end < 1025 || value.end > 65533)) {
-            throw new common_1.BadRequestException('Port end must be a number between 1025 and 65533.');
+            throw new BadRequestException('Port end must be a number between 1025 and 65533.');
         }
         if ('start' in value && 'end' in value && value.start >= value.end) {
-            throw new common_1.BadRequestException('Ports start must be less than end.');
+            throw new BadRequestException('Ports start must be less than end.');
         }
         if ('start' in value && !('end' in value) && config.ports?.end && value.start >= config.ports.end) {
-            throw new common_1.BadRequestException('Ports start must be less than end.');
+            throw new BadRequestException('Ports start must be less than end.');
         }
         if ('end' in value && !('start' in value) && config.ports?.start && config.ports.start >= value.end) {
-            throw new common_1.BadRequestException('Ports start must be less than end.');
+            throw new BadRequestException('Ports start must be less than end.');
         }
         if (!value.start && !value.end) {
             delete config.ports;
@@ -792,10 +765,10 @@ let ServerService = class ServerService {
         const uiConfigBlock = configFile.platforms.find(x => x.platform === 'config');
         if (uiConfigBlock) {
             if (uiConfigBlock.wallpaper) {
-                const oldPath = (0, node_path_1.join)(this.configService.storagePath, uiConfigBlock.wallpaper);
-                if (await (0, fs_extra_1.pathExists)(oldPath)) {
+                const oldPath = join(this.configService.storagePath, uiConfigBlock.wallpaper);
+                if (await pathExists(oldPath)) {
                     try {
-                        await (0, fs_extra_1.unlink)(oldPath);
+                        await unlink(oldPath);
                         this.logger.log(`Old wallpaper file ${oldPath} deleted successfully.`);
                     }
                     catch (e) {
@@ -803,9 +776,9 @@ let ServerService = class ServerService {
                     }
                 }
             }
-            const fileExtension = (0, node_path_1.extname)(data.filename);
-            const newPath = (0, node_path_1.join)(this.configService.storagePath, `ui-wallpaper${fileExtension}`);
-            await pump(data.file, (0, fs_extra_1.createWriteStream)(newPath));
+            const fileExtension = extname(data.filename);
+            const newPath = join(this.configService.storagePath, `ui-wallpaper${fileExtension}`);
+            await pump(data.file, createWriteStream(newPath));
             uiConfigBlock.wallpaper = `ui-wallpaper${fileExtension}`;
             await this.configEditorService.updateConfigFile(configFile);
             this.logger.log('Wallpaper uploaded and set in the config file.');
@@ -814,11 +787,11 @@ let ServerService = class ServerService {
     async deleteWallpaper() {
         const configFile = await this.configEditorService.getConfigFile();
         const uiConfigBlock = configFile.platforms.find(x => x.platform === 'config');
-        const fullPath = (0, node_path_1.join)(this.configService.storagePath, uiConfigBlock.wallpaper);
+        const fullPath = join(this.configService.storagePath, uiConfigBlock.wallpaper);
         if (uiConfigBlock && uiConfigBlock.wallpaper) {
-            if (await (0, fs_extra_1.pathExists)(fullPath)) {
+            if (await pathExists(fullPath)) {
                 try {
-                    await (0, fs_extra_1.unlink)(fullPath);
+                    await unlink(fullPath);
                     this.logger.log(`Wallpaper file ${uiConfigBlock.wallpaper} deleted successfully.`);
                 }
                 catch (e) {
@@ -834,9 +807,9 @@ let ServerService = class ServerService {
     async nodeVersionChanged() {
         return new Promise((res) => {
             let result = false;
-            const child = (0, node_child_process_1.spawn)(node_process_1.default.execPath, ['-v']);
+            const child = spawn(process.execPath, ['-v']);
             child.stdout.once('data', (data) => {
-                result = data.toString().trim() !== node_process_1.default.version;
+                result = data.toString().trim() !== process.version;
             });
             child.on('error', () => {
                 result = true;
@@ -863,22 +836,22 @@ let ServerService = class ServerService {
             }
         }
         if (!files.length) {
-            throw new common_1.BadRequestException('No files uploaded. Please upload both the private key and certificate files.');
+            throw new BadRequestException('No files uploaded. Please upload both the private key and certificate files.');
         }
         const readStreamToBuffer = async (stream) => {
             const chunks = [];
             await new Promise((resolvePromise, rejectPromise) => {
-                stream.on('data', (d) => chunks.push(node_buffer_1.Buffer.isBuffer(d) ? d : node_buffer_1.Buffer.from(d)));
+                stream.on('data', (d) => chunks.push(Buffer.isBuffer(d) ? d : Buffer.from(d)));
                 stream.on('end', () => resolvePromise());
                 stream.on('error', rejectPromise);
             });
-            return node_buffer_1.Buffer.concat(chunks);
+            return Buffer.concat(chunks);
         };
         let keyPem = null;
         let certPem = null;
         for (const f of files) {
             if (f.file?.truncated) {
-                throw new common_1.InternalServerErrorException(`Upload exceeds maximum size ${globalThis.backup.maxBackupSizeText}.`);
+                throw new InternalServerErrorException(`Upload exceeds maximum size ${globalThis.backup.maxBackupSizeText}.`);
             }
             const buf = await readStreamToBuffer(f.file);
             const text = buf.toString('utf8');
@@ -896,35 +869,35 @@ let ServerService = class ServerService {
             }
         }
         if (!keyPem || !certPem) {
-            throw new common_1.BadRequestException('Both a PEM private key and certificate must be provided.');
+            throw new BadRequestException('Both a PEM private key and certificate must be provided.');
         }
         try {
-            const x509 = new node_crypto_1.X509Certificate(certPem);
+            const x509 = new X509Certificate(certPem);
             const certPub = x509.publicKey.export({ type: 'spki', format: 'der' });
-            const priv = (0, node_crypto_1.createPrivateKey)({ key: keyPem });
-            const pubFromPriv = (0, node_crypto_1.createPublicKey)(priv).export({ type: 'spki', format: 'der' });
+            const priv = createPrivateKey({ key: keyPem });
+            const pubFromPriv = createPublicKey(priv).export({ type: 'spki', format: 'der' });
             if (!certPub.equals(pubFromPriv)) {
-                throw new common_1.BadRequestException('The private key does not match the certificate public key.');
+                throw new BadRequestException('The private key does not match the certificate public key.');
             }
-            (0, node_tls_1.createSecureContext)({ key: keyPem, cert: certPem });
+            createSecureContext({ key: keyPem, cert: certPem });
         }
         catch (e) {
-            if (e instanceof common_1.BadRequestException) {
+            if (e instanceof BadRequestException) {
                 throw e;
             }
-            throw new common_1.BadRequestException(`Invalid key/certificate: ${e?.message || e}`);
+            throw new BadRequestException(`Invalid key/certificate: ${e?.message || e}`);
         }
-        const sslDir = (0, node_path_1.join)(this.configService.storagePath, 'ssl-certs');
-        const keyPath = (0, node_path_1.join)(sslDir, 'ui-ssl.key');
-        const certPath = (0, node_path_1.join)(sslDir, 'ui-ssl.crt');
-        const { ensureDir, writeFile } = await Promise.resolve().then(() => __importStar(require('fs-extra')));
+        const sslDir = join(this.configService.storagePath, 'ssl-certs');
+        const keyPath = join(sslDir, 'ui-ssl.key');
+        const certPath = join(sslDir, 'ui-ssl.crt');
+        const { ensureDir, writeFile } = await import('fs-extra');
         await ensureDir(sslDir);
         await writeFile(keyPath, keyPem);
         await writeFile(certPath, certPem);
         const configFile = await this.configEditorService.getConfigFile();
         const uiConfigBlock = configFile.platforms.find((x) => x.platform === 'config');
         if (!uiConfigBlock) {
-            throw new common_1.InternalServerErrorException('Config platform block not found.');
+            throw new InternalServerErrorException('Config platform block not found.');
         }
         if (!uiConfigBlock.ssl) {
             uiConfigBlock.ssl = {};
@@ -963,36 +936,36 @@ let ServerService = class ServerService {
             passphrase = req.body?.passphrase;
         }
         if (!filePart) {
-            throw new common_1.BadRequestException('No PFX file uploaded.');
+            throw new BadRequestException('No PFX file uploaded.');
         }
         if (filePart.file?.truncated) {
-            throw new common_1.InternalServerErrorException(`Upload exceeds maximum size ${globalThis.backup.maxBackupSizeText}.`);
+            throw new InternalServerErrorException(`Upload exceeds maximum size ${globalThis.backup.maxBackupSizeText}.`);
         }
         const readStreamToBuffer = async (stream) => {
             const chunks = [];
             await new Promise((resolvePromise, rejectPromise) => {
-                stream.on('data', (d) => chunks.push(node_buffer_1.Buffer.isBuffer(d) ? d : node_buffer_1.Buffer.from(d)));
+                stream.on('data', (d) => chunks.push(Buffer.isBuffer(d) ? d : Buffer.from(d)));
                 stream.on('end', () => resolvePromise());
                 stream.on('error', rejectPromise);
             });
-            return node_buffer_1.Buffer.concat(chunks);
+            return Buffer.concat(chunks);
         };
         const pfxBuffer = await readStreamToBuffer(filePart.file);
         try {
-            (0, node_tls_1.createSecureContext)({ pfx: pfxBuffer, passphrase });
+            createSecureContext({ pfx: pfxBuffer, passphrase });
         }
         catch (e) {
-            throw new common_1.BadRequestException(`Invalid PFX or passphrase: ${e?.message || e}`);
+            throw new BadRequestException(`Invalid PFX or passphrase: ${e?.message || e}`);
         }
-        const sslDir = (0, node_path_1.join)(this.configService.storagePath, 'ssl-certs');
-        const pfxPath = (0, node_path_1.join)(sslDir, 'ui-ssl.pfx');
-        const { ensureDir, writeFile } = await Promise.resolve().then(() => __importStar(require('fs-extra')));
+        const sslDir = join(this.configService.storagePath, 'ssl-certs');
+        const pfxPath = join(sslDir, 'ui-ssl.pfx');
+        const { ensureDir, writeFile } = await import('fs-extra');
         await ensureDir(sslDir);
         await writeFile(pfxPath, pfxBuffer);
         const configFile = await this.configEditorService.getConfigFile();
         const uiConfigBlock = configFile.platforms.find((x) => x.platform === 'config');
         if (!uiConfigBlock) {
-            throw new common_1.InternalServerErrorException('Config platform block not found.');
+            throw new InternalServerErrorException('Config platform block not found.');
         }
         if (!uiConfigBlock.ssl) {
             uiConfigBlock.ssl = {};
@@ -1022,23 +995,23 @@ let ServerService = class ServerService {
         }
         try {
             if (ssl.key && ssl.cert) {
-                const { readFile } = await Promise.resolve().then(() => __importStar(require('fs-extra')));
+                const { readFile } = await import('fs-extra');
                 const keyPem = await readFile(ssl.key);
                 const certPem = await readFile(ssl.cert);
-                const x509 = new node_crypto_1.X509Certificate(certPem);
+                const x509 = new X509Certificate(certPem);
                 const certPub = x509.publicKey.export({ type: 'spki', format: 'der' });
-                const priv = (0, node_crypto_1.createPrivateKey)({ key: keyPem });
-                const pubFromPriv = (0, node_crypto_1.createPublicKey)(priv).export({ type: 'spki', format: 'der' });
+                const priv = createPrivateKey({ key: keyPem });
+                const pubFromPriv = createPublicKey(priv).export({ type: 'spki', format: 'der' });
                 if (!certPub.equals(pubFromPriv)) {
                     return { ok: true, valid: false, type: 'keycert', details: 'Private key does not match certificate.' };
                 }
-                (0, node_tls_1.createSecureContext)({ key: keyPem, cert: certPem });
+                createSecureContext({ key: keyPem, cert: certPem });
                 return { ok: true, valid: true, type: 'keycert', details: 'Key and certificate are valid and match.' };
             }
             if (ssl.pfx) {
-                const { readFile } = await Promise.resolve().then(() => __importStar(require('fs-extra')));
+                const { readFile } = await import('fs-extra');
                 const pfx = await readFile(ssl.pfx);
-                (0, node_tls_1.createSecureContext)({ pfx, passphrase: ssl.passphrase });
+                createSecureContext({ pfx, passphrase: ssl.passphrase });
                 return { ok: true, valid: true, type: 'pfx', details: 'PFX file and passphrase are valid.' };
             }
         }
@@ -1052,11 +1025,11 @@ let ServerService = class ServerService {
             ? options.hostnames.map(h => String(h).trim()).filter(Boolean)
             : ['localhost', '127.0.0.1'];
         const mode = options.mode || 'keycert';
-        const generator = new ssl_cert_generator_service_1.SslCertGeneratorService();
+        const generator = new SslCertGeneratorService();
         await generator.generateCertificate(hostnames);
-        const sslDir = (0, node_path_1.join)(this.configService.storagePath, 'ssl-certs');
-        const keyPath = (0, node_path_1.join)(sslDir, 'private-key.pem');
-        const certPath = (0, node_path_1.join)(sslDir, 'certificate.pem');
+        const sslDir = join(this.configService.storagePath, 'ssl-certs');
+        const keyPath = join(sslDir, 'private-key.pem');
+        const certPath = join(sslDir, 'certificate.pem');
         const configFile = await this.configEditorService.getConfigFile();
         const uiConfigBlock = configFile.platforms.find((x) => x.platform === 'config');
         if (!uiConfigBlock.ssl) {
@@ -1089,13 +1062,18 @@ let ServerService = class ServerService {
         };
     }
 };
-exports.ServerService = ServerService;
-exports.ServerService = ServerService = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [config_service_1.ConfigService,
-        config_editor_service_1.ConfigEditorService,
-        accessories_service_1.AccessoriesService,
-        homebridge_ipc_service_1.HomebridgeIpcService,
-        logger_service_1.Logger])
+ServerService = __decorate([
+    Injectable(),
+    __param(0, Inject(ConfigService)),
+    __param(1, Inject(ConfigEditorService)),
+    __param(2, Inject(AccessoriesService)),
+    __param(3, Inject(HomebridgeIpcService)),
+    __param(4, Inject(Logger)),
+    __metadata("design:paramtypes", [ConfigService,
+        ConfigEditorService,
+        AccessoriesService,
+        HomebridgeIpcService,
+        Logger])
 ], ServerService);
+export { ServerService };
 //# sourceMappingURL=server.service.js.map