bun_plugins 1.2.6 → 1.2.7

package/dist/{PluginManager.js → src/PluginManager.js}

@@ -1,21 +1,24 @@
 import { EventEmitter } from "node:events";
 import { readdir, mkdir } from "node:fs/promises";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { watch, existsSync } from "node:fs";
 import { WorkerMessageType, PluginPermission, RPCMethod, HookType } from "./types";
 import { validatePlugin } from "./utils/pluginValidator";
 import { JsonPluginStorage } from "./storage/JsonPluginStorage";
-import semver from "semver";
+import * as semver from "semver";
 import { ResourceManager } from "./managers/ResourceManager";
 import { DependencyManager } from "./managers/DependencyManager";
 import { HooksManager } from "./managers/HooksManager";
 import { createPluginContext } from "./managers/ContextFactory";
 import { errorParser } from "./utils/errorParser";
 import { checkNetworkPermission, checkPermission as checkGeneralPermission } from "./utils/security";
+import { logger } from "./logger";
 export class PluginManager extends EventEmitter {
     plugins = new Map();
     availablePlugins = new Map();
-    pluginFiles = new Map(); // filePath -> pluginName
+    configs = new Map();
+    pluginApis = new Map();
+    pluginFilePaths = new Map();
     // Modules
     resources;
     dependencyManager;
@@ -25,8 +28,6 @@ export class PluginManager extends EventEmitter {
     pluginLoadTimeout;
     workerFactory;
     workerRunnerPath;
-    hotReloadWatcher = null;
-    hotReloadTimer = null;
     constructor(storageRoot = join(process.cwd(), "storage"), options) {
         super();
         this.storageRoot = storageRoot;
@@ -62,9 +63,9 @@ export class PluginManager extends EventEmitter {
                 throw new Error(`Plugin ${plugin.name} requires host version ${plugin.engines.host}, but found ${this.hostVersion}`);
             }
         }
-        console.log(`Loading plugin: ${plugin.name} v${plugin.version}`);
-        // 1. Prepare Storage
-        const storage = new JsonPluginStorage(this.storageRoot, plugin.name);
+        logger.getLogger("PluginManager").info(`Loading plugin: ${plugin.name} v${plugin.version}`);
+        // 1. Prepare Storage (singleton)
+        const storage = JsonPluginStorage.getInstance(this.storageRoot, plugin.name);
         // 2. Load & Validate Configuration
         let config = plugin.defaultConfig || {};
         if (plugin.configSchema) {
@@ -73,8 +74,7 @@ export class PluginManager extends EventEmitter {
             }
             catch (e) {
                 const error = errorParser(e, `Error in plugin ${plugin.name}`);
-                console.warn(`[SafeMode] Using default config, validation failed. Error: ${error.message}`);
-                config = {}; // Reset to empty config on validation failure to prevent downstream errors
+                logger.getLogger("PluginManager").warn(`[SafeMode] Using default config, validation failed. Error: ${error.message}`);
             }
         }
         // 3. Initialize Resources
@@ -84,37 +84,57 @@ export class PluginManager extends EventEmitter {
             throw new Error(`Invalid plugin name: ${plugin.name}. Name cannot contain path traversal characters.`);
         }
         // 4. Context Creation
-        const context = createPluginContext(this, plugin, this.resources, storage, config);
+        this.configs.set(plugin.name, config);
+        const context = createPluginContext(this, plugin, this.resources, storage);
         // 5. Setup Hooks with Performance Monitoring (Delegated to HooksManager via Builder)
         if (plugin.setup) {
             try {
-                await plugin.setup(this.hooksManager.getBuilder(plugin.name));
+                await plugin.setup(this.hooksManager.getBuilder(plugin.name, config));
             }
             catch (e) {
-                console.error(`Error during setup for ${plugin.name}:`, e);
+                logger.getLogger("PluginManager").error(`Error during setup for ${plugin.name}:`, e);
                 throw errorParser(e, `Error during setup for ${plugin.name}`);
             }
         }
         // 6. Lifecycle onLoad
         try {
-            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Plugin ${plugin.name} timed out (${this.pluginLoadTimeout}ms)`)), this.pluginLoadTimeout));
+            let completed = false;
+            let timeoutError = null;
+            const timeoutId = setTimeout(() => {
+                if (!completed) {
+                    completed = true;
+                    timeoutError = new Error(`Plugin ${plugin.name} timed out (${this.pluginLoadTimeout}ms)`);
+                }
+            }, this.pluginLoadTimeout);
             const start = performance.now();
-            await Promise.race([plugin.onLoad(context), timeoutPromise]);
+            try {
+                await plugin.onLoad(context);
+            }
+            finally {
+                completed = true;
+                clearTimeout(timeoutId);
+            }
+            // Check if timeout triggered
+            if (timeoutError) {
+                throw timeoutError;
+            }
             const duration = performance.now() - start;
             this.plugins.set(plugin.name, plugin);
-            console.log(`Plugin ${plugin.name} loaded successfully in ${duration.toFixed(2)}ms.`);
+            logger.getLogger("PluginManager").info(`Plugin ${plugin.name} loaded successfully in ${duration.toFixed(2)}ms.`);
             // Trigger onStarted after registration if provided
             if (plugin.onStarted) {
                 try {
                     await plugin.onStarted();
                 }
                 catch (e) {
-                    console.error(`Error in onStarted for ${plugin.name}:`, e);
+                    logger.getLogger("PluginManager").error(`Error in onStarted for ${plugin.name}:`, e);
                 }
             }
+            // 7. Trigger onStart hooks registered via setup()
+            await this.hooksManager.runOnStart();
         }
         catch (error) {
-            console.error(`Failed to load plugin ${plugin.name}:`, error);
+            logger.getLogger("PluginManager").error(`Failed to load plugin ${plugin.name}:`, error);
             // Cleanup resources directly since plugin is not in this.plugins yet
             this.resources.cleanup(plugin.name, this);
             this.hooksManager.cleanup(plugin.name);
@@ -124,7 +144,7 @@ export class PluginManager extends EventEmitter {
     async registerIsolated(pluginPath, pluginName) {
         return new Promise((resolve, reject) => {
             const workerScript = this.workerRunnerPath;
-            console.log("Worker Path:", workerScript);
+            logger.getLogger("PluginManager").info("Worker Path:", workerScript);
             const timeoutId = setTimeout(() => {
                 worker.terminate();
                 reject(new Error(`Isolated plugin ${pluginName} timed out during loading (${this.pluginLoadTimeout}ms)`));
@@ -138,7 +158,7 @@ export class PluginManager extends EventEmitter {
                 worker.terminate();
                 return reject(new Error(`Invalid plugin name: ${pluginName}. Name cannot contain path traversal characters.`));
             }
-            const storage = new JsonPluginStorage(this.storageRoot, pluginName);
+            const storage = JsonPluginStorage.getInstance(this.storageRoot, pluginName);
             const pendingHooks = new Map();
             // Initialize resources
             const res = this.resources.init(pluginName);
@@ -205,16 +225,28 @@ export class PluginManager extends EventEmitter {
                             else if (type === HookType.ON_LOAD) {
                                 this.hooksManager.registerOnLoad(filterRegExp, proxyCallback, pluginName, options?.order);
                             }
+                            else if (type === HookType.ON_START) {
+                                this.hooksManager.registerOnStart(() => proxyCallback({}), pluginName);
+                            }
                             result = true;
                         }
                         else if (method === RPCMethod.ManagerGetPlugin) {
                             const targetName = args[0];
-                            const p = this.getPlugin(targetName);
-                            result = p?.getSharedApi ? p.getSharedApi() : undefined;
+                            // Get the registered API
+                            const api = this.getPluginApi(targetName);
+                            if (api) {
+                                result = api;
+                            }
+                            else {
+                                // Fallback to the plugin itself
+                                const p = this.getPlugin(targetName);
+                                result = api !== undefined ? api : p || undefined;
+                            }
                         }
                         else if (method === RPCMethod.Log) {
                             const level = args[0];
-                            console[level](`[${pluginName}]`, ...args.slice(1));
+                            const [msg, ...restArgs] = args.slice(1);
+                            logger.getLogger(pluginName)[level](msg, ...restArgs);
                             result = true;
                         }
                         else if (method === RPCMethod.PermissionCheck) {
@@ -230,13 +262,27 @@ export class PluginManager extends EventEmitter {
                             const urlStr = typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url;
                             checkPermission(PluginPermission.Network, urlStr);
                             const response = await fetch(input, init);
+                            const responseHeaders = {};
+                            response.headers.forEach((v, k) => { responseHeaders[k] = v; });
                             result = {
                                 status: response.status,
                                 statusText: response.statusText,
-                                headers: Object.fromEntries(response.headers.entries()),
+                                headers: responseHeaders,
                                 body: await response.text()
                             };
                         }
+                        else if (method === RPCMethod.ConfigGet) {
+                            result = this.getPluginConfig(pluginName);
+                        }
+                        else if (method === RPCMethod.StorageReload) {
+                            await storage.reload();
+                            result = true;
+                        }
+                        else if (method === RPCMethod.ManagerRegisterApi) {
+                            const [api] = args;
+                            this.registerApi(pluginName, api);
+                            result = true;
+                        }
                         worker.postMessage({ id, result });
                     }
                     catch (e) {
@@ -263,7 +309,7 @@ export class PluginManager extends EventEmitter {
                 else if (msg.type === WorkerMessageType.MANIFEST) {
                     const { metadata } = msg;
                     pluginMetadata = metadata;
-                    console.log(`Metadata received for isolated plugin: ${metadata.name}`);
+                    logger.getLogger("PluginManager").info(`Metadata received for isolated plugin: ${metadata.name}`);
                 }
                 else if (msg.type === WorkerMessageType.LOAD_SUCCESS) {
                     clearTimeout(timeoutId); // Success, clear global timeout
@@ -286,20 +332,26 @@ export class PluginManager extends EventEmitter {
                             await new Promise(r => setTimeout(r, 200));
                             worker.terminate();
                             // Clear pending hooks on unload
-                            for (const pending of pendingHooks.values()) {
+                            for (const pending of Array.from(pendingHooks.values())) {
                                 pending.reject(new Error("Plugin unloaded"));
                             }
                             pendingHooks.clear();
                         },
                     };
                     this.plugins.set(metadata.name, proxyPlugin);
-                    console.log(`Isolated Plugin ${metadata.name} loaded in worker.`);
+                    // Registrar el path del archivo del plugin aislado
+                    this.pluginFilePaths.set(metadata.name, pluginPath);
+                    // Register API if provided in metadata
+                    if (metadata.api) {
+                        this.registerApi(metadata.name, metadata.api);
+                    }
+                    logger.getLogger("PluginManager").info(`Isolated Plugin ${metadata.name} loaded in worker.`);
                     resolve();
                 }
                 else if (msg.type === WorkerMessageType.LOAD_ERROR) {
                     clearTimeout(timeoutId);
                     // Cleanup pending hooks on load error
-                    for (const pending of pendingHooks.values()) {
+                    for (const pending of Array.from(pendingHooks.values())) {
                         pending.reject(new Error(`Load error: ${msg.error}`));
                     }
                     pendingHooks.clear();
@@ -310,9 +362,9 @@ export class PluginManager extends EventEmitter {
             worker.addEventListener("message", (event) => rpcHandler(event.data));
             worker.addEventListener("error", (err) => {
                 clearTimeout(timeoutId);
-                console.error(`[Isolated:${pluginName}] Worker Error:`, err);
+                logger.getLogger("PluginManager").error(`[Isolated:${pluginName}] Worker Error:`, err);
                 // Reject all pending hooks on crash
-                for (const pending of pendingHooks.values()) {
+                for (const pending of Array.from(pendingHooks.values())) {
                     pending.reject(new Error("Worker terminated unexpectedly"));
                 }
                 pendingHooks.clear();
@@ -320,40 +372,87 @@ export class PluginManager extends EventEmitter {
             });
         });
     }
-    async unregister(pluginName) {
+    async unregister(pluginName, clean = false) {
         const plugin = this.plugins.get(pluginName);
         if (!plugin)
             return;
-        for (const [name, p] of this.plugins.entries()) {
+        for (const [name, p] of Array.from(this.plugins.entries())) {
             if (p.dependencies && p.dependencies[pluginName]) {
-                console.warn(`Warning: Plugin ${name} depends on ${pluginName} which is being unloaded.`);
+                logger.getLogger("PluginManager").warn(`Warning: Plugin ${name} depends on ${pluginName} which is being unloaded.`);
             }
         }
         try {
             await plugin.onUnload();
         }
         catch (error) {
-            console.error(`Error unloading plugin ${pluginName}:`, error);
+            logger.getLogger("PluginManager").error(`Error unloading plugin ${pluginName}:`, error);
         }
         finally {
             this.plugins.delete(pluginName);
             this.resources.cleanup(pluginName, this);
             this.hooksManager.cleanup(pluginName);
-            console.log(`Plugin ${pluginName} unloaded.`);
+            this.unregisterApi(pluginName);
+            if (clean) {
+                this.pluginFilePaths.delete(pluginName);
+            }
+            logger.getLogger("PluginManager").info(`Plugin ${pluginName} unloaded.`);
         }
     }
     getPlugin(name) {
         return this.plugins.get(name);
     }
+    /**
+     * @param pluginName - Plugin name
+     * @returns The absolute path of the plugin file, or undefined if not found
+     */
+    getPluginPath(pluginName) {
+        return this.pluginFilePaths.get(pluginName);
+    }
+    /**
+     * Get all plugin paths
+     * @returns Map with plugin names as keys and their paths as values
+     */
+    getAllPluginPaths() {
+        return new Map(this.pluginFilePaths);
+    }
+    getApi(name) {
+        // Get the registered API
+        return this.getPluginApi(name);
+    }
+    getPluginConfig(name) {
+        return this.configs.get(name) || {};
+    }
+    setPluginConfig(name, config) {
+        this.configs.set(name, config);
+        return this.configs.get(name) || {};
+    }
     listPlugins() {
         return Array.from(this.plugins.keys());
     }
+    // register plugin API
+    registerApi(pluginName, api) {
+        this.pluginApis.set(pluginName, api);
+    }
+    // get plugin API
+    getPluginApi(pluginName) {
+        return this.pluginApis.get(pluginName);
+    }
+    // unregister plugin API
+    unregisterApi(pluginName) {
+        this.pluginApis.delete(pluginName);
+    }
     emit(eventName, ...args) {
         return super.emit(eventName, ...args);
     }
     on(eventName, listener) {
         return super.on(eventName, listener);
     }
+    once(eventName, listener) {
+        return super.once(eventName, listener);
+    }
+    off(eventName, listener) {
+        return super.off(eventName, listener);
+    }
     async loadPluginsFromDirectory(directoryPath = join(process.cwd(), "plugins")) {
         try {
             const globalConfigPath = join(this.storageRoot, "plugins.json");
@@ -366,38 +465,64 @@ export class PluginManager extends EventEmitter {
                 }
             }
             catch (e) {
-                console.warn("Failed to load global plugin config", e);
+                logger.getLogger("PluginManager").warn("Failed to load global plugin config", e);
             }
-            const files = await readdir(directoryPath);
+            const entries = await readdir(directoryPath, { withFileTypes: true });
             this.availablePlugins.clear();
-            for (const file of files) {
-                if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.endsWith(".d.ts")) {
-                    const fullPath = join(directoryPath, file);
+            // Clear the file paths when reloading the directory
+            this.pluginFilePaths.clear();
+            for (const entry of entries) {
+                let fullPath = null;
+                if (entry.isDirectory()) {
+                    const pluginDir = join(directoryPath, entry.name);
+                    const pkgPath = join(pluginDir, "package.json");
+                    if (existsSync(pkgPath)) {
+                        // Auto-install dependencies if node_modules missing
+                        await this.ensureDependenciesInstalled(pluginDir);
+                        fullPath = pluginDir;
+                    }
+                    else {
+                        const distPath = join(pluginDir, "dist");
+                        if (existsSync(distPath)) {
+                            fullPath = distPath;
+                        }
+                    }
+                }
+                else if ((entry.name.endsWith(".ts") || entry.name.endsWith(".js")) && !entry.name.endsWith(".d.ts")) {
+                    fullPath = join(directoryPath, entry.name);
+                }
+                if (fullPath) {
                     try {
-                        const module = await import(fullPath);
+                        // Use cache-busting for hot reload
+                        const query = `?update=${Date.now()}`;
+                        const module = await import(fullPath + query);
                         for (const key in module) {
                             const ExportedItem = module[key];
                             const validation = validatePlugin(ExportedItem);
                             if (validation.valid) {
                                 this.availablePlugins.set(validation.plugin.name, validation.plugin);
+                                // Registrar la ubicación del archivo del plugin
+                                this.pluginFilePaths.set(validation.plugin.name, fullPath);
+                                logger.getLogger("PluginManager").info(`[PluginManager] Plugin file path registered: ${validation.plugin.name} -> ${fullPath}`);
                             }
                             else {
-                                console.warn(`Skipping invalid plugin in ${file}: ${validation.error}`);
+                                const errorMsg = validation.error;
+                                logger.getLogger("PluginManager").warn(`Skipping invalid plugin item in ${entry.name}: ${errorMsg}`);
                             }
                         }
                     }
                     catch (err) {
-                        console.error(`Error importing ${fullPath}:`, err);
+                        logger.getLogger("PluginManager").error(`Error importing ${fullPath}:`, err);
                     }
                 }
             }
             const pluginsToLoad = [];
-            for (const plugin of this.availablePlugins.values()) {
+            for (const plugin of Array.from(this.availablePlugins.values())) {
                 if (!disabledPlugins.includes(plugin.name)) {
                     pluginsToLoad.push(plugin);
                 }
                 else {
-                    console.log(`Plugin ${plugin.name} is disabled.`);
+                    logger.getLogger("PluginManager").info(`Plugin ${plugin.name} is disabled.`);
                 }
             }
             try {
@@ -408,7 +533,7 @@ export class PluginManager extends EventEmitter {
                     if (plugin.dependencies) {
                         for (const dep of Object.keys(plugin.dependencies)) {
                             if (!this.plugins.has(dep)) {
-                                console.warn(`Skipping ${plugin.name}: Dependency ${dep} failed to load or is missing.`);
+                                logger.getLogger("PluginManager").warn(`Skipping ${plugin.name}: Dependency ${dep} failed to load or is missing.`);
                                 dependenciesOk = false;
                                 break;
                             }
@@ -417,13 +542,18 @@ export class PluginManager extends EventEmitter {
                     if (!dependenciesOk)
                         continue;
                     try {
-                        if (!this.plugins.has(plugin.name)) {
+                        if (this.plugins.has(plugin.name)) {
+                            logger.getLogger("PluginManager").info(`Updating plugin: ${plugin.name}`);
+                            await this.reloadPlugin(plugin.name);
+                            loadedPlugins.push(plugin);
+                        }
+                        else {
                             await this.register(plugin);
                             loadedPlugins.push(plugin);
                         }
                     }
                     catch (e) {
-                        console.error(`Failed to load ${plugin.name}:`, e);
+                        logger.getLogger("PluginManager").error(`Failed to load/update ${plugin.name}:`, e);
                     }
                 }
                 for (const plugin of loadedPlugins) {
@@ -432,23 +562,23 @@ export class PluginManager extends EventEmitter {
                             await plugin.onStarted();
                         }
                         catch (e) {
-                            console.error(`Error in onStarted for ${plugin.name}:`, e);
+                            logger.getLogger("PluginManager").error(`Error in onStarted for ${plugin.name}:`, e);
                         }
                     }
                 }
             }
             catch (e) {
-                console.error("Failed to resolve plugin dependencies or load plugins:", e);
+                logger.getLogger("PluginManager").error("Failed to resolve plugin dependencies or load plugins:", e);
             }
         }
         catch (error) {
-            console.error(`Failed to load plugins from ${directoryPath}`, error);
+            logger.getLogger("PluginManager").error(`Failed to load plugins from ${directoryPath}`, error);
         }
     }
     async disablePlugin(name) {
         await this.unregister(name);
         await this.updatePluginState(name, true);
-        console.log(`Plugin ${name} disabled.`);
+        logger.getLogger("PluginManager").info(`Plugin ${name} disabled.`);
     }
     async enablePlugin(name) {
         await this.updatePluginState(name, false);
@@ -458,7 +588,7 @@ export class PluginManager extends EventEmitter {
                 if (plugin.dependencies) {
                     for (const dep of Object.keys(plugin.dependencies)) {
                         if (!this.plugins.has(dep)) {
-                            console.warn(`Cannot enable ${name}: Dependency ${dep} is not loaded.`);
+                            logger.getLogger("PluginManager").warn(`Cannot enable ${name}: Dependency ${dep} is not loaded.`);
                             return;
                         }
                     }
@@ -466,19 +596,33 @@ export class PluginManager extends EventEmitter {
                 await this.register(plugin);
             }
             else {
-                console.warn(`Plugin ${name} enabled but not found in available plugins.`);
+                logger.getLogger("PluginManager").warn(`Plugin ${name} enabled but not found in available plugins.`);
             }
         }
     }
     async reloadPlugin(name) {
-        const plugin = this.plugins.get(name);
-        if (plugin) {
-            console.log(`Reloading plugin ${name}...`);
+        const oldPlugin = this.plugins.get(name);
+        if (oldPlugin) {
+            logger.getLogger("PluginManager").info(`Reloading plugin ${name}...`);
             await this.unregister(name);
         }
         const definition = this.availablePlugins.get(name);
         if (definition) {
             await this.register(definition);
+            const newPlugin = this.plugins.get(name);
+            // If the new version has onReload, call it
+            if (newPlugin && newPlugin.onReload) {
+                // We need a context for onReload as well
+                const storage = JsonPluginStorage.getInstance(this.storageRoot, name);
+                const context = createPluginContext(this, newPlugin, this.resources, storage);
+                try {
+                    await newPlugin.onReload(context);
+                }
+                catch (e) {
+                    logger.getLogger("PluginManager").error(`Error in onReload for ${name}:`, e);
+                }
+            }
+            this.emit("plugin:updated", { name: definition.name, version: definition.version });
         }
         else {
             throw new Error(`Plugin ${name} not found in available plugins.`);
@@ -504,7 +648,7 @@ export class PluginManager extends EventEmitter {
             await Bun.write(globalConfigPath, JSON.stringify(config, null, 2));
         }
         catch (e) {
-            console.error("Failed to update plugin state", e);
+            logger.getLogger("PluginManager").error("Failed to update plugin state", e);
         }
     }
     async runOnResolve(args) {
@@ -513,158 +657,34 @@ export class PluginManager extends EventEmitter {
     async runOnLoad(args) {
         return this.hooksManager.runOnLoad(args);
     }
+    // Bun-like Aliases
+    async use(plugin) { return this.register(plugin); }
+    async plugin(plugin) { return this.register(plugin); }
+    async remove(pluginName) { return this.unregister(pluginName); }
     toBunPlugin() {
         return this.hooksManager.toBunPlugin();
     }
+    hotReloadTimer = null;
     enableHotReload(pluginDir) {
-        // Close existing watcher if any
-        if (this.hotReloadWatcher) {
-            this.hotReloadWatcher.close();
-        }
-        // Initial scan to build file map
-        this.scanAndTrackPlugins(pluginDir);
-        console.log(`[HotReload] Watching ${pluginDir} for changes...`);
-        this.hotReloadWatcher = watch(pluginDir, { recursive: true }, async (event, filename) => {
+        logger.getLogger("PluginManager").info(`[HotReload] Watching ${pluginDir} for changes...`);
+        watch(pluginDir, { recursive: true }, async (event, filename) => {
             if (!filename || (!filename.endsWith(".ts") && !filename.endsWith(".js")))
                 return;
-            if (filename.endsWith(".d.ts"))
-                return; // Skip type definitions
-            const fullPath = join(pluginDir, filename);
             if (this.hotReloadTimer)
                 clearTimeout(this.hotReloadTimer);
             this.hotReloadTimer = setTimeout(async () => {
-                await this.handleFileChange(event, fullPath, filename, pluginDir);
+                logger.getLogger("PluginManager").info(`[HotReload] Change detected in ${filename}. Re-scanning plugins...`);
+                await this.loadPluginsFromDirectory(pluginDir);
             }, 300);
         });
     }
-    async scanAndTrackPlugins(pluginDir) {
-        this.pluginFiles.clear();
-        try {
-            const files = await readdir(pluginDir);
-            for (const file of files) {
-                if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.endsWith(".d.ts")) {
-                    const fullPath = join(pluginDir, file);
-                    try {
-                        const module = await import(fullPath);
-                        for (const key in module) {
-                            const ExportedItem = module[key];
-                            const validation = validatePlugin(ExportedItem);
-                            if (validation.valid) {
-                                this.pluginFiles.set(fullPath, validation.plugin.name);
-                                this.availablePlugins.set(validation.plugin.name, validation.plugin);
-                            }
-                        }
-                    }
-                    catch (err) {
-                        console.warn(`[HotReload] Failed to scan ${file}:`, err);
-                    }
-                }
-            }
-        }
-        catch (err) {
-            console.error(`[HotReload] Failed to scan plugin directory:`, err);
-        }
-    }
-    async handleFileChange(event, fullPath, filename, pluginDir) {
-        const exists = existsSync(fullPath);
-        const previousName = this.pluginFiles.get(fullPath);
-        if (!exists && previousName) {
-            // File was removed - uninstall plugin
-            console.log(`[HotReload] Plugin file removed: ${filename}. Unloading plugin ${previousName}...`);
-            this.pluginFiles.delete(fullPath);
-            if (this.plugins.has(previousName)) {
-                await this.unregister(previousName);
-                console.log(`[HotReload] Plugin ${previousName} unloaded.`);
-            }
-        }
-        else if (exists && !previousName) {
-            // New file added - install plugin
-            console.log(event, `[HotReload] New plugin file detected: ${filename}. Loading plugin...`);
-            try {
-                const module = await import(fullPath);
-                for (const key in module) {
-                    const ExportedItem = module[key];
-                    const validation = validatePlugin(ExportedItem);
-                    if (validation.valid) {
-                        const plugin = validation.plugin;
-                        this.pluginFiles.set(fullPath, plugin.name);
-                        this.availablePlugins.set(plugin.name, plugin);
-                        // Check if not disabled and load it
-                        const globalConfigPath = join(this.storageRoot, "plugins.json");
-                        let disabledPlugins = [];
-                        try {
-                            const file = Bun.file(globalConfigPath);
-                            if (await file.exists()) {
-                                const data = await file.json();
-                                disabledPlugins = data.disabled || [];
-                            }
-                        }
-                        catch (e) { /* ignore */ }
-                        if (!disabledPlugins.includes(plugin.name) && !this.plugins.has(plugin.name)) {
-                            await this.register(plugin);
-                            console.log(`[HotReload] Plugin ${plugin.name} loaded.`);
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                console.error(`[HotReload] Failed to load new plugin ${filename}:`, pluginDir, err);
-            }
-        }
-        else if (exists && previousName) {
-            // File was modified - reload plugin
-            console.log(`[HotReload] Plugin file modified: ${filename}. Reloading plugin ${previousName}...`);
-            try {
-                // Remove from module cache to force reimport
-                delete require.cache[fullPath];
-                // Unload existing plugin
-                if (this.plugins.has(previousName)) {
-                    await this.unregister(previousName);
-                }
-                // Reload the plugin
-                const module = await import(fullPath);
-                for (const key in module) {
-                    const ExportedItem = module[key];
-                    const validation = validatePlugin(ExportedItem);
-                    if (validation.valid) {
-                        const plugin = validation.plugin;
-                        this.availablePlugins.set(plugin.name, plugin);
-                        // Check if not disabled and load it
-                        const globalConfigPath = join(this.storageRoot, "plugins.json");
-                        let disabledPlugins = [];
-                        try {
-                            const file = Bun.file(globalConfigPath);
-                            if (await file.exists()) {
-                                const data = await file.json();
-                                disabledPlugins = data.disabled || [];
-                            }
-                        }
-                        catch (e) { /* ignore */ }
-                        if (!disabledPlugins.includes(plugin.name)) {
-                            await this.register(plugin);
-                            console.log(`[HotReload] Plugin ${plugin.name} reloaded.`);
-                        }
-                    }
-                }
-            }
-            catch (err) {
-                console.error(`[HotReload] Failed to reload plugin ${filename}:`, err);
-            }
-        }
-    }
-    disableHotReload() {
-        if (this.hotReloadWatcher) {
-            this.hotReloadWatcher.close();
-            this.hotReloadWatcher = null;
-            console.log(`[HotReload] File watcher stopped.`);
-        }
-    }
     getMetrics() {
         return {
             totalPlugins: this.plugins.size,
             activePlugins: Array.from(this.plugins.keys()),
             resources: this.resources.getUsageSummary(),
             hooks: {
+                onStart: this.hooksManager.getHookCount(HookType.ON_START),
                 onResolve: this.hooksManager.getHookCount(HookType.ON_RESOLVE),
                 onLoad: this.hooksManager.getHookCount(HookType.ON_LOAD)
             }
@@ -672,7 +692,7 @@ export class PluginManager extends EventEmitter {
     }
     getPluginStatus() {
         const status = {};
-        for (const [name, plugin] of this.plugins) {
+        for (const [name, plugin] of Array.from(this.plugins)) {
             const resources = this.resources.get(name);
             status[name] = {
                 version: plugin.version,
@@ -686,5 +706,37 @@ export class PluginManager extends EventEmitter {
         }
         return status;
     }
+    async ensureDependenciesInstalled(pluginPath) {
+        const nodeModulesPath = join(pluginPath, "node_modules");
+        if (!existsSync(nodeModulesPath)) {
+            // 1. Check if we are in production
+            const isProduction = process.env.NODE_ENV === "production";
+            if (isProduction) {
+                logger.getLogger("PluginManager").warn(`[PluginManager] Warning: Plugin at ${pluginPath} is missing node_modules. Auto-install is disabled in production.`);
+                return;
+            }
+            // 2. Check if 'bun' CLI is even available in the system
+            const bunPath = Bun.which("bun");
+            if (!bunPath) {
+                logger.getLogger("PluginManager").warn(`[PluginManager] Warning: node_modules missing in ${pluginPath}, but 'bun' CLI was not found. Cannot auto-install.`);
+                return;
+            }
+            logger.getLogger("PluginManager").info(`[PluginManager] Development mode detected. node_modules missing in ${pluginPath}. Installing deps...`);
+            try {
+                const proc = Bun.spawn([bunPath, "install"], {
+                    cwd: pluginPath,
+                    stdout: "inherit",
+                    stderr: "inherit",
+                });
+                const exitCode = await proc.exited;
+                if (exitCode !== 0) {
+                    logger.getLogger("PluginManager").error(`[PluginManager] Failed to install dependencies for ${pluginPath}. Exit code: ${exitCode}`);
+                }
+            }
+            catch (e) {
+                logger.getLogger("PluginManager").error(`[PluginManager] Error running bun install for ${pluginPath}:`, e);
+            }
+        }
+    }
 }
 //# sourceMappingURL=PluginManager.js.map