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

package/src/api/database/checks.ts

@@ -1,268 +0,0 @@
-import { isProcessRunning } from '@camera.ui/common';
-import { ffmpegPath } from '@camera.ui/ffmpeg';
-import fkill from 'fkill';
-import { open } from 'lmdb';
-import { exec } from 'node:child_process';
-import { constants, existsSync } from 'node:fs';
-import { access, unlink } from 'node:fs/promises';
-import { createServer } from 'node:net';
-import { promisify } from 'node:util';
-import psList from 'ps-list';
-import { container } from 'tsyringe';
-
-import type { ConfigService } from '../../services/config/index.js';
-
-export interface PathExistenceResult {
-  path: string;
-  exists: boolean;
-}
-
-export interface FFmpegExistenceResult {
-  path: string;
-  exists: boolean;
-  hasPermissions: boolean;
-  error?: Error;
-}
-
-export interface PathPermissionsResult {
-  path: string;
-  hasPermissions: boolean;
-  error?: Error;
-}
-
-export interface CleanedUpFilesResult {
-  path: string;
-  wasCleaned: boolean;
-  error?: Error;
-}
-
-export interface DatabaseCorruptionResult {
-  dbPath: string;
-  isCorrupt: boolean;
-  error?: Error;
-}
-
-export interface PortAvailabilityResult {
-  port: number;
-  isAvailable: boolean;
-}
-
-export interface OrphanedProcessesResult {
-  processInfo: ProcInfo;
-  killed?: boolean;
-  wasOrphaned?: boolean;
-  error?: Error;
-}
-
-export interface PathPermission {
-  path: string;
-  mode: number;
-}
-
-export interface ProcInfo {
-  pid: number;
-  startTime: number;
-  command: string;
-  args: string[];
-  titles?: string[];
-  uniqueId?: string;
-}
-
-const execAsync = promisify(exec);
-
-async function defaultFFmpegPath(): Promise<string | undefined> {
-  try {
-    const command = process.platform === 'win32' ? 'where ffmpeg' : 'which ffmpeg';
-    const { stdout } = await execAsync(command);
-    const ffmpegPath = stdout.trim();
-    return ffmpegPath;
-  } catch {
-    //
-  }
-}
-
-async function isPortAvailable(port: number): Promise<boolean> {
-  return new Promise((resolve) => {
-    const server = createServer();
-    server.once('error', (err: NodeJS.ErrnoException) => {
-      server.close();
-      resolve(err.code !== 'EADDRINUSE');
-    });
-    server.once('listening', () => {
-      server.close();
-      resolve(true);
-    });
-    server.listen(port);
-  });
-}
-
-async function isOwnProcess(processInfo: ProcInfo): Promise<boolean> {
-  const processes = await psList();
-  const proc = processes.find((p) => p.pid === processInfo.pid);
-
-  if (!proc) {
-    return false;
-  }
-
-  const isCommandMatch = Boolean(proc.name === processInfo.command || proc.cmd?.includes(processInfo.command));
-  const areArgsMatch = processInfo.args.every((arg) => proc.cmd?.includes(arg));
-  const idMatch = Boolean(processInfo.uniqueId ? proc.cmd?.includes(processInfo.uniqueId) : false);
-  const titleMatch = Boolean(processInfo.titles ? processInfo.titles.some((title) => proc.name?.includes(title) || proc.cmd?.includes(title)) : false);
-
-  if (idMatch || titleMatch || (isCommandMatch && areArgsMatch)) {
-    return true;
-  }
-
-  return false;
-}
-
-export async function checkPathsExist(pathsToCheck: string[]): Promise<PathExistenceResult[]> {
-  const results: PathExistenceResult[] = [];
-
-  for (const path of pathsToCheck) {
-    const exists = existsSync(path);
-    results.push({ path, exists });
-  }
-
-  return results;
-}
-
-export async function checkPathPermissions(pathsWithPermissionsToCheck: PathPermission[]): Promise<PathPermissionsResult[]> {
-  const results: PathPermissionsResult[] = [];
-
-  for (const { path, mode } of pathsWithPermissionsToCheck) {
-    try {
-      await access(path, mode);
-      results.push({ path, hasPermissions: true });
-    } catch (err) {
-      results.push({ path, hasPermissions: false, error: err as Error });
-    }
-  }
-
-  return results;
-}
-
-export async function cleanUpFiles(filesToClean: string[]): Promise<CleanedUpFilesResult[]> {
-  const cleanedFiles: CleanedUpFilesResult[] = [];
-
-  for (const file of filesToClean) {
-    try {
-      await access(file, constants.W_OK);
-      await unlink(file);
-
-      cleanedFiles.push({ path: file, wasCleaned: true });
-    } catch (err) {
-      cleanedFiles.push({ path: file, wasCleaned: false, error: err as Error });
-    }
-  }
-
-  return cleanedFiles;
-}
-
-export async function checkDatabaseCorruption(dbPath: string): Promise<DatabaseCorruptionResult> {
-  try {
-    const db = open({
-      path: dbPath,
-      readOnly: true,
-    });
-
-    await db.get('test_key');
-    await db.close();
-
-    return { dbPath, isCorrupt: false };
-  } catch (err) {
-    return { dbPath, isCorrupt: true, error: err as Error };
-  }
-}
-
-export async function checkPortAvailability(portsToCheck: number[]): Promise<PortAvailabilityResult[]> {
-  const results: PortAvailabilityResult[] = [];
-
-  for (const port of portsToCheck) {
-    const isAvailable = await isPortAvailable(port);
-    results.push({ port, isAvailable });
-  }
-
-  return results;
-}
-
-export async function checkFfmpegBinary(ffmpegPaths: string[]): Promise<PathExistenceResult[]> {
-  const results: PathExistenceResult[] = [];
-
-  for (const ffmpegPath of ffmpegPaths) {
-    try {
-      await access(ffmpegPath, constants.X_OK);
-      results.push({ exists: true, path: ffmpegPath });
-    } catch {
-      results.push({ exists: false, path: ffmpegPath });
-    }
-  }
-
-  return results;
-}
-
-export async function checkOrphanedProcesses(processInfos: ProcInfo[]): Promise<OrphanedProcessesResult[]> {
-  const configService = container.resolve<ConfigService>('configService');
-  const results: OrphanedProcessesResult[] = [];
-
-  for (const processInfo of processInfos) {
-    try {
-      const isRunning = isProcessRunning(processInfo.pid);
-      if (isRunning) {
-        const isOwnProc = await isOwnProcess(processInfo);
-        if (isOwnProc) {
-          const info: OrphanedProcessesResult = {
-            processInfo,
-            wasOrphaned: true,
-          };
-
-          try {
-            await fkill(processInfo.pid, { force: true });
-            info.killed = true;
-          } catch (error) {
-            info.killed = false;
-            info.error = error as Error;
-          }
-
-          results.push(info);
-        } else {
-          results.push({ processInfo, wasOrphaned: false });
-          configService.removeProcessByPID(processInfo.pid);
-        }
-      } else {
-        results.push({ processInfo, wasOrphaned: false });
-        configService.removeProcessByPID(processInfo.pid);
-      }
-    } catch (err) {
-      results.push({ processInfo, error: err as Error });
-    }
-  }
-
-  return results;
-}
-
-export async function checkInstalledFFmpegs(): Promise<FFmpegExistenceResult[]> {
-  const configService = container.resolve<ConfigService>('configService');
-  const results: FFmpegExistenceResult[] = [];
-
-  const osFFmpegPath = await defaultFFmpegPath();
-  const ffmpegPaths = new Set<string>([configService.go2rtcConfig.ffmpeg.binary, ffmpegPath(), osFFmpegPath].filter(Boolean) as string[]);
-
-  for (const ffmpegPath of ffmpegPaths) {
-    const exists = existsSync(ffmpegPath);
-
-    if (!exists) {
-      results.push({ path: ffmpegPath, exists, hasPermissions: false });
-      continue;
-    }
-
-    try {
-      await access(ffmpegPath, constants.X_OK);
-      results.push({ exists, path: ffmpegPath, hasPermissions: true });
-    } catch (error) {
-      results.push({ exists, path: ffmpegPath, hasPermissions: false, error: error as Error });
-    }
-  }
-
-  return results;
-}

