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

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

@@ -1,220 +0,0 @@
-import { APP_SERVER_NAME } from '@camera.ui/common';
-import { getNpmPath } from '@camera.ui/common/node';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import semver, { gt, parse } from 'semver';
-import { container } from 'tsyringe';
-
-import { ConfigService } from '../../../services/config/index.js';
-import { PluginsService } from '../../services/plugins.service.js';
-import { fetchWithTimeout } from '../../utils/fetch.js';
-
-import type { Namespace, Server, Socket } from 'socket.io';
-import type { LoggerService } from '../../../services/logger/index.js';
-import type { CameraUiPlugin, INpmPluginState, INpmRegistryModule, IPackageJson } from '../../types/index.js';
-import type { SocketNsp } from '../types.js';
-
-const execAsync = promisify(exec);
-
-export class ServerNamespace {
-  public nsp: Namespace;
-  public nspName: SocketNsp = '/server';
-
-  private logger: LoggerService;
-  private pluginsService: PluginsService;
-
-  private serverUpdate: INpmPluginState = {
-    updateAvailable: false,
-    betaUpdateAvailable: false,
-  };
-
-  private pluginUpdates: INpmPluginState[] = [];
-
-  private checkPluginUpdateInterval: NodeJS.Timeout | undefined;
-  private checkServerUpdateInterval: NodeJS.Timeout | undefined;
-
-  constructor(io: Server) {
-    this.logger = container.resolve<LoggerService>('logger');
-    this.pluginsService = new PluginsService();
-
-    this.nsp = io.of(this.nspName);
-    this.nsp.on('connection', (socket: Socket) => {
-      socket.on('get-updates', this.getUpdates.bind(this));
-    });
-
-    this.checkPlugins();
-    this.checkServer();
-  }
-
-  public getUpdates(payload?: any, callback?: Function): { server?: INpmPluginState; plugins: INpmPluginState[] } {
-    const data = {
-      server: this.serverUpdate,
-      plugins: this.pluginUpdates,
-    };
-
-    callback?.(data);
-    return data;
-  }
-
-  public async checkPlugins(interval?: boolean): Promise<void> {
-    const pluginUpdatesSize = this.pluginUpdates.length;
-
-    await this.checkPluginUpdates();
-
-    if (this.pluginUpdates.length > 0) {
-      if (!pluginUpdatesSize || interval) {
-        const notification = this.logger.createNotification('plugin-update', 'Plugin Update', 'New plugin updates available', 'info', '/plugins');
-        this.nsp.emit('plugins-updates', this.pluginUpdates);
-        this.logger.notify(notification);
-      }
-
-      this.restartPluginInterval(10 * 60 * 1000);
-    } else {
-      this.logger.removeNotification('plugin-update', true);
-
-      this.restartPluginInterval();
-    }
-  }
-
-  public async checkServer(interval?: boolean): Promise<void> {
-    const serverUpdate = this.serverUpdate.latestVersion;
-
-    await this.checkServerUpdate();
-
-    if (this.serverUpdate.latestVersion) {
-      if (!serverUpdate || interval) {
-        const notification = this.logger.createNotification('system-update', 'Update', 'New camera.ui udate available', 'info', '/settings/system');
-        this.nsp.emit('server-updates', this.serverUpdate);
-        this.logger.notify(notification);
-      }
-
-      this.restartServerInterval(10 * 60 * 1000);
-    } else {
-      this.logger.removeNotification('system-update', true);
-      this.restartServerInterval();
-    }
-  }
-
-  private async checkServerUpdate(): Promise<void> {
-    try {
-      // TODO: Change on release
-      const npmPath = getNpmPath().join(' ');
-      const { stdout, stderr } = await execAsync(`${npmPath} view ${APP_SERVER_NAME} versions dist-tags --json`);
-
-      if (stderr) {
-        return;
-      }
-
-      const data: { versions: string[]; 'dist-tags': { latest: string; alpha: string } } = JSON.parse(stdout);
-
-      const currentVersion = ConfigService.VERSION;
-      const latestVersion = data['dist-tags'].latest;
-      const latestAlpha = data['dist-tags'].alpha;
-
-      const updateAvailableLatest = semver.gt(latestVersion, currentVersion);
-      const updateAvailableAlpha = semver.gt(latestAlpha, currentVersion);
-      const updateAvailable = updateAvailableLatest ? latestVersion : updateAvailableAlpha ? latestAlpha : undefined;
-
-      this.serverUpdate = {
-        updateAvailable: updateAvailableLatest,
-        betaUpdateAvailable: updateAvailableAlpha,
-        latestVersion: updateAvailable,
-      };
-    } catch {
-      //
-    }
-  }
-
-  private async checkPluginUpdates(): Promise<void> {
-    try {
-      const plugins = this.pluginsService.listPlugins();
-      const pluginStates: INpmPluginState[] = [];
-
-      for (const plugin of plugins) {
-        const pluginState = await this.getPluginFromNpm(plugin.info);
-
-        if (pluginState.updateAvailable || pluginState.betaUpdateAvailable) {
-          pluginStates.push(pluginState);
-        }
-      }
-
-      this.pluginUpdates = pluginStates;
-    } catch {
-      //
-    }
-  }
-
-  private async getPluginFromNpm(plugin: CameraUiPlugin): Promise<INpmPluginState> {
-    const pluginState: INpmPluginState = {
-      updateAvailable: false,
-      betaUpdateAvailable: false,
-    };
-
-    try {
-      const response = await fetchWithTimeout(`https://registry.npmjs.org/${encodeURIComponent(plugin.pluginName).replace(/%40/g, '@')}/latest`, {
-        method: 'GET',
-      });
-
-      if (!response.ok) {
-        throw new Error('Failed to fetch plugin');
-      }
-
-      const pkg = (await response.json()) as IPackageJson;
-
-      pluginState.latestVersion = pkg.version;
-      pluginState.updateAvailable = gt(pkg.version, plugin.installedVersion!);
-
-      // check for beta updates, if no latest version is available
-      if (!pluginState.updateAvailable) {
-        const pluginVersion = parse(plugin.installedVersion);
-        if (pluginVersion?.prerelease[0] === 'beta' && gt(plugin.installedVersion!, pluginState.latestVersion || '0.0.1')) {
-          const versions = await this.getAvailablePluginVersions(plugin.pluginName);
-          if (versions.tags.beta && gt(versions.tags.beta, plugin.installedVersion!)) {
-            pluginState.betaUpdateAvailable = true;
-            pluginState.latestVersion = versions.tags.beta;
-          }
-        }
-      }
-    } catch {
-      pluginState.latestVersion = undefined;
-      pluginState.updateAvailable = false;
-      pluginState.betaUpdateAvailable = false;
-    }
-
-    return pluginState;
-  }
-
-  private async getAvailablePluginVersions(pluginName: string): Promise<{ tags: Record<string, string>; versions: string[] }> {
-    const response = await fetchWithTimeout(`https://registry.npmjs.org/${encodeURIComponent(pluginName).replace(/%40/g, '@')}`, {
-      method: 'GET',
-      headers: {
-        accept: 'application/vnd.npm.install-v1+json', // only return minimal information
-      },
-    });
-
-    if (!response.ok) {
-      throw new Error('Failed to fetch plugin');
-    }
-
-    const pkg = (await response.json()) as INpmRegistryModule;
-
-    return {
-      tags: pkg['dist-tags'],
-      versions: Object.keys(pkg.versions).reverse(),
-    };
-  }
-
-  public restartPluginInterval(timer = 20000): void {
-    clearInterval(this.checkPluginUpdateInterval);
-    this.checkPluginUpdateInterval = setInterval(() => {
-      this.checkPlugins(true);
-    }, timer);
-  }
-
-  public restartServerInterval(timer = 20000): void {
-    clearInterval(this.checkServerUpdateInterval);
-    this.checkServerUpdateInterval = setInterval(() => {
-      this.checkServer(true);
-    }, timer);
-  }
-}

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

