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

package/src/api/database/selfcheck.ts

@@ -0,0 +1,492 @@
+import { green } from 'ansicolor';
+import { dump as yamlDump } from 'js-yaml';
+import { constants, existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { container } from 'tsyringe';
+
+import { ConfigService } from '../../services/config/index.js';
+import {
+  checkDatabaseCorruption,
+  checkInstalledFFmpegs,
+  checkOrphanedProcesses,
+  checkPathPermissions,
+  checkPathsExist,
+  checkPortAvailability,
+  cleanUpFiles,
+} from './checks.js';
+
+import type { LoggerService } from '../../services/logger/index.js';
+import type {
+  CleanedUpFilesResult,
+  DatabaseCorruptionResult,
+  FFmpegExistenceResult,
+  OrphanedProcessesResult,
+  PathExistenceResult,
+  PathPermission,
+  PathPermissionsResult,
+  PortAvailabilityResult,
+} from './checks.js';
+
+export interface SelfCheckConfig {
+  enabled: boolean;
+  checks: {
+    pathsExistence: boolean;
+    pathsPermissions: boolean;
+    cleanupFiles: boolean;
+    databaseCorruption: boolean;
+    portAvailability: boolean;
+    ffmpegBinaries: boolean;
+    orphanedProcesses: boolean;
+  };
+}
+
+export interface SelfCheckResults {
+  status: 'success' | 'error' | 'disabled';
+  error?: string;
+  pathsExistence?: PathExistenceResult[];
+  pathsPermissions?: PathPermissionsResult[];
+  cleanedUpFiles?: CleanedUpFilesResult[];
+  databaseCorruption?: DatabaseCorruptionResult;
+  portAvailability?: PortAvailabilityResult[];
+  installedFFmpegs?: FFmpegExistenceResult[];
+  orphanedProcesses?: OrphanedProcessesResult[];
+}
+
+interface IssueReport {
+  type: string;
+  message: string;
+  details?: any;
+}
+
+export class SelfCheck {
+  private logger: LoggerService;
+  private configService: ConfigService;
+  private config: SelfCheckConfig;
+
+  constructor(config: Partial<SelfCheckConfig> = {}) {
+    this.logger = container.resolve<LoggerService>('logger');
+    this.configService = container.resolve<ConfigService>('configService');
+
+    this.config = {
+      enabled: true,
+      checks: {
+        pathsExistence: true,
+        pathsPermissions: true,
+        cleanupFiles: true,
+        databaseCorruption: true,
+        portAvailability: true,
+        ffmpegBinaries: true,
+        orphanedProcesses: true,
+      },
+      ...config,
+    };
+  }
+
+  public async run(): Promise<void> {
+    if (!this.config.enabled) {
+      this.logger.log('Self-check is disabled');
+      return;
+    }
+
+    this.logger.log('Running self-checks...');
+
+    const checkResults = await this.performChecks();
+
+    if (checkResults.status === 'error') {
+      this.logger.error(`Self-check failed: ${checkResults.error}`);
+      throw new Error('SELF_CHECK_FAILED');
+    }
+
+    const criticalIssues = this.checkForCriticalIssues(checkResults);
+    const nonCriticalIssues = this.checkForNonCriticalIssues(checkResults);
+
+    if (criticalIssues.length > 0) {
+      this.logger.error('Critical issues found during self-check. Check the detailed report for more information.');
+      await this.saveCheckReport(checkResults, criticalIssues, nonCriticalIssues);
+      throw new Error('CRITICAL_ISSUES_FOUND');
+    }
+
+    if (nonCriticalIssues.length > 0) {
+      this.logger.warn('Non-critical issues found during self-check. Check the detailed report for more information.');
+    } else {
+      this.logger.log(green('Self-check passed successfully!'));
+    }
+
+    await this.saveCheckReport(checkResults, criticalIssues, nonCriticalIssues);
+  }
+
+  private async performChecks(): Promise<SelfCheckResults> {
+    const results: Partial<SelfCheckResults> = {};
+
+    const pathsToCheck = [
+      this.configService.HOME_PATH,
+      this.configService.STORAGE_PATH,
+      this.configService.LOGS_PATH,
+      this.configService.PIDS_FILE,
+      this.configService.DATABASE_PATH,
+      this.configService.TOKENS_PATH,
+      this.configService.USERS_STORAGE_PATH,
+      this.configService.TMP_PATH,
+      this.configService.REPORTS_FILE,
+      this.configService.PLUGINS_STORAGE_PATH,
+      this.configService.PLUGINS_INSTALL_PATH,
+      this.configService.LOG_FILE,
+      this.configService.CONFIG_FILE,
+      this.configService.SECRETS_FILE,
+      this.configService.GO2RTC_BINARY,
+      this.configService.GO2RTC_CONFIG_FILE,
+      this.configService.NATS_BINARY,
+    ];
+
+    const pathsWithPermissionsToCheck: PathPermission[] = [
+      { path: this.configService.GO2RTC_BINARY, mode: constants.X_OK },
+      { path: this.configService.NATS_BINARY, mode: constants.X_OK },
+      { path: this.configService.CONFIG_FILE, mode: constants.R_OK | constants.W_OK },
+      { path: this.configService.GO2RTC_CONFIG_FILE, mode: constants.R_OK | constants.W_OK },
+      { path: this.configService.SECRETS_FILE, mode: constants.R_OK | constants.W_OK },
+      { path: this.configService.LOG_FILE, mode: constants.R_OK | constants.W_OK },
+      { path: this.configService.DATABASE_PATH, mode: constants.R_OK | constants.W_OK },
+      { path: this.configService.TOKENS_PATH, mode: constants.R_OK | constants.W_OK },
+      { path: this.configService.HOME_PATH, mode: constants.R_OK | constants.W_OK | constants.X_OK },
+      { path: this.configService.STORAGE_PATH, mode: constants.R_OK | constants.W_OK | constants.X_OK },
+      { path: this.configService.LOGS_PATH, mode: constants.R_OK | constants.W_OK | constants.X_OK },
+      { path: this.configService.USERS_STORAGE_PATH, mode: constants.R_OK | constants.W_OK | constants.X_OK },
+      { path: this.configService.TMP_PATH, mode: constants.R_OK | constants.W_OK | constants.X_OK },
+      { path: this.configService.PLUGINS_STORAGE_PATH, mode: constants.R_OK | constants.W_OK | constants.X_OK },
+      { path: this.configService.PLUGINS_INSTALL_PATH, mode: constants.R_OK | constants.W_OK | constants.X_OK },
+      { path: this.configService.PIDS_FILE, mode: constants.R_OK | constants.W_OK },
+    ];
+
+    const cleanedUpFiles: string[] = [];
+
+    const portsToCheck = [
+      this.configService.config.port,
+      this.configService.go2rtcConfig.api.listen.split(':')[1],
+      this.configService.go2rtcConfig.api.tls_listen.split(':')[1],
+      this.configService.go2rtcConfig.rtsp.listen.split(':')[1],
+      this.configService.go2rtcConfig.srtp.listen.split(':')[1],
+      this.configService.go2rtcConfig.rtmp.listen.split(':')[1],
+      this.configService.go2rtcConfig.webrtc.listen.split(':')[1],
+    ]
+      .filter((port) => port)
+      .map((port) => parseInt(port as any, 10));
+
+    try {
+      if (this.config.checks.pathsExistence) {
+        results.pathsExistence = await checkPathsExist(pathsToCheck);
+      }
+
+      if (this.config.checks.pathsPermissions) {
+        results.pathsPermissions = await checkPathPermissions(pathsWithPermissionsToCheck);
+      }
+
+      if (this.config.checks.cleanupFiles) {
+        results.cleanedUpFiles = await cleanUpFiles(cleanedUpFiles);
+      }
+
+      if (this.config.checks.databaseCorruption) {
+        results.databaseCorruption = await checkDatabaseCorruption(this.configService.DATABASE_PATH);
+      }
+
+      if (this.config.checks.orphanedProcesses) {
+        results.orphanedProcesses = await checkOrphanedProcesses(this.configService.processes);
+      }
+
+      if (this.config.checks.portAvailability) {
+        results.portAvailability = await checkPortAvailability(portsToCheck);
+      }
+
+      if (this.config.checks.ffmpegBinaries) {
+        results.installedFFmpegs = await checkInstalledFFmpegs();
+      }
+
+      return { status: 'success', ...results };
+    } catch (error) {
+      return { status: 'error', error: error.message, ...results };
+    }
+  }
+
+  private checkForCriticalIssues(results: SelfCheckResults): IssueReport[] {
+    const criticalIssues: IssueReport[] = [];
+
+    if (results.databaseCorruption?.isCorrupt) {
+      criticalIssues.push({
+        type: 'Database Corruption',
+        message: 'Database corruption detected',
+        details: this.sanitizeDetails(results.databaseCorruption),
+      });
+    }
+
+    if (results.pathsExistence) {
+      const missingCriticalPaths = results.pathsExistence
+        .filter((result) => !result.exists && this.isCriticalPath(result.path))
+        .map((result) => ({
+          type: 'Missing Critical Path',
+          message: `Missing critical path: ${result.path}`,
+          details: this.sanitizeDetails(result),
+        }));
+      criticalIssues.push(...missingCriticalPaths);
+    }
+
+    if (results.pathsPermissions) {
+      const criticalPermissionIssues = results.pathsPermissions
+        .filter((result) => !result.hasPermissions && this.isCriticalPath(result.path))
+        .map((result) => ({
+          type: 'Insufficient Permissions',
+          message: `Insufficient permissions for critical path: ${result.path}`,
+          details: this.sanitizeDetails(result),
+        }));
+      criticalIssues.push(...criticalPermissionIssues);
+    }
+
+    if (results.portAvailability) {
+      const unavailablePorts = results.portAvailability
+        .filter((result) => !result.isAvailable)
+        .map((result) => ({
+          type: 'Port Unavailable',
+          message: `Required port ${result.port} is not available`,
+          details: this.sanitizeDetails(result),
+        }));
+      criticalIssues.push(...unavailablePorts);
+    }
+
+    return criticalIssues;
+  }
+
+  private checkForNonCriticalIssues(results: SelfCheckResults): IssueReport[] {
+    const nonCriticalIssues: IssueReport[] = [];
+
+    if (results.pathsExistence) {
+      const missingNonCriticalPaths = results.pathsExistence
+        .filter((result) => !result.exists && !this.isCriticalPath(result.path))
+        .map((result) => ({
+          type: 'Missing Non-Critical Path',
+          message: `Missing non-critical path: ${result.path}`,
+          details: result,
+        }));
+      nonCriticalIssues.push(...missingNonCriticalPaths);
+    }
+
+    if (results.pathsPermissions) {
+      const nonCriticalPermissionIssues = results.pathsPermissions
+        .filter((result) => !result.hasPermissions && !this.isCriticalPath(result.path))
+        .map((result) => ({
+          type: 'Insufficient Permissions',
+          message: `Insufficient permissions for non-critical path: ${result.path}`,
+          details: result,
+        }));
+      nonCriticalIssues.push(...nonCriticalPermissionIssues);
+    }
+
+    if (results.orphanedProcesses) {
+      const orphanedProcesses = results.orphanedProcesses
+        .filter((result) => result.wasOrphaned)
+        .map((result) => ({
+          type: 'Orphaned Process',
+          message: `Orphaned process detected: ${result.processInfo.command} (PID: ${result.processInfo.pid})`,
+          details: result,
+        }));
+      nonCriticalIssues.push(...orphanedProcesses);
+    }
+
+    if (results.installedFFmpegs) {
+      const missingFfmpegBinaries = results.installedFFmpegs
+        .filter((result) => !result.exists)
+        .map((result) => ({
+          type: 'Installed FFmpeg Binary',
+          message: 'FFmpeg binary not found',
+          details: result,
+        }));
+      nonCriticalIssues.push(...missingFfmpegBinaries);
+
+      const missingPermissions = results.installedFFmpegs
+        .filter((result) => result.exists && !result.hasPermissions)
+        .map((result) => ({
+          type: 'FFmpeg Binary Permissions',
+          message: 'FFmpeg binary has insufficient permissions',
+          details: result,
+        }));
+      nonCriticalIssues.push(...missingPermissions);
+    }
+
+    return nonCriticalIssues;
+  }
+
+  private async saveCheckReport(checkResults: SelfCheckResults, criticalIssues: IssueReport[], nonCriticalIssues: IssueReport[]): Promise<void> {
+    let reportPath = this.configService.REPORTS_FILE;
+    if (!existsSync(this.configService.REPORTS_FILE)) {
+      reportPath = join(homedir(), 'camera.ui.report.yaml');
+    }
+
+    const report = this.generateCheckReport(checkResults, criticalIssues, nonCriticalIssues);
+
+    await writeFile(reportPath, report);
+    this.logger.log(`Detailed self-check report saved to: ${reportPath}`);
+  }
+
+  private generateCheckReport(checkResults: SelfCheckResults, criticalIssues: IssueReport[], nonCriticalIssues: IssueReport[]): string {
+    const report = {
+      self_check_report: {
+        environment: ConfigService.ENVIRONMENT,
+        metadata: {
+          status: checkResults.status,
+          timestamp: new Date().toISOString(),
+        },
+        critical_issues: this.formatIssues(criticalIssues),
+        non_critical_issues: this.formatIssues(nonCriticalIssues),
+        detailed_results: {
+          paths_existence: this.formatPathsExistence(checkResults.pathsExistence),
+          paths_permissions: this.formatPathsPermissions(checkResults.pathsPermissions),
+          cleaned_up_files: this.formatCleanedUpFiles(checkResults.cleanedUpFiles),
+          database_corruption: this.formatDatabaseCorruption(checkResults.databaseCorruption),
+          port_availability: this.formatPortAvailability(checkResults.portAvailability),
+          ffmpeg_binaries: this.formatFfmpegBinaries(checkResults.installedFFmpegs),
+          orphaned_processes: this.formatOrphanedProcesses(checkResults.orphanedProcesses),
+        },
+      },
+    };
+
+    return yamlDump(report, { indent: 2, lineWidth: -1 });
+  }
+
+  private formatIssues(issues: IssueReport[]): any[] {
+    return issues.map((issue) => ({
+      issue: {
+        type: issue.type,
+        message: issue.message,
+        details: this.sanitizeDetails(issue.details),
+      },
+    }));
+  }
+
+  private formatPathsExistence(results?: SelfCheckResults['pathsExistence']): any[] {
+    if (!results) return [];
+    return results.map((result) => ({
+      path: {
+        name: this.getPathName(result.path),
+        path: result.path,
+        exists: result.exists,
+      },
+    }));
+  }
+
+  private formatPathsPermissions(results?: SelfCheckResults['pathsPermissions']): any[] {
+    if (!results) return [];
+    return results.map((result) => ({
+      path_permission: {
+        name: this.getPathName(result.path),
+        path: result.path,
+        has_permissions: result.hasPermissions,
+        error: result.error ? this.serializeError(result.error) : undefined,
+      },
+    }));
+  }
+
+  private formatCleanedUpFiles(results?: SelfCheckResults['cleanedUpFiles']): any[] {
+    if (!results) return [];
+    return results.map((result) => ({
+      cleaned_file: {
+        name: this.getPathName(result.path),
+        path: result.path,
+        cleaned: result.wasCleaned,
+        error: result.error ? this.serializeError(result.error) : undefined,
+      },
+    }));
+  }
+
+  private formatDatabaseCorruption(result?: SelfCheckResults['databaseCorruption']): Record<string, any> | null {
+    if (!result) return null;
+    return {
+      path: result.dbPath,
+      is_corrupt: result.isCorrupt,
+      error: result.error?.message ? this.serializeError(result.error) : undefined,
+    };
+  }
+
+  private formatPortAvailability(results?: SelfCheckResults['portAvailability']): any[] {
+    if (!results) return [];
+    return results.map((result) => ({
+      port: {
+        port: result.port,
+        available: result.isAvailable,
+      },
+    }));
+  }
+
+  private formatFfmpegBinaries(results?: SelfCheckResults['installedFFmpegs']): any[] {
+    if (!results) return [];
+    return results.map((result) => ({
+      ffmpeg_binary: {
+        name: this.getPathName(result.path),
+        path: result.path,
+        exists: result.exists,
+        hasPermissions: result.hasPermissions,
+        error: result.error ? this.serializeError(result.error) : undefined,
+      },
+    }));
+  }
+
+  private formatOrphanedProcesses(results?: SelfCheckResults['orphanedProcesses']): any[] {
+    if (!results) return [];
+    return results.map((result) => ({
+      process: {
+        command: result.processInfo.command,
+        pid: result.processInfo.pid,
+        orphaned: result.wasOrphaned,
+        error: result.error ? this.serializeError(result.error) : undefined,
+      },
+    }));
+  }
+
+  private sanitizeDetails(details: any): any {
+    if (details instanceof Error) {
+      return this.serializeError(details);
+    } else if (Array.isArray(details)) {
+      return details.map((item) => this.sanitizeDetails(item));
+    } else if (typeof details === 'object' && details !== null) {
+      const sanitizedObject: Record<string, any> = {};
+      for (const key in details) {
+        sanitizedObject[key] = this.sanitizeDetails(details[key]);
+      }
+      return sanitizedObject;
+    } else {
+      return details;
+    }
+  }
+
+  private serializeError(error: Error): Record<string, any> {
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+    };
+  }
+
+  private getPathName(path: string): string {
+    const parts = path.split('/');
+    return parts[parts.length - 1] || path;
+  }
+
+  private isCriticalPath(path: string): boolean {
+    const criticalPaths = [
+      this.configService.HOME_PATH,
+      this.configService.STORAGE_PATH,
+      this.configService.PIDS_FILE,
+      this.configService.DATABASE_PATH,
+      this.configService.TOKENS_PATH,
+      this.configService.USERS_STORAGE_PATH,
+      this.configService.PLUGINS_STORAGE_PATH,
+      this.configService.PLUGINS_INSTALL_PATH,
+      this.configService.LOG_FILE,
+      this.configService.CONFIG_FILE,
+      this.configService.SECRETS_FILE,
+      this.configService.GO2RTC_BINARY,
+      this.configService.GO2RTC_CONFIG_FILE,
+      this.configService.NATS_BINARY,
+    ];
+
+    return criticalPaths.includes(path);
+  }
+}

