@camera.ui/server 0.0.22-alpha.0 → 0.0.22-alpha.2

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

@@ -1,26 +1,26 @@
+import { getNpmPath, orderBy } from '@camera.ui/common';
+import TTLCache from '@isaacs/ttlcache';
 import { spawn as spawnPty } from '@scrypted/node-pty';
-import { cyan, green, red, yellow } from 'ansicolor';
+import AdmZip from 'adm-zip';
+import { cyan, green, red } from 'ansicolor';
 import { ensureDir, move, pathExists, readJSON, readJson, remove, writeJson } from 'fs-extra/esm';
-import { LRUCache } from 'lru-cache';
 import { createHash } from 'node:crypto';
-import { constants, readFile as readFileSync } from 'node:fs';
-import { access, mkdtemp, readFile, rmdir, unlink, writeFile } from 'node:fs/promises';
+import { createReadStream, readFile as readFileSync, truncate } from 'node:fs';
+import { mkdtemp, readFile, rmdir, unlink, writeFile } from 'node:fs/promises';
 import { platform, tmpdir, userInfo } from 'node:os';
 import { basename, dirname, join } from 'node:path';
-import { gt, parse as parseVersion, satisfies } from 'semver';
+import { Readable } from 'node:stream';
+import { gt, parse as parseVersion } from 'semver';
 import sharp from 'sharp';
 import { x as extract } from 'tar';
 import { container } from 'tsyringe';
 import { PluginManager } from '../../plugins/index.js';
-import { ConfigService } from '../../services/config/index.js';
-import { getNpmPath } from '../../utils/npm.js';
-import { orderBy, sleep } from '../../utils/utils.js';
 import { CamerasService } from '../services/cameras.service.js';
 import { PluginsService } from '../services/plugins.service.js';
 import fetchInstance from '../utils/fetch.js';
-const npmPluginCache = new LRUCache({ ttl: 300, max: 100, allowStale: false });
+const npmPluginCache = new TTLCache({ ttl: 300, max: 100 });
 const searchResultBlacklist = new Set(['camera.ui', 'homebridge-camera-ui']);
