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

package/src/api/services/plugins.service.ts

@@ -0,0 +1,470 @@
+import { getNpmPath } from '@camera.ui/common/node';
+import { cyan, green, red, type AnsicolorMethods } from 'ansicolor';
+import { ensureDir, move, pathExists, readJson, remove } from 'fs-extra/esm';
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { platform, tmpdir, userInfo } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { extract } from 'tar';
+import { container, delay, registry } from 'tsyringe';
+import { v4 as uuidv4 } from 'uuid';
+
+import { PluginManager } from '../../plugins/index.js';
+import { Plugin } from '../../plugins/plugin.js';
+import { Database } from '../database/index.js';
+import { CamerasService } from './cameras.service.js';
+
+import type { Server } from 'socket.io';
+import type { PluginWorker } from '../../plugins/worker.js';
+import type { ConfigService } from '../../services/config/index.js';
+import type { LoggerService } from '../../services/logger/index.js';
+import type { DBPlugin } from '../database/types.js';
+import type { PluginsProgress } from '../types/index.js';
+import type { SocketService } from '../websocket/index.js';
+
+@registry([
+  {
+    token: 'dbs',
+    useValue: delay(() => Database),
+  },
+  {
+    token: 'pluginManager',
+    useValue: delay(() => PluginManager),
+  },
+])
+export class PluginsService {
+  private dbs: Database;
+  private io: Server;
+  private logger: LoggerService;
+  private pluginManager: PluginManager;
+  private configService: ConfigService;
+  private socketService: SocketService;
+
+  private managingPluginsMap = new Map<string, PluginsProgress>();
+
+  constructor() {
+    this.dbs = container.resolve<Database>('dbs');
+    this.logger = container.resolve<LoggerService>('logger');
+    this.pluginManager = container.resolve<PluginManager>('pluginManager');
+    this.configService = container.resolve<ConfigService>('configService');
+    this.socketService = container.resolve<SocketService>('socketService');
+
+    this.io = this.socketService.io;
+  }
+
+  public listPlugins(): Plugin[] {
+    return Array.from(this.pluginManager.plugins).map(([, plugin]) => plugin);
+  }
+
+  public listPluginProcesses(): PluginWorker[] {
+    return Array.from(this.pluginManager.plugins).map(([, plugin]) => plugin.worker);
+  }
+
+  public listPluginsIdentifier(): string[] {
+    return Array.from(this.pluginManager.pluginIdentifiers);
+  }
+
+  // installed plugins
+  public getPluginByName(pluginName: string): Plugin | undefined {
+    const installedPlugins = this.listPlugins();
+    const plugin = installedPlugins.find((plugin) => plugin.pluginName === pluginName);
+    return plugin;
+  }
+
+  public getPluginById(id: string): Plugin | undefined {
+    const installedPlugins = this.listPlugins();
+    const plugin = installedPlugins.find((plugin) => plugin.id === id);
+    return plugin;
+  }
+
+  public getPluginProcessByName(pluginName: string): PluginWorker | undefined {
+    const installedPluginsProcesses = this.listPluginProcesses();
+    const plugin = installedPluginsProcesses.find((pluginProcess) => pluginProcess.plugin.pluginName === pluginName);
+    return plugin;
+  }
+
+  public getPluginProcessById(id: string): PluginWorker | undefined {
+    const installedPluginsProcesses = this.listPluginProcesses();
+    const plugin = installedPluginsProcesses.find((pluginProcess) => pluginProcess.plugin.id === id);
+    return plugin;
+  }
+
+  // db plugins
+  public listPluginDb(): DBPlugin[] {
+    return this.dbs.pluginsDB.get('plugins') ?? [];
+  }
+
+  public getPluginDbByName(pluginName: string): DBPlugin | undefined {
+    const plugins = this.dbs.pluginsDB.get('plugins') ?? [];
+    return plugins.find((pluginObj) => pluginObj.pluginName === pluginName);
+  }
+
+  public getPluginDbById(id: string): DBPlugin | undefined {
+    const plugins = this.dbs.pluginsDB.get('plugins') ?? [];
+    return plugins.find((pluginObj) => pluginObj._id === id);
+  }
+
+  public async insertPluginDb(pluginName: string, oldId?: string): Promise<DBPlugin> {
+    const plugins = this.dbs.pluginsDB.get('plugins') ?? [];
+    const pluginExist = plugins.find((pluginObj) => pluginObj.pluginName === pluginName);
+
+    if (pluginExist) {
+      return pluginExist;
+    }
+
+    const pluginData: DBPlugin = {
+      _id: oldId ?? uuidv4(),
+      pluginName,
+    };
+
+    plugins.push(pluginData);
+    await this.dbs.pluginsDB.put('plugins', plugins);
+
+    return pluginData;
+  }
+
+  public async removePluginDbByName(pluginName: string): Promise<void> {
+    const camerasService = new CamerasService();
+    await camerasService.removeByPluginName(pluginName);
+
+    let plugins = this.dbs.pluginsDB.get('plugins') ?? [];
+    plugins = plugins.filter((pluginObj) => pluginObj.pluginName !== pluginName);
+
+    await this.dbs.pluginsDB.put('plugins', plugins);
+  }
+
+  public async removePluginDbById(id: string): Promise<void> {
+    const camerasService = new CamerasService();
+    await camerasService.removeByPluginId(id);
+
+    let plugins = this.dbs.pluginsDB.get('plugins') ?? [];
+    plugins = plugins.filter((pluginObj) => pluginObj._id !== id);
+
+    await this.dbs.pluginsDB.put('plugins', plugins);
+  }
+
+  public async removeAllPluginsDb(): Promise<void> {
+    const plugins = this.dbs.pluginsDB.get('plugins') ?? [];
+
+    const camerasService = new CamerasService();
+
+    for (const plugin of plugins) {
+      await camerasService.removeByPluginName(plugin.pluginName);
+    }
+
+    await this.dbs.pluginsDB.put('plugins', []);
+  }
+
+  public async removeOrphanPluginsDb(): Promise<void> {
+    let plugins = this.dbs.pluginsDB.get('plugins') ?? [];
+    const orphanedPlugins: string[] = [];
+
+    plugins.forEach((pluginObj) => {
+      const pluginExist = this.getPluginByName(pluginObj.pluginName);
+      const pluginIdentifierExist = this.listPluginsIdentifier().includes(pluginObj.pluginName);
+
+      if (!pluginExist && !pluginIdentifierExist) {
+        orphanedPlugins.push(pluginObj.pluginName);
+      }
+    });
+
+    await Promise.all(orphanedPlugins.map((pluginName) => this.removePluginDbByName(pluginName)));
+
+    plugins = plugins.filter((pluginObj) => !orphanedPlugins.includes(pluginObj.pluginName));
+
+    await this.dbs.pluginsDB.put('plugins', plugins);
+  }
+
+  public async handleDisabledPlugins(): Promise<void> {
+    const camerasService = new CamerasService();
+    const plugins = this.listPlugins();
+    const disabledPlugins: string[] = plugins.filter((plugin) => plugin.disabled).map((plugin) => plugin.pluginName);
+
+    for (const pluginName of disabledPlugins) {
+      await camerasService.removeByPluginName(pluginName);
+    }
+  }
+
+  public async manage(pluginName: string, action: 'install' | 'update' | 'uninstall', version?: string, pluginId?: string): Promise<string> {
+    const targetDir = join(this.configService.PLUGINS_INSTALL_PATH, pluginName);
+
+    this.emitProgress(pluginName, `USER: ${userInfo().username}\r\n`, cyan);
+    this.emitProgress(pluginName, `DIR: ${targetDir}\r\n`, cyan);
+    this.emitProgress(pluginName, `ACTION: ${action}\r\r\n\n`, cyan);
+
+    const existingAction = this.managingPluginsMap.get(pluginName);
+    if (existingAction) {
+      this.emitProgress(pluginName, `\r\n\r\nError: Cannot ${action} plugin ${pluginName} while ${existingAction.action} is in progress.\r\n\r\n'`, red);
+      throw new Error(`Cannot ${action} plugin ${pluginName} while ${existingAction.action} is in progress.`);
+    }
+
+    this.managingPluginsMap.set(pluginName, { pluginName, action, version: version ?? 'latest' });
+
+    switch (action) {
+      case 'install':
+        await this.installPlugin(pluginName, version ?? 'latest', targetDir);
+        break;
+      case 'update':
+        await this.updatePlugin(pluginName, version ?? 'latest', targetDir);
+        break;
+      case 'uninstall':
+        await this.uninstallPlugin(pluginName, targetDir);
+
+        if (pluginId) {
+          const camerasService = new CamerasService();
+          await camerasService.removeByPluginId(pluginId);
+        }
+        break;
+    }
+
+    this.managingPluginsMap.delete(pluginName);
+
+    return targetDir;
+  }
+
+  public installingPlugins(): PluginsProgress[] {
+    const pluginsInProgress: PluginsProgress[] = [];
+    for (const [, progressInfo] of this.managingPluginsMap) {
+      pluginsInProgress.push(progressInfo);
+    }
+    return pluginsInProgress;
+  }
+
+  private async installPlugin(pluginName: string, version: string, targetDir: string, update?: boolean): Promise<void> {
+    const backupTempDir = join(tmpdir(), `${pluginName}_backup`);
+
+    try {
+      const npmRegistry = 'https://registry.npmjs.org';
+      const packageUrl = `${npmRegistry}/${pluginName}/${version}`;
+
+      this.emitProgress(pluginName, '> Fetching package information...');
+
+      const response = await fetch(packageUrl);
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const packageInfo = await response.json();
+      const tarballUrl = packageInfo.dist.tarball;
+      const expectedShasum = packageInfo.dist.shasum;
+
+      this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+
+      const tarballData = await this.downloadWithProgress(tarballUrl, pluginName, version);
+      this.emitProgress(pluginName, ' - Done\r\n\r\n', green);
+
+      this.emitProgress(pluginName, '> Verifying package integrity...');
+      const computedShasum = createHash('sha1').update(Buffer.from(tarballData)).digest('hex');
+      if (computedShasum !== expectedShasum) {
+        throw new Error(`SHA checksum mismatch. Expected: ${expectedShasum}, Got: ${computedShasum}`);
+      }
+      this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+
+      if (await pathExists(targetDir)) {
+        this.emitProgress(pluginName, '> Backing up existing installation...');
+        await move(targetDir, backupTempDir);
+        this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+      }
+
+      await ensureDir(targetDir);
+
+      this.emitProgress(pluginName, '> Extracting package...');
+
+      await new Promise<void>((resolve, reject) => {
+        const extractStream = extract({
+          cwd: targetDir,
+          strip: 1,
+        });
+        extractStream.on('error', reject);
+        extractStream.on('end', () => {
+          this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+          resolve();
+        });
+        extractStream.write(Buffer.from(tarballData));
+        extractStream.end();
+      });
+
+      await this.installProductionDependencies(targetDir, pluginName);
+
+      await this.extrackBundeledPlugin(targetDir, pluginName);
+
+      this.emitProgress(pluginName, '\r\n> Cleaning up...');
+      await remove(backupTempDir);
+      this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+
+      this.emitProgress(pluginName, `Plugin ${pluginName}@${version} has been successfully ${update ? 'updated' : 'installed'}.\r\n\r\n`, green);
+    } catch (error) {
+      this.emitProgress(pluginName, `\r\nError during ${update ? 'update' : 'installation'} of ${pluginName}@${version}.\r\n\r\n`, red);
+
+      try {
+        this.emitProgress(pluginName, '> Restoring previous version...');
+        await remove(targetDir);
+        await move(backupTempDir, targetDir);
+        this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+      } catch (error: any) {
+        this.emitProgress(pluginName, `\r\n\r\nError: ${error.message}\r\n`, red);
+        this.emitProgress(pluginName, 'Failed to restore previous version.\r\n\r\n', red);
+      }
+
+      throw error;
+    }
+  }
+
+  private async updatePlugin(pluginName: string, version: string, targetDir: string): Promise<void> {
+    try {
+      this.emitProgress(pluginName, '> Preparing update...');
+
+      const packageJsonPath = join(targetDir, 'package.json');
+      const packageJson = await readJson(packageJsonPath);
+      const currentVersion = packageJson.version;
+
+      if (currentVersion === version) {
+        this.emitProgress(pluginName, `\r\n\r\nPlugin ${pluginName} is already up to date.\r\n\r\n`, green);
+        return;
+      }
+
+      this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+
+      await this.installPlugin(pluginName, version, targetDir, true);
+    } catch (error) {
+      this.emitProgress(pluginName, `\r\nError during update of ${pluginName}@${version}.\r\n\r\n`, red);
+      throw error;
+    }
+  }
+
+  private async uninstallPlugin(pluginName: string, targetDir: string): Promise<void> {
+    try {
+      this.emitProgress(pluginName, '> Removing plugin...');
+
+      await remove(targetDir);
+
+      this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+      this.emitProgress(pluginName, `Plugin ${pluginName} has been successfully uninstalled.\r\n`, green);
+    } catch (error) {
+      this.emitProgress(pluginName, ' Error\r\n\r\n', red);
+      this.emitProgress(pluginName, `\r\nError during uninstallation of ${pluginName}.\r\n\r\n`, red);
+      throw error;
+    }
+  }
+
+  private async downloadWithProgress(url: string, pluginName: string, version: string): Promise<ArrayBuffer> {
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    const contentLength = Number(response.headers.get('Content-Length'));
+    let receivedLength = 0;
+    const chunks: Uint8Array[] = [];
+
+    const reader = response.body!.getReader();
+
+    this.emitProgress(pluginName, `> Downloading ${pluginName}@${version}...\r\n`);
+
+    while (true) {
+      const { done, value } = await reader.read();
+
+      if (done) {
+        break;
+      }
+
+      chunks.push(value);
+      receivedLength += value.length;
+
+      const percentComplete = Math.round((receivedLength / contentLength) * 100);
+      const progressBar = this.getProgressBar(percentComplete);
+      this.emitProgress(pluginName, `\r${progressBar} ${percentComplete}%`, cyan);
+    }
+
+    return await new Blob(chunks).arrayBuffer();
+  }
+
+  private getProgressBar(percent: number): string {
+    const width = 50;
+    const complete = Math.round(width * (percent / 100));
+    const incomplete = width - complete;
+    return `[${'='.repeat(complete)}${'-'.repeat(incomplete)}]`;
+  }
+
+  private async installProductionDependencies(packageDir: string, pluginName: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.emitProgress(pluginName, '> Installing dependencies...\r\n\r\n');
+
+      const npmCmd = getNpmPath()[0];
+      const args = ['install', '--omit=dev', '--include=prod', '--loglevel', 'info'];
+
+      const env = { ...process.env };
+      Object.assign(env, {
+        NODE_ENV: 'production',
+        npm_config_unsafe_perm: 'true',
+        npm_config_update_notifier: 'false',
+        npm_config_prefer_online: 'true',
+        npm_config_loglevel: 'info',
+        npm_config_prefix: packageDir,
+        npm_config_color: 'always',
+        FORCE_COLOR: '1',
+      });
+
+      if (platform() !== 'win32' && basename(packageDir) === 'lib') {
+        env.npm_config_prefix = dirname(packageDir);
+      }
+
+      this.emitProgress(pluginName, `Running Command: ${npmCmd} ${args.join(' ')}\r\n`);
+
+      const childProcess = spawn(npmCmd, args, {
+        cwd: packageDir,
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+
+      childProcess.stdout.on('data', (data) => {
+        this.emitProgress(pluginName, data.toString().replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n/g, '\r\n'));
+      });
+
+      childProcess.stderr.on('data', (data) => {
+        this.emitProgress(pluginName, data.toString().replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n/g, '\r\n'));
+      });
+
+      const timeoutTimer = setTimeout(() => {
+        childProcess.kill('SIGTERM');
+        reject(new Error('Operation timed out after 5 minutes'));
+      }, 300000);
+
+      childProcess.on('close', (code) => {
+        clearTimeout(timeoutTimer);
+
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Operation failed with exit code ${code}. Please review log for details.`));
+        }
+      });
+
+      childProcess.on('error', (err) => {
+        clearTimeout(timeoutTimer);
+        reject(new Error(`Failed to start process: ${err.message}`));
+      });
+    });
+  }
+
+  private async extrackBundeledPlugin(packageDir: string, pluginName: string): Promise<void> {
+    this.emitProgress(pluginName, '\r\n> Checking for bundled plugin...');
+
+    const bundlePath = await PluginManager.checkBundeledPlugin(packageDir);
+    if (!bundlePath) {
+      this.emitProgress(pluginName, '\r\n> Plugin is not bundled, skipping extraction...');
+      return;
+    }
+
+    this.emitProgress(pluginName, '\r\n> Extracting bundled plugin...');
+
+    await PluginManager.extrackBundeledPlugin(packageDir, bundlePath);
+
+    this.emitProgress(pluginName, ' Done', green);
+  }
+
+  private emitProgress(pluginName: string, message: string, color?: AnsicolorMethods) {
+    this.io.of('/logs').emit(`stdout/${pluginName}`, color ? color(message) : message);
+  }
+}

package/src/api/services/system.service.ts

@@ -0,0 +1,85 @@
+import { APP_SERVER_NAME, mergeWith } from '@camera.ui/common/utils';
+import { cyan, green, red, yellow } from 'ansicolor';
+import { userInfo } from 'node:os';
+import { satisfies } from 'semver';
+import { container } from 'tsyringe';
+
+import { ConfigService } from '../../services/config/index.js';
+
+import type { AnsicolorMethods } from 'ansicolor';
+import type { Server } from 'socket.io';
+import type { CameraUi } from '../../main.js';
+import type { Database } from '../database/index.js';
+import type { DBSystem } from '../database/types.js';
+import type { SocketService } from '../websocket/index.js';
+
+export class SystemService {
+  private dbs: Database;
+  private io: Server;
+  private socketService: SocketService;
+  private cameraui: CameraUi;
+
+  private installInProgress = false;
+
+  constructor() {
+    this.dbs = container.resolve<Database>('dbs');
+    this.socketService = container.resolve<SocketService>('socketService');
+    this.cameraui = container.resolve<CameraUi>('cameraui');
+    this.io = this.socketService.io;
+  }
+
+  public info(): DBSystem {
+    return this.dbs.systemDB.get('system')!;
+  }
+
+  public async patch(infoData: Partial<DBSystem> = {}): Promise<DBSystem> {
+    const info = this.info();
+
+    infoData.serverAddresses = infoData.serverAddresses?.filter((address) => address !== '');
+
+    mergeWith(info, infoData, (source: any, target: any) => {
+      if (Array.isArray(source)) {
+        return target;
+      }
+    });
+
+    await this.dbs.systemDB.put('system', info);
+
+    return info;
+  }
+
+  public async install(version = 'latest'): Promise<void> {
+    this.emitProgress('server', `\r\nUSER: ${userInfo().username}\r\n`, cyan);
+    this.emitProgress('server', 'ACTION: update\r\r\n\n', cyan);
+
+    if (this.installInProgress) {
+      this.emitProgress('server', "\r\n\r\nError: Update already in progress.\r\n\r\n'", red);
+      throw new Error('Update already in progress.');
+    }
+
+    this.installInProgress = true;
+
+    if (!satisfies(process.version, `>=${ConfigService.MIN_NODE_VERSION}`)) {
+      this.emitProgress('server', `Node.js v${ConfigService.MIN_NODE_VERSION} higher is required for ${APP_SERVER_NAME}.\r\n`, yellow);
+      this.emitProgress('server', `You may experience issues while running on Node.js ${process.version}.\r\n\r\n`, yellow);
+    }
+
+    try {
+      const updateStream = await this.cameraui.requestUpdate(version);
+      for await (const output of updateStream) {
+        this.emitProgress('server', output.split(/\r?\n/).join('\r\n'));
+      }
+
+      this.emitProgress('server', `\r\nServer ${APP_SERVER_NAME}@${version} has been successfully updated.\r\n\r\n`, green);
+      this.installInProgress = false;
+    } catch (error) {
+      this.installInProgress = false;
+      this.emitProgress('server', `\r\nError during update of ${APP_SERVER_NAME}@${version}.\r\n\r\n`, red);
+      throw error;
+    }
+  }
+
+  private emitProgress(pluginName: string, message: string, color?: AnsicolorMethods) {
+    this.io.of('/logs').emit(`stdout/${pluginName}`, color ? color(message) : message);
+  }
+}