@@ -1,77 +0,0 @@
-import { container } from 'tsyringe';
-import { RUNTIME_STATUS } from '../../../services/config/types.js';
-
-import type { Namespace, Server, Socket } from 'socket.io';
-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 { ConfigService } from '../../../services/config/index.js';
-import type { ServerRuntime, SocketNsp, WorkerRuntime } from '../types.js';
-
-export class StatusNamespace {
-  public nsp: Namespace;
-  public nspName: SocketNsp = '/status';
-
-  private api: CameraUiAPI;
-  private configService: ConfigService;
-  private pluginManager: PluginManager;
-  private go2rtc: Go2Rtc;
-  private natsServer: NATS;
-
-  constructor(io: Server) {
-    this.api = container.resolve<CameraUiAPI>('api');
-    this.configService = container.resolve<ConfigService>('configService');
-    this.pluginManager = container.resolve<PluginManager>('pluginManager');
-    this.go2rtc = container.resolve<Go2Rtc>('go2rtc');
-    this.natsServer = container.resolve<NATS>('natsServer');
-
-    this.nsp = io.of(this.nspName);
-    this.nsp.on('connection', (socket: Socket) => {
-      socket.on('get-process-status', this.watchStats.bind(this, socket));
-      socket.on('get-plugin-process-status', this.watchPluginStats.bind(this, socket));
-      socket.on('get-frameworker-process-status', this.watchFrameWorkerStats.bind(this, socket));
-    });
-  }
-
-  public watchStats(socket: Socket, payload: any, callback?: Function): ServerRuntime {
-    const runtimeStatus: ServerRuntime = {
-      'camera.ui': { name: 'camera.ui', status: RUNTIME_STATUS.STARTED },
-      go2rtc: { name: 'go2rtc', status: this.go2rtc.status },
-      nats: { name: 'nats', status: this.natsServer.status },
-    };
-
-    socket.emit('process-status', runtimeStatus);
-
-    callback?.(runtimeStatus);
-    return runtimeStatus;
-  }
-
-  public watchPluginStats(socket: Socket, payload: any, callback?: Function): WorkerRuntime {
-    const pluginWorkers: WorkerRuntime = {};
-
-    Array.from(this.pluginManager.plugins).map(([pluginName, plugin]) => {
-      pluginWorkers[pluginName] = { name: pluginName, status: plugin.worker.status };
-    });
-
-    socket.emit('plugin-process-status', pluginWorkers);
-
-    callback?.(pluginWorkers);
-    return pluginWorkers;
-  }
-
-  public watchFrameWorkerStats(socket: Socket, payload: any, callback?: Function): WorkerRuntime {
-    const frameWorkers: WorkerRuntime = {};
-
-    const cameraControllers = this.api.getCameras();
-    cameraControllers.forEach((cameraController) => {
-      const frameWorker = cameraController.frameWorker;
-      frameWorkers[frameWorker.name] = { name: frameWorker.name, status: frameWorker.status };
-    });
-
-    socket.emit('frameworker-process-status', frameWorkers);
-
-    callback?.(frameWorkers);
-    return frameWorkers;
-  }
-}

