@camera.ui/server 0.0.49 → 0.0.50-internal.1

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

@@ -1,16 +1,14 @@
 import { orderBy } from '@camera.ui/common';
 import TTLCache from '@isaacs/ttlcache';
-import { pathExists, readJSON, readJson, writeJson } from 'fs-extra/esm';
-import { createReadStream, readFile as readFileSync, truncate } from 'node:fs';
-import { mkdtemp, readFile, rmdir, unlink, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
+import { pathExists } from 'fs-extra/esm';
+import { createReadStream, truncate } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { Readable } from 'node:stream';
 import { gt, parse as parseVersion } from 'semver';
 import sharp from 'sharp';
 import { container } from 'tsyringe';
 import { PluginManager } from '../../plugins/index.js';
-import { MAX_AUDIO_FILE_SIZE, MAX_MOTION_FILE_SIZE, MAX_OBJECT_FILE_SIZE } from '../schemas/plugins.schema.js';
 import { CamerasService } from '../services/cameras.service.js';
 import { PluginsService } from '../services/plugins.service.js';
 import { fetchWithTimeout } from '../utils/fetch.js';
@@ -155,51 +153,64 @@ export class PluginsController {
         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 pluginInfo = plugin?.info ?? (await this.searchNpmRegistrySingle(pluginName));
+            const version = req.query.pluginversion ?? 'latest';
+            // GITHUB API
             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);
+                const repoMatch = pluginInfo?.links?.homepage?.match(/https:\/\/github.com\/([^/]+)\/([^/#]+)/);
+                const bugsMatch = pluginInfo?.links?.bugs?.match(/https:\/\/github.com\/([^/]+)\/([^/#]+)/);
+                const match = repoMatch ?? bugsMatch;
+                if (match) {
+                    const response = await fetchWithTimeout(`https://api.github.com/repos/${match[1]}/${match[2]}/releases`, {
+                        method: 'GET',
+                    });
+                    if (!response.ok) {
+                        throw new Error(`Failed to fetch changelog from GitHub API - ${response.statusText}`);
+                    }
+                    const data = (await response.json());
+                    const release = version === 'latest' ? data[0] : data.find((x) => x.tag_name === version);
+                    if (release) {
+                        reply.header('Content-Type', 'text/plain');
+                        return reply.code(200).send(release.body);
+                    }
                 }
             }
             catch {
                 //
             }
-            const version = plugin.info.installedVersion ?? 'latest';
-            const response = await fetchWithTimeout(`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',
+            // UNPKG
+            try {
+                const response = await fetchWithTimeout(`https://unpkg.com/${pluginName}@${version}/CHANGELOG.md`, {
+                    method: 'GET',
                 });
+                if (!response.ok) {
+                    throw new Error(`Failed to fetch changelog from UNPKG - ${response.statusText}`);
+                }
+                const data = await response.text();
+                reply.header('Content-Type', 'text/plain');
+                return reply.code(200).send(data);
+            }
+            catch {
+                //
+            }
+            // LOCAL
+            if (plugin) {
+                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 config = (await readJSON(configFile, { throws: false })) || {};
-            reply.header('Content-Type', 'application/json');
-            return reply.code(200).send(config);
+            return reply.code(404).send({
+                statusCode: 404,
+                message: 'Changelog not found',
+            });
         }
         catch (error) {
             return reply.code(500).send({
@@ -230,7 +241,7 @@ export class PluginsController {
                 pluginLogoCache.set(pluginName, base64Logo);
             }
             reply.header('Content-Type', 'image/png');
-            return reply.code(200).send(base64Logo);
+            return reply.code(200).send(`data:image/png;base64,${base64Logo}`);
         }
         catch (error) {
             return reply.code(500).send({
@@ -239,23 +250,25 @@ export class PluginsController {
             });
         }
     }
-    async getPluginSchemaByName(req, reply) {
+    async getConfigByName(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
-            const plugin = this.service.getPluginByName(pluginName);
-            if (!plugin) {
+            const pluginWorker = this.service.getPluginProcessByName(pluginName);
+            if (!pluginWorker) {
                 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);
+            const proxy = await pluginWorker.storageProxy();
+            const schemaConfig = await proxy.getConfig();
+            const cameraExtension = {
+                pluginName: pluginWorker.plugin.pluginName,
+                displayName: pluginWorker.plugin.displayName,
+                type: pluginWorker.plugin.contract.extensions,
+                ...schemaConfig,
+            };
+            return reply.code(200).send(cameraExtension);
         }
         catch (error) {
             return reply.code(500).send({
@@ -264,20 +277,19 @@ export class PluginsController {
             });
         }
     }
-    async getPluginInterface(req, reply) {
+    async patchConfigByName(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
-            const plugin = this.service.getPluginByName(pluginName);
-            if (!plugin) {
+            const pluginWorker = this.service.getPluginProcessByName(pluginName);
+            if (!pluginWorker) {
                 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);
+            const proxy = await pluginWorker.storageProxy();
+            await proxy.setConfig(req.body);
+            return reply.code(200).send(req.body);
         }
         catch (error) {
             return reply.code(500).send({
@@ -286,46 +298,67 @@ export class PluginsController {
             });
         }
     }
-    async detectObjects(req, reply) {
+    async setConfigByName(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
-            const plugin = this.service.getPluginByName(pluginName);
-            if (!plugin) {
+            const pluginWorker = this.service.getPluginProcessByName(pluginName);
+            if (!pluginWorker) {
                 return reply.code(404).send({
                     statusCode: 404,
                     message: 'Plugin not exists',
                 });
             }
-            if (!req.isMultipart()) {
-                throw new Error('No multipart request!');
+            const proxy = await pluginWorker.storageProxy();
+            await proxy.setValue(req.body.key, undefined);
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async submitConfigByName(req, reply) {
+        try {
+            const pluginName = this.resolvePluginName(req.params);
+            const pluginWorker = this.service.getPluginProcessByName(pluginName);
+            if (!pluginWorker) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
             }
-            const file = await req.file({ limits: { fileSize: MAX_OBJECT_FILE_SIZE } });
-            if (!file) {
-                return reply.code(400).send({
-                    statusCode: 400,
-                    message: 'No file uploaded',
+            const proxy = await pluginWorker.storageProxy();
+            const response = await proxy.submitValue(req.body.key, req.body.payload);
+            return reply.code(200).send(response);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getPluginInterface(req, reply) {
+        try {
+            const pluginName = this.resolvePluginName(req.params);
+            const pluginWorker = this.service.getPluginProcessByName(pluginName);
+            const pluginProxy = await pluginWorker?.pluginProxy();
+            if (!pluginProxy) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists or not running',
                 });
             }
-            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);
+            let schemaJson;
             try {
-                const promises = [];
-                if (tempFilePath) {
-                    promises.push(unlink(tempFilePath));
-                }
-                if (tempDir) {
-                    promises.push(rmdir(tempDir));
-                }
-                await Promise.allSettled(promises);
+                schemaJson = await pluginProxy.interfaceSchema?.();
             }
             catch {
                 //
             }
-            return reply.code(201).send(response.detections);
+            return reply.code(200).send(schemaJson);
         }
         catch (error) {
             return reply.code(500).send({
@@ -334,46 +367,30 @@ export class PluginsController {
             });
         }
     }
-    async detectAudio(req, reply) {
+    async detectObjects(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
-            const plugin = this.service.getPluginByName(pluginName);
-            if (!plugin) {
+            const pluginWorker = this.service.getPluginProcessByName(pluginName);
+            const pluginProxy = await pluginWorker?.pluginProxy();
+            if (!pluginProxy) {
                 return reply.code(404).send({
                     statusCode: 404,
-                    message: 'Plugin not exists',
+                    message: 'Plugin not exists or not running',
                 });
             }
             if (!req.isMultipart()) {
                 throw new Error('No multipart request!');
             }
-            const file = await req.file({ limits: { fileSize: MAX_AUDIO_FILE_SIZE } });
+            const file = req.body.upload;
             if (!file) {
                 return reply.code(400).send({
                     statusCode: 400,
                     message: 'No file uploaded',
                 });
             }
-            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);
+            const response = await pluginProxy.detectObjects?.(fileBuffer, req.body.metadata, req.body.config);
+            return reply.code(201).send(response?.detections);
         }
         catch (error) {
             return reply.code(500).send({
@@ -382,57 +399,30 @@ export class PluginsController {
             });
         }
     }
-    async detectMotion(req, reply) {
+    async detectAudio(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
-            const plugin = this.service.getPluginByName(pluginName);
-            if (!plugin) {
+            const pluginWorker = this.service.getPluginProcessByName(pluginName);
+            const pluginProxy = await pluginWorker?.pluginProxy();
+            if (!pluginProxy) {
                 return reply.code(404).send({
                     statusCode: 404,
-                    message: 'Plugin not exists',
+                    message: 'Plugin not exists or not running',
                 });
             }
             if (!req.isMultipart()) {
                 throw new Error('No multipart request!');
             }
-            const file = await req.file({ limits: { fileSize: MAX_MOTION_FILE_SIZE } });
+            const file = req.body.upload;
             if (!file) {
                 return reply.code(400).send({
                     statusCode: 400,
                     message: 'No file uploaded',
                 });
             }
-            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;
+            const response = await pluginProxy.detectAudio?.(fileBuffer, req.body.metadata, req.body.config);
+            return reply.code(201).send(response?.detected);
         }
         catch (error) {
             return reply.code(500).send({
@@ -441,19 +431,32 @@ export class PluginsController {
             });
         }
     }
-    async submitActionButtonByName(req, reply) {
+    async detectMotion(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
-            const plugin = this.service.getPluginByName(pluginName);
-            const configFile = plugin?.configFile;
-            if (!plugin || !configFile) {
+            const pluginWorker = this.service.getPluginProcessByName(pluginName);
+            const pluginProxy = await pluginWorker?.pluginProxy();
+            if (!pluginProxy) {
                 return reply.code(404).send({
                     statusCode: 404,
-                    message: 'Plugin or Plugin Config not exists',
+                    message: 'Plugin not exists or not running',
+                });
+            }
+            if (!req.isMultipart()) {
+                throw new Error('No multipart request!');
+            }
+            const file = req.body.upload;
+            if (!file) {
+                return reply.code(400).send({
+                    statusCode: 400,
+                    message: 'No file uploaded',
                 });
             }
-            const toastMessage = await this.proxyServer.requestPluginFn('base', plugin.id, 'onFormSubmit', [req.body.actionId, req.body.payload]);
-            return reply.code(201).send(toastMessage);
+            const fileBuffer = await file.toBuffer();
+            const response = await pluginProxy.detectMotion?.(fileBuffer, req.body.config);
+            reply.header('Content-Type', 'video/mp4');
+            reply.header('Content-Length', response?.videoData.toString().length ?? 0);
+            return reply.send(response?.videoData);
         }
         catch (error) {
             return reply.code(500).send({
@@ -473,7 +476,7 @@ export class PluginsController {
                 });
             }
             const contract = plugin.contract;
-            const camerasList = plugin.contract.extension || plugin.contract.supportAdditionalCameras ? this.camerasService.list() : this.camerasService.listByPluginId(plugin.id);
+            const camerasList = contract.extensions.length === 1 && contract.extensions[0] === 'cameraController' ? this.camerasService.listByPluginId(plugin.id) : this.camerasService.list();
             const cameras = camerasList?.map((camera) => {
                 return {
                     name: camera.name,
@@ -514,6 +517,9 @@ export class PluginsController {
             const response = await fetchWithTimeout(`https://unpkg.com/${plugin.pluginName}@${version}/README.md`, {
                 method: 'GET',
             });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch readme from UNPKG - ${response.statusText}`);
+            }
             const data = await response.text();
             return reply.code(200).send(data);
         }
@@ -524,39 +530,6 @@ export class PluginsController {
             });
         }
     }
-    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 fetchWithTimeout(`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.listPlugins();
@@ -574,12 +547,10 @@ export class PluginsController {
     listExtensions(req, reply) {
         try {
             const installedPlugins = this.service.listPlugins();
-            const allExtensions = installedPlugins
-                .filter((plugin) => plugin.contract.extension ?? plugin.contract.supportAdditionalCameras)
-                .map((plugin) => ({
+            const allExtensions = installedPlugins.map((plugin) => ({
                 pluginName: plugin.pluginName,
                 displayName: plugin.displayName,
-                type: plugin.contract.extension ? [plugin.contract.extension] : plugin.contract.builtIns,
+                type: plugin.contract.extensions,
             }));
             return orderBy(allExtensions, ['displayName'], ['asc']);
         }
@@ -590,36 +561,6 @@ export class PluginsController {
             });
         }
     }
-    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);
@@ -709,16 +650,13 @@ export class PluginsController {
         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 fetchWithTimeout(`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 response = await fetchWithTimeout(`https://registry.npmjs.org/-/v1/search?text=${q}`, {
+                method: 'GET',
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to search the npm registry - ${response.statusText}`);
             }
+            const searchResults = (await response.json());
             const result = searchResults.objects
                 .filter((x) => x.package.name.startsWith('camera-ui-') || this.isScopedPlugin(x.package.name))
                 .filter((x) => !searchResultBlacklist.has(x.package.name))
@@ -731,7 +669,7 @@ export class PluginsController {
                     isPython: false,
                     isNode: true,
                     'camera.ui': {
-                        extension: 'cameraController',
+                        extensions: [],
                     },
                 };
                 const installedPlugins = this.service.listPlugins();
@@ -752,7 +690,7 @@ export class PluginsController {
             });
             if (!result.length && (query.startsWith('camera-ui-') || this.isScopedPlugin(query)) && !searchResultBlacklist.has(query.toLowerCase())) {
                 const singlePluginQuey = await this.searchNpmRegistrySingle(query.toLowerCase());
-                return singlePluginQuey;
+                return singlePluginQuey ? [singlePluginQuey] : [];
             }
             return orderBy(result, ['displayName'], ['asc']);
         }
@@ -829,9 +767,9 @@ export class PluginsController {
                 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();
+                this.logger.log(`Plugin updated: ${plugin.pluginName}.${plugin.displayName} (${req.body.pluginversion})`);
+                // const pluginProcess = this.service.getPluginProcessByName(req.body.pluginname);
+                // pluginProcess?.restart();
             }
             npmPluginCache.delete(plugin.pluginName);
             plugin.reparsePackageJson();
@@ -846,6 +784,18 @@ export class PluginsController {
             });
         }
     }
+    async installProgress(req, reply) {
+        try {
+            const pluginsInProgress = this.service.installingPlugins();
+            return orderBy(pluginsInProgress, ['pluginName'], ['asc']);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
     async uninstallByName(req, reply) {
         try {
             const pluginName = this.resolvePluginName(req.params);
@@ -903,6 +853,9 @@ export class PluginsController {
                     accept: 'application/vnd.npm.install-v1+json', // only return minimal information
                 },
             });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch versions from npm registry - ${response.statusText}`);
+            }
             pkg = (await response.json());
         }
         if (!fromCache) {
@@ -918,6 +871,9 @@ export class PluginsController {
             updateAvailable: false,
             betaUpdateAvailable: false,
         };
+        if (plugin.private) {
+            return pluginState;
+        }
         try {
             npmPluginCache.purgeStale();
             // attempt to load from cache
@@ -927,10 +883,18 @@ export class PluginsController {
                 const response = await fetchWithTimeout(`https://registry.npmjs.org/${encodeURIComponent(plugin.pluginName).replace(/%40/g, '@')}/latest`, {
                     method: 'GET',
                 });
+                if (!response.ok) {
+                    throw new Error(`Failed to check registry.npmjs.org for updates for plugin "${plugin.pluginName}" - ${response.statusText}`);
+                }
                 pkg = (await response.json());
             }
             pluginState.latestVersion = pkg.version;
-            pluginState.updateAvailable = gt(pkg.version, plugin.installedVersion);
+            try {
+                pluginState.updateAvailable = gt(pkg.version, plugin.installedVersion);
+            }
+            catch {
+                pluginState.updateAvailable = false;
+            }
             // check for beta updates, if no latest version is available
             if (!pluginState.updateAvailable) {
                 const pluginVersion = parseVersion(plugin.installedVersion);
@@ -948,16 +912,14 @@ export class PluginsController {
             }
         }
         catch (error) {
-            if (error.response?.status !== 404) {
-                this.logger.error(`[${plugin.pluginName}] Failed to check registry.npmjs.org for updates`, error);
-            }
+            this.logger.error(error);
             pluginState.latestVersion = undefined;
             pluginState.updateAvailable = false;
             pluginState.betaUpdateAvailable = false;
         }
         return pluginState;
     }
-    async searchNpmRegistrySingle(query) {
+    async searchNpmRegistrySingle(query, timeout) {
         try {
             npmPluginCache.purgeStale();
             const fromCache = npmPluginCache.get(`lookup-${query}`);
@@ -965,14 +927,17 @@ export class PluginsController {
             if (!pkg) {
                 const response = await fetchWithTimeout(`https://registry.npmjs.org/${encodeURIComponent(query).replace(/%40/g, '@')}`, {
                     method: 'GET',
-                });
+                }, timeout);
+                if (!response.ok) {
+                    throw new Error(`Failed to search the npm registry - ${response.statusText}`);
+                }
                 pkg = (await response.json());
             }
             if (!fromCache) {
                 npmPluginCache.set(`lookup-${query}`, pkg, { ttl: 60 * 1000 });
             }
             if (!pkg.keywords?.includes('camera-ui-plugin')) {
-                return [];
+                return;
             }
             let plugin;
             const installedPlugins = this.service.listPlugins();
@@ -980,7 +945,7 @@ export class PluginsController {
             if (isInstalled) {
                 plugin = isInstalled.info;
                 plugin.lastUpdated = pkg.time.modified;
-                return [plugin];
+                return plugin;
             }
             plugin = {
                 id: '0',
@@ -999,16 +964,15 @@ export class PluginsController {
                 },
                 author: pkg.maintainers[0]?.name,
                 'camera.ui': {
-                    extension: 'cameraController',
+                    extensions: [],
                 },
             };
-            return [plugin];
+            return plugin;
         }
         catch (error) {
             if (error.response?.status !== 404) {
                 this.logger.error('Failed to search the npm registry', error);
             }
-            return [];
         }
     }
     resolvePluginName(params) {