package/src/api/database/types.ts

@@ -0,0 +1,104 @@
+import type { UsableNetworkAddress } from '@camera.ui/common/network';
+import type { BaseCamera, CameraInputSettings, Point } from '@camera.ui/types';
+import type { CamviewSettingsLayoutMode, ClientData, JwtTokenEncoded } from '../types/index.js';
+
+export interface DBAuth {
+  tokens: JwtTokenEncoded[];
+  clients: ClientData[];
+}
+
+export interface DBCamera extends BaseCamera {
+  sources: CameraInputSettings[];
+}
+
+export interface DBPlugin {
+  readonly _id: string;
+  pluginName: string;
+}
+
+export interface DBSettings {
+  version: string;
+}
+
+export interface DBUser {
+  readonly _id: string;
+  avatar: string;
+  username: string;
+  password: string;
+  sessionTimer: number;
+  role: DBRoles;
+  rememberMe: boolean;
+  singleSession: boolean;
+  firstLogin: boolean;
+  preferences: DBUserPreferences;
+}
+
+export type RemoteAccessMode = 'disabled' | 'upnp' | 'port-forward' | 'router-forward' | 'cloudflare' | 'custom-domain';
+
+export interface CloudflareConfig {
+  customDomain?: string;
+}
+
+export interface CustomDomainConfig {
+  url?: string;
+}
+
+export interface DBSystem {
+  serverAddresses?: string[];
+  remoteAccess: {
+    mode: RemoteAccessMode;
+    cloudflare?: CloudflareConfig;
+    customDomain?: CustomDomainConfig;
+  };
+}
+
+export type DBRoles = 'master' | 'admin' | 'user';
+
+export interface DBCameraShortcut {
+  readonly _id: string;
+  cameraId: string;
+  points: Point;
+}
+
+// prettier-ignore
+export type DBUserCameraPreferences = Record<
+  string,
+  | {
+    shortcuts: DBCameraShortcut[];
+  }
+  | undefined
+>;
+
+export interface DBUserPreferences {
+  camview: {
+    views: DBCamviewLayout[];
+  };
+  cameras: DBUserCameraPreferences;
+}
+
+export type DBCamviewViewSize = 1 | 4 | 6 | 7 | 9 | 10 | 12 | 13 | 15 | 16 | 20 | 26;
+
+export interface DBCamviewLayout {
+  readonly _id: string;
+  name: string;
+  viewSize: DBCamviewViewSize;
+  cameras: DBCamviewLayoutCamera[];
+  type: CamviewSettingsLayoutMode;
+}
+
+export interface DBCamviewLayoutCamera {
+  index: number;
+  cameraId: string;
+}
+
+export type DBPluginStorageValue = Record<string, any>;
+
+export interface SystemInfo extends DBSystem {
+  networkAddresses: UsableNetworkAddress[];
+}
+
+export interface PluginData {
+  pluginName: string;
+  id?: string;
+  version?: string;
+}

