dank-ai 1.0.39 → 1.0.42

package/lib/plugins/manager.js

@@ -0,0 +1,258 @@
+/**
+ * Plugin Manager - Integrates plugins with DankAgent
+ * 
+ * Manages plugin lifecycle, integrates plugin handlers and tools with agents,
+ * handles plugin-to-plugin communication, and manages plugin state persistence.
+ */
+
+const { PluginRegistry } = require('./registry');
+const { PluginEventSystem } = require('./events');
+
+class PluginManager {
+  constructor(agent) {
+    this.agent = agent;
+    this.registry = new PluginRegistry();
+    this.plugins = new Map(); // name -> plugin instance
+    this.eventRouter = PluginEventSystem.createEventRouter();
+    this.isInitialized = false;
+  }
+
+  /**
+   * Add a plugin to the agent
+   */
+  async addPlugin(name, config = {}) {
+    // If name is a string, try to load from npm or local path
+    if (typeof name === 'string') {
+      // Check if it's already loaded
+      if (this.plugins.has(name)) {
+        throw new Error(`Plugin '${name}' is already loaded`);
+      }
+
+      // Try to load from npm first (if it looks like a package name)
+      if (name.startsWith('dank-plugin-') || name.includes('/')) {
+        try {
+          const { name: pluginName, PluginClass } = await this.registry.loadFromNpm(name);
+          const plugin = await this.registry.create(pluginName, config);
+          return await this._registerPlugin(pluginName, plugin);
+        } catch (error) {
+          // If npm load fails, try as local path
+          if (name.includes('/') || name.endsWith('.js')) {
+            const { name: pluginName, PluginClass } = await this.registry.loadFromPath(name, { name });
+            const plugin = await this.registry.create(pluginName, config);
+            return await this._registerPlugin(pluginName, plugin);
+          }
+          throw error;
+        }
+      } else {
+        // Assume it's a registered plugin name
+        const plugin = await this.registry.create(name, config);
+        return await this._registerPlugin(name, plugin);
+      }
+    } else {
+      // name is a PluginBase instance
+      const plugin = name;
+      const pluginName = plugin.name;
+      
+      if (this.plugins.has(pluginName)) {
+        throw new Error(`Plugin '${pluginName}' is already loaded`);
+      }
+
+      return await this._registerPlugin(pluginName, plugin);
+    }
+  }
+
+  /**
+   * Register a plugin instance
+   */
+  async _registerPlugin(name, plugin) {
+    // Set agent context
+    plugin.setAgentContext({
+      agent: this.agent,
+      agentId: this.agent.id,
+      agentName: this.agent.name,
+      toolRegistry: this.agent.toolRegistry,
+      toolExecutor: this.agent.toolExecutor
+    });
+
+    // Set plugin manager reference
+    plugin.setPluginManager(this);
+
+    // Register plugin tools with agent
+    const tools = plugin.getTools();
+    for (const tool of tools) {
+      this.agent.toolRegistry.register(tool.name, {
+        description: tool.description || `Tool from plugin '${name}'`,
+        parameters: tool.parameters || {},
+        handler: tool.handler,
+        category: tool.category || 'plugin',
+        version: tool.version || '1.0.0',
+        timeout: tool.timeout || 30000,
+        retries: tool.retries || 1,
+        async: tool.async !== false,
+        cacheable: tool.cacheable || false,
+        cacheTime: tool.cacheTime || 0,
+        metadata: {
+          ...tool.metadata,
+          plugin: name
+        }
+      });
+    }
+
+    // Register plugin handlers with agent
+    for (const [eventType, handlers] of plugin.handlers) {
+      for (const handlerObj of handlers) {
+        this.agent.addHandler(eventType, handlerObj.handler);
+      }
+    }
+
+    // Set up event routing
+    this.eventRouter.route(`plugin:${name}:*`, this.agent);
+    this.eventRouter.route(`plugin:${name}:*`, plugin);
+
+    // Store plugin
+    this.plugins.set(name, plugin);
+
+    // Don't start plugin here - it will be started at runtime
+    // Starting plugins during build would try to connect to databases/services
+    // which is not available during Docker build
+    // Plugins will be started when the agent container starts
+
+    return plugin;
+  }
+
+  /**
+   * Add multiple plugins
+   */
+  async addPlugins(plugins) {
+    // Resolve dependencies first
+    const pluginNames = Object.keys(plugins);
+    const resolved = this.registry.resolveDependencies(pluginNames);
+
+    // Load plugins in dependency order
+    for (const name of resolved) {
+      await this.addPlugin(name, plugins[name]);
+    }
+
+    return this;
+  }
+
+  /**
+   * Get a plugin by name
+   */
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+
+  /**
+   * Get all plugins
+   */
+  getAllPlugins() {
+    return Array.from(this.plugins.values());
+  }
+
+  /**
+   * Check if plugin is loaded
+   */
+  hasPlugin(name) {
+    return this.plugins.has(name);
+  }
+
+  /**
+   * Remove a plugin
+   */
+  async removePlugin(name) {
+    const plugin = this.plugins.get(name);
+    
+    if (!plugin) {
+      return this;
+    }
+
+    // Stop plugin
+    await plugin.stop();
+
+    // Remove plugin tools from agent
+    const tools = plugin.getTools();
+    for (const tool of tools) {
+      // Note: ToolRegistry doesn't have an unregister method yet
+      // This would need to be added if we want to fully remove tools
+    }
+
+    // Remove event routes
+    this.eventRouter.unroute(`plugin:${name}:*`, this.agent);
+    this.eventRouter.unroute(`plugin:${name}:*`, plugin);
+
+    // Remove from registry
+    await this.registry.unload(name);
+
+    // Remove from plugins map
+    this.plugins.delete(name);
+
+    return this;
+  }
+
+  /**
+   * Remove all plugins
+   */
+  async removeAllPlugins() {
+    const names = Array.from(this.plugins.keys());
+    for (const name of names) {
+      await this.removePlugin(name);
+    }
+    return this;
+  }
+
+  /**
+   * Start all plugins
+   * This should be called at runtime when the agent container starts
+   */
+  async startAll() {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.status === 'initialized' || plugin.status === 'stopped') {
+        await plugin.start();
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Stop all plugins
+   */
+  async stopAll() {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.status !== 'stopped') {
+        await plugin.stop();
+      }
+    }
+    return this;
+  }
+
+  /**
+   * Get plugin manager metadata
+   */
+  getMetadata() {
+    return {
+      plugins: Array.from(this.plugins.values()).map(p => p.getMetadata()),
+      registry: this.registry.getMetadata(),
+      eventRoutes: this.eventRouter.getRoutes()
+    };
+  }
+
+  /**
+   * Emit event to all plugins
+   */
+  emitToPlugins(eventName, data) {
+    for (const plugin of this.plugins.values()) {
+      plugin.emit(eventName, data);
+    }
+  }
+
+  /**
+   * Route event through event router
+   */
+  routeEvent(eventName, data) {
+    this.eventRouter.emit(eventName, data);
+  }
+}
+
+module.exports = { PluginManager };
+

