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

package/src/services/config/index.ts

@@ -0,0 +1,744 @@
+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('---');
+  }
+}