@aifabrix/builder 2.0.0 → 2.0.3

package/lib/infra.js

@@ -15,9 +15,24 @@ const path = require('path');
 const fs = require('fs');
 const os = require('os');
 const secrets = require('./secrets');
+const logger = require('./utils/logger');
 
 const execAsync = promisify(exec);
 
+// Wrapper to support cwd option
+function execAsyncWithCwd(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const { cwd, ...execOptions } = options;
+    exec(command, { ...execOptions, cwd }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+  });
+}
+
 /**
  * Starts local infrastructure services
  * Launches Postgres, Redis, Keycloak, and Controller in Docker containers
@@ -43,7 +58,7 @@ async function checkDockerAvailability() {
 async function ensureAdminSecrets() {
   const adminSecretsPath = path.join(os.homedir(), '.aifabrix', 'admin-secrets.env');
   if (!fs.existsSync(adminSecretsPath)) {
-    console.log('Generating admin-secrets.env...');
+    logger.log('Generating admin-secrets.env...');
     await secrets.generateAdminSecretsEnv();
   }
   return adminSecretsPath;
@@ -59,21 +74,26 @@ async function startInfra() {
     throw new Error(`Compose template not found: ${templatePath}`);
   }
 
-  const template = fs.readFileSync(templatePath, 'utf8');
-  const tempComposePath = path.join(os.tmpdir(), 'aifabrix-compose.yaml');
-  fs.writeFileSync(tempComposePath, template);
+  // Create infra directory in ~/.aifabrix
+  const aifabrixDir = path.join(os.homedir(), '.aifabrix');
+  const infraDir = path.join(aifabrixDir, 'infra');
+  if (!fs.existsSync(infraDir)) {
+    fs.mkdirSync(infraDir, { recursive: true });
+  }
+
+  const composePath = path.join(infraDir, 'compose.yaml');
+  fs.writeFileSync(composePath, fs.readFileSync(templatePath, 'utf8'));
 
   try {
-    console.log('Starting infrastructure services...');
-    await execAsync(`docker-compose -f "${tempComposePath}" --env-file "${adminSecretsPath}" up -d`);
-    console.log('Infrastructure services started successfully');
+    logger.log(`Using compose file: ${composePath}`);
+    logger.log('Starting infrastructure services...');
+    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p infra --env-file "${adminSecretsPath}" up -d`, { cwd: infraDir });
+    logger.log('Infrastructure services started successfully');
 
     await waitForServices();
-    console.log('All services are healthy and ready');
+    logger.log('All services are healthy and ready');
   } finally {
-    if (fs.existsSync(tempComposePath)) {
-      fs.unlinkSync(tempComposePath);
-    }
+    // Keep the compose file for stop commands
   }
 }
 
@@ -91,25 +111,23 @@ async function startInfra() {
  * // All infrastructure containers are stopped and removed
  */
 async function stopInfra() {
-  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml');
-  const adminSecretsPath = path.join(os.homedir(), '.aifabrix', 'admin-secrets.env');
+  const aifabrixDir = path.join(os.homedir(), '.aifabrix');
+  const composePath = path.join(aifabrixDir, 'infra', 'compose.yaml');
+  const adminSecretsPath = path.join(aifabrixDir, 'admin-secrets.env');
 
-  if (!fs.existsSync(templatePath) || !fs.existsSync(adminSecretsPath)) {
-    console.log('Infrastructure not running or not properly configured');
+  if (!fs.existsSync(composePath) || !fs.existsSync(adminSecretsPath)) {
+    logger.log('Infrastructure not running or not properly configured');
     return;
   }
 
-  const tempComposePath = path.join(os.tmpdir(), 'aifabrix-compose.yaml');
-  fs.writeFileSync(tempComposePath, fs.readFileSync(templatePath, 'utf8'));
+  const infraDir = path.join(aifabrixDir, 'infra');
 
   try {
-    console.log('Stopping infrastructure services...');
-    await execAsync(`docker-compose -f "${tempComposePath}" --env-file "${adminSecretsPath}" down`);
-    console.log('Infrastructure services stopped');
+    logger.log('Stopping infrastructure services...');
+    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p infra --env-file "${adminSecretsPath}" down`, { cwd: infraDir });
+    logger.log('Infrastructure services stopped');
   } finally {
-    if (fs.existsSync(tempComposePath)) {
-      fs.unlinkSync(tempComposePath);
-    }
+    // Keep the compose file for future use
   }
 }
 
@@ -127,25 +145,90 @@ async function stopInfra() {
  * // All infrastructure containers and data are removed
  */
 async function stopInfraWithVolumes() {
-  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml');
-  const adminSecretsPath = path.join(os.homedir(), '.aifabrix', 'admin-secrets.env');
+  const aifabrixDir = path.join(os.homedir(), '.aifabrix');
+  const composePath = path.join(aifabrixDir, 'infra', 'compose.yaml');
+  const adminSecretsPath = path.join(aifabrixDir, 'admin-secrets.env');
 
-  if (!fs.existsSync(templatePath) || !fs.existsSync(adminSecretsPath)) {
-    console.log('Infrastructure not running or not properly configured');
+  if (!fs.existsSync(composePath) || !fs.existsSync(adminSecretsPath)) {
+    logger.log('Infrastructure not running or not properly configured');
     return;
   }
 
-  const tempComposePath = path.join(os.tmpdir(), 'aifabrix-compose.yaml');
-  fs.writeFileSync(tempComposePath, fs.readFileSync(templatePath, 'utf8'));
+  const infraDir = path.join(aifabrixDir, 'infra');
 
   try {
-    console.log('Stopping infrastructure services and removing all data...');
-    await execAsync(`docker-compose -f "${tempComposePath}" --env-file "${adminSecretsPath}" down -v`);
-    console.log('Infrastructure services stopped and all data removed');
+    logger.log('Stopping infrastructure services and removing all data...');
+    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p infra --env-file "${adminSecretsPath}" down -v`, { cwd: infraDir });
+    logger.log('Infrastructure services stopped and all data removed');
   } finally {
-    if (fs.existsSync(tempComposePath)) {
-      fs.unlinkSync(tempComposePath);
+    // Keep the compose file for future use
+  }
+}
+
+/**
+ * Finds container by name pattern
+ * @private
+ * @async
+ * @param {string} serviceName - Service name
+ * @returns {Promise<string|null>} Container name or null if not found
+ */
+async function findContainer(serviceName) {
+  try {
+    // Try both naming patterns: infra-* (dynamic names) and aifabrix-* (hardcoded names)
+    let { stdout } = await execAsync(`docker ps --filter "name=infra-${serviceName}" --format "{{.Names}}"`);
+    let containerName = stdout.trim();
+    if (!containerName) {
+      // Fallback to hardcoded names
+      ({ stdout } = await execAsync(`docker ps --filter "name=aifabrix-${serviceName}" --format "{{.Names}}"`));
+      containerName = stdout.trim();
+    }
+    return containerName;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Checks health status for a service with health checks
+ * @private
+ * @async
+ * @param {string} serviceName - Service name
+ * @returns {Promise<string>} Health status
+ */
+async function checkServiceWithHealthCheck(serviceName) {
+  try {
+    const containerName = await findContainer(serviceName);
+    if (!containerName) {
+      return 'unknown';
     }
+    const { stdout } = await execAsync(`docker inspect --format='{{.State.Health.Status}}' ${containerName}`);
+    const status = stdout.trim().replace(/['"]/g, '');
+    // Accept both 'healthy' and 'starting' as healthy (starting means it's initializing)
+    return (status === 'healthy' || status === 'starting') ? 'healthy' : status;
+  } catch (error) {
+    return 'unknown';
+  }
+}
+
+/**
+ * Checks health status for a service without health checks
+ * @private
+ * @async
+ * @param {string} serviceName - Service name
+ * @returns {Promise<string>} Health status
+ */
+async function checkServiceWithoutHealthCheck(serviceName) {
+  try {
+    const containerName = await findContainer(serviceName);
+    if (!containerName) {
+      return 'unknown';
+    }
+    const { stdout } = await execAsync(`docker inspect --format='{{.State.Status}}' ${containerName}`);
+    const status = stdout.trim().replace(/['"]/g, '');
+    // Treat 'running' or 'healthy' as 'healthy' for services without health checks
+    return (status === 'running' || status === 'healthy') ? 'healthy' : 'unhealthy';
+  } catch (error) {
+    return 'unknown';
   }
 }
 
@@ -163,16 +246,18 @@ async function stopInfraWithVolumes() {
  * // Returns: { postgres: 'healthy', redis: 'healthy', keycloak: 'healthy', controller: 'healthy' }
  */
 async function checkInfraHealth() {
-  const services = ['postgres', 'redis', 'pgadmin', 'redis-commander'];
+  const servicesWithHealthCheck = ['postgres', 'redis'];
+  const servicesWithoutHealthCheck = ['pgadmin', 'redis-commander'];
   const health = {};
 
-  for (const service of services) {
-    try {
-      const { stdout } = await execAsync(`docker inspect --format='{{.State.Health.Status}}' aifabrix-${service}`);
-      health[service] = stdout.trim();
-    } catch (error) {
-      health[service] = 'unknown';
-    }
+  // Check health status for services with health checks
+  for (const service of servicesWithHealthCheck) {
+    health[service] = await checkServiceWithHealthCheck(service);
+  }
+
+  // Check if services without health checks are running
+  for (const service of servicesWithoutHealthCheck) {
+    health[service] = await checkServiceWithoutHealthCheck(service);
   }
 
   return health;
@@ -202,12 +287,21 @@ async function getInfraStatus() {
 
   for (const [serviceName, config] of Object.entries(services)) {
     try {
-      const { stdout } = await execAsync(`docker inspect --format='{{.State.Status}}' aifabrix-${serviceName}`);
-      status[serviceName] = {
-        status: stdout.trim(),
-        port: config.port,
-        url: config.url
-      };
+      const containerName = await findContainer(serviceName);
+      if (containerName) {
+        const { stdout } = await execAsync(`docker inspect --format='{{.State.Status}}' ${containerName}`);
+        status[serviceName] = {
+          status: stdout.trim(),
+          port: config.port,
+          url: config.url
+        };
+      } else {
+        status[serviceName] = {
+          status: 'not running',
+          port: config.port,
+          url: config.url
+        };
+      }
     } catch (error) {
       status[serviceName] = {
         status: 'not running',
@@ -244,24 +338,22 @@ async function restartService(serviceName) {
     throw new Error(`Invalid service name. Must be one of: ${validServices.join(', ')}`);
   }
 
-  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml');
-  const adminSecretsPath = path.join(os.homedir(), '.aifabrix', 'admin-secrets.env');
+  const aifabrixDir = path.join(os.homedir(), '.aifabrix');
+  const composePath = path.join(aifabrixDir, 'infra', 'compose.yaml');
+  const adminSecretsPath = path.join(aifabrixDir, 'admin-secrets.env');
 
-  if (!fs.existsSync(templatePath) || !fs.existsSync(adminSecretsPath)) {
+  if (!fs.existsSync(composePath) || !fs.existsSync(adminSecretsPath)) {
     throw new Error('Infrastructure not properly configured');
   }
 
-  const tempComposePath = path.join(os.tmpdir(), 'aifabrix-compose.yaml');
-  fs.writeFileSync(tempComposePath, fs.readFileSync(templatePath, 'utf8'));
+  const infraDir = path.join(aifabrixDir, 'infra');
 
   try {
-    console.log(`Restarting ${serviceName} service...`);
-    await execAsync(`docker-compose -f "${tempComposePath}" --env-file "${adminSecretsPath}" restart ${serviceName}`);
-    console.log(`${serviceName} service restarted successfully`);
+    logger.log(`Restarting ${serviceName} service...`);
+    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p infra --env-file "${adminSecretsPath}" restart ${serviceName}`, { cwd: infraDir });
+    logger.log(`${serviceName} service restarted successfully`);
   } finally {
-    if (fs.existsSync(tempComposePath)) {
-      fs.unlinkSync(tempComposePath);
-    }
+    // Keep the compose file for future use
   }
 }
 
@@ -281,8 +373,10 @@ async function waitForServices() {
       return;
     }
 
+    // Debug logging
+
     if (attempt < maxAttempts) {
-      console.log(`Waiting for services to be healthy... (${attempt}/${maxAttempts})`);
+      logger.log(`Waiting for services to be healthy... (${attempt}/${maxAttempts})`);
       await new Promise(resolve => setTimeout(resolve, delay));
     }
   }
@@ -296,5 +390,6 @@ module.exports = {
   stopInfraWithVolumes,
   checkInfraHealth,
   getInfraStatus,
-  restartService
+  restartService,
+  ensureAdminSecrets
 };

package/lib/push.js

@@ -12,6 +12,7 @@
 const { exec } = require('child_process');
 const { promisify } = require('util');
 const chalk = require('chalk');
+const logger = require('./utils/logger');
 
 const execAsync = promisify(exec);
 
@@ -43,12 +44,55 @@ function extractRegistryName(registryUrl) {
 }
 
 /**
- * Validate registry URL format
+ * Parses registry URL format
+ * @function parseRegistryUrl
+ * @param {string} registryUrl - Registry URL to parse
+ * @returns {Object|null} Parsed registry info or null if invalid
+ */
+function parseRegistryUrl(registryUrl) {
+  if (!registryUrl || typeof registryUrl !== 'string') {
+    return null;
+  }
+
+  if (registryUrl.includes('://')) {
+    return null;
+  }
+
+  if (/^[^.]+\.azurecr\.io$/.test(registryUrl)) {
+    return { type: 'acr', valid: true };
+  }
+
+  if (registryUrl === 'docker.io' || registryUrl === 'index.docker.io') {
+    return { type: 'dockerhub', valid: true };
+  }
+
+  if (registryUrl === 'ghcr.io') {
+    return { type: 'ghcr', valid: true };
+  }
+
+  if (registryUrl === 'azurecr.io') {
+    return null;
+  }
+
+  if (/^[^.]+\.azurecr\.com$/.test(registryUrl)) {
+    return null;
+  }
+
+  if (/^[a-z0-9][a-z0-9.-]+\.[a-z]{2,}(?::[0-9]+)?$/.test(registryUrl)) {
+    return { type: 'custom', valid: true };
+  }
+
+  return null;
+}
+
+/**
+ * Validates registry URL format
  * @param {string} registryUrl - Registry URL to validate
  * @returns {boolean} True if valid
  */
 function validateRegistryURL(registryUrl) {
-  return /^[^.]+\.azurecr\.io$/.test(registryUrl);
+  const parsed = parseRegistryUrl(registryUrl);
+  return parsed !== null && parsed.valid;
 }
 
 /**
@@ -74,14 +118,62 @@ async function checkACRAuthentication(registry) {
 async function authenticateACR(registry) {
   try {
     const registryName = extractRegistryName(registry);
-    console.log(chalk.blue(`Authenticating with ${registry}...`));
+    logger.log(chalk.blue(`Authenticating with ${registry}...`));
     await execAsync(`az acr login --name ${registryName}`);
-    console.log(chalk.green(`✓ Authenticated with ${registry}`));
+    logger.log(chalk.green(`✓ Authenticated with ${registry}`));
   } catch (error) {
     throw new Error(`Failed to authenticate with Azure Container Registry: ${error.message}`);
   }
 }
 
+/**
+ * Authenticate with external registry
+ * @param {string} registry - Registry URL
+ * @param {string} username - Username for authentication
+ * @param {string} password - Password or token for authentication
+ * @throws {Error} If authentication fails
+ */
+async function authenticateExternalRegistry(registry, username, password) {
+  try {
+    logger.log(chalk.blue(`Authenticating with ${registry}...`));
+
+    // Use cross-platform approach: write password to stdin directly
+    // This works on Windows, Linux, and macOS
+    const { spawn } = require('child_process');
+    const dockerLogin = spawn('docker', ['login', registry, '-u', username, '--password-stdin']);
+
+    return new Promise((resolve, reject) => {
+      let errorOutput = '';
+
+      dockerLogin.stdin.write(password);
+      dockerLogin.stdin.end();
+
+      dockerLogin.stdout.on('data', (_data) => {
+        // Authentication output (usually minimal)
+      });
+
+      dockerLogin.stderr.on('data', (data) => {
+        errorOutput += data.toString();
+      });
+
+      dockerLogin.on('close', (code) => {
+        if (code === 0) {
+          logger.log(chalk.green(`✓ Authenticated with ${registry}`));
+          resolve();
+        } else {
+          reject(new Error(`Docker login failed: ${errorOutput || `Exit code ${code}`}`));
+        }
+      });
+
+      dockerLogin.on('error', (error) => {
+        reject(new Error(`Failed to execute docker login: ${error.message}`));
+      });
+    });
+  } catch (error) {
+    throw new Error(`Failed to authenticate with external registry: ${error.message}`);
+  }
+}
+
 /**
  * Check if Docker image exists locally
  * @param {string} imageName - Image name
@@ -90,8 +182,10 @@ async function authenticateACR(registry) {
  */
 async function checkLocalImageExists(imageName, tag = 'latest') {
   try {
-    const { stdout } = await execAsync(`docker images --format "{{.Repository}}:{{.Tag}}" | grep "^${imageName}:${tag}$"`);
-    return stdout.trim() === `${imageName}:${tag}`;
+    // Use Docker's native filtering for cross-platform compatibility (Windows-safe)
+    const { stdout } = await execAsync(`docker images --format "{{.Repository}}:{{.Tag}}" --filter "reference=${imageName}:${tag}"`);
+    const lines = stdout.trim().split('\n').filter(line => line.trim() !== '');
+    return lines.some(line => line.trim() === `${imageName}:${tag}`);
   } catch (error) {
     return false;
   }
@@ -105,9 +199,9 @@ async function checkLocalImageExists(imageName, tag = 'latest') {
  */
 async function tagImage(sourceImage, targetImage) {
   try {
-    console.log(chalk.blue(`Tagging ${sourceImage} as ${targetImage}...`));
+    logger.log(chalk.blue(`Tagging ${sourceImage} as ${targetImage}...`));
     await execAsync(`docker tag ${sourceImage} ${targetImage}`);
-    console.log(chalk.green(`✓ Tagged: ${targetImage}`));
+    logger.log(chalk.green(`✓ Tagged: ${targetImage}`));
   } catch (error) {
     throw new Error(`Failed to tag image: ${error.message}`);
   }
@@ -120,9 +214,9 @@ async function tagImage(sourceImage, targetImage) {
  */
 async function pushImage(imageWithTag) {
   try {
-    console.log(chalk.blue(`Pushing ${imageWithTag}...`));
+    logger.log(chalk.blue(`Pushing ${imageWithTag}...`));
     await execAsync(`docker push ${imageWithTag}`);
-    console.log(chalk.green(`✓ Pushed: ${imageWithTag}`));
+    logger.log(chalk.green(`✓ Pushed: ${imageWithTag}`));
   } catch (error) {
     throw new Error(`Failed to push image: ${error.message}`);
   }
@@ -134,6 +228,7 @@ module.exports = {
   validateRegistryURL,
   checkACRAuthentication,
   authenticateACR,
+  authenticateExternalRegistry,
   checkLocalImageExists,
   tagImage,
   pushImage

package/lib/schema/application-schema.json

@@ -90,7 +90,7 @@
           "name": {
             "type": "string",
             "description": "Database name",
-            "pattern": "^[a-z0-9_]+$"
+            "pattern": "^[a-z0-9-_]+$"
           }
         },
         "additionalProperties": false
@@ -506,7 +506,7 @@
         },
         "repositoryUrl": {
           "type": "string",
-          "description": "Full repository URL for deployment validation (same as OAuth callback)",
+          "description": "Full repository URL for pipeline validation (same as OAuth callback)",
           "pattern": "^(https://github.com/[^/]+/[^/]+|https://gitlab.com/[^/]+/[^/]+|https://dev.azure.com/[^/]+/[^/]+/[^/]+)$"
         }
       },
@@ -586,6 +586,12 @@
           "minimum": 1000,
           "maximum": 65535
         },
+        "containerPort": {
+          "type": "integer",
+          "description": "Container internal port (defaults to port if not specified)",
+          "minimum": 1,
+          "maximum": 65535
+        },
         "language": {
           "type": "string",
           "description": "Runtime language for template selection",
@@ -603,6 +609,28 @@
         }
       },
       "additionalProperties": false
+    },
+    "deployment": {
+      "type": "object",
+      "description": "Deployment configuration for pipeline API",
+      "properties": {
+        "controllerUrl": {
+          "type": "string",
+          "description": "Controller API URL for deployment",
+          "pattern": "^https://.*$"
+        },
+        "clientId": {
+          "type": "string",
+          "description": "Pipeline ClientId for automated deployment",
+          "pattern": "^[a-z0-9-]+$"
+        },
+        "clientSecret": {
+          "type": "string",
+          "description": "Pipeline ClientSecret (use kv:// reference)",
+          "pattern": "^(kv://.*|.+)$"
+        }
+      },
+      "additionalProperties": false
     }
   },
   "additionalProperties": false,

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