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

package/src/main.ts

@@ -1,267 +0,0 @@
-#!/usr/bin/env node
-
-process.title = 'camera.ui';
-
-import 'reflect-metadata';
-
-import { SignalHandler } from '@camera.ui/common';
-import { sleep } from '@camera.ui/common/utils';
-import { green } from 'ansicolor';
-import fkill from 'fkill';
-import { container } from 'tsyringe';
-
-import { CameraUiAPI } from './api.js';
-import { Database } from './api/database/index.js';
-import { Go2RtcApi } from './api/go2rtc/index.js';
-import { Server } from './api/index.js';
-import { CertificateGeneration } from './api/utils/cert.js';
-import { Go2Rtc } from './go2rtc/index.js';
-import { PluginManager } from './plugins/index.js';
-import { ProxyServer } from './rpc/index.js';
-import { ConfigService } from './services/config/index.js';
-import { LoggerService } from './services/logger/index.js';
-
-import type { Logger } from '@camera.ui/common';
-import type { CLIMessage } from './types.js';
-
-class CameraUi {
-  public readonly logger: Logger;
-
-  private api: CameraUiAPI;
-  private database: Database;
-  private configService: ConfigService;
-  private pluginManager: PluginManager;
-  private go2rtc: Go2Rtc;
-  private go2rtcApi: Go2RtcApi;
-  private server: Server;
-  private proxy: ProxyServer;
-  private signalHandler: SignalHandler;
-
-  private homePath: string | undefined;
-
-  public status: 'loading' | 'ready' = 'loading';
-
-  constructor() {
-    container.registerInstance('cameraui', this);
-
-    this.logger = new LoggerService();
-
-    this.signalHandler = new SignalHandler({
-      displayName: '[Signal]',
-      timeoutDuration: 5000,
-      logger: this.logger,
-      closeFunction: this.close.bind(this),
-    });
-
-    this.homePath = process.argv[2];
-
-    this.configService = new ConfigService(this.homePath);
-    this.api = new CameraUiAPI();
-    this.proxy = new ProxyServer();
-    this.go2rtc = new Go2Rtc();
-    this.pluginManager = new PluginManager();
-    this.server = new Server();
-    this.database = new Database();
-    this.go2rtcApi = new Go2RtcApi();
-  }
-
-  public async start(): Promise<void> {
-    CertificateGeneration.generateCert();
-
-    // Initialize database
-    await this.database.initialize();
-
-    // Start Go2RTC
-    await this.go2rtc.start();
-
-    // Initialize proxy Server and start NATS
-    await this.proxy.initialize();
-
-    // Register server plugins
-    await this.server.register();
-
-    this.logger.log('---');
-
-    // Start server
-    await this.server.listen();
-
-    this.logger.log('---');
-
-    this.setStatus('loading');
-
-    // Initialize plugins
-    await this.pluginManager.initializePlugins();
-
-    // Configure cameras
-    await this.api.configureCameras();
-
-    // Start initialized plugins
-    this.initializePlugins();
-  }
-
-  public async close(): Promise<void> {
-    if (this.server.isRunning) {
-      await this.server.close();
-    } else {
-      await Promise.allSettled([this.server.close(), this.proxy.close(), this.go2rtc.stop()]);
-    }
-
-    await Promise.allSettled(Array.from(this.pluginManager.plugins).map(([, plugin]) => plugin.worker.teardown(true)));
-
-    await sleep(1000);
-
-    const processes = this.configService.processes;
-    await fkill(
-      processes.map((process) => process.pid),
-      { force: true, silent: true },
-    );
-  }
-
-  // TODO
-  public async restart(): Promise<void> {
-    this.logger.log('Restarting camera.ui...');
-
-    await this.close();
-    await this.start();
-  }
-
-  public async requestUpdate(version?: string): Promise<AsyncGenerator<string, void, unknown>> {
-    if (!process.send) {
-      throw new Error('Cannot update server: No CLI process found');
-    }
-
-    process.send({
-      type: 'UPDATE_SERVER',
-      version: version,
-    });
-
-    // prettier-ignore
-    const messageHandler = async function *() {
-      let resolver: ((value: { done: boolean; value?: string }) => void) | null = null;
-      let rejector: ((error: Error) => void) | null = null;
-
-      const messageQueue: { done: boolean; value?: string }[] = [];
-      let updateFailed = false;
-      let updateError: Error | null = null;
-
-      const timer = setTimeout(
-        () => {
-          if (resolver) {
-            rejector?.(new Error('Update timeout after 5 minutes'));
-          }
-        },
-        5 * 60 * 1000,
-      );
-
-      const handler = (message: CLIMessage) => {
-        switch (message.type) {
-          case 'UPDATE_OUTPUT':
-          case 'UPDATE_ERROR': {
-            const result = { done: false, value: message.data };
-            if (resolver) {
-              resolver(result);
-              resolver = null;
-            } else {
-              messageQueue.push(result);
-            }
-            break;
-          }
-          case 'UPDATE_FAILED': {
-            updateFailed = true;
-            updateError = new Error(message.error ?? 'Update failed');
-            if (rejector) {
-              rejector(updateError);
-            }
-            process.removeListener('message', handler);
-            clearTimeout(timer);
-            break;
-          }
-          case 'UPDATE_COMPLETE': {
-            const result = { done: true };
-            if (resolver) {
-              resolver(result);
-              resolver = null;
-            } else {
-              messageQueue.push(result);
-            }
-            process.removeListener('message', handler);
-            clearTimeout(timer);
-            break;
-          }
-        }
-      };
-
-      process.on('message', handler);
-
-      try {
-        while (true) {
-          if (updateFailed) {
-            throw updateError!;
-          }
-
-          if (messageQueue.length > 0) {
-            const next = messageQueue.shift()!;
-            if (next.done) {
-              return;
-            }
-            if (next.value) {
-              yield next.value;
-            }
-          } else {
-            const next = await new Promise<{ done: boolean; value?: string }>((resolve, reject) => {
-              resolver = resolve;
-              rejector = reject;
-            });
-
-            if (next.done) {
-              return;
-            }
-            if (next.value) {
-              yield next.value;
-            }
-          }
-        }
-      } finally {
-        process.removeListener('message', handler);
-        clearTimeout(timer);
-      }
-    };
-
-    return messageHandler();
-  }
-
-  private async initializePlugins(): Promise<void> {
-    await this.pluginManager.initializeInstalledPlugins();
-    this.setStatus('ready');
-    this.logger.log(green('All plugins initialized'));
-  }
-
-  private setStatus(status: 'loading' | 'ready'): void {
-    this.status = status;
-    this.server.app?.io.of('/camera.ui').emit('status', status);
-  }
-}
-
-const launch = async () => {
-  const cameraui = new CameraUi();
-  const logger = cameraui.logger;
-
-  try {
-    await cameraui.start();
-    process.send?.('started');
-  } catch (error) {
-    logger.error('Failed to start camera.ui', error);
-
-    if (error.message === 'SELF_CHECK_FAILED') {
-      process.send?.('START_ERROR');
-    }
-
-    await cameraui.close();
-
-    process.exit(1);
-  }
-};
-
-launch();
-
-export type { CameraUi };

