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

package/src/rpc/server.ts

@@ -1,422 +0,0 @@
-import { IS_DEV, Logger, sleep } from '@camera.ui/common';
-import { strip } from 'ansicolor';
-import getPort from 'get-port';
-import { spawn } from 'node:child_process';
-import { mkdtempSync } from 'node:fs';
-import { writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { createInterface } from 'node:readline';
-import { container } from 'tsyringe';
-
-import { RUNTIME_STATUS } from '../services/config/types.js';
-
-import type { ChildProcess } from 'node:child_process';
-import type { SocketService } from '../api/websocket/index.js';
-import type { ServerRuntime } from '../api/websocket/types.js';
-import type { ConfigService } from '../services/config/index.js';
-import type { NatsConfig, NatsTLSConfig, ProxyAuth } from './types.js';
-
-const SERVER_READY_MESSAGE = 'Server is ready';
-const SERVER_ERROR_MESSAGE = 'Error listening on port';
-
-export class NATS {
-  private readonly clusterAmount = 0;
-  private readonly auth: ProxyAuth;
-
-  private _serverPort!: number;
-  private _clusterPort!: number;
-  private _wsPort!: number;
-  private _endpoints: string[] = [];
-
-  private serverProcess?: ChildProcess;
-  private clusterProcesses: ChildProcess[] = [];
-
-  private logger: Logger;
-  private configService: ConfigService;
-
-  private tmpDir: string;
-  private config: NatsConfig;
-
-  private manuallyKilled = false;
-  private shuttingDown = false;
-
-  private _status: RUNTIME_STATUS = RUNTIME_STATUS.UNKNOWN;
-
-  get status(): RUNTIME_STATUS {
-    return this._status;
-  }
-
-  get endpoints(): string[] {
-    return this._endpoints;
-  }
-
-  get serverPort(): number {
-    return this._serverPort;
-  }
-
-  get clusterPort(): number {
-    return this._clusterPort;
-  }
-
-  get wsPort(): number {
-    return this._wsPort;
-  }
-
-  constructor(auth: ProxyAuth) {
-    container.registerInstance('natsServer', this);
-
-    this.configService = container.resolve<ConfigService>('configService');
-
-    this.auth = auth;
-    this.logger = new Logger({ ...this.configService.loggerOptions, prefix: 'Nats', suffix: undefined });
-    this.tmpDir = mkdtempSync(join(this.configService.TMP_PATH, 'nats-'));
-
-    const tlsConfig: NatsTLSConfig = {
-      cert_file: this.configService.config.ssl.certFile,
-      key_file: this.configService.config.ssl.keyFile,
-      ca_file: this.configService.config.ssl.caFile,
-      timeout: 5,
-    };
-
-    this.config = {
-      host: '127.0.0.1',
-      port: 0,
-      server_name: 'camera.ui-server',
-      tls: tlsConfig,
-      cluster: {
-        name: 'camera.ui-cluster',
-        host: '127.0.0.1',
-        port: 0,
-        routes: [],
-        authorization: {
-          timeout: 5,
-          ...this.auth.cluster,
-        },
-        tls: tlsConfig,
-      },
-      authorization: {
-        timeout: 5,
-        ...this.auth.server,
-      },
-      // max_pending: 6 * 1024 * 1024, // 6MB
-      max_payload: 6 * 1024 * 1024, // 6MB
-      max_control_line: 1024 * 1024, // 1MB
-      // write_deadline: '5s',
-      disable_sublist_cache: true,
-      // no_fast_producer_stall: false,
-    };
-  }
-
-  public async start(): Promise<void> {
-    this.manuallyKilled = false;
-    this.shuttingDown = false;
-
-    this.setStatus(RUNTIME_STATUS.STARTING);
-
-    await this.configServer();
-
-    this.setStatus(RUNTIME_STATUS.STARTED);
-
-    await this.configClusters();
-
-    this.logger.debug('Nats server started and cluster formed!');
-    this.logger.log(`Nats server is running on port ${this._serverPort}`);
-  }
-
-  private async configServer(): Promise<void> {
-    this._serverPort = await getPort({ host: '127.0.0.1', ipv6Only: false });
-    this._clusterPort = await getPort({ host: '127.0.0.1', ipv6Only: false });
-    this._wsPort = IS_DEV ? this.configService.WS_PORT : await getPort({ host: '127.0.0.1', ipv6Only: false });
-
-    this._endpoints.push(`nats://127.0.0.1:${this._serverPort}`);
-
-    const config: NatsConfig = {
-      ...this.config,
-      port: this._serverPort,
-      http: IS_DEV ? 9999 : undefined,
-      cluster: {
-        ...this.config.cluster,
-        port: this._clusterPort,
-      },
-      websocket: {
-        host: '127.0.0.1',
-        port: this.wsPort,
-        authorization: {
-          username: this.auth.server.user,
-          password: this.auth.server.password,
-          timeout: 5,
-        },
-        tls: {
-          cert_file: this.configService.config.ssl.certFile,
-          key_file: this.configService.config.ssl.keyFile,
-        },
-      },
-    };
-
-    const serverConfig = await this.writeConfigFile(config, 'server');
-    await this.startServer(serverConfig);
-  }
-
-  private async configClusters(): Promise<void> {
-    for (let i = 0; i < this.clusterAmount; i++) {
-      const _clusterPort = await getPort({ host: '127.0.0.1', ipv6Only: false });
-      this._endpoints.push(`nats://127.0.0.1:${_clusterPort}`);
-
-      const config = {
-        ...this.config,
-        server_name: `camera.ui-cluster-${i}`,
-        port: _clusterPort,
-        cluster: {
-          ...this.config.cluster,
-          port: await getPort({ host: '127.0.0.1', ipv6Only: false }),
-          routes: [`nats://${this.config.cluster.authorization.user}:${this.config.cluster.authorization.password}@127.0.0.1:${this._clusterPort}`],
-        },
-      };
-
-      const clusterConfig = await this.writeConfigFile(config, `cluster-${i}`);
-      await new Promise<void>((resolve) => setTimeout(() => resolve(), 100)); // wait for port
-      await this.startClusterServer(clusterConfig);
-    }
-  }
-
-  public async stop(): Promise<void> {
-    this.manuallyKilled = true;
-
-    this.logger.log('Stopping Nats server and cluster...');
-
-    const promises = this.clusterProcesses.map((process) => this.kill(process));
-
-    if (this.serverProcess) {
-      promises.push(this.kill(this.serverProcess));
-    }
-
-    await Promise.all(promises);
-  }
-
-  public async restart(): Promise<void> {
-    this.setStatus(RUNTIME_STATUS.RESTARTING);
-
-    await this.stop();
-    await sleep(1000);
-    await this.start();
-  }
-
-  public getPID(): number {
-    return this.serverProcess?.pid ?? 0;
-  }
-
-  private async startServer(configFile: string): Promise<void> {
-    const args = ['-config', configFile];
-
-    this.logger.debug(`Starting Nats server with following command: ${this.configService.NATS_BINARY} ${args.join(' ')}`);
-
-    await new Promise<void>((resolve, reject) => {
-      this.serverProcess = spawn(this.configService.NATS_BINARY, args);
-      this.setupProcess(this.serverProcess, args, configFile, 'server', resolve, reject);
-    });
-  }
-
-  private async startClusterServer(configFile: string): Promise<void> {
-    const args = ['-config', configFile];
-
-    this.logger.debug(`Starting Nats cluster server with following command: ${this.configService.NATS_BINARY} ${args.join(' ')}`);
-
-    await new Promise<void>((resolve, reject) => {
-      const clusterProcess = spawn(this.configService.NATS_BINARY, args);
-      this.setupProcess(clusterProcess, args, configFile, 'cluster', resolve, reject);
-      this.clusterProcesses.push(clusterProcess);
-    });
-  }
-
-  private setupProcess(natsProcess: ChildProcess, args: string[], configFile: string, name: string, resolve: () => void, reject: (error: Error) => void): void {
-    let natsPID: number | undefined = undefined;
-
-    natsProcess.once('spawn', () => {
-      this.logger.log(`Initializing process with PID: ${natsProcess.pid}`);
-      natsPID = natsProcess.pid;
-
-      if (natsPID) {
-        this.configService.addProcess({
-          pid: natsPID,
-          startTime: Date.now(),
-          command: this.configService.NATS_BINARY,
-          args,
-        });
-      }
-    });
-
-    natsProcess.once('error', (error: Error) => {
-      this.logger.error(`The Nats ${name} process failed to start/stop!`, error);
-      reject(error);
-    });
-
-    natsProcess.once('exit', () => {
-      if (name === 'server') {
-        this.setStatus(RUNTIME_STATUS.STOPPED);
-        this.configService.removeProcessByPID(natsPID);
-
-        setTimeout(() => {
-          this.handleClose();
-          resolve();
-        }, 100);
-      } else {
-        this.clusterProcesses = this.clusterProcesses.filter((p) => p !== natsProcess);
-        setTimeout(() => {
-          this.handleCloseCluster(configFile);
-        }, 100);
-      }
-    });
-
-    const closeInterface = () => {
-      if (name !== 'server') {
-        stdoutLine.close();
-        stderrLine.close();
-      }
-    };
-
-    const listen = (line: string) => {
-      if (name === 'server') {
-        this.processLogger(line);
-      }
-
-      if (this.status === RUNTIME_STATUS.STARTING || this.status === RUNTIME_STATUS.STARTED) {
-        if (line.includes(SERVER_READY_MESSAGE)) {
-          resolve();
-          closeInterface();
-        } else if (line.includes(SERVER_ERROR_MESSAGE)) {
-          reject(new Error(`Error starting Nats ${name}!`));
-          closeInterface();
-        }
-      }
-    };
-
-    const stdoutLine = createInterface({
-      input: natsProcess.stdout!,
-      terminal: false,
-    });
-
-    const stderrLine = createInterface({
-      input: natsProcess.stderr!,
-      terminal: false,
-    });
-
-    stdoutLine.on('line', listen.bind(this));
-    stderrLine.on('line', listen.bind(this));
-  }
-
-  private async writeConfigFile(config: any, name: string): Promise<string> {
-    const configFile = join(this.tmpDir, `nats-server-${name}.conf`);
-    const configContent = this.stringifyConfig(config);
-    await writeFile(configFile, configContent);
-    return configFile;
-  }
-
-  private stringifyConfig(config: any, pad = ''): string {
-    const lines: string[] = [];
-    for (const key in config) {
-      if (Object.prototype.hasOwnProperty.call(config, key)) {
-        const value = config[key];
-        if (Array.isArray(value)) {
-          lines.push(`${pad}${key} [`);
-          lines.push(this.stringifyConfig(value, pad + '  '));
-          lines.push(`${pad}]`);
-        } else if (typeof value === 'object') {
-          const keyName = Array.isArray(config) ? '' : key;
-          lines.push(`${pad}${keyName} {`);
-          lines.push(this.stringifyConfig(value, pad + '  '));
-          lines.push(`${pad}}`);
-        } else {
-          const escapedValue = typeof value === 'string' ? `"${value.replace(/"/g, '\\"')}"` : value;
-          if (!Array.isArray(config)) {
-            lines.push(`${pad}${key}: ${escapedValue}`);
-          } else {
-            lines.push(pad + escapedValue);
-          }
-        }
-      }
-    }
-    return lines.join('\n');
-  }
-
-  private async kill(childProcess: ChildProcess): Promise<void> {
-    return new Promise((resolve) => {
-      const res = (): void => {
-        clearTimeout(killTimeout);
-        resolve();
-      };
-
-      childProcess.on('exit', () => {
-        res();
-      });
-      childProcess.kill('SIGKILL');
-
-      const killTimeout = setTimeout(() => res(), 3000);
-    });
-  }
-
-  private handleClose(): void {
-    if (!this.shuttingDown && !this.manuallyKilled) {
-      process.kill(process.pid, 'SIGINT');
-    }
-  }
-
-  private handleCloseCluster(configFile: string): void {
-    if (!this.shuttingDown && !this.manuallyKilled && this.status === RUNTIME_STATUS.STARTED) {
-      this.logger.log('Restarting Nats cluster in 3s...');
-
-      setTimeout(() => {
-        if (this.shuttingDown || this.manuallyKilled || this.status !== RUNTIME_STATUS.STARTED) {
-          this.logger.log('Cancelled restarting nats cluster!');
-          return;
-        }
-
-        this.startClusterServer(configFile);
-      }, 3000);
-    }
-  }
-
-  private setStatus(status: RUNTIME_STATUS): void {
-    this._status = status;
-
-    const socketService = container.resolve<SocketService>('socketService');
-
-    const runtimeInfo: ServerRuntime = {
-      nats: { name: 'nats', status: status },
-    };
-
-    socketService.io?.of('/status').emit('process-status', runtimeInfo);
-  }
-
-  private processLogger(line: string): void {
-    const blankLine = strip(line.replace(/\[(\d+)\] (\d{4}\/\d{2}\/\d{2} \d{2}:\d{2}:\d{2}\.\d{6}) /, ''));
-
-    if (this.isIgnorableString(blankLine)) {
-      return;
-    }
-
-    if (blankLine.includes('WRN')) {
-      this.logger.warn(blankLine);
-    } else if (blankLine.includes('FTL') || blankLine.includes('ERR')) {
-      this.logger.error(blankLine);
-    } else {
-      this.logger.trace(blankLine);
-    }
-  }
-
-  private isIgnorableString(line: string): boolean {
-    switch (true) {
-      case line.includes('Git:'):
-      case line.includes('Name:'):
-      case line.includes('ID:'):
-      case line.includes('Route connection created'):
-      case line.includes('Using configuration file'):
-      case line.includes('Listening for route connections'):
-      case line.includes('Cluster name is'):
-      case line.includes('Plaintext passwords detected'):
-      case line.includes('Maximum payloads over'):
-        return true;
-      default:
-        return false;
-    }
-  }
-}

package/src/rpc/types.ts

@@ -1,119 +0,0 @@
-import type { AuthConfig } from '@camera.ui/rpc-common';
-import type { Camera, CameraDevice, CameraExtension, StateValues } from '@camera.ui/types';
-import type { PluginCapabilities } from '../camera/types.js';
-
-export interface ProxyAuth {
-  cluster: AuthConfig;
-  server: AuthConfig;
-}
-
-export interface NatsAuthConfig {
-  timeout: number;
-  user: string;
-  password: string;
-}
-
-export interface NatsTLSConfig {
-  cert_file: string;
-  key_file: string;
-  ca_file: string;
-  timeout: number;
-  verify?: boolean;
-  insecure?: boolean;
-}
-
-export interface NatsWsAuthConfig {
-  timeout: number;
-  username: string;
-  password: string;
-}
-
-export interface NatsWsTLSConfig {
-  cert_file: string;
-  key_file: string;
-}
-
-export interface NatsClusterConfig {
-  host: string;
-  port: number;
-  name: string;
-  routes: string[];
-  tls: NatsTLSConfig;
-  authorization: NatsAuthConfig;
-}
-
-export interface NatsWebsocketConfig {
-  host: string;
-  port: number;
-  authorization: NatsWsAuthConfig;
-  tls: NatsWsTLSConfig;
-}
-
-export interface NatsConfig {
-  host: string;
-  port: number;
-  http?: number;
-  server_name: string;
-  cluster: NatsClusterConfig;
-  authorization: NatsAuthConfig;
-  tls: NatsTLSConfig;
-  websocket?: NatsWebsocketConfig;
-  max_pending?: number;
-  max_payload?: number;
-  max_control_line?: number;
-  disable_sublist_cache?: boolean;
-  no_fast_producer_stall?: boolean;
-  write_deadline?: string;
-}
-
-export interface DeviceManagerListenerMessagePayload {
-  type: keyof DeviceManagerProxyEventCallbacks;
-  data: DeviceManagerProxyEvents[keyof DeviceManagerProxyEvents];
-}
-
-export interface DeviceManagerProxyEvents {
-  cameraSelected: { camera: Camera; extension: CameraExtension };
-  cameraDeselected: { camera: Camera; extension: CameraExtension };
-}
-
-export interface DeviceManagerProxyEventCallbacks {
-  cameraSelected: (camera: CameraDevice, extension: CameraExtension) => void;
-  cameraDeselected: (cameraId: string, extension: CameraExtension) => void;
-}
-
-export interface DeviceManagerProxyGenericEvent<K extends keyof DeviceManagerProxyEvents> {
-  type: K;
-  data: DeviceManagerProxyEvents[K];
-}
-
-export interface CoreManagerListenerMessagePayload {
-  type: keyof CoreManagerProxyEventCallbacks;
-  data: CoreManagerProxyEvents[keyof CoreManagerProxyEvents];
-}
-
-export interface CoreManagerProxyEvents {}
-
-export interface CoreManagerProxyEventCallbacks {}
-
-export interface CoreManagerProxyGenericEvent<K extends keyof CoreManagerProxyEvents> {
-  type: K;
-  data: CoreManagerProxyEvents[K];
-}
-
-export interface CameraDeviceListenerStatePayload<K extends keyof StateValues> {
-  stateName: K;
-  data: { newEvent: StateValues[K]; oldEvent: StateValues[K] };
-}
-
-export interface CameraDeviceListenerMessagePayload {
-  type: 'removed' | 'updated' | 'cameraState' | 'frameWorkerState' | 'capabilities';
-  data?: any;
-}
-
-export interface RefreshedStates {
-  camera: Camera;
-  states: StateValues;
-  cameraState: boolean;
-  frameWorkerState: boolean;
-  capabilities: PluginCapabilities[];
-}

package/src/rpc/utils.ts

@@ -1,16 +0,0 @@
-import { randomBytes } from 'node:crypto';
-
-import type { AuthConfig } from '@camera.ui/rpc-common';
-
-export function generateCredentials(): AuthConfig {
-  const userBytes = randomBytes(8);
-  const passwordBytes = randomBytes(16);
-
-  const user = userBytes
-    .toString('base64')
-    .replace(/[+/=@:]/g, '')
-    .slice(0, 8);
-  const password = passwordBytes.toString('base64').replace(/[+/=@:]/g, '');
-
-  return { user, password };
-}

package/src/services/config/constants.ts

@@ -1,47 +0,0 @@
-import { ffmpegPath, isFFmpegAvailable } from '@camera.ui/ffmpeg';
-import { platform } from 'node:os';
-
-import {
-  DEFAULT_CONFIG_LOGGER,
-  DEFAULT_CONFIG_PLUGINS,
-  DEFAULT_CONFIG_PORT,
-  DEFAULT_CONFIG_SSL,
-  DEFAULT_GO2RTC_CONFIG_API,
-  DEFAULT_GO2RTC_CONFIG_FFMPEG,
-  DEFAULT_GO2RTC_CONFIG_LOGGER,
-  DEFAULT_GO2RTC_CONFIG_RTMP,
-  DEFAULT_GO2RTC_CONFIG_RTSP,
-  DEFAULT_GO2RTC_CONFIG_SRTP,
-  DEFAULT_GO2RTC_CONFIG_WEBRTC,
-} from './defaults.js';
-
-import type { IceServer } from '@camera.ui/types';
-import type { Go2RtcConfig, IConfig } from './types.js';
-
-export const PROCESS_IDENTIFIER = '--id=camera.ui';
-
-export const DEFAULT_ICE_SERVERS: IceServer[] = [
-  {
-    urls: ['stun:stun.l.google.com:19302'],
-  },
-];
-
-export const DEFAULT_CONFIG: IConfig = {
-  port: DEFAULT_CONFIG_PORT,
-  ssl: DEFAULT_CONFIG_SSL,
-  logger: DEFAULT_CONFIG_LOGGER,
-  plugins: DEFAULT_CONFIG_PLUGINS,
-};
-
-export const DEFAULT_GO2RTC_CONFIG: Go2RtcConfig = {
-  log: DEFAULT_GO2RTC_CONFIG_LOGGER,
-  api: DEFAULT_GO2RTC_CONFIG_API,
-  rtsp: DEFAULT_GO2RTC_CONFIG_RTSP,
-  srtp: DEFAULT_GO2RTC_CONFIG_SRTP,
-  rtmp: DEFAULT_GO2RTC_CONFIG_RTMP,
-  webrtc: DEFAULT_GO2RTC_CONFIG_WEBRTC,
-  ffmpeg: {
-    ...DEFAULT_GO2RTC_CONFIG_FFMPEG,
-    bin: !isFFmpegAvailable() ? (platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg') : ffmpegPath().replace('app.asar', 'app.asar.unpacked'),
-  },
-};

package/src/services/config/defaults.ts

@@ -1,57 +0,0 @@
-import type { API, Ffmpeg, IConfigSSL, Log, Logger, PluginsSettings, RTMP, RTSP, SRTP, Webrtc } from './types.js';
-
-// server
-export const DEFAULT_CONFIG_PORT = 3443;
-export const DEFAULT_CONFIG_SSL: IConfigSSL = {
-  certFile: '',
-  keyFile: '',
-  caFile: '',
-  addresses: ['127.0.0.1'],
-};
-export const DEFAULT_CONFIG_LOGGER: Logger = {
-  level: 'trace',
-  disableTimestamps: false,
-};
-export const DEFAULT_CONFIG_PLUGINS: PluginsSettings = {
-  disabledPlugins: [],
-};
-
-// go2rtc
-export const DEFAULT_GO2RTC_CONFIG_LOGGER: Partial<Log> = {
-  level: 'debug',
-  format: 'text',
-  hass: 'info',
-};
-export const DEFAULT_GO2RTC_CONFIG_API: API = {
-  origin: '*',
-  listen: '',
-  tls_listen: '127.0.0.1:2000',
-  tls_cert: '',
-  tls_key: '',
-  tls_ca: '',
-};
-export const DEFAULT_GO2RTC_CONFIG_RTSP: RTSP = {
-  listen: ':2001',
-  default_query: 'video=all&audio=all',
-  username: 'admin',
-  password: 'admin',
-};
-export const DEFAULT_GO2RTC_CONFIG_SRTP: SRTP = {
-  listen: '127.0.0.1:2002',
-};
-export const DEFAULT_GO2RTC_CONFIG_RTMP: RTMP = {
-  listen: '127.0.0.1:2003',
-};
-export const DEFAULT_GO2RTC_CONFIG_WEBRTC: Webrtc = {
-  listen: ':2004/tcp',
-  candidates: ['stun:2004'],
-};
-export const DEFAULT_GO2RTC_CONFIG_FFMPEG: Ffmpeg = {
-  bin: 'ffmpeg',
-  global: '-hide_banner',
-  file: '-re -stream_loop -1 -i {input}',
-  http: '-fflags +discardcorrupt+nobuffer -flags low_delay -probesize 500000 -analyzeduration 0 -avioflags direct -i {input}',
-  // eslint-disable-next-line @stylistic/max-len
-  rtsp: '-fflags +discardcorrupt+nobuffer -flags low_delay -probesize 500000 -analyzeduration 0 -avioflags direct -user_agent go2rtc/ffmpeg -rtsp_transport tcp -i {input}',
-  output: '-user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}',
-};