@aifabrix/builder 2.0.2 → 2.0.3

package/README.md

@@ -1,9 +1,7 @@
-# 🧱 @aifabrix/builder
-
-[![npm version](https://img.shields.io/npm/v/%40aifabrix%2Fbuilder.svg)](https://www.npmjs.com/package/%40aifabrix%2Fbuilder)
+# AI Fabrix - Builder SDK
 
+[![npm version](https://img.shields.io/npm/v/@aifabrix/builder.svg)](https://www.npmjs.com/package/@aifabrix/builder)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
 Local development infrastructure + Azure deployment tool.
 
 ## Install

package/lib/app-run.js

@@ -15,7 +15,6 @@ const path = require('path');
 const net = require('net');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
-const handlebars = require('handlebars');
 const { exec } = require('child_process');
 const { promisify } = require('util');
 const validator = require('./validator');
@@ -23,6 +22,7 @@ const infra = require('./infra');
 const secrets = require('./secrets');
 const logger = require('./utils/logger');
 const { waitForHealthCheck } = require('./utils/health-check');
+const composeGenerator = require('./utils/compose-generator');
 
 const execAsync = promisify(exec);
 
@@ -89,22 +89,6 @@ async function checkPortAvailable(port) {
   });
 }
 
-/**
- * Loads and compiles Docker Compose template
- * @param {string} language - Language type
- * @returns {Function} Compiled Handlebars template
- * @throws {Error} If template not found
- */
-function loadDockerComposeTemplate(language) {
-  const templatePath = path.join(__dirname, '..', 'templates', language, 'docker-compose.hbs');
-  if (!fsSync.existsSync(templatePath)) {
-    throw new Error(`Docker Compose template not found for language: ${language}`);
-  }
-
-  const templateContent = fsSync.readFileSync(templatePath, 'utf8');
-  return handlebars.compile(templateContent);
-}
-
 /**
  * Extracts image name from configuration (same logic as build.js)
  * @param {Object} config - Application configuration
@@ -112,146 +96,7 @@ function loadDockerComposeTemplate(language) {
  * @returns {string} Image name
  */
 function getImageName(config, appName) {
-  if (typeof config.image === 'string') {
-    return config.image.split(':')[0];
-  } else if (config.image?.name) {
-    return config.image.name;
-  } else if (config.app?.key) {
-    return config.app.key;
-  }
-  return appName;
-}
-
-/**
- * Builds app configuration section
- * @param {string} appName - Application name
- * @param {Object} config - Application configuration
- * @returns {Object} App configuration
- */
-function buildAppConfig(appName, config) {
-  return {
-    key: appName,
-    name: config.displayName || appName
-  };
-}
-
-/**
- * Builds image configuration section
- * @param {Object} config - Application configuration
- * @param {string} appName - Application name
- * @returns {Object} Image configuration
- */
-function buildImageConfig(config, appName) {
-  const imageName = getImageName(config, appName);
-  const imageTag = config.image?.tag || 'latest';
-  return {
-    name: imageName,
-    tag: imageTag
-  };
-}
-
-/**
- * Builds health check configuration section
- * @param {Object} config - Application configuration
- * @returns {Object} Health check configuration
- */
-function buildHealthCheckConfig(config) {
-  return {
-    path: config.healthCheck?.path || '/health',
-    interval: config.healthCheck?.interval || 30
-  };
-}
-
-/**
- * Builds requires configuration section
- * @param {Object} config - Application configuration
- * @returns {Object} Requires configuration
- */
-function buildRequiresConfig(config) {
-  return {
-    requiresDatabase: config.requires?.database || config.services?.database || false,
-    requiresStorage: config.requires?.storage || config.services?.storage || false,
-    requiresRedis: config.requires?.redis || config.services?.redis || false
-  };
-}
-
-/**
- * Builds service configuration for template data
- * @param {string} appName - Application name
- * @param {Object} config - Application configuration
- * @param {number} port - Application port
- * @returns {Object} Service configuration
- */
-function buildServiceConfig(appName, config, port) {
-  const containerPort = config.build?.containerPort || config.port || 3000;
-
-  return {
-    app: buildAppConfig(appName, config),
-    image: buildImageConfig(config, appName),
-    port: containerPort,
-    build: {
-      localPort: port
-    },
-    healthCheck: buildHealthCheckConfig(config),
-    ...buildRequiresConfig(config)
-  };
-}
-
-/**
- * Builds volumes configuration for template data
- * @param {string} appName - Application name
- * @returns {Object} Volumes configuration
- */
-function buildVolumesConfig(appName) {
-  // Use forward slashes for Docker paths (works on both Windows and Unix)
-  const volumePath = path.join(process.cwd(), 'data', appName);
-  return {
-    mountVolume: volumePath.replace(/\\/g, '/')
-  };
-}
-
-/**
- * Builds networks configuration for template data
- * @param {Object} config - Application configuration
- * @returns {Object} Networks configuration
- */
-function buildNetworksConfig(config) {
-  // Get databases from requires.databases or top-level databases
-  const databases = config.requires?.databases || config.databases || [];
-  return {
-    databases: databases
-  };
-}
-
-/**
- * Generates Docker Compose configuration from template
- * @param {string} appName - Application name
- * @param {Object} config - Application configuration
- * @param {Object} options - Run options
- * @returns {Promise<string>} Generated compose content
- */
-async function generateDockerCompose(appName, config, options) {
-  const language = config.build?.language || config.language || 'typescript';
-  const template = loadDockerComposeTemplate(language);
-
-  const port = options.port || config.build?.localPort || config.port || 3000;
-
-  const serviceConfig = buildServiceConfig(appName, config, port);
-  const volumesConfig = buildVolumesConfig(appName);
-  const networksConfig = buildNetworksConfig(config);
-
-  // Get absolute path to .env file for docker-compose
-  const envFilePath = path.join(process.cwd(), 'builder', appName, '.env');
-  const envFileAbsolutePath = envFilePath.replace(/\\/g, '/'); // Use forward slashes for Docker
-
-  const templateData = {
-    ...serviceConfig,
-    ...volumesConfig,
-    ...networksConfig,
-    envFile: envFileAbsolutePath
-  };
-
-  return template(templateData);
+  return composeGenerator.getImageName(config, appName);
 }
 
 /**
@@ -267,10 +112,34 @@ async function validateAppConfiguration(appName) {
     throw new Error('Application name is required');
   }
 
+  // Check if we're running from inside the builder directory
+  const currentDir = process.cwd();
+  const normalizedPath = currentDir.replace(/\\/g, '/');
+  const expectedBuilderPath = `builder/${appName}`;
+
+  // If inside builder/{appName}, suggest moving to project root
+  if (normalizedPath.endsWith(expectedBuilderPath)) {
+    const projectRoot = path.resolve(currentDir, '../..');
+    throw new Error(
+      'You\'re running from inside the builder directory.\n' +
+      `Current directory: ${currentDir}\n` +
+      'Please change to the project root and try again:\n' +
+      `  cd ${projectRoot}\n` +
+      `  aifabrix run ${appName}`
+    );
+  }
+
   // Load and validate app configuration
   const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
   if (!fsSync.existsSync(configPath)) {
-    throw new Error(`Application configuration not found: ${configPath}\nRun 'aifabrix create ${appName}' first`);
+    const expectedDir = path.join(currentDir, 'builder', appName);
+    throw new Error(
+      `Application configuration not found: ${configPath}\n` +
+      `Current directory: ${currentDir}\n` +
+      `Expected location: ${expectedDir}\n` +
+      'Make sure you\'re running from the project root (where \'builder\' directory exists)\n' +
+      `Run 'aifabrix create ${appName}' first if configuration doesn't exist`
+    );
   }
 
   const configContent = fsSync.readFileSync(configPath, 'utf8');
@@ -279,7 +148,28 @@ async function validateAppConfiguration(appName) {
   // Validate configuration
   const validation = await validator.validateApplication(appName);
   if (!validation.valid) {
-    throw new Error(`Configuration validation failed:\n${validation.variables.errors.join('\n')}`);
+    const allErrors = [];
+
+    if (validation.variables && validation.variables.errors && validation.variables.errors.length > 0) {
+      allErrors.push('variables.yaml:');
+      allErrors.push(...validation.variables.errors.map(err => `  ${err}`));
+    }
+
+    if (validation.rbac && validation.rbac.errors && validation.rbac.errors.length > 0) {
+      allErrors.push('rbac.yaml:');
+      allErrors.push(...validation.rbac.errors.map(err => `  ${err}`));
+    }
+
+    if (validation.env && validation.env.errors && validation.env.errors.length > 0) {
+      allErrors.push('env.template:');
+      allErrors.push(...validation.env.errors.map(err => `  ${err}`));
+    }
+
+    if (allErrors.length === 0) {
+      throw new Error('Configuration validation failed');
+    }
+
+    throw new Error(`Configuration validation failed:\n${allErrors.join('\n')}`);
   }
 
   return config;
@@ -354,7 +244,7 @@ async function prepareEnvironment(appName, config, options) {
 
   // Generate Docker Compose configuration
   logger.log(chalk.blue('Generating Docker Compose configuration...'));
-  const composeContent = await generateDockerCompose(appName, config, options);
+  const composeContent = await composeGenerator.generateDockerCompose(appName, config, options);
   // Write compose file to temporary location
   const tempComposePath = path.join(process.cwd(), 'builder', appName, 'docker-compose.yaml');
   await fs.writeFile(tempComposePath, composeContent);
@@ -487,6 +377,6 @@ module.exports = {
   checkContainerRunning,
   stopAndRemoveContainer,
   checkPortAvailable,
-  generateDockerCompose,
+  generateDockerCompose: composeGenerator.generateDockerCompose,
   waitForHealthCheck
 };

package/lib/build.js

@@ -22,6 +22,7 @@ const secrets = require('./secrets');
 const logger = require('./utils/logger');
 const validator = require('./validator');
 const dockerfileUtils = require('./utils/dockerfile-utils');
+const dockerBuild = require('./utils/docker-build');
 
 const execAsync = promisify(exec);
 
@@ -71,66 +72,6 @@ function resolveContextPath(builderPath, contextPath) {
   return resolvedPath;
 }
 
-/**
- * Checks if error indicates Docker is not running or not installed
- * @param {string} errorMessage - Error message to check
- * @returns {boolean} True if Docker is not available
- */
-function isDockerNotAvailableError(errorMessage) {
-  return errorMessage.includes('docker: command not found') ||
-         errorMessage.includes('Cannot connect to the Docker daemon') ||
-         errorMessage.includes('Is the docker daemon running') ||
-         errorMessage.includes('Cannot connect to Docker');
-}
-
-/**
- * Handles Docker build errors and provides user-friendly messages
- * @param {Error} error - Build error
- * @throws {Error} Formatted error message
- */
-function handleBuildError(error) {
-  const errorMessage = error.message || error.stderr || String(error);
-
-  if (isDockerNotAvailableError(errorMessage)) {
-    throw new Error('Docker is not running or not installed. Please start Docker Desktop and try again.');
-  }
-
-  const detailedError = error.stderr || error.stdout || errorMessage;
-  throw new Error(`Docker build failed: ${detailedError}`);
-}
-
-/**
- * Executes Docker build command with proper error handling
- * @param {string} imageName - Image name to build
- * @param {string} dockerfilePath - Path to Dockerfile
- * @param {string} contextPath - Build context path
- * @param {string} tag - Image tag
- * @returns {Promise<void>} Resolves when build completes
- * @throws {Error} If build fails
- */
-async function executeDockerBuild(imageName, dockerfilePath, contextPath, tag) {
-  const dockerCommand = `docker build -t ${imageName}:${tag} -f "${dockerfilePath}" "${contextPath}"`;
-
-  try {
-    logger.log(chalk.blue('Building image...'));
-    logger.log(chalk.gray(`Command: ${dockerCommand}`));
-
-    const { stdout, stderr } = await execAsync(dockerCommand);
-
-    if (stderr && !stderr.includes('warning')) {
-      logger.log(chalk.yellow(stderr));
-    }
-
-    if (stdout) {
-      logger.log(stdout);
-    }
-
-    logger.log(chalk.green(`✓ Image built: ${imageName}:${tag}`));
-  } catch (error) {
-    handleBuildError(error);
-  }
-}
-
 /**
  * Detects the runtime language of an application
  * Analyzes project files to determine TypeScript, Python, etc.
@@ -317,7 +258,7 @@ async function loadAndValidateConfig(appName) {
  * @param {Object} options - Build options
  */
 async function executeBuild(imageName, dockerfilePath, contextPath, tag, options) {
-  await executeDockerBuild(imageName, dockerfilePath, contextPath, tag);
+  await dockerBuild.executeDockerBuild(imageName, dockerfilePath, contextPath, tag);
 
   // Tag image if additional tag provided
   if (options.tag && options.tag !== 'latest') {
@@ -417,7 +358,7 @@ async function buildApp(appName, options = {}) {
 module.exports = {
   loadVariablesYaml,
   resolveContextPath,
-  executeDockerBuild,
+  executeDockerBuild: dockerBuild.executeDockerBuild,
   detectLanguage,
   generateDockerfile,
   buildApp

package/lib/schema/env-config.yaml

@@ -7,9 +7,17 @@ environments:
     REDIS_HOST: redis
     MISO_HOST: miso-controller
     KEYCLOAK_HOST: keycloak
-    
+    MORI_HOST: mori-controller
+    OPENWEBUI_HOST: openwebui
+    FLOWISE_HOST: flowise
+    DATAPLANE_HOST: dataplane
+
   local:
     DB_HOST: localhost
     REDIS_HOST: localhost
     MISO_HOST: localhost
     KEYCLOAK_HOST: localhost
+    MORI_HOST: localhost
+    OPENWEBUI_HOST: localhost
+    FLOWISE_HOST: localhost
+    DATAPLANE_HOST: localhost

package/lib/utils/compose-generator.js

@@ -0,0 +1,185 @@
+/**
+ * Docker Compose Generation Utilities
+ *
+ * This module handles Docker Compose configuration generation for application running.
+ * Separated from app-run.js to maintain file size limits.
+ *
+ * @fileoverview Docker Compose generation utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fsSync = require('fs');
+const path = require('path');
+const handlebars = require('handlebars');
+
+/**
+ * Loads and compiles Docker Compose template
+ * @param {string} language - Language type
+ * @returns {Function} Compiled Handlebars template
+ * @throws {Error} If template not found
+ */
+function loadDockerComposeTemplate(language) {
+  const templatePath = path.join(__dirname, '..', '..', 'templates', language, 'docker-compose.hbs');
+  if (!fsSync.existsSync(templatePath)) {
+    throw new Error(`Docker Compose template not found for language: ${language}`);
+  }
+
+  const templateContent = fsSync.readFileSync(templatePath, 'utf8');
+  return handlebars.compile(templateContent);
+}
+
+/**
+ * Extracts image name from configuration (same logic as build.js)
+ * @param {Object} config - Application configuration
+ * @param {string} appName - Application name (fallback)
+ * @returns {string} Image name
+ */
+function getImageName(config, appName) {
+  if (typeof config.image === 'string') {
+    return config.image.split(':')[0];
+  } else if (config.image?.name) {
+    return config.image.name;
+  } else if (config.app?.key) {
+    return config.app.key;
+  }
+  return appName;
+}
+
+/**
+ * Builds app configuration section
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @returns {Object} App configuration
+ */
+function buildAppConfig(appName, config) {
+  return {
+    key: appName,
+    name: config.displayName || appName
+  };
+}
+
+/**
+ * Builds image configuration section
+ * @param {Object} config - Application configuration
+ * @param {string} appName - Application name
+ * @returns {Object} Image configuration
+ */
+function buildImageConfig(config, appName) {
+  const imageName = getImageName(config, appName);
+  const imageTag = config.image?.tag || 'latest';
+  return {
+    name: imageName,
+    tag: imageTag
+  };
+}
+
+/**
+ * Builds health check configuration section
+ * @param {Object} config - Application configuration
+ * @returns {Object} Health check configuration
+ */
+function buildHealthCheckConfig(config) {
+  return {
+    path: config.healthCheck?.path || '/health',
+    interval: config.healthCheck?.interval || 30
+  };
+}
+
+/**
+ * Builds requires configuration section
+ * @param {Object} config - Application configuration
+ * @returns {Object} Requires configuration
+ */
+function buildRequiresConfig(config) {
+  return {
+    requiresDatabase: config.requires?.database || config.services?.database || false,
+    requiresStorage: config.requires?.storage || config.services?.storage || false,
+    requiresRedis: config.requires?.redis || config.services?.redis || false
+  };
+}
+
+/**
+ * Builds service configuration for template data
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @param {number} port - Application port
+ * @returns {Object} Service configuration
+ */
+function buildServiceConfig(appName, config, port) {
+  const containerPort = config.build?.containerPort || config.port || 3000;
+
+  return {
+    app: buildAppConfig(appName, config),
+    image: buildImageConfig(config, appName),
+    port: containerPort,
+    build: {
+      localPort: port
+    },
+    healthCheck: buildHealthCheckConfig(config),
+    ...buildRequiresConfig(config)
+  };
+}
+
+/**
+ * Builds volumes configuration for template data
+ * @param {string} appName - Application name
+ * @returns {Object} Volumes configuration
+ */
+function buildVolumesConfig(appName) {
+  // Use forward slashes for Docker paths (works on both Windows and Unix)
+  const volumePath = path.join(process.cwd(), 'data', appName);
+  return {
+    mountVolume: volumePath.replace(/\\/g, '/')
+  };
+}
+
+/**
+ * Builds networks configuration for template data
+ * @param {Object} config - Application configuration
+ * @returns {Object} Networks configuration
+ */
+function buildNetworksConfig(config) {
+  // Get databases from requires.databases or top-level databases
+  const databases = config.requires?.databases || config.databases || [];
+  return {
+    databases: databases
+  };
+}
+
+/**
+ * Generates Docker Compose configuration from template
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @param {Object} options - Run options
+ * @returns {Promise<string>} Generated compose content
+ */
+async function generateDockerCompose(appName, config, options) {
+  const language = config.build?.language || config.language || 'typescript';
+  const template = loadDockerComposeTemplate(language);
+
+  const port = options.port || config.build?.localPort || config.port || 3000;
+
+  const serviceConfig = buildServiceConfig(appName, config, port);
+  const volumesConfig = buildVolumesConfig(appName);
+  const networksConfig = buildNetworksConfig(config);
+
+  // Get absolute path to .env file for docker-compose
+  const envFilePath = path.join(process.cwd(), 'builder', appName, '.env');
+  const envFileAbsolutePath = envFilePath.replace(/\\/g, '/'); // Use forward slashes for Docker
+
+  const templateData = {
+    ...serviceConfig,
+    ...volumesConfig,
+    ...networksConfig,
+    envFile: envFileAbsolutePath
+  };
+
+  return template(templateData);
+}
+
+module.exports = {
+  generateDockerCompose,
+  getImageName
+};
+

package/lib/utils/docker-build.js

@@ -0,0 +1,173 @@
+/**
+ * Docker Build Utilities
+ *
+ * This module handles Docker image building with progress indicators.
+ * Separated from build.js to maintain file size limits.
+ *
+ * @fileoverview Docker build execution utilities
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { spawn } = require('child_process');
+const ora = require('ora');
+
+/**
+ * Checks if error indicates Docker is not running or not installed
+ * @param {string} errorMessage - Error message to check
+ * @returns {boolean} True if Docker is not available
+ */
+function isDockerNotAvailableError(errorMessage) {
+  return errorMessage.includes('docker: command not found') ||
+         errorMessage.includes('Cannot connect to the Docker daemon') ||
+         errorMessage.includes('Is the docker daemon running') ||
+         errorMessage.includes('Cannot connect to Docker');
+}
+
+/**
+ * Parses Docker build output to extract progress information
+ * @param {string} line - Single line of Docker build output
+ * @returns {string|null} Progress message or null if no progress info
+ */
+function parseDockerBuildProgress(line) {
+  // Match step progress: "Step 1/10 : FROM node:20-alpine"
+  const stepMatch = line.match(/^Step\s+(\d+)\/(\d+)\s*:/i);
+  if (stepMatch) {
+    return `Step ${stepMatch[1]}/${stepMatch[2]}`;
+  }
+
+  // Match layer pulling: "Pulling from library/node"
+  const pullingMatch = line.match(/^Pulling\s+(.+)$/i);
+  if (pullingMatch) {
+    return `Pulling ${pullingMatch[1]}`;
+  }
+
+  // Match layer extracting: "Extracting [====>     ]"
+  const extractingMatch = line.match(/^Extracting/i);
+  if (extractingMatch) {
+    return 'Extracting layers';
+  }
+
+  // Match build progress: " => [internal] load build context"
+  const buildMatch = line.match(/^=>\s*\[(.*?)\]\s*(.+)$/i);
+  if (buildMatch) {
+    return buildMatch[2].substring(0, 50);
+  }
+
+  // Match progress bars: "[====>     ] 10.5MB/50MB"
+  const progressMatch = line.match(/\[.*?\]\s+([\d.]+(MB|KB|GB))\/([\d.]+(MB|KB|GB))/i);
+  if (progressMatch) {
+    return `${progressMatch[1]}/${progressMatch[3]}`;
+  }
+
+  return null;
+}
+
+/**
+ * Executes Docker build command with progress indicator
+ * @param {string} imageName - Image name to build
+ * @param {string} dockerfilePath - Path to Dockerfile
+ * @param {string} contextPath - Build context path
+ * @param {string} tag - Image tag
+ * @returns {Promise<void>} Resolves when build completes
+ * @throws {Error} If build fails
+ */
+async function executeDockerBuild(imageName, dockerfilePath, contextPath, tag) {
+  const spinner = ora({
+    text: 'Starting Docker build...',
+    spinner: 'dots'
+  }).start();
+
+  return new Promise((resolve, reject) => {
+    // Use spawn for streaming output
+    const dockerProcess = spawn('docker', [
+      'build',
+      '-t', `${imageName}:${tag}`,
+      '-f', dockerfilePath,
+      contextPath
+    ], {
+      shell: process.platform === 'win32'
+    });
+
+    let stdoutBuffer = '';
+    let stderrBuffer = '';
+    let lastProgressUpdate = Date.now();
+
+    dockerProcess.stdout.on('data', (data) => {
+      const output = data.toString();
+      stdoutBuffer += output;
+
+      // Parse progress from output lines
+      const lines = output.split('\n');
+      for (const line of lines) {
+        const progress = parseDockerBuildProgress(line.trim());
+        if (progress) {
+          // Update spinner text with progress (throttle updates)
+          const now = Date.now();
+          if (now - lastProgressUpdate > 200) {
+            spinner.text = `Building image... ${progress}`;
+            lastProgressUpdate = now;
+          }
+        }
+      }
+    });
+
+    dockerProcess.stderr.on('data', (data) => {
+      const output = data.toString();
+      stderrBuffer += output;
+
+      // Check for warnings vs errors
+      if (!output.toLowerCase().includes('warning')) {
+        // Parse progress from stderr too (Docker outputs progress to stderr)
+        const lines = output.split('\n');
+        for (const line of lines) {
+          const progress = parseDockerBuildProgress(line.trim());
+          if (progress) {
+            const now = Date.now();
+            if (now - lastProgressUpdate > 200) {
+              spinner.text = `Building image... ${progress}`;
+              lastProgressUpdate = now;
+            }
+          }
+        }
+      }
+    });
+
+    dockerProcess.on('close', (code) => {
+      if (code === 0) {
+        spinner.succeed(`Image built: ${imageName}:${tag}`);
+        resolve();
+      } else {
+        spinner.fail('Build failed');
+
+        const errorMessage = stderrBuffer || stdoutBuffer || 'Docker build failed';
+
+        if (isDockerNotAvailableError(errorMessage)) {
+          reject(new Error('Docker is not running or not installed. Please start Docker Desktop and try again.'));
+        } else {
+          // Show last few lines of error output
+          const errorLines = errorMessage.split('\n').filter(line => line.trim());
+          const lastError = errorLines.slice(-5).join('\n');
+          reject(new Error(`Docker build failed: ${lastError}`));
+        }
+      }
+    });
+
+    dockerProcess.on('error', (error) => {
+      spinner.fail('Build failed');
+      const errorMessage = error.message || String(error);
+
+      if (isDockerNotAvailableError(errorMessage)) {
+        reject(new Error('Docker is not running or not installed. Please start Docker Desktop and try again.'));
+      } else {
+        reject(new Error(`Docker build failed: ${errorMessage}`));
+      }
+    });
+  });
+}
+
+module.exports = {
+  executeDockerBuild,
+  isDockerNotAvailableError
+};
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {
@@ -18,6 +18,7 @@
     "lint:ci": "eslint . --ext .js --format json --output-file eslint-report.json",
     "dev": "node bin/aifabrix.js",
     "build": "npm run lint && npm run test:ci",
+    "pack": "npm run build && npm pack",
     "validate": "npm run build",
     "prepublishOnly": "npm run validate",
     "precommit": "npm run lint:fix && npm run test"

package/templates/applications/miso-controller/rbac.yaml

@@ -52,6 +52,53 @@ permissions:
     roles: ["aifabrix-platform-admin", "aifabrix-security-admin"]
     description: "Deactivate service users"
   
+  # User Management
+  - name: "users:create"
+    roles: ["aifabrix-platform-admin", "aifabrix-security-admin"]
+    description: "Create new users"
+  
+  - name: "users:read"
+    roles: ["aifabrix-platform-admin", "aifabrix-security-admin", "aifabrix-observer"]
+    description: "View user information and profiles"
+  
+  - name: "users:update"
+    roles: ["aifabrix-platform-admin", "aifabrix-security-admin"]
+    description: "Update user information and manage group memberships"
+  
+  - name: "users:delete"
+    roles: ["aifabrix-platform-admin", "aifabrix-security-admin"]
+    description: "Delete users"
+  
+  # Group Management
+  - name: "groups:create"
+    roles: ["aifabrix-platform-admin", "aifabrix-security-admin"]
+    description: "Create new groups"
+  
+  - name: "groups:read"
+    roles: ["aifabrix-platform-admin", "aifabrix-security-admin", "aifabrix-observer"]
+    description: "View group information and members"
+  
+  - name: "groups:update"
+    roles: ["aifabrix-platform-admin", "aifabrix-security-admin"]
+    description: "Update group information"
+  
+  - name: "groups:delete"
+    roles: ["aifabrix-platform-admin", "aifabrix-security-admin"]
+    description: "Delete groups"
+  
+  # Administrative Permissions
+  - name: "admin:read"
+    roles: ["aifabrix-platform-admin"]
+    description: "Administrative read access to all resources"
+  
+  - name: "admin:write"
+    roles: ["aifabrix-platform-admin"]
+    description: "Administrative write access to all resources"
+  
+  - name: "admin:delete"
+    roles: ["aifabrix-platform-admin"]
+    description: "Administrative delete access to all resources"
+  
   # Template Applications (environment = null)
   - name: "applications:create"
     roles: ["aifabrix-platform-admin", "aifabrix-infrastructure-admin", "aifabrix-deployment-admin"]
@@ -165,4 +212,3 @@ permissions:
   - name: "dashboard:read"
     roles: ["aifabrix-platform-admin", "aifabrix-deployment-admin", "aifabrix-developer", "aifabrix-observer"]
     description: "View dashboard summaries and aggregates"
-

package/templates/applications/miso-controller/variables.yaml

@@ -1,6 +1,6 @@
 # Application Metadata
 app:
-  key: miso
+  key: miso-controller
   displayName: "Miso Controller"
   description: "AI Fabrix Miso Controller - Backend API and orchestration service"
   type: webapp
@@ -36,21 +36,21 @@ healthCheck:
 authentication:
   type: keycloak
   enableSSO: true
-  requiredRoles: ["aifabrix-user"]
+  requiredRoles:
+    - aifabrix-user
   endpoints:
-    local: "http://localhost:3000/auth/callback"
+    local: http://localhost:3000/auth/callback
 
 # Build Configuration
 build:
-  context: ..                                           # Docker build context (relative to builder/)
-  dockerfile: builder/Dockerfile                        # Dockerfile name (empty = use template)
-  envOutputPath: ../packages/miso-controller/.env       # Copy .env to repo root for local dev
-  localPort: 3010                                       # Port for local development (different from Docker port)
-  language: typescript                                  # Runtime language for template selection
-  secrets:                                              # Path to secrets file (optional)
+  context: ..                                           		# Docker build context (relative to builder/)
+  dockerfile: builder/miso-controller/Dockerfile         		# Dockerfile name (empty = use template)
+  envOutputPath:          	                                # Copy .env to repo root for local dev (relative to builder/) (if null, no .env file is copied) (if empty, .env file is copied to repo root)
+  localPort: 3010                                           # Port for local development (different from Docker port)
+  language: typescript                                  		# Runtime language for template selection (typescript or python)
+  secrets:                                                 	# Path to secrets file
 
 # Docker Compose
 compose:
   file: docker-compose.yaml
   service: miso-controller
-