bun_plugins 1.2.5 → 1.2.6

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

@@ -1,23 +1,21 @@
 import { EventEmitter } from "node:events";
 import { readdir, mkdir } from "node:fs/promises";
-import { join } from "node:path";
+import { join, dirname } 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 * as semver from "semver";
+import 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();
-    configs = new Map();
-    pluginApis = new Map();
+    pluginFiles = new Map(); // filePath -> pluginName
     // Modules
     resources;
     dependencyManager;
@@ -27,6 +25,8 @@ export class PluginManager extends EventEmitter {
     pluginLoadTimeout;
     workerFactory;
     workerRunnerPath;
+    hotReloadWatcher = null;
+    hotReloadTimer = null;
     constructor(storageRoot = join(process.cwd(), "storage"), options) {
         super();
         this.storageRoot = storageRoot;
@@ -62,7 +62,7 @@ export class PluginManager extends EventEmitter {
                 throw new Error(`Plugin ${plugin.name} requires host version ${plugin.engines.host}, but found ${this.hostVersion}`);
             }
         }
-        logger.getLogger("PluginManager").info(`Loading plugin: ${plugin.name} v${plugin.version}`);
+        console.log(`Loading plugin: ${plugin.name} v${plugin.version}`);
         // 1. Prepare Storage
         const storage = new JsonPluginStorage(this.storageRoot, plugin.name);
         // 2. Load & Validate Configuration
@@ -73,7 +73,8 @@ export class PluginManager extends EventEmitter {
             }
             catch (e) {
                 const error = errorParser(e, `Error in plugin ${plugin.name}`);
-                logger.getLogger("PluginManager").warn(`[SafeMode] Using default config, validation failed. Error: ${error.message}`);
+                console.warn(`[SafeMode] Using default config, validation failed. Error: ${error.message}`);
+                config = {}; // Reset to empty config on validation failure to prevent downstream errors
             }
         }
         // 3. Initialize Resources
@@ -83,57 +84,37 @@ export class PluginManager extends EventEmitter {
             throw new Error(`Invalid plugin name: ${plugin.name}. Name cannot contain path traversal characters.`);
         }
         // 4. Context Creation
-        this.configs.set(plugin.name, config);
-        const context = createPluginContext(this, plugin, this.resources, storage);
+        const context = createPluginContext(this, plugin, this.resources, storage, config);
         // 5. Setup Hooks with Performance Monitoring (Delegated to HooksManager via Builder)
         if (plugin.setup) {
             try {
-                await plugin.setup(this.hooksManager.getBuilder(plugin.name, config));
+                await plugin.setup(this.hooksManager.getBuilder(plugin.name));
             }
             catch (e) {
-                logger.getLogger("PluginManager").error(`Error during setup for ${plugin.name}:`, e);
+                console.error(`Error during setup for ${plugin.name}:`, e);
                 throw errorParser(e, `Error during setup for ${plugin.name}`);
             }
         }
         // 6. Lifecycle onLoad
         try {
-            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 timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Plugin ${plugin.name} timed out (${this.pluginLoadTimeout}ms)`)), this.pluginLoadTimeout));
             const start = performance.now();
-            try {
-                await plugin.onLoad(context);
-            }
-            finally {
-                completed = true;
-                clearTimeout(timeoutId);
-            }
-            // Check if timeout triggered
-            if (timeoutError) {
-                throw timeoutError;
-            }
+            await Promise.race([plugin.onLoad(context), timeoutPromise]);
             const duration = performance.now() - start;
             this.plugins.set(plugin.name, plugin);
-            logger.getLogger("PluginManager").info(`Plugin ${plugin.name} loaded successfully in ${duration.toFixed(2)}ms.`);
+            console.log(`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) {
-                    logger.getLogger("PluginManager").error(`Error in onStarted for ${plugin.name}:`, e);
+                    console.error(`Error in onStarted for ${plugin.name}:`, e);
                 }
             }