package/lib/plugins/registry.js

@@ -0,0 +1,268 @@
+/**
+ * Plugin Registry - Discovery, loading, and lifecycle management
+ * 
+ * Manages plugin discovery, loading from npm packages or local paths,
+ * validates plugin schemas, and tracks plugin dependencies.
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { PluginBase } = require('./base');
+const { PluginConfig } = require('./config');
+
+class PluginRegistry {
+  constructor() {
+    this.plugins = new Map(); // name -> plugin instance
+    this.pluginClasses = new Map(); // name -> Plugin class
+    this.loadedPaths = new Map(); // name -> path
+    this.dependencies = new Map(); // name -> [dependencies]
+  }
+
+  /**
+   * Register a plugin class
+   */
+  register(name, PluginClass, options = {}) {
+    if (!name || typeof name !== 'string') {
+      throw new Error('Plugin name must be a non-empty string');
+    }
+
+    if (!PluginClass || !(PluginClass.prototype instanceof PluginBase)) {
+      throw new Error(`Plugin '${name}' must extend PluginBase`);
+    }
+
+    this.pluginClasses.set(name, PluginClass);
+    
+    if (options.dependencies) {
+      this.dependencies.set(name, options.dependencies);
+    }
+
+    return this;
+  }
+
+  /**
+   * Load plugin from npm package
+   */
+  async loadFromNpm(packageName, config = {}) {
+    try {
+      // Try to require the package
+      let PluginClass;
+      try {
+        const pluginModule = require(packageName);
+        PluginClass = pluginModule.default || pluginModule;
+      } catch (error) {
+        // If not installed, try to install it
+        if (error.code === 'MODULE_NOT_FOUND') {
+          throw new Error(
+            `Plugin package '${packageName}' not found. ` +
+            `Install it with: npm install ${packageName}`
+          );
+        }
+        throw error;
+      }
+
+      // Validate it's a PluginBase subclass
+      if (!PluginClass || !(PluginClass.prototype instanceof PluginBase)) {
+        throw new Error(
+          `Package '${packageName}' does not export a PluginBase subclass`
+        );
+      }
+
+      // Extract plugin name from package or use package name
+      const pluginName = PluginClass.name || packageName.replace(/^dank-plugin-/, '');
+      
+      this.pluginClasses.set(pluginName, PluginClass);
+      this.loadedPaths.set(pluginName, `npm:${packageName}`);
+
+      return { name: pluginName, PluginClass };
+    } catch (error) {
+      throw new Error(`Failed to load plugin from npm package '${packageName}': ${error.message}`);
+    }
+  }
+
+  /**
+   * Load plugin from local file path
+   */
+  async loadFromPath(filePath, config = {}) {
+    try {
+      const resolvedPath = path.resolve(filePath);
+      
+      if (!(await fs.pathExists(resolvedPath))) {
+        throw new Error(`Plugin file not found: ${resolvedPath}`);
+      }
+
+      // Clear require cache for this file
+      delete require.cache[require.resolve(resolvedPath)];
+
+      const pluginModule = require(resolvedPath);
+      const PluginClass = pluginModule.default || pluginModule;
+
+      if (!PluginClass || !(PluginClass.prototype instanceof PluginBase)) {
+        throw new Error(
+          `File '${resolvedPath}' does not export a PluginBase subclass`
+        );
+      }
+
+      const pluginName = config.name || PluginClass.name || path.basename(resolvedPath, '.js');
+      
+      this.pluginClasses.set(pluginName, PluginClass);
+      this.loadedPaths.set(pluginName, resolvedPath);
+
+      return { name: pluginName, PluginClass };
+    } catch (error) {
+      throw new Error(`Failed to load plugin from path '${filePath}': ${error.message}`);
+    }
+  }
+
+  /**
+   * Create plugin instance
+   */
+  async create(name, config = {}) {
+    const PluginClass = this.pluginClasses.get(name);
+    
+    if (!PluginClass) {
+      throw new Error(`Plugin '${name}' not registered. Load it first with loadFromNpm() or loadFromPath()`);
+    }
+
+    // Inject environment variables into config
+    const injectedConfig = PluginConfig.injectEnvVars(config);
+
+    // Create plugin instance
+    const plugin = new PluginClass(injectedConfig);
+
+    // Validate plugin config if plugin has validateConfig method
+    if (typeof plugin.validateConfig === 'function') {
+      plugin.validateConfig(injectedConfig);
+    }
+
+    // Initialize plugin
+    await plugin.init();
+
+    this.plugins.set(name, plugin);
+
+    return plugin;
+  }
+
+  /**
+   * Get plugin instance
+   */
+  get(name) {
+    return this.plugins.get(name);
+  }
+
+  /**
+   * Get all plugin instances
+   */
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+
+  /**
+   * Check if plugin is registered
+   */
+  has(name) {
+    return this.pluginClasses.has(name);
+  }
+
+  /**
+   * Check if plugin is loaded (has instance)
+   */
+  isLoaded(name) {
+    return this.plugins.has(name);
+  }
+
+  /**
+   * Get plugin class
+   */
+  getClass(name) {
+    return this.pluginClasses.get(name);
+  }
+
+  /**
+   * Get plugin dependencies
+   */
+  getDependencies(name) {
+    return this.dependencies.get(name) || [];
+  }
+
+  /**
+   * Resolve plugin dependencies (topological sort)
+   */
+  resolveDependencies(pluginNames) {
+    const resolved = [];
+    const visited = new Set();
+    const visiting = new Set();
+
+    const visit = (name) => {
+      if (visiting.has(name)) {
+        throw new Error(`Circular dependency detected involving plugin '${name}'`);
+      }
+      
+      if (visited.has(name)) {
+        return;
+      }
+
+      visiting.add(name);
+      
+      const deps = this.getDependencies(name);
+      for (const dep of deps) {
+        if (!this.has(dep)) {
+          throw new Error(`Plugin '${name}' depends on '${dep}' which is not registered`);
+        }
+        visit(dep);
+      }
+
+      visiting.delete(name);
+      visited.add(name);
+      resolved.push(name);
+    };
+
+    for (const name of pluginNames) {
+      visit(name);
+    }
+
+    return resolved;
+  }
+
+  /**
+   * Unload plugin
+   */
+  async unload(name) {
+    const plugin = this.plugins.get(name);
+    
+    if (plugin) {
+      await plugin.destroy();
+      this.plugins.delete(name);
+    }
+
+    return this;
+  }
+
+  /**
+   * Unload all plugins
+   */
+  async unloadAll() {
+    const names = Array.from(this.plugins.keys());
+    for (const name of names) {
+      await this.unload(name);
+    }
+    return this;
+  }
+
+  /**
+   * Get registry metadata
+   */
+  getMetadata() {
+    return {
+      registered: Array.from(this.pluginClasses.keys()),
+      loaded: Array.from(this.plugins.keys()).map(name => ({
+        name,
+        status: this.plugins.get(name).status,
+        path: this.loadedPaths.get(name)
+      })),
+      dependencies: Object.fromEntries(this.dependencies)
+    };
+  }
+}
+
+module.exports = { PluginRegistry };
+

