dank-ai 1.0.18 → 1.0.19

package/lib/docker/manager.js

@@ -1,6 +1,6 @@
 /**
  * Docker Container Manager
- * 
+ *
  * Manages Docker containers for Dank agents including:
  * - Building agent images
  * - Starting/stopping containers
@@ -8,32 +8,68 @@
  * - Managing Docker resources
  */
 
-const Docker = require('dockerode');
-const fs = require('fs-extra');
-const path = require('path');
-const tar = require('tar');
-const winston = require('winston');
-const { spawn, exec } = require('child_process');
-const { promisify } = require('util');
-const { DOCKER_CONFIG } = require('../constants');
-const { AgentConfig } = require('../config');
+const Docker = require("dockerode");
+const fs = require("fs-extra");
+const path = require("path");
+const os = require("os");
+const tar = require("tar");
+const winston = require("winston");
+const { spawn, exec } = require("child_process");
+const { promisify } = require("util");
+const { DOCKER_CONFIG } = require("../constants");
+const { AgentConfig } = require("../config");
 
 const execAsync = promisify(exec);
 
 class DockerManager {
   constructor(options = {}) {
     this.docker = new Docker(options.dockerOptions || {});
-    this.logger = options.logger || winston.createLogger({
-      level: 'info',
-      format: winston.format.simple(),
-      transports: [new winston.transports.Console()]
-    });
-    
+    this.logger =
+      options.logger ||
+      winston.createLogger({
+        level: "info",
+        format: winston.format.simple(),
+        transports: [new winston.transports.Console()],
+      });
+
     this.defaultBaseImageName = `${DOCKER_CONFIG.baseImagePrefix}:${DOCKER_CONFIG.defaultTag}`;
     this.networkName = DOCKER_CONFIG.networkName;
     this.containers = new Map();
   }
 
+  /**
+   * Create Docker client with proper socket detection
+   */
+  createDockerClient() {
+    const fs = require("fs-extra");
+    const path = require("path");
+
+    // Common Docker socket locations
+    const socketPaths = [
+      "/var/run/docker.sock", // Standard Linux
+      "//var/run/docker.sock", // Windows WSL2
+      "\\\\.\\pipe\\docker_engine", // Windows named pipe
+      path.join(os.homedir(), ".docker", "run", "docker.sock"), // macOS Docker Desktop
+      "/Users/Shared/docker.sock", // Alternative macOS location
+    ];
+
+    // Find the first available socket
+    for (const socketPath of socketPaths) {
+      try {
+        if (fs.existsSync(socketPath)) {
+          this.logger.info(`Found Docker socket at: ${socketPath}`);
+          return new Docker({ socketPath });
+        }
+      } catch (error) {
+        // Continue to next socket path
+      }
+    }
+
+    // If no socket found, try default connection (will use environment variables)
+    this.logger.info("No Docker socket found, using default connection");
+    return new Docker();
+  }
+
   /**
    * Initialize Docker environment
    */
@@ -41,21 +77,25 @@ class DockerManager {
     try {
       // Ensure Docker is available and running
       await this.ensureDockerAvailable();
-      
+
+      // Initialize Docker client with proper socket detection
+      this.docker = this.createDockerClient();
+
       // Check Docker connection
       await this.docker.ping();
-      this.logger.info('Docker connection established');
+      this.logger.info("Docker connection established");
 
       // Create network if it doesn't exist
       await this.ensureNetwork();
-      
+
       // Check if default base image exists, pull if not found
       const hasBaseImage = await this.hasImage(this.defaultBaseImageName);
       if (!hasBaseImage) {
-        this.logger.info(`Default base image '${this.defaultBaseImageName}' not found. Pulling from registry...`);
+        this.logger.info(
+          `Default base image '${this.defaultBaseImageName}' not found. Pulling from registry...`
+        );
         await this.pullBaseImage();
       }
-
     } catch (error) {
       throw new Error(`Failed to initialize Docker: ${error.message}`);
     }
@@ -66,22 +106,27 @@ class DockerManager {
    */
   async ensureDockerAvailable() {
     try {
+      // Initialize Docker client with proper socket detection
+      this.docker = this.createDockerClient();
+
       // First, try to ping Docker to see if it's running
       await this.docker.ping();
-      this.logger.info('Docker is running and accessible');
+      this.logger.info("Docker is running and accessible");
       return;
     } catch (error) {
-      this.logger.info('Docker is not accessible, checking installation...');
+      this.logger.info("Docker is not accessible, checking installation...");
     }
 
     // Check if Docker is installed
     const isInstalled = await this.isDockerInstalled();
-    
+
     if (!isInstalled) {
-      this.logger.info('Docker is not installed. Installing Docker...');
+      this.logger.info("Docker is not installed. Installing Docker...");
       await this.installDocker();
     } else {
-      this.logger.info('Docker is installed but not running. Starting Docker...');
+      this.logger.info(
+        "Docker is installed but not running. Starting Docker..."
+      );
       await this.startDocker();
     }
 
@@ -94,33 +139,140 @@ class DockerManager {
    */
   async isDockerInstalled() {
     try {
-      await execAsync('docker --version');
+      // Check if docker command is available using multiple paths
+      const dockerPaths = [
+        "/usr/local/bin/docker",
+        "/opt/homebrew/bin/docker",
+        "/usr/bin/docker",
+        "docker", // fallback to PATH
+      ];
+
+      let dockerFound = false;
+      for (const path of dockerPaths) {
+        try {
+          await execAsync(`${path} --version`);
+          dockerFound = true;
+          break;
+        } catch (error) {
+          // Try next path
+        }
+      }
+
+      if (!dockerFound) {
+        return false;
+      }
+
+      // On macOS, also check if Docker Desktop is installed
+      if (process.platform === "darwin") {
+        const dockerAppPath = "/Applications/Docker.app";
+        const fs = require("fs-extra");
+        if (!(await fs.pathExists(dockerAppPath))) {
+          this.logger.info("Docker CLI found but Docker Desktop not installed");
+          return false;
+        }
+      }
+
       return true;
     } catch (error) {
       return false;
     }
   }
 
+  /**
+   * Check if Docker is accessible and running
+   */
+  async checkDockerAccess() {
+    try {
+      // Try to run a simple docker command to check if Docker is accessible
+      // Use full path to docker command to avoid PATH issues after installation
+      const dockerPaths = [
+        "/usr/local/bin/docker",
+        "/opt/homebrew/bin/docker",
+        "/usr/bin/docker",
+        "docker", // fallback to PATH
+      ];
+
+      let dockerCommand = "docker";
+      let dockerFound = false;
+
+      for (const path of dockerPaths) {
+        try {
+          this.logger.info(`Trying Docker path: ${path}`);
+          const result = await execAsync(`${path} --version`);
+          this.logger.info(`✅ Docker found at: ${path}`);
+          this.logger.info(`Docker version: ${result.stdout.trim()}`);
+          dockerCommand = path;
+          dockerFound = true;
+          break;
+        } catch (error) {
+          this.logger.debug(
+            `❌ Docker not found at: ${path} - ${error.message}`
+          );
+        }
+      }
+
+      if (!dockerFound) {
+        throw new Error("Docker executable not found in any expected location");
+      }
+
+      // Test if Docker daemon service is accessible and running
+      this.logger.info("🔍 Testing Docker daemon service...");
+      try {
+        const result = await execAsync(`${dockerCommand} ps`);
+        this.logger.info("✅ Docker daemon service is running and accessible");
+        this.logger.debug(`Docker ps output: ${result.stdout.trim()}`);
+        return true;
+      } catch (error) {
+        this.logger.error(
+          `❌ Docker daemon service not accessible: ${error.message}`
+        );
+        this.logger.error(`STDERR: ${error.stderr || "No stderr"}`);
+
+        // Provide helpful error information
+        if (error.message.includes("Cannot connect to the Docker daemon")) {
+          this.logger.info(
+            "💡 Docker daemon is not running. Please start Docker Desktop or Docker service."
+          );
+        } else if (error.message.includes("permission denied")) {
+          this.logger.info(
+            "💡 Permission denied. You may need to add your user to the docker group or restart your terminal."
+          );
+        } else if (error.message.includes("connection refused")) {
+          this.logger.info(
+            "💡 Connection refused. Docker daemon may not be started yet."
+          );
+        }
+
+        throw new Error(
+          `Docker daemon service is not accessible: ${error.message}`
+        );
+      }
+    } catch (error) {
+      this.logger.error(`Docker access check failed: ${error.message}`);
+      throw new Error(`Docker is not accessible: ${error.message}`);
+    }
+  }
+
   /**
    * Install Docker on the system
    */
   async installDocker() {
     const platform = process.platform;
-    
+
     this.logger.info(`Installing Docker for ${platform}...`);
-    
+
     try {
-      if (platform === 'darwin') {
+      if (platform === "darwin") {
         await this.installDockerMacOS();
-      } else if (platform === 'linux') {
+      } else if (platform === "linux") {
         await this.installDockerLinux();
-      } else if (platform === 'win32') {
+      } else if (platform === "win32") {
         await this.installDockerWindows();
       } else {
         throw new Error(`Unsupported platform: ${platform}`);
       }
-      
-      this.logger.info('Docker installation completed');
+
+      this.logger.info("Docker installation completed");
     } catch (error) {
       throw new Error(`Failed to install Docker: ${error.message}`);
     }
@@ -130,121 +282,421 @@ class DockerManager {
    * Install Docker on macOS
    */
   async installDockerMacOS() {
-    this.logger.info('Installing Docker Desktop for macOS...');
-    
-    // Check if Homebrew is available with multiple methods
-    let homebrewAvailable = false;
-    let homebrewPath = 'brew';
-    
+    this.logger.info("Installing Docker Desktop for macOS...");
+
     try {
-      // Try different ways to detect Homebrew
-      await execAsync('brew --version');
-      homebrewAvailable = true;
-      homebrewPath = 'brew';
+      // Download Docker Desktop installer
+      await this.downloadDockerInstaller();
+
+      // Launch the installer
+      await this.launchDockerInstaller();
+
+      // Prompt user to complete installation
+      this.promptUserToCompleteInstallation();
+
+      // Wait for Docker to be installed and available
+      await this.waitForDockerInstallation();
     } catch (error) {
+      this.logger.error("Docker installation failed:", error.message);
+      throw new Error(`Docker Desktop installation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Wait for Docker to be ready and accessible
+   */
+  async waitForDockerReady(maxWaitTime = 120000) {
+    // 2 minutes max wait
+    const startTime = Date.now();
+    const checkInterval = 5000; // Check every 5 seconds
+
+    this.logger.info("Checking if Docker is ready...");
+
+    while (Date.now() - startTime < maxWaitTime) {
       try {
-        // Try with full path (Apple Silicon Macs)
-        await execAsync('/opt/homebrew/bin/brew --version');
-        homebrewAvailable = true;
-        homebrewPath = '/opt/homebrew/bin/brew';
-      } catch (error2) {
-        try {
-          // Try with usr/local path (Intel Macs)
-          await execAsync('/usr/local/bin/brew --version');
-          homebrewAvailable = true;
-          homebrewPath = '/usr/local/bin/brew';
-        } catch (error3) {
-          // Try to find brew in PATH
-          try {
-            const { stdout } = await execAsync('which brew');
-            if (stdout.trim()) {
-              await execAsync(`${stdout.trim()} --version`);
-              homebrewAvailable = true;
-              homebrewPath = stdout.trim();
-            }
-          } catch (error4) {
-            // Homebrew not found
-            this.logger.debug('Homebrew detection failed:', error4.message);
-          }
-        }
+        await this.checkDockerAccess();
+        this.logger.info("Docker is ready and accessible!");
+        return true;
+      } catch (error) {
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        this.logger.info(
+          `Docker not ready yet (${elapsed}s elapsed), waiting...`
+        );
+        await new Promise((resolve) => setTimeout(resolve, checkInterval));
       }
     }
-    
-    if (homebrewAvailable) {
-      this.logger.info(`Using Homebrew to install Docker Desktop (found at: ${homebrewPath})...`);
-      
-      try {
-        // First, try to update Homebrew to ensure it's working
-        this.logger.info('Updating Homebrew...');
-        try {
-          const updateCommand = `${homebrewPath} update`;
-          this.logger.info(`🔧 About to run command: ${updateCommand}`);
-          await this.runCommandWithEnv(updateCommand, 'Updating Homebrew');
-        } catch (updateError) {
-          this.logger.warn('Homebrew update failed, continuing with installation...');
+
+    throw new Error(
+      `Docker did not become ready within ${maxWaitTime / 1000} seconds`
+    );
+  }
+
+  /**
+   * Download a file using Node.js built-in modules with proper binary handling
+   */
+  async downloadFile(url, filePath) {
+    this.logger.info(`Downloading file from ${url} to ${filePath}`);
+
+    const https = require("https");
+    const http = require("http");
+    const fs = require("fs-extra");
+    const { URL } = require("url");
+
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(url);
+      const client = parsedUrl.protocol === "https:" ? https : http;
+
+      const request = client.get(url, (response) => {
+        if (response.statusCode === 200) {
+          const file = fs.createWriteStream(filePath);
+
+          // Handle binary data properly
+          response.setEncoding("binary");
+
+          response.on("data", (chunk) => {
+            file.write(chunk, "binary");
+          });
+
+          response.on("end", () => {
+            file.end();
+            this.logger.info("File downloaded successfully");
+            resolve();
+          });
+
+          file.on("error", (error) => {
+            fs.unlink(filePath, () => {}); // Delete the file on error
+            reject(new Error(`File write error: ${error.message}`));
+          });
+        } else if (response.statusCode === 302 || response.statusCode === 301) {
+          // Handle redirects
+          this.logger.info(
+            `Following redirect to: ${response.headers.location}`
+          );
+          this.downloadFile(response.headers.location, filePath)
+            .then(resolve)
+            .catch(reject);
+        } else {
+          reject(
+            new Error(
+              `HTTP error: ${response.statusCode} ${response.statusMessage}`
+            )
+          );
         }
-        
-        // Try different installation approaches
-        let installSuccess = false;
-        
-        // Approach 1: Direct installation
-        try {
-          this.logger.info('Attempting direct installation...');
-          const command1 = `${homebrewPath} install cask docker`;
-          this.logger.info(`🔧 About to run command: ${command1}`);
-          await this.runCommandWithEnv(command1, 'Installing Docker Desktop via Homebrew');
-          installSuccess = true;
-        } catch (error1) {
-          this.logger.warn('Direct installation failed, trying alternative approach...');
-          
-          // Approach 2: Try with --force flag
-          try {
-            this.logger.info('Attempting installation with --force flag...');
-            const command2 = `${homebrewPath} install cask --force docker`;
-            this.logger.info(`🔧 About to run command: ${command2}`);
-            await this.runCommandWithEnv(command2, 'Installing Docker Desktop via Homebrew (force)');
-            installSuccess = true;
-          } catch (error2) {
-            this.logger.warn('Force installation failed, trying with --no-quarantine flag...');
-            
-            // Approach 3: Try with --no-quarantine flag
-            try {
-              this.logger.info('Attempting installation with --no-quarantine flag...');
-              const command3 = `${homebrewPath} install cask --no-quarantine docker`;
-              this.logger.info(`🔧 About to run command: ${command3}`);
-              await this.runCommandWithEnv(command3, 'Installing Docker Desktop via Homebrew (no-quarantine)');
-              installSuccess = true;
-            } catch (error3) {
-              this.logger.error('All installation approaches failed');
-              throw error3;
-            }
+      });
+
+      request.on("error", (error) => {
+        reject(new Error(`Download error: ${error.message}`));
+      });
+    });
+  }
+
+  /**
+   * Download Docker Desktop installer for the current platform
+   */
+  async downloadDockerInstaller() {
+    this.logger.info("Downloading Docker Desktop installer...");
+
+    try {
+      // Determine the correct download URL based on platform and architecture
+      let downloadUrl, installerName, installerPath;
+
+      if (process.platform === "darwin") {
+        const arch = process.arch === "arm64" ? "arm64" : "amd64";
+        downloadUrl = `https://desktop.docker.com/mac/main/${arch}/Docker.dmg`;
+        installerName = "Docker.dmg";
+        installerPath = path.join(os.homedir(), "Downloads", installerName);
+      } else if (process.platform === "win32") {
+        downloadUrl =
+          "https://desktop.docker.com/win/main/amd64/Docker%20Desktop%20Installer.exe";
+        installerName = "Docker Desktop Installer.exe";
+        installerPath = path.join(os.homedir(), "Downloads", installerName);
+      } else if (process.platform === "linux") {
+        downloadUrl =
+          "https://desktop.docker.com/linux/main/amd64/docker-desktop-4.46.0-amd64.deb";
+        installerName = "docker-desktop.deb";
+        installerPath = path.join(os.homedir(), "Downloads", installerName);
+      } else {
+        throw new Error(`Unsupported platform: ${process.platform}`);
+      }
+
+      this.logger.info(
+        `Downloading Docker Desktop for ${process.platform} (${process.arch})...`
+      );
+      this.logger.info(`URL: ${downloadUrl}`);
+      this.logger.info(`Destination: ${installerPath}`);
+
+      // Download the installer using Node.js built-in modules
+      await this.downloadFile(downloadUrl, installerPath);
+
+      this.logger.info("Docker Desktop installer downloaded successfully");
+      return { installerPath, installerName };
+    } catch (error) {
+      this.logger.error(
+        "Failed to download Docker Desktop installer:",
+        error.message
+      );
+      throw new Error(
+        `Failed to download Docker Desktop installer: ${error.message}`
+      );
+    }
+  }
+
+  /**
+   * Launch the Docker Desktop installer
+   */
+  async launchDockerInstaller() {
+    this.logger.info("Launching Docker Desktop installer...");
+
+    try {
+      let launchCommand;
+
+      if (process.platform === "darwin") {
+        // Mount DMG and copy Docker.app to Applications
+        const dmgPath = path.join(os.homedir(), "Downloads", "Docker.dmg");
+
+        // Mount the DMG
+        const mountCommand = `hdiutil attach "${dmgPath}"`;
+        this.logger.info(`🔧 About to run command: ${mountCommand}`);
+        await this.runCommand(mountCommand, "Mounting Docker Desktop DMG");
+
+        // Wait a moment for the mount to complete
+        await this.sleep(2000);
+
+        // Check if the volume was mounted and find the correct path
+        const fs = require("fs-extra");
+        const possiblePaths = [
+          "/Volumes/Docker/Docker.app",
+          "/Volumes/Docker.app",
+          "/Volumes/Docker Desktop/Docker.app",
+        ];
+
+        let dockerAppPath = null;
+        for (const path of possiblePaths) {
+          if (await fs.pathExists(path)) {
+            dockerAppPath = path;
+            break;
           }
         }
-        
-        if (installSuccess) {
-          // Try to start Docker Desktop
-          this.logger.info('Starting Docker Desktop...');
-          try {
-            const startCommand = 'open -a Docker';
-            this.logger.info(`🔧 About to run command: ${startCommand}`);
-            await this.runCommandWithEnv(startCommand, 'Starting Docker Desktop');
-          } catch (startError) {
-            this.logger.warn('Could not start Docker Desktop automatically. Please start it manually from Applications.');
-          }
+
+        if (!dockerAppPath) {
+          throw new Error("Could not find Docker.app in mounted volume");
         }
-        
+
+        // Copy Docker.app to Applications folder
+        this.logger.info("Copying Docker.app to Applications folder...");
+        const copyCommand = `cp -R "${dockerAppPath}" /Applications/`;
+        this.logger.info(`🔧 About to run command: ${copyCommand}`);
+        await this.runCommand(
+          copyCommand,
+          "Copying Docker.app to Applications"
+        );
+
+        // Unmount the DMG
+        this.logger.info("Unmounting DMG...");
+        const unmountCommand = "hdiutil detach /Volumes/Docker";
+        this.logger.info(`🔧 About to run command: ${unmountCommand}`);
+        try {
+          await this.runCommand(unmountCommand, "Unmounting DMG");
+        } catch (error) {
+          this.logger.warn(
+            "Could not unmount DMG (may already be unmounted):",
+            error.message
+          );
+        }
+
+        // Launch Docker Desktop from Applications
+        launchCommand = "open -a Docker";
+      } else if (process.platform === "win32") {
+        const installerPath = path.join(
+          os.homedir(),
+          "Downloads",
+          "Docker Desktop Installer.exe"
+        );
+        launchCommand = `"${installerPath}"`;
+      } else if (process.platform === "linux") {
+        const installerPath = path.join(
+          os.homedir(),
+          "Downloads",
+          "docker-desktop.deb"
+        );
+        launchCommand = `sudo dpkg -i "${installerPath}"`;
+      }
+
+      this.logger.info(`🔧 About to run command: ${launchCommand}`);
+      await this.runCommand(
+        launchCommand,
+        "Launching Docker Desktop installer"
+      );
+
+      this.logger.info("Docker Desktop installer launched successfully");
+    } catch (error) {
+      this.logger.error(
+        "Failed to launch Docker Desktop installer:",
+        error.message
+      );
+      throw new Error(
+        `Failed to launch Docker Desktop installer: ${error.message}`
+      );
+    }
+  }
+
+  /**
+   * Prompt user to complete Docker installation
+   */
+  promptUserToCompleteInstallation() {
+    console.log("\n" + "=".repeat(60));
+    console.log("🐳 DOCKER INSTALLATION REQUIRED");
+    console.log("=".repeat(60));
+    console.log("");
+    console.log("The Docker Desktop installer has been launched.");
+    console.log("Please follow these steps to complete the installation:");
+    console.log("");
+
+    if (process.platform === "darwin") {
+      console.log(
+        "1. Docker.app has been automatically copied to Applications"
+      );
+      console.log("2. Docker Desktop should launch automatically");
+      console.log("3. Follow the setup wizard to complete installation");
+      console.log("4. Start Docker Desktop when prompted");
+    } else if (process.platform === "win32") {
+      console.log("1. The Docker Desktop installer should open automatically");
+      console.log("2. Follow the installation wizard");
+      console.log("3. Restart your computer if prompted");
+      console.log("4. Launch Docker Desktop from Start Menu");
+    } else if (process.platform === "linux") {
+      console.log("1. The Docker Desktop package has been installed");
+      console.log("2. Launch Docker Desktop from your applications menu");
+      console.log("3. Follow the setup wizard to complete installation");
+    }
+
+    console.log("");
+    console.log("⏳ Waiting for Docker to be installed and started...");
+    console.log("   (This may take a few minutes)");
+    console.log("");
+    console.log("=".repeat(60));
+  }
+
+  /**
+   * Wait for Docker to be installed and available
+   */
+  async waitForDockerInstallation() {
+    this.logger.info("Waiting for Docker to be installed and available...");
+
+    const maxWaitTime = 300000; // 5 minutes max wait
+    const checkInterval = 5000; // Check every 5 seconds
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < maxWaitTime) {
+      try {
+        // Check if Docker is installed and running
+        await this.checkDockerAccess();
+        this.logger.info("Docker is installed and running!");
+        return true;
       } catch (error) {
-        this.logger.warn('Homebrew found but installation failed. Please install Docker Desktop manually from https://www.docker.com/products/docker-desktop/');
-        this.logger.error(`Installation error: ${error.message}`);
-        this.logger.info('You can also try installing Docker Desktop manually:');
-        this.logger.info('1. Download from: https://www.docker.com/products/docker-desktop/');
-        this.logger.info('2. Or try: brew install cask docker');
-        throw new Error('Docker Desktop installation via Homebrew failed. Please install manually from https://www.docker.com/products/docker-desktop/');
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+        const remaining = Math.round(
+          (maxWaitTime - (Date.now() - startTime)) / 1000
+        );
+
+        this.logger.info(
+          `Docker not ready yet (${elapsed}s elapsed, ${remaining}s remaining)...`
+        );
+
+        // Show progress every 30 seconds
+        if (elapsed % 30 === 0) {
+          console.log(`⏳ Still waiting for Docker... (${elapsed}s elapsed)`);
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, checkInterval));
       }
-    } else {
-      this.logger.warn('Homebrew not found. Please install Docker Desktop manually from https://www.docker.com/products/docker-desktop/');
-      this.logger.info('You can install Homebrew by running: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"');
-      throw new Error('Docker Desktop installation requires manual intervention. Please install from https://www.docker.com/products/docker-desktop/');
+    }
+
+    throw new Error(
+      `Docker did not become available within ${
+        maxWaitTime / 1000
+      } seconds. Please ensure Docker Desktop is installed and running.`
+    );
+  }
+
+  /**
+   * Install Docker Desktop manually by downloading and installing the DMG
+   */
+  async installDockerDesktopManually() {
+    this.logger.info("Downloading Docker Desktop manually...");
+
+    try {
+      // Determine the correct download URL based on architecture
+      const arch = process.arch === "arm64" ? "arm64" : "amd64";
+      const downloadUrl = `https://desktop.docker.com/mac/main/${arch}/Docker.dmg`;
+      const dmgPath = path.join(os.homedir(), "Downloads", "Docker.dmg");
+
+      this.logger.info(`Downloading Docker Desktop for ${arch}...`);
+      this.logger.info(`URL: ${downloadUrl}`);
+      this.logger.info(`Destination: ${dmgPath}`);
+
+      // Download the DMG file
+      const downloadCommand = `curl -L "${downloadUrl}" -o "${dmgPath}"`;
+      this.logger.info(`🔧 About to run command: ${downloadCommand}`);
+      await this.runCommandWithEnv(
+        downloadCommand,
+        "Downloading Docker Desktop"
+      );
+
+      // Mount the DMG
+      this.logger.info("Mounting Docker Desktop DMG...");
+      const mountCommand = `hdiutil attach "${dmgPath}"`;
+      this.logger.info(`🔧 About to run command: ${mountCommand}`);
+      await this.runCommandWithEnv(mountCommand, "Mounting Docker Desktop DMG");
+
+      // Copy Docker.app to Applications
+      this.logger.info("Installing Docker Desktop to Applications...");
+      const copyCommand = 'cp -R "/Volumes/Docker/Docker.app" /Applications/';
+      this.logger.info(`🔧 About to run command: ${copyCommand}`);
+      await this.runCommandWithEnv(copyCommand, "Installing Docker Desktop");
+
+      // Unmount the DMG
+      this.logger.info("Unmounting Docker Desktop DMG...");
+      const unmountCommand = "hdiutil detach /Volumes/Docker";
+      this.logger.info(`🔧 About to run command: ${unmountCommand}`);
+      await this.runCommandWithEnv(
+        unmountCommand,
+        "Unmounting Docker Desktop DMG"
+      );
+
+      // Clean up the DMG file
+      this.logger.info("Cleaning up downloaded DMG...");
+      const cleanupCommand = `rm "${dmgPath}"`;
+      this.logger.info(`🔧 About to run command: ${cleanupCommand}`);
+      await this.runCommandWithEnv(cleanupCommand, "Cleaning up DMG file");
+
+      this.logger.info(
+        "Docker Desktop installed successfully via manual download"
+      );
+
+      // Try to start Docker Desktop
+      this.logger.info("Starting Docker Desktop...");
+      try {
+        const startCommand = "open -a Docker";
+        this.logger.info(`🔧 About to run command: ${startCommand}`);
+        await this.runCommandWithEnv(startCommand, "Starting Docker Desktop");
+
+        // Wait for Docker to be ready
+        this.logger.info("Waiting for Docker Desktop to start...");
+        await this.waitForDockerReady();
+      } catch (startError) {
+        this.logger.warn(
+          "Could not start Docker Desktop automatically. Please start it manually from Applications."
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        "Manual Docker Desktop installation failed:",
+        error.message
+      );
+      throw new Error(
+        `Manual Docker Desktop installation failed: ${error.message}`
+      );
     }
   }
 
@@ -252,34 +704,23 @@ class DockerManager {
    * Install Docker on Linux
    */
   async installDockerLinux() {
-    this.logger.info('Installing Docker on Linux...');
-    
+    this.logger.info("Installing Docker on Linux...");
+
     try {
-      // Update package index
-      await this.runCommand('sudo apt-get update', 'Updating package index');
-      
-      // Install prerequisites
-      await this.runCommand('sudo apt-get install -y apt-transport-https ca-certificates curl gnupg lsb-release', 'Installing prerequisites');
-      
-      // Add Docker's official GPG key
-      await this.runCommand('curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg', 'Adding Docker GPG key');
-      
-      // Add Docker repository
-      await this.runCommand('echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null', 'Adding Docker repository');
-      
-      // Update package index again
-      await this.runCommand('sudo apt-get update', 'Updating package index with Docker repository');
-      
-      // Install Docker
-      await this.runCommand('sudo apt-get install -y docker-ce docker-ce-cli containerd.io', 'Installing Docker');
-      
-      // Add current user to docker groupl
-      await this.runCommand('sudo usermod -aG docker $USER', 'Adding user to docker group');
-      
-      this.logger.info('Docker installation completed. You may need to log out and back in for group changes to take effect.');
-      
+      // Download Docker Desktop installer
+      await this.downloadDockerInstaller();
+
+      // Launch the installer
+      await this.launchDockerInstaller();
+
+      // Prompt user to complete installation
+      this.promptUserToCompleteInstallation();
+
+      // Wait for Docker to be installed and available
+      await this.waitForDockerInstallation();
     } catch (error) {
-      throw new Error(`Failed to install Docker on Linux: ${error.message}`);
+      this.logger.error("Docker installation failed:", error.message);
+      throw new Error(`Docker Desktop installation failed: ${error.message}`);
     }
   }
 
@@ -287,19 +728,23 @@ class DockerManager {
    * Install Docker on Windows
    */
   async installDockerWindows() {
-    this.logger.info('Installing Docker Desktop for Windows...');
-    
-    // Check if Chocolatey is available
+    this.logger.info("Installing Docker Desktop for Windows...");
+
     try {
-      await execAsync('choco --version');
-      this.logger.info('Using Chocolatey to install Docker Desktop...');
-      
-      // Install Docker Desktop via Chocolatey
-      await this.runCommand('choco install docker-desktop -y', 'Installing Docker Desktop via Chocolatey');
-      
+      // Download Docker Desktop installer
+      await this.downloadDockerInstaller();
+
+      // Launch the installer
+      await this.launchDockerInstaller();
+
+      // Prompt user to complete installation
+      this.promptUserToCompleteInstallation();
+
+      // Wait for Docker to be installed and available
+      await this.waitForDockerInstallation();
     } catch (error) {
-      this.logger.warn('Chocolatey not found. Please install Docker Desktop manually from https://www.docker.com/products/docker-desktop/');
-      throw new Error('Docker Desktop installation requires manual intervention. Please install from https://www.docker.com/products/docker-desktop/');
+      this.logger.error("Docker installation failed:", error.message);
+      throw new Error(`Docker Desktop installation failed: ${error.message}`);
     }
   }
 
@@ -308,24 +753,33 @@ class DockerManager {
    */
   async startDocker() {
     const platform = process.platform;
-    
+
     try {
-      if (platform === 'darwin') {
+      if (platform === "darwin") {
         // On macOS, try to start Docker Desktop
-        await this.runCommand('open -a Docker', 'Starting Docker Desktop');
-      } else if (platform === 'linux') {
+        await this.runCommand("open -a Docker", "Starting Docker Desktop");
+      } else if (platform === "linux") {
         // On Linux, start Docker service
-        await this.runCommand('sudo systemctl start docker', 'Starting Docker service');
-        await this.runCommand('sudo systemctl enable docker', 'Enabling Docker service');
-      } else if (platform === 'win32') {
+        await this.runCommand(
+          "sudo systemctl start docker",
+          "Starting Docker service"
+        );
+        await this.runCommand(
+          "sudo systemctl enable docker",
+          "Enabling Docker service"
+        );
+      } else if (platform === "win32") {
         // On Windows, try to start Docker Desktop
-        await this.runCommand('start "" "C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe"', 'Starting Docker Desktop');
+        await this.runCommand(
+          'start "" "C:\\Program Files\\Docker\\Docker\\Docker Desktop.exe"',
+          "Starting Docker Desktop"
+        );
       }
-      
-      this.logger.info('Docker service started');
+
+      this.logger.info("Docker service started");
     } catch (error) {
       this.logger.warn(`Failed to start Docker service: ${error.message}`);
-      this.logger.info('Please start Docker manually and try again');
+      this.logger.info("Please start Docker manually and try again");
       throw error;
     }
   }
@@ -334,25 +788,85 @@ class DockerManager {
    * Wait for Docker to become available
    */
   async waitForDocker() {
-    this.logger.info('Waiting for Docker to become available...');
-    
-    const maxAttempts = 30; // 30 seconds
-    const delay = 1000; // 1 second
-    
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const maxWaitTime = 300000; // 5 minutes
+    const checkInterval = 3000; // 3 seconds
+    const stabilityCheckDuration = 10000; // 10 seconds of consistent readiness
+    const stabilityCheckInterval = 2000; // Check every 2 seconds during stability phase
+    let elapsedTime = 0;
+
+    this.logger.info(
+      "⏳ Waiting for Docker daemon service to become available..."
+    );
+    this.logger.info("This may take a few minutes if Docker is starting up...");
+
+    while (elapsedTime < maxWaitTime) {
       try {
-        await this.docker.ping();
-        this.logger.info('Docker is now available');
+        await this.checkDockerAccess();
+        this.logger.info("✅ Docker daemon detected! Verifying stability...");
+
+        // Wait for Docker to be consistently ready for stabilityCheckDuration
+        const stabilityStartTime = Date.now();
+        let consecutiveSuccessfulChecks = 0;
+        const requiredConsecutiveChecks = Math.ceil(
+          stabilityCheckDuration / stabilityCheckInterval
+        );
+
+        while (Date.now() - stabilityStartTime < stabilityCheckDuration) {
+          try {
+            await this.checkDockerAccess();
+            consecutiveSuccessfulChecks++;
+            this.logger.info(
+              `Stability check ${consecutiveSuccessfulChecks}/${requiredConsecutiveChecks} passed`
+            );
+
+            if (consecutiveSuccessfulChecks >= requiredConsecutiveChecks) {
+              this.logger.info("✅ Docker daemon is stable and ready!");
+              return;
+            }
+          } catch (error) {
+            this.logger.info(
+              "Docker daemon became unstable, restarting stability check..."
+            );
+            consecutiveSuccessfulChecks = 0;
+          }
+
+          await this.sleep(stabilityCheckInterval);
+        }
+
+        // If we get here, stability check timed out
+        this.logger.warn(
+          "Docker daemon stability check timed out, continuing anyway..."
+        );
         return;
       } catch (error) {
-        if (attempt === maxAttempts) {
-          throw new Error('Docker did not become available within the expected time');
+        const remainingTime = Math.round((maxWaitTime - elapsedTime) / 1000);
+        const elapsedSeconds = Math.round(elapsedTime / 1000);
+
+        if (elapsedSeconds % 30 === 0) {
+          // Log every 30 seconds
+          this.logger.info(
+            `Docker daemon service not ready yet (${elapsedSeconds}s elapsed, ${remainingTime}s remaining)...`
+          );
+          this.logger.info(`Last error: ${error.message}`);
         }
-        
-        this.logger.info(`Waiting for Docker... (${attempt}/${maxAttempts})`);
-        await this.sleep(delay);
+
+        await this.sleep(checkInterval);
+        elapsedTime += checkInterval;
       }
     }
+
+    this.logger.error(
+      "❌ Docker daemon service did not become available within the expected time"
+    );
+    this.logger.error("Please check:");
+    this.logger.error(
+      "1. Docker is installed and the daemon service is running"
+    );
+    this.logger.error("2. Docker daemon has finished starting up");
+    this.logger.error("3. You have permission to access Docker");
+    this.logger.error('4. Try running "docker ps" manually to test');
+
+    throw new Error("Docker did not become available within the expected time");
   }
 
   /**
@@ -361,36 +875,38 @@ class DockerManager {
   async runCommand(command, description) {
     this.logger.info(`${description}...`);
     this.logger.debug(`Executing command: ${command}`);
-    
+
     return new Promise((resolve, reject) => {
-      const child = spawn('sh', ['-c', command], { 
-        stdio: ['inherit', 'pipe', 'pipe'],
-        shell: true 
+      const child = spawn(command, {
+        stdio: ["inherit", "pipe", "pipe"],
+        shell: true,
       });
-      
-      let stdout = '';
-      let stderr = '';
-      
-      child.stdout.on('data', (data) => {
+
+      let stdout = "";
+      let stderr = "";
+
+      child.stdout.on("data", (data) => {
         const output = data.toString();
         stdout += output;
         // Log output in debug mode
         this.logger.debug(`STDOUT: ${output.trim()}`);
       });
-      
-      child.stderr.on('data', (data) => {
+
+      child.stderr.on("data", (data) => {
         const output = data.toString();
         stderr += output;
         // Log stderr in debug mode
         this.logger.debug(`STDERR: ${output.trim()}`);
       });
-      
-      child.on('close', (code) => {
+
+      child.on("close", (code) => {
         if (code === 0) {
           this.logger.info(`${description} completed successfully`);
           resolve({ stdout, stderr });
         } else {
-          const error = new Error(`Command failed with exit code ${code}: ${stderr}`);
+          const error = new Error(
+            `Command failed with exit code ${code}: ${stderr}`
+          );
           this.logger.error(`${description} failed: ${error.message}`);
           this.logger.error(`Command: ${command}`);
           this.logger.error(`STDOUT: ${stdout}`);
@@ -398,8 +914,8 @@ class DockerManager {
           reject(error);
         }
       });
-      
-      child.on('error', (error) => {
+
+      child.on("error", (error) => {
         this.logger.error(`${description} failed: ${error.message}`);
         this.logger.error(`Command: ${command}`);
         reject(error);
@@ -413,51 +929,74 @@ class DockerManager {
   async runCommandWithEnv(command, description) {
     this.logger.info(`${description}...`);
     this.logger.debug(`Executing command: ${command}`);
-    
+
     return new Promise((resolve, reject) => {
       // Set up environment for Homebrew
+      const homebrewPaths = [
+        "/opt/homebrew/bin",
+        "/usr/local/bin",
+        "/opt/homebrew/sbin",
+        "/usr/local/sbin",
+      ];
+
+      const existingPath = process.env.PATH || "";
+      const allPaths = [...homebrewPaths, ...existingPath.split(":")];
+      const uniquePaths = [...new Set(allPaths.filter((p) => p))];
+      const effectivePath = uniquePaths.join(":");
+
       const env = {
         ...process.env,
-        PATH: process.env.PATH,
-        HOMEBREW_NO_AUTO_UPDATE: '1', // Prevent auto-update during installation
-        HOMEBREW_NO_INSTALL_CLEANUP: '1' // Keep installation files
+        PATH: effectivePath,
+        HOMEBREW_NO_AUTO_UPDATE: "1",
+        HOMEBREW_NO_INSTALL_CLEANUP: "1",
+        HOMEBREW_PREFIX: "/opt/homebrew",
+        HOMEBREW_CELLAR: "/opt/homebrew/Cellar",
+        HOMEBREW_REPOSITORY: "/opt/homebrew",
+        HOMEBREW_SHELLENV_PREFIX: "/opt/homebrew",
       };
-      
+
       // Debug: Log environment details
       this.logger.debug(`Environment PATH: ${env.PATH}`);
-      this.logger.debug(`HOMEBREW_NO_AUTO_UPDATE: ${env.HOMEBREW_NO_AUTO_UPDATE}`);
-      this.logger.debug(`HOMEBREW_NO_INSTALL_CLEANUP: ${env.HOMEBREW_NO_INSTALL_CLEANUP}`);
-      
-      // Use bash instead of sh for better environment support
-      const child = spawn('bash', ['-c', command], { 
-        stdio: ['inherit', 'pipe', 'pipe'],
-        shell: true,
-        env: env
+      this.logger.debug(`HOMEBREW_PREFIX: ${env.HOMEBREW_PREFIX}`);
+      this.logger.debug(
+        `HOMEBREW_NO_AUTO_UPDATE: ${env.HOMEBREW_NO_AUTO_UPDATE}`
+      );
+      this.logger.debug(
+        `HOMEBREW_NO_INSTALL_CLEANUP: ${env.HOMEBREW_NO_INSTALL_CLEANUP}`
+      );
+
+      // Use zsh with login shell for better environment support on macOS
+      const child = spawn("zsh", ["-l", "-c", command], {
+        stdio: ["inherit", "pipe", "pipe"],
+        shell: false,
+        env: env,
       });
-      
-      let stdout = '';
-      let stderr = '';
-      
-      child.stdout.on('data', (data) => {
+
+      let stdout = "";
+      let stderr = "";
+
+      child.stdout.on("data", (data) => {
         const output = data.toString();
         stdout += output;
         // Log output in debug mode
         this.logger.debug(`STDOUT: ${output.trim()}`);
       });
-      
-      child.stderr.on('data', (data) => {
+
+      child.stderr.on("data", (data) => {
         const output = data.toString();
         stderr += output;
         // Log stderr in debug mode
         this.logger.debug(`STDERR: ${output.trim()}`);
       });
-      
-      child.on('close', (code) => {
+
+      child.on("close", (code) => {
         if (code === 0) {
           this.logger.info(`${description} completed successfully`);
           resolve({ stdout, stderr });
         } else {
-          const error = new Error(`Command failed with exit code ${code}: ${stderr}`);
+          const error = new Error(
+            `Command failed with exit code ${code}: ${stderr}`
+          );
           this.logger.error(`${description} failed: ${error.message}`);
           this.logger.error(`Command: ${command}`);
           this.logger.error(`STDOUT: ${stdout}`);
@@ -465,8 +1004,8 @@ class DockerManager {
           reject(error);
         }
       });
-      
-      child.on('error', (error) => {
+
+      child.on("error", (error) => {
         this.logger.error(`${description} failed: ${error.message}`);
         this.logger.error(`Command: ${command}`);
         reject(error);
@@ -478,7 +1017,7 @@ class DockerManager {
    * Sleep utility
    */
   sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
   /**
@@ -487,20 +1026,21 @@ class DockerManager {
   async pullBaseImage(baseImageName = null, options = {}) {
     const imageName = baseImageName || this.defaultBaseImageName;
     this.logger.info(`Pulling base Docker image: ${imageName}`);
-    
+
     try {
       const stream = await this.docker.pull(imageName);
-      
-      await this.followPullProgress(stream, 'Base image pull');
-      
+
+      await this.followPullProgress(stream, "Base image pull");
+
       // Verify the image was pulled
       const hasImage = await this.hasImage(imageName);
       if (hasImage) {
         this.logger.info(`Base image '${imageName}' pulled successfully`);
       } else {
-        throw new Error(`Base image '${imageName}' was not pulled successfully`);
+        throw new Error(
+          `Base image '${imageName}' was not pulled successfully`
+        );
       }
-      
     } catch (error) {
       throw new Error(`Failed to pull base image: ${error.message}`);
     }
@@ -510,55 +1050,61 @@ class DockerManager {
    * Clean up existing containers from previous runs
    */
   async cleanupExistingContainers(agents) {
-    this.logger.info('Cleaning up existing containers from previous runs...');
-    
+    this.logger.info("Cleaning up existing containers from previous runs...");
+
     try {
       // Get all containers (running and stopped) that match our agent naming pattern
       const containers = await this.docker.listContainers({ all: true });
-      
-      const agentNames = agents.map(agent => agent.name.toLowerCase());
-      const containersToCleanup = containers.filter(container => {
+
+      const agentNames = agents.map((agent) => agent.name.toLowerCase());
+      const containersToCleanup = containers.filter((container) => {
         // Check if container name matches our dank agent pattern
-        const containerName = container.Names[0].replace(/^\//, ''); // Remove leading slash
-        return agentNames.some(agentName => 
-          containerName.startsWith(`dank-${agentName}-`) || 
-          containerName === `dank-${agentName}`
+        const containerName = container.Names[0].replace(/^\//, ""); // Remove leading slash
+        return agentNames.some(
+          (agentName) =>
+            containerName.startsWith(`dank-${agentName}-`) ||
+            containerName === `dank-${agentName}`
         );
       });
 
       if (containersToCleanup.length === 0) {
-        this.logger.info('No existing containers found to cleanup');
+        this.logger.info("No existing containers found to cleanup");
         return;
       }
 
-      this.logger.info(`Found ${containersToCleanup.length} existing containers to cleanup`);
+      this.logger.info(
+        `Found ${containersToCleanup.length} existing containers to cleanup`
+      );
 
       // Stop and remove each container
       for (const containerInfo of containersToCleanup) {
         const container = this.docker.getContainer(containerInfo.Id);
-        const containerName = containerInfo.Names[0].replace(/^\//, '');
-        
+        const containerName = containerInfo.Names[0].replace(/^\//, "");
+
         try {
           // Stop container if running
-          if (containerInfo.State === 'running') {
+          if (containerInfo.State === "running") {
             this.logger.info(`Stopping container: ${containerName}`);
             await container.stop({ t: 10 }); // 10 second timeout
           }
-          
+
           // Remove container
           this.logger.info(`Removing container: ${containerName}`);
           await container.remove({ force: true });
-          
         } catch (error) {
           // Log but don't fail if we can't clean up a specific container
-          this.logger.warn(`Failed to cleanup container ${containerName}: ${error.message}`);
+          this.logger.warn(
+            `Failed to cleanup container ${containerName}: ${error.message}`
+          );
         }
       }
 
-      this.logger.info('Container cleanup completed');
-      
+      this.logger.info("Container cleanup completed");
     } catch (error) {
-      this.logger.error('Failed to cleanup existing containers:', error.message);
+      this.logger.error(
+        "Failed to cleanup existing containers:",
+        error.message
+      );
       // Don't throw - we want to continue even if cleanup fails
     }
   }
@@ -572,22 +1118,21 @@ class DockerManager {
 
     try {
       const buildContext = await this.createAgentBuildContext(agent);
-      
+
       const stream = await this.docker.buildImage(buildContext, {
         t: imageName,
-        dockerfile: 'Dockerfile',
-        nocache: options.rebuild || options.noCache || false
+        dockerfile: "Dockerfile",
+        nocache: options.rebuild || options.noCache || false,
       });
 
       await this.followBuildProgress(stream, `Agent ${agent.name} build`);
-      
+
       this.logger.info(`Agent image '${imageName}' built successfully`);
-      
+
       // Clean up build context
       await fs.remove(buildContext);
-      
+
       return imageName;
-      
     } catch (error) {
       throw new Error(`Failed to build agent image: ${error.message}`);
     }
@@ -598,49 +1143,54 @@ class DockerManager {
    */
   async buildProductionImage(agent, options = {}) {
     const {
-      tag = 'latest',
+      tag = "latest",
       registry,
       namespace,
       force = false,
-      push = false
+      push = false,
     } = options;
 
     // Construct production image name
     let imageName = agent.name.toLowerCase();
-    
+
     // Add namespace if provided
     if (namespace) {
       imageName = `${namespace}/${imageName}`;
     }
-    
+
     // Add registry if provided
     if (registry) {
       imageName = `${registry}/${imageName}`;
     }
-    
+
     // Add tag
     imageName = `${imageName}:${tag}`;
 
-    this.logger.info(`Building production image for agent: ${agent.name} -> ${imageName}`);
+    this.logger.info(
+      `Building production image for agent: ${agent.name} -> ${imageName}`
+    );
 
     try {
       const buildContext = await this.createAgentBuildContext(agent);
-      
+
       const stream = await this.docker.buildImage(buildContext, {
         t: imageName,
-        dockerfile: 'Dockerfile',
-        nocache: force
+        dockerfile: "Dockerfile",
+        nocache: force,
       });
 
-      await this.followBuildProgress(stream, `Production build for ${agent.name}`);
-      
+      await this.followBuildProgress(
+        stream,
+        `Production build for ${agent.name}`
+      );
+
       this.logger.info(`Production image '${imageName}' built successfully`);
-      
+
       // Clean up build context
       await fs.remove(buildContext);
-      
+
       let pushed = false;
-      
+
       // Push to registry if requested
       if (push) {
         try {
@@ -650,16 +1200,17 @@ class DockerManager {
           this.logger.info(`Successfully pushed image: ${imageName}`);
           pushed = true;
         } catch (pushError) {
-          this.logger.warn(`Failed to push image ${imageName}: ${pushError.message}`);
+          this.logger.warn(
+            `Failed to push image ${imageName}: ${pushError.message}`
+          );
           // Don't fail the build if push fails
         }
       }
-      
+
       return {
         imageName,
-        pushed
+        pushed,
       };
-      
     } catch (error) {
       throw new Error(`Failed to build production image: ${error.message}`);
     }
@@ -670,21 +1221,21 @@ class DockerManager {
    */
   generateHandlersCode(agent) {
     const handlers = {};
-    
+
     // Add default handlers
     handlers.output = ['(data) => console.log("Output:", data)'];
     handlers.error = ['(error) => console.error("Error:", error)'];
-    
+
     // Add custom handlers from agent configuration
     if (agent.handlers && agent.handlers.size > 0) {
       for (const [eventName, handlerList] of agent.handlers) {
         if (!handlers[eventName]) {
           handlers[eventName] = [];
         }
-        
+
         // Convert handler functions to string representations
-        handlerList.forEach(handlerObj => {
-          if (handlerObj && typeof handlerObj.handler === 'function') {
+        handlerList.forEach((handlerObj) => {
+          if (handlerObj && typeof handlerObj.handler === "function") {
             // Convert function to string, handling the function properly
             const handlerStr = handlerObj.handler.toString();
             handlers[eventName].push(handlerStr);
@@ -692,15 +1243,19 @@ class DockerManager {
         });
       }
     }
-    
+
     // Generate the JavaScript object code
-    const handlersEntries = Object.entries(handlers).map(([eventName, handlerArray]) => {
-      const handlersStr = handlerArray.join(',\n      ');
-      // Quote event names that contain special characters (like colons)
-      const quotedEventName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(eventName) ? eventName : `"${eventName}"`;
-      return `    ${quotedEventName}: [\n      ${handlersStr}\n    ]`;
-    }).join(',\n');
-    
+    const handlersEntries = Object.entries(handlers)
+      .map(([eventName, handlerArray]) => {
+        const handlersStr = handlerArray.join(",\n      ");
+        // Quote event names that contain special characters (like colons)
+        const quotedEventName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(eventName)
+          ? eventName
+          : `"${eventName}"`;
+        return `    ${quotedEventName}: [\n      ${handlersStr}\n    ]`;
+      })
+      .join(",\n");
+
     return `{\n${handlersEntries}\n  }`;
   }
 
@@ -710,16 +1265,21 @@ class DockerManager {
   async startAgent(agent, options = {}) {
     // Finalize agent configuration (auto-detect features)
     agent.finalize();
-    
+
     const imageName = `dank-agent-${agent.name.toLowerCase()}`;
-    const containerName = `dank-${agent.name.toLowerCase()}-${agent.id.split('_').pop()}`;
-    const baseImageName = agent.config.docker?.baseImage || this.defaultBaseImageName;
+    const containerName = `dank-${agent.name.toLowerCase()}-${agent.id
+      .split("_")
+      .pop()}`;
+    const baseImageName =
+      agent.config.docker?.baseImage || this.defaultBaseImageName;
 
     try {
       // Ensure base image exists
       const hasBaseImage = await this.hasImage(baseImageName);
       if (!hasBaseImage) {
-        this.logger.info(`Base image '${baseImageName}' not found for agent ${agent.name}. Pulling...`);
+        this.logger.info(
+          `Base image '${baseImageName}' not found for agent ${agent.name}. Pulling...`
+        );
         await this.pullBaseImage(baseImageName);
       }
 
@@ -739,44 +1299,48 @@ class DockerManager {
           CpuQuota: Math.floor(agent.config.resources.cpu * 100000),
           CpuPeriod: 100000,
           RestartPolicy: {
-            Name: 'on-failure',
-            MaximumRetryCount: agent.config.resources.maxRestarts || 3
+            Name: "on-failure",
+            MaximumRetryCount: agent.config.resources.maxRestarts || 3,
           },
           NetworkMode: this.networkName,
-          ...this.preparePortConfiguration(agent)
+          ...this.preparePortConfiguration(agent),
         },
         NetworkingConfig: {
           EndpointsConfig: {
-            [this.networkName]: {}
-          }
+            [this.networkName]: {},
+          },
         },
-        ...this.prepareExposedPorts(agent)
+        ...this.prepareExposedPorts(agent),
       };
 
       // Create container
       this.logger.info(`Creating container for agent: ${agent.name}`);
       const container = await this.docker.createContainer(containerConfig);
-      
+
       // Start container
       await container.start();
-      
+
       // Store container reference
       this.containers.set(agent.name, {
         container,
         agent,
         startTime: new Date(),
-        status: 'running'
+        status: "running",
       });
 
       agent.containerId = container.id;
-      agent.status = 'running';
+      agent.status = "running";
+
+      this.logger.info(
+        `Agent ${agent.name} started successfully (${container.id.substring(
+          0,
+          12
+        )})`
+      );
 
-      this.logger.info(`Agent ${agent.name} started successfully (${container.id.substring(0, 12)})`);
-      
       return container;
-      
     } catch (error) {
-      agent.status = 'error';
+      agent.status = "error";
       throw new Error(`Failed to start agent ${agent.name}: ${error.message}`);
     }
   }
@@ -792,23 +1356,22 @@ class DockerManager {
 
     try {
       const { container, agent } = containerInfo;
-      
+
       this.logger.info(`Stopping agent: ${agentName}`);
-      
+
       if (options.force) {
         await container.kill();
       } else {
         await container.stop({ t: 10 }); // 10 second timeout
       }
-      
+
       await container.remove();
-      
+
       this.containers.delete(agentName);
-      agent.status = 'stopped';
+      agent.status = "stopped";
       agent.containerId = null;
-      
+
       this.logger.info(`Agent ${agentName} stopped successfully`);
-      
     } catch (error) {
       throw new Error(`Failed to stop agent ${agentName}: ${error.message}`);
     }
@@ -820,28 +1383,27 @@ class DockerManager {
   async getAgentStatus(agentName) {
     const containerInfo = this.containers.get(agentName);
     if (!containerInfo) {
-      return { status: 'not_running' };
+      return { status: "not_running" };
     }
 
     try {
       const { container, agent, startTime } = containerInfo;
       const containerData = await container.inspect();
-      
+
       return {
-        status: containerData.State.Running ? 'running' : 'stopped',
+        status: containerData.State.Running ? "running" : "stopped",
         containerId: container.id,
         startTime,
         uptime: Date.now() - startTime.getTime(),
-        health: containerData.State.Health?.Status || 'unknown',
+        health: containerData.State.Health?.Status || "unknown",
         restartCount: containerData.RestartCount,
         resources: {
           memory: agent.config.resources.memory,
-          cpu: agent.config.resources.cpu
-        }
+          cpu: agent.config.resources.cpu,
+        },
       };
-      
     } catch (error) {
-      return { status: 'error', error: error.message };
+      return { status: "error", error: error.message };
     }
   }
 
@@ -855,14 +1417,14 @@ class DockerManager {
     }
 
     const { container } = containerInfo;
-    
+
     const logStream = await container.logs({
       stdout: true,
       stderr: true,
       follow: options.follow || false,
       tail: options.tail || 100,
       since: options.since || undefined,
-      timestamps: true
+      timestamps: true,
     });
 
     return logStream;
@@ -872,22 +1434,25 @@ class DockerManager {
    * Create build context for base image
    */
   async createBaseBuildContext() {
-    const contextDir = path.join(__dirname, '../../.build-context-base');
+    const contextDir = path.join(__dirname, "../../.build-context-base");
     await fs.ensureDir(contextDir);
 
     // Copy Docker files
-    await fs.copy(path.join(__dirname, '../../docker'), contextDir);
-    
+    await fs.copy(path.join(__dirname, "../../docker"), contextDir);
+
     // Create runtime directory
-    const runtimeDir = path.join(contextDir, 'runtime');
+    const runtimeDir = path.join(contextDir, "runtime");
     await fs.ensureDir(runtimeDir);
-    
+
     // Create tarball
-    const tarPath = path.join(__dirname, '../../.base-build-context.tar');
-    await tar.create({
-      file: tarPath,
-      cwd: contextDir
-    }, ['.']);
+    const tarPath = path.join(__dirname, "../../.base-build-context.tar");
+    await tar.create(
+      {
+        file: tarPath,
+        cwd: contextDir,
+      },
+      ["."]
+    );
 
     return tarPath;
   }
@@ -896,28 +1461,32 @@ class DockerManager {
    * Create build context for agent
    */
   async createAgentBuildContext(agent) {
-    const contextDir = path.join(__dirname, `../../.build-context-${agent.name}`);
+    const contextDir = path.join(
+      __dirname,
+      `../../.build-context-${agent.name}`
+    );
     await fs.ensureDir(contextDir);
 
     // Get the base image for this agent
-    const baseImageName = agent.config.docker?.baseImage || this.defaultBaseImageName;
+    const baseImageName =
+      agent.config.docker?.baseImage || this.defaultBaseImageName;
 
     // Create Dockerfile for agent
     const dockerfile = `FROM ${baseImageName}
 COPY agent-code/ /app/agent-code/
 USER dankuser
 `;
-    
-    await fs.writeFile(path.join(contextDir, 'Dockerfile'), dockerfile);
-    
+
+    await fs.writeFile(path.join(contextDir, "Dockerfile"), dockerfile);
+
     // Copy agent code if it exists
-    const agentCodeDir = path.join(contextDir, 'agent-code');
+    const agentCodeDir = path.join(contextDir, "agent-code");
     await fs.ensureDir(agentCodeDir);
-    
+
     // Create basic agent code structure
     // Generate handlers from agent configuration
     const handlersCode = this.generateHandlersCode(agent);
-    
+
     const agentCode = `
 // Agent: ${agent.name}
 // Generated by Dank Agent Service
@@ -961,15 +1530,21 @@ module.exports = {
   handlers: ${handlersCode}
 };
 `;
-    
-    await fs.writeFile(path.join(agentCodeDir, 'index.js'), agentCode);
-    
+
+    await fs.writeFile(path.join(agentCodeDir, "index.js"), agentCode);
+
     // Create tarball
-    const tarPath = path.join(__dirname, `../../.agent-${agent.name}-context.tar`);
-    await tar.create({
-      file: tarPath,
-      cwd: contextDir
-    }, ['.']);
+    const tarPath = path.join(
+      __dirname,
+      `../../.agent-${agent.name}-context.tar`
+    );
+    await tar.create(
+      {
+        file: tarPath,
+        cwd: contextDir,
+      },
+      ["."]
+    );
 
     return tarPath;
   }
@@ -988,11 +1563,11 @@ module.exports = {
   preparePortConfiguration(agent) {
     const portConfig = {};
     const portBindings = {};
-    
+
     // Always bind the main agent port
     const mainPort = agent.config.docker?.port || DOCKER_CONFIG.defaultPort;
     portBindings[`${mainPort}/tcp`] = [{ HostPort: mainPort.toString() }];
-    
+
     // Also bind HTTP port if HTTP is enabled and different from main port
     if (agent.config.http && agent.config.http.enabled) {
       const httpPort = agent.config.http.port;
@@ -1000,11 +1575,11 @@ module.exports = {
         portBindings[`${httpPort}/tcp`] = [{ HostPort: httpPort.toString() }];
       }
     }
-    
+
     // Always bind health check port
     const healthPort = DOCKER_CONFIG.healthCheckPort;
     portBindings[`${healthPort}/tcp`] = [{ HostPort: healthPort.toString() }];
-    
+
     portConfig.PortBindings = portBindings;
     return portConfig;
   }
@@ -1014,11 +1589,11 @@ module.exports = {
    */
   prepareExposedPorts(agent) {
     const exposedPorts = {};
-    
+
     // Always expose the main agent port
     const mainPort = agent.config.docker?.port || DOCKER_CONFIG.defaultPort;
     exposedPorts[`${mainPort}/tcp`] = {};
-    
+
     // Also expose HTTP port if HTTP is enabled and different from main port
     if (agent.config.http && agent.config.http.enabled) {
       const httpPort = agent.config.http.port;
@@ -1026,11 +1601,11 @@ module.exports = {
         exposedPorts[`${httpPort}/tcp`] = {};
       }
     }
-    
+
     // Always expose health check port
     const healthPort = DOCKER_CONFIG.healthCheckPort;
     exposedPorts[`${healthPort}/tcp`] = {};
-    
+
     return { ExposedPorts: exposedPorts };
   }
 
@@ -1046,7 +1621,7 @@ module.exports = {
         this.logger.info(`Creating Docker network: ${this.networkName}`);
         await this.docker.createNetwork({
           Name: this.networkName,
-          Driver: 'bridge'
+          Driver: "bridge",
         });
       } else {
         throw error;
@@ -1074,19 +1649,23 @@ module.exports = {
    */
   async followBuildProgress(stream, buildName) {
     return new Promise((resolve, reject) => {
-      this.docker.modem.followProgress(stream, (err, res) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(res);
-        }
-      }, (event) => {
-        if (event.stream) {
-          process.stdout.write(event.stream);
-        } else if (event.status) {
-          this.logger.debug(`${buildName}: ${event.status}`);
+      this.docker.modem.followProgress(
+        stream,
+        (err, res) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve(res);
+          }
+        },
+        (event) => {
+          if (event.stream) {
+            process.stdout.write(event.stream);
+          } else if (event.status) {
+            this.logger.debug(`${buildName}: ${event.status}`);
+          }
         }
-      });
+      );
     });
   }
 
@@ -1095,21 +1674,27 @@ module.exports = {
    */
   async followPullProgress(stream, pullName) {
     return new Promise((resolve, reject) => {
-      this.docker.modem.followProgress(stream, (err, res) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(res);
-        }
-      }, (event) => {
-        if (event.status) {
-          if (event.progress) {
-            process.stdout.write(`\r${pullName}: ${event.status} ${event.progress}`);
+      this.docker.modem.followProgress(
+        stream,
+        (err, res) => {
+          if (err) {
+            reject(err);
           } else {
-            this.logger.info(`${pullName}: ${event.status}`);
+            resolve(res);
+          }
+        },
+        (event) => {
+          if (event.status) {
+            if (event.progress) {
+              process.stdout.write(
+                `\r${pullName}: ${event.status} ${event.progress}`
+              );
+            } else {
+              this.logger.info(`${pullName}: ${event.status}`);
+            }
           }
         }
-      });
+      );
     });
   }
 
@@ -1117,26 +1702,28 @@ module.exports = {
    * Clean up Docker resources
    */
   async cleanup(options = {}) {
-    this.logger.info('Cleaning up Docker resources...');
+    this.logger.info("Cleaning up Docker resources...");
 
     try {
       if (options.containers || options.all) {
         // Stop and remove all Dank containers
         const containers = await this.docker.listContainers({
           all: true,
-          filters: { name: ['dank-'] }
+          filters: { name: ["dank-"] },
         });
 
         for (const containerInfo of containers) {
           const container = this.docker.getContainer(containerInfo.Id);
           try {
-            if (containerInfo.State === 'running') {
+            if (containerInfo.State === "running") {
               await container.stop();
             }
             await container.remove();
             this.logger.info(`Removed container: ${containerInfo.Names[0]}`);
           } catch (error) {
-            this.logger.warn(`Failed to remove container ${containerInfo.Names[0]}: ${error.message}`);
+            this.logger.warn(
+              `Failed to remove container ${containerInfo.Names[0]}: ${error.message}`
+            );
           }
         }
       }
@@ -1144,14 +1731,16 @@ module.exports = {
       if (options.images || options.all) {
         // Remove Dank images
         const images = await this.docker.listImages({
-          filters: { reference: ['dank-*'] }
+          filters: { reference: ["dank-*"] },
         });
 
         for (const imageInfo of images) {
           const image = this.docker.getImage(imageInfo.Id);
           try {
             await image.remove();
-            this.logger.info(`Removed image: ${imageInfo.RepoTags?.[0] || imageInfo.Id}`);
+            this.logger.info(
+              `Removed image: ${imageInfo.RepoTags?.[0] || imageInfo.Id}`
+            );
           } catch (error) {
             this.logger.warn(`Failed to remove image: ${error.message}`);
           }
@@ -1163,8 +1752,7 @@ module.exports = {
         await this.cleanupBuildContexts();
       }
 
-      this.logger.info('Cleanup completed');
-
+      this.logger.info("Cleanup completed");
     } catch (error) {
       throw new Error(`Cleanup failed: ${error.message}`);
     }
@@ -1174,13 +1762,15 @@ module.exports = {
    * Clean up build context directories and tarballs
    */
   async cleanupBuildContexts() {
-    const projectRoot = path.join(__dirname, '../..');
-    
+    const projectRoot = path.join(__dirname, "../..");
+
     try {
       // Find all build context directories
       const entries = await fs.readdir(projectRoot);
-      const buildContextDirs = entries.filter(entry => entry.startsWith('.build-context-'));
-      
+      const buildContextDirs = entries.filter((entry) =>
+        entry.startsWith(".build-context-")
+      );
+
       // Remove build context directories
       for (const dir of buildContextDirs) {
         const dirPath = path.join(projectRoot, dir);
@@ -1188,29 +1778,33 @@ module.exports = {
           await fs.remove(dirPath);
           this.logger.info(`Removed build context directory: ${dir}`);
         } catch (error) {
-          this.logger.warn(`Failed to remove build context directory ${dir}: ${error.message}`);
+          this.logger.warn(
+            `Failed to remove build context directory ${dir}: ${error.message}`
+          );
         }
       }
-      
+
       // Find and remove tarball files
-      const tarballs = entries.filter(entry => 
-        entry.endsWith('-context.tar') || entry.endsWith('-build-context.tar')
+      const tarballs = entries.filter(
+        (entry) =>
+          entry.endsWith("-context.tar") || entry.endsWith("-build-context.tar")
       );
-      
+
       for (const tarball of tarballs) {
         const tarballPath = path.join(projectRoot, tarball);
         try {
           await fs.remove(tarballPath);
           this.logger.info(`Removed build context tarball: ${tarball}`);
         } catch (error) {
-          this.logger.warn(`Failed to remove tarball ${tarball}: ${error.message}`);
+          this.logger.warn(
+            `Failed to remove tarball ${tarball}: ${error.message}`
+          );
         }
       }
-      
+
       if (buildContextDirs.length === 0 && tarballs.length === 0) {
-        this.logger.info('No build context files found to clean up');
+        this.logger.info("No build context files found to clean up");
       }
-      
     } catch (error) {
       this.logger.warn(`Error during build context cleanup: ${error.message}`);
     }