@camera.ui/server 0.0.14-alpha.4 → 0.0.14-test.0

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

@@ -3,21 +3,20 @@ import { cyan, green, red, yellow } from 'ansicolor';
 import fs from 'fs-extra';
 import { LRUCache } from 'lru-cache';
 import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { platform, tmpdir, userInfo } from 'node:os';
-import { basename, dirname, join, parse, resolve, sep } from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { basename, dirname, join, resolve } from 'node:path';
 import { gt, parse as parseVersion, satisfies } from 'semver';
 import sharp from 'sharp';
+import { x as extract } from 'tar';
 import { container } from 'tsyringe';
 import { PluginManager } from '../../plugins/index.js';
 import { ConfigService } from '../../services/config/index.js';
 import { getNpmPath } from '../../utils/npm.js';
-import { orderBy } from '../../utils/utils.js';
+import { orderBy, sleep } from '../../utils/utils.js';
 import { CamerasService } from '../services/cameras.service.js';
 import { PluginsService } from '../services/plugins.service.js';
 import fetchInstance from '../utils/fetch.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
 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 });
@@ -545,96 +544,6 @@ export class PluginsController {
             });
         }
     }
-    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}`);
-                this.pluginManager.initializeInstalledPlugin(plugin);
-            }
-            else {
-                this.logger.log(`Plugin updated: ${plugin.pluginName}.${plugin.displayName} (${plugin.info.installedVersion}), restarting ...`);
-                const pluginProcess = this.service.getPluginProcessByName(req.body.pluginname);
-                pluginProcess?.restart();
-            }
-            npmPluginCache.delete(plugin.pluginName);
-            plugin.reparsePackageJson();
-            const serverNsp = this.socketService.namespaces.get('/server');
-            serverNsp.checkUpdate();
-            return reply.code(201).send(plugin.info);
-        }
-        catch (error) {
-            return reply.code(500).send({
-                statusCode: 500,
-                message: error.message,
-            });
-        }
-    }
-    async updateSystem(req, reply) {
-        try {
-            const installPath = await this.managePlugin('install', { pluginName: req.body.pluginname, version: req.body.pluginversion });
-            this.logger.log(`System updated: ${ConfigService.APP_NAME}@${ConfigService.VERSION} (${installPath})`);
-            const serverNsp = this.socketService.namespaces.get('/server');
-            serverNsp.checkUpdate();
-            return reply.code(204).send();
-        }
-        catch (error) {
-            return reply.code(500).send({
-                statusCode: 500,
-                message: error.message,
-            });
-        }
-    }
-    async managePlugin(action, pluginInfo) {
-        pluginInfo.version = pluginInfo.version || 'latest';
-        if (pluginInfo.pluginName === ConfigService.APP_NAME) {
-            if (action === 'uninstall' || action === 'unlink') {
-                throw new Error(`Cannot uninstall ${pluginInfo.pluginName} from ${ConfigService.APP_NAME}.`);
-            }
-            if (!ConfigService.INSTALL_PATH) {
-                throw new Error(`Can not determine the install path for ${pluginInfo.pluginName}`);
-            }
-        }
-        if (action === 'install' && pluginInfo.version === 'latest') {
-            pluginInfo.version = await this.getNpmModuleLatestVersion(pluginInfo.pluginName);
-        }
-        let installPath = this.configService.PLUGINS_INSTALL_PATH;
-        if (pluginInfo.pluginName === ConfigService.APP_NAME) {
-            installPath = ConfigService.INSTALL_PATH;
-        }
-        else {
-            const existingPlugin = this.service.getPluginByName(pluginInfo.pluginName);
-            if (existingPlugin) {
-                installPath = existingPlugin.installPath;
-            }
-        }
-        installPath = this.getLastNodeModulesPath(installPath) || installPath;
-        installPath = resolve(installPath, '../');
-        const installOptions = [];
-        if (platform() === 'win32' || pluginInfo.pluginName === ConfigService.APP_NAME) {
-            installOptions.push('-g');
-        }
-        const npmPluginLabel = action === 'uninstall' || action === 'unlink' ? pluginInfo.pluginName : `${pluginInfo.pluginName}@${pluginInfo.version}`;
-        try {
-            await this.runNpmCommand([...getNpmPath(), action, ...installOptions, npmPluginLabel], installPath, pluginInfo);
-            await this.ensurePluginDirExists();
-            if (pluginInfo.id && (action === 'uninstall' || action === 'unlink') && pluginInfo.pluginName !== ConfigService.APP_NAME) {
-                await this.camerasService.removeByPluginId(pluginInfo.id);
-            }
-            return installPath;
-        }
-        catch (error) {
-            if (pluginInfo.pluginName === ConfigService.APP_NAME) {
-                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();
@@ -834,6 +743,90 @@ export class PluginsController {
             });
         }
     }
+    ////////////////////////////
+    async installOrUpdate(req, reply) {
+        try {
+            let plugin = this.pluginManager.plugins.get(req.body.pluginname);
+            const command = plugin ? 'update' : 'install';
+            this.logger.log(`${plugin ? 'Updating' : 'Installing'} plugin: ${req.body.pluginname}@${req.body.pluginversion}`);
+            const installPath = await this.manage(req.body.pluginname, command, req.body.pluginversion, plugin?.id);
+            if (!plugin) {
+                plugin = await this.pluginManager.loadPlugin(installPath);
+                this.logger.log(`Plugin installed: ${plugin.pluginName}.${plugin.displayName} (${plugin.info.installedVersion})`);
+                this.pluginManager.initializeInstalledPlugin(plugin);
+            }
+            else {
+                this.logger.log(`Plugin updated: ${plugin.pluginName}.${plugin.displayName} (${req.body.pluginversion}), restarting ...`);
+                const pluginProcess = this.service.getPluginProcessByName(req.body.pluginname);
+                pluginProcess?.restart();
+            }
+            npmPluginCache.delete(plugin.pluginName);
+            plugin.reparsePackageJson();
+            const serverNsp = this.socketService.namespaces.get('/server');
+            serverNsp.checkUpdate();
+            return reply.code(201).send(plugin.info);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async updateServer(req, reply) {
+        try {
+            this.logger.log(`Updating server: ${ConfigService.APP_NAME}@${req.body.pluginversion}`);
+            const installPath = await this.manage(ConfigService.APP_NAME, 'installServer', req.body.pluginversion);
+            this.logger.log(`Server updated: ${ConfigService.APP_NAME}@${ConfigService.VERSION} (${installPath})`);
+            const serverNsp = this.socketService.namespaces.get('/server');
+            serverNsp.checkUpdate();
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    // public async managePlugin(action: 'install' | 'uninstall' | 'unlink', pluginInfo: PluginData): Promise<string> {
+    //   pluginInfo.version = pluginInfo.version || 'latest';
+    //   if (pluginInfo.pluginName === ConfigService.APP_NAME) {
+    //     if (action === 'uninstall' || action === 'unlink') {
+    //       throw new Error(`Cannot uninstall ${pluginInfo.pluginName} from ${ConfigService.APP_NAME}.`);
+    //     }
+    //     if (!ConfigService.INSTALL_PATH) {
+    //       throw new Error(`Can not determine the install path for ${pluginInfo.pluginName}`);
+    //     }
+    //   }
+    //   if (action === 'install' && pluginInfo.version === 'latest') {
+    //     pluginInfo.version = await this.getNpmModuleLatestVersion(pluginInfo.pluginName);
+    //   }
+    //   let installPath = this.configService.PLUGINS_INSTALL_PATH;
+    //   if (pluginInfo.pluginName === ConfigService.APP_NAME) {
+    //     installPath = ConfigService.INSTALL_PATH!;
+    //   }
+    //   const installOptions: string[] = [];
+    //   if (platform() === 'win32' || pluginInfo.pluginName === ConfigService.APP_NAME) {
+    //     installOptions.push('-g');
+    //   }
+    //   const npmPluginLabel = action === 'uninstall' || action === 'unlink' ? pluginInfo.pluginName : `${pluginInfo.pluginName}@${pluginInfo.version}`;
+    //   try {
+    //     await this.runNpmCommand([...getNpmPath(), action, ...installOptions, npmPluginLabel], installPath, pluginInfo);
+    //     await this.ensurePluginDirExists();
+    //     if (pluginInfo.id && (action === 'uninstall' || action === 'unlink') && pluginInfo.pluginName !== ConfigService.APP_NAME) {
+    //       await this.camerasService.removeByPluginId(pluginInfo.id);
+    //     }
+    //     return installPath;
+    //   } catch (error: any) {
+    //     if (pluginInfo.pluginName === ConfigService.APP_NAME) {
+    //       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;
+    //   }
+    // }
     async uninstallByName(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
@@ -844,10 +837,12 @@ export class PluginsController {
                     message: 'Plugin not exists',
                 });
             }
-            await this.managePlugin(plugin.isSymLink ? 'unlink' : 'uninstall', { pluginName: plugin.pluginName, id: plugin.id });
+            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) {
@@ -859,14 +854,16 @@ export class PluginsController {
     }
     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.managePlugin(plugin.isSymLink ? 'unlink' : 'uninstall', { pluginName: plugin.pluginName, id: plugin.id })));
+            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) {
@@ -876,6 +873,381 @@ export class PluginsController {
             });
         }
     }
+    // private async runNpmCommand(command: Array<string>, cwd: string, pluginInfo: PluginData): Promise<void> {
+    //   // remove synology @eaDir folders from the node_modules
+    //   await this.removeSynologyMetadata();
+    //   let timeoutTimer: NodeJS.Timeout;
+    //   command = command.filter((x) => x.length);
+    //   let sudoEnabled = this.configService.config.plugins.sudo;
+    //   if (pluginInfo.pluginName === ConfigService.APP_NAME) {
+    //     sudoEnabled = true;
+    //     if (!command.includes('-g')) {
+    //       command.push('-g');
+    //     }
+    //   } else {
+    //     const pluginDir = resolve(this.configService.PLUGINS_INSTALL_PATH, pluginInfo.pluginName);
+    //     await fs.mkdir(resolve(pluginDir, 'node_modules'), { recursive: true });
+    //     cwd = pluginDir;
+    //     // Entfernen Sie -g, falls vorhanden
+    //     command = command.filter((arg) => arg !== '-g');
+    //     // Fügen Sie --prefix hinzu, um den spezifischen Pluginordner zu verwenden
+    //     // command.push('--prefix', pluginDir);
+    //     if (command[1] === 'install') {
+    //       // Extrahieren Sie den Paketnamen und die Version
+    //       const packageSpec = command[command.length - 1];
+    //       // Ändern Sie den Installationsbefehl
+    //       command = [command[0], 'install', '--no-save', packageSpec];
+    //     }
+    //   }
+    //   if (sudoEnabled) {
+    //     command.unshift('sudo', '-E', '-n');
+    //   } else if (pluginInfo.pluginName !== ConfigService.APP_NAME) {
+    //     // 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: 'false',
+    //     npm_config_unsafe_perm: 'true',
+    //     npm_config_update_notifier: 'false',
+    //     npm_config_prefer_online: 'true',
+    //     npm_config_foreground_scripts: 'true',
+    //     npm_config_loglevel: pluginInfo.pluginName === ConfigService.APP_NAME ? 'verbose' : 'error',
+    //     npm_config_prefix: cwd,
+    //   });
+    //   // set global prefix for unix based systems
+    //   if (pluginInfo.pluginName === ConfigService.APP_NAME && platform() !== 'win32') {
+    //     if (basename(cwd) === 'lib') {
+    //       cwd = dirname(cwd);
+    //       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: string) => {
+    //       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: { exitCode: number; signal?: number | undefined }) => {
+    //       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 manage(pluginName, action, version, pluginId) {
+        if (pluginName === ConfigService.APP_NAME && !ConfigService.INSTALL_PATH) {
+            throw new Error(`Can not determine the install path for ${pluginName}`);
+        }
+        const targetDir = pluginName === ConfigService.APP_NAME ? join(ConfigService.INSTALL_PATH, ConfigService.APP_NAME) : join(this.configService.PLUGINS_INSTALL_PATH, pluginName);
+        this.emitProgress(pluginName, `\n\rUSER: ${userInfo().username}\n\r`, cyan);
+        this.emitProgress(pluginName, `DIR: ${this.configService.PLUGINS_INSTALL_PATH}\n\r`, cyan);
+        this.emitProgress(pluginName, `ACTION: ${action}\n\r\n\r`, cyan);
+        await this.removeSynologyMetadata();
+        try {
+            switch (action) {
+                case 'install':
+                    await this.installPlugin(pluginName, version || 'latest', targetDir);
+                    break;
+                case 'installServer':
+                    await this.installServer(pluginName, version || 'latest', targetDir);
+                    break;
+                case 'update':
+                    await this.updatePlugin(pluginName, version || 'latest', targetDir);
+                    break;
+                case 'uninstall':
+                    await this.uninstallPlugin(pluginName, targetDir);
+                    await sleep(2000);
+                    break;
+                default:
+                    throw new Error(`Unknown action: ${action}`);
+            }
+            await this.ensurePluginDirExists();
+            if (pluginId && action === 'uninstall' && pluginName !== ConfigService.APP_NAME) {
+                await this.camerasService.removeByPluginId(pluginId);
+            }
+            return targetDir;
+        }
+        catch (error) {
+            if (pluginName === ConfigService.APP_NAME) {
+                this.emitProgress(pluginName, 'Cleaning up npm cache, please wait...\r\n', yellow);
+                await this.cleanNpmCache();
+                this.emitProgress(pluginName, 'Cache cleared, please try updating camera.ui again.\r\n', yellow);
+            }
+            throw error;
+        }
+    }
+    async installServer(pluginName, version, targetDir) {
+        await this.removeSynologyMetadata();
+        const prefix = dirname(dirname(dirname(targetDir)));
+        const upgradeInstallScriptPath = join(targetDir, 'upgrade-server.sh');
+        let timeoutTimer;
+        const command = [upgradeInstallScriptPath, version, prefix];
+        try {
+            await fs.access(resolve(targetDir, 'node_modules'), fs.constants.W_OK);
+        }
+        catch {
+            this.emitProgress(pluginName, `The user "${userInfo().username}" does not have write access to the target directory:\n\r\n\r`, yellow);
+            this.emitProgress(pluginName, `${resolve(targetDir, 'node_modules')}\n\r\n\r`, yellow);
+            this.emitProgress(pluginName, 'This may cause the operation to fail.\n\r', yellow);
+            this.emitProgress(pluginName, 'See the docs for details on how to enable sudo mode:\n\r', yellow);
+            throw new Error('Operation failed. Please review log for details.');
+        }
+        this.logger.log(`Running Command: ${command.join(' ')}`);
+        if (!satisfies(process.version, `>=${ConfigService.MIN_NODE_VERSION}`)) {
+            this.emitProgress(pluginName, `Node.js v${ConfigService.MIN_NODE_VERSION} higher is required for ${ConfigService.APP_NAME}.\n\r`, yellow);
+            this.emitProgress(pluginName, `You may experience issues while running on Node.js ${process.version}.\n\r\n\r`, yellow);
+        }
+        // set up the environment for the call
+        const env = {};
+        Object.assign(env, process.env);
+        Object.assign(env, {
+            npm_config_install_strategy: 'shallow',
+            npm_config_unsafe_perm: 'true',
+            npm_config_update_notifier: 'false',
+            npm_config_prefer_online: 'true',
+            npm_config_foreground_scripts: 'true',
+            npm_config_loglevel: 'verbose',
+            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),
+                });
+            }
+        }
+        this.io.of('/logs').emit(`stdout/${pluginName}`, cyan(`\n\rUSER: ${userInfo().username}\n\r`));
+        this.io.of('/logs').emit(`stdout/${pluginName}`, cyan(`DIR: ${targetDir}\n\r`));
+        this.io.of('/logs').emit(`stdout/${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: targetDir,
+                env,
+            });
+            // send stdout data from the process to all clients
+            term.onData((data) => {
+                this.io.of('/logs').emit(`stdout/${pluginName}`, data);
+            });
+            // send an error message to the client if the command does not exit with code 0
+            term.onExit((error) => {
+                clearTimeout(timeoutTimer);
+                if (error.exitCode === 0) {
+                    this.emitProgress(pluginName, `\n\rPlugin ${pluginName}@${version} has been successfully updated.\n\r\n\r`, green);
+                    _resolve(null);
+                }
+                else {
+                    this.emitProgress(pluginName, `\n\rError during installation of ${pluginName}@${version}.\n\r\n\r`, red);
+                    _reject(new Error('Operation failed. Please review log for details.'));
+                }
+            });
+            // if the command spends to long trying to execute kill it after 5 minutes
+            timeoutTimer = setTimeout(() => {
+                term.kill('SIGTERM');
+            }, 300000);
+        });
+    }
+    async installPlugin(pluginName, version, targetDir, update) {
+        try {
+            const npmRegistry = 'https://registry.npmjs.org';
+            const packageUrl = `${npmRegistry}/${pluginName}/${version}`;
+            this.emitProgress(pluginName, '> Fetching package information...');
+            // Hole Paketinformationen vom npm-Registry
+            const response = await fetch(packageUrl);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const packageInfo = await response.json();
+            const tarballUrl = packageInfo.dist.tarball;
+            const expectedShasum = packageInfo.dist.shasum;
+            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            const tarballData = await this.downloadWithProgress(tarballUrl, pluginName, version);
+            this.emitProgress(pluginName, ' - Done\n\r\n\r', green);
+            this.emitProgress(pluginName, '> Verifying package integrity...');
+            const computedShasum = createHash('sha1').update(Buffer.from(tarballData)).digest('hex');
+            if (computedShasum !== expectedShasum) {
+                throw new Error(`SHA checksum mismatch. Expected: ${expectedShasum}, Got: ${computedShasum}`);
+            }
+            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            // Erstelle das Zielverzeichnis
+            await fs.ensureDir(targetDir);
+            this.emitProgress(pluginName, '> Extracting package...');
+            // Entpacke das Tarball direkt in das Zielverzeichnis
+            await new Promise((resolve, reject) => {
+                const extractStream = extract({
+                    cwd: targetDir,
+                    strip: 1,
+                });
+                extractStream.on('error', reject);
+                extractStream.on('end', () => {
+                    this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+                    resolve();
+                });
+                extractStream.write(Buffer.from(tarballData));
+                extractStream.end();
+            });
+            await this.installProductionDependencies(targetDir, pluginName);
+            this.emitProgress(pluginName, `\n\rPlugin ${pluginName}@${version} has been successfully ${update ? 'updated' : 'installed'}.\n\r\n\r`, green);
+        }
+        catch (error) {
+            this.emitProgress(pluginName, `\n\rError during ${update ? 'update' : 'installation'} of ${pluginName}@${version}.\n\r\n\r`, red);
+            throw error;
+        }
+    }
+    async updatePlugin(pluginName, version, targetDir) {
+        try {
+            this.emitProgress(pluginName, '> Preparing update...');
+            const packageJsonPath = join(targetDir, 'package.json');
+            const packageJson = await fs.readJson(packageJsonPath);
+            const currentVersion = packageJson.version;
+            if (currentVersion === version) {
+                this.emitProgress(pluginName, ' Break', red);
+                this.emitProgress(pluginName, `Plugin ${pluginName} is already up to date\n\r\n\r`, green);
+                return;
+            }
+            const tempNodeModules = join(targetDir, 'node_modules_temp');
+            await fs.move(join(targetDir, 'node_modules'), tempNodeModules);
+            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            let cleaningUp = false;
+            try {
+                await this.installPlugin(pluginName, version, targetDir, true);
+                this.emitProgress(pluginName, '> Cleaning up...');
+                cleaningUp = true;
+                await fs.remove(tempNodeModules);
+                this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            }
+            catch (error) {
+                if (cleaningUp) {
+                    this.emitProgress(pluginName, ' Error\n\r\n\r', red);
+                }
+                this.emitProgress(pluginName, ' Restoring previous version...');
+                await fs.remove(targetDir);
+                await fs.move(tempNodeModules, targetDir);
+                this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+                throw error;
+            }
+        }
+        catch (error) {
+            this.emitProgress(pluginName, `\n\rError during update of ${pluginName}@${version}.\n\r\n\r`, red);
+            throw error;
+        }
+    }
+    async uninstallPlugin(pluginName, targetDir) {
+        try {
+            this.emitProgress(pluginName, '> Fetching plugin information...');
+            const pluginInstalled = await fs.pathExists(targetDir);
+            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            if (!pluginInstalled) {
+                this.emitProgress(pluginName, `Plugin ${pluginName} is not installed. Break\n\r\n\r`, red);
+                return;
+            }
+            this.emitProgress(pluginName, '> Uninstalling plugin...');
+            await fs.remove(targetDir);
+            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            this.emitProgress(pluginName, `Plugin ${pluginName} has been successfully uninstalled.\n\r`, green);
+        }
+        catch (error) {
+            this.emitProgress(pluginName, ' Error\n\r\n\r', red);
+            this.emitProgress(pluginName, `\n\rError during uninstallation of ${pluginName}.\n\r\n\r`, red);
+            throw error;
+        }
+    }
+    async installProductionDependencies(packageDir, pluginName) {
+        await new Promise((_resolve, _reject) => {
+            this.emitProgress(pluginName, '> Installing dependencies...\n\r\n\r');
+            const command = [...getNpmPath(), 'install', '--omit=dev', '--verbose'];
+            const env = {};
+            Object.assign(env, process.env);
+            Object.assign(env, {
+                // npm_config_global_style: 'false',
+                npm_config_install_strategy: 'shallow',
+                npm_config_unsafe_perm: 'true',
+                npm_config_update_notifier: 'false',
+                npm_config_prefer_online: 'true',
+                npm_config_foreground_scripts: 'true',
+                npm_config_loglevel: 'verbose',
+                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 = pty.spawn(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 cleanNpmCache() {
         const command = [...getNpmPath(), 'cache', 'clean', '--force'];
         if (this.configService.config.plugins.sudo) {
@@ -905,16 +1277,6 @@ export class PluginsController {
                 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}`);
@@ -936,28 +1298,17 @@ export class PluginsController {
             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';
-        }
-    }
+    // private async getNpmModuleLatestVersion(npmModuleName: string): Promise<string> {
+    //   try {
+    //     const response = await fetchInstance(`https://registry.npmjs.org/${npmModuleName}/latest`, {
+    //       method: 'GET',
+    //     });
+    //     const data: IPackageJson = await response.json();
+    //     return data.version!;
+    //   } catch {
+    //     return 'latest';
+    //   }
+    // }
     async getPluginFromNpm(plugin) {
         const pluginState = {
             updateAvailable: false,
@@ -1001,15 +1352,6 @@ export class PluginsController {
         }
         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;
@@ -1024,100 +1366,6 @@ export class PluginsController {
             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);
-        let sudoEnabled = this.configService.config.plugins.sudo;
-        if (pluginInfo.pluginName === ConfigService.APP_NAME) {
-            try {
-                await fs.access(resolve(cwd, 'node_modules'), fs.constants.W_OK);
-                sudoEnabled = false;
-            }
-            catch {
-                sudoEnabled = true;
-            }
-        }
-        if (sudoEnabled) {
-            command.unshift('sudo', '-E', '-n');
-        }
-        else if (pluginInfo.pluginName !== ConfigService.APP_NAME) {
-            // 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: pluginInfo.pluginName === ConfigService.APP_NAME ? 'true' : 'false',
-            npm_config_unsafe_perm: 'true',
-            npm_config_update_notifier: 'false',
-            npm_config_prefer_online: 'true',
-            npm_config_foreground_scripts: 'true',
-            npm_config_loglevel: pluginInfo.pluginName === ConfigService.APP_NAME ? 'verbose' : '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}`);
@@ -1168,20 +1416,6 @@ export class PluginsController {
             return [];
         }
     }
-    findInstalledPath() {
-        let currentDir = __dirname;
-        while (currentDir !== parse(currentDir).root) {
-            const nodeModulesDir = join(currentDir, 'node_modules');
-            if (fs.existsSync(nodeModulesDir)) {
-                const moduleDir = join(nodeModulesDir, 'test'); // 'test' ist der Name Ihres Moduls
-                if (fs.existsSync(moduleDir)) {
-                    return nodeModulesDir;
-                }
-            }
-            currentDir = dirname(currentDir);
-        }
-        return null;
-    }
     resolvePluginName(params) {
         if (params.scope) {
             const at = params.scope.startsWith('@') ? '' : '@';
@@ -1194,5 +1428,38 @@ export class PluginsController {
     isScopedPlugin(pluginName) {
         return pluginName.charAt(0) === '@' && pluginName.split('/').length > 0 && pluginName.split('/')[1]?.indexOf('camera-ui-') === 0;
     }
+    async downloadWithProgress(url, pluginName, version) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        const contentLength = Number(response.headers.get('Content-Length'));
+        let receivedLength = 0;
+        const chunks = [];
+        const reader = response.body.getReader();
+        this.emitProgress(pluginName, `> Downloading ${pluginName}@${version}...\n\r`);
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            chunks.push(value);
+            receivedLength += value.length;
+            const percentComplete = Math.round((receivedLength / contentLength) * 100);
+            const progressBar = this.getProgressBar(percentComplete);
+            this.emitProgress(pluginName, `\r${progressBar} ${percentComplete}%`, cyan);
+        }
+        return await new Blob(chunks).arrayBuffer();
+    }
+    getProgressBar(percent) {
+        const width = 50;
+        const complete = Math.round(width * (percent / 100));
+        const incomplete = width - complete;
+        return `[${'='.repeat(complete)}${'-'.repeat(incomplete)}]`;
+    }
+    emitProgress(pluginName, message, color) {
+        this.io.of('/logs').emit(`stdout/${pluginName}`, color ? color(message) : message);
+    }
 }
 //# sourceMappingURL=plugins.controller.js.map