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

package/dist/modules/backup/backup.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,31 +7,37 @@ 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.BackupService = void 0;
-const node_events_1 = require("node:events");
-const node_os_1 = require("node:os");
-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 common_1 = require("@nestjs/common");
-const bash_color_1 = require("bash-color");
-const dayjs_1 = __importDefault(require("dayjs"));
-const fs_extra_1 = require("fs-extra");
-const systeminformation_1 = require("systeminformation");
-const tar_1 = require("tar");
-const unzipper_1 = require("unzipper");
-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 scheduler_service_1 = require("../../core/scheduler/scheduler.service");
-const plugins_service_1 = require("../plugins/plugins.service");
-const pump = (0, node_util_1.promisify)(node_stream_1.pipeline);
+import { EventEmitter } from 'node:events';
+import { constants, createReadStream, statSync } from 'node:fs';
+import { access, lstat, mkdtemp, readdir, realpath } from 'node:fs/promises';
+import { platform, tmpdir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import process from 'node:process';
+import { pipeline } from 'node:stream';
+import { promisify } from 'node:util';
+import { BadRequestException, Inject, Injectable, InternalServerErrorException, NotFoundException, StreamableFile, } from '@nestjs/common';
+import { cyan, green, red, yellow } from 'bash-color';
+import dayjs from 'dayjs';
+import { copy, ensureDir, pathExists, readJson, remove, writeJson } from 'fs-extra/esm';
+import { networkInterfaces } from 'systeminformation';
+import { create, extract } from 'tar';
+import { Extract } from 'unzipper';
+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 { SchedulerService } from '../../core/scheduler/scheduler.service.js';
+import { PluginsService } from '../plugins/plugins.service.js';
+const pump = promisify(pipeline);
 let BackupService = class BackupService {
+    configService;
+    pluginsService;
+    schedulerService;
+    homebridgeIpcService;
+    logger;
+    restoreDirectory;
     constructor(configService, pluginsService, schedulerService, homebridgeIpcService, logger) {
         this.configService = configService;
         this.pluginsService = pluginsService;
@@ -57,13 +62,13 @@ let BackupService = class BackupService {
     }
     async createBackup() {
         const instanceId = this.configService.homebridgeConfig.bridge.username.replace(/:/g, '');
-        const backupDir = await (0, fs_extra_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'homebridge-backup-'));
+        const backupDir = await mkdtemp(join(tmpdir(), 'homebridge-backup-'));
         const backupFileName = `homebridge-backup-${instanceId}.${new Date().getTime().toString()}.tar.gz`;
-        const backupPath = (0, node_path_1.resolve)(backupDir, backupFileName);
+        const backupPath = resolve(backupDir, backupFileName);
         this.logger.log(`Creating temporary backup archive at ${backupPath}.`);
         try {
-            const storagePath = await (0, fs_extra_1.realpath)(this.configService.storagePath);
-            await (0, fs_extra_1.copy)(storagePath, (0, node_path_1.resolve)(backupDir, 'storage'), {
+            const storagePath = await realpath(this.configService.storagePath);
+            await copy(storagePath, resolve(backupDir, 'storage'), {
                 filter: async (filePath) => {
                     if ([
                         'instance-backups',
@@ -88,11 +93,11 @@ let BackupService = class BackupService {
                         '@eaDir',
                         '.venv',
                         '.cache',
-                    ].includes((0, node_path_1.basename)(filePath))) {
+                    ].includes(basename(filePath))) {
                         return false;
                     }
                     try {
-                        const stat = await (0, fs_extra_1.lstat)(filePath);
+                        const stat = await lstat(filePath);
                         return (stat.isDirectory() || stat.isFile());
                     }
                     catch (e) {
@@ -101,14 +106,14 @@ let BackupService = class BackupService {
                 },
             });
             const installedPlugins = await this.pluginsService.getInstalledPlugins();
-            await (0, fs_extra_1.writeJson)((0, node_path_1.resolve)(backupDir, 'plugins.json'), installedPlugins);
-            await (0, fs_extra_1.writeJson)((0, node_path_1.resolve)(backupDir, 'info.json'), {
+            await writeJson(resolve(backupDir, 'plugins.json'), installedPlugins);
+            await writeJson(resolve(backupDir, 'info.json'), {
                 timestamp: new Date().toISOString(),
-                platform: (0, node_os_1.platform)(),
+                platform: platform(),
                 uix: this.configService.package.version,
-                node: node_process_1.default.version,
+                node: process.version,
             });
-            await (0, tar_1.create)({
+            await create({
                 portable: true,
                 gzip: true,
                 file: backupPath,
@@ -125,13 +130,13 @@ let BackupService = class BackupService {
                 'plugins.json',
                 'info.json',
             ]);
-            if ((0, fs_extra_1.statSync)(backupPath).size > globalThis.backup.maxBackupSize) {
-                this.logger.error(`Backup file exceeds maximum restore file size (${globalThis.backup.maxBackupSizeText}) ${((0, fs_extra_1.statSync)(backupPath).size / (1024 * 1024)).toFixed(1)}MB.`);
+            if (statSync(backupPath).size > globalThis.backup.maxBackupSize) {
+                this.logger.error(`Backup file exceeds maximum restore file size (${globalThis.backup.maxBackupSizeText}) ${(statSync(backupPath).size / (1024 * 1024)).toFixed(1)}MB.`);
             }
         }
         catch (e) {
             this.logger.log(`Backup failed, removing ${backupDir}.`);
-            await (0, fs_extra_1.remove)((0, node_path_1.resolve)(backupDir));
+            await remove(resolve(backupDir));
             throw e;
         }
         return {
@@ -143,18 +148,18 @@ let BackupService = class BackupService {
     }
     async ensureScheduledBackupPath() {
         if (this.configService.ui.scheduledBackupPath) {
-            if (!await (0, fs_extra_1.pathExists)(this.configService.instanceBackupPath)) {
+            if (!await pathExists(this.configService.instanceBackupPath)) {
                 throw new Error('Custom instance backup path does not exist');
             }
             try {
-                await (0, fs_extra_1.access)(this.configService.instanceBackupPath, fs_extra_1.constants.W_OK | fs_extra_1.constants.R_OK);
+                await access(this.configService.instanceBackupPath, constants.W_OK | constants.R_OK);
             }
             catch (e) {
                 throw new Error(`Custom instance backup path is not writable / readable by service: ${e.message}`);
             }
         }
         else {
-            return await (0, fs_extra_1.ensureDir)(this.configService.instanceBackupPath);
+            return await ensureDir(this.configService.instanceBackupPath);
         }
     }
     async runScheduledBackupJob() {
@@ -167,8 +172,8 @@ let BackupService = class BackupService {
         }
         try {
             const { backupDir, backupPath, instanceId } = await this.createBackup();
-            await (0, fs_extra_1.copy)(backupPath, (0, node_path_1.resolve)(this.configService.instanceBackupPath, `homebridge-backup-${instanceId}.${new Date().getTime().toString()}.tar.gz`));
-            await (0, fs_extra_1.remove)((0, node_path_1.resolve)(backupDir));
+            await copy(backupPath, resolve(this.configService.instanceBackupPath, `homebridge-backup-${instanceId}.${new Date().getTime().toString()}.tar.gz`));
+            await remove(resolve(backupDir));
         }
         catch (e) {
             this.logger.warn(`Failed to create scheduled instance backup as ${e.message}.`);
@@ -176,8 +181,8 @@ let BackupService = class BackupService {
         try {
             const backups = await this.listScheduledBackups();
             for (const backup of backups) {
-                if ((0, dayjs_1.default)().diff((0, dayjs_1.default)(backup.timestamp), 'day') >= 7) {
-                    await (0, fs_extra_1.remove)((0, node_path_1.resolve)(this.configService.instanceBackupPath, backup.fileName));
+                if (dayjs().diff(dayjs(backup.timestamp), 'day') >= 7) {
+                    await remove(resolve(this.configService.instanceBackupPath, backup.fileName));
                 }
             }
         }
@@ -200,7 +205,7 @@ let BackupService = class BackupService {
     async listScheduledBackups() {
         try {
             await this.ensureScheduledBackupPath();
-            const dirContents = await (0, fs_extra_1.readdir)(this.configService.instanceBackupPath, { withFileTypes: true });
+            const dirContents = await readdir(this.configService.instanceBackupPath, { withFileTypes: true });
             return dirContents
                 .filter(x => x.isFile() && x.name.match(/^homebridge-backup-[0-9A-Za-z]{12}.\d{09,15}.tar.gz/))
                 .map((x) => {
@@ -212,7 +217,7 @@ let BackupService = class BackupService {
                         instanceId: split[0].split('-')[2],
                         timestamp: new Date(Number.parseInt(split[1], 10)),
                         fileName: x.name,
-                        size: ((0, fs_extra_1.statSync)(`${this.configService.instanceBackupPath}/${x.name}`).size / (1024 * 1024)).toFixed(1),
+                        size: (statSync(`${this.configService.instanceBackupPath}/${x.name}`).size / (1024 * 1024)).toFixed(1),
                         maxBackupSize: globalThis.backup.maxBackupSize / (1024 * 1024),
                         maxBackupSizeText: globalThis.backup.maxBackupSizeText,
                     };
@@ -236,38 +241,38 @@ let BackupService = class BackupService {
         }
         catch (e) {
             this.logger.warn(`Could not get scheduled backups as ${e.message}.`);
-            throw new common_1.InternalServerErrorException(e.message);
+            throw new InternalServerErrorException(e.message);
         }
     }
     async getScheduledBackup(backupId) {
-        const backupPath = (0, node_path_1.resolve)(this.configService.instanceBackupPath, `homebridge-backup-${backupId}.tar.gz`);
-        if (!await (0, fs_extra_1.pathExists)(backupPath)) {
-            throw new common_1.NotFoundException();
+        const backupPath = resolve(this.configService.instanceBackupPath, `homebridge-backup-${backupId}.tar.gz`);
+        if (!await pathExists(backupPath)) {
+            throw new NotFoundException();
         }
-        return new common_1.StreamableFile((0, fs_extra_1.createReadStream)(backupPath));
+        return new StreamableFile(createReadStream(backupPath));
     }
     async deleteScheduledBackup(backupId) {
-        const backupPath = (0, node_path_1.resolve)(this.configService.instanceBackupPath, `homebridge-backup-${backupId}.tar.gz`);
-        if (!await (0, fs_extra_1.pathExists)(backupPath)) {
-            throw new common_1.NotFoundException();
+        const backupPath = resolve(this.configService.instanceBackupPath, `homebridge-backup-${backupId}.tar.gz`);
+        if (!await pathExists(backupPath)) {
+            throw new NotFoundException();
         }
         try {
-            await (0, fs_extra_1.remove)(backupPath);
+            await remove(backupPath);
             this.logger.warn(`Scheduled backup ${backupId} deleted by request.`);
         }
         catch (e) {
             this.logger.warn(`Failed to delete scheduled backup by request as ${e.message}.`);
-            throw new common_1.InternalServerErrorException(e.message);
+            throw new InternalServerErrorException(e.message);
         }
     }
     async restoreScheduledBackup(backupId) {
-        const backupPath = (0, node_path_1.resolve)(this.configService.instanceBackupPath, `homebridge-backup-${backupId}.tar.gz`);
-        if (!await (0, fs_extra_1.pathExists)(backupPath)) {
-            throw new common_1.NotFoundException();
+        const backupPath = resolve(this.configService.instanceBackupPath, `homebridge-backup-${backupId}.tar.gz`);
+        if (!await pathExists(backupPath)) {
+            throw new NotFoundException();
         }
         this.restoreDirectory = undefined;
-        const restoreDir = await (0, fs_extra_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'homebridge-backup-'));
-        await pump((0, fs_extra_1.createReadStream)(backupPath), (0, tar_1.extract)({
+        const restoreDir = await mkdtemp(join(tmpdir(), 'homebridge-backup-'));
+        await pump(createReadStream(backupPath), extract({
             cwd: restoreDir,
         }));
         this.restoreDirectory = restoreDir;
@@ -280,7 +285,7 @@ let BackupService = class BackupService {
         if (reply.request.hostname === 'localhost:8080') {
             reply.raw.setHeader('access-control-allow-origin', 'http://localhost:4200');
         }
-        return new common_1.StreamableFile((0, fs_extra_1.createReadStream)(backupPath).on('close', () => (0, fs_extra_1.remove)((0, node_path_1.resolve)(backupDir))));
+        return new StreamableFile(createReadStream(backupPath).on('close', () => remove(resolve(backupDir))));
     }
     async createBackupInDirectory() {
         try {
@@ -288,36 +293,36 @@ let BackupService = class BackupService {
         }
         catch (error) {
             this.logger.error(`Create backup failed: ${error.message}`);
-            throw new common_1.NotFoundException();
+            throw new NotFoundException();
         }
         try {
             const { backupDir, backupPath, instanceId } = await this.createBackup();
-            await (0, fs_extra_1.copy)(backupPath, (0, node_path_1.resolve)(this.configService.instanceBackupPath, `homebridge-backup-${instanceId}.${new Date().getTime().toString()}.tar.gz`));
-            await (0, fs_extra_1.remove)((0, node_path_1.resolve)(backupDir));
+            await copy(backupPath, resolve(this.configService.instanceBackupPath, `homebridge-backup-${instanceId}.${new Date().getTime().toString()}.tar.gz`));
+            await remove(resolve(backupDir));
         }
         catch (error) {
             this.logger.error(`Create backup failed: ${error.message}`);
-            throw new common_1.InternalServerErrorException(error.message);
+            throw new InternalServerErrorException(error.message);
         }
     }
     async uploadBackupRestore(data) {
         this.restoreDirectory = undefined;
-        const backupDir = await (0, fs_extra_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'homebridge-backup-'));
-        await pump(data.file, (0, tar_1.extract)({
+        const backupDir = await mkdtemp(join(tmpdir(), 'homebridge-backup-'));
+        await pump(data.file, extract({
             cwd: backupDir,
         }));
         this.restoreDirectory = backupDir;
     }
     async removeRestoreDirectory() {
         if (this.restoreDirectory) {
-            return await (0, fs_extra_1.remove)(this.restoreDirectory);
+            return await remove(this.restoreDirectory);
         }
     }
     async triggerHeadlessRestore() {
-        if (!await (0, fs_extra_1.pathExists)(this.restoreDirectory)) {
-            throw new common_1.BadRequestException('No backup file uploaded');
+        if (!await pathExists(this.restoreDirectory)) {
+            throw new BadRequestException('No backup file uploaded');
         }
-        const client = new node_events_1.EventEmitter();
+        const client = new EventEmitter();
         client.on('stdout', (data) => {
             this.logger.log(data);
         });
@@ -329,78 +334,78 @@ let BackupService = class BackupService {
     }
     async restoreFromBackup(client, autoRestart = false) {
         if (!this.restoreDirectory) {
-            throw new common_1.BadRequestException();
+            throw new BadRequestException();
         }
-        if (!await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(this.restoreDirectory, 'info.json'))) {
+        if (!await pathExists(resolve(this.restoreDirectory, 'info.json'))) {
             await this.removeRestoreDirectory();
             throw new Error('Uploaded file is not a valid Homebridge Backup Archive.');
         }
-        if (!await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(this.restoreDirectory, 'plugins.json'))) {
+        if (!await pathExists(resolve(this.restoreDirectory, 'plugins.json'))) {
             await this.removeRestoreDirectory();
             throw new Error('Uploaded file is not a valid Homebridge Backup Archive.');
         }
-        if (!await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(this.restoreDirectory, 'storage'))) {
+        if (!await pathExists(resolve(this.restoreDirectory, 'storage'))) {
             await this.removeRestoreDirectory();
             throw new Error('Uploaded file is not a valid Homebridge Backup Archive.');
         }
-        const backupInfo = await (0, fs_extra_1.readJson)((0, node_path_1.resolve)(this.restoreDirectory, 'info.json'));
-        client.emit('stdout', (0, bash_color_1.cyan)('Backup Archive Information\r\n'));
+        const backupInfo = await readJson(resolve(this.restoreDirectory, 'info.json'));
+        client.emit('stdout', cyan('Backup Archive Information\r\n'));
         client.emit('stdout', `Source Node.js Version: ${backupInfo.node}\r\n`);
         client.emit('stdout', `Source Homebridge UI Version: v${backupInfo.uix}\r\n`);
         client.emit('stdout', `Source Platform: ${backupInfo.platform}\r\n`);
         client.emit('stdout', `Created: ${backupInfo.timestamp}\r\n`);
         this.logger.warn('Starting backup restore...');
-        client.emit('stdout', (0, bash_color_1.cyan)('\r\nRestoring backup...\r\n\r\n'));
+        client.emit('stdout', cyan('\r\nRestoring backup...\r\n\r\n'));
         await new Promise(res => setTimeout(res, 1000));
         const restoreFilter = [
-            (0, node_path_1.join)(this.restoreDirectory, 'storage', 'package.json'),
-            (0, node_path_1.join)(this.restoreDirectory, 'storage', 'package-lock.json'),
-            (0, node_path_1.join)(this.restoreDirectory, 'storage', '.npmrc'),
-            (0, node_path_1.join)(this.restoreDirectory, 'storage', 'docker-compose.yml'),
+            join(this.restoreDirectory, 'storage', 'package.json'),
+            join(this.restoreDirectory, 'storage', 'package-lock.json'),
+            join(this.restoreDirectory, 'storage', '.npmrc'),
+            join(this.restoreDirectory, 'storage', 'docker-compose.yml'),
         ];
-        const storagePath = await (0, fs_extra_1.realpath)(this.configService.storagePath);
-        client.emit('stdout', (0, bash_color_1.yellow)(`Restoring Homebridge storage to ${storagePath}\r\n`));
+        const storagePath = await realpath(this.configService.storagePath);
+        client.emit('stdout', yellow(`Restoring Homebridge storage to ${storagePath}\r\n`));
         await new Promise(res => setTimeout(res, 100));
-        await (0, fs_extra_1.copy)((0, node_path_1.resolve)(this.restoreDirectory, 'storage'), storagePath, {
+        await copy(resolve(this.restoreDirectory, 'storage'), storagePath, {
             filter: async (filePath) => {
                 if (restoreFilter.includes(filePath)) {
-                    client.emit('stdout', `Skipping ${(0, node_path_1.basename)(filePath)}\r\n`);
+                    client.emit('stdout', `Skipping ${basename(filePath)}\r\n`);
                     return false;
                 }
                 try {
-                    const stat = await (0, fs_extra_1.lstat)(filePath);
+                    const stat = await lstat(filePath);
                     if (stat.isDirectory() || stat.isFile()) {
-                        client.emit('stdout', `Restoring ${(0, node_path_1.basename)(filePath)}\r\n`);
+                        client.emit('stdout', `Restoring ${basename(filePath)}\r\n`);
                         return true;
                     }
                     else {
-                        client.emit('stdout', `Skipping ${(0, node_path_1.basename)(filePath)}\r\n`);
+                        client.emit('stdout', `Skipping ${basename(filePath)}\r\n`);
                         return false;
                     }
                 }
                 catch (e) {
-                    client.emit('stdout', `Skipping ${(0, node_path_1.basename)(filePath)}\r\n`);
+                    client.emit('stdout', `Skipping ${basename(filePath)}\r\n`);
                     return false;
                 }
             },
         });
-        client.emit('stdout', (0, bash_color_1.yellow)('File restore complete.\r\n'));
+        client.emit('stdout', yellow('File restore complete.\r\n'));
         await new Promise(res => setTimeout(res, 1000));
-        client.emit('stdout', (0, bash_color_1.cyan)('\r\nRestoring plugins...\r\n'));
-        const plugins = (await (0, fs_extra_1.readJson)((0, node_path_1.resolve)(this.restoreDirectory, 'plugins.json')))
+        client.emit('stdout', cyan('\r\nRestoring plugins...\r\n'));
+        const plugins = (await readJson(resolve(this.restoreDirectory, 'plugins.json')))
             .filter((x) => ![
             'homebridge-config-ui-x',
         ].includes(x.name) && x.publicPackage);
         for (const plugin of plugins) {
             try {
-                client.emit('stdout', (0, bash_color_1.yellow)(`\r\nInstalling ${plugin.name}...\r\n`));
+                client.emit('stdout', yellow(`\r\nInstalling ${plugin.name}...\r\n`));
                 await this.pluginsService.managePlugin('install', { name: plugin.name, version: plugin.installedVersion }, client);
             }
             catch (e) {
-                client.emit('stdout', (0, bash_color_1.red)(`Failed to install ${plugin.name}.\r\n`));
+                client.emit('stdout', red(`Failed to install ${plugin.name}.\r\n`));
             }
         }
-        const restoredConfig = await (0, fs_extra_1.readJson)(this.configService.configPath);
+        const restoredConfig = await readJson(this.configService.configPath);
         if (restoredConfig.bridge) {
             restoredConfig.bridge.port = this.configService.homebridgeConfig.bridge.port;
         }
@@ -421,9 +426,9 @@ let BackupService = class BackupService {
                 platform: 'config',
             });
         }
-        await (0, fs_extra_1.writeJson)(this.configService.configPath, restoredConfig, { spaces: 4 });
+        await writeJson(this.configService.configPath, restoredConfig, { spaces: 4 });
         await this.removeRestoreDirectory();
-        client.emit('stdout', (0, bash_color_1.green)('\r\nRestore Complete!\r\n'));
+        client.emit('stdout', green('\r\nRestore Complete!\r\n'));
         this.configService.hbServiceUiRestartRequired = true;
         if (autoRestart) {
             this.postBackupRestoreRestart();
@@ -432,59 +437,59 @@ let BackupService = class BackupService {
     }
     async uploadHbfxRestore(data) {
         this.restoreDirectory = undefined;
-        const backupDir = await (0, fs_extra_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'homebridge-backup-'));
+        const backupDir = await mkdtemp(join(tmpdir(), 'homebridge-backup-'));
         this.logger.log(`Extracting .hbfx file to ${backupDir}.`);
-        await pump(data.file, (0, unzipper_1.Extract)({
+        await pump(data.file, Extract({
             path: backupDir,
         }));
         this.restoreDirectory = backupDir;
     }
     async restoreHbfxBackup(client) {
         if (!this.restoreDirectory) {
-            throw new common_1.BadRequestException();
+            throw new BadRequestException();
         }
-        if (!await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(this.restoreDirectory, 'package.json'))) {
+        if (!await pathExists(resolve(this.restoreDirectory, 'package.json'))) {
             await this.removeRestoreDirectory();
             throw new Error('Uploaded file is not a valid HBFX Backup Archive.');
         }
-        if (!await (0, fs_extra_1.pathExists)((0, node_path_1.resolve)(this.restoreDirectory, 'etc', 'config.json'))) {
+        if (!await pathExists(resolve(this.restoreDirectory, 'etc', 'config.json'))) {
             await this.removeRestoreDirectory();
             throw new Error('Uploaded file is not a valid HBFX Backup Archive.');
         }
-        const backupInfo = await (0, fs_extra_1.readJson)((0, node_path_1.resolve)(this.restoreDirectory, 'package.json'));
-        client.emit('stdout', (0, bash_color_1.cyan)('Backup Archive Information\r\n'));
+        const backupInfo = await readJson(resolve(this.restoreDirectory, 'package.json'));
+        client.emit('stdout', cyan('Backup Archive Information\r\n'));
         client.emit('stdout', `Backup Source: ${backupInfo.name}\r\n`);
         client.emit('stdout', `Version: v${backupInfo.version}\r\n`);
         this.logger.warn('Starting hbfx restore...');
-        client.emit('stdout', (0, bash_color_1.cyan)('\r\nRestoring hbfx backup...\r\n\r\n'));
+        client.emit('stdout', cyan('\r\nRestoring hbfx backup...\r\n\r\n'));
         await new Promise(res => setTimeout(res, 1000));
-        const storagePath = await (0, fs_extra_1.realpath)(this.configService.storagePath);
-        client.emit('stdout', (0, bash_color_1.yellow)(`Restoring Homebridge storage to ${storagePath}\r\n`));
-        await (0, fs_extra_1.copy)((0, node_path_1.resolve)(this.restoreDirectory, 'etc'), (0, node_path_1.resolve)(storagePath), {
+        const storagePath = await realpath(this.configService.storagePath);
+        client.emit('stdout', yellow(`Restoring Homebridge storage to ${storagePath}\r\n`));
+        await copy(resolve(this.restoreDirectory, 'etc'), resolve(storagePath), {
             filter: (filePath) => {
                 if ([
                     'access.json',
                     'dashboard.json',
                     'layout.json',
                     'config.json',
-                ].includes((0, node_path_1.basename)(filePath))) {
+                ].includes(basename(filePath))) {
                     return false;
                 }
-                client.emit('stdout', `Restoring ${(0, node_path_1.basename)(filePath)}\r\n`);
+                client.emit('stdout', `Restoring ${basename(filePath)}\r\n`);
                 return true;
             },
         });
-        const sourceAccessoriesPath = (0, node_path_1.resolve)(this.restoreDirectory, 'etc', 'accessories');
-        const targetAccessoriesPath = (0, node_path_1.resolve)(storagePath, 'accessories');
-        if (await (0, fs_extra_1.pathExists)(sourceAccessoriesPath)) {
-            await (0, fs_extra_1.copy)(sourceAccessoriesPath, targetAccessoriesPath, {
+        const sourceAccessoriesPath = resolve(this.restoreDirectory, 'etc', 'accessories');
+        const targetAccessoriesPath = resolve(storagePath, 'accessories');
+        if (await pathExists(sourceAccessoriesPath)) {
+            await copy(sourceAccessoriesPath, targetAccessoriesPath, {
                 filter: (filePath) => {
-                    client.emit('stdout', `Restoring ${(0, node_path_1.basename)(filePath)}\r\n`);
+                    client.emit('stdout', `Restoring ${basename(filePath)}\r\n`);
                     return true;
                 },
             });
         }
-        const sourceConfig = await (0, fs_extra_1.readJson)((0, node_path_1.resolve)(this.restoreDirectory, 'etc', 'config.json'));
+        const sourceConfig = await readJson(resolve(this.restoreDirectory, 'etc', 'config.json'));
         const pluginMap = {
             'hue': 'homebridge-hue',
             'chamberlain': 'homebridge-chamberlain',
@@ -503,11 +508,11 @@ let BackupService = class BackupService {
                     plugin = pluginMap[plugin];
                 }
                 try {
-                    client.emit('stdout', (0, bash_color_1.yellow)(`\r\nInstalling ${plugin}...\r\n`));
+                    client.emit('stdout', yellow(`\r\nInstalling ${plugin}...\r\n`));
                     await this.pluginsService.managePlugin('install', { name: plugin, version: 'latest' }, client);
                 }
                 catch (e) {
-                    client.emit('stdout', (0, bash_color_1.red)(`Failed to install ${plugin}.\r\n`));
+                    client.emit('stdout', red(`Failed to install ${plugin}.\r\n`));
                 }
             }
         }
@@ -534,9 +539,9 @@ let BackupService = class BackupService {
             ...this.configService.ui,
             platform: 'config',
         });
-        await (0, fs_extra_1.writeJson)(this.configService.configPath, targetConfig, { spaces: 4 });
+        await writeJson(this.configService.configPath, targetConfig, { spaces: 4 });
         await this.removeRestoreDirectory();
-        client.emit('stdout', (0, bash_color_1.green)('\r\nRestore Complete!\r\n'));
+        client.emit('stdout', green('\r\nRestore Complete!\r\n'));
         this.configService.hbServiceUiRestartRequired = true;
         return { status: 0 };
     }
@@ -544,7 +549,7 @@ let BackupService = class BackupService {
         setTimeout(() => {
             this.homebridgeIpcService.killHomebridge();
             setTimeout(() => {
-                node_process_1.default.kill(node_process_1.default.pid, 'SIGKILL');
+                process.kill(process.pid, 'SIGKILL');
             }, 500);
         }, 500);
         return { status: 0 };
@@ -558,7 +563,7 @@ let BackupService = class BackupService {
                 delete restoredConfig.bridge.bind;
                 return;
             }
-            const interfaces = (0, systeminformation_1.networkInterfaces)();
+            const interfaces = networkInterfaces();
             restoredConfig.bridge.bind = restoredConfig.bridge.bind.filter(x => interfaces[x]);
             if (!restoredConfig.bridge.bind) {
                 delete restoredConfig.bridge.bind;
@@ -566,13 +571,18 @@ let BackupService = class BackupService {
         }
     }
 };
-exports.BackupService = BackupService;
-exports.BackupService = BackupService = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [config_service_1.ConfigService,
-        plugins_service_1.PluginsService,
-        scheduler_service_1.SchedulerService,
-        homebridge_ipc_service_1.HomebridgeIpcService,
-        logger_service_1.Logger])
+BackupService = __decorate([
+    Injectable(),
+    __param(0, Inject(ConfigService)),
+    __param(1, Inject(PluginsService)),
+    __param(2, Inject(SchedulerService)),
+    __param(3, Inject(HomebridgeIpcService)),
+    __param(4, Inject(Logger)),
+    __metadata("design:paramtypes", [ConfigService,
+        PluginsService,
+        SchedulerService,
+        HomebridgeIpcService,
+        Logger])
 ], BackupService);
+export { BackupService };
 //# sourceMappingURL=backup.service.js.map