@aifabrix/builder 2.0.3 → 2.0.5

package/README.md

@@ -2,6 +2,7 @@
 
 [![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

@@ -281,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);
 }
 
 /**

package/lib/secrets.js

@@ -13,9 +13,12 @@ const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const os = require('os');
-const crypto = require('crypto');
 const chalk = require('chalk');
 const logger = require('./utils/logger');
+const {
+  generateMissingSecrets,
+  createDefaultSecrets
+} = require('./utils/secrets-generator');
 
 /**
  * Loads environment configuration for docker/local context
@@ -42,13 +45,7 @@ function loadEnvConfig() {
  * // Returns: { 'postgres-passwordKeyVault': 'admin123', ... }
  */
 async function loadSecrets(secretsPath) {
-  let resolvedPath = secretsPath;
-
-  if (!resolvedPath) {
-    resolvedPath = path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
-  } else if (secretsPath.startsWith('..')) {
-    resolvedPath = path.resolve(process.cwd(), secretsPath);
-  }
+  const resolvedPath = resolveSecretsPath(secretsPath);
 
   if (!fs.existsSync(resolvedPath)) {
     throw new Error(`Secrets file not found: ${resolvedPath}`);
@@ -64,6 +61,45 @@ async function loadSecrets(secretsPath) {
   return secrets;
 }
 
+/**
+ * Resolves secrets file path (same logic as loadSecrets)
+ * Also checks common locations if path is not provided
+ * @function resolveSecretsPath
+ * @param {string} [secretsPath] - Path to secrets file (optional)
+ * @returns {string} Resolved secrets file path
+ */
+function resolveSecretsPath(secretsPath) {
+  let resolvedPath = secretsPath;
+
+  if (!resolvedPath) {
+    // Check common locations for secrets.local.yaml
+    const commonLocations = [
+      path.join(process.cwd(), '..', 'aifabrix-setup', 'secrets.local.yaml'),
+      path.join(process.cwd(), '..', '..', 'aifabrix-setup', 'secrets.local.yaml'),
+      path.join(process.cwd(), 'secrets.local.yaml'),
+      path.join(process.cwd(), '..', 'secrets.local.yaml'),
+      path.join(os.homedir(), '.aifabrix', 'secrets.yaml')
+    ];
+
+    // Find first existing file
+    for (const location of commonLocations) {
+      if (fs.existsSync(location)) {
+        resolvedPath = location;
+        break;
+      }
+    }
+
+    // If none found, use default location
+    if (!resolvedPath) {
+      resolvedPath = path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
+    }
+  } else if (secretsPath.startsWith('..')) {
+    resolvedPath = path.resolve(process.cwd(), secretsPath);
+  }
+
+  return resolvedPath;
+}
+
 /**
  * Resolves kv:// references in environment template
  * Replaces kv://keyName with actual values from secrets
@@ -73,6 +109,7 @@ async function loadSecrets(secretsPath) {
  * @param {string} envTemplate - Environment template content
  * @param {Object} secrets - Secrets object from loadSecrets()
  * @param {string} [environment='local'] - Environment context (docker/local)
+ * @param {string} [secretsFilePath] - Path to secrets file (for error messages)
  * @returns {Promise<string>} Resolved environment content
  * @throws {Error} If kv:// reference cannot be resolved
  *
@@ -80,7 +117,7 @@ async function loadSecrets(secretsPath) {
  * const resolved = await resolveKvReferences(template, secrets, 'local');
  * // Returns: 'DATABASE_URL=postgresql://user:pass@localhost:5432/db'
  */
-async function resolveKvReferences(envTemplate, secrets, environment = 'local') {
+async function resolveKvReferences(envTemplate, secrets, environment = 'local', secretsFilePath = null) {
   const envConfig = loadEnvConfig();
   const envVars = envConfig.environments[environment] || envConfig.environments.local;
 
@@ -101,7 +138,8 @@ async function resolveKvReferences(envTemplate, secrets, environment = 'local')
   }
 
   if (missingSecrets.length > 0) {
-    throw new Error(`Missing secrets: ${missingSecrets.join(', ')}`);
+    const fileInfo = secretsFilePath ? `\n\nSecrets file location: ${secretsFilePath}` : '';
+    throw new Error(`Missing secrets: ${missingSecrets.join(', ')}${fileInfo}`);
   }
 
   // Now replace kv:// references, and handle ${VAR} inside the secret values
@@ -119,146 +157,6 @@ async function resolveKvReferences(envTemplate, secrets, environment = 'local')
   return resolved;
 }
 
-/**
- * Finds missing secret keys from template
- * @function findMissingSecretKeys
- * @param {string} envTemplate - Environment template content
- * @param {Object} existingSecrets - Existing secrets object
- * @returns {string[]} Array of missing secret keys
- */
-function findMissingSecretKeys(envTemplate, existingSecrets) {
-  const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
-  const missingKeys = [];
-  const seenKeys = new Set();
-
-  let match;
-  while ((match = kvPattern.exec(envTemplate)) !== null) {
-    const secretKey = match[1];
-    if (!seenKeys.has(secretKey) && !(secretKey in existingSecrets)) {
-      missingKeys.push(secretKey);
-      seenKeys.add(secretKey);
-    }
-  }
-
-  return missingKeys;
-}
-
-/**
- * Generates secret value based on key name
- * @function generateSecretValue
- * @param {string} key - Secret key name
- * @returns {string} Generated secret value
- */
-function generateSecretValue(key) {
-  const keyLower = key.toLowerCase();
-
-  if (keyLower.includes('password')) {
-    const dbPasswordMatch = key.match(/^databases-([a-z0-9-_]+)-\d+-passwordKeyVault$/i);
-    if (dbPasswordMatch) {
-      const appName = dbPasswordMatch[1];
-      const dbName = appName.replace(/-/g, '_');
-      return `${dbName}_pass123`;
-    }
-    return crypto.randomBytes(32).toString('base64');
-  }
-
-  if (keyLower.includes('url') || keyLower.includes('uri')) {
-    const dbUrlMatch = key.match(/^databases-([a-z0-9-_]+)-\d+-urlKeyVault$/i);
-    if (dbUrlMatch) {
-      const appName = dbUrlMatch[1];
-      const dbName = appName.replace(/-/g, '_');
-      return `postgresql://${dbName}_user:${dbName}_pass123@\${DB_HOST}:5432/${dbName}`;
-    }
-    return '';
-  }
-
-  if (keyLower.includes('key') || keyLower.includes('secret') || keyLower.includes('token')) {
-    return crypto.randomBytes(32).toString('base64');
-  }
-
-  return '';
-}
-
-/**
- * Loads existing secrets from file
- * @function loadExistingSecrets
- * @param {string} resolvedPath - Path to secrets file
- * @returns {Object} Existing secrets object
- */
-function loadExistingSecrets(resolvedPath) {
-  if (!fs.existsSync(resolvedPath)) {
-    return {};
-  }
-
-  try {
-    const content = fs.readFileSync(resolvedPath, 'utf8');
-    const secrets = yaml.load(content) || {};
-    return typeof secrets === 'object' ? secrets : {};
-  } catch (error) {
-    logger.warn(`Warning: Could not read existing secrets file: ${error.message}`);
-    return {};
-  }
-}
-
-/**
- * Saves secrets file
- * @function saveSecretsFile
- * @param {string} resolvedPath - Path to secrets file
- * @param {Object} secrets - Secrets object to save
- * @throws {Error} If save fails
- */
-function saveSecretsFile(resolvedPath, secrets) {
-  const dir = path.dirname(resolvedPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  }
-
-  const yamlContent = yaml.dump(secrets, {
-    indent: 2,
-    lineWidth: 120,
-    noRefs: true,
-    sortKeys: false
-  });
-
-  fs.writeFileSync(resolvedPath, yamlContent, { mode: 0o600 });
-}
-
-/**
- * Generates missing secret keys in secrets file
- * Scans env.template for kv:// references and adds missing keys with secure defaults
- *
- * @async
- * @function generateMissingSecrets
- * @param {string} envTemplate - Environment template content
- * @param {string} secretsPath - Path to secrets file
- * @returns {Promise<string[]>} Array of newly generated secret keys
- * @throws {Error} If generation fails
- *
- * @example
- * const newKeys = await generateMissingSecrets(template, '~/.aifabrix/secrets.yaml');
- * // Returns: ['new-secret-key', 'another-secret']
- */
-async function generateMissingSecrets(envTemplate, secretsPath) {
-  const resolvedPath = secretsPath || path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
-  const existingSecrets = loadExistingSecrets(resolvedPath);
-  const missingKeys = findMissingSecretKeys(envTemplate, existingSecrets);
-
-  if (missingKeys.length === 0) {
-    return [];
-  }
-
-  const newSecrets = {};
-  for (const key of missingKeys) {
-    newSecrets[key] = generateSecretValue(key);
-  }
-
-  const updatedSecrets = { ...existingSecrets, ...newSecrets };
-  saveSecretsFile(resolvedPath, updatedSecrets);
-
-  logger.log(`✓ Generated ${missingKeys.length} missing secret key(s): ${missingKeys.join(', ')}`);
-  return missingKeys;
-}
-
 /**
  * Loads environment template from file
  * @function loadEnvTemplate
@@ -335,13 +233,15 @@ async function generateEnvFile(appName, secretsPath, environment = 'local', forc
 
   const template = loadEnvTemplate(templatePath);
 
+  // Resolve secrets path to show in error messages
+  const resolvedSecretsPath = resolveSecretsPath(secretsPath);
+
   if (force) {
-    const resolvedSecretsPath = secretsPath || path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
     await generateMissingSecrets(template, resolvedSecretsPath);
   }
 
   const secrets = await loadSecrets(secretsPath);
-  const resolved = await resolveKvReferences(template, secrets, environment);
+  const resolved = await resolveKvReferences(template, secrets, environment, resolvedSecretsPath);
 
   fs.writeFileSync(envPath, resolved, { mode: 0o600 });
   processEnvVariables(envPath, variablesPath);
@@ -434,48 +334,6 @@ function validateSecrets(envTemplate, secrets) {
   };
 }
 
-/**
- * Creates default secrets file if it doesn't exist
- * Generates template with common secrets for local development
- *
- * @async
- * @function createDefaultSecrets
- * @param {string} secretsPath - Path where to create secrets file
- * @returns {Promise<void>} Resolves when file is created
- * @throws {Error} If file creation fails
- *
- * @example
- * await createDefaultSecrets('~/.aifabrix/secrets.yaml');
- * // Default secrets file is created
- */
-async function createDefaultSecrets(secretsPath) {
-  const resolvedPath = secretsPath.startsWith('~')
-    ? path.join(os.homedir(), secretsPath.slice(1))
-    : secretsPath;
-
-  const dir = path.dirname(resolvedPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  }
-
-  const defaultSecrets = `# Local Development Secrets
-# Production uses Azure KeyVault
-
-# Database Secrets
-postgres-passwordKeyVault: "admin123"
-
-# Redis Secrets
-redis-passwordKeyVault: ""
-redis-urlKeyVault: "redis://\${REDIS_HOST}:6379"
-
-# Keycloak Secrets
-keycloak-admin-passwordKeyVault: "admin123"
-keycloak-auth-server-urlKeyVault: "http://\${KEYCLOAK_HOST}:8082"
-`;
-
-  fs.writeFileSync(resolvedPath, defaultSecrets, { mode: 0o600 });
-}
-
 module.exports = {
   loadSecrets,
   resolveKvReferences,

package/lib/utils/compose-generator.js

@@ -107,14 +107,18 @@ function buildRequiresConfig(config) {
  * @returns {Object} Service configuration
  */
 function buildServiceConfig(appName, config, port) {
-  const containerPort = config.build?.containerPort || config.port || 3000;
+  // Host port is the local port (from options.port or build.localPort)
+  const hostPort = port;
+  // Container port: use build.containerPort if specified, otherwise use port config
+  const containerPortValue = config.build?.containerPort || config.port || hostPort;
 
   return {
     app: buildAppConfig(appName, config),
     image: buildImageConfig(config, appName),
-    port: containerPort,
+    port: containerPortValue, // Container port (for health check and template)
+    containerPort: config.build?.containerPort || null, // Explicit containerPort if specified, null otherwise
     build: {
-      localPort: port
+      localPort: hostPort // Host port
     },
     healthCheck: buildHealthCheckConfig(config),
     ...buildRequiresConfig(config)

package/lib/utils/health-check.js

@@ -71,10 +71,29 @@ async function waitForDbInit(appName) {
  */
 async function getContainerPort(appName) {
   try {
-    const { stdout: portMapping } = await execAsync(`docker inspect --format='{{range .NetworkSettings.Ports}}{{range .}}{{.HostPort}}{{end}}{{end}}' aifabrix-${appName}`);
-    const ports = portMapping.trim().split('\n').filter(p => p);
+    // Try to get the actual mapped host port from Docker
+    // First try docker inspect for the container port mapping
+    const { stdout: portMapping } = await execAsync(`docker inspect --format='{{range $p, $conf := .NetworkSettings.Ports}}{{if $conf}}{{range $conf}}{{.HostPort}}{{end}}{{end}}{{end}}' aifabrix-${appName}`);
+    const ports = portMapping.trim().split('\n').filter(p => p && p !== '');
     if (ports.length > 0) {
-      return parseInt(ports[0], 10);
+      const port = parseInt(ports[0], 10);
+      if (!isNaN(port) && port > 0) {
+        return port;
+      }
+    }
+
+    // Fallback: try docker ps to get port mapping (format: "0.0.0.0:3010->3000/tcp")
+    try {
+      const { stdout: psOutput } = await execAsync(`docker ps --filter "name=aifabrix-${appName}" --format "{{.Ports}}"`);
+      const portMatch = psOutput.match(/:(\d+)->/);
+      if (portMatch) {
+        const port = parseInt(portMatch[1], 10);
+        if (!isNaN(port) && port > 0) {
+          return port;
+        }
+      }
+    } catch (error) {
+      // Fall through
     }
   } catch (error) {
     // Fall through to default
@@ -152,12 +171,12 @@ async function checkHealthEndpoint(healthCheckUrl) {
 async function waitForHealthCheck(appName, timeout = 90, port = null, config = null) {
   await waitForDbInit(appName);
 
-  if (!port) {
-    port = await getContainerPort(appName);
-  }
+  // Always detect the actual port from Docker to ensure we use the correct mapped port
+  const detectedPort = await getContainerPort(appName);
+  const healthCheckPort = port || detectedPort;
 
   const healthCheckPath = config?.healthCheck?.path || '/health';
-  const healthCheckUrl = `http://localhost:${port}${healthCheckPath}`;
+  const healthCheckUrl = `http://localhost:${healthCheckPort}${healthCheckPath}`;
   const maxAttempts = timeout / 2;
 
   for (let attempts = 0; attempts < maxAttempts; attempts++) {

package/lib/utils/secrets-generator.js

@@ -0,0 +1,209 @@
+/**
+ * AI Fabrix Builder Secrets Generation Utilities
+ *
+ * This module handles secret generation and file management.
+ * Generates default secret values and manages secrets files.
+ *
+ * @fileoverview Secret generation utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yaml = require('js-yaml');
+const os = require('os');
+const crypto = require('crypto');
+const logger = require('./logger');
+
+/**
+ * Finds missing secret keys from template
+ * @function findMissingSecretKeys
+ * @param {string} envTemplate - Environment template content
+ * @param {Object} existingSecrets - Existing secrets object
+ * @returns {string[]} Array of missing secret keys
+ */
+function findMissingSecretKeys(envTemplate, existingSecrets) {
+  const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
+  const missingKeys = [];
+  const seenKeys = new Set();
+
+  let match;
+  while ((match = kvPattern.exec(envTemplate)) !== null) {
+    const secretKey = match[1];
+    if (!seenKeys.has(secretKey) && !(secretKey in existingSecrets)) {
+      missingKeys.push(secretKey);
+      seenKeys.add(secretKey);
+    }
+  }
+
+  return missingKeys;
+}
+
+/**
+ * Generates secret value based on key name
+ * @function generateSecretValue
+ * @param {string} key - Secret key name
+ * @returns {string} Generated secret value
+ */
+function generateSecretValue(key) {
+  const keyLower = key.toLowerCase();
+
+  if (keyLower.includes('password')) {
+    const dbPasswordMatch = key.match(/^databases-([a-z0-9-_]+)-\d+-passwordKeyVault$/i);
+    if (dbPasswordMatch) {
+      const appName = dbPasswordMatch[1];
+      const dbName = appName.replace(/-/g, '_');
+      return `${dbName}_pass123`;
+    }
+    return crypto.randomBytes(32).toString('base64');
+  }
+
+  if (keyLower.includes('url') || keyLower.includes('uri')) {
+    const dbUrlMatch = key.match(/^databases-([a-z0-9-_]+)-\d+-urlKeyVault$/i);
+    if (dbUrlMatch) {
+      const appName = dbUrlMatch[1];
+      const dbName = appName.replace(/-/g, '_');
+      return `postgresql://${dbName}_user:${dbName}_pass123@\${DB_HOST}:5432/${dbName}`;
+    }
+    return '';
+  }
+
+  if (keyLower.includes('key') || keyLower.includes('secret') || keyLower.includes('token')) {
+    return crypto.randomBytes(32).toString('base64');
+  }
+
+  return '';
+}
+
+/**
+ * Loads existing secrets from file
+ * @function loadExistingSecrets
+ * @param {string} resolvedPath - Path to secrets file
+ * @returns {Object} Existing secrets object
+ */
+function loadExistingSecrets(resolvedPath) {
+  if (!fs.existsSync(resolvedPath)) {
+    return {};
+  }
+
+  try {
+    const content = fs.readFileSync(resolvedPath, 'utf8');
+    const secrets = yaml.load(content) || {};
+    return typeof secrets === 'object' ? secrets : {};
+  } catch (error) {
+    logger.warn(`Warning: Could not read existing secrets file: ${error.message}`);
+    return {};
+  }
+}
+
+/**
+ * Saves secrets file
+ * @function saveSecretsFile
+ * @param {string} resolvedPath - Path to secrets file
+ * @param {Object} secrets - Secrets object to save
+ * @throws {Error} If save fails
+ */
+function saveSecretsFile(resolvedPath, secrets) {
+  const dir = path.dirname(resolvedPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+
+  const yamlContent = yaml.dump(secrets, {
+    indent: 2,
+    lineWidth: 120,
+    noRefs: true,
+    sortKeys: false
+  });
+
+  fs.writeFileSync(resolvedPath, yamlContent, { mode: 0o600 });
+}
+
+/**
+ * Generates missing secret keys in secrets file
+ * Scans env.template for kv:// references and adds missing keys with secure defaults
+ *
+ * @async
+ * @function generateMissingSecrets
+ * @param {string} envTemplate - Environment template content
+ * @param {string} secretsPath - Path to secrets file
+ * @returns {Promise<string[]>} Array of newly generated secret keys
+ * @throws {Error} If generation fails
+ *
+ * @example
+ * const newKeys = await generateMissingSecrets(template, '~/.aifabrix/secrets.yaml');
+ * // Returns: ['new-secret-key', 'another-secret']
+ */
+async function generateMissingSecrets(envTemplate, secretsPath) {
+  const resolvedPath = secretsPath || path.join(os.homedir(), '.aifabrix', 'secrets.yaml');
+  const existingSecrets = loadExistingSecrets(resolvedPath);
+  const missingKeys = findMissingSecretKeys(envTemplate, existingSecrets);
+
+  if (missingKeys.length === 0) {
+    return [];
+  }
+
+  const newSecrets = {};
+  for (const key of missingKeys) {
+    newSecrets[key] = generateSecretValue(key);
+  }
+
+  const updatedSecrets = { ...existingSecrets, ...newSecrets };
+  saveSecretsFile(resolvedPath, updatedSecrets);
+
+  logger.log(`✓ Generated ${missingKeys.length} missing secret key(s): ${missingKeys.join(', ')}`);
+  return missingKeys;
+}
+
+/**
+ * Creates default secrets file if it doesn't exist
+ * Generates template with common secrets for local development
+ *
+ * @async
+ * @function createDefaultSecrets
+ * @param {string} secretsPath - Path where to create secrets file
+ * @returns {Promise<void>} Resolves when file is created
+ * @throws {Error} If file creation fails
+ *
+ * @example
+ * await createDefaultSecrets('~/.aifabrix/secrets.yaml');
+ * // Default secrets file is created
+ */
+async function createDefaultSecrets(secretsPath) {
+  const resolvedPath = secretsPath.startsWith('~')
+    ? path.join(os.homedir(), secretsPath.slice(1))
+    : secretsPath;
+
+  const dir = path.dirname(resolvedPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  }
+
+  const defaultSecrets = `# Local Development Secrets
+# Production uses Azure KeyVault
+
+# Database Secrets
+postgres-passwordKeyVault: "admin123"
+
+# Redis Secrets
+redis-passwordKeyVault: ""
+redis-urlKeyVault: "redis://\${REDIS_HOST}:6379"
+
+# Keycloak Secrets
+keycloak-admin-passwordKeyVault: "admin123"
+keycloak-auth-server-urlKeyVault: "http://\${KEYCLOAK_HOST}:8082"
+`;
+
+  fs.writeFileSync(resolvedPath, defaultSecrets, { mode: 0o600 });
+}
+
+module.exports = {
+  findMissingSecretKeys,
+  generateSecretValue,
+  loadExistingSecrets,
+  saveSecretsFile,
+  generateMissingSecrets,
+  createDefaultSecrets
+};
+

package/lib/validator.js

@@ -185,13 +185,17 @@ async function validateEnvTemplate(appName) {
   const lines = content.split('\n');
   lines.forEach((line, index) => {
     const trimmed = line.trim();
+    // Skip empty lines and comments
     if (trimmed && !trimmed.startsWith('#')) {
       if (!trimmed.includes('=')) {
         errors.push(`Line ${index + 1}: Invalid environment variable format (missing =)`);
       } else {
-        const [key, value] = trimmed.split('=', 2);
-        if (!key || !value) {
-          errors.push(`Line ${index + 1}: Invalid environment variable format`);
+        const [key, _value] = trimmed.split('=', 2);
+        // Trim key to handle whitespace issues
+        // Empty values are allowed (_value can be empty string or undefined)
+        const trimmedKey = key ? key.trim() : '';
+        if (!trimmedKey) {
+          errors.push(`Line ${index + 1}: Invalid environment variable format (missing variable name)`);
         }
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {

package/templates/infra/compose.yaml

@@ -2,8 +2,6 @@
 # Shared infrastructure services only
 # Generated by AI Fabrix Builder SDK
 
-version: "3.9"
-
 services:
   # PostgreSQL Database with pgvector extension
   postgres:

package/templates/python/docker-compose.hbs

@@ -2,8 +2,6 @@
 # Generated by AI Fabrix Builder SDK
 # Service definition for local development
 
-version: "3.9"
-
 services:
   {{app.key}}:
     image: {{image.name}}:{{image.tag}}
@@ -11,7 +9,11 @@ services:
     env_file:
       - {{envFile}}
     ports:
+      {{#if containerPort}}
+      - "{{build.localPort}}:{{containerPort}}"
+      {{else}}
       - "{{build.localPort}}:{{port}}"
+      {{/if}}
     networks:
       - infra_aifabrix-network
     {{#if requiresStorage}}
@@ -48,23 +50,34 @@ services:
     command: >
       sh -c "
         export PGHOST=postgres PGPORT=5432 PGUSER=pgadmin &&
-        export PGPASSWORD="${POSTGRES_PASSWORD}" &&
+        export PGPASSWORD=\"${POSTGRES_PASSWORD}\" &&
+        echo 'Waiting for PostgreSQL to be ready...' &&
+        counter=0 &&
+        while [ $counter -lt 30 ]; do
+          if pg_isready -h postgres -p 5432 -U pgadmin >/dev/null 2>&1; then
+            echo 'PostgreSQL is ready!'
+            break
+          fi
+          echo 'Waiting for PostgreSQL...'
+          sleep 1
+          counter=$((counter + 1))
+        done &&
         {{#if databases}}
         {{#each databases}}
         echo 'Creating {{name}} database and user...' &&
-        psql -d postgres -c 'CREATE DATABASE {{name}};' || echo '{{name}} database exists' &&
-        psql -d postgres -c \"CREATE USER {{name}}_user WITH PASSWORD '{{name}}_pass123';\" || echo '{{name}}_user exists' &&
-        psql -d postgres -c 'GRANT ALL PRIVILEGES ON DATABASE {{name}} TO {{name}}_user;' &&
-        psql -d {{name}} -c 'ALTER SCHEMA public OWNER TO {{name}}_user;' &&
-        psql -d {{name}} -c 'GRANT ALL ON SCHEMA public TO {{name}}_user;' &&
+        (psql -d postgres -c 'CREATE DATABASE {{name}};' || true) &&
+        (psql -d postgres -c \"CREATE USER {{name}}_user WITH PASSWORD '{{name}}_pass123';\" || true) &&
+        psql -d postgres -c 'GRANT ALL PRIVILEGES ON DATABASE {{name}} TO {{name}}_user;' || true &&
+        psql -d {{name}} -c 'ALTER SCHEMA public OWNER TO {{name}}_user;' || true &&
+        psql -d {{name}} -c 'GRANT ALL ON SCHEMA public TO {{name}}_user;' || true &&
         {{/each}}
         {{else}}
         echo 'Creating {{app.key}} database and user...' &&
-        psql -d postgres -c 'CREATE DATABASE {{app.key}};' || echo '{{app.key}} database exists' &&
-        psql -d postgres -c \"CREATE USER {{app.key}}_user WITH PASSWORD '{{app.key}}_pass123';\" || echo '{{app.key}}_user exists' &&
-        psql -d postgres -c 'GRANT ALL PRIVILEGES ON DATABASE {{app.key}} TO {{app.key}}_user;' &&
-        psql -d {{app.key}} -c 'ALTER SCHEMA public OWNER TO {{app.key}}_user;' &&
-        psql -d {{app.key}} -c 'GRANT ALL ON SCHEMA public TO {{app.key}}_user;' &&
+        (psql -d postgres -c 'CREATE DATABASE {{app.key}};' || true) &&
+        (psql -d postgres -c \"CREATE USER {{app.key}}_user WITH PASSWORD '{{app.key}}_pass123';\" || true) &&
+        psql -d postgres -c 'GRANT ALL PRIVILEGES ON DATABASE {{app.key}} TO {{app.key}}_user;' || true &&
+        psql -d {{app.key}} -c 'ALTER SCHEMA public OWNER TO {{app.key}}_user;' || true &&
+        psql -d {{app.key}} -c 'GRANT ALL ON SCHEMA public TO {{app.key}}_user;' || true &&
         {{/if}}
         echo 'Database initialization complete!'
       "

package/templates/typescript/docker-compose.hbs

@@ -2,8 +2,6 @@
 # Generated by AI Fabrix Builder SDK
 # Service definition for local development
 
-version: "3.9"
-
 services:
   {{app.key}}:
     image: {{image.name}}:{{image.tag}}
@@ -11,7 +9,11 @@ services:
     env_file:
       - {{envFile}}
     ports:
+      {{#if containerPort}}
+      - "{{build.localPort}}:{{containerPort}}"
+      {{else}}
       - "{{build.localPort}}:{{port}}"
+      {{/if}}
     networks:
       - infra_aifabrix-network
     {{#if requiresStorage}}
@@ -48,23 +50,34 @@ services:
     command: >
       sh -c "
         export PGHOST=postgres PGPORT=5432 PGUSER=pgadmin &&
-        export PGPASSWORD="${POSTGRES_PASSWORD}" &&
+        export PGPASSWORD=\"${POSTGRES_PASSWORD}\" &&
+        echo 'Waiting for PostgreSQL to be ready...' &&
+        counter=0 &&
+        while [ $counter -lt 30 ]; do
+          if pg_isready -h postgres -p 5432 -U pgadmin >/dev/null 2>&1; then
+            echo 'PostgreSQL is ready!'
+            break
+          fi
+          echo 'Waiting for PostgreSQL...'
+          sleep 1
+          counter=$((counter + 1))
+        done &&
         {{#if databases}}
         {{#each databases}}
         echo 'Creating {{name}} database and user...' &&
-        psql -d postgres -c 'CREATE DATABASE {{name}};' || echo '{{name}} database exists' &&
-        psql -d postgres -c \"CREATE USER {{name}}_user WITH PASSWORD '{{name}}_pass123';\" || echo '{{name}}_user exists' &&
-        psql -d postgres -c 'GRANT ALL PRIVILEGES ON DATABASE {{name}} TO {{name}}_user;' &&
-        psql -d {{name}} -c 'ALTER SCHEMA public OWNER TO {{name}}_user;' &&
-        psql -d {{name}} -c 'GRANT ALL ON SCHEMA public TO {{name}}_user;' &&
+        (psql -d postgres -c 'CREATE DATABASE {{name}};' || true) &&
+        (psql -d postgres -c \"CREATE USER {{name}}_user WITH PASSWORD '{{name}}_pass123';\" || true) &&
+        psql -d postgres -c 'GRANT ALL PRIVILEGES ON DATABASE {{name}} TO {{name}}_user;' || true &&
+        psql -d {{name}} -c 'ALTER SCHEMA public OWNER TO {{name}}_user;' || true &&
+        psql -d {{name}} -c 'GRANT ALL ON SCHEMA public TO {{name}}_user;' || true &&
         {{/each}}
         {{else}}
         echo 'Creating {{app.key}} database and user...' &&
-        psql -d postgres -c 'CREATE DATABASE {{app.key}};' || echo '{{app.key}} database exists' &&
-        psql -d postgres -c \"CREATE USER {{app.key}}_user WITH PASSWORD '{{app.key}}_pass123';\" || echo '{{app.key}}_user exists' &&
-        psql -d postgres -c 'GRANT ALL PRIVILEGES ON DATABASE {{app.key}} TO {{app.key}}_user;' &&
-        psql -d {{app.key}} -c 'ALTER SCHEMA public OWNER TO {{app.key}}_user;' &&
-        psql -d {{app.key}} -c 'GRANT ALL ON SCHEMA public TO {{app.key}}_user;' &&
+        (psql -d postgres -c 'CREATE DATABASE {{app.key}};' || true) &&
+        (psql -d postgres -c \"CREATE USER {{app.key}}_user WITH PASSWORD '{{app.key}}_pass123';\" || true) &&
+        psql -d postgres -c 'GRANT ALL PRIVILEGES ON DATABASE {{app.key}} TO {{app.key}}_user;' || true &&
+        psql -d {{app.key}} -c 'ALTER SCHEMA public OWNER TO {{app.key}}_user;' || true &&
+        psql -d {{app.key}} -c 'GRANT ALL ON SCHEMA public TO {{app.key}}_user;' || true &&
         {{/if}}
         echo 'Database initialization complete!'
       "