package/src/manager/coreManager.ts

@@ -1,78 +0,0 @@
-import { getHwaccelInfo } from '@camera.ui/common/camera';
-import { rpc } from '@camera.ui/rpc-common';
-import { container } from 'tsyringe';
-
-import { PluginsService } from '../api/services/plugins.service.js';
-import { SystemService } from '../api/services/system.service.js';
-import { DEFAULT_ICE_SERVERS } from '../services/config/constants.js';
-
-import type { FfmpegArgs, HWAccelOptions, IceServer } from '@camera.ui/types';
-import type { PluginInfo } from '../plugins/types.js';
-import type { ConfigService } from '../services/config/index.js';
-import type { CoreManagerInterface } from './types.js';
-
-export class CoreManagerProxy implements CoreManagerInterface {
-  private configService: ConfigService;
-  private systemService: SystemService;
-  private pluginService: PluginsService;
-  private hwaccelCache = new Map<string, FfmpegArgs[]>();
-
-  constructor() {
-    container.registerInstance('coreManagerProxy', this);
-
-    this.configService = container.resolve<ConfigService>('configService');
-    this.systemService = new SystemService();
-    this.pluginService = new PluginsService();
-  }
-
-  @rpc({ public: true })
-  public async getPlugin(pluginName: string): Promise<PluginInfo | undefined> {
-    const plugin = this.pluginService.getPluginByName(pluginName);
-    if (plugin) {
-      return {
-        id: plugin.id,
-        name: plugin.pluginName,
-        contract: plugin.contract,
-      };
-    }
-  }
-
-  @rpc({ public: true })
-  public async getFFmpegPath(): Promise<string> {
-    return this.configService.go2rtcConfig.ffmpeg.bin;
-  }
-
-  @rpc({ public: true })
-  public async getHwaccelInfo(options: HWAccelOptions): Promise<FfmpegArgs[]> {
-    const cacheKey = this.createHwaccelCacheKey(options);
-    if (this.hwaccelCache.has(cacheKey)) {
-      return this.hwaccelCache.get(cacheKey)!;
-    }
-
-    const result = await getHwaccelInfo(this.configService.go2rtcConfig.ffmpeg.bin, options);
-
-    this.hwaccelCache.set(cacheKey, result);
-
-    return result;
-  }
-
-  @rpc({ public: true })
-  public async getServerAddresses(): Promise<string[]> {
-    return this.systemService.info().serverAddresses ?? [];
-  }
-
-  @rpc({ public: true })
-  public async getIceServers(): Promise<IceServer[]> {
-    return this.configService.go2rtcConfig.webrtc.ice_servers ?? DEFAULT_ICE_SERVERS;
-  }
-
-  private createHwaccelCacheKey(options: HWAccelOptions): string {
-    return JSON.stringify({
-      targetCodec: options.targetCodec ?? 'h264',
-      keepOnHardware: options.keepOnHardware ?? false,
-      pixelFormat: options.pixelFormat ?? null,
-      width: options.scale?.width ?? null,
-      height: options.scale?.height ?? null,
-    });
-  }
-}

