@camera.ui/server 0.0.1

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

@@ -0,0 +1,1178 @@
+import pty from '@scrypted/node-pty';
+import fixPath from '@seydx/fix-path';
+import { cyan, green, red, yellow } from 'ansicolor';
+import fs from 'fs-extra';
+import { LRUCache } from 'lru-cache';
+import { spawn } from 'node:child_process';
+import { platform, tmpdir, userInfo } from 'node:os';
+import { basename, dirname, join, resolve, sep } from 'path';
+import { gt, parse, satisfies } from 'semver';
+import sharp from 'sharp';
+import { container } from 'tsyringe';
+import { PluginManager } from '../../plugins/index.js';
+import { ConfigService } from '../../services/config/index.js';
+import { orderBy } 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 });
+export class PluginsController {
+    app;
+    logger;
+    configService;
+    io;
+    pluginManager;
+    proxyServer;
+    service;
+    camerasService;
+    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');
+    }
+    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;
+            if (!this.configService.config.plugins.disabledPlugins) {
+                this.configService.config.plugins.disabledPlugins = [];
+            }
+            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 = resolve(plugin.installPath, 'CHANGELOG.md');
+                if (await fs.pathExists(changelog)) {
+                    const file = await fs.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 fs.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(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            const logoPath = resolve(plugin.installPath, 'logo.png');
+            if (!(await fs.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 = resolve(plugin.installPath, 'config.schema.json');
+            if (!(await fs.pathExists(schemaPath))) {
+                return reply.code(200).send();
+            }
+            const schemaJson = await fs.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 fs.mkdtemp(join(tmpdir(), 'cameraui-object-detection-'));
+            const fileName = file.filename;
+            const tempFilePath = resolve(tempDir, fileName);
+            const fileBuffer = await file.toBuffer();
+            await fs.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(fs.unlink(tempFilePath));
+                }
+                if (tempDir) {
+                    promises.push(fs.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 fs.mkdtemp(join(tmpdir(), 'cameraui-audio-detection-'));
+            const fileName = file.filename;
+            const tempFilePath = resolve(tempDir, fileName);
+            const fileBuffer = await file.toBuffer();
+            await fs.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(fs.unlink(tempFilePath));
+                }
+                if (tempDir) {
+                    promises.push(fs.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 fs.mkdtemp(join(tmpdir(), 'cameraui-motion-detection-'));
+            const fileName = file.filename;
+            const tempFilePath = resolve(tempDir, fileName);
+            const fileBuffer = await file.toBuffer();
+            await fs.writeFile(tempFilePath, fileBuffer);
+            const response = await this.proxyServer.requestPluginFn('motionDetection', plugin.id, 'detectMotion', [tempFilePath, req.body.config], 60 * 1000);
+            fs.readFile(response.filePath, async (error, fileBuffer) => {
+                if (error) {
+                    this.logger.error(error);
+                }
+                try {
+                    const promises = [];
+                    if (tempFilePath) {
+                        promises.push(fs.unlink(tempFilePath));
+                    }
+                    if (response.filePath && response.filePath !== tempFilePath) {
+                        promises.push(fs.unlink(response.filePath));
+                    }
+                    if (tempDir) {
+                        promises.push(fs.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 = resolve(plugin.installPath, 'CHANGELOG.md');
+                if (await fs.pathExists(readme)) {
+                    const file = await fs.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,
+            });
+        }
+    }
+    async installOrUpdate(req, reply) {
+        try {
+            let plugin = this.pluginManager.plugins.get(req.body.pluginname);
+            const installPath = await this.managePlugin('install', { pluginName: req.body.pluginname, version: req.body.pluginversion });
+            if (!plugin) {
+                plugin = await this.pluginManager.loadPlugin(`${installPath}/node_modules/${req.body.pluginname}`);
+                this.logger.log(`Plugin installed: ${plugin.pluginName}.${plugin.displayName} (${plugin.info.installedVersion})`);
+                this.logger.log(`Plugin Path: ${plugin.installPath}`);
+                await this.pluginManager.initializeInstalledPlugin(plugin);
+                await this.pluginManager.startPluginChild(plugin.pluginName);
+            }
+            else {
+                this.logger.log(`Plugin updated: ${plugin.pluginName}.${plugin.displayName} (${plugin.info.installedVersion}), restarting ...`);
+                const pluginProcess = this.service.getPluginProcessByName(req.body.pluginname);
+                if (pluginProcess) {
+                    await pluginProcess.restart();
+                }
+            }
+            npmPluginCache.delete(plugin.pluginName);
+            plugin.reparsePackageJson();
+            return reply.code(201).send(plugin.info);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async managePlugin(action, pluginInfo) {
+        pluginInfo.version = pluginInfo.version || 'latest';
+        // convert 'latest' into a real version
+        if (action === 'install' && pluginInfo.version === 'latest') {
+            pluginInfo.version = await this.getNpmModuleLatestVersion(pluginInfo.pluginName);
+        }
+        // set default install path
+        let installPath = this.configService.PLUGINS_INSTALL_PATH;
+        // check if the plugin is currently installed
+        const existingPlugin = this.service.getPluginByName(pluginInfo.pluginName);
+        // if the plugin is already installed, match the installation path
+        if (existingPlugin) {
+            installPath = existingPlugin.installPath;
+        }
+        installPath = this.getLastNodeModulesPath(installPath) || installPath;
+        // prepare flags for npm command
+        const installOptions = [];
+        // check to see if custom plugin path is using a package.json file
+        if (installPath === this.configService.PLUGINS_INSTALL_PATH && (await fs.pathExists(resolve(installPath, '../package.json')))) {
+            installOptions.push('--save');
+        }
+        // install path is one level up
+        installPath = resolve(installPath, '../');
+        // set global flag
+        if (!this.configService.PLUGINS_INSTALL_PATH || platform() === 'win32' || existingPlugin?.info.globalInstall === true) {
+            installOptions.push('-g');
+        }
+        const npmPluginLabel = action === 'uninstall' || action === 'unlink' ? pluginInfo.pluginName : `${pluginInfo.pluginName}@${pluginInfo.version}`;
+        try {
+            await this.runNpmCommand([...this.getNpmPath(), action, ...installOptions, npmPluginLabel], installPath, pluginInfo);
+            // ensure the custom plugin dir was not deleted
+            await this.ensurePluginDirExists();
+            if (pluginInfo.id && (action === 'uninstall' || action === 'unlink')) {
+                await this.camerasService.removeByPluginId(pluginInfo.id);
+            }
+            return installPath;
+        }
+        catch (error) {
+            if (pluginInfo.pluginName === 'camera.ui') {
+                this.io.of('/logs').emit('stdout', yellow('\r\nCleaning up npm cache, please wait...\r\n'));
+                await this.cleanNpmCache();
+                this.io.of('/logs').emit('stdout', yellow('npm cache cleared, please try updating camera.ui again.\r\n'));
+            }
+            throw error;
+        }
+    }
+    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 fs.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 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',
+                });
+            }
+            await this.managePlugin(plugin.isSymLink ? 'unlink' : 'uninstall', { pluginName: plugin.pluginName, id: plugin.id });
+            await this.pluginManager.removePlugin(plugin, true, req.query.removeStorage);
+            npmPluginCache.delete(plugin.pluginName);
+            npmPluginCache.delete(`lookup-${plugin.pluginName}`);
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async uninstallAll(req, reply) {
+        try {
+            const plugins = this.service.installedPlugins();
+            const pluginNames = plugins.map((plugin) => plugin.pluginName);
+            await Promise.all(plugins.map((plugin) => this.managePlugin(plugin.isSymLink ? 'unlink' : 'uninstall', { pluginName: plugin.pluginName, id: plugin.id })));
+            for (const plugin of plugins) {
+                await this.pluginManager.removePlugin(plugin, true, req.query.removeStorage);
+            }
+            const pluginsToDelete = [...pluginNames, ...pluginNames.map((pluginName) => `lookup-${pluginName}`)];
+            pluginsToDelete.forEach((p) => npmPluginCache.delete(p));
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async cleanNpmCache() {
+        const command = [...this.getNpmPath(), 'cache', 'clean', '--force'];
+        if (this.configService.config.plugins.sudo) {
+            command.unshift('sudo', '-E', '-n');
+        }
+        return new Promise((_resolve) => {
+            const child = spawn(command.shift(), command);
+            child.on('exit', (code) => {
+                this.logger.log('npm cache clear command executed with exit code', code);
+                _resolve();
+            });
+            child.on('error', () => {
+                // do nothing
+            });
+        });
+    }
+    async ensurePluginDirExists() {
+        if (!this.configService.PLUGINS_INSTALL_PATH) {
+            return;
+        }
+        if (!(await fs.pathExists(this.configService.PLUGINS_INSTALL_PATH))) {
+            this.logger.warn(`Plugin directory was removed. Re-creating: ${this.configService.PLUGINS_INSTALL_PATH}`);
+            try {
+                await fs.ensureDir(this.configService.PLUGINS_INSTALL_PATH);
+            }
+            catch (error) {
+                this.logger.error('Failed to recreate plugin directory', error);
+            }
+        }
+        if (!(await fs.pathExists(this.configService.PLUGINS_PJSON_FILE))) {
+            this.logger.warn(`Plugin package.json was removed. Re-creating: ${this.configService.PLUGINS_INSTALL_PATH}`);
+            try {
+                await fs.ensureFile(this.configService.PLUGINS_PJSON_FILE);
+                await fs.writeJson(this.configService.PLUGINS_PJSON_FILE, this.pluginsPackageJson(), { spaces: 2 });
+            }
+            catch (error) {
+                this.logger.error('Failed to recreate plugin package.json file', 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(),
+        };
+    }
+    getLastNodeModulesPath(fullPath) {
+        const segments = fullPath.split(sep);
+        const lastNodeModulesIndex = segments.lastIndexOf('node_modules');
+        if (lastNodeModulesIndex !== -1) {
+            return segments.slice(0, lastNodeModulesIndex + 1).join(sep);
+        }
+        else {
+            return null;
+        }
+    }
+    async getNpmModuleLatestVersion(npmModuleName) {
+        try {
+            const response = await fetchInstance(`https://registry.npmjs.org/${npmModuleName}/latest`, {
+                method: 'GET',
+            });
+            const data = await response.json();
+            return data.version;
+        }
+        catch {
+            return 'latest';
+        }
+    }
+    getNpmPath() {
+        fixPath();
+        if (platform() === 'win32') {
+            // if running on windows find the full path to npm
+            const windowsNpmPath = [
+                join(process.env.APPDATA, 'npm/npm.cmd'),
+                join(process.env.ProgramFiles, 'nodejs/npm.cmd'),
+                join(process.env.NVM_SYMLINK || process.env.ProgramFiles + '/nodejs', 'npm.cmd'),
+            ].filter(fs.existsSync);
+            if (windowsNpmPath.length) {
+                return [windowsNpmPath[0]];
+            }
+            else {
+                this.logger.error('ERROR: Cannot find npm binary. You will not be able to manage plugins or update camera.ui.');
+                this.logger.error('ERROR: You might be able to fix this problem by running: npm install -g npm');
+            }
+        }
+        // Linux and macOS don't require the full path to npm / pnpm
+        return ['npm'];
+    }
+    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 || '0.0.1', plugin.installedVersion);
+            // check for beta updates, if no latest version is available
+            if (!pluginState.updateAvailable) {
+                const pluginVersion = parse(plugin.installedVersion);
+                if (pluginVersion?.prerelease[0] === 'beta' && gt(plugin.installedVersion, pluginState.latestVersion || '0.0.1')) {
+                    const versions = await this.getAvailablePluginVersions(plugin.pluginName);
+                    if (versions.tags.beta && gt(versions.tags.beta, plugin.installedVersion)) {
+                        pluginState.betaUpdateAvailable = true;
+                        pluginState.latestVersion = versions.tags.beta;
+                    }
+                }
+            }
+            // 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;
+    }
+    pluginsPackageJson() {
+        return {
+            private: true,
+            name: 'plugins',
+            version: '1.0.0',
+            description: 'camera.ui plugins',
+            dependencies: {},
+        };
+    }
+    async removeSynologyMetadata() {
+        if (!this.configService.PLUGINS_INSTALL_PATH) {
+            return;
+        }
+        const offendingPath = resolve(this.configService.PLUGINS_INSTALL_PATH, '@eaDir');
+        try {
+            if (!(await fs.pathExists(offendingPath))) {
+                await fs.remove(offendingPath);
+            }
+        }
+        catch (error) {
+            this.logger.error(`Failed to remove ${offendingPath}`, error);
+        }
+    }
+    async runNpmCommand(command, cwd, pluginInfo) {
+        // remove synology @eaDir folders from the node_modules
+        await this.removeSynologyMetadata();
+        let timeoutTimer;
+        command = command.filter((x) => x.length);
+        // sudo mode is requested in plugin config
+        if (this.configService.config.plugins.sudo) {
+            command.unshift('sudo', '-E', '-n');
+        }
+        else {
+            // do a pre-check to test for write access when not using sudo mode
+            try {
+                await fs.access(resolve(cwd, 'node_modules'), fs.constants.W_OK);
+            }
+            catch {
+                this.io
+                    .of('/logs')
+                    .emit(`stdout/${pluginInfo.pluginName}`, yellow(`The user "${userInfo().username}" does not have write access to the target directory:\n\r\n\r`));
+                this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, `${resolve(cwd, 'node_modules')}\n\r\n\r`);
+                this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, yellow('This may cause the operation to fail.\n\r'));
+                this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, yellow('See the docs for details on how to enable sudo mode:\n\r'));
+            }
+        }
+        this.logger.log(`Running Command: ${command.join(' ')}`);
+        if (!satisfies(process.version, `>=${ConfigService.MIN_NODE_VERSION}`)) {
+            this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, yellow(`Node.js v${ConfigService.MIN_NODE_VERSION} higher is required for camera.ui.\n\r`));
+            this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, yellow(`You may experience issues while running on Node.js ${process.version}.\n\r\n\r`));
+        }
+        // set up the environment for the call
+        const env = {};
+        Object.assign(env, process.env);
+        Object.assign(env, {
+            npm_config_global_style: 'true',
+            npm_config_unsafe_perm: 'true',
+            npm_config_update_notifier: 'false',
+            npm_config_prefer_online: 'true',
+            npm_config_foreground_scripts: 'true',
+            npm_config_loglevel: 'error',
+        });
+        // set global prefix for unix based systems
+        if (command.includes('-g') && basename(cwd) === 'lib') {
+            cwd = dirname(cwd);
+            Object.assign(env, {
+                npm_config_prefix: cwd,
+            });
+        }
+        // on windows, we want to ensure the global prefix is the same as the installation path
+        if (platform() === 'win32') {
+            Object.assign(env, {
+                npm_config_prefix: cwd,
+            });
+        }
+        this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, cyan(`\n\rUSER: ${userInfo().username}\n\r`));
+        this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, cyan(`DIR: ${cwd}\n\r`));
+        this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, cyan(`CMD: ${command.join(' ')}\n\r\n\r`));
+        await new Promise((_resolve, _reject) => {
+            const term = pty.spawn(command.shift(), command, {
+                name: 'xterm-color',
+                cols: 80,
+                rows: 30,
+                cwd,
+                env,
+            });
+            // send stdout data from the process to all clients
+            term.onData((data) => {
+                this.io.of('/logs').emit(`stdout/${pluginInfo.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.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, green('\n\rOperation succeeded!.\n\r\n\r'));
+                    _resolve(null);
+                }
+                else {
+                    this.io.of('/logs').emit(`stdout/${pluginInfo.pluginName}`, red('\n\rOperation failed!.\n\r\n\r'));
+                    _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 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;
+    }
+}
+//# sourceMappingURL=plugins.controller.js.map