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

package/src/api/websocket/nsp/logs.ts

@@ -0,0 +1,240 @@
+import ansiRegex from 'ansi-regex';
+import { red } from 'ansicolor';
+import { createReadStream, existsSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { Tail } from 'tail';
+import { container } from 'tsyringe';
+
+import type { EventEmitter } from 'node:events';
+import type { ReadStream } from 'node:fs';
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { CameraUiAPI } from '../../../api.js';
+import type { PluginManager } from '../../../plugins/index.js';
+import type { ConfigService } from '../../../services/config/index.js';
+import type { SocketNsp } from '../types.js';
+
+export class LogsNamespace {
+  public nsp: Namespace;
+  public nspName: SocketNsp = '/logs';
+
+  private tailInstances = new Map<string, Tail & EventEmitter>();
+
+  private api: CameraUiAPI;
+  private configService: ConfigService;
+  private pluginManager: PluginManager;
+
+  constructor(io: Server) {
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.configService = container.resolve<ConfigService>('configService');
+    this.pluginManager = container.resolve<PluginManager>('pluginManager');
+
+    this.nsp = io.of(this.nspName);
+    this.nsp.on('connection', (socket: Socket) => {
+      socket.on('get-all-logs', () => this.getAllLogs(socket));
+      socket.on('get-camera-log', (cameraName: string, options?: { sinceLastStart?: boolean }) => this.getCameraLog(socket, cameraName, options));
+      socket.on('get-plugin-log', (pluginName: string, options?: { sinceLastStart?: boolean }) => this.getPluginLog(socket, pluginName, options));
+    });
+  }
+
+  public getAllLogs(socket: Socket) {
+    const emitTo = 'stdout';
+    this.tailLogFromFileNative(socket, this.configService.LOG_FILE, emitTo);
+  }
+
+  public getCameraLog(socket: Socket, cameraName: string, options?: { sinceLastStart?: boolean }) {
+    const emitTo = `stdout/${cameraName}`;
+    const cameraController = this.api.getCamera(cameraName);
+
+    if (!cameraController) {
+      socket.emit(emitTo, red(`Camera "${cameraName}" not found.\r\n`));
+      return;
+    }
+
+    this.tailLogFromFileNative(socket, cameraController.logPath, emitTo, cameraController.camera.name, options);
+  }
+
+  public getPluginLog(socket: Socket, pluginName: string, options?: { sinceLastStart?: boolean }) {
+    const emitTo = `stdout/${pluginName}`;
+    const plugin = this.pluginManager.plugins.get(pluginName);
+
+    if (!plugin) {
+      socket.emit(emitTo, red(`Plugin "${pluginName}" not found.\r\n`));
+      return;
+    }
+
+    this.tailLogFromFileNative(socket, plugin.logPath, emitTo, plugin.displayName, options);
+  }
+
+  private async tailLogFromFileNative(socket: Socket, logFile: string, to: string, filter?: string | number, options?: { sinceLastStart?: boolean }) {
+    if (!existsSync(logFile)) {
+      socket.emit(to, red(`\r\nNo log file exists at path: ${logFile}\r\n`));
+      return;
+    }
+
+    const tailId = `${logFile}-${to}`;
+
+    try {
+      const logStats = await stat(logFile);
+      const fileContent = await this.readFileContent(logFile, logStats.size);
+
+      if (options?.sinceLastStart) {
+        const lastStartPosition = this.findLastStartPosition(fileContent);
+        if (lastStartPosition !== -1) {
+          const recentContent = fileContent.substring(lastStartPosition);
+          this.emitContent(socket, to, recentContent, filter);
+        } else {
+          const logStartPosition = logStats.size <= 50000 ? 0 : logStats.size - 50000;
+          const logStream = createReadStream(logFile, { start: logStartPosition });
+          this.handleLogStream(socket, to, logStream, filter);
+        }
+      } else {
+        const logStartPosition = logStats.size <= 50000 ? 0 : logStats.size - 50000;
+        const logStream = createReadStream(logFile, { start: logStartPosition });
+        this.handleLogStream(socket, to, logStream, filter);
+      }
+
+      this.setupTail(socket, logFile, to, tailId, filter);
+    } catch (error: any) {
+      socket.emit(to, red(`Failed to read log file: ${error.message}\r\n`));
+    }
+  }
+
+  private async readFileContent(logFile: string, size: number): Promise<string> {
+    const startPosition = size <= 50000 ? 0 : size - 50000;
+    const fd = createReadStream(logFile, { start: startPosition });
+
+    return new Promise((resolve, reject) => {
+      let content = '';
+      fd.on('data', (chunk) => {
+        content += chunk.toString();
+      });
+      fd.on('end', () => resolve(content));
+      fd.on('error', reject);
+    });
+  }
+
+  private findLastStartPosition(content: string): number {
+    const startMarkerPattern = /-{3,}\r?\n[\d/]+, [\d:]+ [AP]M:/;
+    const matches = [...content.matchAll(new RegExp(startMarkerPattern, 'g'))];
+
+    if (matches.length > 0) {
+      const lastMatch = matches[matches.length - 1];
+      return lastMatch.index || -1;
+    }
+
+    return -1;
+  }
+
+  private emitContent(socket: Socket, to: string, content: string, filter?: string | number) {
+    const lines = content.split(/\r?\n/);
+    lines.forEach((line) => {
+      if (line.trim()) {
+        let processedLine = line;
+        if (filter !== undefined) {
+          processedLine = this.filterLine(processedLine, filter);
+        }
+        socket.emit(to, processedLine + '\r\n');
+      }
+    });
+  }
+
+  private handleLogStream(socket: Socket, to: string, logStream: ReadStream, filter?: string | number) {
+    logStream.on('data', (buffer) => {
+      let line = buffer.toString().split(/\r?\n/).join('\r\n');
+      if (filter !== undefined) {
+        line = this.filterLine(line, filter);
+      }
+      socket.emit(to, line);
+    });
+
+    logStream.on('end', () => {
+      logStream.close();
+    });
+
+    logStream.on('error', (error) => {
+      socket.emit(to, red(`Error reading log file: ${error.message}\r\n`));
+      logStream.close();
+    });
+  }
+
+  private setupTail(socket: Socket, logFile: string, to: string, tailId: string, filter?: string | number) {
+    if (this.tailInstances.has(tailId)) {
+      const existingTail = this.tailInstances.get(tailId);
+      existingTail?.unwatch();
+      this.tailInstances.delete(tailId);
+    }
+
+    const tail = new Tail(logFile, {
+      fromBeginning: false,
+      useWatchFile: true,
+      fsWatchOptions: {
+        interval: 200,
+      },
+    }) as Tail & EventEmitter;
+
+    this.tailInstances.set(tailId, tail);
+
+    const onLine = (line: string) => {
+      let processedLine = line.toString().split(/\r?\n/).join('\r\n');
+      if (filter !== undefined) {
+        processedLine = this.filterLine(processedLine, filter);
+      }
+      socket.emit(to, processedLine + '\r\n');
+    };
+
+    const onError = (error: Error | string) => {
+      let errorLine = error.toString().split(/\r?\n/).join('\r\n');
+      if (filter !== undefined) {
+        errorLine = this.filterLine(errorLine, filter);
+      }
+      socket.emit(to, red(errorLine + '\r\n'));
+    };
+
+    tail.on('line', onLine);
+    tail.on('error', onError);
+
+    const cleanup = () => {
+      tail.removeListener('line', onLine);
+      tail.removeListener('error', onError);
+      tail.unwatch();
+      this.tailInstances.delete(tailId);
+
+      socket.removeAllListeners('end');
+      socket.removeAllListeners('disconnect');
+    };
+
+    socket.on('end', cleanup);
+    socket.on('disconnect', cleanup);
+  }
+
+  private filterLine(line: string, filter: string | number): string {
+    if (typeof filter === 'string') {
+      return this.removeName(line, filter);
+    } else {
+      return this.removeBracketedContent(line, filter);
+    }
+  }
+
+  private removeName(str: string, cameraName: string) {
+    const escapeRegex = (string: string) => string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedCameraName = escapeRegex(cameraName);
+    const regex = new RegExp(`(${ansiRegex().source}\\s*\\[${escapedCameraName}\\]\\s*${ansiRegex().source})`, 'g');
+
+    return str
+      .replace(regex, ' ')
+      .replace(/[^\S\r\n]+/g, ' ')
+      .replace(/^[^\S\r\n]+|[^\S\r\n]+$/gm, '');
+  }
+
+  private removeBracketedContent(str: string, n: number) {
+    let count = 0;
+    const regex = new RegExp(`(${ansiRegex().source}\\s*\\[[^\\]]+\\]\\s*${ansiRegex().source})`, 'g');
+
+    const replacedStr = str.replace(regex, (match) => {
+      count++;
+      return count === n ? ' ' : match;
+    });
+
+    return replacedStr.replace(/[^\S\r\n]+/g, ' ').replace(/^[^\S\r\n]+|[^\S\r\n]+$/gm, '');
+  }
+}

package/src/api/websocket/nsp/main.ts

@@ -0,0 +1,27 @@
+import { container } from 'tsyringe';
+
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { CameraUi } from '../../../main.js';
+import type { SocketNsp } from '../types.js';
+
+export class MainNamespace {
+  public nsp: Namespace;
+  public nspName: SocketNsp = '/camera.ui';
+
+  private cameraui: CameraUi;
+
+  constructor(io: Server) {
+    this.cameraui = container.resolve<CameraUi>('cameraui');
+
+    this.nsp = io.of(this.nspName);
+    this.nsp.on('connection', (socket: Socket) => {
+      socket.on('get-status', this.getStatus.bind(this));
+    });
+  }
+
+  public async getStatus(payload: any, callback?: Function): Promise<'loading' | 'ready'> {
+    const status = this.cameraui.status;
+    callback?.(status);
+    return status;
+  }
+}

package/src/api/websocket/nsp/metrics.ts

@@ -0,0 +1,301 @@
+import { cpus, loadavg, platform } from 'node:os';
+import { currentLoad, mem, processes } from 'systeminformation';
+import { container } from 'tsyringe';
+
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { Systeminformation } from 'systeminformation';
+import type { CameraUiAPI } from '../../../api.js';
+import type { Go2Rtc } from '../../../go2rtc/index.js';
+import type { PluginManager } from '../../../plugins/index.js';
+import type { NATS } from '../../../rpc/server.js';
+import type { AllProcesses, ProcessInfo, ProcessType, ServerProcesses, SocketNsp, WorkerProcesses } from '../types.js';
+
+export class MetricsNamespace {
+  public nsp: Namespace;
+  public nspName: SocketNsp = '/metrics';
+
+  private readonly HISTORY_INTERVAL = 60000;
+  private readonly REALTIME_INTERVAL = 5000;
+  private readonly MAX_HISTORY_POINTS = 60;
+
+  private api: CameraUiAPI;
+  private pluginManager: PluginManager;
+  private go2rtc: Go2Rtc;
+  private natsServer: NATS;
+
+  private history = {
+    system: [] as ProcessInfo[],
+    processes: {
+      'camera.ui': [] as ProcessInfo[],
+      go2rtc: [] as ProcessInfo[],
+      nats: [] as ProcessInfo[],
+    },
+    plugins: {} as WorkerProcesses,
+    frameWorkers: {} as WorkerProcesses,
+  };
+
+  private realtimeData: { system: ProcessInfo | null; processes: AllProcesses | null } = {
+    system: null,
+    processes: null,
+  };
+
+  constructor(io: Server) {
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.pluginManager = container.resolve<PluginManager>('pluginManager');
+    this.go2rtc = container.resolve<Go2Rtc>('go2rtc');
+    this.natsServer = container.resolve<NATS>('natsServer');
+
+    if (platform() === 'freebsd') {
+      // eslint-disable-next-line @typescript-eslint/unbound-method
+      this.getSystemLoad = this.getSystemLoadAlt;
+    }
+
+    this.nsp = io.of(this.nspName);
+    this.nsp.on('connection', (socket: Socket) => {
+      socket.on('get-system-info', this.handleGetSystemInfo.bind(this));
+      socket.on('get-server-process-info', this.handleGetServerProcessInfo.bind(this));
+      socket.on('get-plugins-process-info', this.handleGetPluginsProcessInfo.bind(this));
+      socket.on('get-frameworker-process-info', this.handleGetFrameWorkerProcessInfo.bind(this));
+
+      if (this.realtimeData.system) {
+        socket.emit('system-infos-realtime', this.realtimeData.system);
+      }
+      if (this.realtimeData.processes) {
+        socket.emit('process-infos-realtime', this.realtimeData.processes);
+      }
+    });
+
+    this.setupIntervals();
+  }
+
+  private setupIntervals(): void {
+    setInterval(async () => {
+      let processData = this.realtimeData.processes;
+      let systemData = this.realtimeData.system;
+
+      if (!processData || !systemData) {
+        [processData, systemData] = await Promise.all([this.collectProcessData(), this.getSystemLoad()]);
+      }
+
+      this.updateHistory(processData, systemData);
+      this.emitHistoryUpdates(processData, systemData);
+    }, this.HISTORY_INTERVAL);
+
+    setInterval(async () => {
+      const [processData, systemData] = await Promise.all([this.collectProcessData(), this.getSystemLoad()]);
+
+      this.realtimeData = {
+        system: systemData,
+        processes: processData,
+      };
+
+      if (this.shouldUpdateHistory()) {
+        this.updateHistory(processData, systemData);
+      }
+
+      this.emitRealtimeUpdates(processData, systemData);
+    }, this.REALTIME_INTERVAL);
+
+    this.collectInitialData();
+  }
+
+  private async collectInitialData(): Promise<void> {
+    const [processData, systemData] = await Promise.all([this.collectProcessData(), this.getSystemLoad()]);
+
+    this.updateHistory(processData, systemData);
+    this.realtimeData = {
+      system: systemData,
+      processes: processData,
+    };
+  }
+
+  private async collectProcessData(): Promise<AllProcesses> {
+    const allProcesses = await processes();
+    const currentTime = Date.now();
+    const processList = allProcesses.list;
+
+    const createProcessInfo = (process: Systeminformation.ProcessesProcessData, name: string, type: ProcessType): ProcessInfo => ({
+      name,
+      type,
+      pid: process.pid,
+      cpuLoad: (process.cpu || 0.1).toFixed(2),
+      memLoad: (process.mem || 0.1).toFixed(2),
+      timestamp: currentTime,
+    });
+
+    const serverProcess = processList.find((p) => p.pid === process.pid);
+    const go2rtcProcess = processList.find((p) => p.pid === this.go2rtc.getPID());
+    const natsProcess = processList.find((p) => p.pid === this.natsServer.getPID());
+
+    const plugins = Array.from(this.pluginManager.plugins);
+    const pluginProcesses = Object.fromEntries(
+      plugins
+        .map(([name, plugin]) => {
+          const proc = processList.find((p) => p.pid === plugin.worker.getPID());
+          return proc ? [name, createProcessInfo(proc, name, 'plugin')] : undefined;
+        })
+        .filter((entry): entry is [string, ProcessInfo] => entry !== undefined),
+    );
+
+    const cameraControllers = this.api.getCameras();
+    const frameWorkerProcesses = Object.fromEntries(
+      cameraControllers
+        .map((controller) => {
+          const proc = processList.find((p) => p.pid === controller.frameWorker.getPID());
+          return proc ? [controller.frameWorker.name, createProcessInfo(proc, controller.frameWorker.name, 'frameworker')] : null;
+        })
+        .filter((entry): entry is [string, ProcessInfo] => entry !== null),
+    );
+
+    return {
+      'camera.ui': serverProcess ? createProcessInfo(serverProcess, 'camera.ui', 'core') : this.defaultProcessInfo('camera.ui', 'core'),
+      go2rtc: go2rtcProcess ? createProcessInfo(go2rtcProcess, 'go2rtc', 'core') : this.defaultProcessInfo('go2rtc', 'core'),
+      nats: natsProcess ? createProcessInfo(natsProcess, 'nats', 'core') : this.defaultProcessInfo('nats', 'core'),
+      plugins: pluginProcesses,
+      workers: frameWorkerProcesses,
+    };
+  }
+
+  private async getSystemLoad(): Promise<ProcessInfo> {
+    const load = (await currentLoad()).currentLoad;
+    const memory = await mem();
+    const memoryFreePercent = ((memory.total - memory.available) / memory.total) * 100;
+
+    return {
+      name: 'system',
+      type: 'system',
+      cpuLoad: load.toFixed(2),
+      memLoad: memoryFreePercent.toFixed(2),
+      timestamp: Date.now(),
+    };
+  }
+
+  private async getSystemLoadAlt(): Promise<ProcessInfo> {
+    const load = (loadavg()[0] * 100) / cpus().length;
+    const memory = await mem();
+    const memoryFreePercent = ((memory.total - memory.available) / memory.total) * 100;
+
+    return {
+      name: 'system',
+      type: 'system',
+      cpuLoad: load.toFixed(2),
+      memLoad: memoryFreePercent.toFixed(2),
+      timestamp: Date.now(),
+    };
+  }
+
+  private updateHistory(processData: AllProcesses, systemData: ProcessInfo): void {
+    this.history.system.push(systemData);
+    this.history.system = this.history.system.slice(-this.MAX_HISTORY_POINTS);
+
+    if (processData['camera.ui']) {
+      this.history.processes['camera.ui'].push(processData['camera.ui']);
+      this.history.processes['camera.ui'] = this.history.processes['camera.ui'].slice(-this.MAX_HISTORY_POINTS);
+    }
+    if (processData.go2rtc) {
+      this.history.processes.go2rtc.push(processData.go2rtc);
+      this.history.processes.go2rtc = this.history.processes.go2rtc.slice(-this.MAX_HISTORY_POINTS);
+    }
+    if (processData.nats) {
+      this.history.processes.nats.push(processData.nats);
+      this.history.processes.nats = this.history.processes.nats.slice(-this.MAX_HISTORY_POINTS);
+    }
+
+    Object.entries(processData.plugins || {}).forEach(([name, info]) => {
+      if (!this.history.plugins[name]) {
+        this.history.plugins[name] = [];
+      }
+      this.history.plugins[name].push(info);
+      this.history.plugins[name] = this.history.plugins[name].slice(-this.MAX_HISTORY_POINTS);
+    });
+
+    Object.entries(processData.workers || {}).forEach(([name, info]) => {
+      if (!this.history.frameWorkers[name]) {
+        this.history.frameWorkers[name] = [];
+      }
+      this.history.frameWorkers[name].push(info);
+      this.history.frameWorkers[name] = this.history.frameWorkers[name].slice(-this.MAX_HISTORY_POINTS);
+    });
+
+    this.cleanupOrphanedEntries(processData);
+  }
+
+  private cleanupOrphanedEntries(currentData: AllProcesses): void {
+    Object.keys(this.history.plugins).forEach((name) => {
+      if (!currentData.plugins?.[name]) {
+        delete this.history.plugins[name];
+      }
+    });
+
+    Object.keys(this.history.frameWorkers).forEach((name) => {
+      if (!currentData.workers?.[name]) {
+        delete this.history.frameWorkers[name];
+      }
+    });
+  }
+
+  private emitHistoryUpdates(processData: AllProcesses, systemData: ProcessInfo): void {
+    if (!this.hasConnectedClients()) {
+      return;
+    }
+
+    this.nsp.emit('process-infos', processData);
+    this.nsp.emit('system-infos', systemData);
+  }
+
+  private emitRealtimeUpdates(processData: AllProcesses, systemData: ProcessInfo): void {
+    if (!this.hasConnectedClients()) {
+      return;
+    }
+
+    this.nsp.emit('process-infos-realtime', processData);
+    this.nsp.emit('system-infos-realtime', systemData);
+  }
+
+  private async handleGetSystemInfo(payload: any, callback?: Function): Promise<ProcessInfo[]> {
+    callback?.(this.history.system);
+    return this.history.system;
+  }
+
+  private async handleGetServerProcessInfo(payload: any, callback?: Function): Promise<ServerProcesses> {
+    const data: ServerProcesses = {
+      'camera.ui': this.history.processes['camera.ui'],
+      go2rtc: this.history.processes.go2rtc,
+      nats: this.history.processes.nats,
+    };
+    callback?.(data);
+    return data;
+  }
+
+  private async handleGetPluginsProcessInfo(payload: any, callback?: Function): Promise<WorkerProcesses> {
+    callback?.(this.history.plugins);
+    return this.history.plugins;
+  }
+
+  private async handleGetFrameWorkerProcessInfo(payload: any, callback?: Function): Promise<WorkerProcesses> {
+    callback?.(this.history.frameWorkers);
+    return this.history.frameWorkers;
+  }
+
+  private hasConnectedClients(): boolean {
+    return this.nsp.sockets.size > 0;
+  }
+
+  private defaultProcessInfo(name: string, type: ProcessType): ProcessInfo {
+    return {
+      name,
+      type,
+      pid: -1,
+      cpuLoad: '0.00',
+      memLoad: '0.00',
+      timestamp: 0,
+    };
+  }
+
+  private shouldUpdateHistory(): boolean {
+    return (
+      (Object.keys(this.history.plugins).length === 0 && this.pluginManager.plugins.size > 0) ||
+      (Object.keys(this.history.frameWorkers).length === 0 && this.api.getCameras().length > 0)
+    );
+  }
+}

package/src/api/websocket/nsp/notifications.ts

@@ -0,0 +1,43 @@
+import { container } from 'tsyringe';
+
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { LoggerService } from '../../../services/logger/index.js';
+import type { UiNotification } from '../../types/index.js';
+import type { SocketNsp } from '../types.js';
+
+export class NotificationsNamespace {
+  public nsp: Namespace;
+  public nspName: SocketNsp = '/notifications';
+
+  private logger: LoggerService;
+
+  constructor(io: Server) {
+    this.logger = container.resolve<LoggerService>('logger');
+
+    this.nsp = io.of(this.nspName);
+    this.nsp.on('connection', (socket: Socket) => {
+      socket.on('get-notifications', this.getNotifications.bind(this));
+      socket.on('remove-notification', (id: string) => this.removeNotification(id));
+      socket.on('clear-notifications', this.clearNotifications.bind(this));
+    });
+  }
+
+  public clearNotifications(): void {
+    this.logger.notifications.splice(0, this.logger.notifications.length);
+  }
+
+  public getNotifications(payload: any, callback?: Function): UiNotification[] {
+    const notifications = this.logger.notifications;
+
+    callback?.(notifications);
+    return notifications;
+  }
+
+  public removeNotification(id?: string): void {
+    const notificationIndex = this.logger.notifications.findIndex((notification) => notification._id === id);
+
+    if (notificationIndex !== -1) {
+      this.logger.notifications.splice(notificationIndex, 1);
+    }
+  }
+}

package/src/api/websocket/nsp/plugins.ts

@@ -0,0 +1,37 @@
+import { container } from 'tsyringe';
+
+import type { Namespace, Server, Socket } from 'socket.io';
+import type { PluginManager } from '../../../plugins/index.js';
+import type { PLUGIN_STATUS } from '../../../plugins/types.js';
+import type { SocketNsp } from '../types.js';
+
+export class PluginsNamespace {
+  public nsp: Namespace;
+  public nspName: SocketNsp = '/plugins';
+
+  private pluginManager: PluginManager;
+
+  constructor(io: Server) {
+    this.pluginManager = container.resolve<PluginManager>('pluginManager');
+
+    this.nsp = io.of(this.nspName);
+    this.nsp.on('connection', (socket: Socket) => {
+      socket.on('get-plugin-status', this.pluginStatus.bind(this));
+    });
+  }
+
+  public async pluginStatus(pluginName: string, callback?: Function): Promise<void | { pluginName: string; status: PLUGIN_STATUS }> {
+    const plugin = this.pluginManager.plugins.get(pluginName);
+
+    if (plugin) {
+      const status = plugin.worker.status;
+      const data = {
+        pluginName,
+        status,
+      };
+
+      callback?.(data);
+      return data;
+    }
+  }
+}