dank-ai 1.0.41 → 1.0.45

package/lib/plugins/config.js

@@ -0,0 +1,171 @@
+/**
+ * Plugin Configuration - Schema validation and management
+ * 
+ * Provides Joi-based schema validation for plugin configurations,
+ * environment variable injection, and secret management.
+ */
+
+const Joi = require('joi');
+
+class PluginConfig {
+  /**
+   * Validate plugin configuration against schema
+   */
+  static validate(name, config, schema) {
+    if (!schema) {
+      // No schema provided, just return config as-is
+      return config;
+    }
+
+    const { error, value } = schema.validate(config, {
+      stripUnknown: true,
+      abortEarly: false
+    });
+
+    if (error) {
+      const details = error.details.map(d => d.message).join(', ');
+      throw new Error(`Invalid configuration for plugin '${name}': ${details}`);
+    }
+
+    return value;
+  }
+
+  /**
+   * Inject environment variables into config
+   * Replaces ${ENV_VAR} or ${ENV_VAR:default} patterns
+   */
+  static injectEnvVars(config) {
+    if (typeof config === 'string') {
+      return this._replaceEnvVars(config);
+    }
+
+    if (Array.isArray(config)) {
+      return config.map(item => this.injectEnvVars(item));
+    }
+
+    if (config && typeof config === 'object') {
+      const result = {};
+      for (const [key, value] of Object.entries(config)) {
+        result[key] = this.injectEnvVars(value);
+      }
+      return result;
+    }
+
+    return config;
+  }
+
+  /**
+   * Replace environment variable patterns in string
+   */
+  static _replaceEnvVars(str) {
+    if (typeof str !== 'string') {
+      return str;
+    }
+
+    // Match ${ENV_VAR} or ${ENV_VAR:default}
+    return str.replace(/\$\{([^}:]+)(?::([^}]+))?\}/g, (match, envVar, defaultValue) => {
+      const value = process.env[envVar];
+      if (value !== undefined) {
+        return value;
+      }
+      if (defaultValue !== undefined) {
+        return defaultValue;
+      }
+      return match; // Keep original if no replacement found
+    });
+  }
+
+  /**
+   * Common configuration schemas for plugin types
+   */
+  static schemas = {
+    /**
+     * Database connection schema
+     */
+    database: Joi.object({
+      connectionString: Joi.string().optional(),
+      host: Joi.string().optional(),
+      port: Joi.number().optional(),
+      database: Joi.string().optional(),
+      username: Joi.string().optional(),
+      password: Joi.string().optional(),
+      poolSize: Joi.number().min(1).max(100).default(10),
+      timeout: Joi.number().min(1000).default(30000),
+      ssl: Joi.boolean().default(false)
+    }).or('connectionString', 'host'),
+
+    /**
+     * API key schema
+     */
+    apiKey: Joi.object({
+      apiKey: Joi.string().required(),
+      baseURL: Joi.string().uri().optional(),
+      timeout: Joi.number().min(1000).default(30000),
+      retries: Joi.number().min(0).max(5).default(2)
+    }),
+
+    /**
+     * Vector database schema
+     */
+    vectorDB: Joi.object({
+      apiKey: Joi.string().required(),
+      environment: Joi.string().optional(),
+      index: Joi.string().optional(),
+      dimension: Joi.number().optional(),
+      timeout: Joi.number().min(1000).default(30000)
+    }),
+
+    /**
+     * File storage schema
+     */
+    fileStorage: Joi.object({
+      path: Joi.string().required(),
+      maxSize: Joi.number().min(0).optional(),
+      allowedExtensions: Joi.array().items(Joi.string()).optional()
+    }),
+
+    /**
+     * Redis schema
+     */
+    redis: Joi.object({
+      host: Joi.string().default('localhost'),
+      port: Joi.number().min(1).max(65535).default(6379),
+      password: Joi.string().optional(),
+      db: Joi.number().min(0).default(0),
+      keyPrefix: Joi.string().optional()
+    })
+  };
+
+  /**
+   * Get a schema by name
+   */
+  static getSchema(name) {
+    return this.schemas[name];
+  }
+
+  /**
+   * Merge multiple schemas
+   */
+  static mergeSchemas(...schemas) {
+    return schemas.reduce((merged, schema) => {
+      return merged ? merged.concat(schema) : schema;
+    }, null);
+  }
+
+  /**
+   * Create a schema with environment variable support
+   */
+  static createEnvSchema(baseSchema) {
+    return baseSchema.custom((value, helpers) => {
+      const injected = this.injectEnvVars(value);
+      const { error } = baseSchema.validate(injected);
+      if (error) {
+        return helpers.error('any.custom', { message: error.message });
+      }
+      return injected;
+    });
+  }
+}
+
+module.exports = { PluginConfig };
+

package/lib/plugins/events.js

