camera.ui3 0.0.34-alpha.6 → 0.0.35-test.2

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

@@ -1,1353 +0,0 @@
-import { getNpmPath, orderBy, sleep } from '@camera.ui/common';
-import TTLCache from '@isaacs/ttlcache';
-import { spawn as spawnPty } from '@scrypted/node-pty';
-import AdmZip from 'adm-zip';
-import { cyan, green, red, yellow } from 'ansicolor';
-import { ensureDir, move, pathExists, readJSON, readJson, remove, writeJson } from 'fs-extra/esm';
-import { createHash } from 'node:crypto';
-import { constants, createReadStream, readFile as readFileSync, truncate } 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 { Readable } from 'node:stream';
-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 { APP_NAME } from '../../services/config/constants.js';
-import { ConfigService } from '../../services/config/index.js';
-import { CamerasService } from '../services/cameras.service.js';
-import { PluginsService } from '../services/plugins.service.js';
-import fetchInstance from '../utils/fetch.js';
-const npmPluginCache = new TTLCache({ ttl: 300, max: 100 });
-const searchResultBlacklist = new Set(['camera.ui', 'homebridge-camera-ui']);
-const pluginLogoCache = new TTLCache({ 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;
-            pluginLogoCache.purgeStale();
-            if (pluginLogoCache.has(pluginName)) {
-                base64Logo = pluginLogoCache.get(pluginName);
-            }
-            else {
-                const logo = await sharp(logoPath).resize({ width: 100, height: 100, fit: 'cover', kernel: 'nearest' }).toBuffer();
-                base64Logo = Buffer.from(logo).toString('base64');
-                pluginLogoCache.set(pluginName, base64Logo);
-            }
-            reply.header('Content-Type', 'image/png');
-            return reply.code(200).send(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,
-            });
-        }
-    }
-    clearLog(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',
-                });
-            }
-            truncate(plugin.logPath, (error) => {
-                if (error) {
-                    return reply.code(500).send({
-                        statusCode: 500,
-                        message: error.message,
-                    });
-                }
-                this.app.io.of('/logs').emit('clear-plugin-log', pluginName);
-                return reply.code(204).send();
-            });
-        }
-        catch (error) {
-            return reply.code(500).send({
-                statusCode: 500,
-                message: error.message,
-            });
-        }
-    }
-    downloadLog(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 buffer = new Readable();
-            buffer._read = () => { };
-            const readStream = createReadStream(plugin.logPath);
-            readStream.on('data', (data) => {
-                buffer.push(data.toString('utf8').replace(/\x1b\[[0-9;]*m/g, ''));
-            });
-            readStream.on('end', () => {
-                buffer.push(null);
-            });
-            reply.header('Content-Type', 'application/octet-stream');
-            reply.header('Content-Disposition', `attachment; filename=camera.ui.${plugin.pluginName}.log.txt`);
-            return reply.code(200).send(buffer);
-        }
-        catch (error) {
-            return reply.code(500).send({
-                statusCode: 500,
-                message: error.message,
-            });
-        }
-    }
-    async search(req, reply) {
-        try {
-            const query = req.query.pluginname ?? '';
-            const q = (!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.startsWith('camera-ui-') || 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.startsWith('camera-ui-') || 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.checkPlugins();
-            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: ${APP_NAME}@${req.body.pluginversion}`);
-            const installPath = await this.manage(APP_NAME, 'installServer', req.body.pluginversion);
-            this.logger.log(`Server updated: ${APP_NAME}@${ConfigService.VERSION} (${installPath})`);
-            const serverNsp = this.socketService.namespaces.get('/server');
-            serverNsp.checkServer();
-            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 === APP_NAME && !ConfigService.INSTALL_PATH) {
-            throw new Error(`Can not determine the install path for ${pluginName}`);
-        }
-        const dir = pluginName === APP_NAME ? ConfigService.INSTALL_PATH : this.configService.PLUGINS_INSTALL_PATH;
-        let targetDir;
-        if (pluginName === APP_NAME) {
-            targetDir = dir;
-        }
-        else {
-            targetDir = join(dir, pluginName);
-        }
-        this.emitProgress(pluginName, `\r\nUSER: ${userInfo().username}\r\n`, cyan);
-        this.emitProgress(pluginName, `DIR: ${targetDir}\r\n`, cyan);
-        this.emitProgress(pluginName, `ACTION: ${action}\r\r\n\n`, 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 !== 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:\r\n\r\n`, yellow);
-            this.emitProgress(pluginName, `${join(targetDir, 'node_modules')}\r\n\r\n`);
-            this.emitProgress(pluginName, 'This may cause the operation to fail.\r\n\r\n', 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 ${APP_NAME}.\r\n`, yellow);
-            this.emitProgress(pluginName, `You may experience issues while running on Node.js ${process.version}.\r\n\r\n`, 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, `\r\nServer ${pluginName}@${version} has been successfully updated.\r\n\r\n`, green);
-                    _resolve(null);
-                }
-                else {
-                    this.emitProgress(pluginName, `\r\nError during update of ${pluginName}@${version}.\r\n\r\n`, 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) {
-        const backupTempDir = join(tmpdir(), `${pluginName}_backup`);
-        try {
-            const npmRegistry = 'https://registry.npmjs.org';
-            const packageUrl = `${npmRegistry}/${pluginName}/${version}`;
-            this.emitProgress(pluginName, '> Fetching package information...');
-            const response = await fetch(packageUrl);
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            const packageInfo = await response.json();
-            const tarballUrl = packageInfo.dist.tarball;
-            const expectedShasum = packageInfo.dist.shasum;
-            this.emitProgress(pluginName, ' Done\r\n\r\n', green);
-            const tarballData = await this.downloadWithProgress(tarballUrl, pluginName, version);
-            this.emitProgress(pluginName, ' - Done\r\n\r\n', green);
-            this.emitProgress(pluginName, '> Verifying package integrity...');
-            const computedShasum = createHash('sha1').update(Buffer.from(tarballData)).digest('hex');
-            if (computedShasum !== expectedShasum) {
-                throw new Error(`SHA checksum mismatch. Expected: ${expectedShasum}, Got: ${computedShasum}`);
-            }
-            this.emitProgress(pluginName, ' Done\r\n\r\n', green);
-            if (await pathExists(targetDir)) {
-                this.emitProgress(pluginName, '> Backing up existing installation...');
-                await move(targetDir, backupTempDir);
-                this.emitProgress(pluginName, ' Done\r\n\r\n', green);
-            }
-            await ensureDir(targetDir);
-            this.emitProgress(pluginName, '> Extracting package...');
-            await new Promise((_resolve, _reject) => {
-                const extractStream = extract({
-                    cwd: targetDir,
-                    strip: 1,
-                });
-                extractStream.on('error', _reject);
-                extractStream.on('end', () => {
-                    this.emitProgress(pluginName, ' Done\r\n\r\n', green);
-                    _resolve();
-                });
-                extractStream.write(Buffer.from(tarballData));
-                extractStream.end();
-            });
-            await this.installProductionDependencies(targetDir, pluginName);
-            await this.extrackBundeledPlugin(targetDir, pluginName);
-            this.emitProgress(pluginName, '\r\n> Cleaning up...');
-            await remove(backupTempDir);
-            this.emitProgress(pluginName, ' Done\r\n\r\n', green);
-            this.emitProgress(pluginName, `Plugin ${pluginName}@${version} has been successfully ${update ? 'updated' : 'installed'}.\r\n\r\n`, green);
-        }
-        catch (error) {
-            this.emitProgress(pluginName, `\r\nError during ${update ? 'update' : 'installation'} of ${pluginName}@${version}.\r\n\r\n`, red);
-            try {
-                this.emitProgress(pluginName, '> Restoring previous version...');
-                await remove(targetDir);
-                await move(backupTempDir, targetDir);
-                this.emitProgress(pluginName, ' Done\r\n\r\n', green);
-            }
-            catch (error) {
-                this.emitProgress(pluginName, `\r\n\r\nError: ${error.message}\r\n`, red);
-                this.emitProgress(pluginName, 'Failed to restore previous version.\r\n\r\n', red);
-            }
-            throw error;
-        }
-    }
-    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, `Plugin ${pluginName} is already up to date.\r\n\r\n`, green);
-                return;
-            }
-            this.emitProgress(pluginName, ' Done\r\n\r\n', green);
-            await this.installPlugin(pluginName, version, targetDir, true);
-        }
-        catch (error) {
-            this.emitProgress(pluginName, `\r\nError during update of ${pluginName}@${version}.\r\n\r\n`, red);
-            throw error;
-        }
-    }
-    async uninstallPlugin(pluginName, targetDir) {
-        try {
-            this.emitProgress(pluginName, '> Removing plugin...');
-            await remove(targetDir);
-            this.emitProgress(pluginName, ' Done\r\n\r\n', green);
-            this.emitProgress(pluginName, `Plugin ${pluginName} has been successfully uninstalled.\r\n`, green);
-        }
-        catch (error) {
-            this.emitProgress(pluginName, ' Error\r\n\r\n', red);
-            this.emitProgress(pluginName, `\r\nError during uninstallation of ${pluginName}.\r\n\r\n`, red);
-            throw error;
-        }
-    }
-    async installProductionDependencies(packageDir, pluginName) {
-        await new Promise((_resolve, _reject) => {
-            this.emitProgress(pluginName, '> Installing dependencies...\r\n\r\n');
-            const command = [...getNpmPath(), 'install', '--omit=dev', '--include=prod', '--loglevel', 'info'];
-            const env = {};
-            Object.assign(env, process.env);
-            Object.assign(env, {
-                // npm_config_global_style: 'false',
-                // npm_config_install_strategy: 'shallow',
-                NODE_ENV: 'production',
-                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 extrackBundeledPlugin(packageDir, pluginName) {
-        const bundlePath = join(packageDir, 'bundle.zip');
-        const isBundeledPlugin = await pathExists(bundlePath);
-        if (!isBundeledPlugin) {
-            return;
-        }
-        this.emitProgress(pluginName, '\r\n> Extracting bundled plugin...');
-        const zip = new AdmZip(bundlePath);
-        zip.extractAllTo(packageDir, true);
-        await remove(bundlePath);
-        this.emitProgress(pluginName, ' Done', green);
-    }
-    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) {
-        npmPluginCache.purgeStale();
-        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 {
-            npmPluginCache.purgeStale();
-            // 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 {
-            npmPluginCache.purgeStale();
-            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?.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.startsWith('@') && pluginName.split('/').length > 0 && pluginName.split('/')[1]?.startsWith('camera-ui-');
-    }
-    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}...\r\n`);
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-                break;
-            }
-            chunks.push(value);
-            receivedLength += value.length;
-            const percentComplete = Math.round((receivedLength / contentLength) * 100);
-            const progressBar = this.getProgressBar(percentComplete);
-            this.emitProgress(pluginName, `\r${progressBar} ${percentComplete}%`, cyan);
-        }
-        return await new Blob(chunks).arrayBuffer();
-    }
-    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