package/src/api/websocket/types.ts

@@ -1,55 +0,0 @@
-import type { Namespace } from 'socket.io';
-import type { PLUGIN_STATUS } from '../../plugins/types.js';
-import type { RuntimeInfo } from '../../services/config/types.js';
-
-export type SocketNsp = '/camera.ui' | '/metrics' | '/logs' | '/status' | '/notifications' | '/plugins' | '/server';
-
-export interface SocketNspMap {
-  nsp: Namespace;
-  [key: string]: any;
-}
-
-export type ProcessType = 'system' | 'core' | 'frameworker' | 'plugin';
-
-export interface ProcessInfo {
-  name: string;
-  pid?: number;
-  cpuLoad: string;
-  memLoad: string;
-  type: ProcessType;
-  timestamp: number;
-}
-
-export interface ServerProcessInfo {
-  'camera.ui': ProcessInfo;
-  go2rtc: ProcessInfo;
-  nats: ProcessInfo;
-}
-
-export interface ServerProcesses {
-  'camera.ui': ProcessInfo[];
-  go2rtc: ProcessInfo[];
-  nats: ProcessInfo[];
-}
-
-export type WorkerProcessInfo = Record<string, ProcessInfo>;
-
-export type WorkerProcesses = Record<string, ProcessInfo[]>;
-
-export interface AllProcesses extends ServerProcessInfo {
-  plugins: WorkerProcessInfo;
-  workers: WorkerProcessInfo;
-}
-
-export interface PluginRuntimeInfo {
-  name: string;
-  status: PLUGIN_STATUS;
-}
-
-export interface ServerRuntime {
-  'camera.ui'?: RuntimeInfo;
-  go2rtc?: RuntimeInfo;
-  nats?: RuntimeInfo;
-}
-
-export type WorkerRuntime = Record<string, PluginRuntimeInfo>;

