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

package/src/rpc/server.ts

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

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

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

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

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