package/src/manager/deviceManager.ts

@@ -1,132 +0,0 @@
-import { rpc } from '@camera.ui/rpc-common';
-import { container } from 'tsyringe';
-
-import { createCameraSchema, patchCameraSchema } from '../api/schemas/cameras.schema.js';
-import { CamerasService } from '../api/services/cameras.service.js';
-import { PluginsService } from '../api/services/plugins.service.js';
-
-import type { Camera, CameraConfig } from '@camera.ui/types';
-import type { DBCamera } from '../api/database/types.js';
-import type { ConfigService } from '../services/config/index.js';
-import type { DeviceManagerInterface } from './types.js';
-
-export class DeviceManagerProxy implements DeviceManagerInterface {
-  private camerasService: CamerasService;
-  private pluginsService: PluginsService;
-  private configService: ConfigService;
-
-  constructor() {
-    container.registerInstance('deviceManagerProxy', this);
-
-    this.camerasService = new CamerasService();
-    this.pluginsService = new PluginsService();
-    this.configService = container.resolve('configService');
-  }
-
-  @rpc({ public: true })
-  public async getCamera(cameraIdOrName: string): Promise<Camera | undefined> {
-    return this.camerasService.findTransformedByName(cameraIdOrName) ?? this.camerasService.findTransformedById(cameraIdOrName);
-  }
-
-  @rpc({ public: true })
-  public async createCamera(cameraConfig: CameraConfig, pluginId: string): Promise<Camera> {
-    const cameraExist = this.camerasService.findByName(cameraConfig.name);
-    const plugin = this.pluginsService.getPluginById(pluginId);
-
-    if (cameraExist) {
-      throw new Error(`Camera with name "${cameraConfig.name}" already exist`);
-    }
-
-    if (!plugin) {
-      throw new Error(`Plugin with ID "${pluginId}" not found`);
-    }
-
-    if (!plugin.contract.extensions.includes('cameraController')) {
-      throw new Error(`Plugin "${plugin.pluginName}" is not a camera plugin`);
-    }
-
-    if (!cameraConfig.sources) {
-      cameraConfig.sources = [
-        {
-          name: 'main',
-          role: 'high-resolution',
-          hotMode: false,
-          useForSnapshot: false,
-          urls: ['cui://127.0.0.1'], // placeholder for parsing
-        },
-      ];
-    }
-
-    cameraConfig.sources = cameraConfig.sources.map((source) => {
-      if (!source.urls?.length) {
-        source.urls = ['cui://127.0.0.1']; // placeholder for parsing
-      }
-      return source;
-    });
-
-    const cameraDB: DBCamera = createCameraSchema.parse({
-      ...cameraConfig,
-      pluginId,
-    });
-
-    cameraDB.sources = cameraDB.sources.map((source) => {
-      if (!source.urls?.length) {
-        source.urls = [`cui://127.0.0.1:${this.configService.config.port}/api/cameras/streams/${cameraDB._id}/${source.name}`];
-      }
-      return source;
-    });
-
-    const camera = await this.camerasService.createCamera(cameraDB);
-
-    return this.camerasService.transformCamera(camera);
-  }
-
-  @rpc({ public: true })
-  public async updateCamera(cameraIdOrName: string, cameraConfig: Partial<CameraConfig>, pluginId: string): Promise<Camera> {
-    const camera = this.camerasService.findByName(cameraIdOrName) ?? this.camerasService.findById(cameraIdOrName);
-    const plugin = this.pluginsService.getPluginById(pluginId);
-
-    if (!camera) {
-      throw new Error(`Camera with name/id "${cameraIdOrName}" not found`);
-    }
-
-    if (!plugin) {
-      throw new Error(`Plugin with ID "${pluginId}" not found`);
-    }
-
-    if (camera.pluginId !== pluginId) {
-      throw new Error(`Camera with name/id "${cameraIdOrName}" not belong to plugin with ID "${pluginId}"`);
-    }
-
-    if (cameraConfig.name && cameraConfig.name !== camera.name) {
-      const cameraExist = this.camerasService.findByName(cameraConfig.name);
-      if (cameraExist) {
-        throw new Error(`Camera with name "${cameraConfig.name}" already exist`);
-      }
-    }
-
-    const cameraDB = patchCameraSchema.parse(cameraConfig);
-
-    const newCamera = await this.camerasService.patchCameraByName(camera.name, cameraDB);
-    if (!newCamera) {
-      throw new Error(`Camera with name/id "${cameraIdOrName}" not found`);
-    }
-
-    return this.camerasService.transformCamera(newCamera);
-  }
-
-  @rpc({ public: true })
-  public async removeCamera(cameraIdOrName: string, pluginId: string): Promise<void> {
-    const camera = this.camerasService.findByName(cameraIdOrName) ?? this.camerasService.findById(cameraIdOrName);
-
-    if (!camera) {
-      throw new Error(`Camera with name/id "${cameraIdOrName}" does not exist`);
-    }
-
-    if (camera.pluginId !== pluginId) {
-      throw new Error(`Camera with name/id "${cameraIdOrName}" not belong to plugin with ID "${pluginId}"`);
-    }
-
-    await this.camerasService.removeById(camera._id);
-  }
-}

package/src/manager/types.ts

@@ -1,17 +0,0 @@
-import type { Camera, CameraConfig, CoreManager, DeviceManager, FfmpegArgs, HWAccelOptions, IceServer } from '@camera.ui/types';
-import type { PluginInfo } from '../plugins/types.js';
-
-export interface CoreManagerInterface extends Omit<CoreManager, keyof CoreManager> {
-  getFFmpegPath(): Promise<string>;
-  getHwaccelInfo(options: HWAccelOptions): Promise<FfmpegArgs[]>;
-  getServerAddresses(): Promise<string[]>;
-  getIceServers(): Promise<IceServer[]>;
-  getPlugin(pluginName: string): Promise<PluginInfo | undefined>;
-}
-
-export interface DeviceManagerInterface extends Omit<DeviceManager, keyof DeviceManager> {
-  createCamera(cameraConfig: CameraConfig, pluginId: string): Promise<Camera>;
-  updateCamera(cameraNameOrId: string, cameraConfig: Partial<CameraConfig>, pluginId: string): Promise<Camera>;
-  getCamera(cameraNameOrId: string, pluginId: string): Promise<Camera | undefined>;
-  removeCamera(cameraNameOrId: string, pluginId: string): Promise<void>;
-}