matterbridge 3.4.3-dev-20251209-e6cb85f → 3.4.3

package/dist/pluginManager.js

@@ -1,9 +1,37 @@
+/**
+ * This file contains the Plugins class.
+ *
+ * @file plugins.ts
+ * @author Luca Liguori
+ * @created 2024-07-14
+ * @version 1.3.5
+ * @license Apache-2.0
+ *
+ * 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.
+ */
+// Node.js import
 import EventEmitter from 'node:events';
+// AnsiLogger module
 import { AnsiLogger, UNDERLINE, UNDERLINEOFF, BLUE, db, er, nf, nt, rs, wr, debugStringify, CYAN } from 'node-ansi-logger';
 import { plg, typ } from './matterbridgeTypes.js';
 import { inspectError, logError } from './utils/error.js';
 import { hasParameter } from './utils/commandLine.js';
 import { BroadcastServer } from './broadcastServer.js';
+/**
+ * Manages Matterbridge plugins.
+ */
 export class PluginManager extends EventEmitter {
     matterbridge;
     _plugins = new Map();
@@ -11,10 +39,15 @@ export class PluginManager extends EventEmitter {
     server;
     debug = hasParameter('debug') || hasParameter('verbose');
     verbose = hasParameter('verbose');
+    /**
+     * Creates an instance of PluginManager.
+     *
+     * @param {Matterbridge} matterbridge - The Matterbridge instance.
+     */
     constructor(matterbridge) {
         super();
         this.matterbridge = matterbridge;
-        this.log = new AnsiLogger({ logName: 'PluginManager', logTimestampFormat: 4, logLevel: hasParameter('debug') ? "debug" : "info" });
+        this.log = new AnsiLogger({ logName: 'PluginManager', logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: hasParameter('debug') ? "debug" /* LogLevel.DEBUG */ : "info" /* LogLevel.INFO */ });
         this.log.debug('Matterbridge plugin manager starting...');
         this.server = new BroadcastServer('plugins', this.log);
         this.server.on('broadcast_message', this.msgHandler.bind(this));
@@ -187,7 +220,7 @@ export class PluginManager extends EventEmitter {
                     {
                         const plugin = this.get(msg.params.name);
                         if (plugin) {
-                            this.saveConfigFromJson(plugin, msg.params.config, msg.params.restartRequired);
+                            this.saveConfigFromJson(plugin, msg.params.config, msg.params.restartRequired); // No await as it's not necessary to wait
                             this.server.respond({ ...msg, result: { success: true } });
                         }
                         else {
@@ -225,25 +258,62 @@ export class PluginManager extends EventEmitter {
             }
         }
     }
+    /**
+     * Gets the number of plugins.
+     *
+     * @returns {number} The number of plugins.
+     */
     get length() {
         return this._plugins.size;
     }
+    /**
+     * Gets the number of plugins.
+     *
+     * @returns {number} The number of plugins.
+     */
     get size() {
         return this._plugins.size;
     }
+    /**
+     * Checks if a plugin with the specified name exists.
+     *
+     * @param {string} name - The name of the plugin.
+     * @returns {boolean} True if the plugin exists, false otherwise.
+     */
     has(name) {
         return this._plugins.has(name);
     }
+    /**
+     * Gets a plugin by its name.
+     *
+     * @param {string} name - The name of the plugin.
+     * @returns {Plugin | undefined} The plugin, or undefined if not found.
+     */
     get(name) {
         return this._plugins.get(name);
     }
+    /**
+     * Adds a plugin to the manager.
+     *
+     * @param {Plugin} plugin - The plugin to add.
+     * @returns {Plugin} The added plugin.
+     */
     set(plugin) {
         this._plugins.set(plugin.name, plugin);
         return plugin;
     }
+    /**
+     * Clears all plugins from the manager.
+     */
     clear() {
         this._plugins.clear();
     }
+    /**
+     * Converts a plugin or API plugin to a storage plugin.
+     *
+     * @param {Plugin | ApiPlugin} plugin - The plugin or API plugin to convert.
+     * @returns {StoragePlugin} The converted storage plugin.
+     */
     toStoragePlugin(plugin) {
         return {
             name: plugin.name,
@@ -255,6 +325,12 @@ export class PluginManager extends EventEmitter {
             enabled: plugin.enabled,
         };
     }
+    /**
+     * Converts a plugin to an API plugin.
+     *
+     * @param {Plugin} plugin - The plugin to convert.
+     * @returns {ApiPlugin} The converted API plugin.
+     */
     toApiPlugin(plugin) {
         return {
             name: plugin.name,
@@ -284,9 +360,19 @@ export class PluginManager extends EventEmitter {
             matter: plugin.serverNode ? this.matterbridge.getServerNodeData(plugin.serverNode) : undefined,
         };
     }
+    /**
+     * Gets an array of all plugins.
+     *
+     * @returns {Plugin[]} An array of all plugins.
+     */
     array() {
         return Array.from(this._plugins.values());
     }
+    /**
+     * Gets a StoragePlugin array of all plugins suitable for serialization.
+     *
+     * @returns {StoragePlugin[]} An array of all plugins.
+     */
     storagePluginArray() {
         const storagePlugins = [];
         for (const plugin of this._plugins.values()) {
@@ -294,6 +380,11 @@ export class PluginManager extends EventEmitter {
         }
         return storagePlugins;
     }
+    /**
+     * Gets an ApiPlugin array of all plugins suitable for serialization.
+     *
+     * @returns {ApiPlugin[]} An array of all plugins.
+     */
     apiPluginArray() {
         const apiPlugins = [];
         for (const plugin of this._plugins.values()) {
@@ -301,9 +392,20 @@ export class PluginManager extends EventEmitter {
         }
         return apiPlugins;
     }
+    /**
+     * Gets an iterator for the plugins.
+     *
+     * @returns {IterableIterator<Plugin>} An iterator for the plugins.
+     */
     [Symbol.iterator]() {
         return this._plugins.values();
     }
+    /**
+     * Executes a provided function once for each plugin.
+     *
+     * @param {Function} callback - The function to execute for each plugin.
+     * @returns {Promise<void>}
+     */
     async forEach(callback) {
         if (this.size === 0)
             return;
@@ -317,23 +419,40 @@ export class PluginManager extends EventEmitter {
         });
         await Promise.all(tasks);
     }
+    /**
+     * Sets the log level for the plugin manager.
+     *
+     * @param {LogLevel} logLevel - The log level to set.
+     */
     set logLevel(logLevel) {
         this.log.logLevel = logLevel;
     }
+    /**
+     * Loads registered plugins from storage.
+     *
+     * @returns {Promise<StoragePlugin[]>} A promise that resolves to an array of registered plugins.
+     */
     async loadFromStorage() {
         if (!this.matterbridge.nodeContext) {
             throw new Error('loadFromStorage: node context is not available.');
         }
+        // Load the array from storage and convert it to a map
         const pluginsArray = await this.matterbridge.nodeContext.get('plugins', []);
         for (const plugin of pluginsArray)
             this._plugins.set(plugin.name, plugin);
         this.log.debug(`Loaded ${BLUE}${pluginsArray.length}${db} plugins from storage`);
         return pluginsArray;
     }
+    /**
+     * Saves registered plugins to storage.
+     *
+     * @returns {Promise<number>} A promise that resolves to the number of registered plugins.
+     */
     async saveToStorage() {
         if (!this.matterbridge.nodeContext) {
             throw new Error('loadFromStorage: node context is not available.');
         }
+        // Convert the map to an array
         const plugins = [];
         for (const plugin of this.array()) {
             plugins.push({
@@ -350,13 +469,22 @@ export class PluginManager extends EventEmitter {
         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.
+     * It will first try to resolve the path as is, then in the global modules directory, and finally in the matterbridge plugin directory.
+     *
+     * @param {string} nameOrPath - The name of the plugin or the path to the plugin's package.json file.
+     * @returns {Promise<string | null>} A promise that resolves to the path of the plugin's package.json file or null if it could not be resolved.
+     */
     async resolve(nameOrPath) {
         const { default: path } = await import('node:path');
         const { promises } = await import('node:fs');
         if (!nameOrPath.endsWith('package.json'))
             nameOrPath = path.join(nameOrPath, 'package.json');
+        // Resolve the package.json of the plugin
         let packageJsonPath = path.resolve(nameOrPath);
         this.log.debug(`Resolving plugin path ${plg}${packageJsonPath}${db}`);
+        // Check if the package.json file exists at the specified path or next try in the global modules directory
         try {
             await promises.access(packageJsonPath);
         }
@@ -365,6 +493,7 @@ export class PluginManager extends EventEmitter {
             packageJsonPath = path.join(this.matterbridge.globalModulesDirectory, nameOrPath);
             this.log.debug(`Trying at ${plg}${packageJsonPath}${db}`);
         }
+        // Check if the package.json file exists at the global modules directory or next try in the matterbridge plugin directory
         try {
             await promises.access(packageJsonPath);
         }
@@ -374,7 +503,9 @@ export class PluginManager extends EventEmitter {
             this.log.debug(`Trying at ${plg}${packageJsonPath}${db}`);
         }
         try {
+            // Load the package.json of the plugin or fails if even not found in the matterbridge plugin directory
             const packageJson = JSON.parse(await promises.readFile(packageJsonPath, 'utf8'));
+            // Check for main issues
             if (!packageJson.name) {
                 this.log.error(`Package.json name not found at ${packageJsonPath}`);
                 return null;
@@ -387,6 +518,7 @@ export class PluginManager extends EventEmitter {
                 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'));
             };
@@ -408,6 +540,7 @@ export class PluginManager extends EventEmitter {
                 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');
             };
@@ -437,13 +570,19 @@ export class PluginManager extends EventEmitter {
             return null;
         }
     }
+    /**
+     * Installs a package globally using npm.
+     *
+     * @param {string} packageName - The name of the package to install.
+     * @returns {Promise<boolean>} A promise that resolves to true if the installation was successful, false otherwise.
+     */
     async install(packageName) {
         this.log.debug(`Installing plugin ${plg}${packageName}${db}...`);
         const { spawnCommand } = await import('./utils/spawn.js');
         if (await spawnCommand('npm', ['install', '-g', packageName, '--omit=dev', '--verbose'], 'install', packageName)) {
             this.matterbridge.restartRequired = true;
             this.matterbridge.fixedRestartRequired = true;
-            packageName = packageName.replace(/@.*$/, '');
+            packageName = packageName.replace(/@.*$/, ''); // Remove @version if present
             if (packageName !== 'matterbridge') {
                 if (!this.has(packageName))
                     await this.add(packageName);
@@ -464,6 +603,12 @@ export class PluginManager extends EventEmitter {
             return false;
         }
     }
+    /**
+     * Uninstalls a package globally using npm.
+     *
+     * @param {string} packageName - The name of the package to uninstall.
+     * @returns {Promise<boolean>} A promise that resolves to true if the uninstallation was successful, false otherwise.
+     */
     async uninstall(packageName) {
         this.log.debug(`Uninstalling plugin ${plg}${packageName}${db}...`);
         const { spawnCommand } = await import('./utils/spawn.js');
@@ -485,6 +630,12 @@ export class PluginManager extends EventEmitter {
             return false;
         }
     }
+    /**
+     * Get the author of a plugin from its package.json.
+     *
+     * @param {Record<string, string | number | Record<string, string | number | object>>} packageJson - The package.json object of the plugin.
+     * @returns {string} The author of the plugin, or 'Unknown author' if not found.
+     */
     getAuthor(packageJson) {
         if (packageJson.author && typeof packageJson.author === 'string')
             return packageJson.author;
@@ -492,6 +643,12 @@ export class PluginManager extends EventEmitter {
             return packageJson.author.name;
         return 'Unknown author';
     }
+    /**
+     * Get the homepage of a plugin from its package.json.
+     *
+     * @param {Record<string, string | number | Record<string, string | number | object>>} packageJson - The package.json object of the plugin.
+     * @returns {string | undefined} The homepage of the plugin, or undefined if not found.
+     */
     getHomepage(packageJson) {
         if (packageJson.homepage && typeof packageJson.homepage === 'string' && packageJson.homepage.includes('http')) {
             return packageJson.homepage.replace('git+', '').replace('.git', '');
@@ -500,7 +657,14 @@ export class PluginManager extends EventEmitter {
             return packageJson.repository.url.replace('git+', '').replace('.git', '');
         }
     }
+    /**
+     * Get the help URL of a plugin from its package.json.
+     *
+     * @param {Record<string, string | number | Record<string, string | number | object>>} packageJson - The package.json object of the plugin.
+     * @returns {string | undefined} The URL to the help page or to the README file, or undefined if not found.
+     */
     getHelp(packageJson) {
+        // If there's a help field that looks like a URL, return it.
         if (packageJson.help && typeof packageJson.help === 'string' && packageJson.help.startsWith('http')) {
             return packageJson.help;
         }
@@ -511,7 +675,14 @@ export class PluginManager extends EventEmitter {
             return packageJson.homepage.replace('git+', '').replace('.git', '');
         }
     }
+    /**
+     * Get the changelog URL of a plugin from its package.json.
+     *
+     * @param {Record<string, string | number | Record<string, string | number | object>>} packageJson - The package.json object of the plugin.
+     * @returns {string | undefined} The URL to the CHANGELOG file, or undefined if not found.
+     */
     getChangelog(packageJson) {
+        // If there's a changelog field that looks like a URL, return it.
         if (packageJson.changelog && typeof packageJson.changelog === 'string' && packageJson.changelog.startsWith('http')) {
             return packageJson.changelog;
         }
@@ -522,6 +693,13 @@ export class PluginManager extends EventEmitter {
             return packageJson.homepage.replace('git+', '').replace('.git', '');
         }
     }
+    /**
+     * Get the first funding URL(s) of a plugin from its package.json.
+     *
+     * @param {Record<string, any>} packageJson - The package.json object of the plugin.
+     * @returns {string | undefined} The first funding URLs, or undefined if not found.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getFunding(packageJson) {
         const funding = packageJson.funding;
         if (!funding)
@@ -530,16 +708,27 @@ export class PluginManager extends EventEmitter {
             return;
         if (typeof funding === 'string' && funding.startsWith('http'))
             return funding;
+        // Normalize funding into an array.
         const fundingEntries = Array.isArray(funding) ? funding : [funding];
         for (const entry of fundingEntries) {
             if (entry && typeof entry === 'string' && entry.startsWith('http')) {
+                // If the funding entry is a string, assume it is a URL.
                 return entry;
             }
             else if (entry && typeof entry === 'object' && typeof entry.url === 'string' && entry.url.startsWith('http')) {
+                // If it's an object with a 'url' property, use that.
                 return entry.url;
             }
         }
     }
+    /**
+     * Parses the plugin package.json and returns it.
+     * It will also log warnings and errors for missing or invalid fields.
+     * It will return null if critical errors are found.
+     *
+     * @param {Plugin | PluginName} plugin - The plugin to load the package from.
+     * @returns {Promise<Record<string, string | number | object> | null>} A promise that resolves to the parsed package.json object or null if it could not be parsed.
+     */
     async parse(plugin) {
         const { promises } = await import('node:fs');
         if (typeof plugin === 'string') {
@@ -577,6 +766,7 @@ export class PluginManager extends EventEmitter {
             plugin.funding = this.getFunding(packageJson);
             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'));
             };
@@ -598,6 +788,7 @@ export class PluginManager extends EventEmitter {
                 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');
             };
@@ -627,6 +818,16 @@ export class PluginManager extends EventEmitter {
             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<Plugin | 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)
@@ -662,6 +863,16 @@ export class PluginManager extends EventEmitter {
             return null;
         }
     }
+    /**
+     * Disables a plugin by its name or path.
+     *
+     * This method disables a plugin by setting its `enabled` property to `false` 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 disable it.
+     *
+     * @param {string} nameOrPath - The name or path of the plugin to enable.
+     * @returns {Promise<Plugin | null>} A promise that resolves to the disabled plugin object, or null if the plugin could not be disabled.
+     */
     async disable(nameOrPath) {
         const { promises } = await import('node:fs');
         if (!nameOrPath)
@@ -697,6 +908,16 @@ export class PluginManager extends EventEmitter {
             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<Plugin | 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)
@@ -732,6 +953,17 @@ export class PluginManager extends EventEmitter {
             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<Plugin | 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)
@@ -771,6 +1003,15 @@ export class PluginManager extends EventEmitter {
             return null;
         }
     }
+    /**
+     * Loads a plugin and returns the corresponding MatterbridgePlatform instance.
+     *
+     * @param {Plugin | PluginName} plugin - The plugin to load.
+     * @param {boolean} start - Optional flag indicating whether to start the plugin after loading. Default is false.
+     * @param {string} message - Optional message to pass to the plugin when starting.
+     * @param {boolean} configure - Optional flag indicating whether to configure the plugin after loading. Default is false.
+     * @returns {Promise<MatterbridgePlatform | undefined>} A Promise that resolves to the loaded MatterbridgePlatform instance or undefined.
+     */
     async load(plugin, start = false, message = '', configure = false) {
         const { promises } = await import('node:fs');
         const { default: path } = await import('node:path');
@@ -792,15 +1033,20 @@ export class PluginManager extends EventEmitter {
         }
         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;
@@ -809,13 +1055,14 @@ export class PluginManager extends EventEmitter {
                 plugin.schemaJson = await this.loadSchema(plugin);
                 config.name = packageJson.name;
                 config.version = packageJson.version;
-                const log = new AnsiLogger({ logName: plugin.description, logTimestampFormat: 4, logLevel: config.debug ? "debug" : this.matterbridge.logLevel });
+                const log = new AnsiLogger({ logName: plugin.description, logTimestampFormat: 4 /* TimestampFormat.TIME_MILLIS */, logLevel: config.debug ? "debug" /* LogLevel.DEBUG */ : this.matterbridge.logLevel });
                 const platform = pluginInstance.default(this.matterbridge, log, config);
                 config.type = platform.type;
                 platform.name = packageJson.name;
                 platform.config = config;
                 platform.version = packageJson.version;
                 platform.isLoaded = true;
+                // @ts-expect-error - setMatterNode is intentionally private
                 platform.setMatterNode?.(this.matterbridge.addBridgedEndpoint.bind(this.matterbridge), this.matterbridge.removeBridgedEndpoint.bind(this.matterbridge), this.matterbridge.removeAllBridgedEndpoints.bind(this.matterbridge), this.matterbridge.addVirtualEndpoint.bind(this.matterbridge));
                 plugin.name = packageJson.name;
                 plugin.description = packageJson.description ?? 'No description';
@@ -829,7 +1076,7 @@ export class PluginManager extends EventEmitter {
                 plugin.platform = platform;
                 plugin.loaded = true;
                 plugin.registeredDevices = 0;
-                await this.saveToStorage();
+                await this.saveToStorage(); // Save the plugin to storage
                 this.log.notice(`Loaded plugin ${plg}${plugin.name}${nt} type ${typ}${platform.type}${nt} (entrypoint ${UNDERLINE}${pluginEntry}${UNDERLINEOFF})`);
                 this.emit('loaded', plugin.name);
                 if (start)
@@ -849,6 +1096,14 @@ export class PluginManager extends EventEmitter {
         }
         return undefined;
     }
+    /**
+     * Starts a plugin.
+     *
+     * @param {Plugin | PluginName} 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<Plugin | 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 (typeof plugin === 'string') {
             const p = this._plugins.get(plugin);
@@ -888,6 +1143,12 @@ export class PluginManager extends EventEmitter {
         }
         return undefined;
     }
+    /**
+     * Configures a plugin.
+     *
+     * @param {Plugin | PluginName} plugin - The plugin to configure.
+     * @returns {Promise<Plugin | undefined>} A promise that resolves when the plugin is configured successfully, or rejects with an error if configuration fails.
+     */
     async configure(plugin) {
         if (typeof plugin === 'string') {
             const p = this._plugins.get(plugin);
@@ -928,6 +1189,18 @@ export class PluginManager extends EventEmitter {
         }
         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 {Plugin | PluginName} plugin - The plugin to shut down.
+     * @param {string} [reason] - The reason for shutting down the plugin.
+     * @param {boolean} [removeAllDevices] - Whether to remove all devices associated with the plugin.
+     * @param {boolean} [force] - Whether to force the shutdown even if the plugin is not loaded or started.
+     * @returns {Promise<Plugin | 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) {
         if (typeof plugin === 'string') {
             const p = this._plugins.get(plugin);
@@ -984,6 +1257,15 @@ export class PluginManager extends EventEmitter {
         }
         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} plugin - The plugin for which to load the configuration.
+     * @returns {Promise<PlatformConfig>} 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');
@@ -994,6 +1276,8 @@ export class PluginManager extends EventEmitter {
             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)
@@ -1020,6 +1304,7 @@ export class PluginManager extends EventEmitter {
                 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) {
@@ -1033,6 +1318,19 @@ export class PluginManager extends EventEmitter {
             }
         }
     }
+    /**
+     * 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 {Plugin} plugin - The plugin whose configuration is to be saved.
+     * @param {boolean} [restartRequired] - Indicates whether a restart is required after saving the configuration.
+     * @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, restartRequired = false) {
         const { default: path } = await import('node:path');
         const { promises } = await import('node:fs');
@@ -1047,6 +1345,7 @@ export class PluginManager extends EventEmitter {
             if (restartRequired)
                 plugin.restartRequired = true;
             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) {
@@ -1054,6 +1353,20 @@ export class PluginManager extends EventEmitter {
             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 {Plugin} plugin - The plugin whose configuration is to be saved.
+     * @param {PlatformConfig} config - The configuration data to be saved.
+     * @param {boolean} [restartRequired] - Indicates whether a restart is required after saving the configuration.
+     * @returns {Promise<void>} A promise that resolves when the configuration is successfully saved, or returns if an error occurs.
+     */
     async saveConfigFromJson(plugin, config, restartRequired = false) {
         const { default: path } = await import('node:path');
         const { promises } = await import('node:fs');
@@ -1072,12 +1385,23 @@ export class PluginManager extends EventEmitter {
                 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) {
             logError(this.log, `Error saving config file ${configFile} for plugin ${plg}${plugin.name}${er}`, 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 {Plugin} 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`);
@@ -1088,6 +1412,7 @@ export class PluginManager extends EventEmitter {
             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 (_err) {
@@ -1095,6 +1420,16 @@ export class PluginManager extends EventEmitter {
             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 {Plugin} 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,
@@ -1125,3 +1460,4 @@ export class PluginManager extends EventEmitter {
         };
     }
 }
+//# sourceMappingURL=pluginManager.js.map