camera.ui3 0.0.30-alpha.0

package/dist/server/src/api/controllers/plugins.controller.js

@@ -0,0 +1,1284 @@
+import { spawn as spawnPty } from '@scrypted/node-pty';
+import { cyan, green, red, yellow } from 'ansicolor';
+import { ensureDir, move, pathExists, readJSON, readJson, remove, writeJson } from 'fs-extra/esm';
+import { LRUCache } from 'lru-cache';
+import { createHash } from 'node:crypto';
+import { constants, readFile as readFileSync } from 'node:fs';
+import { access, mkdtemp, readFile, rmdir, unlink, writeFile } from 'node:fs/promises';
+import { platform, tmpdir, userInfo } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { gt, parse as parseVersion, satisfies } from 'semver';
+import sharp from 'sharp';
+import { x as extract } from 'tar';
+import { container } from 'tsyringe';
+import { PluginManager } from '../../plugins/index.js';
+import { ConfigService } from '../../services/config/index.js';
+import { getNpmPath } from '../../utils/npm.js';
+import { orderBy, sleep } from '../../utils/utils.js';
+import { CamerasService } from '../services/cameras.service.js';
+import { PluginsService } from '../services/plugins.service.js';
+import fetchInstance from '../utils/fetch.js';
+const npmPluginCache = new LRUCache({ ttl: 300, max: 100, allowStale: false });
+const searchResultBlacklist = new Set(['camera.ui', 'homebridge-camera-ui']);
+const pluginLogoCache = new LRUCache({ max: 100, ttl: 1000 * 60 * 60 * 24 });
+export class PluginsController {
+    app;
+    logger;
+    configService;
+    io;
+    pluginManager;
+    proxyServer;
+    service;
+    camerasService;
+    socketService;
+    constructor(app) {
+        this.app = app;
+        this.io = app.io;
+        this.service = new PluginsService();
+        this.camerasService = new CamerasService();
+        this.logger = container.resolve('logger');
+        this.configService = container.resolve('configService');
+        this.pluginManager = container.resolve('pluginManager');
+        this.proxyServer = container.resolve('proxy');
+        this.socketService = container.resolve('socketService');
+    }
+    async enableByName(req, reply) {
+        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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async disableByName(req, reply) {
+        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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    getByName(req, reply) {
+        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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getPluginUpdateByName(req, reply) {
+        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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getVersionsByName(req, reply) {
+        try {
+            const pluginName = this.resolvePluginName(req.params);
+            const availableVersions = await this.getAvailablePluginVersions(pluginName);
+            return reply.code(200).send(availableVersions);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getChangelogByName(req, reply) {
+        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 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 {
+                //
+            }
+            const version = plugin.info.installedVersion || 'latest';
+            const response = await fetchInstance(`https://unpkg.com/${plugin.pluginName}@${version}/CHANGELOG.md`, {
+                method: 'GET',
+            });
+            const data = await response.text();
+            return reply.code(200).send(data);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getConfigJsonByName(req, reply) {
+        try {
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.service.getPluginByName(pluginName);
+            const configFile = plugin?.configFile;
+            if (!plugin || !configFile) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin or Plugin Config not exists',
+                });
+            }
+            const config = (await readJSON(configFile, { throws: false })) || {};
+            reply.header('Content-Type', 'application/json');
+            return reply.code(200).send(config);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getPluginLogoByName(req, reply) {
+        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;
+            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(base64Logo);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getPluginSchemaByName(req, reply) {
+        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 schemaPath = join(plugin.installPath, 'config.schema.json');
+            if (!(await pathExists(schemaPath))) {
+                return reply.code(200).send();
+            }
+            const schemaJson = await readJson(schemaPath, { throws: false });
+            reply.header('Content-Type', 'application/json');
+            return reply.code(200).send(schemaJson);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getPluginInterface(req, reply) {
+        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 { type } = req.query.type;
+            const schemaJson = await this.proxyServer.requestPluginFn(type, plugin.id, 'interfaceSchema', []);
+            reply.header('Content-Type', 'application/json');
+            return reply.code(200).send(schemaJson);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async detectObjects(req, reply) {
+        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 (!req.isMultipart()) {
+                throw new Error('No multipart request!');
+            }
+            const file = req.body.upload;
+            const tempDir = await mkdtemp(join(tmpdir(), 'cameraui-object-detection-'));
+            const fileName = file.filename;
+            const tempFilePath = join(tempDir, fileName);
+            const fileBuffer = await file.toBuffer();
+            await writeFile(tempFilePath, fileBuffer);
+            const response = await this.proxyServer.requestPluginFn('objectDetection', plugin.id, 'detectObjects', [tempFilePath, req.body.metadata, req.body.config], 15000);
+            try {
+                const promises = [];
+                if (tempFilePath) {
+                    promises.push(unlink(tempFilePath));
+                }
+                if (tempDir) {
+                    promises.push(rmdir(tempDir));
+                }
+                await Promise.allSettled(promises);
+            }
+            catch {
+                //
+            }
+            return reply.code(201).send(response.detections);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async detectAudio(req, reply) {
+        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 (!req.isMultipart()) {
+                throw new Error('No multipart request!');
+            }
+            const file = req.body.upload;
+            const tempDir = await mkdtemp(join(tmpdir(), 'cameraui-audio-detection-'));
+            const fileName = file.filename;
+            const tempFilePath = join(tempDir, fileName);
+            const fileBuffer = await file.toBuffer();
+            await writeFile(tempFilePath, fileBuffer);
+            const response = await this.proxyServer.requestPluginFn('audioDetection', plugin.id, 'detectAudio', [tempFilePath, req.body.metadata, req.body.config], 15000);
+            try {
+                const promises = [];
+                if (tempFilePath) {
+                    promises.push(unlink(tempFilePath));
+                }
+                if (tempDir) {
+                    promises.push(rmdir(tempDir));
+                }
+                await Promise.allSettled(promises);
+            }
+            catch {
+                //
+            }
+            return reply.code(201).send(response.detected);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async detectMotion(req, reply) {
+        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 (!req.isMultipart()) {
+                throw new Error('No multipart request!');
+            }
+            const file = req.body.upload;
+            const tempDir = await mkdtemp(join(tmpdir(), 'cameraui-motion-detection-'));
+            const fileName = file.filename;
+            const tempFilePath = join(tempDir, fileName);
+            const fileBuffer = await file.toBuffer();
+            await writeFile(tempFilePath, fileBuffer);
+            const response = await this.proxyServer.requestPluginFn('motionDetection', plugin.id, 'detectMotion', [tempFilePath, req.body.config], 60 * 1000);
+            readFileSync(response.filePath, async (error, fileBuffer) => {
+                if (error) {
+                    this.logger.error(error);
+                }
+                try {
+                    const promises = [];
+                    if (tempFilePath) {
+                        promises.push(unlink(tempFilePath));
+                    }
+                    if (response.filePath && response.filePath !== tempFilePath) {
+                        promises.push(unlink(response.filePath));
+                    }
+                    if (tempDir) {
+                        promises.push(rmdir(tempDir));
+                    }
+                    await Promise.allSettled(promises);
+                }
+                catch {
+                    //
+                }
+                reply.send(error || fileBuffer);
+            });
+            reply.header('Content-Type', 'application/octet-stream');
+            reply.header('Content-Disposition', 'attachment; filename=video.mp4');
+            return reply;
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async submitActionButtonByName(req, reply) {
+        try {
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.service.getPluginByName(pluginName);
+            const configFile = plugin?.configFile;
+            if (!plugin || !configFile) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin or Plugin Config not exists',
+                });
+            }
+            const toastMessage = await this.proxyServer.requestPluginFn('base', plugin.id, 'onFormSubmit', [req.body.actionId, req.body.payload]);
+            return reply.code(201).send(toastMessage);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    getContractByName(req, reply) {
+        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 = plugin.contract.extension || plugin.contract.supportAdditionalCameras ? this.camerasService.list() : this.camerasService.listByPluginId(plugin.id);
+            const cameras = camerasList?.map((camera) => {
+                return {
+                    name: camera.name,
+                    extensions: camera.extensions,
+                };
+            }) || [];
+            return reply.code(200).send({ contract, cameras });
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getReadmeByName(req, reply) {
+        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 fetchInstance(`https://unpkg.com/${plugin.pluginName}@${version}/README.md`, {
+                method: 'GET',
+            });
+            const data = await response.text();
+            return reply.code(200).send(data);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getReleaseByName(req, reply) {
+        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 repoMatch = plugin.info.links?.homepage?.match(/https:\/\/github.com\/([^/]+)\/([^/#]+)/);
+            if (!repoMatch) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: '"homepage" not exists in package.json or is not a github repo',
+                });
+            }
+            const response = await fetchInstance(`https://api.github.com/repos/${repoMatch[1]}/${repoMatch[2]}/releases/latest`, {
+                method: 'GET',
+            });
+            const data = await response.json();
+            return reply.code(200).send({
+                name: data.name,
+                changelog: data.body,
+            });
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    list(req, reply) {
+        try {
+            const installedPlugins = this.service.installedPlugins();
+            const plugins = installedPlugins.map((plugin) => plugin.info);
+            return orderBy(plugins, ['displayName'], ['asc']);
+            // return orderBy(plugins, ['disabled', 'displayName'], ['asc', 'asc']);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    listExtensions(req, reply) {
+        try {
+            const installedPlugins = this.service.installedPlugins();
+            const allExtensions = installedPlugins
+                .filter((plugin) => plugin.contract.extension || plugin.contract.supportAdditionalCameras)
+                .map((plugin) => ({
+                pluginName: plugin.pluginName,
+                displayName: plugin.displayName,
+                type: plugin.contract.extension ? [plugin.contract.extension] : plugin.contract.builtIns,
+            }));
+            return orderBy(allExtensions, ['displayName'], ['asc']);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async patchConfigJsonByName(req, reply) {
+        try {
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.service.getPluginByName(pluginName);
+            const configFile = plugin?.configFile;
+            if (!plugin || !configFile) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin or Plugin Config not exists',
+                });
+            }
+            let configData = req.body;
+            if (typeof req.body === 'string') {
+                try {
+                    configData = JSON.parse(req.body);
+                }
+                catch {
+                    //
+                }
+            }
+            await writeJson(configFile, configData, { spaces: 2 });
+            return reply.code(201).send(configData);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async restartByName(req, reply) {
+        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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async search(req, reply) {
+        try {
+            const query = req.query.pluginname || '';
+            const q = (!query || !query.length ? '' : query + '+') + 'keywords:camera-ui-plugin+not:deprecated&size=30';
+            let searchResults;
+            try {
+                const response = await fetchInstance(`https://registry.npmjs.org/-/v1/search?text=${q}`, {
+                    method: 'GET',
+                });
+                searchResults = await response.json();
+            }
+            catch (error) {
+                throw new Error(`Failed to search the npm registry - "${error.message}"`);
+            }
+            const result = searchResults.objects
+                .filter((x) => x.package.name.indexOf('camera-ui-') === 0 || this.isScopedPlugin(x.package.name))
+                .filter((x) => !searchResultBlacklist.has(x.package.name))
+                .map((pkg) => {
+                let plugin = {
+                    id: '0',
+                    pluginName: pkg.package.name,
+                    displayName: PluginManager.transformDisplaName(pkg.package.name),
+                    private: false,
+                    isPython: false,
+                    isNode: true,
+                };
+                const installedPlugins = this.service.installedPlugins();
+                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.indexOf('camera-ui-') === 0 || this.isScopedPlugin(query)) && !searchResultBlacklist.has(query.toLowerCase())) {
+                const singlePluginQuey = await this.searchNpmRegistrySingle(query.toLowerCase());
+                return singlePluginQuey;
+            }
+            return orderBy(result, ['displayName'], ['asc']);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async startByName(req, reply) {
+        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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async stopByName(req, reply) {
+        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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async installOrUpdate(req, reply) {
+        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.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}), restarting ...`);
+                const pluginProcess = this.service.getPluginProcessByName(req.body.pluginname);
+                pluginProcess?.restart();
+            }
+            npmPluginCache.delete(plugin.pluginName);
+            plugin.reparsePackageJson();
+            const serverNsp = this.socketService.namespaces.get('/server');
+            serverNsp.checkUpdate();
+            return reply.code(201).send(plugin.info);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async updateServer(req, reply) {
+        try {
+            this.logger.log(`Updating server: ${ConfigService.APP_NAME}@${req.body.pluginversion}`);
+            const installPath = await this.manage(ConfigService.APP_NAME, 'installServer', req.body.pluginversion);
+            this.logger.log(`Server updated: ${ConfigService.APP_NAME}@${ConfigService.VERSION} (${installPath})`);
+            const serverNsp = this.socketService.namespaces.get('/server');
+            serverNsp.checkUpdate();
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async uninstallByName(req, reply) {
+        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.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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async uninstallAll(req, reply) {
+        try {
+            this.logger.log('Uninstalling all plugins');
+            const plugins = this.service.installedPlugins();
+            const pluginNames = plugins.map((plugin) => plugin.pluginName);
+            await Promise.all(plugins.map((plugin) => this.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) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async manage(pluginName, action, version, pluginId) {
+        if (pluginName === ConfigService.APP_NAME && !ConfigService.INSTALL_PATH) {
+            throw new Error(`Can not determine the install path for ${pluginName}`);
+        }
+        const dir = pluginName === ConfigService.APP_NAME ? ConfigService.INSTALL_PATH : this.configService.PLUGINS_INSTALL_PATH;
+        let targetDir;
+        if (pluginName === ConfigService.APP_NAME) {
+            targetDir = dir;
+        }
+        else {
+            targetDir = join(dir, pluginName);
+        }
+        this.emitProgress(pluginName, `\n\rUSER: ${userInfo().username}\n\r`, cyan);
+        this.emitProgress(pluginName, `DIR: ${targetDir}\n\r`, cyan);
+        this.emitProgress(pluginName, `ACTION: ${action}\n\r\n\r`, cyan);
+        await this.removeSynologyMetadata();
+        switch (action) {
+            case 'install':
+                await this.installPlugin(pluginName, version || 'latest', targetDir);
+                break;
+            case 'installServer':
+                await this.installServer(pluginName, version || 'latest', targetDir);
+                break;
+            case 'update':
+                await this.updatePlugin(pluginName, version || 'latest', targetDir);
+                break;
+            case 'uninstall':
+                await this.uninstallPlugin(pluginName, targetDir);
+                await sleep(2000);
+                break;
+            default:
+                throw new Error(`Unknown action: ${action}`);
+        }
+        await this.ensurePluginDirExists();
+        if (pluginId && action === 'uninstall' && pluginName !== ConfigService.APP_NAME) {
+            await this.camerasService.removeByPluginId(pluginId);
+        }
+        return targetDir;
+    }
+    async installServer(pluginName, version, targetDir) {
+        await this.removeSynologyMetadata();
+        const upgradeInstallScriptPath = join(targetDir, 'upgrade-server.sh');
+        let timeoutTimer;
+        const command = [upgradeInstallScriptPath, version, targetDir];
+        try {
+            await access(join(targetDir, 'node_modules'), constants.W_OK);
+        }
+        catch {
+            this.emitProgress(pluginName, `The user "${userInfo().username}" does not have write access to the target directory:\n\r\n\r`, yellow);
+            this.emitProgress(pluginName, `${join(targetDir, 'node_modules')}\n\r\n\r`);
+            this.emitProgress(pluginName, 'This may cause the operation to fail.\n\r\n\r', yellow);
+        }
+        this.logger.log(`Running Command: ${command.join(' ')}`);
+        if (!satisfies(process.version, `>=${ConfigService.MIN_NODE_VERSION}`)) {
+            this.emitProgress(pluginName, `Node.js v${ConfigService.MIN_NODE_VERSION} higher is required for ${ConfigService.APP_NAME}.\n\r`, yellow);
+            this.emitProgress(pluginName, `You may experience issues while running on Node.js ${process.version}.\n\r\n\r`, yellow);
+        }
+        // set up the environment for the call
+        const env = {};
+        Object.assign(env, process.env);
+        Object.assign(env, {
+            // npm_config_install_strategy: 'shallow',
+            npm_config_unsafe_perm: 'true',
+            npm_config_update_notifier: 'false',
+            npm_config_prefer_online: 'true',
+            npm_config_foreground_scripts: 'true',
+            npm_config_loglevel: 'info',
+            npm_config_prefix: targetDir,
+        });
+        // set global prefix for unix based systems
+        if (platform() !== 'win32') {
+            if (basename(targetDir) === 'lib') {
+                Object.assign(env, {
+                    npm_config_prefix: dirname(targetDir),
+                });
+            }
+        }
+        await new Promise((_resolve, _reject) => {
+            const term = spawnPty(command.shift(), command, {
+                name: 'xterm-color',
+                cols: 80,
+                rows: 30,
+                cwd: targetDir,
+                env,
+            });
+            // send stdout data from the process to all clients
+            term.onData((data) => {
+                this.emitProgress(pluginName, data);
+            });
+            // send an error message to the client if the command does not exit with code 0
+            term.onExit((error) => {
+                clearTimeout(timeoutTimer);
+                if (error.exitCode === 0) {
+                    this.emitProgress(pluginName, `\n\rServer ${pluginName}@${version} has been successfully updated.\n\r\n\r`, green);
+                    _resolve(null);
+                }
+                else {
+                    this.emitProgress(pluginName, `\n\rError during update of ${pluginName}@${version}.\n\r\n\r`, red);
+                    _reject(new Error('Operation failed. Please review log for details.'));
+                }
+            });
+            // if the command spends to long trying to execute kill it after 5 minutes
+            timeoutTimer = setTimeout(() => {
+                term.kill('SIGTERM');
+            }, 300000);
+        });
+    }
+    async installPlugin(pluginName, version, targetDir, update) {
+        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\n\r\n\r', green);
+            const tarballData = await this.downloadWithProgress(tarballUrl, pluginName, version);
+            this.emitProgress(pluginName, ' - Done\n\r\n\r', 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\n\r\n\r', green);
+            await ensureDir(targetDir);
+            this.emitProgress(pluginName, '> Extracting package...');
+            await new Promise((_resolve, _reject) => {
+                const extractStream = extract({
+                    cwd: targetDir,
+                    strip: 1,
+                });
+                extractStream.on('error', _reject);
+                extractStream.on('end', () => {
+                    this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+                    _resolve();
+                });
+                extractStream.write(Buffer.from(tarballData));
+                extractStream.end();
+            });
+            await this.installProductionDependencies(targetDir, pluginName);
+            this.emitProgress(pluginName, `\n\rPlugin ${pluginName}@${version} has been successfully ${update ? 'updated' : 'installed'}.\n\r\n\r`, green);
+        }
+        catch (error) {
+            this.emitProgress(pluginName, `\n\rError during ${update ? 'update' : 'installation'} of ${pluginName}@${version}.\n\r\n\r`, red);
+            throw error;
+        }
+    }
+    async updatePlugin(pluginName, version, targetDir) {
+        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, ' Break', red);
+                this.emitProgress(pluginName, `Plugin ${pluginName} is already up to date\n\r\n\r`, green);
+                return;
+            }
+            const tempNodeModules = join(targetDir, 'node_modules_temp');
+            await move(join(targetDir, 'node_modules'), tempNodeModules);
+            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            let cleaningUp = false;
+            try {
+                await this.installPlugin(pluginName, version, targetDir, true);
+                this.emitProgress(pluginName, '> Cleaning up...');
+                cleaningUp = true;
+                await remove(tempNodeModules);
+                this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            }
+            catch (error) {
+                if (cleaningUp) {
+                    this.emitProgress(pluginName, ' Error\n\r\n\r', red);
+                }
+                this.emitProgress(pluginName, ' Restoring previous version...');
+                await remove(targetDir);
+                await move(tempNodeModules, targetDir);
+                this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+                throw error;
+            }
+        }
+        catch (error) {
+            this.emitProgress(pluginName, `\n\rError during update of ${pluginName}@${version}.\n\r\n\r`, red);
+            throw error;
+        }
+    }
+    async uninstallPlugin(pluginName, targetDir) {
+        try {
+            this.emitProgress(pluginName, '> Fetching plugin information...');
+            const pluginInstalled = await pathExists(targetDir);
+            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            if (!pluginInstalled) {
+                this.emitProgress(pluginName, `Plugin ${pluginName} is not installed. Break\n\r\n\r`, red);
+                return;
+            }
+            this.emitProgress(pluginName, '> Uninstalling plugin...');
+            await remove(targetDir);
+            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            this.emitProgress(pluginName, `Plugin ${pluginName} has been successfully uninstalled.\n\r`, green);
+        }
+        catch (error) {
+            this.emitProgress(pluginName, ' Error\n\r\n\r', red);
+            this.emitProgress(pluginName, `\n\rError during uninstallation of ${pluginName}.\n\r\n\r`, red);
+            throw error;
+        }
+    }
+    async installProductionDependencies(packageDir, pluginName) {
+        await new Promise((_resolve, _reject) => {
+            this.emitProgress(pluginName, '> Installing dependencies...\n\r\n\r');
+            const command = [...getNpmPath(), 'install', '--omit=dev', '--loglevel', 'info'];
+            const env = {};
+            Object.assign(env, process.env);
+            Object.assign(env, {
+                // npm_config_global_style: 'false',
+                // npm_config_install_strategy: 'shallow',
+                npm_config_unsafe_perm: 'true',
+                npm_config_update_notifier: 'false',
+                npm_config_prefer_online: 'true',
+                npm_config_foreground_scripts: 'true',
+                npm_config_loglevel: 'info',
+                npm_config_prefix: packageDir,
+            });
+            // set global prefix for unix based systems
+            if (platform() !== 'win32') {
+                if (basename(packageDir) === 'lib') {
+                    packageDir = dirname(packageDir);
+                    Object.assign(env, {
+                        npm_config_prefix: packageDir,
+                    });
+                }
+            }
+            this.logger.log(`Running Command: ${command.join(' ')}`);
+            const term = spawnPty(command.shift(), command, {
+                name: 'xterm-color',
+                cols: 80,
+                rows: 30,
+                cwd: packageDir,
+                env,
+            });
+            // send stdout data from the process to all clients
+            term.onData((data) => {
+                this.emitProgress(pluginName, data);
+            });
+            // send an error message to the client if the command does not exit with code 0
+            term.onExit((error) => {
+                clearTimeout(timeoutTimer);
+                if (error.exitCode === 0) {
+                    _resolve(null);
+                }
+                else {
+                    _reject(new Error('Operation failed. Please review log for details.'));
+                }
+            });
+            // if the command spends to long trying to execute kill it after 5 minutes
+            const timeoutTimer = setTimeout(() => {
+                term.kill('SIGTERM');
+            }, 300000);
+        });
+    }
+    async ensurePluginDirExists() {
+        if (!this.configService.PLUGINS_INSTALL_PATH) {
+            return;
+        }
+        if (!(await pathExists(this.configService.PLUGINS_INSTALL_PATH))) {
+            this.logger.warn(`Plugin directory was removed. Re-creating: ${this.configService.PLUGINS_INSTALL_PATH}`);
+            try {
+                await ensureDir(this.configService.PLUGINS_INSTALL_PATH);
+            }
+            catch (error) {
+                this.logger.error('Failed to recreate plugin directory', error);
+            }
+        }
+    }
+    async getAvailablePluginVersions(pluginName) {
+        const fromCache = npmPluginCache.get(`lookup-${pluginName}`);
+        let pkg = fromCache;
+        if (!pkg) {
+            const response = await fetchInstance(`https://registry.npmjs.org/${encodeURIComponent(pluginName).replace(/%40/g, '@')}`, {
+                method: 'GET',
+                headers: {
+                    accept: 'application/vnd.npm.install-v1+json', // only return minimal information
+                },
+            });
+            pkg = (await response.json());
+        }
+        if (!fromCache) {
+            npmPluginCache.set(`lookup-${pluginName}`, pkg, { ttl: 60 * 1000 });
+        }
+        return {
+            tags: pkg['dist-tags'],
+            versions: Object.keys(pkg.versions).reverse(),
+        };
+    }
+    async getPluginFromNpm(plugin) {
+        const pluginState = {
+            updateAvailable: false,
+            betaUpdateAvailable: false,
+        };
+        try {
+            // attempt to load from cache
+            const fromCache = npmPluginCache.get(plugin.pluginName);
+            let pkg = fromCache;
+            if (!pkg) {
+                const response = await fetchInstance(`https://registry.npmjs.org/${encodeURIComponent(plugin.pluginName).replace(/%40/g, '@')}/latest`, {
+                    method: 'GET',
+                });
+                pkg = (await response.json());
+            }
+            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 = 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) {
+            if (error.response?.status !== 404) {
+                this.logger.error(`[${plugin.pluginName}] Failed to check registry.npmjs.org for updates`, error);
+            }
+            pluginState.latestVersion = undefined;
+            pluginState.updateAvailable = false;
+            pluginState.betaUpdateAvailable = false;
+        }
+        return pluginState;
+    }
+    async removeSynologyMetadata() {
+        if (!this.configService.PLUGINS_INSTALL_PATH) {
+            return;
+        }
+        const offendingPath = join(this.configService.PLUGINS_INSTALL_PATH, '@eaDir');
+        try {
+            if (!(await pathExists(offendingPath))) {
+                await remove(offendingPath);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Failed to remove ${offendingPath}`, error);
+        }
+    }
+    async searchNpmRegistrySingle(query) {
+        try {
+            const fromCache = npmPluginCache.get(`lookup-${query}`);
+            let pkg = fromCache;
+            if (!pkg) {
+                const response = await fetchInstance(`https://registry.npmjs.org/${encodeURIComponent(query).replace(/%40/g, '@')}`, {
+                    method: 'GET',
+                });
+                pkg = (await response.json());
+            }
+            if (!fromCache) {
+                npmPluginCache.set(`lookup-${query}`, pkg, { ttl: 60 * 1000 });
+            }
+            if (!pkg.keywords || !pkg.keywords.includes('camera-ui-plugin')) {
+                return [];
+            }
+            let plugin;
+            const installedPlugins = this.service.installedPlugins();
+            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,
+            };
+            return [plugin];
+        }
+        catch (error) {
+            if (error.response?.status !== 404) {
+                this.logger.error('Failed to search the npm registry', error);
+            }
+            return [];
+        }
+    }
+    resolvePluginName(params) {
+        if (params.scope) {
+            const at = params.scope.startsWith('@') ? '' : '@';
+            return `${at}${params.scope}/${params.pluginname}`;
+        }
+        else {
+            return params.pluginname;
+        }
+    }
+    isScopedPlugin(pluginName) {
+        return pluginName.charAt(0) === '@' && pluginName.split('/').length > 0 && pluginName.split('/')[1]?.indexOf('camera-ui-') === 0;
+    }
+    async downloadWithProgress(url, pluginName, version) {
+        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 = [];
+        const reader = response.body.getReader();
+        this.emitProgress(pluginName, `> Downloading ${pluginName}@${version}...\n\r`);
+        // eslint-disable-next-line no-constant-condition
+        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();
+    }
+    getProgressBar(percent) {
+        const width = 50;
+        const complete = Math.round(width * (percent / 100));
+        const incomplete = width - complete;
+        return `[${'='.repeat(complete)}${'-'.repeat(incomplete)}]`;
+    }
+    emitProgress(pluginName, message, color) {
+        this.io.of('/logs').emit(`stdout/${pluginName}`, color ? color(message) : message);
+    }
+}
+//# sourceMappingURL=plugins.controller.js.map