package/src/api/database/constants.ts

@@ -1,8 +0,0 @@
-export const CAMERAS_ID = 'cameras';
-export const DATABASE_ID = 'database';
-export const PLUGINS_ID = 'plugins';
-export const USER_PLUGINS_ID = 'user-plugins';
-export const SETTINGS_ID = 'settings';
-export const USERS_ID = 'users';
-export const SYSTEM_ID = 'system';
-export const TOKENS_ID = 'tokens';

package/src/api/database/index.ts

@@ -1,262 +0,0 @@
-import { createSourceName, sleep } from '@camera.ui/common/utils';
-import { open } from 'lmdb';
-import { createHmac, randomBytes, randomUUID } from 'node:crypto';
-import semver from 'semver';
-import { container } from 'tsyringe';
-
-import { API_EVENT } from '../../api.js';
-import { CAMERAS_ID, DATABASE_ID, PLUGINS_ID, SETTINGS_ID, SYSTEM_ID, TOKENS_ID, USERS_ID } from './constants.js';
-import { DatabaseMigrationTable } from './migration.js';
-import { SelfCheck } from './selfcheck.js';
-
-import type { Database as DB, RootDatabase as RootDB } from 'lmdb';
-import type { CameraUiAPI } from '../../api.js';
-import type { ConfigService } from '../../services/config/index.js';
-import type { LoggerService } from '../../services/logger/index.js';
-import type { DBAuth, DBCamera, DBPlugin, DBSettings, DBSystem, DBUser } from './types.js';
-
-export class Database {
-  static readonly VERSION = '2.0.0';
-
-  public authDB: RootDB<DBAuth, 'auth'>;
-  public camerasDB: DB<DBCamera[], 'cameras'>;
-  public pluginsDB: DB<DBPlugin[], 'plugins'>;
-  public settingsDB: DB<DBSettings, 'settings'>;
-  public usersDB: DB<DBUser[], 'users'>;
-  public systemDB: DB<DBSystem, 'system'>;
-
-  private lowdb: RootDB;
-  private databaseMigration: DatabaseMigrationTable;
-  private selfCheck: SelfCheck;
-
-  private configService: ConfigService;
-  private logger: LoggerService;
-  private api: CameraUiAPI;
-
-  constructor() {
-    container.registerInstance('dbs', this);
-
-    this.configService = container.resolve<ConfigService>('configService');
-    this.logger = container.resolve<LoggerService>('logger');
-    this.api = container.resolve<CameraUiAPI>('api');
-    this.authDB = open({
-      path: this.configService.TOKENS_PATH,
-      name: TOKENS_ID,
-    });
-
-    this.lowdb = open({
-      path: this.configService.DATABASE_PATH,
-      name: DATABASE_ID,
-    });
-
-    this.camerasDB = this.lowdb.openDB({
-      name: CAMERAS_ID,
-    });
-
-    this.pluginsDB = this.lowdb.openDB({
-      name: PLUGINS_ID,
-    });
-
-    this.settingsDB = this.lowdb.openDB({
-      name: SETTINGS_ID,
-    });
-
-    this.usersDB = this.lowdb.openDB({
-      name: USERS_ID,
-    });
-
-    this.systemDB = this.lowdb.openDB({
-      name: SYSTEM_ID,
-    });
-
-    this.selfCheck = new SelfCheck();
-    this.databaseMigration = new DatabaseMigrationTable(this.authDB, this.camerasDB, this.pluginsDB, this.settingsDB, this.usersDB, this.systemDB);
-
-    this.logger.debug('Databases opened!');
-
-    this.api.setMaxListeners(this.api.getMaxListeners() + 1);
-    this.api.once(API_EVENT.SHUTDOWN, this.close.bind(this));
-  }
-
-  public async initialize(): Promise<void> {
-    this.logger.debug('Initializing database...');
-
-    await this.checkOldVersion();
-    await this.selfCheck.run();
-    await this.ensureDatabases();
-    await this.prepareDatabases();
-    await this.ensureMaster();
-    await this.databaseMigration.migrate();
-    this.updateConfig();
-
-    this.logger.debug('Database initialized!');
-  }
-
-  public async close(): Promise<void> {
-    await Promise.allSettled([this.authDB.close(), this.lowdb.close()]);
-    this.logger.debug('Databases closed!');
-  }
-
-  public async updateCameras(): Promise<void> {
-    const cameras = this.camerasDB.get('cameras') ?? [];
-
-    for (const camera of cameras) {
-      const go2rtcSources = Object.keys(this.configService.go2rtcConfig.streams ?? {});
-
-      for (const source of camera.sources) {
-        const sourceName = createSourceName(camera.name, source.name);
-        if (go2rtcSources.includes(sourceName)) {
-          let go2rtcUrls = this.configService.go2rtcConfig.streams?.[sourceName] ?? [];
-          go2rtcUrls = Array.isArray(go2rtcUrls) ? go2rtcUrls : [go2rtcUrls];
-          source.urls = go2rtcUrls.filter((url) => !url.includes('#cameraui'));
-        }
-      }
-    }
-
-    await this.camerasDB.put('cameras', cameras);
-  }
-
-  private async checkOldVersion(): Promise<void> {
-    const settingsDB = this.settingsDB.get('settings');
-    const oldVersion = settingsDB?.version ?? Database.VERSION;
-
-    if (semver.lt(oldVersion, '2.0.0')) {
-      this.logger.attention('Database version is too old! camera.ui will reset the database and restart!');
-
-      this.configService.reset();
-
-      await this.settingsDB.put('settings', {
-        version: Database.VERSION,
-      });
-
-      await sleep(1000);
-
-      process.exit(0);
-    }
-  }
-
-  private async ensureDatabases(): Promise<void> {
-    const authDB = this.authDB.get('auth');
-    if (!authDB) {
-      await this.authDB.put('auth', {
-        tokens: [],
-        clients: [],
-      });
-    }
-
-    const camerasDB = this.camerasDB.get('cameras');
-    if (!camerasDB) {
-      await this.camerasDB.put('cameras', []);
-    }
-
-    const usersDB = this.usersDB.get('users');
-    if (!usersDB) {
-      await this.usersDB.put('users', []);
-    }
-
-    const pluginsDB = this.pluginsDB.get('plugins');
-    if (!pluginsDB) {
-      await this.pluginsDB.put('plugins', []);
-    }
-
-    const settingsDB = this.settingsDB.get('settings');
-    if (!settingsDB) {
-      await this.settingsDB.put('settings', {
-        version: Database.VERSION,
-      });
-    }
-
-    const systemDB = this.systemDB.get('system');
-    if (!systemDB) {
-      await this.systemDB.put('system', {
-        serverAddresses: [],
-        remoteAccess: {
-          mode: 'disabled',
-          cloudflare: {},
-          customDomain: {},
-        },
-      });
-    }
-  }
-
-  private async prepareDatabases(): Promise<void> {
-    const systemDB = this.systemDB.get('system');
-    const serverAddresses = systemDB?.serverAddresses ?? [];
-    await this.configService.updateGo2RtcWebRtcFilter(serverAddresses, undefined);
-  }
-
-  private async ensureMaster(): Promise<void> {
-    const users = this.usersDB.get('users') ?? [];
-    let master = users.find((user) => user.role === 'master');
-
-    if (!master) {
-      this.logger.attention('No master found! Creating new master...');
-      master = this.generateMaster();
-      users.push(master);
-      await this.usersDB.put('users', users);
-    }
-  }
-
-  private generateMaster(): DBUser {
-    const salt = randomBytes(16).toString('base64');
-    const hash = createHmac('sha512', salt).update('admin').digest('base64');
-
-    return {
-      _id: randomUUID(),
-      avatar: 'logo-256.png',
-      username: 'admin',
-      password: salt + '$' + hash,
-      sessionTimer: 14400,
-      role: 'master',
-      rememberMe: false,
-      firstLogin: true,
-      singleSession: false,
-      preferences: {
-        camview: {
-          views: [],
-        },
-        cameras: {},
-      },
-    };
-  }
-
-  private updateConfig(): void {
-    const cameras = this.camerasDB.get('cameras') ?? [];
-
-    this.configService.go2rtcConfig.streams ??= {};
-
-    for (const camera of cameras) {
-      const go2rtcSources = Object.keys(this.configService.go2rtcConfig.streams || {});
-
-      for (const source of camera.sources) {
-        source.urls = source.urls.map((url) => {
-          if (url.startsWith('cui://')) {
-            url = `cui://127.0.0.1:${this.configService.config.port}/api/cameras/streams/${camera._id}/${source.name}`;
-          }
-          return url;
-        });
-
-        const sourceName = createSourceName(camera.name, source.name);
-        const ffmpegUrl = `ffmpeg:${sourceName}#cameraui#audio=pcma#audio=opus#audio=aac`;
-        const baseUrls = [...source.urls, ffmpegUrl];
-
-        if (!go2rtcSources.includes(sourceName)) {
-          this.configService.go2rtcConfig.streams[sourceName] = baseUrls;
-        } else {
-          let go2rtcUrls = this.configService.go2rtcConfig.streams[sourceName] ?? [];
-          go2rtcUrls = Array.isArray(go2rtcUrls) ? go2rtcUrls : [go2rtcUrls];
-
-          const hasFFmpegUrl = go2rtcUrls.some((url) => url.startsWith('ffmpeg:') && url.includes('#cameraui'));
-          if (!hasFFmpegUrl && source.role !== 'snapshot') {
-            go2rtcUrls.push(ffmpegUrl);
-          }
-
-          this.configService.go2rtcConfig.streams[sourceName] = go2rtcUrls;
-        }
-      }
-    }
-
-    // update manually go2rtc config file, because go2rtc is not running yet
-    this.configService.writeGo2RtcConfigFile();
-  }
-}

