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

package/src/api/controllers/plugins.controller.ts

@@ -0,0 +1,1206 @@
+import { orderBy } from '@camera.ui/common';
+import TTLCache from '@isaacs/ttlcache';
+import { pathExists } from 'fs-extra/esm';
+import { createReadStream, truncate } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { Readable } from 'node:stream';
+import { gt, parse as parseVersion } from 'semver';
+import sharp from 'sharp';
+import { container } from 'tsyringe';
+
+import { PluginManager } from '../../plugins/index.js';
+import { CamerasService } from '../services/cameras.service.js';
+import { PluginsService } from '../services/plugins.service.js';
+import { fetchWithTimeout } from '../utils/fetch.js';
+
+import type { JsonSchema } from '@camera.ui/types';
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import type { Server } from 'socket.io';
+import type { ProxyServer } from '../../rpc/index.js';
+import type { ConfigService } from '../../services/config/index.js';
+import type { LoggerService } from '../../services/logger/index.js';
+import type {
+  AuthLoginRequest,
+  CameraUiPlugin,
+  INpmPluginState,
+  INpmRegistryModule,
+  INpmSearchResults,
+  IPackageJson,
+  PaginationRequest,
+  PluginExtension,
+  PluginExtensionConfig,
+  PluginsDetectAudioRequest,
+  PluginsDetectMotionRequest,
+  PluginsDetectObjectRequest,
+  PluginsInsertRequest,
+  PluginsParamsNameRequest,
+  PluginsParamsRemoveRequest,
+  PluginsProgress,
+  PluginsQueryRequest,
+  StoragePatchRequest,
+  StorageSetRequest,
+  StorageSubmitRequest,
+} from '../types/index.js';
+import type { SocketService } from '../websocket/index.js';
+import type { ServerNamespace } from '../websocket/nsp/server.js';
+
+const npmPluginCache = new TTLCache<string, INpmRegistryModule | IPackageJson>({ ttl: 300, max: 100 });
+const searchResultBlacklist = new Set(['camera.ui', 'homebridge-camera-ui']);
+const pluginLogoCache = new TTLCache<string, string>({ max: 100, ttl: 1000 * 60 * 60 * 24 });
+
+export class PluginsController {
+  private app: FastifyInstance;
+  private logger: LoggerService;
+  private configService: ConfigService;
+  private io: Server;
+  private pluginManager: PluginManager;
+  private proxyServer: ProxyServer;
+  private service: PluginsService;
+  private camerasService: CamerasService;
+  private socketService: SocketService;
+
+  constructor(app: FastifyInstance) {
+    this.app = app;
+    this.io = app.io;
+    this.service = new PluginsService();
+    this.camerasService = new CamerasService();
+
+    this.logger = container.resolve<LoggerService>('logger');
+    this.configService = container.resolve<ConfigService>('configService');
+    this.pluginManager = container.resolve<PluginManager>('pluginManager');
+    this.proxyServer = container.resolve<ProxyServer>('proxy');
+    this.socketService = container.resolve<SocketService>('socketService');
+  }
+
+  public async enableByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      if (!plugin.disabled) {
+        return reply.code(400).send({
+          statusCode: 404,
+          message: 'Plugin already enabled',
+        });
+      }
+
+      plugin.disabled = false;
+
+      if (this.configService.config.plugins.disabledPlugins.includes(pluginName)) {
+        const index = this.configService.config.plugins.disabledPlugins.indexOf(pluginName);
+        this.configService.config.plugins.disabledPlugins.splice(index, 1);
+        this.configService.writeConfig();
+      }
+
+      await this.pluginManager.startPluginChild(pluginName);
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async disableByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      if (plugin.disabled) {
+        return reply.code(400).send({
+          statusCode: 404,
+          message: 'Plugin already disabled',
+        });
+      }
+
+      plugin.disabled = true;
+
+      this.configService.config.plugins.disabledPlugins.push(pluginName);
+      this.configService.writeConfig();
+
+      await this.pluginManager.stopPluginChild(pluginName);
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public getByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): FastifyReply {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      return reply.code(200).send(plugin.info);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getPluginUpdateByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const pluginUpdateState = await this.getPluginFromNpm(plugin.info);
+
+      return reply.code(200).send(pluginUpdateState);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getVersionsByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const availableVersions = await this.getAvailablePluginVersions(pluginName);
+      return reply.code(200).send(availableVersions);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getChangelogByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & PluginsQueryRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+      const pluginInfo = plugin?.info ?? (await this.searchNpmRegistrySingle(pluginName));
+
+      const version = req.query.pluginversion ?? 'latest';
+
+      // GITHUB API
+      try {
+        const repoMatch = pluginInfo?.links?.homepage?.match(/https:\/\/github.com\/([^/]+)\/([^/#]+)/);
+        const bugsMatch = pluginInfo?.links?.bugs?.match(/https:\/\/github.com\/([^/]+)\/([^/#]+)/);
+        const match: RegExpMatchArray | null | undefined = repoMatch ?? bugsMatch;
+
+        if (match) {
+          const response = await fetchWithTimeout(`https://api.github.com/repos/${match[1]}/${match[2]}/releases`, {
+            method: 'GET',
+          });
+
+          if (!response.ok) {
+            throw new Error(`Failed to fetch changelog from GitHub API - ${response.statusText}`);
+          }
+
+          const data = (await response.json()) as { body: string; tag_name: string }[];
+          const release = version === 'latest' ? data[0] : data.find((x) => x.tag_name === version);
+
+          if (release) {
+            reply.header('Content-Type', 'text/plain');
+            return reply.code(200).send(release.body);
+          }
+        }
+      } catch {
+        //
+      }
+
+      // UNPKG
+      try {
+        const response = await fetchWithTimeout(`https://unpkg.com/${pluginName}@${version}/CHANGELOG.md`, {
+          method: 'GET',
+        });
+
+        if (!response.ok) {
+          throw new Error(`Failed to fetch changelog from UNPKG - ${response.statusText}`);
+        }
+
+        const data = await response.text();
+        reply.header('Content-Type', 'text/plain');
+        return reply.code(200).send(data);
+      } catch {
+        //
+      }
+
+      // LOCAL
+      if (plugin) {
+        try {
+          const changelog = join(plugin.installPath, 'CHANGELOG.md');
+
+          if (await pathExists(changelog)) {
+            const file = await readFile(`${plugin.installPath}/CHANGELOG.md`, 'utf8');
+            reply.header('Content-Type', 'text/plain');
+            return reply.code(200).send(file);
+          }
+        } catch {
+          //
+        }
+      }
+
+      return reply.code(404).send({
+        statusCode: 404,
+        message: 'Changelog not found',
+      });
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getPluginLogoByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(200).send(Buffer.from('').toString('base64'));
+      }
+
+      const logoPath = join(plugin.installPath, 'logo.png');
+
+      if (!(await pathExists(logoPath))) {
+        return reply.code(200).send(Buffer.from('').toString('base64'));
+      }
+
+      let base64Logo: string;
+      pluginLogoCache.purgeStale();
+
+      if (pluginLogoCache.has(pluginName)) {
+        base64Logo = pluginLogoCache.get(pluginName)!;
+      } else {
+        const logo = await sharp(logoPath).resize({ width: 100, height: 100, fit: 'cover', kernel: 'nearest' }).toBuffer();
+        base64Logo = Buffer.from(logo).toString('base64');
+        pluginLogoCache.set(pluginName, base64Logo);
+      }
+
+      reply.header('Content-Type', 'image/png');
+      return reply.code(200).send(`data:image/png;base64,${base64Logo}`);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getConfigByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const pluginWorker = this.service.getPluginProcessByName(pluginName);
+
+      if (!pluginWorker) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const proxy = await pluginWorker.storageProxy();
+      const schemaConfig = await proxy.getConfig();
+
+      const cameraExtension: PluginExtensionConfig = {
+        pluginName: pluginWorker.plugin.pluginName,
+        displayName: pluginWorker.plugin.displayName,
+        type: pluginWorker.plugin.contract.extensions,
+        ...schemaConfig,
+      };
+
+      return reply.code(200).send(cameraExtension);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async patchConfigByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & StoragePatchRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const pluginWorker = this.service.getPluginProcessByName(pluginName);
+
+      if (!pluginWorker) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const proxy = await pluginWorker.storageProxy();
+      await proxy.setConfig(req.body);
+
+      return reply.code(200).send(req.body);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async setConfigByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & StorageSetRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const pluginWorker = this.service.getPluginProcessByName(pluginName);
+
+      if (!pluginWorker) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const proxy = await pluginWorker.storageProxy();
+      await proxy.setValue<undefined>(req.body.key, undefined);
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async submitConfigByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & StorageSubmitRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const pluginWorker = this.service.getPluginProcessByName(pluginName);
+
+      if (!pluginWorker) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const proxy = await pluginWorker.storageProxy();
+      const response = await proxy.submitValue(req.body.key, req.body.payload);
+
+      return reply.code(200).send(response);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getPluginInterface(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const pluginWorker = this.service.getPluginProcessByName(pluginName);
+      const pluginProxy = await pluginWorker?.pluginProxy();
+
+      if (!pluginProxy) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists or not running',
+        });
+      }
+
+      let schemaJson: JsonSchema[] | undefined;
+
+      try {
+        schemaJson = await pluginProxy.interfaceSchema?.();
+      } catch {
+        //
+      }
+
+      return reply.code(200).send(schemaJson);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async detectObjects(
+    req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & PluginsDetectObjectRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply | void> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const pluginWorker = this.service.getPluginProcessByName(pluginName);
+      const pluginProxy = await pluginWorker?.pluginProxy();
+
+      if (!pluginProxy) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists or not running',
+        });
+      }
+
+      if (!req.isMultipart()) {
+        throw new Error('No multipart request!');
+      }
+
+      const file = req.body.upload;
+      if (!file) {
+        return reply.code(400).send({
+          statusCode: 400,
+          message: 'No file uploaded',
+        });
+      }
+
+      const fileBuffer = await file.toBuffer();
+      const response = await pluginProxy.detectObjects?.(fileBuffer, req.body.metadata, req.body.config);
+
+      return reply.code(201).send(response?.detections);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async detectAudio(
+    req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & PluginsDetectAudioRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply | void> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const pluginWorker = this.service.getPluginProcessByName(pluginName);
+      const pluginProxy = await pluginWorker?.pluginProxy();
+
+      if (!pluginProxy) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists or not running',
+        });
+      }
+
+      if (!req.isMultipart()) {
+        throw new Error('No multipart request!');
+      }
+
+      const file = req.body.upload;
+      if (!file) {
+        return reply.code(400).send({
+          statusCode: 400,
+          message: 'No file uploaded',
+        });
+      }
+
+      const fileBuffer = await file.toBuffer();
+      const response = await pluginProxy.detectAudio?.(fileBuffer, req.body.metadata, req.body.config);
+
+      return reply.code(201).send(response?.detected);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async detectMotion(
+    req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & PluginsDetectMotionRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply | void> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const pluginWorker = this.service.getPluginProcessByName(pluginName);
+      const pluginProxy = await pluginWorker?.pluginProxy();
+
+      if (!pluginProxy) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists or not running',
+        });
+      }
+
+      if (!req.isMultipart()) {
+        throw new Error('No multipart request!');
+      }
+
+      const file = req.body.upload;
+      if (!file) {
+        return reply.code(400).send({
+          statusCode: 400,
+          message: 'No file uploaded',
+        });
+      }
+
+      const fileBuffer = await file.toBuffer();
+      const response = await pluginProxy.detectMotion?.(fileBuffer, req.body.config);
+
+      reply.header('Content-Type', 'video/mp4');
+      reply.header('Content-Length', response?.videoData.toString().length ?? 0);
+
+      return reply.send(response?.videoData);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public getContractByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): FastifyReply {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const contract = plugin.contract;
+      const camerasList =
+        contract.extensions.length === 1 && contract.extensions[0] === 'cameraController' ? this.camerasService.listByPluginId(plugin.id) : this.camerasService.list();
+
+      const cameras =
+        camerasList?.map((camera) => {
+          return {
+            name: camera.name,
+            extensions: camera.extensions,
+          };
+        }) || [];
+
+      return reply.code(200).send({ contract, cameras });
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getReadmeByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & PluginsQueryRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      try {
+        const readme = join(plugin.installPath, 'CHANGELOG.md');
+
+        if (await pathExists(readme)) {
+          const file = await readFile(`${plugin.installPath}/README.md`, 'utf8');
+          reply.header('Content-Type', 'text/plain');
+          return reply.code(200).send(file);
+        }
+      } catch {
+        //
+      }
+
+      const version = plugin.info.installedVersion ?? 'latest';
+      const response = await fetchWithTimeout(`https://unpkg.com/${plugin.pluginName}@${version}/README.md`, {
+        method: 'GET',
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to fetch readme from UNPKG - ${response.statusText}`);
+      }
+
+      const data = await response.text();
+
+      return reply.code(200).send(data);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public list(req: FastifyRequest<AuthLoginRequest & PaginationRequest>, reply: FastifyReply): FastifyReply | CameraUiPlugin[] {
+    try {
+      const installedPlugins = this.service.listPlugins();
+      const plugins = installedPlugins.map((plugin) => plugin.info);
+
+      return orderBy(plugins, ['displayName'], ['asc']);
+      // return orderBy(plugins, ['disabled', 'displayName'], ['asc', 'asc']);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public listExtensions(req: FastifyRequest<AuthLoginRequest & PaginationRequest>, reply: FastifyReply): FastifyReply | PluginExtension[] {
+    try {
+      const installedPlugins = this.service.listPlugins();
+      const allExtensions: PluginExtension[] = installedPlugins.map((plugin) => ({
+        pluginName: plugin.pluginName,
+        displayName: plugin.displayName,
+        type: plugin.contract.extensions,
+      }));
+
+      return orderBy(allExtensions, ['displayName'], ['asc']);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async restartByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const pluginProcess = this.service.getPluginProcessByName(pluginName);
+
+      if (!pluginProcess) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin process not initialized',
+        });
+      }
+
+      await pluginProcess.restart();
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public clearLog(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): FastifyReply | void {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      truncate(plugin.logPath, (error) => {
+        if (error) {
+          return reply.code(500).send({
+            statusCode: 500,
+            message: error.message,
+          });
+        }
+
+        this.app.io.of('/logs').emit('clear-plugin-log', pluginName);
+
+        return reply.code(204).send();
+      });
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public downloadLog(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): FastifyReply | void {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const buffer = new Readable();
+      buffer._read = () => {};
+
+      const readStream = createReadStream(plugin.logPath);
+
+      readStream.on('data', (data) => {
+        buffer.push(data.toString('utf8').replace(/\x1b\[[0-9;]*m/g, ''));
+      });
+
+      readStream.on('end', () => {
+        buffer.push(null);
+      });
+
+      reply.header('Content-Type', 'application/octet-stream');
+      reply.header('Content-Disposition', `attachment; filename=camera.ui.${plugin.pluginName}.log.txt`);
+
+      return reply.code(200).send(buffer);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async search(req: FastifyRequest<AuthLoginRequest & PluginsQueryRequest & PaginationRequest>, reply: FastifyReply): Promise<FastifyReply | CameraUiPlugin[]> {
+    try {
+      const query = req.query.pluginname ?? '';
+      const q = (!query?.length ? '' : query + '+') + 'keywords:camera-ui-plugin+not:deprecated&size=30';
+
+      const response = await fetchWithTimeout(`https://registry.npmjs.org/-/v1/search?text=${q}`, {
+        method: 'GET',
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to search the npm registry - ${response.statusText}`);
+      }
+
+      const searchResults = (await response.json()) as INpmSearchResults;
+
+      const result: CameraUiPlugin[] = searchResults.objects
+        .filter((x) => x.package.name.startsWith('camera-ui-') || this.isScopedPlugin(x.package.name))
+        .filter((x) => !searchResultBlacklist.has(x.package.name))
+        .map((pkg) => {
+          let plugin: CameraUiPlugin = {
+            id: '0',
+            pluginName: pkg.package.name,
+            displayName: PluginManager.transformDisplaName(pkg.package.name),
+            private: false,
+            isPython: false,
+            isNode: true,
+            'camera.ui': {
+              extensions: [],
+            },
+          };
+
+          const installedPlugins = this.service.listPlugins();
+          const isInstalled = installedPlugins.find((installedPlugin) => installedPlugin.pluginName === plugin.pluginName);
+
+          if (isInstalled) {
+            plugin = isInstalled.info;
+            plugin.lastUpdated = pkg.package.date;
+            return plugin;
+          }
+
+          plugin.publicPackage = true;
+          plugin.installedVersion = undefined;
+          plugin.latestVersion = pkg.package.version;
+          plugin.lastUpdated = pkg.package.date;
+          plugin.description = pkg.package.description ? pkg.package.description.replace(/(?:https?|ftp):\/\/[\n\S]+/g, '').trim() : pkg.package.name;
+          plugin.links = pkg.package.links;
+          plugin.author = pkg.package.publisher ? pkg.package.publisher.username : undefined;
+
+          return plugin;
+        });
+
+      if (!result.length && (query.startsWith('camera-ui-') || this.isScopedPlugin(query)) && !searchResultBlacklist.has(query.toLowerCase())) {
+        const singlePluginQuey = await this.searchNpmRegistrySingle(query.toLowerCase());
+        return singlePluginQuey ? [singlePluginQuey] : [];
+      }
+
+      return orderBy(result, ['displayName'], ['asc']);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async startByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const pluginProcess = this.service.getPluginProcessByName(pluginName);
+
+      if (!pluginProcess) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin process not initialized',
+        });
+      }
+
+      await pluginProcess.start();
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async stopByName(req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      const pluginProcess = this.service.getPluginProcessByName(pluginName);
+
+      if (!pluginProcess) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin process not initialized',
+        });
+      }
+
+      await pluginProcess.teardown();
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async installOrUpdate(req: FastifyRequest<AuthLoginRequest & PluginsInsertRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      let plugin = this.pluginManager.plugins.get(req.body.pluginname);
+
+      const command = plugin ? 'update' : 'install';
+
+      this.logger.log(`${plugin ? 'Updating' : 'Installing'} plugin: ${req.body.pluginname}@${req.body.pluginversion}`);
+
+      const installPath = await this.service.manage(req.body.pluginname, command, req.body.pluginversion, plugin?.id);
+
+      if (!plugin) {
+        plugin = await this.pluginManager.loadPlugin(installPath);
+
+        this.logger.log(`Plugin installed: ${plugin.pluginName}.${plugin.displayName} (${plugin.info.installedVersion})`);
+
+        this.pluginManager.initializeInstalledPlugin(plugin);
+      } else {
+        this.logger.log(`Plugin updated: ${plugin.pluginName}.${plugin.displayName} (${req.body.pluginversion})`);
+
+        // const pluginProcess = this.service.getPluginProcessByName(req.body.pluginname);
+        // pluginProcess?.restart();
+      }
+
+      npmPluginCache.delete(plugin.pluginName);
+      plugin.reparsePackageJson();
+
+      const serverNsp = this.socketService.namespaces.get('/server');
+      (serverNsp as ServerNamespace).checkPlugins();
+
+      return reply.code(201).send(plugin.info);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async installProgress(req: FastifyRequest<AuthLoginRequest & PaginationRequest>, reply: FastifyReply): Promise<FastifyReply | PluginsProgress[]> {
+    try {
+      const pluginsInProgress = this.service.installingPlugins();
+      return orderBy(pluginsInProgress, ['pluginName'], ['asc']);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async uninstallByName(
+    req: FastifyRequest<AuthLoginRequest & PluginsParamsNameRequest & PluginsParamsRemoveRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply> {
+    try {
+      const pluginName = this.resolvePluginName(req.params);
+      const plugin = this.service.getPluginByName(pluginName);
+
+      if (!plugin) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Plugin not exists',
+        });
+      }
+
+      this.logger.log(`Uninstalling plugin: ${plugin.pluginName}.${plugin.displayName} (${plugin.info.installedVersion})`);
+
+      await this.service.manage(plugin.pluginName, 'uninstall', undefined, plugin.id);
+      await this.pluginManager.removePlugin(plugin, req.query.removeStorage);
+
+      npmPluginCache.delete(plugin.pluginName);
+      npmPluginCache.delete(`lookup-${plugin.pluginName}`);
+
+      this.logger.log(`Plugin uninstalled: ${plugin.pluginName}.${plugin.displayName} (${plugin.info.installedVersion})`);
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async uninstallAll(req: FastifyRequest<AuthLoginRequest & PluginsParamsRemoveRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      this.logger.log('Uninstalling all plugins');
+
+      const plugins = this.service.listPlugins();
+      const pluginNames = plugins.map((plugin) => plugin.pluginName);
+
+      await Promise.all(plugins.map((plugin) => this.service.manage(plugin.pluginName, 'uninstall', undefined, plugin.id)));
+
+      for (const plugin of plugins) {
+        await this.pluginManager.removePlugin(plugin, req.query.removeStorage);
+      }
+
+      const pluginsToDelete = [...pluginNames, ...pluginNames.map((pluginName) => `lookup-${pluginName}`)];
+      pluginsToDelete.forEach((p) => npmPluginCache.delete(p));
+
+      this.logger.log('All plugins uninstalled');
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  private async getAvailablePluginVersions(pluginName: string): Promise<{ tags: Record<string, string>; versions: string[] }> {
+    npmPluginCache.purgeStale();
+
+    const fromCache = npmPluginCache.get(`lookup-${pluginName}`);
+
+    let pkg = fromCache as INpmRegistryModule;
+
+    if (!pkg) {
+      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 versions from npm registry - ${response.statusText}`);
+      }
+
+      pkg = (await response.json()) as INpmRegistryModule;
+    }
+
+    if (!fromCache) {
+      npmPluginCache.set(`lookup-${pluginName}`, pkg, { ttl: 60 * 1000 });
+    }
+
+    return {
+      tags: pkg['dist-tags'],
+      versions: Object.keys(pkg.versions).reverse(),
+    };
+  }
+
+  private async getPluginFromNpm(plugin: CameraUiPlugin): Promise<INpmPluginState> {
+    const pluginState: INpmPluginState = {
+      updateAvailable: false,
+      betaUpdateAvailable: false,
+    };
+
+    if (plugin.private) {
+      return pluginState;
+    }
+
+    try {
+      npmPluginCache.purgeStale();
+
+      // attempt to load from cache
+      const fromCache = npmPluginCache.get(plugin.pluginName);
+
+      let pkg = fromCache as IPackageJson;
+      if (!pkg) {
+        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 check registry.npmjs.org for updates for plugin "${plugin.pluginName}" - ${response.statusText}`);
+        }
+
+        pkg = (await response.json()) as IPackageJson;
+      }
+
+      pluginState.latestVersion = pkg.version;
+
+      try {
+        pluginState.updateAvailable = gt(pkg.version, plugin.installedVersion!);
+      } catch {
+        pluginState.updateAvailable = false;
+      }
+
+      // check for beta updates, if no latest version is available
+      if (!pluginState.updateAvailable) {
+        const pluginVersion = parseVersion(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;
+          }
+        }
+      }
+
+      // store in cache if it was not there already
+      if (!fromCache) {
+        npmPluginCache.set(plugin.pluginName, pkg);
+      }
+    } catch (error: any) {
+      this.logger.error(error);
+      pluginState.latestVersion = undefined;
+      pluginState.updateAvailable = false;
+      pluginState.betaUpdateAvailable = false;
+    }
+
+    return pluginState;
+  }
+
+  private async searchNpmRegistrySingle(query: string, timeout?: number): Promise<CameraUiPlugin | undefined> {
+    try {
+      npmPluginCache.purgeStale();
+
+      const fromCache = npmPluginCache.get(`lookup-${query}`);
+
+      let pkg = fromCache as INpmRegistryModule;
+
+      if (!pkg) {
+        const response = await fetchWithTimeout(
+          `https://registry.npmjs.org/${encodeURIComponent(query).replace(/%40/g, '@')}`,
+          {
+            method: 'GET',
+          },
+          timeout,
+        );
+
+        if (!response.ok) {
+          throw new Error(`Failed to search the npm registry - ${response.statusText}`);
+        }
+
+        pkg = (await response.json()) as INpmRegistryModule;
+      }
+
+      if (!fromCache) {
+        npmPluginCache.set(`lookup-${query}`, pkg, { ttl: 60 * 1000 });
+      }
+
+      if (!pkg.keywords?.includes('camera-ui-plugin')) {
+        return;
+      }
+
+      let plugin: CameraUiPlugin;
+      const installedPlugins = this.service.listPlugins();
+      const isInstalled = installedPlugins.find((installedPlugin) => installedPlugin.pluginName === pkg.name);
+
+      if (isInstalled) {
+        plugin = isInstalled.info;
+        plugin.lastUpdated = pkg.time.modified;
+        return plugin;
+      }
+
+      plugin = {
+        id: '0',
+        pluginName: pkg.name,
+        private: false,
+        displayName: PluginManager.transformDisplaName(pkg.name),
+        description: pkg.description ? pkg.description.replace(/(?:https?|ftp):\/\/[\n\S]+/g, '').trim() : pkg.name,
+        isPython: false,
+        isNode: true,
+        publicPackage: true,
+        latestVersion: pkg['dist-tags'] ? pkg['dist-tags'].latest : undefined,
+        lastUpdated: pkg.time.modified,
+        links: {
+          npm: `https://www.npmjs.com/package/${pkg.name}`,
+          homepage: pkg.homepage,
+        },
+        author: pkg.maintainers[0]?.name,
+        'camera.ui': {
+          extensions: [],
+        },
+      };
+
+      return plugin;
+    } catch (error: any) {
+      if (error.response?.status !== 404) {
+        this.logger.error('Failed to search the npm registry', error);
+      }
+    }
+  }
+
+  private resolvePluginName(params: PluginsParamsNameRequest['Params']): string {
+    if (params.scope) {
+      const at = params.scope.startsWith('@') ? '' : '@';
+      return `${at}${params.scope}/${params.pluginname}`;
+    } else {
+      return params.pluginname;
+    }
+  }
+
+  private isScopedPlugin(pluginName: string): boolean {
+    return pluginName.startsWith('@') && pluginName.split('/').length > 0 && pluginName.split('/')[1]?.startsWith('camera-ui-');
+  }
+}