@aifabrix/builder 2.0.2 → 2.0.4

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);
@@ -391,11 +281,11 @@ async function startContainer(appName, composePath, port, config = null) {
   await execAsync(`docker-compose -f "${composePath}" up -d`, { env });
   logger.log(chalk.green(`✓ Container aifabrix-${appName} started`));
 
-  // Wait for health check
+  // Wait for health check - detect actual mapped port from Docker
+  // Don't pass port so waitForHealthCheck will auto-detect it from container
   const healthCheckPath = config?.healthCheck?.path || '/health';
-  const healthCheckUrl = `http://localhost:${port}${healthCheckPath}`;
-  logger.log(chalk.blue(`Waiting for application to be healthy at ${healthCheckUrl}...`));
-  await waitForHealthCheck(appName, 90, port, config);
+  logger.log(chalk.blue(`Waiting for application to be healthy at http://localhost:${port}${healthCheckPath}...`));
+  await waitForHealthCheck(appName, 90, null, config);
 }
 
 /**
@@ -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