@aifabrix/builder 2.1.7 → 2.3.0

package/lib/infra.js

@@ -14,11 +14,37 @@ const { promisify } = require('util');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
+const handlebars = require('handlebars');
 const secrets = require('./secrets');
+const config = require('./config');
+const devConfig = require('./utils/dev-config');
 const logger = require('./utils/logger');
+const containerUtils = require('./utils/infra-containers');
 
+// Register Handlebars helper for equality check
+handlebars.registerHelper('eq', (a, b) => a === b);
 const execAsync = promisify(exec);
 
+/**
+ * Gets infrastructure directory name based on developer ID
+ * Dev 0: infra (no dev-0 suffix), Dev > 0: infra-dev{id}
+ * @param {number} devId - Developer ID
+ * @returns {string} Infrastructure directory name
+ */
+function getInfraDirName(devId) {
+  return devId === 0 ? 'infra' : `infra-dev${devId}`;
+}
+
+/**
+ * Gets Docker Compose project name based on developer ID
+ * Dev 0: infra (no dev-0 suffix), Dev > 0: infra-dev{id}
+ * @param {number} devId - Developer ID
+ * @returns {string} Docker Compose project name
+ */
+function getInfraProjectName(devId) {
+  return devId === 0 ? 'infra' : `infra-dev${devId}`;
+}
+
 // Wrapper to support cwd option
 function execAsyncWithCwd(command, options = {}) {
   return new Promise((resolve, reject) => {
@@ -64,33 +90,53 @@ async function ensureAdminSecrets() {
   return adminSecretsPath;
 }
 
-async function startInfra() {
+async function startInfra(developerId = null) {
   await checkDockerAvailability();
   const adminSecretsPath = await ensureAdminSecrets();
 
-  // Load compose template
-  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml');
+  // Get developer ID from parameter or config
+  const devId = developerId || await config.getDeveloperId();
+  const ports = devConfig.getDevPorts(devId);
+
+  // Load compose template (Handlebars)
+  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml.hbs');
   if (!fs.existsSync(templatePath)) {
     throw new Error(`Compose template not found: ${templatePath}`);
   }
 
-  // Create infra directory in ~/.aifabrix
+  // Create infra directory in ~/.aifabrix with dev ID
   const aifabrixDir = path.join(os.homedir(), '.aifabrix');
-  const infraDir = path.join(aifabrixDir, 'infra');
+  const infraDirName = getInfraDirName(devId);
+  const infraDir = path.join(aifabrixDir, infraDirName);
   if (!fs.existsSync(infraDir)) {
     fs.mkdirSync(infraDir, { recursive: true });
   }
 
+  // Generate compose file from template
+  const templateContent = fs.readFileSync(templatePath, 'utf8');
+  const template = handlebars.compile(templateContent);
+  // Dev 0: infra-aifabrix-network, Dev > 0: infra-dev{id}-aifabrix-network
+  const networkName = devId === 0 ? 'infra-aifabrix-network' : `infra-dev${devId}-aifabrix-network`;
+  const composeContent = template({
+    devId: devId,
+    postgresPort: ports.postgres,
+    redisPort: ports.redis,
+    pgadminPort: ports.pgadmin,
+    redisCommanderPort: ports.redisCommander,
+    networkName: networkName
+  });
+
   const composePath = path.join(infraDir, 'compose.yaml');
-  fs.writeFileSync(composePath, fs.readFileSync(templatePath, 'utf8'));
+  fs.writeFileSync(composePath, composeContent);
 
   try {
     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(`Starting infrastructure services for developer ${devId}...`);
+    const projectName = getInfraProjectName(devId);
+    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p ${projectName} --env-file "${adminSecretsPath}" up -d`, { cwd: infraDir });
     logger.log('Infrastructure services started successfully');
 
-    await waitForServices();
+    await waitForServices(devId);
     logger.log('All services are healthy and ready');
   } finally {
     // Keep the compose file for stop commands
@@ -111,8 +157,11 @@ async function startInfra() {
  * // All infrastructure containers are stopped and removed
  */
 async function stopInfra() {
+  const devId = await config.getDeveloperId();
   const aifabrixDir = path.join(os.homedir(), '.aifabrix');
-  const composePath = path.join(aifabrixDir, 'infra', 'compose.yaml');
+  const infraDirName = getInfraDirName(devId);
+  const infraDir = path.join(aifabrixDir, infraDirName);
+  const composePath = path.join(infraDir, 'compose.yaml');
   const adminSecretsPath = path.join(aifabrixDir, 'admin-secrets.env');
 
   if (!fs.existsSync(composePath) || !fs.existsSync(adminSecretsPath)) {
@@ -120,11 +169,10 @@ async function stopInfra() {
     return;
   }
 
-  const infraDir = path.join(aifabrixDir, 'infra');
-
   try {
     logger.log('Stopping infrastructure services...');
-    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p infra --env-file "${adminSecretsPath}" down`, { cwd: infraDir });
+    const projectName = getInfraProjectName(devId);
+    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p ${projectName} --env-file "${adminSecretsPath}" down`, { cwd: infraDir });
     logger.log('Infrastructure services stopped');
   } finally {
     // Keep the compose file for future use
@@ -145,8 +193,11 @@ async function stopInfra() {
  * // All infrastructure containers and data are removed
  */
 async function stopInfraWithVolumes() {
+  const devId = await config.getDeveloperId();
   const aifabrixDir = path.join(os.homedir(), '.aifabrix');
-  const composePath = path.join(aifabrixDir, 'infra', 'compose.yaml');
+  const infraDirName = getInfraDirName(devId);
+  const infraDir = path.join(aifabrixDir, infraDirName);
+  const composePath = path.join(infraDir, 'compose.yaml');
   const adminSecretsPath = path.join(aifabrixDir, 'admin-secrets.env');
 
   if (!fs.existsSync(composePath) || !fs.existsSync(adminSecretsPath)) {
@@ -154,84 +205,16 @@ async function stopInfraWithVolumes() {
     return;
   }
 
-  const infraDir = path.join(aifabrixDir, 'infra');
-
   try {
     logger.log('Stopping infrastructure services and removing all data...');
-    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p infra --env-file "${adminSecretsPath}" down -v`, { cwd: infraDir });
+    const projectName = getInfraProjectName(devId);
+    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p ${projectName} --env-file "${adminSecretsPath}" down -v`, { cwd: infraDir });
     logger.log('Infrastructure services stopped and all data removed');
   } finally {
     // 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';
-  }
-}
-
 /**
  * Checks if infrastructure services are running
  * Validates that all required services are healthy and accessible
@@ -245,19 +228,20 @@ async function checkServiceWithoutHealthCheck(serviceName) {
  * const health = await checkInfraHealth();
  * // Returns: { postgres: 'healthy', redis: 'healthy', keycloak: 'healthy', controller: 'healthy' }
  */
-async function checkInfraHealth() {
+async function checkInfraHealth(devId = null) {
+  const developerId = devId || await config.getDeveloperId();
   const servicesWithHealthCheck = ['postgres', 'redis'];
   const servicesWithoutHealthCheck = ['pgadmin', 'redis-commander'];
   const health = {};
 
   // Check health status for services with health checks
   for (const service of servicesWithHealthCheck) {
-    health[service] = await checkServiceWithHealthCheck(service);
+    health[service] = await containerUtils.checkServiceWithHealthCheck(service, developerId);
   }
 
   // Check if services without health checks are running
   for (const service of servicesWithoutHealthCheck) {
-    health[service] = await checkServiceWithoutHealthCheck(service);
+    health[service] = await containerUtils.checkServiceWithoutHealthCheck(service, developerId);
   }
 
   return health;
@@ -276,39 +260,41 @@ async function checkInfraHealth() {
  * // Returns: { postgres: { status: 'running', port: 5432, url: 'localhost:5432' }, ... }
  */
 async function getInfraStatus() {
+  const devId = await config.getDeveloperId();
+  const ports = devConfig.getDevPorts(devId);
   const services = {
-    postgres: { port: 5432, url: 'localhost:5432' },
-    redis: { port: 6379, url: 'localhost:6379' },
-    pgadmin: { port: 5050, url: 'http://localhost:5050' },
-    'redis-commander': { port: 8081, url: 'http://localhost:8081' }
+    postgres: { port: ports.postgres, url: `localhost:${ports.postgres}` },
+    redis: { port: ports.redis, url: `localhost:${ports.redis}` },
+    pgadmin: { port: ports.pgadmin, url: `http://localhost:${ports.pgadmin}` },
+    'redis-commander': { port: ports.redisCommander, url: `http://localhost:${ports.redisCommander}` }
   };
 
   const status = {};
 
-  for (const [serviceName, config] of Object.entries(services)) {
+  for (const [serviceName, serviceConfig] of Object.entries(services)) {
     try {
-      const containerName = await findContainer(serviceName);
+      const containerName = await containerUtils.findContainer(serviceName, devId);
       if (containerName) {
         const { stdout } = await execAsync(`docker inspect --format='{{.State.Status}}' ${containerName}`);
         // Normalize status value (trim whitespace and remove quotes)
         const normalizedStatus = stdout.trim().replace(/['"]/g, '');
         status[serviceName] = {
           status: normalizedStatus,
-          port: config.port,
-          url: config.url
+          port: serviceConfig.port,
+          url: serviceConfig.url
         };
       } else {
         status[serviceName] = {
           status: 'not running',
-          port: config.port,
-          url: config.url
+          port: serviceConfig.port,
+          url: serviceConfig.url
         };
       }
     } catch (error) {
       status[serviceName] = {
         status: 'not running',
-        port: config.port,
-        url: config.url
+        port: serviceConfig.port,
+        url: serviceConfig.url
       };
     }
   }
@@ -340,19 +326,21 @@ async function restartService(serviceName) {
     throw new Error(`Invalid service name. Must be one of: ${validServices.join(', ')}`);
   }
 
+  const devId = await config.getDeveloperId();
   const aifabrixDir = path.join(os.homedir(), '.aifabrix');
-  const composePath = path.join(aifabrixDir, 'infra', 'compose.yaml');
+  const infraDirName = getInfraDirName(devId);
+  const infraDir = path.join(aifabrixDir, infraDirName);
+  const composePath = path.join(infraDir, 'compose.yaml');
   const adminSecretsPath = path.join(aifabrixDir, 'admin-secrets.env');
 
   if (!fs.existsSync(composePath) || !fs.existsSync(adminSecretsPath)) {
     throw new Error('Infrastructure not properly configured');
   }
 
-  const infraDir = path.join(aifabrixDir, 'infra');
-
   try {
     logger.log(`Restarting ${serviceName} service...`);
-    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p infra --env-file "${adminSecretsPath}" restart ${serviceName}`, { cwd: infraDir });
+    const projectName = getInfraProjectName(devId);
+    await execAsyncWithCwd(`docker-compose -f "${composePath}" -p ${projectName} --env-file "${adminSecretsPath}" restart ${serviceName}`, { cwd: infraDir });
     logger.log(`${serviceName} service restarted successfully`);
   } finally {
     // Keep the compose file for future use
@@ -362,13 +350,14 @@ async function restartService(serviceName) {
 /**
  * Waits for services to be healthy
  * @private
+ * @param {number} [devId] - Developer ID (optional, will be loaded from config if not provided)
  */
-async function waitForServices() {
+async function waitForServices(devId = null) {
   const maxAttempts = 30;
   const delay = 2000; // 2 seconds
 
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const health = await checkInfraHealth();
+    const health = await checkInfraHealth(devId);
     const allHealthy = Object.values(health).every(status => status === 'healthy');
 
     if (allHealthy) {
@@ -386,12 +375,88 @@ async function waitForServices() {
   throw new Error('Services failed to become healthy within timeout period');
 }
 
+/**
+ * Gets status of running application containers
+ * Finds all containers matching pattern aifabrix-dev{id}-* (excluding infrastructure)
+ *
+ * @async
+ * @function getAppStatus
+ * @returns {Promise<Array>} Array of application status objects
+ *
+ * @example
+ * const apps = await getAppStatus();
+ * // Returns: [{ name: 'myapp', container: 'aifabrix-dev1-myapp', port: '3100:3000', status: 'running', url: 'http://localhost:3100' }]
+ */
+async function getAppStatus() {
+  const devId = await config.getDeveloperId();
+  const apps = [];
+
+  try {
+    // Find all containers with pattern
+    // Dev 0: aifabrix-* (but exclude infrastructure containers)
+    // Dev > 0: aifabrix-dev{id}-*
+    const filterPattern = devId === 0 ? 'aifabrix-' : `aifabrix-dev${devId}-`;
+    const { stdout } = await execAsync(`docker ps --filter "name=${filterPattern}" --format "{{.Names}}\t{{.Ports}}\t{{.Status}}"`);
+    const lines = stdout.trim().split('\n').filter(line => line.trim() !== '');
+
+    // Infrastructure container names to exclude
+    // Dev 0: aifabrix-{serviceName}, Dev > 0: aifabrix-dev{id}-{serviceName}
+    const infraContainers = devId === 0
+      ? [
+        'aifabrix-postgres',
+        'aifabrix-redis',
+        'aifabrix-pgadmin',
+        'aifabrix-redis-commander'
+      ]
+      : [
+        `aifabrix-dev${devId}-postgres`,
+        `aifabrix-dev${devId}-redis`,
+        `aifabrix-dev${devId}-pgadmin`,
+        `aifabrix-dev${devId}-redis-commander`
+      ];
+
+    for (const line of lines) {
+      const [containerName, ports, status] = line.split('\t');
+
+      // Skip infrastructure containers
+      if (infraContainers.includes(containerName)) {
+        continue;
+      }
+
+      // Extract app name from container name
+      // Dev 0: aifabrix-{appName}, Dev > 0: aifabrix-dev{id}-{appName}
+      const pattern = devId === 0
+        ? /^aifabrix-(.+)$/
+        : new RegExp(`^aifabrix-dev${devId}-(.+)$`);
+      const appNameMatch = containerName.match(pattern);
+      if (!appNameMatch) {
+        continue;
+      }
+
+      const appName = appNameMatch[1];
+
+      // Extract host port from ports string (e.g., "0.0.0.0:3100->3000/tcp")
+      const portMatch = ports.match(/:(\d+)->\d+\//);
+      const hostPort = portMatch ? portMatch[1] : 'unknown';
+      const url = hostPort !== 'unknown' ? `http://localhost:${hostPort}` : 'unknown';
+
+      apps.push({
+        name: appName,
+        container: containerName,
+        port: ports,
+        status: status.trim(),
+        url: url
+      });
+    }
+  } catch (error) {
+    // If no containers found, return empty array
+    return [];
+  }
+
+  return apps;
+}
+
 module.exports = {
-  startInfra,
-  stopInfra,
-  stopInfraWithVolumes,
-  checkInfraHealth,
-  getInfraStatus,
-  restartService,
-  ensureAdminSecrets
+  startInfra, stopInfra, stopInfraWithVolumes, checkInfraHealth,
+  getInfraStatus, getAppStatus, restartService, ensureAdminSecrets
 };

package/lib/push.js

@@ -21,12 +21,35 @@ const execAsync = promisify(exec);
  * @returns {Promise<boolean>} True if Azure CLI is available
  */
 async function checkAzureCLIInstalled() {
-  try {
-    await execAsync('az --version');
-    return true;
-  } catch (error) {
-    return false;
+  // On Windows, use shell option to ensure proper command resolution
+  const options = process.platform === 'win32' ? { shell: true } : {};
+
+  // Try multiple methods to detect Azure CLI (commands that don't require authentication)
+  const commands = process.platform === 'win32'
+    ? ['az --version', 'az.cmd --version']
+    : ['az --version'];
+
+  for (const command of commands) {
+    try {
+      // Use a timeout to avoid hanging if command doesn't exist
+      await execAsync(command, { ...options, timeout: 5000 });
+      return true;
+    } catch (error) {
+      // Log the error for debugging (only in development)
+      if (process.env.DEBUG) {
+        logger.log(chalk.gray(`[DEBUG] Command '${command}' failed: ${error.message}`));
+      }
+      // Continue to next command if this one fails
+      continue;
+    }
+  }
+
+  // If all commands failed, Azure CLI is not available
+  // Log for debugging if enabled
+  if (process.env.DEBUG) {
+    logger.log(chalk.gray('[DEBUG] All Azure CLI detection methods failed'));
   }
+  return false;
 }
 
 /**
@@ -103,7 +126,9 @@ function validateRegistryURL(registryUrl) {
 async function checkACRAuthentication(registry) {
   try {
     const registryName = extractRegistryName(registry);
-    await execAsync(`az acr show --name ${registryName}`);
+    // On Windows, use shell option to ensure proper command resolution
+    const options = process.platform === 'win32' ? { shell: true } : {};
+    await execAsync(`az acr show --name ${registryName}`, options);
     return true;
   } catch (error) {
     return false;
@@ -119,7 +144,9 @@ async function authenticateACR(registry) {
   try {
     const registryName = extractRegistryName(registry);
     logger.log(chalk.blue(`Authenticating with ${registry}...`));
-    await execAsync(`az acr login --name ${registryName}`);
+    // On Windows, use shell option to ensure proper command resolution
+    const options = process.platform === 'win32' ? { shell: true } : {};
+    await execAsync(`az acr login --name ${registryName}`, options);
     logger.log(chalk.green(`✓ Authenticated with ${registry}`));
   } catch (error) {
     throw new Error(`Failed to authenticate with Azure Container Registry: ${error.message}`);