@camera.ui/server 0.0.50-internal.0 → 0.0.50-internal.2

package/src/services/config/index.ts

@@ -1,744 +0,0 @@
-import 'reflect-metadata';
-
-import { getUserHomeDir, IS_DEV, IS_DOCKER, IS_ELECTRON, IS_HA, isEqual, isFfmpegInstalled, mergeWith, structuredClone } from '@camera.ui/common';
-import { ffmpegPath, isFFmpegAvailable } from '@camera.ui/ffmpeg';
-import { go2rtcPath } from '@camera.ui/go2rtc';
-import { natsServerPath } from '@camera.ui/nats';
-import { config } from 'dotenv';
-import { emptyDirSync, ensureDirSync, ensureFileSync, pathExistsSync, readJsonSync, removeSync, writeJsonSync } from 'fs-extra/esm';
-import { dump, load } from 'js-yaml';
-import { randomBytes } from 'node:crypto';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { arch, platform, release, tmpdir, type } from 'node:os';
-import { dirname, join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { container } from 'tsyringe';
-import { ZodError } from 'zod';
-
-import { patchConfigSchema } from '../../api/schemas/config.schema.js';
-import { patchGo2RtcSchema } from '../../api/schemas/go2rtc.schema.js';
-import { CertificateGeneration } from '../../api/utils/cert.js';
-import { HOST_CERT_FILENAME, HOST_KEY_FILENAME, OLD_ROOT_CERT_FILENAME, OLD_ROOT_KEY_FILENAME, ROOT_CERT_FILENAME } from '../../api/utils/constants.js';
-import { DEFAULT_CONFIG, DEFAULT_GO2RTC_CONFIG } from './constants.js';
-
-import type { LoggerOptions } from '@camera.ui/common/logger';
-import type { ProcInfo } from '../../api/database/checks.js';
-import type { Database } from '../../api/database/index.js';
-import type { Go2RtcApi } from '../../api/go2rtc/index.js';
-import type { DeepPartial } from '../../types.js';
-import type { LoggerService } from '../logger/index.js';
-import type { EnvironmentInfo, Go2RtcConfig, IConfig, Secrets, SSLConfig } from './types.js';
-
-const __require = createRequire(import.meta.url);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const packageJson = __require('../../../package.json');
-
-config({ path: resolve(join(__dirname, '../../../../.env')) });
-
-export class ConfigService {
-  static get VERSION(): string {
-    const pjson = readJsonSync(resolve(join(__dirname, '../../../package.json')));
-    return pjson.version;
-  }
-
-  static get ENVIRONMENT(): EnvironmentInfo {
-    return {
-      development: IS_DEV,
-      docker: IS_DOCKER,
-      electron: IS_ELECTRON,
-      homeassistant: IS_HA,
-    };
-  }
-
-  static readonly NODE_VERSION = process.version;
-  static readonly MIN_NODE_VERSION = ConfigService.extractVersion(packageJson.engines.node)!;
-
-  // paths
-  static readonly SERVER_PATH = resolve(join(__dirname, '../../../'));
-  static readonly INTERFACE_PATH = IS_DEV && !IS_ELECTRON ? join(ConfigService.SERVER_PATH, 'dist', 'interface') : join(ConfigService.SERVER_PATH, '..', 'interface');
-
-  private logger: LoggerService;
-  private _config!: IConfig;
-  private _go2rtcConfig!: Go2RtcConfig;
-  private _ssl!: SSLConfig;
-
-  // database
-  readonly SECRETS!: Secrets;
-
-  // dirs
-  readonly HOME_PATH: string;
-  readonly STORAGE_PATH: string;
-  readonly LOGS_PATH: string;
-  readonly PIDS_FILE: string;
-  readonly DATABASE_PATH: string;
-  readonly TOKENS_PATH: string;
-  readonly USERS_STORAGE_PATH: string;
-  readonly TMP_PATH: string;
-
-  readonly PLUGINS_STORAGE_PATH: string;
-  readonly PLUGINS_INSTALL_PATH: string;
-
-  // files
-  readonly REPORTS_FILE: string;
-  readonly LOG_FILE: string;
-  readonly CONFIG_FILE: string;
-  readonly SECRETS_FILE: string;
-  readonly GO2RTC_BINARY: string;
-  readonly GO2RTC_CONFIG_FILE: string;
-  readonly NATS_BINARY: string;
-  readonly BACKUP_INFO_FILE: string;
-
-  // server
-  readonly UI_PORT = parseInt(process.env.CAMERA_UI_DEV_UI_PORT!); // dotenv
-  readonly WS_PORT = parseInt(process.env.CAMERA_UI_DEV_WS_PORT!); // dotenv
-
-  // certs
-  get ssl(): SSLConfig {
-    return this._ssl;
-  }
-
-  // Proxy for main config to track nested changes
-  get config(): IConfig {
-    return this._config;
-  }
-
-  set config(newConfig: IConfig) {
-    this.validateAndSetConfig(newConfig);
-  }
-
-  // Proxy for go2rtc config to track nested changes
-  get go2rtcConfig(): Go2RtcConfig {
-    return this._go2rtcConfig;
-  }
-
-  set go2rtcConfig(newConfig: Go2RtcConfig) {
-    this.validateAndSetGo2RtcConfig(newConfig);
-  }
-
-  get processes(): ProcInfo[] {
-    try {
-      return JSON.parse(readFileSync(this.PIDS_FILE, 'utf-8'));
-    } catch {
-      return [];
-    }
-  }
-
-  set processes(pids: ProcInfo[]) {
-    writeFileSync(this.PIDS_FILE, JSON.stringify(pids));
-  }
-
-  get loggerOptions(): LoggerOptions {
-    return {
-      prefix: 'camera.ui',
-      suffix: undefined,
-      disableTimestamps: this._config.logger?.disableTimestamps === true,
-      debugEnabled: this._config.logger?.level === 'debug' || this._config.logger?.level === 'trace',
-      traceEnabled: this._config.logger?.level === 'trace',
-    };
-  }
-
-  get go2rtcLoggerOptions(): LoggerOptions {
-    return {
-      prefix: 'Go2RTC',
-      suffix: undefined,
-      disableTimestamps: this._config.logger?.disableTimestamps === true,
-      debugEnabled: this._go2rtcConfig.log?.level === 'debug' || this._go2rtcConfig.log?.level === 'trace',
-      traceEnabled: this._go2rtcConfig.log?.level === 'trace',
-    };
-  }
-
-  constructor(homePath?: string) {
-    container.registerInstance('configService', this);
-
-    this.logger = container.resolve<LoggerService>('logger');
-
-    if (!homePath) {
-      if (IS_DEV) {
-        this.HOME_PATH = join(__dirname, '..', '..', '..', '..', '.camera.ui');
-      } else {
-        this.HOME_PATH = join(getUserHomeDir(), '.camera.ui');
-      }
-    } else {
-      this.HOME_PATH = resolve(homePath);
-    }
-
-    this.TMP_PATH = join(tmpdir(), '.camera.ui');
-    this.STORAGE_PATH = join(this.HOME_PATH, 'volume');
-    this.LOGS_PATH = join(this.STORAGE_PATH, 'logs');
-    this.PIDS_FILE = join(this.STORAGE_PATH, 'camera.ui.pids');
-    this.REPORTS_FILE = join(this.STORAGE_PATH, 'camera.ui.report.yaml');
-    this.GO2RTC_CONFIG_FILE = join(this.STORAGE_PATH, 'go2rtc.yaml');
-    this.CONFIG_FILE = join(this.STORAGE_PATH, 'camera.ui.yaml');
-    this.BACKUP_INFO_FILE = join(this.STORAGE_PATH, 'camera.ui.backup.json');
-    this.DATABASE_PATH = join(this.STORAGE_PATH, 'database');
-    this.TOKENS_PATH = join(this.STORAGE_PATH, 'tokens');
-    this.USERS_STORAGE_PATH = join(this.STORAGE_PATH, 'users');
-
-    this.PLUGINS_STORAGE_PATH = join(this.STORAGE_PATH, 'plugins', 'storage');
-    this.PLUGINS_INSTALL_PATH = join(this.HOME_PATH, 'plugins');
-
-    this.GO2RTC_BINARY = go2rtcPath().replace('app.asar', 'app.asar.unpacked');
-    this.NATS_BINARY = natsServerPath().replace('app.asar', 'app.asar.unpacked');
-
-    this.SECRETS_FILE = join(this.STORAGE_PATH, '.camera.ui.secrets');
-    this.LOG_FILE = join(this.STORAGE_PATH, 'camera.ui.log');
-    this.SECRETS = this.updateSecrets();
-
-    this.createDirs();
-    this.read();
-    this.logStart();
-  }
-
-  public static extractVersion(str: string): string | null {
-    const regex = /(?:[>=^]*)(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.]+)?)/;
-    const matches = regex.exec(str);
-
-    if (matches?.[1]) {
-      return matches[1];
-    } else {
-      return null;
-    }
-  }
-
-  /**
-   * Updates the main configuration and writes it to disk
-   * @param newConfig Partial config to merge with existing
-   */
-  public writeConfig(newConfig?: DeepPartial<IConfig>): void {
-    const oldSSL = structuredClone(this._config.ssl);
-
-    if (newConfig) {
-      this.mergeAndValidate(this._config, newConfig);
-    }
-
-    const newSSL = structuredClone(this._config.ssl);
-    const sslChanged = isEqual(oldSSL, newSSL, true) === false;
-    const certFile = join(this.STORAGE_PATH, HOST_CERT_FILENAME);
-    const keyFile = join(this.STORAGE_PATH, HOST_KEY_FILENAME);
-
-    if (sslChanged) {
-      removeSync(certFile);
-      removeSync(keyFile);
-      this._ssl = this.readSSL();
-    }
-
-    writeFileSync(this.CONFIG_FILE, dump(this._config, { lineWidth: -1, noRefs: true }));
-  }
-
-  /**
-   * Common implementation for both file and API-based go2rtc config updates
-   * @param newConfig Partial config to merge with existing
-   * @param writeMethod Method to use for writing the config (file or API)
-   */
-  private async updateGo2RtcConfigCommon(newConfig?: DeepPartial<Go2RtcConfig>, writeMethod: 'file' | 'api' = 'file'): Promise<void> {
-    if (newConfig) {
-      this.mergeAndValidate(this._go2rtcConfig, newConfig);
-    }
-
-    // Handle empty streams object
-    if (this._go2rtcConfig.streams && Object.keys(this._go2rtcConfig.streams).length === 0) {
-      delete this._go2rtcConfig.streams;
-    }
-
-    // Use the appropriate write method
-    if (writeMethod === 'api') {
-      const go2rtcApi = container.resolve<Go2RtcApi>('go2rtcApi');
-      await go2rtcApi.configApi.rewriteConfig(this._go2rtcConfig);
-    } else {
-      writeFileSync(this.GO2RTC_CONFIG_FILE, dump(this._go2rtcConfig, { lineWidth: -1, noRefs: true }));
-    }
-  }
-
-  /**
-   * Write Go2RTC config to file
-   */
-  public async writeGo2RtcConfigFile(newConfig?: DeepPartial<Go2RtcConfig>): Promise<void> {
-    await this.updateGo2RtcConfigCommon(newConfig, 'file');
-  }
-
-  /**
-   * Write Go2RTC config using the API
-   */
-  public async writeGo2RtcConfigApi(newConfig?: DeepPartial<Go2RtcConfig>): Promise<void> {
-    await this.updateGo2RtcConfigCommon(newConfig, 'api');
-  }
-
-  /**
-   * Merge Go2RTC config from file and update database
-   */
-  public async mergeGo2RtcConfig(): Promise<void> {
-    // refresh stored go2rtc config and also update database
-    const fileConfig = load(readFileSync(this.GO2RTC_CONFIG_FILE, 'utf-8')) as Go2RtcConfig;
-    this.validateAndSetGo2RtcConfig(fileConfig);
-
-    const db: Database = container.resolve<Database>('dbs');
-    await db?.updateCameras();
-  }
-
-  /**
-   * Update WebRTC filter settings
-   */
-  public async updateGo2RtcWebRtcFilter(serverAddresses: string[] = [], oldAddresses: string[] = [], api?: boolean): Promise<void> {
-    const webRtcConfig = this._go2rtcConfig.webrtc;
-
-    // Initialize filters object if it doesn't exist
-    webRtcConfig.filters ??= {};
-
-    // Initialize candidates array if it doesn't exist
-    webRtcConfig.filters.candidates ??= [];
-
-    // Initialize IPs array if it doesn't exist
-    webRtcConfig.filters.ips ??= [];
-
-    // Remove old addresses from filters
-    if (oldAddresses.length) {
-      webRtcConfig.filters.candidates = webRtcConfig.filters.candidates.filter((address) => !oldAddresses.includes(address));
-      webRtcConfig.filters.ips = webRtcConfig.filters.ips.filter((address) => !oldAddresses.includes(address));
-    }
-
-    // Add new server addresses to filters
-    if (serverAddresses.length) {
-      for (const address of serverAddresses) {
-        if (!webRtcConfig.filters.candidates.includes(address)) {
-          webRtcConfig.filters.candidates.push(address);
-        }
-
-        if (!webRtcConfig.filters.ips.includes(address)) {
-          webRtcConfig.filters.ips.push(address);
-        }
-      }
-    } else {
-      // Clear filters if no addresses are provided
-      webRtcConfig.filters.candidates = [];
-      webRtcConfig.filters.ips = [];
-    }
-
-    // Clean up empty filter arrays
-    this.cleanupWebRtcFilters(webRtcConfig);
-
-    // Write the updated config
-    if (api) {
-      await this.writeGo2RtcConfigApi({ webrtc: webRtcConfig });
-    } else {
-      await this.writeGo2RtcConfigFile({ webrtc: webRtcConfig });
-    }
-  }
-
-  /**
-   * Reset camera.ui
-   */
-  public async reset(): Promise<void> {
-    this.logger.attention('Resetting camera.ui...');
-
-    // Cleanup
-    this.safetyEmptyDir(this.STORAGE_PATH); // .camera.ui/volume
-    // this.safetyEmptyDir(resolve(this.HOME_PATH, 'python')); // .camera.ui/python
-    this.safetyEmptyDir(this.PLUGINS_INSTALL_PATH); // .camera.ui/plugins
-  }
-
-  /**
-   * Clean up empty WebRTC filter arrays
-   */
-  private cleanupWebRtcFilters(webRtcConfig: any): void {
-    // Remove empty filter arrays
-    for (const key of ['candidates', 'ips', 'networks', 'interfaces', 'udp_ports']) {
-      if (!webRtcConfig.filters[key]?.length) {
-        delete webRtcConfig.filters[key];
-      }
-    }
-
-    // Remove empty filters object
-    if (Object.keys(webRtcConfig.filters).length === 0) {
-      delete webRtcConfig.filters;
-    }
-  }
-
-  public addProcess(proc: ProcInfo): ProcInfo {
-    const processes = this.processes;
-    processes.push(proc);
-    writeFileSync(this.PIDS_FILE, JSON.stringify(processes));
-    return proc;
-  }
-
-  public removeProcessByPID(pid?: number): void {
-    if (!pid) {
-      return;
-    }
-
-    const processes = this.processes;
-    const index = processes.findIndex((process) => process.pid === pid);
-
-    if (index > -1) {
-      processes.splice(index, 1);
-      writeFileSync(this.PIDS_FILE, JSON.stringify(processes));
-    }
-  }
-
-  public go2rtcAddress(mod: 'api' | 'rtsp' | 'onvif' | 'srtp' | 'rtmp' | 'webrtc' | 'ws' = 'api'): string {
-    let go2rtcPort: number;
-    let protocol: string | undefined;
-
-    const isTls = this._go2rtcConfig.api.listen === '';
-
-    if (mod === 'api' || mod === 'ws' || mod === 'onvif') {
-      const listen = isTls ? this._go2rtcConfig.api.tls_listen : this._go2rtcConfig.api.listen;
-      go2rtcPort = parseInt(listen.split(':')[1], 10);
-    } else {
-      go2rtcPort = parseInt(this._go2rtcConfig[mod].listen.split(':')[1], 10);
-    }
-
-    if (!protocol) {
-      switch (mod) {
-        case 'api':
-        case 'webrtc':
-          protocol = isTls ? 'https' : 'http';
-          break;
-        case 'ws':
-          protocol = isTls ? 'wss' : 'ws';
-          break;
-        case 'rtsp':
-          protocol = 'rtsp';
-          break;
-        case 'onvif':
-          protocol = 'onvif';
-          break;
-        case 'srtp':
-          protocol = 'srtp';
-          break;
-        case 'rtmp':
-          protocol = 'rtmp';
-          break;
-        default:
-          protocol = 'http';
-          break;
-      }
-    }
-
-    return `${protocol}://127.0.0.1:${go2rtcPort}`;
-  }
-
-  public cameraURLExists(cameraUrl: string): boolean {
-    const url = new URL(cameraUrl);
-    const host = url.host;
-    const port = url.port;
-
-    const sources = this._go2rtcConfig.streams ?? {};
-    const urls = Object.values(sources)
-      .filter((source) => source)
-      .map((source) => source!)
-      .flat();
-
-    return urls.some((url) => {
-      if (!host) {
-        return host === url;
-      }
-
-      const u = new URL(url);
-      return u.host === host && u.port === port;
-    });
-  }
-
-  /**
-   * Validate and set the main config, handling Zod validation
-   */
-  private validateAndSetConfig(newConfig: IConfig): void {
-    try {
-      const config = patchConfigSchema.parse(newConfig);
-      this._config = config;
-    } catch (error: any) {
-      if (error instanceof ZodError) {
-        this.logger.error('Invalid camera.ui config!');
-        throw error;
-      }
-
-      this.logger.error('Failed to parse camera.ui config!');
-      throw error;
-    }
-  }
-
-  /**
-   * Validate and set the Go2RTC config, handling Zod validation
-   */
-  private validateAndSetGo2RtcConfig(newConfig: Go2RtcConfig): void {
-    // Handle null streams
-    if (!newConfig.streams || newConfig.streams === null) {
-      delete newConfig.streams;
-    }
-
-    try {
-      // Validate using Zod schema
-      const config = patchGo2RtcSchema.parse(newConfig);
-
-      // Apply restrictions and ensure correct configuration
-      this._go2rtcConfig = this.updateGo2RtcConfig(config);
-    } catch (error: any) {
-      if (error instanceof ZodError) {
-        this.logger.error('Invalid go2rtc config!');
-        throw error;
-      }
-
-      this.logger.error('Failed to parse go2rtc config!');
-      throw error;
-    }
-  }
-
-  /**
-   * Merge a partial config with the existing config and validate it
-   */
-  private mergeAndValidate<T>(target: T, source: DeepPartial<T>): void {
-    mergeWith(target, source, (sourceVal: any, targetVal: any) => {
-      if (Array.isArray(sourceVal)) {
-        return targetVal;
-      }
-    });
-  }
-
-  private read() {
-    this.updateConfig();
-    this.writeConfig();
-    this.writeGo2RtcConfigFile();
-  }
-
-  private defaultConfig(): IConfig {
-    const defaultConfig = structuredClone(DEFAULT_CONFIG);
-    defaultConfig.ssl.certFile = join(this.STORAGE_PATH, HOST_CERT_FILENAME);
-    defaultConfig.ssl.keyFile = join(this.STORAGE_PATH, HOST_KEY_FILENAME);
-    defaultConfig.ssl.caFile = join(this.STORAGE_PATH, ROOT_CERT_FILENAME);
-    return patchConfigSchema.parse(defaultConfig);
-  }
-
-  private defaultGo2RtcConfig(): Go2RtcConfig {
-    const defaultConfig = structuredClone(DEFAULT_GO2RTC_CONFIG);
-    defaultConfig.api.tls_cert = join(this.STORAGE_PATH, HOST_CERT_FILENAME);
-    defaultConfig.api.tls_key = join(this.STORAGE_PATH, HOST_KEY_FILENAME);
-    defaultConfig.api.tls_ca = join(this.STORAGE_PATH, ROOT_CERT_FILENAME);
-    return patchGo2RtcSchema.parse(defaultConfig);
-  }
-
-  private readConfig(): IConfig {
-    let config = this.defaultConfig();
-
-    if (pathExistsSync(this.CONFIG_FILE)) {
-      let configFileData = load(readFileSync(this.CONFIG_FILE, 'utf-8')) as IConfig;
-      configFileData = this.cleanupConfig(config, configFileData);
-
-      config = mergeWith(this.defaultConfig(), configFileData, (source: any, target: any) => {
-        if (Array.isArray(source)) {
-          return target;
-        }
-      });
-
-      // Update legacy cert paths
-      if (config.ssl.certFile === join(this.STORAGE_PATH, OLD_ROOT_CERT_FILENAME)) {
-        config.ssl.certFile = join(this.STORAGE_PATH, HOST_CERT_FILENAME);
-      }
-
-      if (config.ssl.keyFile === join(this.STORAGE_PATH, OLD_ROOT_KEY_FILENAME)) {
-        config.ssl.keyFile = join(this.STORAGE_PATH, HOST_KEY_FILENAME);
-      }
-    }
-
-    return config;
-  }
-
-  private readGo2RtcConfig(): Go2RtcConfig {
-    let go2rtcConfig = this.defaultGo2RtcConfig();
-
-    if (pathExistsSync(this.GO2RTC_CONFIG_FILE)) {
-      const configFileData = load(readFileSync(this.GO2RTC_CONFIG_FILE, 'utf-8')) as Go2RtcConfig;
-
-      go2rtcConfig = mergeWith(go2rtcConfig, configFileData, (source: any, target: any) => {
-        if (Array.isArray(source)) {
-          return target;
-        }
-      });
-    }
-
-    return this.updateGo2RtcConfig(go2rtcConfig);
-  }
-
-  private cleanupConfig(config: IConfig, newConfig: IConfig): IConfig {
-    for (const key in newConfig) {
-      if ((config as any)[key] === undefined) {
-        delete (newConfig as any)[key];
-      } else if (Object.keys((newConfig as any)[key]).length > 0) {
-        const keys = Object.keys((newConfig as any)[key]);
-        for (const k of keys) {
-          if ((config as any)[key][k] === undefined) {
-            delete (newConfig as any)[key][k];
-          }
-        }
-      }
-    }
-
-    return newConfig;
-  }
-
-  private updateConfig(): void {
-    // validate and setup configs
-    this.validateAndSetConfig(this.readConfig());
-    this.validateAndSetGo2RtcConfig(this.readGo2RtcConfig());
-    this._ssl = this.readSSL();
-
-    // setup logger
-    this.logger.debugEnabled = this._config.logger?.level === 'debug' || this._config.logger?.level === 'trace';
-    this.logger.traceEnabled = this._config.logger?.level === 'trace';
-    this.logger.disableTimestamps = this._config.logger?.disableTimestamps === true;
-  }
-
-  private updateGo2RtcConfig(go2rtcConfig: Go2RtcConfig): Go2RtcConfig {
-    const config = structuredClone(go2rtcConfig);
-
-    // Validate api
-    config.api.listen = '';
-    config.api.origin = '*';
-    config.api.tls_cert = this.config.ssl.certFile;
-    config.api.tls_key = this.config.ssl.keyFile;
-    config.api.tls_ca = this.config.ssl.caFile;
-
-    // Validate ffmpeg
-    if (!isFfmpegInstalled(config.ffmpeg.bin)) {
-      config.ffmpeg.bin = !isFFmpegAvailable() ? (platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg') : ffmpegPath().replace('app.asar', 'app.asar.unpacked');
-    }
-
-    // Validate webrtc
-
-    // Initialize filters if needed
-    config.webrtc.filters ??= {};
-
-    // Clean up configuration
-    if (!config.streams) {
-      delete config.streams;
-    }
-
-    if (!config.webrtc.candidates?.length) {
-      delete config.webrtc.candidates;
-    }
-
-    this.cleanupWebRtcFilters(config.webrtc);
-
-    return config;
-  }
-
-  private readSSL(): SSLConfig {
-    const { cert, key, ca } = CertificateGeneration.generateCert();
-
-    return {
-      cert: Buffer.from(cert),
-      key: Buffer.from(key),
-      ca: Buffer.from(ca),
-    };
-  }
-
-  private updateSecrets(): Secrets {
-    const createSecrets = (): Secrets => {
-      const secrets: Secrets = {
-        jwtAccessKey: randomBytes(32).toString('hex'),
-        jwtRefreshKey: randomBytes(32).toString('hex'),
-      };
-
-      writeJsonSync(this.SECRETS_FILE, secrets, { spaces: 2 });
-
-      return secrets;
-    };
-
-    if (pathExistsSync(this.SECRETS_FILE)) {
-      try {
-        const secrets: Secrets = readJsonSync(this.SECRETS_FILE);
-
-        if (!secrets.jwtAccessKey || !secrets.jwtRefreshKey) {
-          return createSecrets();
-        } else {
-          return secrets;
-        }
-      } catch {
-        return createSecrets();
-      }
-    } else {
-      return createSecrets();
-    }
-  }
-
-  private async createDirs(): Promise<void> {
-    this.safetyEmptyDir(this.TMP_PATH);
-    this.safetyEnsureDir(this.HOME_PATH);
-    this.safetyEnsureDir(this.LOGS_PATH);
-    this.safetyEnsureDir(this.STORAGE_PATH);
-    this.safetyEnsureDir(this.USERS_STORAGE_PATH);
-    this.safetyEnsureDir(this.PLUGINS_STORAGE_PATH);
-    this.safetyEnsureDir(this.PLUGINS_INSTALL_PATH);
-    this.safetyEnsureDir(this.DATABASE_PATH);
-    this.safetyEnsureDir(this.TOKENS_PATH);
-    this.safetyEnsureFile(this.CONFIG_FILE);
-    this.safetyEnsureFile(this.GO2RTC_CONFIG_FILE);
-    this.safetyEnsureFile(this.SECRETS_FILE);
-    this.safetyEnsureFile(this.LOG_FILE);
-    this.safetyEnsureFile(this.REPORTS_FILE);
-    this.safetyEnsureFile(this.PIDS_FILE);
-  }
-
-  private safetyEnsureDir(dir: string): void {
-    try {
-      ensureDirSync(dir);
-    } catch (error: any) {
-      if (error.code !== 'EACCES') {
-        this.logger.warn(`Failed to create directory: ${dir}`);
-        this.logger.warn(`Please make sure the user "${process.env.USER}" has the correct permissions`);
-        this.logger.warn(`EXAMPLE: sudo chown -R ${process.env.USER}:${process.env.USER} ${dir}`);
-      }
-
-      throw error;
-    }
-  }
-
-  private safetyEmptyDir(dir: string): void {
-    try {
-      emptyDirSync(dir);
-    } catch (error: any) {
-      if (error.code !== 'EACCES') {
-        this.logger.warn(`Failed to empty directory: ${dir}`);
-        this.logger.warn(`Please make sure the user "${process.env.USER}" has the correct permissions`);
-        this.logger.warn(`EXAMPLE: sudo chown -R ${process.env.USER}:${process.env.USER} ${dir}`);
-      }
-
-      throw error;
-    }
-  }
-
-  private safetyEnsureFile(file: string): void {
-    try {
-      ensureFileSync(file);
-    } catch (error: any) {
-      if (error.code !== 'EACCES') {
-        this.logger.warn(`Failed to create file: ${file}`);
-        this.logger.warn(`Please make sure the user "${process.env.USER}" has the correct permissions`);
-        this.logger.warn(`EXAMPLE: sudo chown ${process.env.USER}:${process.env.USER} ${file}`);
-      }
-
-      throw error;
-    }
-  }
-
-  private logStart(): void {
-    this.logger.log('---');
-    this.logger.log(`Initializing camera.ui with PID: ${process.pid}`);
-    this.logger.log('---');
-    this.logger.log(`camera.ui Home Path: ${this.HOME_PATH}`);
-    this.logger.log(`camera.ui Storage Path: ${this.STORAGE_PATH}`);
-    this.logger.log(`camera.ui Config Path: ${this.CONFIG_FILE}`);
-    this.logger.log(`Go2RTC Binary Path: ${this.GO2RTC_BINARY}`);
-    this.logger.log(`Go2RTC Config Path ${this.GO2RTC_CONFIG_FILE}`);
-    this.logger.log(`Nats Binary Path: ${this.NATS_BINARY}`);
-    this.logger.log(`Plugins Storage Path: ${this.PLUGINS_STORAGE_PATH}`);
-    this.logger.log(`Plugins Install Path: ${this.PLUGINS_INSTALL_PATH}`);
-    this.logger.log('---');
-    this.logger.log(`OS: ${type()} ${release()} ${arch()}`);
-    this.logger.log(`Node.js ${process.version} ${process.execPath}`);
-    this.logger.log(`User: ${process.env.USER ?? process.env.USERNAME}`);
-    this.logger.log('Environment:', ConfigService.ENVIRONMENT);
-    this.logger.log('---');
-  }
-}