@@ -0,0 +1,186 @@
+/**
+ * Plugin Event System Utilities
+ * 
+ * Provides utilities for plugin event handling, pattern matching,
+ * and event routing between plugins and agents.
+ */
+
+class PluginEventSystem {
+  /**
+   * Check if an event name matches a handler pattern
+   * Supports wildcards and specific patterns (same as agent handlers)
+   */
+  static matchesEventPattern(eventName, pattern) {
+    // Exact match
+    if (eventName === pattern) {
+      return true;
+    }
+
+    // Wildcard patterns
+    if (pattern.includes('*')) {
+      const regexPattern = pattern.replace(/\*/g, '.*').replace(/:/g, ':');
+      const regex = new RegExp(`^${regexPattern}$`);
+      return regex.test(eventName);
+    }
+
+    // Prefix match (e.g., 'plugin:postgres:*' matches 'plugin:postgres:query')
+    if (pattern.endsWith(':*')) {
+      const prefix = pattern.slice(0, -2);
+      return eventName.startsWith(prefix + ':');
+    }
+
+    return false;
+  }
+
+  /**
+   * Normalize event name (add plugin prefix if needed)
+   */
+  static normalizeEventName(eventName, pluginName) {
+    if (eventName.startsWith('plugin:')) {
+      return eventName;
+    }
+    return `plugin:${pluginName}:${eventName}`;
+  }
+
+  /**
+   * Extract plugin name from event name
+   */
+  static extractPluginName(eventName) {
+    const match = eventName.match(/^plugin:([^:]+):/);
+    return match ? match[1] : null;
+  }
+
+  /**
+   * Create event name for plugin
+   */
+  static createPluginEvent(pluginName, eventName) {
+    return `plugin:${pluginName}:${eventName}`;
+  }
+
+  /**
+   * Create tool event name
+   */
+  static createToolEvent(toolName, action) {
+    return `tool:${toolName}:${action}`;
+  }
+
+  /**
+   * Create plugin tool event name
+   */
+  static createPluginToolEvent(pluginName, toolName, action) {
+    return `plugin:${pluginName}:tool:${toolName}:${action}`;
+  }
+
+  /**
+   * Find all matching handlers for an event
+   */
+  static findMatchingHandlers(eventName, handlersMap) {
+    const matchingHandlers = [];
+
+    for (const [handlerPattern, handlers] of handlersMap) {
+      if (this.matchesEventPattern(eventName, handlerPattern)) {
+        matchingHandlers.push(...handlers);
+      }
+    }
+
+    return matchingHandlers;
+  }
+
+  /**
+   * Execute handlers and collect responses
+   */
+  static async executeHandlers(handlers, data) {
+    let modifiedData = { ...data };
+
+    for (const handlerObj of handlers) {
+      try {
+        const handler = typeof handlerObj === 'function' 
+          ? handlerObj 
+          : handlerObj.handler;
+
+        if (typeof handler !== 'function') {
+          continue;
+        }
+
+        const result = await handler(modifiedData);
+
+        // If handler returns an object, merge it with the current data
+        if (result && typeof result === 'object' && !Array.isArray(result)) {
+          modifiedData = { ...modifiedData, ...result };
+        }
+      } catch (error) {
+        console.error(`Error in event handler:`, error);
+        // Continue executing other handlers even if one fails
+      }
+    }
+
+    return modifiedData;
+  }
+
+  /**
+   * Emit event to multiple targets
+   */
+  static emitToTargets(targets, eventName, data) {
+    targets.forEach(target => {
+      if (target && typeof target.emit === 'function') {
+        target.emit(eventName, data);
+      }
+    });
+  }
+
+  /**
+   * Create event router for plugin-to-plugin communication
+   */
+  static createEventRouter() {
+    const routes = new Map();
+
+    return {
+      /**
+       * Register a route from event pattern to target
+       */
+      route(pattern, target) {
+        if (!routes.has(pattern)) {
+          routes.set(pattern, []);
+        }
+        routes.get(pattern).push(target);
+      },
+
+      /**
+       * Remove a route
+       */
+      unroute(pattern, target) {
+        if (routes.has(pattern)) {
+          const targets = routes.get(pattern);
+          const index = targets.indexOf(target);
+          if (index !== -1) {
+            targets.splice(index, 1);
+          }
+        }
+      },
+
+      /**
+       * Route an event
+       */
+      emit(eventName, data) {
+        for (const [pattern, targets] of routes) {
+          if (this.matchesEventPattern(eventName, pattern)) {
+            this.emitToTargets(targets, eventName, data);
+          }
+        }
+      },
+
+      /**
+       * Get all routes
+       */
+      getRoutes() {
+        return Array.from(routes.entries()).map(([pattern, targets]) => ({
+          pattern,
+          targets: targets.length
+        }));
+      }
+    };
+  }
+}
+
+module.exports = { PluginEventSystem };
+

package/lib/plugins/index.js

@@ -0,0 +1,29 @@
+/**
+ * Dank Plugin System - Main Exports
+ * 
+ * Provides the plugin system infrastructure for extending Dank agents
+ * with third-party plugins for databases, vector stores, and other services.
+ */
+
+const { PluginBase } = require('./base');
+const { PluginRegistry } = require('./registry');
+const { PluginManager } = require('./manager');
+const { PluginConfig } = require('./config');
+const { PluginEventSystem } = require('./events');
+
+module.exports = {
+  // Core classes
+  PluginBase,
+  PluginRegistry,
+  PluginManager,
+  PluginConfig,
+  PluginEventSystem,
+
+  // Convenience exports
+  createPlugin: (name, config) => {
+    // This is a helper for creating plugins, but typically plugins
+    // should extend PluginBase directly
+    throw new Error('Plugins must extend PluginBase. Use: class MyPlugin extends PluginBase { ... }');
+  }
+};
+

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 };
+