dank-ai 1.0.39 → 1.0.42

package/lib/agent.js

@@ -6,10 +6,11 @@
  */
 
 const Joi = require('joi');
-const { validate: validateUUID } = require('uuid');
+const { validate: validateUUID, v4: uuidv4 } = require('uuid');
 const { DEFAULT_CONFIG, SUPPORTED_LLMS, DOCKER_CONFIG, INSTANCE_TYPES } = require('./constants');
 const { ToolRegistry, ToolExecutor } = require('./tools');
 const builtinTools = require('./tools/builtin');
+const { PluginManager } = require('./plugins');
 
 class DankAgent {
   constructor(name, config = {}) {
@@ -26,6 +27,10 @@ class DankAgent {
     this.toolRegistry = new ToolRegistry();
     this.toolExecutor = new ToolExecutor(this.toolRegistry);
     
+    // Initialize plugin system
+    this.pluginManager = new PluginManager(this);
+    this.pendingPlugins = new Map(); // Store plugins to be loaded during finalization
+    
     // Register built-in tools if enabled
     if (config.enableBuiltinTools !== false) {
       this.registerBuiltinTools();
@@ -420,6 +425,68 @@ class DankAgent {
     return this.toolRegistry.toOpenAISchema();
   }
 
+  /**
+   * Add a plugin to this agent
+   * Plugin will be loaded and initialized during finalization
+   * @param {string|PluginBase} name - Plugin name, npm package, local path, or PluginBase instance
+   * @param {object} config - Plugin configuration
+   */
+  addPlugin(name, config = {}) {
+    this.pendingPlugins.set(name, config);
+    return this;
+  }
+
+  /**
+   * Add multiple plugins at once
+   * Plugins will be loaded and initialized during finalization
+   * @param {object} plugins - Object mapping plugin names to configs
+   */
+  addPlugins(plugins) {
+    Object.entries(plugins).forEach(([name, config]) => {
+      this.pendingPlugins.set(name, config);
+    });
+    return this;
+  }
+
+  /**
+   * Get a plugin by name
+   * @param {string} name - Plugin name
+   */
+  getPlugin(name) {
+    return this.pluginManager.getPlugin(name);
+  }
+
+  /**
+   * Get all plugins
+   */
+  getPlugins() {
+    return this.pluginManager.getAllPlugins();
+  }
+
+  /**
+   * Check if a plugin is loaded
+   * @param {string} name - Plugin name
+   */
+  hasPlugin(name) {
+    return this.pluginManager.hasPlugin(name);
+  }
+
+  /**
+   * Remove a plugin
+   * @param {string} name - Plugin name
+   */
+  async removePlugin(name) {
+    await this.pluginManager.removePlugin(name);
+    return this;
+  }
+
+  /**
+   * Get plugin manager metadata
+   */
+  getPluginMetadata() {
+    return this.pluginManager.getMetadata();
+  }
+
   /**
    * Register built-in tools
    */
@@ -467,9 +534,7 @@ class DankAgent {
     }
 
     this.handlers.get(eventType).push({
-      id: this._generateId(),
-      handler,
-      createdAt: new Date().toISOString()
+      handler
     });
 
     return this;
@@ -592,6 +657,7 @@ class DankAgent {
   /**
    * Finalize agent configuration by auto-detecting features
    * This should be called before the agent is deployed
+   * Plugins will be loaded when the agent is started
    */
   finalize() {
     // Validate that ID is set before finalization (REQUIRED)
@@ -601,6 +667,18 @@ class DankAgent {
     return this;
   }
 
+  /**
+   * Initialize plugins (called internally when agent starts)
+   * @private
+   */
+  async _initializePlugins() {
+    if (this.pendingPlugins.size > 0) {
+      const plugins = Object.fromEntries(this.pendingPlugins);
+      await this.pluginManager.addPlugins(plugins);
+      this.pendingPlugins.clear();
+    }
+  }
+
   /**
    * Set custom configuration
    */
@@ -776,8 +854,6 @@ class DankAgent {
     
     this.handlers.forEach((handlerList, eventType) => {
       serialized[eventType] = handlerList.map(h => ({
-        id: h.id,
-        createdAt: h.createdAt,
         // Note: actual function is not serialized
         hasFunction: typeof h.handler === 'function'
       }));

package/lib/cli/init.js

@@ -126,7 +126,9 @@ async function createPackageJson(npmProjectName, projectPath) {
       clean: 'dank clean'
     },
     dependencies: {
-      'dank-ai': '^1.0.0'
+      'dank-ai': '^1.0.0',
+      'axios': '^1.6.0',
+      'date-fns': '^3.0.0'
     },
     keywords: ['dank', 'ai', 'agents', 'automation', 'llm'],
     author: '',
@@ -270,6 +272,7 @@ A Dank AI agent project with modern event handling and Docker orchestration.
 
 - 🤖 **AI Agents**: Powered by multiple LLM providers (OpenAI, Anthropic, Google AI)
 - 🐳 **Docker Integration**: Containerized agents with automatic management
+- 📦 **NPM Packages**: Use any npm package in your handlers with top-level imports
 - 📡 **Event System**: Real-time event handling for prompts, responses, and tools
 - 🔧 **Auto-Detection**: Automatically enables features based on usage
 - 📊 **Monitoring**: Built-in logging and status monitoring
@@ -349,6 +352,27 @@ Each agent in your project has a unique UUIDv4 identifier that is automatically
 - Once agents register with Dank Cloud services, these IDs become locked to your account
 - You can generate new UUIDs if needed: \`require('uuid').v4()\`
 
+## Using NPM Packages
+
+You can use any npm package in your handlers by importing them at the top of \`dank.config.js\`:
+
+\`\`\`javascript
+// Import packages at the top
+const axios = require('axios');
+const { format } = require('date-fns');
+
+// Use them in your handlers
+.addHandler('request_output', async (data) => {
+  const timestamp = format(new Date(), 'yyyy-MM-dd HH:mm');
+  await axios.post('https://api.example.com/log', {
+    response: data.response,
+    timestamp
+  });
+})
+\`\`\`
+
+Just add any packages you need to your \`package.json\` and run \`npm install\`.
+
 ## Configuration
 
 Edit \`dank.config.js\` to:

package/lib/cli/production-build.js

@@ -173,7 +173,9 @@ async function productionBuildCommand(options) {
           force: options.force || false,
           push: options.push || false,
           baseImageOverride: options.baseImageOverride || null,
-          projectDir: projectDir  // Pass project directory so external files can be copied
+          projectDir: projectDir,  // Pass project directory so external files can be copied
+          configPath: configPath,  // Pass config path for extracting top-level requires
+          projectRoot: process.cwd()  // Pass project root for package.json location
         };
         
         const result = await dockerManager.buildProductionImage(agent, buildOptions);

package/lib/cli/run.js

@@ -71,7 +71,9 @@ async function runCommand(options) {
           
           const container = await dockerManager.startAgent(agent, {
             rebuild: !options.noBuild,  // Rebuild by default unless --no-build is specified
-            projectDir: projectDir  // Pass project directory so external files can be copied
+            projectDir: projectDir,  // Pass project directory so external files can be copied
+            configPath: configPath,  // Pass config path for extracting top-level requires
+            projectRoot: process.cwd()  // Pass project root for package.json location
           });
           
           console.log(chalk.green(`  ✅ ${agent.name} started (${container.id.substring(0, 12)})`));

package/lib/docker/manager.js

@@ -1056,12 +1056,15 @@ class DockerManager {
    */
   async pullBaseImage(baseImageName = null, options = {}) {
     const imageName = baseImageName || this.defaultBaseImageName;
-    this.logger.info(`Pulling base Docker image: ${imageName}`);
+    this.logger.info(`Pulling base Docker image: ${imageName} (platform: linux/amd64)`);
 
     try {
-      const stream = await this.docker.pull(imageName);
-
-      await this.followPullProgress(stream, "Base image pull");
+      // Use docker CLI with --platform to ensure we pull the AMD64 version
+      // This is necessary because dockerode's pull doesn't support platform directly
+      const dockerCmd = await this.resolveDockerCommand();
+      const pullCommand = `${dockerCmd} pull --platform linux/amd64 ${imageName}`;
+      
+      await this.runCommand(pullCommand, `Pull base image ${imageName}`);
 
       // Verify the image was pulled
       const hasImage = await this.hasImage(imageName);
@@ -1165,13 +1168,21 @@ class DockerManager {
     const imageName = `dank-agent-${normalizedName}`;
     this.logger.info(`Building image for agent: ${agent.name}`);
 
+    // Initialize plugins before finalizing
+    // This ensures plugin handlers and tools are available during code generation
+    if (agent._initializePlugins) {
+      await agent._initializePlugins();
+    }
+
     // Finalize agent configuration before building
     // This ensures ports and other configs are properly set
     agent.finalize();
 
     try {
       const buildContext = await this.createAgentBuildContext(agent, {
-        projectDir: options.projectDir
+        projectDir: options.projectDir,
+        configPath: options.configPath,
+        projectRoot: options.projectRoot
       });
       const dockerCmd = await this.resolveDockerCommand();
 
@@ -1224,6 +1235,8 @@ class DockerManager {
       push = false,
       baseImageOverride = null, // Production-only: override base image for all agents
       projectDir = null, // Project directory to copy files from
+      configPath = null, // Config path for extracting top-level requires
+      projectRoot = null, // Project root for package.json location
     } = options;
 
     // Normalize all components
@@ -1250,6 +1263,12 @@ class DockerManager {
       `Building production image for agent: ${agent.name} -> ${imageName}`
     );
 
+    // Initialize plugins before finalizing
+    // This ensures plugin handlers and tools are available during code generation
+    if (agent._initializePlugins) {
+      await agent._initializePlugins();
+    }
+
     // Finalize agent configuration before building
     // This ensures ports and other configs are properly set
     agent.finalize();
@@ -1263,7 +1282,9 @@ class DockerManager {
       const buildContext = await this.createAgentBuildContext(agent, { 
         isProductionBuild: true,
         baseImageOverride: baseImageOverride,
-        projectDir: projectDir
+        projectDir: projectDir,
+        configPath: configPath,
+        projectRoot: projectRoot
       });
       const dockerCmd = await this.resolveDockerCommand();
 
@@ -1298,6 +1319,65 @@ class DockerManager {
     }
   }
 
+  /**
+   * Extract top-level require statements from a config file
+   * This allows handlers to reference modules imported at the top of the config
+   * @param {string} configPath - Path to dank.config.js
+   * @returns {string[]} - Array of require statement strings
+   */
+  extractTopLevelRequires(configPath) {
+    try {
+      const content = fs.readFileSync(configPath, 'utf8');
+      const imports = [];
+      
+      // Regex 1: Match CommonJS require() patterns
+      // - const/let/var declaration
+      // - Simple name (axios) or destructured ({ get, post }) or destructured with rename ({ get: httpGet })
+      // - Single or double quotes for module path
+      // - Optional semicolon at end
+      // - Handles multi-line destructured imports via [\s\S]*?
+      const requireRegex = /^(const|let|var)\s+(\{[\s\S]*?\}|\w+)\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\);?/gm;
+      
+      let match;
+      while ((match = requireRegex.exec(content)) !== null) {
+        let statement = match[0];
+        if (!statement.endsWith(';')) {
+          statement += ';';
+        }
+        imports.push(statement);
+      }
+      
+      // Regex 2: Match dynamic import() patterns (for ESM-only packages in CommonJS)
+      // Handles:
+      // - const x = import("y");
+      // - const x = import("y").then((m) => m.default);
+      // - const x = import("y").then((m) => { return m.default; });
+      // - Multiline .then() callbacks
+      // - Single or double quotes
+      const dynamicImportRegex = /^(const|let|var)\s+\w+\s*=\s*import\s*\(\s*['"][^'"]+['"]\s*\)[\s\S]*?;/gm;
+      
+      while ((match = dynamicImportRegex.exec(content)) !== null) {
+        let statement = match[0];
+        // Clean up extra whitespace in multiline statements
+        statement = statement.replace(/\n\s+/g, '\n  ');
+        if (!statement.endsWith(';')) {
+          statement += ';';
+        }
+        imports.push(statement);
+      }
+      
+      const requireCount = imports.filter(s => s.includes('require(')).length;
+      const importCount = imports.filter(s => s.includes('import(')).length;
+      
+      this.logger.info(`📦 Extracted ${imports.length} top-level imports from config (${requireCount} require, ${importCount} dynamic import)`);
+      
+      return imports;
+    } catch (error) {
+      this.logger.warn(`⚠️ Failed to extract imports from config: ${error.message}`);
+      return [];
+    }
+  }
+
   /**
    * Generate handlers code from agent configuration
    */
@@ -1398,6 +1478,12 @@ class DockerManager {
       has_docker_config: !!agent.config.docker
     });
 
+    // Initialize plugins before finalizing
+    // This ensures plugin handlers and tools are available during code generation
+    if (agent._initializePlugins) {
+      await agent._initializePlugins();
+    }
+
     // Finalize agent configuration (auto-detect features)
     // This will validate that agent.id is set (required)
     agent.finalize();
@@ -1433,14 +1519,19 @@ class DockerManager {
       const hasImage = await this.hasImage(imageName);
       if (!hasImage || options.rebuild) {
         await this.buildAgentImage(agent, {
-          projectDir: options.projectDir
+          projectDir: options.projectDir,
+          configPath: options.configPath,
+          projectRoot: options.projectRoot
         });
       }
 
       // Prepare container configuration
+      // Platform is set to linux/amd64 to match the build platform
+      // This ensures consistent behavior and allows ARM machines to run via QEMU emulation
       const containerConfig = {
         Image: imageName,
         name: containerName,
+        platform: 'linux/amd64',
         Env: this.prepareEnvironmentVariables(agent),
         HostConfig: {
           Memory: AgentConfig.parseMemory(AgentConfig.getResourcesFromInstanceType(agent.config.instanceType).memory),
@@ -1636,11 +1727,35 @@ class DockerManager {
 
   /**
    * Copy project files to build context (excluding common ignore patterns)
+   * @param {string} projectDir - Directory containing code files to copy
+   * @param {string} contextDir - Build context directory
+   * @param {object} options - Additional options
+   * @param {string} options.projectRoot - Root directory for package.json (defaults to process.cwd())
    */
-  async copyProjectFiles(projectDir, contextDir) {
+  async copyProjectFiles(projectDir, contextDir, options = {}) {
     const agentCodeDir = path.join(contextDir, "agent-code");
     await fs.ensureDir(agentCodeDir);
     
+    // Copy package.json and package-lock.json from project root (not projectDir)
+    // This ensures dependencies are installed correctly even for compiled projects
+    // where projectDir might be ./dist but package.json is at root
+    const projectRoot = options.projectRoot || process.cwd();
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    const packageLockPath = path.join(projectRoot, 'package-lock.json');
+    
+    try {
+      if (await fs.pathExists(packageJsonPath)) {
+        await fs.copy(packageJsonPath, path.join(agentCodeDir, 'package.json'));
+        this.logger.info(`📦 Copied package.json from project root`);
+      }
+      if (await fs.pathExists(packageLockPath)) {
+        await fs.copy(packageLockPath, path.join(agentCodeDir, 'package-lock.json'));
+        this.logger.info(`📦 Copied package-lock.json from project root`);
+      }
+    } catch (error) {
+      this.logger.warn(`⚠️ Failed to copy package files: ${error.message}`);
+    }
+    
     // Patterns to exclude when copying project files
     const ignorePatterns = [
       'node_modules',
@@ -1654,7 +1769,9 @@ class DockerManager {
       'build',
       '.dank',
       'coverage',
-      '.nyc_output'
+      '.nyc_output',
+      'package.json',      // Already copied from project root
+      'package-lock.json'  // Already copied from project root
     ];
     
     try {
@@ -1707,7 +1824,9 @@ class DockerManager {
     // Copy project files if project directory is provided
     // This allows handlers to reference functions from other files
     if (options.projectDir) {
-      await this.copyProjectFiles(options.projectDir, contextDir);
+      await this.copyProjectFiles(options.projectDir, contextDir, {
+        projectRoot: options.projectRoot
+      });
     }
 
     // Get the base image for this agent
@@ -1745,14 +1864,39 @@ class DockerManager {
       this.logger.info(`   - DOCKER_PORT: ${env.DOCKER_PORT || 'not set'}`);
     }
 
+    // Check if package.json exists in project root to determine if we need npm install
+    const projectRoot = options.projectRoot || process.cwd();
+    const hasPackageJson = await fs.pathExists(path.join(projectRoot, 'package.json'));
+    
+    // Generate npm install step if package.json exists
+    // We copy package files first for Docker layer caching, then install, then copy code
+    const npmInstallStep = hasPackageJson ? `
+# Copy dependency files first (for Docker layer caching)
+COPY agent-code/package.json /app/agent-code/package.json
+COPY agent-code/package-lock.json* /app/agent-code/
+
+# Install dependencies
+WORKDIR /app/agent-code
+RUN npm ci --production 2>/dev/null || npm install --production
+
+# Reset working directory
+WORKDIR /app
+` : '';
+
     // Create Dockerfile for agent
     const dockerfile = `FROM ${baseImageName}
+${npmInstallStep}
+# Copy agent code
 COPY agent-code/ /app/agent-code/
 ${envStatements}
 USER dankuser
 `;
 
     await fs.writeFile(path.join(contextDir, "Dockerfile"), dockerfile);
+    
+    if (hasPackageJson) {
+      this.logger.info(`📦 Dockerfile includes npm ci step for dependency installation`);
+    }
 
     // Copy agent code if it exists
     const agentCodeDir = path.join(contextDir, "agent-code");
@@ -1763,6 +1907,16 @@ USER dankuser
     const handlersCode = this.generateHandlersCode(agent);
     const routesCode = this.generateRoutesCode(agent);
 
+    // Extract top-level requires from config file for injection into generated code
+    // This solves the closure problem where handlers reference modules imported at top of config
+    const topLevelRequires = options.configPath 
+      ? this.extractTopLevelRequires(options.configPath)
+      : [];
+    
+    const injectedRequires = topLevelRequires.length > 0
+      ? `// Injected top-level requires from dank.config.js\n${topLevelRequires.join('\n')}\n`
+      : '';
+
     // Check if project files were copied (indicated by presence of files other than index.js)
     const hasProjectFiles = options.projectDir ? true : false;
     const projectFilesNote = hasProjectFiles 
@@ -1775,6 +1929,7 @@ USER dankuser
 // Agent: ${agent.name}
 // Generated by Dank Agent Service
 
+${injectedRequires}
 ${projectFilesNote}
 
 module.exports = {

package/lib/index.js

@@ -9,6 +9,7 @@ const { DankAgent } = require('./agent');
 const { DankProject } = require('./project');
 const { AgentConfig } = require('./config');
 const { SUPPORTED_LLMS, DEFAULT_CONFIG } = require('./constants');
+const { PluginBase, PluginRegistry, PluginManager, PluginConfig, PluginEventSystem } = require('./plugins');
 
 module.exports = {
   // Main classes
@@ -16,6 +17,13 @@ module.exports = {
   DankProject,
   AgentConfig,
   
+  // Plugin system
+  PluginBase,
+  PluginRegistry,
+  PluginManager,
+  PluginConfig,
+  PluginEventSystem,
+  
   // Constants
   SUPPORTED_LLMS,
   DEFAULT_CONFIG,