dank-ai 1.0.41 → 1.0.45

package/lib/docker/manager.js

@@ -1051,17 +1051,47 @@ class DockerManager {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
+  /**
+   * Escape special characters in environment variable values for Dockerfile ENV statements
+   * Handles newlines, quotes, backslashes, and Docker variable syntax
+   * 
+   * @param {string} value - The environment variable value to escape
+   * @returns {string} - Escaped value safe for Dockerfile ENV statements
+   */
+  escapeDockerfileEnvValue(value) {
+    if (value === null || value === undefined) {
+      return '';
+    }
+    
+    return String(value)
+      // Escape backslashes first (must be first to avoid double-escaping)
+      .replace(/\\/g, '\\\\')
+      // Escape dollar signs for Dockerfile variable syntax ($VAR becomes $$VAR)
+      .replace(/\$/g, '$$$$')
+      // Escape double quotes
+      .replace(/"/g, '\\"')
+      // Escape newlines as \n (will be interpreted as newline when container reads env var)
+      .replace(/\n/g, '\\n')
+      // Escape carriage returns as \r
+      .replace(/\r/g, '\\r')
+      // Escape tabs as \t
+      .replace(/\t/g, '\\t');
+  }
+
   /**
    * Pull the base Docker image
    */
   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 +1195,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 +1262,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 +1290,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 +1309,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 +1346,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 +1505,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 +1546,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 +1754,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 +1796,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 +1851,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
@@ -1736,7 +1882,7 @@ class DockerManager {
       envStatements = Object.entries(env)
         .map(([key, value]) => {
           // Escape special characters in values for Dockerfile ENV
-          const escapedValue = String(value).replace(/\$/g, '$$$$').replace(/"/g, '\\"');
+          const escapedValue = this.escapeDockerfileEnvValue(String(value));
           return `ENV ${key}="${escapedValue}"`;
         })
         .join('\n');
@@ -1745,14 +1891,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 +1934,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 +1956,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,

package/lib/plugins/base.js

@@ -0,0 +1,324 @@
+/**
+ * PluginBase - Abstract base class for all Dank plugins
+ * 
+ * Provides lifecycle hooks, event handling, tool registration, and state management
+ * for plugins that integrate with Dank agents.
+ */
+
+const EventEmitter = require('events');
+const { v4: uuidv4 } = require('uuid');
+
+class PluginBase extends EventEmitter {
+  constructor(name, config = {}) {
+    super();
+    
+    if (!name || typeof name !== 'string') {
+      throw new Error('Plugin name must be a non-empty string');
+    }
+    
+    this.name = name;
+    this.id = uuidv4();
+    this.config = config;
+    this.state = new Map();
+    this.tools = new Map();
+    this.handlers = new Map();
+    this.status = 'initialized'; // initialized, starting, running, stopping, stopped, error
+    this.agentContext = null;
+    this.pluginManager = null;
+    this.createdAt = new Date().toISOString();
+    this.startedAt = null;
+    this.stoppedAt = null;
+  }
+
+  /**
+   * Initialize the plugin
+   * Override this method to set up connections, validate config, etc.
+   */
+  async init() {
+    this.status = 'initialized';
+    return this;
+  }
+
+  /**
+   * Start the plugin
+   * Override this method to start services, begin listening, etc.
+   */
+  async start() {
+    if (this.status === 'running') {
+      return this;
+    }
+    
+    this.status = 'starting';
+    this.startedAt = new Date().toISOString();
+    
+    try {
+      await this.onStart();
+      this.status = 'running';
+      this.emit('started');
+      return this;
+    } catch (error) {
+      this.status = 'error';
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Stop the plugin
+   * Override this method to clean up resources, close connections, etc.
+   */
+  async stop() {
+    if (this.status === 'stopped' || this.status === 'stopping') {
+      return this;
+    }
+    
+    this.status = 'stopping';
+    
+    try {
+      await this.onStop();
+      this.status = 'stopped';
+      this.stoppedAt = new Date().toISOString();
+      this.emit('stopped');
+      return this;
+    } catch (error) {
+      this.status = 'error';
+      this.emit('error', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Destroy the plugin (cleanup)
+   * Override this method for final cleanup
+   */
+  async destroy() {
+    if (this.status !== 'stopped') {
+      await this.stop();
+    }
+    
+    await this.onDestroy();
+    this.removeAllListeners();
+    this.state.clear();
+    this.tools.clear();
+    this.handlers.clear();
+    return this;
+  }
+
+  /**
+   * Lifecycle hooks (override these in subclasses)
+   */
+  async onStart() {
+    // Override in subclass
+  }
+
+  async onStop() {
+    // Override in subclass
+  }
+
+  async onDestroy() {
+    // Override in subclass
+  }
+
+  /**
+   * Register an event handler
+   * Uses the same pattern as agent handlers
+   */
+  on(eventType, handler) {
+    if (typeof handler !== 'function') {
+      throw new Error('Handler must be a function');
+    }
+
+    if (!this.handlers.has(eventType)) {
+      this.handlers.set(eventType, []);
+    }
+
+    this.handlers.get(eventType).push({
+      handler,
+      plugin: this.name
+    });
+
+    // Also register with EventEmitter for compatibility
+    super.on(eventType, handler);
+    
+    return this;
+  }
+
+  /**
+   * Remove an event handler
+   */
+  off(eventType, handler) {
+    if (this.handlers.has(eventType)) {
+      const handlers = this.handlers.get(eventType);
+      const index = handlers.findIndex(h => h.handler === handler);
+      if (index !== -1) {
+        handlers.splice(index, 1);
+      }
+    }
+    
+    super.off(eventType, handler);
+    return this;
+  }
+
+  /**
+   * Emit an event (delegates to EventEmitter)
+   */
+  emit(eventName, ...args) {
+    // Prefix plugin events with plugin name
+    const prefixedEvent = `plugin:${this.name}:${eventName}`;
+    super.emit(prefixedEvent, ...args);
+    super.emit(eventName, ...args);
+    return this;
+  }
+
+  /**
+   * Register a tool that agents can use
+   */
+  registerTool(name, definition) {
+    if (typeof name !== 'string' || name.trim().length === 0) {
+      throw new Error('Tool name must be a non-empty string');
+    }
+
+    // Prefix tool name with plugin name
+    const prefixedName = `plugin:${this.name}:${name}`;
+    
+    this.tools.set(prefixedName, {
+      ...definition,
+      name: prefixedName,
+      plugin: this.name,
+      registeredAt: new Date().toISOString()
+    });
+
+    // Emit event for tool registration
+    this.emit('tool:registered', { name: prefixedName, definition });
+    
+    return this;
+  }
+
+  /**
+   * Get all registered tools
+   */
+  getTools() {
+    return Array.from(this.tools.values());
+  }
+
+  /**
+   * Get a specific tool
+   */
+  getTool(name) {
+    const prefixedName = name.startsWith(`plugin:${this.name}:`) 
+      ? name 
+      : `plugin:${this.name}:${name}`;
+    return this.tools.get(prefixedName);
+  }
+
+  /**
+   * Set plugin state (key-value store)
+   */
+  setState(key, value) {
+    this.state.set(key, value);
+    this.emit('state:changed', { key, value });
+    return this;
+  }
+
+  /**
+   * Get plugin state
+   */
+  getState(key) {
+    return this.state.get(key);
+  }
+
+  /**
+   * Get all plugin state
+   */
+  getAllState() {
+    return Object.fromEntries(this.state);
+  }
+
+  /**
+   * Clear plugin state
+   */
+  clearState() {
+    this.state.clear();
+    this.emit('state:cleared');
+    return this;
+  }
+
+  /**
+   * Get agent context (set by PluginManager)
+   */
+  getAgentContext() {
+    return this.agentContext;
+  }
+
+  /**
+   * Set agent context (called by PluginManager)
+   */
+  setAgentContext(context) {
+    this.agentContext = context;
+    return this;
+  }
+
+  /**
+   * Get plugin manager reference
+   */
+  getPluginManager() {
+    return this.pluginManager;
+  }
+
+  /**
+   * Set plugin manager reference (called by PluginManager)
+   */
+  setPluginManager(manager) {
+    this.pluginManager = manager;
+    return this;
+  }
+
+  /**
+   * Get another plugin by name
+   */
+  getPlugin(name) {
+    if (!this.pluginManager) {
+      throw new Error('Plugin manager not available');
+    }
+    return this.pluginManager.getPlugin(name);
+  }
+
+  /**
+   * Get all other plugins
+   */
+  getPlugins() {
+    if (!this.pluginManager) {
+      throw new Error('Plugin manager not available');
+    }
+    return this.pluginManager.getAllPlugins();
+  }
+
+  /**
+   * Get plugin metadata
+   */
+  getMetadata() {
+    return {
+      name: this.name,
+      id: this.id,
+      status: this.status,
+      createdAt: this.createdAt,
+      startedAt: this.startedAt,
+      stoppedAt: this.stoppedAt,
+      toolCount: this.tools.size,
+      handlerCount: this.handlers.size,
+      stateSize: this.state.size
+    };
+  }
+
+  /**
+   * Validate plugin configuration
+   * Override this method to add custom validation
+   */
+  validateConfig(config) {
+    // Override in subclass for custom validation
+    return true;
+  }
+}
+
+module.exports = { PluginBase };
+