dank-ai 1.0.25 → 1.0.28

package/README.md

@@ -169,6 +169,8 @@ dank build:prod --push             # Build and push to registry (CLI only)
 dank build:prod --tag v1.0.0       # Build with custom tag
 dank build:prod --registry ghcr.io # Build for specific registry
 dank build:prod --force            # Force rebuild without cache
+dank build:prod --output-metadata deployment.json  # Generate deployment metadata
+dank build:prod --json             # Output JSON summary to stdout
 ```
 
 > **💡 Push Control**: The `--push` option is the only way to push images to registries. Agent configuration defines naming, CLI controls pushing.
@@ -190,6 +192,8 @@ dank build:prod --registry ghcr.io         # Build for GitHub Container Registry
 dank build:prod --namespace mycompany      # Build with custom namespace
 dank build:prod --tag-by-agent             # Use agent name as tag (common repo)
 dank build:prod --force                    # Force rebuild without cache
+dank build:prod --output-metadata <file>   # Output deployment metadata JSON
+dank build:prod --json                     # Output machine-readable JSON summary
 ```
 
 ## 🤖 Agent Configuration
@@ -719,6 +723,93 @@ dank build:prod --force --push
 dank build:prod --tag release-2024.1 --push
 ```
 
+**Deployment Metadata Output:**
+```bash
+# Generate deployment metadata JSON file
+dank build:prod --output-metadata deployment.json
+
+# Build, push, and generate metadata
+dank build:prod --push --output-metadata deployment.json
+
+# Use with custom configuration
+dank build:prod --config production.config.js --output-metadata deployment.json
+```
+
+The `--output-metadata` option generates a JSON file containing all deployment information needed for your backend infrastructure:
+- **Base image** used (`setBaseImage()` value)
+- **Prompting server** configuration (protocol, port, authentication, maxConnections)
+- **Resource limits** (memory, CPU, timeout)
+- **Ports** that need to be opened
+- **Features enabled** (direct prompting, HTTP API, event handlers)
+- **HTTP server** configuration (if enabled)
+- **LLM provider** and model information
+- **Event handlers** registered
+- **Environment variables** required
+- **Build options** (registry, namespace, tag, image name)
+
+This metadata file is perfect for CI/CD pipelines to automatically configure your deployment infrastructure, determine which ports to open, and which features to enable/disable.
+
+**Example Metadata Output:**
+```json
+{
+  "project": "my-agent-project",
+  "buildTimestamp": "2024-01-15T10:30:00.000Z",
+  "agents": [
+    {
+      "name": "customer-service",
+      "imageName": "ghcr.io/mycompany/customer-service:v1.2.0",
+      "baseImage": {
+        "full": "deltadarkly/dank-agent-base:nodejs-20",
+        "tag": "nodejs-20"
+      },
+      "promptingServer": {
+        "protocol": "http",
+        "port": 3000,
+        "authentication": false,
+        "maxConnections": 50,
+        "timeout": 30000
+      },
+      "resources": {
+        "memory": "512m",
+        "cpu": 1,
+        "timeout": 30000
+      },
+      "ports": [
+        {
+          "port": 3000,
+          "protocol": "http",
+          "description": "Direct prompting server"
+        }
+      ],
+      "features": {
+        "directPrompting": true,
+        "httpApi": false,
+        "eventHandlers": true
+      },
+      "llm": {
+        "provider": "openai",
+        "model": "gpt-3.5-turbo",
+        "temperature": 0.7,
+        "maxTokens": 1000
+      },
+      "handlers": ["request_output", "request_output:start"],
+      "buildOptions": {
+        "registry": "ghcr.io",
+        "namespace": "mycompany",
+        "tag": "v1.2.0",
+        "tagByAgent": false
+      }
+    }
+  ],
+  "summary": {
+    "total": 1,
+    "successful": 1,
+    "failed": 0,
+    "pushed": 1
+  }
+}
+```
+
 #### 🏷️ **Image Naming Convention**
 
 **Default (Per-Agent Repository):**

package/bin/dank

@@ -90,6 +90,8 @@ program
   .option('--registry <registry>', 'Docker registry URL (e.g., docker.io, ghcr.io)')
   .option('--namespace <namespace>', 'Docker namespace/organization')
   .option('--tag-by-agent', 'Use agent name as the image tag (common image name)')
+  .option('--json', 'Output machine-readable JSON summary to stdout')
+  .option('--output-metadata <file>', 'Output deployment metadata JSON file')
   .option('--force', 'Force rebuild without cache')
   .action(async (options) => {
     const { productionBuildCommand } = require('../lib/cli/production-build');

package/lib/cli/production-build.js

@@ -8,6 +8,116 @@ const chalk = require('chalk');
 const { DockerManager } = require('../docker/manager');
 const analytics = require('../analytics');
 
+/**
+ * Extract deployment metadata from an agent configuration
+ */
+function extractAgentMetadata(agent, buildOptions, imageName) {
+  const config = agent.config || {};
+  const dockerConfig = config.docker || {};
+  const resources = config.resources || {};
+  const communication = config.communication || {};
+  const directPrompting = communication.directPrompting || {};
+  const httpConfig = config.http || {};
+  const llmConfig = config.llm || {};
+
+  // Extract base image tag (remove prefix)
+  // setBaseImage() sets docker.baseImage to "deltadarkly/dank-agent-base:tag"
+  const baseImage = dockerConfig.baseImage || '';
+  let baseImageTag = '';
+  if (baseImage.includes(':')) {
+    baseImageTag = baseImage.split(':').slice(1).join(':'); // Handle tags with colons
+  } else if (baseImage) {
+    baseImageTag = baseImage;
+  }
+
+  // Extract prompting server configuration
+  const promptingServer = directPrompting.enabled ? {
+    protocol: directPrompting.protocol || 'http',
+    port: dockerConfig.port || 3000,
+    authentication: directPrompting.authentication || false,
+    maxConnections: directPrompting.maxConnections || 50,
+    timeout: directPrompting.timeout || 30000
+  } : null;
+
+  // Extract resources configuration
+  const resourcesConfig = {
+    memory: resources.memory || '512m',
+    cpu: resources.cpu || 1,
+    timeout: resources.timeout || 30000
+  };
+
+  // Extract HTTP server configuration if enabled
+  const httpServer = httpConfig.enabled ? {
+    port: httpConfig.port || 3000,
+    host: httpConfig.host || '0.0.0.0',
+    cors: httpConfig.cors !== false,
+    routes: httpConfig.routes ? Array.from(httpConfig.routes.keys()).map(routeKey => {
+      const [method, path] = routeKey.split(':');
+      return { method, path };
+    }) : []
+  } : null;
+
+  // Extract handler information
+  const handlers = agent.handlers ? Array.from(agent.handlers.keys()) : [];
+
+  // Extract LLM configuration (without sensitive data)
+  const llm = llmConfig.provider ? {
+    provider: llmConfig.provider,
+    model: llmConfig.model || 'gpt-3.5-turbo',
+    temperature: llmConfig.temperature || 0.7,
+    maxTokens: llmConfig.maxTokens || 1000,
+    baseURL: llmConfig.baseURL || null
+  } : null;
+
+  // Collect ports that need to be opened
+  const ports = [];
+  if (promptingServer) {
+    ports.push({
+      port: promptingServer.port,
+      protocol: promptingServer.protocol,
+      description: 'Direct prompting server'
+    });
+  }
+  if (httpServer) {
+    ports.push({
+      port: httpServer.port,
+      protocol: 'http',
+      description: 'HTTP API server'
+    });
+  }
+
+  // Determine features enabled
+  const features = {
+    directPrompting: directPrompting.enabled || false,
+    httpApi: communication.httpApi?.enabled || httpConfig.enabled || false,
+    eventHandlers: communication.eventHandlers?.enabled || handlers.length > 0 || false
+  };
+
+  return {
+    name: agent.name,
+    imageName: imageName,
+    baseImage: {
+      full: baseImage,
+      tag: baseImageTag
+    },
+    buildOptions: {
+      registry: buildOptions.registry || null,
+      namespace: buildOptions.namespace || null,
+      tag: buildOptions.tag || 'latest',
+      tagByAgent: buildOptions.tagByAgent || false
+    },
+    promptingServer: promptingServer,
+    resources: resourcesConfig,
+    httpServer: httpServer,
+    ports: ports,
+    features: features,
+    llm: llm,
+    handlers: handlers,
+    hasPrompt: !!config.prompt,
+    environment: config.environment || {}
+  };
+}
+
 async function productionBuildCommand(options) {
   // Track production build command
   await analytics.trackCommand('build:prod', true, {
@@ -35,6 +145,8 @@ async function productionBuildCommand(options) {
 
     // Build production images for each agent
     const buildResults = [];
+    const metadata = [];
+    
     for (const agent of config.agents) {
       try {
         console.log(chalk.blue(`📦 Building production image for agent: ${agent.name}`));
@@ -67,6 +179,10 @@ async function productionBuildCommand(options) {
           pushed: result.pushed || false
         });
 
+        // Extract deployment metadata for successfully built agents
+        const agentMetadata = extractAgentMetadata(agent, buildOptions, result.imageName);
+        metadata.push(agentMetadata);
+
         console.log(chalk.green(`✅ Successfully built: ${result.imageName}`));
         if (result.pushed) {
           console.log(chalk.green(`🚀 Successfully pushed: ${result.imageName}`));
@@ -82,41 +198,71 @@ async function productionBuildCommand(options) {
       }
     }
 
-    // Print summary
-    console.log(chalk.yellow('\n📊 Build Summary:'));
-    console.log(chalk.gray('================'));
-    
-    const successful = buildResults.filter(r => r.success);
-    const failed = buildResults.filter(r => !r.success);
-    const pushed = buildResults.filter(r => r.pushed);
-
-    console.log(chalk.green(`✅ Successful builds: ${successful.length}`));
-    if (pushed.length > 0) {
-      console.log(chalk.blue(`🚀 Pushed to registry: ${pushed.length}`));
-    }
-    if (failed.length > 0) {
-      console.log(chalk.red(`❌ Failed builds: ${failed.length}`));
+    // Output metadata file if requested
+    if (options.outputMetadata) {
+      const metadataPath = path.resolve(options.outputMetadata);
+      const metadataOutput = {
+        project: config.name,
+        buildTimestamp: new Date().toISOString(),
+        agents: metadata,
+        summary: {
+          total: metadata.length,
+          successful: buildResults.filter(r => r.success).length,
+          failed: buildResults.filter(r => !r.success).length,
+          pushed: buildResults.filter(r => r.pushed).length
+        }
+      };
+      
+      await fs.writeJson(metadataPath, metadataOutput, { spaces: 2 });
+      console.log(chalk.cyan(`\n📄 Deployment metadata saved to: ${metadataPath}`));
     }
 
-    // List built images
-    if (successful.length > 0) {
-      console.log(chalk.cyan('\n📦 Built Images:'));
-      successful.forEach(result => {
-        console.log(chalk.gray(`  - ${result.imageName}`));
-      });
-    }
+    // Output
+    if (options.json) {
+      const payload = {
+        success: buildResults.every(r => r.success),
+        results: buildResults
+      };
+      // Always print JSON to stdout for machine consumption
+      console.log(JSON.stringify(payload));
+      process.exit(payload.success ? 0 : 1);
+    } else {
+      // Human summary
+      console.log(chalk.yellow('\n📊 Build Summary:'));
+      console.log(chalk.gray('================'));
+      
+      const successful = buildResults.filter(r => r.success);
+      const failed = buildResults.filter(r => !r.success);
+      const pushed = buildResults.filter(r => r.pushed);
 
-    // List failed builds
-    if (failed.length > 0) {
-      console.log(chalk.red('\n❌ Failed Builds:'));
-      failed.forEach(result => {
-        console.log(chalk.gray(`  - ${result.agent}: ${result.error}`));
-      });
-      process.exit(1);
-    }
+      console.log(chalk.green(`✅ Successful builds: ${successful.length}`));
+      if (pushed.length > 0) {
+        console.log(chalk.blue(`🚀 Pushed to registry: ${pushed.length}`));
+      }
+      if (failed.length > 0) {
+        console.log(chalk.red(`❌ Failed builds: ${failed.length}`));
+      }
+
+      // List built images
+      if (successful.length > 0) {
+        console.log(chalk.cyan('\n📦 Built Images:'));
+        successful.forEach(result => {
+          console.log(chalk.gray(`  - ${result.imageName}`));
+        });
+      }
 
-    console.log(chalk.green('\n🎉 Production build completed successfully!'));
-    process.exit(0);
+      // List failed builds
+      if (failed.length > 0) {
+        console.log(chalk.red('\n❌ Failed Builds:'));
+        failed.forEach(result => {
+          console.log(chalk.gray(`  - ${result.agent}: ${result.error}`));
+        });
+        process.exit(1);
+      }
+
+      console.log(chalk.green('\n🎉 Production build completed successfully!'));
+      process.exit(0);
+    }
 
   } catch (error) {
     console.error(chalk.red('❌ Production build failed:'), error.message);

package/lib/docker/manager.js

@@ -23,6 +23,26 @@ const analytics = require("../analytics");
 const execAsync = promisify(exec);
 
 class DockerManager {
+  /**
+   * Resolve docker executable path
+   */
+  async resolveDockerCommand() {
+    const dockerPaths = [
+      "/usr/local/bin/docker",
+      "/opt/homebrew/bin/docker",
+      "/usr/bin/docker",
+      "docker",
+    ];
+    for (const path of dockerPaths) {
+      try {
+        await execAsync(`${path} --version`);
+        return path;
+      } catch (_) {
+        // continue
+      }
+    }
+    throw new Error("Docker executable not found in expected locations");
+  }
   constructor(options = {}) {
     this.docker = new Docker(options.dockerOptions || {});
     this.logger =
@@ -1129,14 +1149,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,
-      });
-
-      await this.followBuildProgress(stream, `Agent ${agent.name} build`);
+      const dockerCmd = await this.resolveDockerCommand();
+
+      const buildCommand = [
+        dockerCmd,
+        'buildx',
+        'build',
+        '--platform', 'linux/amd64,linux/arm64',
+        '--tag', imageName,
+        '--file', path.join(buildContext, 'Dockerfile'),
+        '--load',
+        ...(options.rebuild || options.noCache ? ['--no-cache'] : []),
+        buildContext
+      ].join(' ');
+
+      await this.runCommand(buildCommand, `Agent ${agent.name} build`);
 
       this.logger.info(`Agent image '${imageName}' built successfully`);
 
@@ -1172,25 +1199,21 @@ class DockerManager {
       return sanitized;
     };
 
-    // Base repository name logic
+    //construct full repo name
     let repoName;
-    if (tagByAgent) {
-      // Use a common repository only when no namespace is provided
-      // Otherwise, fall back to per-agent repository name
-      repoName = namespace ? agent.name.toLowerCase() : 'dank-agent';
-    } else {
-      // Default: per-agent repository name
-      repoName = agent.name.toLowerCase();
+    if(!tagByAgent){
+   
+      repoName = `${registry?`${registry}/`:''}${namespace?`${namespace}/`:''}${repoName}`;
+    }else{
+      repoName = `${registry?`${registry}/`:''}${namespace?`${namespace}/`:''}`;
     }
+    
+    repoName = repoName.replace(/\/+$/, '');
 
-    // Compose full repository path
-    let fullRepo = repoName;
-    if (namespace) fullRepo = `${namespace}/${fullRepo}`;
-    if (registry) fullRepo = `${registry}/${fullRepo}`;
 
     // Final tag selection
     const finalTag = tagByAgent ? normalizeTag(agent.name) : tag;
-    const imageName = `${fullRepo}:${finalTag}`;
+    const imageName = `${repoName}:${finalTag}`;
 
     this.logger.info(
       `Building production image for agent: ${agent.name} -> ${imageName}`
@@ -1198,17 +1221,21 @@ class DockerManager {
 
     try {
       const buildContext = await this.createAgentBuildContext(agent);
-
-      const stream = await this.docker.buildImage(buildContext, {
-        t: imageName,
-        dockerfile: "Dockerfile",
-        nocache: force,
-      });
-
-      await this.followBuildProgress(
-        stream,
-        `Production build for ${agent.name}`
-      );
+      const dockerCmd = await this.resolveDockerCommand();
+
+      const buildCommand = [
+        dockerCmd,
+        'buildx',
+        'build',
+        '--platform', 'linux/amd64,linux/arm64',
+        '--tag', imageName,
+        '--file', path.join(buildContext, 'Dockerfile'),
+        '--load',
+        ...(force ? ['--no-cache'] : []),
+        buildContext
+      ].join(' ');
+
+      await this.runCommand(buildCommand, `Production build for ${agent.name}`);
 
       this.logger.info(`Production image '${imageName}' built successfully`);
 
@@ -1217,19 +1244,29 @@ class DockerManager {
 
       let pushed = false;
 
-      // Push to registry if requested
+      // Push to registry if requested (use docker CLI for reliability)
       if (push) {
-        try {
-          this.logger.info(`Pushing image to registry: ${imageName}`);
-          const pushStream = await this.docker.getImage(imageName).push();
-          await this.followBuildProgress(pushStream, `Push ${imageName}`);
-          this.logger.info(`Successfully pushed image: ${imageName}`);
-          pushed = true;
-        } catch (pushError) {
-          this.logger.warn(
-            `Failed to push image ${imageName}: ${pushError.message}`
-          );
-          // Don't fail the build if push fails
+        const dockerCmd = await this.resolveDockerCommand();
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+          try {
+            this.logger.info(`Pushing image to registry (attempt ${attempt}/${maxAttempts}): ${imageName}`);
+            await this.runCommand(`${dockerCmd} push ${imageName}`, `Docker push ${imageName}`);
+            this.logger.info(`Successfully pushed image: ${imageName}`);
+            pushed = true;
+            break;
+          } catch (pushError) {
+            const msg = pushError?.message || '';
+            this.logger.warn(`Push attempt ${attempt} failed: ${msg}`);
+            if (msg.match(/denied|unauthorized|authentication required/i)) {
+              this.logger.warn("Authentication issue detected. Please ensure you're logged in: docker login <registry>");
+              break; // don't retry auth failures automatically
+            }
+            if (attempt < maxAttempts) {
+              await this.sleep(2000 * attempt);
+              continue;
+            }
+          }
         }
       }
 

package/package.json

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