matterbridge 2.2.6 → 3.0.0-edge.1

package/dist/pluginManager.js

@@ -1,26 +1,3 @@
-/**
- * This file contains the Plugins class.
- *
- * @file plugins.ts
- * @author Luca Liguori
- * @date 2024-07-14
- * @version 1.1.1
- *
- * Copyright 2024, 2025, 2026 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License. *
- */
-// AnsiLogger module
 import { AnsiLogger, UNDERLINE, UNDERLINEOFF, BLUE, db, er, nf, nt, rs, wr } from './logger/export.js';
 import { plg, typ } from './matterbridgeTypes.js';
 export class PluginManager {
@@ -30,9 +7,8 @@ export class PluginManager {
     log;
     constructor(matterbridge) {
         this.matterbridge = matterbridge;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.nodeContext = matterbridge.nodeContext;
-        this.log = new AnsiLogger({ logName: 'PluginManager', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: matterbridge.log.logLevel });
+        this.log = new AnsiLogger({ logName: 'PluginManager', logTimestampFormat: 4, logLevel: matterbridge.log.logLevel });
         this.log.debug('Matterbridge plugin manager starting...');
     }
     get length() {
@@ -67,9 +43,8 @@ export class PluginManager {
             try {
                 await callback(plugin);
             }
-            catch (error) {
-                this.log.error(`Error processing forEach plugin ${plg}${plugin.name}${er}:`, error);
-                // throw error;
+            catch (err) {
+                this.log.error(`Error processing forEach plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             }
         });
         await Promise.all(tasks);
@@ -77,31 +52,13 @@ export class PluginManager {
     set logLevel(logLevel) {
         this.log.logLevel = logLevel;
     }
-    /**
-     * Loads registered plugins from storage.
-     *
-     * This method retrieves an array of registered plugins from the storage and converts it
-     * into a map where the plugin names are the keys and the plugin objects are the values.
-     *
-     * @returns {Promise<RegisteredPlugin[]>} A promise that resolves to an array of registered plugins.
-     */
     async loadFromStorage() {
-        // Load the array from storage and convert it to a map
         const pluginsArray = await this.nodeContext.get('plugins', []);
         for (const plugin of pluginsArray)
             this._plugins.set(plugin.name, plugin);
         return pluginsArray;
     }
-    /**
-     * Loads registered plugins from storage.
-     *
-     * This method retrieves an array of registered plugins from the storage and converts it
-     * into a map where the plugin names are the keys and the plugin objects are the values.
-     *
-     * @returns {Promise<RegisteredPlugin[]>} A promise that resolves to an array of registered plugins.
-     */
     async saveToStorage() {
-        // Convert the map to an array
         const plugins = [];
         const pluginArrayFromMap = Array.from(this._plugins.values());
         for (const plugin of pluginArrayFromMap) {
@@ -121,20 +78,13 @@ export class PluginManager {
         this.log.debug(`Saved ${BLUE}${plugins.length}${db} plugins to storage`);
         return plugins.length;
     }
-    /**
-     * Resolves the name of a plugin by loading and parsing its package.json file.
-     * @param pluginPath - The path to the plugin or the path to the plugin's package.json file.
-     * @returns The path to the resolved package.json file, or null if the package.json file is not found or does not contain a name.
-     */
     async resolve(pluginPath) {
         const { default: path } = await import('node:path');
         const { promises } = await import('node:fs');
         if (!pluginPath.endsWith('package.json'))
             pluginPath = path.join(pluginPath, 'package.json');
-        // Resolve the package.json of the plugin
         let packageJsonPath = path.resolve(pluginPath);
         this.log.debug(`Resolving plugin path ${plg}${packageJsonPath}${db}`);
-        // Check if the package.json file exists
         try {
             await promises.access(packageJsonPath);
         }
@@ -144,13 +94,11 @@ export class PluginManager {
             this.log.debug(`Trying at ${plg}${packageJsonPath}${db}`);
         }
         try {
-            // Load the package.json of the plugin
             const packageJson = JSON.parse(await promises.readFile(packageJsonPath, 'utf8'));
             if (!packageJson.name) {
                 this.log.error(`Package.json name not found at ${packageJsonPath}`);
                 return null;
             }
-            // Check for main issues
             if (!packageJson.type || packageJson.type !== 'module') {
                 this.log.error(`Plugin at ${packageJsonPath} is not a module`);
                 return null;
@@ -159,7 +107,6 @@ export class PluginManager {
                 this.log.error(`Plugin at ${packageJsonPath} has no main entrypoint in package.json`);
                 return null;
             }
-            // Check for @project-chip and @matter packages in dependencies and devDependencies
             const checkForProjectChipPackages = (dependencies) => {
                 return Object.keys(dependencies).filter((pkg) => pkg.startsWith('@project-chip') || pkg.startsWith('@matter'));
             };
@@ -181,7 +128,6 @@ export class PluginManager {
                 this.log.error(`Please open an issue on the plugin repository to remove them.`);
                 return null;
             }
-            // Check for matterbridge package in dependencies and devDependencies
             const checkForMatterbridgePackage = (dependencies) => {
                 return Object.keys(dependencies).filter((pkg) => pkg === 'matterbridge');
             };
@@ -207,15 +153,65 @@ export class PluginManager {
             return packageJsonPath;
         }
         catch (err) {
-            this.log.error(`Failed to resolve plugin path ${plg}${pluginPath}${er}: ${err}`);
+            this.log.error(`Failed to resolve plugin path ${plg}${pluginPath}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             return null;
         }
     }
-    /**
-     * Loads and parse the plugin package.json and returns it.
-     * @param plugin - The plugin to load the package from.
-     * @returns A Promise that resolves to the package.json object or undefined if the package.json could not be loaded.
-     */
+    getAuthor(packageJson) {
+        if (packageJson.author && typeof packageJson.author === 'string')
+            return packageJson.author;
+        else if (packageJson.author && typeof packageJson.author === 'object' && packageJson.author.name && typeof packageJson.author.name === 'string')
+            return packageJson.author.name;
+        return 'Unknown author';
+    }
+    getHomepage(packageJson) {
+        if (packageJson.homepage && typeof packageJson.homepage === 'string' && packageJson.homepage.includes('http')) {
+            return packageJson.homepage.replace('git+', '').replace('.git', '');
+        }
+        else if (packageJson.repository && typeof packageJson.repository === 'object' && packageJson.repository.url && typeof packageJson.repository.url === 'string' && packageJson.repository.url.includes('http')) {
+            return packageJson.repository.url.replace('git+', '').replace('.git', '');
+        }
+    }
+    getHelp(packageJson) {
+        if (packageJson.help && typeof packageJson.help === 'string' && packageJson.help.startsWith('http')) {
+            return packageJson.help;
+        }
+        else if (packageJson.repository && typeof packageJson.repository === 'object' && packageJson.repository.url && typeof packageJson.repository.url === 'string' && packageJson.repository.url.includes('http')) {
+            return packageJson.repository.url.replace('git+', '').replace('.git', '') + '/blob/main/README.md';
+        }
+        else if (packageJson.homepage && typeof packageJson.homepage === 'string' && packageJson.homepage.includes('http')) {
+            return packageJson.homepage.replace('git+', '').replace('.git', '');
+        }
+    }
+    getChangelog(packageJson) {
+        if (packageJson.changelog && typeof packageJson.changelog === 'string' && packageJson.changelog.startsWith('http')) {
+            return packageJson.changelog;
+        }
+        else if (packageJson.repository && typeof packageJson.repository === 'object' && packageJson.repository.url && typeof packageJson.repository.url === 'string' && packageJson.repository.url.includes('http')) {
+            return packageJson.repository.url.replace('git+', '').replace('.git', '') + '/blob/main/CHANGELOG.md';
+        }
+        else if (packageJson.homepage && typeof packageJson.homepage === 'string' && packageJson.homepage.includes('http')) {
+            return packageJson.homepage.replace('git+', '').replace('.git', '');
+        }
+    }
+    getFunding(packageJson) {
+        const funding = packageJson.funding;
+        if (!funding)
+            return undefined;
+        if (typeof funding === 'string' && !funding.startsWith('http'))
+            return;
+        if (typeof funding === 'string' && funding.startsWith('http'))
+            return funding;
+        const fundingEntries = Array.isArray(funding) ? funding : [funding];
+        for (const entry of fundingEntries) {
+            if (entry && typeof entry === 'string' && entry.startsWith('http')) {
+                return entry;
+            }
+            else if (entry && typeof entry === 'object' && typeof entry.url === 'string' && entry.url.startsWith('http')) {
+                return entry.url;
+            }
+        }
+    }
     async parse(plugin) {
         const { promises } = await import('node:fs');
         try {
@@ -229,6 +225,8 @@ export class PluginManager {
                 this.log.warn(`Plugin ${plg}${plugin.name}${wr} has no description in package.json`);
             if (!packageJson.author)
                 this.log.warn(`Plugin ${plg}${plugin.name}${wr} has no author in package.json`);
+            if (!packageJson.homepage)
+                this.log.warn(`Plugin ${plg}${plugin.name}${wr} has no homepage in package.json`);
             if (!packageJson.type || packageJson.type !== 'module')
                 this.log.error(`Plugin ${plg}${plugin.name}${er} is not a module`);
             if (!packageJson.main)
@@ -236,12 +234,15 @@ export class PluginManager {
             plugin.name = packageJson.name || 'Unknown name';
             plugin.version = packageJson.version || '1.0.0';
             plugin.description = packageJson.description || 'Unknown description';
-            plugin.author = packageJson.author || 'Unknown author';
+            plugin.author = this.getAuthor(packageJson);
+            plugin.homepage = this.getHomepage(packageJson);
+            plugin.help = this.getHelp(packageJson);
+            plugin.changelog = this.getChangelog(packageJson);
+            plugin.funding = this.getFunding(packageJson);
             if (!plugin.path)
                 this.log.warn(`Plugin ${plg}${plugin.name}${wr} has no path`);
             if (!plugin.type)
                 this.log.warn(`Plugin ${plg}${plugin.name}${wr} has no type`);
-            // Check for @project-chip and @matter packages in dependencies and devDependencies
             const checkForProjectChipPackages = (dependencies) => {
                 return Object.keys(dependencies).filter((pkg) => pkg.startsWith('@project-chip') || pkg.startsWith('@matter'));
             };
@@ -263,7 +264,6 @@ export class PluginManager {
                 this.log.error(`Please open an issue on the plugin repository to remove them.`);
                 return null;
             }
-            // Check for matterbridge package in dependencies and devDependencies
             const checkForMatterbridgePackage = (dependencies) => {
                 return Object.keys(dependencies).filter((pkg) => pkg === 'matterbridge');
             };
@@ -285,25 +285,14 @@ export class PluginManager {
                 this.log.error(`Please open an issue on the plugin repository to remove them.`);
                 return null;
             }
-            // await this.saveToStorage(); // No need to save the plugin to storage
             return packageJson;
         }
         catch (err) {
-            this.log.error(`Failed to parse package.json of plugin ${plg}${plugin.name}${er}: ${err}`);
+            this.log.error(`Failed to parse package.json of plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             plugin.error = true;
             return null;
         }
     }
-    /**
-     * Enables a plugin by its name or path.
-     *
-     * This method enables a plugin by setting its `enabled` property to `true` and saving the updated
-     * plugin information to storage. It first checks if the plugin is already registered in the `_plugins` map.
-     * If not, it attempts to resolve the plugin's `package.json` file to retrieve its name and enable it.
-     *
-     * @param {string} nameOrPath - The name or path of the plugin to enable.
-     * @returns {Promise<RegisteredPlugin | null>} A promise that resolves to the enabled plugin object, or null if the plugin could not be enabled.
-     */
     async enable(nameOrPath) {
         const { promises } = await import('node:fs');
         if (!nameOrPath || nameOrPath === '')
@@ -333,20 +322,10 @@ export class PluginManager {
             return plugin;
         }
         catch (err) {
-            this.log.error(`Failed to parse package.json of plugin ${plg}${nameOrPath}${er}: ${err}`);
+            this.log.error(`Failed to parse package.json of plugin ${plg}${nameOrPath}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             return null;
         }
     }
-    /**
-     * Enables a plugin by its name or path.
-     *
-     * This method enables a plugin by setting its `enabled` property to `true` and saving the updated
-     * plugin information to storage. It first checks if the plugin is already registered in the `_plugins` map.
-     * If not, it attempts to resolve the plugin's `package.json` file to retrieve its name and enable it.
-     *
-     * @param {string} nameOrPath - The name or path of the plugin to enable.
-     * @returns {Promise<RegisteredPlugin | null>} A promise that resolves to the enabled plugin object, or null if the plugin could not be enabled.
-     */
     async disable(nameOrPath) {
         const { promises } = await import('node:fs');
         if (!nameOrPath || nameOrPath === '')
@@ -376,20 +355,10 @@ export class PluginManager {
             return plugin;
         }
         catch (err) {
-            this.log.error(`Failed to parse package.json of plugin ${plg}${nameOrPath}${er}: ${err}`);
+            this.log.error(`Failed to parse package.json of plugin ${plg}${nameOrPath}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             return null;
         }
     }
-    /**
-     * Removes a plugin by its name or path.
-     *
-     * This method removes a plugin from the `_plugins` map and saves the updated plugin information to storage.
-     * It first checks if the plugin is already registered in the `_plugins` map. If not, it attempts to resolve
-     * the plugin's `package.json` file to retrieve its name and remove it.
-     *
-     * @param {string} nameOrPath - The name or path of the plugin to remove.
-     * @returns {Promise<RegisteredPlugin | null>} A promise that resolves to the removed plugin object, or null if the plugin could not be removed.
-     */
     async remove(nameOrPath) {
         const { promises } = await import('node:fs');
         if (!nameOrPath || nameOrPath === '')
@@ -419,21 +388,10 @@ export class PluginManager {
             return plugin;
         }
         catch (err) {
-            this.log.error(`Failed to parse package.json of plugin ${plg}${nameOrPath}${er}: ${err}`);
+            this.log.error(`Failed to parse package.json of plugin ${plg}${nameOrPath}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             return null;
         }
     }
-    /**
-     * Adds a plugin by its name or path.
-     *
-     * This method adds a plugin to the `_plugins` map and saves the updated plugin information to storage.
-     * It first resolves the plugin's `package.json` file to retrieve its details. If the plugin is already
-     * registered, it logs an info message and returns null. Otherwise, it registers the plugin, enables it,
-     * and saves the updated plugin information to storage.
-     *
-     * @param {string} nameOrPath - The name or path of the plugin to add.
-     * @returns {Promise<RegisteredPlugin | null>} A promise that resolves to the added plugin object, or null if the plugin could not be added.
-     */
     async add(nameOrPath) {
         const { promises } = await import('node:fs');
         if (!nameOrPath || nameOrPath === '')
@@ -449,26 +407,25 @@ export class PluginManager {
                 this.log.info(`Plugin ${plg}${nameOrPath}${nf} already registered`);
                 return null;
             }
-            this._plugins.set(packageJson.name, { name: packageJson.name, enabled: true, path: packageJsonPath, type: 'AnyPlatform', version: packageJson.version, description: packageJson.description, author: packageJson.author });
+            this._plugins.set(packageJson.name, {
+                name: packageJson.name,
+                enabled: true,
+                path: packageJsonPath,
+                type: 'AnyPlatform',
+                version: packageJson.version,
+                description: packageJson.description,
+                author: this.getAuthor(packageJson),
+            });
             this.log.info(`Added plugin ${plg}${packageJson.name}${nf}`);
             await this.saveToStorage();
             const plugin = this._plugins.get(packageJson.name);
             return plugin || null;
         }
         catch (err) {
-            this.log.error(`Failed to parse package.json of plugin ${plg}${nameOrPath}${er}: ${err instanceof Error ? err.message : err}`);
+            this.log.error(`Failed to parse package.json of plugin ${plg}${nameOrPath}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             return null;
         }
     }
-    /**
-     * Installs a plugin by its name.
-     *
-     * This method first uninstalls any existing version of the plugin, then installs the plugin globally using npm.
-     * It logs the installation process and retrieves the installed version of the plugin.
-     *
-     * @param {string} name - The name of the plugin to install.
-     * @returns {Promise<string | undefined>} A promise that resolves to the installed version of the plugin, or undefined if the installation failed.
-     */
     async install(name) {
         const { exec } = await import('node:child_process');
         await this.uninstall(name);
@@ -483,14 +440,11 @@ export class PluginManager {
                 else {
                     this.log.info(`Installed plugin ${plg}${name}${nf}`);
                     this.log.debug(`Installed plugin ${plg}${name}${db}: ${stdout}`);
-                    // Get the installed version
-                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
                     exec(`npm list -g ${name} --depth=0`, (listError, listStdout, listStderr) => {
                         if (listError) {
                             this.log.error(`List error: ${listError}`);
                             resolve(undefined);
                         }
-                        // Clean the output to get only the package name and version
                         const lines = listStdout.split('\n');
                         const versionLine = lines.find((line) => line.includes(`${name}@`));
                         if (versionLine) {
@@ -506,15 +460,6 @@ export class PluginManager {
             });
         });
     }
-    /**
-     * Uninstalls a plugin by its name.
-     *
-     * This method uninstalls a globally installed plugin using npm. It logs the uninstallation process
-     * and returns the name of the uninstalled plugin if successful, or undefined if the uninstallation failed.
-     *
-     * @param {string} name - The name of the plugin to uninstall.
-     * @returns {Promise<string | undefined>} A promise that resolves to the name of the uninstalled plugin, or undefined if the uninstallation failed.
-     */
     async uninstall(name) {
         const { exec } = await import('node:child_process');
         this.log.info(`Uninstalling plugin ${plg}${name}${nf}`);
@@ -533,14 +478,6 @@ export class PluginManager {
             });
         });
     }
-    /**
-     * Loads a plugin and returns the corresponding MatterbridgePlatform instance.
-     * @param plugin - The plugin to load.
-     * @param start - Optional flag indicating whether to start the plugin after loading. Default is false.
-     * @param message - Optional message to pass to the plugin when starting.
-     * @returns A Promise that resolves to the loaded MatterbridgePlatform instance.
-     * @throws An error if the plugin is not enabled, already loaded, or fails to load.
-     */
     async load(plugin, start = false, message = '', configure = false) {
         const { promises } = await import('node:fs');
         const { default: path } = await import('node:path');
@@ -554,29 +491,24 @@ export class PluginManager {
         }
         this.log.info(`Loading plugin ${plg}${plugin.name}${nf} type ${typ}${plugin.type}${nf}`);
         try {
-            // Load the package.json of the plugin
             const packageJson = JSON.parse(await promises.readFile(plugin.path, 'utf8'));
-            // Resolve the main module path relative to package.json
             const pluginEntry = path.resolve(path.dirname(plugin.path), packageJson.main);
-            // Dynamically import the plugin
             const { pathToFileURL } = await import('node:url');
             const pluginUrl = pathToFileURL(pluginEntry);
             this.log.debug(`Importing plugin ${plg}${plugin.name}${db} from ${pluginUrl.href}`);
             const pluginInstance = await import(pluginUrl.href);
             this.log.debug(`Imported plugin ${plg}${plugin.name}${db} from ${pluginUrl.href}`);
-            // Call the default export function of the plugin, passing this MatterBridge instance, the log and the config
             if (pluginInstance.default) {
                 const config = await this.loadConfig(plugin);
-                // Preset the plugin properties here in case the plugin throws an error during loading. In this case the user can change the config and restart the plugin.
                 plugin.name = packageJson.name;
                 plugin.description = packageJson.description ?? 'No description';
                 plugin.version = packageJson.version;
-                plugin.author = packageJson.author ?? 'Unknown';
+                plugin.author = this.getAuthor(packageJson);
                 plugin.configJson = config;
                 plugin.schemaJson = await this.loadSchema(plugin);
                 config.name = plugin.name;
                 config.version = packageJson.version;
-                const log = new AnsiLogger({ logName: plugin.description ?? 'No description', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: config.debug ? "debug" /* LogLevel.DEBUG */ : this.matterbridge.log.logLevel });
+                const log = new AnsiLogger({ logName: plugin.description ?? 'No description', logTimestampFormat: 4, logLevel: config.debug ? "debug" : this.matterbridge.log.logLevel });
                 const platform = pluginInstance.default(this.matterbridge, log, config);
                 config.type = platform.type;
                 platform.name = packageJson.name;
@@ -585,15 +517,17 @@ export class PluginManager {
                 plugin.name = packageJson.name;
                 plugin.description = packageJson.description ?? 'No description';
                 plugin.version = packageJson.version;
-                plugin.author = packageJson.author ?? 'Unknown';
+                plugin.author = this.getAuthor(packageJson);
+                plugin.homepage = this.getHomepage(packageJson);
+                plugin.help = this.getHelp(packageJson);
+                plugin.changelog = this.getChangelog(packageJson);
+                plugin.funding = this.getFunding(packageJson);
                 plugin.type = platform.type;
                 plugin.platform = platform;
                 plugin.loaded = true;
                 plugin.registeredDevices = 0;
                 plugin.addedDevices = 0;
-                // plugin.configJson = config;
-                // plugin.schemaJson = await this.loadSchema(plugin);
-                await this.saveToStorage(); // Save the plugin to storage
+                await this.saveToStorage();
                 this.log.notice(`Loaded plugin ${plg}${plugin.name}${nt} type ${typ}${platform.type}${nt} (entrypoint ${UNDERLINE}${pluginEntry}${UNDERLINEOFF})`);
                 if (start)
                     await this.start(plugin, message, false);
@@ -607,19 +541,11 @@ export class PluginManager {
             }
         }
         catch (err) {
-            this.log.error(`Failed to load plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message : err}`);
+            this.log.error(`Failed to load plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             plugin.error = true;
         }
         return undefined;
     }
-    /**
-     * Starts a plugin.
-     *
-     * @param {RegisteredPlugin} plugin - The plugin to start.
-     * @param {string} [message] - Optional message to pass to the plugin's onStart method.
-     * @param {boolean} [configure] - Indicates whether to configure the plugin after starting (default false).
-     * @returns {Promise<RegisteredPlugin | undefined>} A promise that resolves when the plugin is started successfully, or rejects with an error if starting the plugin fails.
-     */
     async start(plugin, message, configure = false) {
         if (!plugin.loaded) {
             this.log.error(`Plugin ${plg}${plugin.name}${er} not loaded`);
@@ -645,16 +571,10 @@ export class PluginManager {
         }
         catch (err) {
             plugin.error = true;
-            this.log.error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message : err}`);
+            this.log.error(`Failed to start plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
         }
         return undefined;
     }
-    /**
-     * Configures a plugin.
-     *
-     * @param {RegisteredPlugin} plugin - The plugin to configure.
-     * @returns {Promise<void>} A promise that resolves when the plugin is configured successfully, or rejects with an error if configuration fails.
-     */
     async configure(plugin) {
         if (!plugin.loaded) {
             this.log.error(`Plugin ${plg}${plugin.name}${er} not loaded`);
@@ -681,22 +601,10 @@ export class PluginManager {
         }
         catch (err) {
             plugin.error = true;
-            this.log.error(`Failed to configure plugin ${plg}${plugin.name}${er}: ${err}`);
+            this.log.error(`Failed to configure plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
         }
         return undefined;
     }
-    /**
-     * Shuts down a plugin.
-     *
-     * This method shuts down a plugin by calling its `onShutdown` method and resetting its state.
-     * It logs the shutdown process and optionally removes all devices associated with the plugin.
-     *
-     * @param {RegisteredPlugin} plugin - The plugin to shut down.
-     * @param {string} [reason] - The reason for shutting down the plugin.
-     * @param {boolean} [removeAllDevices=false] - Whether to remove all devices associated with the plugin.
-     * @param {boolean} [force=false] - Whether to force the shutdown even if the plugin is not loaded or started.
-     * @returns {Promise<RegisteredPlugin | undefined>} A promise that resolves to the shut down plugin object, or undefined if the shutdown failed.
-     */
     async shutdown(plugin, reason, removeAllDevices = false, force = false) {
         this.log.debug(`Shutting down plugin ${plg}${plugin.name}${db}`);
         if (!plugin.loaded) {
@@ -735,19 +643,10 @@ export class PluginManager {
             return plugin;
         }
         catch (err) {
-            this.log.error(`Failed to shut down plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message : err}`);
+            this.log.error(`Failed to shut down plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
         }
         return undefined;
     }
-    /**
-     * Loads the configuration for a plugin.
-     * If the configuration file exists, it reads the file and returns the parsed JSON data.
-     * If the configuration file does not exist, it creates a new file with default configuration and returns it.
-     * If any error occurs during file access or creation, it logs an error and return un empty config.
-     *
-     * @param plugin - The plugin for which to load the configuration.
-     * @returns A promise that resolves to the loaded or created configuration.
-     */
     async loadConfig(plugin) {
         const { default: path } = await import('node:path');
         const { promises } = await import('node:fs');
@@ -758,8 +657,6 @@ export class PluginManager {
             const data = await promises.readFile(configFile, 'utf8');
             const config = JSON.parse(data);
             this.log.debug(`Loaded config file ${configFile} for plugin ${plg}${plugin.name}${db}.`);
-            // this.log.debug(`Loaded config file ${configFile} for plugin ${plg}${plugin.name}${db}.\nConfig:${rs}\n`, config);
-            // The first time a plugin is added to the system, the config file is created with the plugin name and type "AnyPlatform".
             config.name = plugin.name;
             config.type = plugin.type;
             if (config.debug === undefined)
@@ -783,32 +680,19 @@ export class PluginManager {
                 try {
                     await promises.writeFile(configFile, JSON.stringify(config, null, 2), 'utf8');
                     this.log.debug(`Created config file ${configFile} for plugin ${plg}${plugin.name}${db}.`);
-                    // this.log.debug(`Created config file ${configFile} for plugin ${plg}${plugin.name}${db}.\nConfig:${rs}\n`, config);
                     return config;
                 }
                 catch (err) {
-                    this.log.error(`Error creating config file ${configFile} for plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message : err}`);
+                    this.log.error(`Error creating config file ${configFile} for plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
                     return config;
                 }
             }
             else {
-                this.log.error(`Error accessing config file ${configFile} for plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message : err}`);
+                this.log.error(`Error accessing config file ${configFile} for plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
                 return { name: plugin.name, type: plugin.type, debug: false, unregisterOnShutdown: false };
             }
         }
     }
-    /**
-     * Saves the configuration of a plugin to a file.
-     *
-     * This method saves the configuration of the specified plugin to a JSON file in the matterbridge directory.
-     * If the plugin's configuration is not found, it logs an error and rejects the promise. If the configuration
-     * is successfully saved, it logs a debug message. If an error occurs during the file write operation, it logs
-     * the error and rejects the promise.
-     *
-     * @param {RegisteredPlugin} plugin - The plugin whose configuration is to be saved.
-     * @returns {Promise<void>} A promise that resolves when the configuration is successfully saved, or rejects if an error occurs.
-     * @throws {Error} If the plugin's configuration is not found.
-     */
     async saveConfigFromPlugin(plugin) {
         const { default: path } = await import('node:path');
         const { promises } = await import('node:fs');
@@ -821,27 +705,13 @@ export class PluginManager {
             await promises.writeFile(configFile, JSON.stringify(plugin.platform.config, null, 2), 'utf8');
             plugin.configJson = plugin.platform.config;
             this.log.debug(`Saved config file ${configFile} for plugin ${plg}${plugin.name}${db}`);
-            // this.log.debug(`Saved config file ${configFile} for plugin ${plg}${plugin.name}${db}.\nConfig:${rs}\n`, plugin.platform.config);
             return Promise.resolve();
         }
         catch (err) {
-            this.log.error(`Error saving config file ${configFile} for plugin ${plg}${plugin.name}${er}: ${err}`);
+            this.log.error(`Error saving config file ${configFile} for plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             return Promise.reject(err);
         }
     }
-    /**
-     * Saves the configuration of a plugin from a JSON object to a file.
-     *
-     * This method saves the provided configuration of the specified plugin to a JSON file in the matterbridge directory.
-     * It first checks if the configuration data is valid by ensuring it contains the correct name and type, and matches
-     * the plugin's name. If the configuration data is invalid, it logs an error and returns. If the configuration is
-     * successfully saved, it updates the plugin's `configJson` property and logs a debug message. If an error occurs
-     * during the file write operation, it logs the error and returns.
-     *
-     * @param {RegisteredPlugin} plugin - The plugin whose configuration is to be saved.
-     * @param {PlatformConfig} config - The configuration data to be saved.
-     * @returns {Promise<void>} A promise that resolves when the configuration is successfully saved, or returns if an error occurs.
-     */
     async saveConfigFromJson(plugin, config) {
         const { default: path } = await import('node:path');
         const { promises } = await import('node:fs');
@@ -859,23 +729,12 @@ export class PluginManager {
                 plugin.platform.onConfigChanged(config).catch((err) => this.log.error(`Error calling onConfigChanged for plugin ${plg}${plugin.name}${er}: ${err}`));
             }
             this.log.debug(`Saved config file ${configFile} for plugin ${plg}${plugin.name}${db}`);
-            // this.log.debug(`Saved config file ${configFile} for plugin ${plg}${plugin.name}${db}.\nConfig:${rs}\n`, config);
         }
         catch (err) {
-            this.log.error(`Error saving config file ${configFile} for plugin ${plg}${plugin.name}${er}: ${err}`);
+            this.log.error(`Error saving config file ${configFile} for plugin ${plg}${plugin.name}${er}: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             return;
         }
     }
-    /**
-     * Loads the schema for a plugin.
-     *
-     * This method attempts to load the schema file for the specified plugin. If the schema file is found,
-     * it reads and parses the file, updates the schema's title and description, and logs the process.
-     * If the schema file is not found, it logs the event and loads a default schema for the plugin.
-     *
-     * @param {RegisteredPlugin} plugin - The plugin whose schema is to be loaded.
-     * @returns {Promise<PlatformSchema>} A promise that resolves to the loaded schema object, or the default schema if the schema file is not found.
-     */
     async loadSchema(plugin) {
         const { promises } = await import('node:fs');
         const schemaFile = plugin.path.replace('package.json', `${plugin.name}.schema.json`);
@@ -886,24 +745,13 @@ export class PluginManager {
             schema.title = plugin.description;
             schema.description = plugin.name + ' v. ' + plugin.version + ' by ' + plugin.author;
             this.log.debug(`Loaded schema file ${schemaFile} for plugin ${plg}${plugin.name}${db}.`);
-            // this.log.debug(`Loaded schema file ${schemaFile} for plugin ${plg}${plugin.name}${db}.\nSchema:${rs}\n`, schema);
             return schema;
         }
-        catch (error) {
-            this.log.debug(`Schema file ${schemaFile} for plugin ${plg}${plugin.name}${db} not found. Loading default schema. Error: ${error instanceof Error ? error.message : error}`);
+        catch (err) {
+            this.log.debug(`Schema file ${schemaFile} for plugin ${plg}${plugin.name}${db} not found. Loading default schema. Error: ${err instanceof Error ? err.message + '\n' + err.stack : err}`);
             return this.getDefaultSchema(plugin);
         }
     }
-    /**
-     * Returns the default schema for a plugin.
-     *
-     * This method generates a default schema object for the specified plugin. The schema includes
-     * metadata such as the plugin's title, description, version, and author. It also defines the
-     * properties of the schema, including the plugin's name, type, debug flag, and unregisterOnShutdown flag.
-     *
-     * @param {RegisteredPlugin} plugin - The plugin for which the default schema is to be generated.
-     * @returns {PlatformSchema} The default schema object for the plugin.
-     */
     getDefaultSchema(plugin) {
         return {
             title: plugin.description,
@@ -934,4 +782,3 @@ export class PluginManager {
         };
     }
 }
-//# sourceMappingURL=pluginManager.js.map