-            // 7. Trigger onStart hooks registered via setup()
-            await this.hooksManager.runOnStart();
         }
         catch (error) {
-            logger.getLogger("PluginManager").error(`Failed to load plugin ${plugin.name}:`, error);
+            console.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);
@@ -143,7 +124,7 @@ export class PluginManager extends EventEmitter {
     async registerIsolated(pluginPath, pluginName) {
         return new Promise((resolve, reject) => {
             const workerScript = this.workerRunnerPath;
-            logger.getLogger("PluginManager").info("Worker Path:", workerScript);
+            console.log("Worker Path:", workerScript);
             const timeoutId = setTimeout(() => {
                 worker.terminate();
                 reject(new Error(`Isolated plugin ${pluginName} timed out during loading (${this.pluginLoadTimeout}ms)`));
@@ -224,28 +205,16 @@ 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];
-                            // 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;
-                            }
+                            const p = this.getPlugin(targetName);
+                            result = p?.getSharedApi ? p.getSharedApi() : undefined;
                         }
                         else if (method === RPCMethod.Log) {
                             const level = args[0];
-                            const [msg, ...restArgs] = args.slice(1);
-                            logger.getLogger(pluginName)[level](msg, ...restArgs);
+                            console[level](`[${pluginName}]`, ...args.slice(1));
                             result = true;
                         }
                         else if (method === RPCMethod.PermissionCheck) {
@@ -261,27 +230,13 @@ 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: responseHeaders,
+                                headers: Object.fromEntries(response.headers.entries()),
                                 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) {
@@ -308,7 +263,7 @@ export class PluginManager extends EventEmitter {
                 else if (msg.type === WorkerMessageType.MANIFEST) {
                     const { metadata } = msg;
                     pluginMetadata = metadata;
-                    logger.getLogger("PluginManager").info(`Metadata received for isolated plugin: ${metadata.name}`);
+                    console.log(`Metadata received for isolated plugin: ${metadata.name}`);
                 }
                 else if (msg.type === WorkerMessageType.LOAD_SUCCESS) {
                     clearTimeout(timeoutId); // Success, clear global timeout
@@ -331,24 +286,20 @@ export class PluginManager extends EventEmitter {
                             await new Promise(r => setTimeout(r, 200));
                             worker.terminate();
                             // Clear pending hooks on unload
-                            for (const pending of Array.from(pendingHooks.values())) {
+                            for (const pending of pendingHooks.values()) {
                                 pending.reject(new Error("Plugin unloaded"));
                             }
                             pendingHooks.clear();
                         },
                     };
                     this.plugins.set(metadata.name, proxyPlugin);
-                    // 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.`);
+                    console.log(`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 Array.from(pendingHooks.values())) {
+                    for (const pending of pendingHooks.values()) {
                         pending.reject(new Error(`Load error: ${msg.error}`));
                     }
                     pendingHooks.clear();
@@ -359,9 +310,9 @@ export class PluginManager extends EventEmitter {
             worker.addEventListener("message", (event) => rpcHandler(event.data));
             worker.addEventListener("error", (err) => {
                 clearTimeout(timeoutId);
-                logger.getLogger("PluginManager").error(`[Isolated:${pluginName}] Worker Error:`, err);
+                console.error(`[Isolated:${pluginName}] Worker Error:`, err);
                 // Reject all pending hooks on crash
-                for (const pending of Array.from(pendingHooks.values())) {
+                for (const pending of pendingHooks.values()) {
                     pending.reject(new Error("Worker terminated unexpectedly"));
                 }
                 pendingHooks.clear();
@@ -373,62 +324,36 @@ export class PluginManager extends EventEmitter {
         const plugin = this.plugins.get(pluginName);
         if (!plugin)
             return;
-        for (const [name, p] of Array.from(this.plugins.entries())) {
+        for (const [name, p] of this.plugins.entries()) {
             if (p.dependencies && p.dependencies[pluginName]) {
-                logger.getLogger("PluginManager").warn(`Warning: Plugin ${name} depends on ${pluginName} which is being unloaded.`);
+                console.warn(`Warning: Plugin ${name} depends on ${pluginName} which is being unloaded.`);
             }
         }
         try {
             await plugin.onUnload();
         }
         catch (error) {
-            logger.getLogger("PluginManager").error(`Error unloading plugin ${pluginName}:`, error);
+            console.error(`Error unloading plugin ${pluginName}:`, error);
         }
         finally {
             this.plugins.delete(pluginName);
             this.resources.cleanup(pluginName, this);
             this.hooksManager.cleanup(pluginName);
-            this.unregisterApi(pluginName);
-            logger.getLogger("PluginManager").info(`Plugin ${pluginName} unloaded.`);
+            console.log(`Plugin ${pluginName} unloaded.`);
         }
     }
     getPlugin(name) {
         return this.plugins.get(name);
     }
-    getApi(name) {
-        // Get the registered API
-        return this.getPluginApi(name);
-    }
-    getPluginConfig(name) {
-        return this.configs.get(name) || {};
-    }
     listPlugins() {
         return Array.from(this.plugins.keys());
     }
-    // Método para registrar manualmente la API de un plugin
-    registerApi(pluginName, api) {
-        this.pluginApis.set(pluginName, api);
-    }
-    // Método para obtener la API de un plugin
-    getPluginApi(pluginName) {
-        return this.pluginApis.get(pluginName);
-    }
-    // Método para limpiar la API de un plugin al desregistrarlo
-    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");
@@ -441,35 +366,15 @@ export class PluginManager extends EventEmitter {
                 }
             }
             catch (e) {
-                logger.getLogger("PluginManager").warn("Failed to load global plugin config", e);
+                console.warn("Failed to load global plugin config", e);
             }
-            const entries = await readdir(directoryPath, { withFileTypes: true });
+            const files = await readdir(directoryPath);
             this.availablePlugins.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) {
+            for (const file of files) {
+                if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.endsWith(".d.ts")) {
+                    const fullPath = join(directoryPath, file);
                     try {
-                        // Use cache-busting for hot reload
-                        const query = `?update=${Date.now()}`;
-                        const module = await import(fullPath + query);
+                        const module = await import(fullPath);
                         for (const key in module) {
                             const ExportedItem = module[key];
                             const validation = validatePlugin(ExportedItem);
@@ -477,23 +382,22 @@ export class PluginManager extends EventEmitter {
                                 this.availablePlugins.set(validation.plugin.name, validation.plugin);
                             }
                             else {
-                                const errorMsg = validation.error;
-                                logger.getLogger("PluginManager").warn(`Skipping invalid plugin item in ${entry.name}: ${errorMsg}`);
+                                console.warn(`Skipping invalid plugin in ${file}: ${validation.error}`);
                             }
                         }
                     }
                     catch (err) {
-                        logger.getLogger("PluginManager").error(`Error importing ${fullPath}:`, err);
+                        console.error(`Error importing ${fullPath}:`, err);
                     }
                 }
             }
             const pluginsToLoad = [];
-            for (const plugin of Array.from(this.availablePlugins.values())) {
+            for (const plugin of this.availablePlugins.values()) {
                 if (!disabledPlugins.includes(plugin.name)) {
                     pluginsToLoad.push(plugin);
                 }
                 else {
-                    logger.getLogger("PluginManager").info(`Plugin ${plugin.name} is disabled.`);
+                    console.log(`Plugin ${plugin.name} is disabled.`);
                 }
             }
             try {
@@ -504,7 +408,7 @@ export class PluginManager extends EventEmitter {
                     if (plugin.dependencies) {
                         for (const dep of Object.keys(plugin.dependencies)) {
                             if (!this.plugins.has(dep)) {
-                                logger.getLogger("PluginManager").warn(`Skipping ${plugin.name}: Dependency ${dep} failed to load or is missing.`);
+                                console.warn(`Skipping ${plugin.name}: Dependency ${dep} failed to load or is missing.`);
                                 dependenciesOk = false;
                                 break;
                             }
@@ -513,18 +417,13 @@ export class PluginManager extends EventEmitter {
                     if (!dependenciesOk)
                         continue;
                     try {
-                        if (this.plugins.has(plugin.name)) {
-                            logger.getLogger("PluginManager").info(`Updating plugin: ${plugin.name}`);
-                            await this.reloadPlugin(plugin.name);
-                            loadedPlugins.push(plugin);
-                        }
-                        else {
+                        if (!this.plugins.has(plugin.name)) {
                             await this.register(plugin);
                             loadedPlugins.push(plugin);
                         }
                     }
                     catch (e) {
-                        logger.getLogger("PluginManager").error(`Failed to load/update ${plugin.name}:`, e);
+                        console.error(`Failed to load ${plugin.name}:`, e);
                     }
                 }
                 for (const plugin of loadedPlugins) {
@@ -533,23 +432,23 @@ export class PluginManager extends EventEmitter {
                             await plugin.onStarted();
                         }
                         catch (e) {
-                            logger.getLogger("PluginManager").error(`Error in onStarted for ${plugin.name}:`, e);
+                            console.error(`Error in onStarted for ${plugin.name}:`, e);
                         }
                     }
                 }
             }
             catch (e) {
-                logger.getLogger("PluginManager").error("Failed to resolve plugin dependencies or load plugins:", e);
+                console.error("Failed to resolve plugin dependencies or load plugins:", e);
             }
         }
         catch (error) {
-            logger.getLogger("PluginManager").error(`Failed to load plugins from ${directoryPath}`, error);
+            console.error(`Failed to load plugins from ${directoryPath}`, error);
         }
     }
     async disablePlugin(name) {
         await this.unregister(name);
         await this.updatePluginState(name, true);
-        logger.getLogger("PluginManager").info(`Plugin ${name} disabled.`);
+        console.log(`Plugin ${name} disabled.`);
     }
     async enablePlugin(name) {
         await this.updatePluginState(name, false);
@@ -559,7 +458,7 @@ export class PluginManager extends EventEmitter {
                 if (plugin.dependencies) {
                     for (const dep of Object.keys(plugin.dependencies)) {
                         if (!this.plugins.has(dep)) {
-                            logger.getLogger("PluginManager").warn(`Cannot enable ${name}: Dependency ${dep} is not loaded.`);
+                            console.warn(`Cannot enable ${name}: Dependency ${dep} is not loaded.`);
                             return;
                         }
                     }
@@ -567,33 +466,19 @@ export class PluginManager extends EventEmitter {
                 await this.register(plugin);
             }
             else {
-                logger.getLogger("PluginManager").warn(`Plugin ${name} enabled but not found in available plugins.`);
+                console.warn(`Plugin ${name} enabled but not found in available plugins.`);
             }
         }
     }
     async reloadPlugin(name) {
-        const oldPlugin = this.plugins.get(name);
-        if (oldPlugin) {
-            logger.getLogger("PluginManager").info(`Reloading plugin ${name}...`);
+        const plugin = this.plugins.get(name);
+        if (plugin) {
+            console.log(`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 = new JsonPluginStorage(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.`);
@@ -619,7 +504,7 @@ export class PluginManager extends EventEmitter {
             await Bun.write(globalConfigPath, JSON.stringify(config, null, 2));
         }
         catch (e) {
-            logger.getLogger("PluginManager").error("Failed to update plugin state", e);
+            console.error("Failed to update plugin state", e);
         }
     }
     async runOnResolve(args) {
@@ -628,34 +513,158 @@ 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) {
-        logger.getLogger("PluginManager").info(`[HotReload] Watching ${pluginDir} for changes...`);
-        watch(pluginDir, { recursive: true }, async (event, filename) => {
+        // 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) => {
             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 () => {
-                logger.getLogger("PluginManager").info(`[HotReload] Change detected in ${filename}. Re-scanning plugins...`);
-                await this.loadPluginsFromDirectory(pluginDir);
+                await this.handleFileChange(event, fullPath, filename, 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)
             }
@@ -663,7 +672,7 @@ export class PluginManager extends EventEmitter {
     }
     getPluginStatus() {
         const status = {};
-        for (const [name, plugin] of Array.from(this.plugins)) {
+        for (const [name, plugin] of this.plugins) {
             const resources = this.resources.get(name);
             status[name] = {
                 version: plugin.version,
@@ -677,37 +686,5 @@ 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