package/lib/project.js

@@ -66,6 +66,9 @@ class DankProject {
  * This file defines your AI agents and their configurations.
  * Run 'dank run' to start all defined agents.
  * 
+ * NPM PACKAGES: You can import any npm package at the top of this file
+ * and use it in your handlers. Just make sure packages are in your package.json.
+ * 
  * IMPORTANT: Agent IDs (UUIDv4)
  * ==============================
  * Each agent has a unique UUIDv4 identifier that is generated when you initialize
@@ -76,6 +79,10 @@ class DankProject {
  *   locked in and owned by your account
  */
 
+// Import npm packages - these will be available in your handlers
+const axios = require('axios');
+const { format } = require('date-fns');
+
 const { createAgent } = require('${requirePath}');
 
 // Agent IDs - Generated UUIDv4 identifiers for each agent
@@ -119,17 +126,17 @@ module.exports = {
           prompt: enhancedPrompt
         };
       })
-      .addHandler('request_output', (data) => {
-        console.log('[Prompt Agent] LLM Response:', {
+      .addHandler('request_output', async (data) => {
+        // Example: Using imported packages in handlers
+        const timestamp = format(new Date(), 'yyyy-MM-dd HH:mm:ss');
+        console.log(\`[\${timestamp}] LLM Response:\`, {
           prompt: data.prompt,
-          finalPrompt: data.finalPrompt,
-          promptModified: data.promptModified,
           response: data.response,
-          conversationId: data.conversationId,
-          processingTime: data.processingTime,
-          usage: data.usage,
-          model: data.model
+          processingTime: data.processingTime
         });
+        
+        // Example: Make HTTP requests with axios (uncomment to use)
+        // await axios.post('https://your-api.com/log', { response: data.response });
       })
       .addHandler('request_output:end', (data) => {
         console.log('[Prompt Agent] Completed in:', data.processingTime + 'ms');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dank-ai",
-  "version": "1.0.39",
+  "version": "1.0.42",
   "description": "Dank Agent Service - Docker-based AI agent orchestration platform",
   "main": "lib/index.js",
   "exports": {