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

package/dist/modules/server/server.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,70 +7,80 @@ 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); }
 };
-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_path_1 = require("node:path");
-const node_process_1 = __importDefault(require("node:process"));
-const node_stream_1 = require("node:stream");
-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 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();
@@ -116,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);
@@ -141,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.');
                     }
@@ -149,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 };
@@ -169,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) {
@@ -208,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 = {
@@ -248,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();
@@ -266,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';
@@ -307,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.`);
@@ -317,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 };
@@ -349,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');
@@ -366,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);
@@ -381,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 };
     }
@@ -409,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);
@@ -426,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;
@@ -489,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 };
     }
@@ -520,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);
@@ -542,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}.`);
@@ -555,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;
@@ -582,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,
@@ -595,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));
         });
@@ -649,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 };
@@ -672,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();
@@ -698,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;
@@ -706,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;
@@ -721,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;
@@ -756,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) {
@@ -767,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.');
@@ -778,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) {
@@ -798,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'], { shell: true });
+            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;
@@ -810,14 +819,261 @@ let ServerService = class ServerService {
             });
         });
     }
+    async uploadSslKeyCert(req) {
+        const parts = req.parts ? req.parts() : null;
+        const files = [];
+        if (parts) {
+            for await (const part of parts) {
+                if (part.file) {
+                    files.push(part);
+                }
+            }
+        }
+        else {
+            const single = await req.file();
+            if (single?.file) {
+                files.push(single);
+            }
+        }
+        if (!files.length) {
+            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(Buffer.isBuffer(d) ? d : Buffer.from(d)));
+                stream.on('end', () => resolvePromise());
+                stream.on('error', rejectPromise);
+            });
+            return Buffer.concat(chunks);
+        };
+        let keyPem = null;
+        let certPem = null;
+        for (const f of files) {
+            if (f.file?.truncated) {
+                throw new InternalServerErrorException(`Upload exceeds maximum size ${globalThis.backup.maxBackupSizeText}.`);
+            }
+            const buf = await readStreamToBuffer(f.file);
+            const text = buf.toString('utf8');
+            if (/-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/.test(text)) {
+                keyPem = buf;
+            }
+            else if (/-----BEGIN CERTIFICATE-----/.test(text)) {
+                certPem = buf;
+            }
+            else if (f.fieldname === 'key') {
+                keyPem = buf;
+            }
+            else if (f.fieldname === 'cert') {
+                certPem = buf;
+            }
+        }
+        if (!keyPem || !certPem) {
+            throw new BadRequestException('Both a PEM private key and certificate must be provided.');
+        }
+        try {
+            const x509 = new X509Certificate(certPem);
+            const certPub = x509.publicKey.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 BadRequestException('The private key does not match the certificate public key.');
+            }
+            createSecureContext({ key: keyPem, cert: certPem });
+        }
+        catch (e) {
+            if (e instanceof BadRequestException) {
+                throw e;
+            }
+            throw new BadRequestException(`Invalid key/certificate: ${e?.message || e}`);
+        }
+        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 InternalServerErrorException('Config platform block not found.');
+        }
+        if (!uiConfigBlock.ssl) {
+            uiConfigBlock.ssl = {};
+        }
+        uiConfigBlock.ssl.key = keyPath;
+        uiConfigBlock.ssl.cert = certPath;
+        delete uiConfigBlock.ssl.pfx;
+        delete uiConfigBlock.ssl.passphrase;
+        uiConfigBlock.ssl.selfSigned = false;
+        await this.configEditorService.updateConfigFile(configFile);
+        return {
+            ok: true,
+            type: 'keycert',
+            keyPath,
+            certPath,
+            details: 'Certificate and key validated and saved.',
+        };
+    }
+    async uploadSslPfx(req) {
+        let passphrase;
+        let filePart;
+        if (req.parts) {
+            for await (const part of req.parts()) {
+                if (part.type === 'file' || part.file) {
+                    filePart = part;
+                }
+                else if (part.type === 'field' || part.value) {
+                    if (part.fieldname === 'passphrase') {
+                        passphrase = part.value;
+                    }
+                }
+            }
+        }
+        else {
+            filePart = await req.file();
+            passphrase = req.body?.passphrase;
+        }
+        if (!filePart) {
+            throw new BadRequestException('No PFX file uploaded.');
+        }
+        if (filePart.file?.truncated) {
+            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(Buffer.isBuffer(d) ? d : Buffer.from(d)));
+                stream.on('end', () => resolvePromise());
+                stream.on('error', rejectPromise);
+            });
+            return Buffer.concat(chunks);
+        };
+        const pfxBuffer = await readStreamToBuffer(filePart.file);
+        try {
+            createSecureContext({ pfx: pfxBuffer, passphrase });
+        }
+        catch (e) {
+            throw new BadRequestException(`Invalid PFX or passphrase: ${e?.message || e}`);
+        }
+        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 InternalServerErrorException('Config platform block not found.');
+        }
+        if (!uiConfigBlock.ssl) {
+            uiConfigBlock.ssl = {};
+        }
+        uiConfigBlock.ssl.pfx = pfxPath;
+        uiConfigBlock.ssl.passphrase = passphrase || '';
+        delete uiConfigBlock.ssl.key;
+        delete uiConfigBlock.ssl.cert;
+        uiConfigBlock.ssl.selfSigned = false;
+        await this.configEditorService.updateConfigFile(configFile);
+        return {
+            ok: true,
+            type: 'pfx',
+            pfxPath,
+            details: 'PFX validated and saved.',
+        };
+    }
+    async validateCurrentSslConfig() {
+        const configFile = await this.configEditorService.getConfigFile();
+        const uiConfigBlock = configFile.platforms.find((x) => x.platform === 'config');
+        const ssl = uiConfigBlock?.ssl || {};
+        if (!ssl || (!ssl.selfSigned && !ssl.key && !ssl.cert && !ssl.pfx)) {
+            return { ok: true, valid: true, type: 'off', details: 'HTTPS is disabled.' };
+        }
+        if (ssl.selfSigned) {
+            return { ok: true, valid: true, type: 'selfsigned', details: 'Self-signed mode enabled.' };
+        }
+        try {
+            if (ssl.key && ssl.cert) {
+                const { readFile } = await import('fs-extra');
+                const keyPem = await readFile(ssl.key);
+                const certPem = await readFile(ssl.cert);
+                const x509 = new X509Certificate(certPem);
+                const certPub = x509.publicKey.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.' };
+                }
+                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 import('fs-extra');
+                const pfx = await readFile(ssl.pfx);
+                createSecureContext({ pfx, passphrase: ssl.passphrase });
+                return { ok: true, valid: true, type: 'pfx', details: 'PFX file and passphrase are valid.' };
+            }
+        }
+        catch (e) {
+            return { ok: true, valid: false, type: ssl.pfx ? 'pfx' : 'keycert', details: e?.message || String(e) };
+        }
+        return { ok: true, valid: false, type: 'off', details: 'No SSL configuration found.' };
+    }
+    async generateSelfSignedCertificate(options = {}) {
+        const hostnames = Array.isArray(options.hostnames) && options.hostnames.length
+            ? options.hostnames.map(h => String(h).trim()).filter(Boolean)
+            : ['localhost', '127.0.0.1'];
+        const mode = options.mode || 'keycert';
+        const generator = new SslCertGeneratorService();
+        await generator.generateCertificate(hostnames);
+        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) {
+            uiConfigBlock.ssl = {};
+        }
+        if (mode === 'keycert') {
+            uiConfigBlock.ssl.key = keyPath;
+            uiConfigBlock.ssl.cert = certPath;
+            delete uiConfigBlock.ssl.pfx;
+            delete uiConfigBlock.ssl.passphrase;
+            uiConfigBlock.ssl.selfSigned = false;
+            uiConfigBlock.ssl.selfSignedHostnames = hostnames;
+        }
+        else {
+            delete uiConfigBlock.ssl.key;
+            delete uiConfigBlock.ssl.cert;
+            delete uiConfigBlock.ssl.pfx;
+            delete uiConfigBlock.ssl.passphrase;
+            uiConfigBlock.ssl.selfSigned = true;
+            uiConfigBlock.ssl.selfSignedHostnames = hostnames;
+        }
+        await this.configEditorService.updateConfigFile(configFile);
+        return {
+            ok: true,
+            type: 'generated',
+            mode,
+            keyPath: mode === 'keycert' ? keyPath : undefined,
+            certPath: mode === 'keycert' ? certPath : undefined,
+            details: `Self-signed certificate generated for ${hostnames.join(', ')}`,
+        };
+    }
 };
-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