package/src/api.ts

@@ -1,163 +0,0 @@
-import 'reflect-metadata';
-
-import { EventEmitter } from 'node:events';
-import { container } from 'tsyringe';
-
-import { CamerasService } from './api/services/cameras.service.js';
-import { PluginsService } from './api/services/plugins.service.js';
-import { CameraController } from './camera/controller.js';
-
-import type { Camera, CameraExtension, CameraExtensions } from '@camera.ui/types';
-import type { Plugin } from './plugins/plugin.js';
-import type { ProxyServer } from './rpc/index.js';
-import type { LoggerService } from './services/logger/index.js';
-
-export enum API_EVENT {
-  FINISH_LAUNCHING = 'finishLaunching',
-  SHUTDOWN = 'shutdown',
-}
-
-export declare interface CameraUiAPI {
-  on(event: 'finishLaunching', listener: () => void): this;
-  on(event: 'shutdown', listener: () => void): this;
-
-  emit(event: 'finishLaunching'): boolean;
-  emit(event: 'shutdown'): boolean;
-}
-
-export class CameraUiAPI extends EventEmitter {
-  private cameraControllers = new Map<string, CameraController>();
-
-  constructor() {
-    super();
-
-    container.registerInstance('api', this);
-  }
-
-  public async configureCameras(): Promise<void> {
-    const camerasService = new CamerasService();
-    const cameras = camerasService.listTransformed();
-    // for (const camera of cameras) {
-    //   await this.addCamera(camera);
-    // }
-    await Promise.all(cameras.map((camera) => this.addCamera(camera)));
-  }
-
-  public async addCamera(camera: Camera): Promise<CameraController> {
-    let cameraController = this.cameraControllers.get(camera._id);
-
-    if (!cameraController) {
-      const logger = container.resolve<LoggerService>('logger');
-      const cameraLogger = logger.createLogger({ prefix: camera.name });
-
-      cameraController = new CameraController(camera, cameraLogger);
-      await cameraController.init();
-
-      this.cameraControllers.set(camera._id, cameraController);
-    }
-
-    return cameraController;
-  }
-
-  public getCamera(cameraIdOrName: string): CameraController | undefined {
-    let cameraController = this.cameraControllers.get(cameraIdOrName);
-
-    if (!cameraController) {
-      const cameras = Array.from(this.cameraControllers.values());
-      cameraController = cameras.find((cc) => cc.name === cameraIdOrName);
-    }
-
-    return cameraController;
-  }
-
-  public getCameras(pluginId?: string): CameraController[] {
-    const cameraController = Array.from(this.cameraControllers.values());
-
-    if (pluginId) {
-      return cameraController.filter((cc) => cc.pluginId === pluginId);
-    }
-
-    return cameraController;
-  }
-
-  public resetCameraState(cameraId: string, extension: CameraExtension): void {
-    const cameraController = this.cameraControllers.get(cameraId);
-    if (cameraController) {
-      switch (extension) {
-        case 'audioDetection':
-          cameraController.updateState('audio', { state: false, db: 0 }, undefined, true);
-          break;
-        case 'motionDetection':
-          cameraController.updateState('motion', { state: false, detections: [] }, undefined, true);
-          break;
-        case 'objectDetection':
-          cameraController.updateState('object', { detections: [] }, undefined, true);
-          break;
-      }
-    }
-  }
-
-  public updateCamera(camera: Camera): void {
-    const cameraController = this.cameraControllers.get(camera._id);
-    cameraController?.updateCamera(camera);
-  }
-
-  public async removeCamera(camera: Camera, extensions: CameraExtensions): Promise<void> {
-    const pluginsService = new PluginsService();
-    const cameraController = this.cameraControllers.get(camera._id);
-
-    if (cameraController) {
-      await cameraController.stop();
-
-      for (const [extension, pluginName] of Object.entries(extensions)) {
-        if (extension !== 'plugins') {
-          const pluginNames: string[] = [];
-
-          if (extension === 'hub') {
-            pluginNames.push(...(pluginName as string[]));
-          } else {
-            pluginNames.push(pluginName as string);
-          }
-
-          const plugins = pluginNames.map((pluginName) => pluginsService.getPluginByName(pluginName)).filter(Boolean) as Plugin[];
-          await Promise.allSettled(plugins.map((plugin) => this.deselectCamera(plugin.id, camera, extension as any)));
-        }
-      }
-
-      this.cameraControllers.delete(camera._id);
-    }
-  }
-
-  public async selectCamera(pluginId: string, camera: Camera, extension: CameraExtension): Promise<void> {
-    if (camera.pluginId === pluginId) {
-      return;
-    }
-
-    const proxyServer = container.resolve<ProxyServer>('proxy');
-
-    if (!this.cameraControllers.get(camera._id)) {
-      this.addCamera(camera);
-    }
-
-    await proxyServer.requestDeviceManagerEvent(pluginId, 'cameraSelected', { camera, extension });
-  }
-
-  public async deselectCamera(pluginId: string, camera: Camera, extension: CameraExtension): Promise<void> {
-    if (camera.pluginId === pluginId) {
-      return;
-    }
-
-    this.resetCameraState(camera._id, extension);
-
-    const proxyServer = container.resolve<ProxyServer>('proxy');
-    await proxyServer.requestDeviceManagerEvent(pluginId, 'cameraDeselected', { camera, extension });
-
-    const cameraController = this.cameraControllers.get(camera._id);
-    cameraController?.removePluginCapabilities(pluginId);
-  }
-
-  public writeCameraLog(cameraId: string, msg: string): void {
-    const cameraController = this.cameraControllers.get(cameraId);
-    cameraController?.writeLog(msg);
-  }
-}

package/src/camera/classes.ts

@@ -1,32 +0,0 @@
-import type { Detection, ObjectClass } from '@camera.ui/types';
-
-const categorizeCocoClass = (className: string): ObjectClass => {
-  if (className === 'person') {
-    return 'person';
-  }
-
-  if (className === 'motion') {
-    return 'motion';
-  }
-
-  const animals = new Set(['bird', 'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'teddy bear']);
-  if (animals.has(className)) {
-    return 'animal';
-  }
-
-  const vehicles = new Set(['bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat']);
-  if (vehicles.has(className)) {
-    return 'vehicle';
-  }
-
-  return 'other';
-};
-
-export function transformLabels(detections: Detection[]): Detection[] {
-  return detections.map(
-    (detection): Detection => ({
-      ...detection,
-      label: categorizeCocoClass(detection.label),
-    }),
-  );
-}