package/src/api/go2rtc/api/application.ts

@@ -0,0 +1,48 @@
+import { sleep } from '@camera.ui/common/utils';
+
+import { fetchInstance } from './index.js';
+
+import type { RequestQueue } from '../queue.js';
+import type { ApplicationResponse, ExitData } from '../types.js';
+
+export class ApplicationApi {
+  private requestQueue: RequestQueue;
+
+  constructor(requestQueue: RequestQueue) {
+    this.requestQueue = requestQueue;
+  }
+
+  public async close(data: ExitData): Promise<void> {
+    try {
+      const params = new URLSearchParams(data as any);
+      await fetchInstance()(`/exit?${params}`, {
+        method: 'POST',
+      });
+    } catch {
+      // Do nothing
+    }
+  }
+
+  public async info(): Promise<ApplicationResponse> {
+    const response = await fetchInstance()('', {
+      method: 'GET',
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! Message: ${response.statusText} (${response.status})`);
+    }
+
+    const json: ApplicationResponse = await response.json();
+
+    return json;
+  }
+
+  public async restart(): Promise<void> {
+    try {
+      await fetchInstance()('/restart', { method: 'POST' });
+      await sleep(250);
+    } catch {
+      // Do nothing
+    }
+  }
+}

package/src/api/go2rtc/api/config.ts

@@ -0,0 +1,61 @@
+import { dump } from 'js-yaml';
+
+import { fetchInstance } from './index.js';
+
+import type { RequestQueue } from '../queue.js';
+
+export class ConfigApi {
+  private requestQueue: RequestQueue;
+
+  constructor(requestQueue: RequestQueue) {
+    this.requestQueue = requestQueue;
+  }
+
+  public async getConfig(): Promise<any> {
+    const response = await fetchInstance()('/config', {
+      method: 'GET',
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! Message: ${response.statusText} (${response.status})`);
+    }
+
+    return response.text();
+  }
+
+  public async rewriteConfig(data: Record<string, any>): Promise<void> {
+    if (data.streams && Object.keys(data.streams).length === 0) {
+      delete data.streams;
+    }
+
+    const config = dump(data, { lineWidth: -1, noRefs: true });
+    const response = await this.requestQueue.enqueue(() =>
+      fetchInstance()('/config', {
+        method: 'POST',
+        body: config,
+      }),
+    );
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! Message: ${response.statusText} (${response.status})`);
+    }
+  }
+
+  public async mergeConfig(data: Record<string, any>): Promise<void> {
+    if (data.streams && Object.keys(data.streams).length === 0) {
+      delete data.streams;
+    }
+
+    const config = dump(data, { lineWidth: -1, noRefs: true });
+    const response = await this.requestQueue.enqueue(() =>
+      fetchInstance()('/config', {
+        method: 'PATCH',
+        body: config,
+      }),
+    );
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! Message: ${response.statusText} (${response.status})`);
+    }
+  }
+}