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

package/src/api/database/selfcheck.ts

@@ -1,492 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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})`);
-    }
-  }
-}