-const pluginLogoCache = new LRUCache({ max: 100, ttl: 1000 * 60 * 60 * 24 });
+const pluginLogoCache = new TTLCache({ max: 100, ttl: 1000 * 60 * 60 * 24 });
 export class PluginsController {
     app;
     logger;
@@ -176,7 +176,7 @@ export class PluginsController {
             catch {
                 //
             }
-            const version = plugin.info.installedVersion || 'latest';
+            const version = plugin.info.installedVersion ?? 'latest';
             const response = await fetchInstance(`https://unpkg.com/${plugin.pluginName}@${version}/CHANGELOG.md`, {
                 method: 'GET',
             });
@@ -224,6 +224,7 @@ export class PluginsController {
                 return reply.code(200).send(Buffer.from('').toString('base64'));
             }
             let base64Logo;
+            pluginLogoCache.purgeStale();
             if (pluginLogoCache.has(pluginName)) {
                 base64Logo = pluginLogoCache.get(pluginName);
             }
@@ -413,7 +414,7 @@ export class PluginsController {
                 catch {
                     //
                 }
-                reply.send(error || fileBuffer);
+                reply.send(error ?? fileBuffer);
             });
             reply.header('Content-Type', 'application/octet-stream');
             reply.header('Content-Disposition', 'attachment; filename=video.mp4');
@@ -495,7 +496,7 @@ export class PluginsController {
             catch {
                 //
             }
-            const version = plugin.info.installedVersion || 'latest';
+            const version = plugin.info.installedVersion ?? 'latest';
             const response = await fetchInstance(`https://unpkg.com/${plugin.pluginName}@${version}/README.md`, {
                 method: 'GET',
             });
@@ -560,7 +561,7 @@ export class PluginsController {
         try {
             const installedPlugins = this.service.installedPlugins();
             const allExtensions = installedPlugins
-                .filter((plugin) => plugin.contract.extension || plugin.contract.supportAdditionalCameras)
+                .filter((plugin) => plugin.contract.extension ?? plugin.contract.supportAdditionalCameras)
                 .map((plugin) => ({
                 pluginName: plugin.pluginName,
                 displayName: plugin.displayName,
@@ -632,10 +633,68 @@ export class PluginsController {
             });
         }
     }
+    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 || !query.length ? '' : query + '+') + 'keywords:camera-ui-plugin+not:deprecated&size=30';
+            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}`, {
@@ -647,7 +706,7 @@ export class PluginsController {
                 throw new Error(`Failed to search the npm registry - "${error.message}"`);
             }
             const result = searchResults.objects
-                .filter((x) => x.package.name.indexOf('camera-ui-') === 0 || this.isScopedPlugin(x.package.name))
+                .filter((x) => x.package.name.startsWith('camera-ui-') || this.isScopedPlugin(x.package.name))
                 .filter((x) => !searchResultBlacklist.has(x.package.name))
                 .map((pkg) => {
                 let plugin = {
@@ -674,7 +733,7 @@ export class PluginsController {
                 plugin.author = pkg.package.publisher ? pkg.package.publisher.username : undefined;
                 return plugin;
             });
-            if (!result.length && (query.indexOf('camera-ui-') === 0 || this.isScopedPlugin(query)) && !searchResultBlacklist.has(query.toLowerCase())) {
+            if (!result.length && (query.startsWith('camera-ui-') || this.isScopedPlugin(query)) && !searchResultBlacklist.has(query.toLowerCase())) {
                 const singlePluginQuey = await this.searchNpmRegistrySingle(query.toLowerCase());
                 return singlePluginQuey;
             }
@@ -760,7 +819,7 @@ export class PluginsController {
             npmPluginCache.delete(plugin.pluginName);
             plugin.reparsePackageJson();
             const serverNsp = this.socketService.namespaces.get('/server');
-            serverNsp.checkUpdate();
+            serverNsp.checkPlugins();
             return reply.code(201).send(plugin.info);
         }
         catch (error) {
@@ -770,22 +829,6 @@ export class PluginsController {
             });
         }
     }
-    async updateServer(req, reply) {
-        try {
-            this.logger.log(`Updating server: ${ConfigService.APP_NAME}@${req.body.pluginversion}`);
-            const installPath = await this.manage(ConfigService.APP_NAME, 'installServer', req.body.pluginversion);
-            this.logger.log(`Server updated: ${ConfigService.APP_NAME}@${ConfigService.VERSION} (${installPath})`);
-            const serverNsp = this.socketService.namespaces.get('/server');
-            serverNsp.checkUpdate();
-            return reply.code(204).send();
-        }
-        catch (error) {
-            return reply.code(500).send({
-                statusCode: 500,
-                message: error.message,
-            });
-        }
-    }
     async uninstallByName(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
@@ -833,113 +876,30 @@ export class PluginsController {
         }
     }
     async manage(pluginName, action, version, pluginId) {
-        if (pluginName === ConfigService.APP_NAME && !ConfigService.INSTALL_PATH) {
-            throw new Error(`Can not determine the install path for ${pluginName}`);
-        }
-        const dir = pluginName === ConfigService.APP_NAME ? ConfigService.INSTALL_PATH : this.configService.PLUGINS_INSTALL_PATH;
-        let targetDir;
-        if (pluginName === ConfigService.APP_NAME) {
-            targetDir = dir;
-        }
-        else {
-            targetDir = join(dir, pluginName);
-        }
-        this.emitProgress(pluginName, `\n\rUSER: ${userInfo().username}\n\r`, cyan);
-        this.emitProgress(pluginName, `DIR: ${targetDir}\n\r`, cyan);
-        this.emitProgress(pluginName, `ACTION: ${action}\n\r\n\r`, cyan);
-        await this.removeSynologyMetadata();
+        const targetDir = join(this.configService.PLUGINS_INSTALL_PATH, 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);
         switch (action) {
             case 'install':
-                await this.installPlugin(pluginName, version || 'latest', targetDir);
-                break;
-            case 'installServer':
-                await this.installServer(pluginName, version || 'latest', targetDir);
+                await this.installPlugin(pluginName, version ?? 'latest', targetDir);
                 break;
             case 'update':
-                await this.updatePlugin(pluginName, version || 'latest', targetDir);
+                await this.updatePlugin(pluginName, version ?? 'latest', targetDir);
                 break;
             case 'uninstall':
                 await this.uninstallPlugin(pluginName, targetDir);
-                await sleep(2000);
+                if (pluginId) {
+                    await this.camerasService.removeByPluginId(pluginId);
+                }
                 break;
             default:
                 throw new Error(`Unknown action: ${action}`);
         }
-        await this.ensurePluginDirExists();
-        if (pluginId && action === 'uninstall' && pluginName !== ConfigService.APP_NAME) {
-            await this.camerasService.removeByPluginId(pluginId);
-        }
         return targetDir;
     }
-    async installServer(pluginName, version, targetDir) {
-        await this.removeSynologyMetadata();
-        const upgradeInstallScriptPath = join(targetDir, 'upgrade-server.sh');
-        let timeoutTimer;
-        const command = [upgradeInstallScriptPath, version, targetDir];
-        try {
-            await access(join(targetDir, 'node_modules'), constants.W_OK);
-        }
-        catch {
-            this.emitProgress(pluginName, `The user "${userInfo().username}" does not have write access to the target directory:\n\r\n\r`, yellow);
-            this.emitProgress(pluginName, `${join(targetDir, 'node_modules')}\n\r\n\r`);
-            this.emitProgress(pluginName, 'This may cause the operation to fail.\n\r\n\r', yellow);
-        }
-        this.logger.log(`Running Command: ${command.join(' ')}`);
-        if (!satisfies(process.version, `>=${ConfigService.MIN_NODE_VERSION}`)) {
-            this.emitProgress(pluginName, `Node.js v${ConfigService.MIN_NODE_VERSION} higher is required for ${ConfigService.APP_NAME}.\n\r`, yellow);
-            this.emitProgress(pluginName, `You may experience issues while running on Node.js ${process.version}.\n\r\n\r`, yellow);
-        }
-        // set up the environment for the call
-        const env = {};
-        Object.assign(env, process.env);
-        Object.assign(env, {
-            // npm_config_install_strategy: 'shallow',
-            npm_config_unsafe_perm: 'true',
-            npm_config_update_notifier: 'false',
-            npm_config_prefer_online: 'true',
-            npm_config_foreground_scripts: 'true',
-            npm_config_loglevel: 'info',
-            npm_config_prefix: targetDir,
-        });
-        // set global prefix for unix based systems
-        if (platform() !== 'win32') {
-            if (basename(targetDir) === 'lib') {
-                Object.assign(env, {
-                    npm_config_prefix: dirname(targetDir),
-                });
-            }
-        }
-        await new Promise((_resolve, _reject) => {
-            const term = spawnPty(command.shift(), command, {
-                name: 'xterm-color',
-                cols: 80,
-                rows: 30,
-                cwd: targetDir,
-                env,
-            });
-            // send stdout data from the process to all clients
-            term.onData((data) => {
-                this.emitProgress(pluginName, data);
-            });
-            // send an error message to the client if the command does not exit with code 0
-            term.onExit((error) => {
-                clearTimeout(timeoutTimer);
-                if (error.exitCode === 0) {
-                    this.emitProgress(pluginName, `\n\rServer ${pluginName}@${version} has been successfully updated.\n\r\n\r`, green);
-                    _resolve(null);
-                }
-                else {
-                    this.emitProgress(pluginName, `\n\rError during update of ${pluginName}@${version}.\n\r\n\r`, red);
-                    _reject(new Error('Operation failed. Please review log for details.'));
-                }
-            });
-            // if the command spends to long trying to execute kill it after 5 minutes
-            timeoutTimer = setTimeout(() => {
-                term.kill('SIGTERM');
-            }, 300000);
-        });
-    }
     async installPlugin(pluginName, version, targetDir, update) {
+        const backupTempDir = join(tmpdir(), `${pluginName}_backup`);
         try {
             const npmRegistry = 'https://registry.npmjs.org';
             const packageUrl = `${npmRegistry}/${pluginName}/${version}`;
@@ -951,15 +911,20 @@ export class PluginsController {
             const packageInfo = await response.json();
             const tarballUrl = packageInfo.dist.tarball;
             const expectedShasum = packageInfo.dist.shasum;
-            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+            this.emitProgress(pluginName, ' Done\r\n\r\n', green);
             const tarballData = await this.downloadWithProgress(tarballUrl, pluginName, version);
-            this.emitProgress(pluginName, ' - Done\n\r\n\r', green);
+            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\n\r\n\r', green);
+            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) => {
@@ -969,17 +934,31 @@ export class PluginsController {
                 });
                 extractStream.on('error', _reject);
                 extractStream.on('end', () => {
-                    this.emitProgress(pluginName, ' Done\n\r\n\r', green);
+                    this.emitProgress(pluginName, ' Done\r\n\r\n', 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);
+            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, `\n\rError during ${update ? 'update' : 'installation'} of ${pluginName}@${version}.\n\r\n\r`, red);
+            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;
         }
     }
@@ -990,70 +969,44 @@ export class PluginsController {
             const packageJson = await readJson(packageJsonPath);
             const currentVersion = packageJson.version;
             if (currentVersion === version) {
-                this.emitProgress(pluginName, ' Break', red);
-                this.emitProgress(pluginName, `Plugin ${pluginName} is already up to date\n\r\n\r`, green);
+                this.emitProgress(pluginName, `Plugin ${pluginName} is already up to date.\r\n\r\n`, green);
                 return;
             }
-            const tempNodeModules = join(targetDir, 'node_modules_temp');
-            await move(join(targetDir, 'node_modules'), tempNodeModules);
-            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
-            let cleaningUp = false;
-            try {
-                await this.installPlugin(pluginName, version, targetDir, true);
-                this.emitProgress(pluginName, '> Cleaning up...');
-                cleaningUp = true;
-                await remove(tempNodeModules);
-                this.emitProgress(pluginName, ' Done\n\r\n\r', green);
-            }
-            catch (error) {
-                if (cleaningUp) {
-                    this.emitProgress(pluginName, ' Error\n\r\n\r', red);
-                }
-                this.emitProgress(pluginName, ' Restoring previous version...');
-                await remove(targetDir);
-                await move(tempNodeModules, targetDir);
-                this.emitProgress(pluginName, ' Done\n\r\n\r', green);
-                throw error;
-            }
+            this.emitProgress(pluginName, ' Done\r\n\r\n', green);
+            await this.installPlugin(pluginName, version, targetDir, true);
         }
         catch (error) {
-            this.emitProgress(pluginName, `\n\rError during update of ${pluginName}@${version}.\n\r\n\r`, red);
+            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, '> Fetching plugin information...');
-            const pluginInstalled = await pathExists(targetDir);
-            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
-            if (!pluginInstalled) {
-                this.emitProgress(pluginName, `Plugin ${pluginName} is not installed. Break\n\r\n\r`, red);
-                return;
-            }
-            this.emitProgress(pluginName, '> Uninstalling plugin...');
+            this.emitProgress(pluginName, '> Removing plugin...');
             await remove(targetDir);
-            this.emitProgress(pluginName, ' Done\n\r\n\r', green);
-            this.emitProgress(pluginName, `Plugin ${pluginName} has been successfully uninstalled.\n\r`, green);
+            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\n\r\n\r', red);
-            this.emitProgress(pluginName, `\n\rError during uninstallation of ${pluginName}.\n\r\n\r`, red);
+            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...\n\r\n\r');
-            const command = [...getNpmPath(), 'install', '--omit=dev', '--loglevel', 'info'];
+            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_foreground_scripts: 'true',
                 npm_config_loglevel: 'info',
                 npm_config_prefix: packageDir,
             });
@@ -1094,21 +1047,20 @@ export class PluginsController {
             }, 300000);
         });
     }
-    async ensurePluginDirExists() {
-        if (!this.configService.PLUGINS_INSTALL_PATH) {
+    async extrackBundeledPlugin(packageDir, pluginName) {
+        const bundlePath = join(packageDir, 'bundle.zip');
+        const isBundeledPlugin = await pathExists(bundlePath);
+        if (!isBundeledPlugin) {
             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);
-            }
-        }
+        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 getAvailablePluginVersions(pluginName) {
+        npmPluginCache.purgeStale();
         const fromCache = npmPluginCache.get(`lookup-${pluginName}`);
         let pkg = fromCache;
         if (!pkg) {
@@ -1134,6 +1086,7 @@ export class PluginsController {
             betaUpdateAvailable: false,
         };
         try {
+            npmPluginCache.purgeStale();
             // attempt to load from cache
             const fromCache = npmPluginCache.get(plugin.pluginName);
             let pkg = fromCache;
@@ -1171,22 +1124,9 @@ export class PluginsController {
         }
         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) {
@@ -1198,7 +1138,7 @@ export class PluginsController {
             if (!fromCache) {
                 npmPluginCache.set(`lookup-${query}`, pkg, { ttl: 60 * 1000 });
             }
-            if (!pkg.keywords || !pkg.keywords.includes('camera-ui-plugin')) {
+            if (!pkg.keywords?.includes('camera-ui-plugin')) {
                 return [];
             }
             let plugin;
@@ -1245,7 +1185,7 @@ export class PluginsController {
         }
     }
     isScopedPlugin(pluginName) {
-        return pluginName.charAt(0) === '@' && pluginName.split('/').length > 0 && pluginName.split('/')[1]?.indexOf('camera-ui-') === 0;
+        return pluginName.startsWith('@') && pluginName.split('/').length > 0 && pluginName.split('/')[1]?.startsWith('camera-ui-');
     }
     async downloadWithProgress(url, pluginName, version) {
         const response = await fetch(url);
@@ -1256,8 +1196,7 @@ export class PluginsController {
         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
+        this.emitProgress(pluginName, `> Downloading ${pluginName}@${version}...\r\n`);
         while (true) {
             const { done, value } = await reader.read();
             if (done) {