package/src/api/database/migration.ts

@@ -1,62 +0,0 @@
-import semver from 'semver';
-import { container } from 'tsyringe';
-
-import { Database } from './index.js';
-
-import type { Database as DB, RootDatabase as RootDB } from 'lmdb';
-import type { ConfigService } from '../../services/config/index.js';
-import type { LoggerService } from '../../services/logger/index.js';
-import type { DBAuth, DBCamera, DBPlugin, DBSettings, DBSystem, DBUser } from './types.js';
-
-export class DatabaseMigrationTable {
-  private logger: LoggerService;
-  private configService: ConfigService;
-
-  constructor(
-    private authDB: RootDB<DBAuth, 'auth'>,
-    private camerasDB: DB<DBCamera[], 'cameras'>,
-    private pluginsDB: DB<DBPlugin[], 'plugins'>,
-    private settingsDB: DB<DBSettings, 'settings'>,
-    private usersDB: DB<DBUser[], 'users'>,
-    private systemDB: DB<DBSystem, 'system'>,
-  ) {
-    this.logger = container.resolve<LoggerService>('logger');
-    this.configService = container.resolve<ConfigService>('configService');
-  }
-
-  public async migrate(): Promise<void> {
-    const settingsDb = this.settingsDB.get('settings')!;
-
-    const oldVersion = settingsDb.version;
-    const newVersion = Database.VERSION;
-
-    if (semver.eq(oldVersion, newVersion)) {
-      this.logger.log('Database is up to date. Version:', newVersion);
-      return;
-    }
-
-    if (semver.gt(oldVersion, newVersion)) {
-      this.logger.log(`Database version ${oldVersion} is greater than the current version ${newVersion}, skipping migration.`);
-      return;
-    }
-
-    this.logger.attention(`Database migration from ${oldVersion} to ${newVersion}`);
-
-    const migrations = this.getMigrations();
-    for (const migration of migrations) {
-      if (semver.gt(migration.version, oldVersion) && semver.lte(migration.version, newVersion)) {
-        this.logger.trace(`Applying migration to version ${migration.version}`);
-        await migration.up();
-      }
-    }
-
-    settingsDb.version = newVersion;
-    await this.settingsDB.put('settings', settingsDb);
-
-    this.logger.log('Database migration completed');
-  }
-
-  private getMigrations(): { version: string; up: () => Promise<void> }[] {
-    return [];
-  }
-}