@aifabrix/builder 2.0.0 → 2.0.2

package/README.md

@@ -1,5 +1,9 @@
 # 🧱 @aifabrix/builder
 
+[![npm version](https://img.shields.io/npm/v/%40aifabrix%2Fbuilder.svg)](https://www.npmjs.com/package/%40aifabrix%2Fbuilder)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 Local development infrastructure + Azure deployment tool.
 
 ## Install
@@ -32,12 +36,12 @@ Want authentication or deployment controller?
 
 ```bash
 # Keycloak for authentication
-aifabrix create keycloak --port 8082 --database --template platform
+aifabrix create keycloak --port 8082 --database --template keycloak
 aifabrix build keycloak
 aifabrix run keycloak
 
 # Miso Controller for Azure deployments
-aifabrix create miso-controller --port 3000 --database --redis --template platform
+aifabrix create miso-controller --port 3000 --database --redis --template miso-controller
 aifabrix build miso-controller
 aifabrix run miso-controller
 ```

package/bin/aifabrix.js

@@ -10,11 +10,14 @@
  *
  * @fileoverview CLI entry point for AI Fabrix Builder SDK
  * @author AI Fabrix Team
- * @version 2.0.0
+ * @version 2.0.2
  */
 
 const { Command } = require('commander');
 const cli = require('../lib/cli');
+const { setupAppCommands } = require('../lib/commands/app');
+const logger = require('../lib/utils/logger');
+const packageJson = require('../package.json');
 
 /**
  * Initialize and configure the CLI
@@ -24,12 +27,15 @@ function initializeCLI() {
   const program = new Command();
 
   program.name('aifabrix')
-    .version('2.0.0')
+    .version(packageJson.version)
     .description('AI Fabrix Local Fabric & Deployment SDK');
 
   // Delegate command setup to lib/cli.js
   cli.setupCommands(program);
 
+  // Add application management commands
+  setupAppCommands(program);
+
   // Parse command line arguments
   program.parse();
 }
@@ -43,7 +49,7 @@ if (require.main === module) {
   try {
     initializeCLI();
   } catch (error) {
-    console.error('❌ Failed to initialize CLI:', error.message);
+    logger.error('❌ Failed to initialize CLI:', error.message);
     process.exit(1);
   }
 }

package/jest.config.integration.js

@@ -0,0 +1,30 @@
+/**
+ * Jest Configuration for Integration Tests
+ * Ensures tests run in correct order with proper error handling
+ *
+ * @fileoverview Jest config specifically for integration tests
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const baseConfig = require('./jest.config');
+
+module.exports = {
+  ...baseConfig,
+  // Override testPathIgnorePatterns for integration tests
+  testPathIgnorePatterns: [
+    '/node_modules/',
+    '\\\\node_modules\\\\'
+  ],
+  // Use custom test sequencer for correct order
+  testSequencer: '<rootDir>/tests/integration/test-sequencer.js',
+  // Longer timeout for integration tests
+  testTimeout: 300000, // 5 minutes
+  // Run tests sequentially
+  maxWorkers: 1,
+  // Don't ignore integration tests
+  testMatch: [
+    '**/tests/integration/**/*.test.js'
+  ]
+};
+

package/lib/app-config.js

@@ -0,0 +1,157 @@
+/**
+ * Application Configuration File Generation
+ *
+ * Generates configuration files for applications (variables.yaml, env.template, rbac.yaml, etc.)
+ *
+ * @fileoverview Configuration file generation for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const { generateVariablesYaml, generateEnvTemplate, generateRbacYaml } = require('./templates');
+const { generateEnvTemplate: generateEnvTemplateFromReader } = require('./env-reader');
+const logger = require('./utils/logger');
+
+/**
+ * Checks if a file exists
+ * @async
+ * @param {string} filePath - Path to file
+ * @returns {Promise<boolean>} True if file exists
+ */
+async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Generates variables.yaml file if it doesn't exist
+ * @async
+ * @param {string} appPath - Path to application directory
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ */
+async function generateVariablesYamlFile(appPath, appName, config) {
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  if (!(await fileExists(variablesPath))) {
+    const variablesYaml = generateVariablesYaml(appName, config);
+    await fs.writeFile(variablesPath, variablesYaml);
+  }
+}
+
+/**
+ * Generates env.template file if it doesn't exist
+ * @async
+ * @param {string} appPath - Path to application directory
+ * @param {Object} config - Application configuration
+ * @param {Object} existingEnv - Existing environment variables
+ */
+async function generateEnvTemplateFile(appPath, config, existingEnv) {
+  const envTemplatePath = path.join(appPath, 'env.template');
+  if (!(await fileExists(envTemplatePath))) {
+    let envTemplate;
+    if (existingEnv) {
+      const envResult = await generateEnvTemplateFromReader(config, existingEnv);
+      envTemplate = envResult.template;
+
+      if (envResult.warnings.length > 0) {
+        logger.log(chalk.yellow('\n⚠️  Environment conversion warnings:'));
+        envResult.warnings.forEach(warning => logger.log(chalk.yellow(`  - ${warning}`)));
+      }
+    } else {
+      envTemplate = generateEnvTemplate(config);
+    }
+    await fs.writeFile(envTemplatePath, envTemplate);
+  }
+}
+
+/**
+ * Generates rbac.yaml file if authentication is enabled and file doesn't exist
+ * @async
+ * @param {string} appPath - Path to application directory
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ */
+async function generateRbacYamlFile(appPath, appName, config) {
+  if (!config.authentication) {
+    return;
+  }
+
+  const rbacPath = path.join(appPath, 'rbac.yaml');
+  if (!(await fileExists(rbacPath))) {
+    const rbacYaml = generateRbacYaml(appName, config);
+    if (rbacYaml) {
+      await fs.writeFile(rbacPath, rbacYaml);
+    }
+  }
+}
+
+/**
+ * Generates aifabrix-deploy.json file
+ * @async
+ * @param {string} appPath - Path to application directory
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ */
+async function generateDeployJsonFile(appPath, appName, config) {
+  const deployJson = {
+    apiVersion: 'v1',
+    kind: 'ApplicationDeployment',
+    metadata: {
+      name: appName,
+      namespace: 'default'
+    },
+    spec: {
+      application: {
+        name: appName,
+        version: '1.0.0',
+        language: config.language,
+        port: config.port
+      },
+      services: {
+        database: config.database,
+        redis: config.redis,
+        storage: config.storage,
+        authentication: config.authentication
+      },
+      deployment: {
+        replicas: 1,
+        strategy: 'RollingUpdate'
+      }
+    }
+  };
+
+  await fs.writeFile(
+    path.join(appPath, 'aifabrix-deploy.json'),
+    JSON.stringify(deployJson, null, 2)
+  );
+}
+
+/**
+ * Generate all configuration files for the application
+ * @param {string} appPath - Path to application directory
+ * @param {string} appName - Application name
+ * @param {Object} config - Application configuration
+ * @param {Object} existingEnv - Existing environment variables
+ */
+async function generateConfigFiles(appPath, appName, config, existingEnv) {
+  try {
+    await generateVariablesYamlFile(appPath, appName, config);
+    await generateEnvTemplateFile(appPath, config, existingEnv);
+    await generateRbacYamlFile(appPath, appName, config);
+    await generateDeployJsonFile(appPath, appName, config);
+  } catch (error) {
+    throw new Error(`Failed to generate configuration files: ${error.message}`);
+  }
+}
+
+module.exports = {
+  generateConfigFiles
+};
+

package/lib/app-deploy.js

@@ -14,6 +14,7 @@ const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
 const pushUtils = require('./push');
+const logger = require('./utils/logger');
 
 /**
  * Validate application name format
@@ -42,6 +43,63 @@ function validateAppName(appName) {
   }
 }
 
+/**
+ * Validates push prerequisites
+ * @async
+ * @function validatePushPrerequisites
+ * @param {string} appName - Application name
+ * @param {string} registry - Registry URL
+ * @throws {Error} If prerequisites are not met
+ */
+async function validatePushPrerequisites(appName, registry) {
+  if (!pushUtils.validateRegistryURL(registry)) {
+    throw new Error(`Invalid registry URL format: ${registry}. Expected format: *.azurecr.io`);
+  }
+
+  if (!await pushUtils.checkLocalImageExists(appName, 'latest')) {
+    throw new Error(`Docker image ${appName}:latest not found locally.\nRun 'aifabrix build ${appName}' first`);
+  }
+
+  if (!await pushUtils.checkAzureCLIInstalled()) {
+    throw new Error('Azure CLI is not installed. Install from: https://docs.microsoft.com/cli/azure/install-azure-cli');
+  }
+}
+
+/**
+ * Executes push operations
+ * @async
+ * @function executePush
+ * @param {string} appName - Application name
+ * @param {string} registry - Registry URL
+ * @param {string[]} tags - Tags to push
+ * @throws {Error} If push fails
+ */
+async function executePush(appName, registry, tags) {
+  if (await pushUtils.checkACRAuthentication(registry)) {
+    logger.log(chalk.green(`✓ Already authenticated with ${registry}`));
+  } else {
+    await pushUtils.authenticateACR(registry);
+  }
+
+  await Promise.all(tags.map(async(tag) => {
+    await pushUtils.tagImage(`${appName}:latest`, `${registry}/${appName}:${tag}`);
+    await pushUtils.pushImage(`${registry}/${appName}:${tag}`);
+  }));
+}
+
+/**
+ * Verifies push result
+ * @function verifyPushResult
+ * @param {string[]} tags - Tags that were pushed
+ * @param {string} registry - Registry URL
+ * @param {string} appName - Application name
+ */
+function verifyPushResult(tags, registry, appName) {
+  logger.log(chalk.green(`\n✓ Successfully pushed ${tags.length} tag(s) to ${registry}`));
+  logger.log(chalk.gray(`Image: ${registry}/${appName}:*`));
+  logger.log(chalk.gray(`Tags: ${tags.join(', ')}`));
+}
+
 /**
  * Pushes application image to Azure Container Registry
  * @async
@@ -52,7 +110,6 @@ function validateAppName(appName) {
  */
 async function pushApp(appName, options = {}) {
   try {
-    // Validate app name
     validateAppName(appName);
 
     const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
@@ -68,37 +125,181 @@ async function pushApp(appName, options = {}) {
       throw new Error('Registry URL is required. Provide via --registry flag or configure in variables.yaml under image.registry');
     }
 
-    if (!pushUtils.validateRegistryURL(registry)) {
-      throw new Error(`Invalid registry URL format: ${registry}. Expected format: *.azurecr.io`);
+    if (!/^[^.]+\.azurecr\.io$/.test(registry)) {
+      throw new Error(`Invalid ACR URL format: ${registry}. Expected format: *.azurecr.io`);
     }
 
     const tags = options.tag ? options.tag.split(',').map(t => t.trim()) : ['latest'];
 
-    if (!await pushUtils.checkLocalImageExists(appName, 'latest')) {
-      throw new Error(`Docker image ${appName}:latest not found locally.\nRun 'aifabrix build ${appName}' first`);
-    }
+    await validatePushPrerequisites(appName, registry);
+    await executePush(appName, registry, tags);
+    verifyPushResult(tags, registry, appName);
 
-    if (!await pushUtils.checkAzureCLIInstalled()) {
-      throw new Error('Azure CLI is not installed. Install from: https://docs.microsoft.com/cli/azure/install-azure-cli');
-    }
+  } catch (error) {
+    throw new Error(`Failed to push application: ${error.message}`);
+  }
+}
 
-    if (await pushUtils.checkACRAuthentication(registry)) {
-      console.log(chalk.green(`✓ Already authenticated with ${registry}`));
-    } else {
-      await pushUtils.authenticateACR(registry);
+/**
+ * Validates that the application directory exists
+ * @async
+ * @param {string} builderPath - Path to builder directory
+ * @param {string} appName - Application name
+ * @throws {Error} If directory doesn't exist
+ */
+async function validateAppDirectory(builderPath, appName) {
+  try {
+    await fs.access(builderPath);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`Application '${appName}' not found in builder/. Run 'aifabrix create ${appName}' first`);
     }
+    throw error;
+  }
+}
 
-    await Promise.all(tags.map(async(tag) => {
-      await pushUtils.tagImage(`${appName}:latest`, `${registry}/${appName}:${tag}`);
-      await pushUtils.pushImage(`${registry}/${appName}:${tag}`);
-    }));
+/**
+ * Loads variables.yaml file
+ * @async
+ * @param {string} variablesPath - Path to variables.yaml
+ * @returns {Promise<Object>} Variables object
+ * @throws {Error} If file cannot be loaded
+ */
+async function loadVariablesFile(variablesPath) {
+  try {
+    const variablesContent = await fs.readFile(variablesPath, 'utf8');
+    return yaml.load(variablesContent);
+  } catch (error) {
+    throw new Error(`Failed to load configuration from variables.yaml: ${error.message}`);
+  }
+}
 
-    console.log(chalk.green(`\n✓ Successfully pushed ${tags.length} tag(s) to ${registry}`));
-    console.log(chalk.gray(`Image: ${registry}/${appName}:*`));
-    console.log(chalk.gray(`Tags: ${tags.join(', ')}`));
+/**
+ * Extracts deployment configuration from options and variables
+ * @param {Object} options - CLI options
+ * @param {Object} variables - Variables from variables.yaml
+ * @returns {Object} Extracted configuration
+ */
+function extractDeploymentConfig(options, variables) {
+  return {
+    controllerUrl: options.controller || variables.deployment?.controllerUrl,
+    envKey: options.environment || variables.deployment?.environment || 'dev',
+    clientId: options.clientId || variables.deployment?.clientId,
+    clientSecret: options.clientSecret || variables.deployment?.clientSecret,
+    poll: options.poll !== false,
+    pollInterval: options.pollInterval || 5000,
+    pollMaxAttempts: options.pollMaxAttempts || 60
+  };
+}
 
-  } catch (error) {
-    throw new Error(`Failed to push application: ${error.message}`);
+/**
+ * Validates required deployment configuration
+ * @param {Object} config - Deployment configuration
+ * @throws {Error} If configuration is invalid
+ */
+function validateDeploymentConfig(config) {
+  if (!config.controllerUrl) {
+    throw new Error('Controller URL is required. Set it in variables.yaml or use --controller flag');
+  }
+  if (!config.clientId || !config.clientSecret) {
+    throw new Error('Client ID and Client Secret are required. Set them in variables.yaml or use --client-id and --client-secret flags');
+  }
+}
+
+/**
+ * Loads deployment configuration from variables.yaml
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - CLI options
+ * @returns {Promise<Object>} Deployment configuration
+ * @throws {Error} If configuration is invalid
+ */
+async function loadDeploymentConfig(appName, options) {
+  const builderPath = path.join(process.cwd(), 'builder', appName);
+  await validateAppDirectory(builderPath, appName);
+
+  const variablesPath = path.join(builderPath, 'variables.yaml');
+  const variables = await loadVariablesFile(variablesPath);
+
+  const config = extractDeploymentConfig(options, variables);
+  validateDeploymentConfig(config);
+
+  return config;
+}
+
+/**
+ * Generates and validates deployment manifest
+ * @async
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Deployment manifest
+ * @throws {Error} If generation or validation fails
+ */
+async function generateAndValidateManifest(appName) {
+  logger.log(chalk.blue(`\n📋 Generating deployment manifest for ${appName}...`));
+  const generator = require('./generator');
+
+  // generateDeployJson already validates against schema and throws on error
+  const manifestPath = await generator.generateDeployJson(appName);
+  const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
+
+  // Additional validation for warnings (schema validation already passed)
+  // Note: Schema validation happens in generateDeployJson, this is just for additional checks if needed
+  return { manifest, manifestPath };
+}
+
+/**
+ * Displays deployment information
+ * @param {Object} manifest - Deployment manifest
+ * @param {string} manifestPath - Path to manifest file
+ */
+function displayDeploymentInfo(manifest, manifestPath) {
+  logger.log(chalk.green(`✓ Manifest generated: ${manifestPath}`));
+  logger.log(chalk.blue(`   Key: ${manifest.key}`));
+  logger.log(chalk.blue(`   Display Name: ${manifest.displayName}`));
+  logger.log(chalk.blue(`   Image: ${manifest.image}`));
+  logger.log(chalk.blue(`   Port: ${manifest.port}`));
+}
+
+/**
+ * Executes deployment to controller
+ * @async
+ * @param {Object} manifest - Deployment manifest
+ * @param {Object} config - Deployment configuration
+ * @returns {Promise<Object>} Deployment result
+ */
+async function executeDeployment(manifest, config) {
+  logger.log(chalk.blue(`\n🚀 Deploying to ${config.controllerUrl} (environment: ${config.envKey})...`));
+  const deployer = require('./deployer');
+  return await deployer.deployToController(
+    manifest,
+    config.controllerUrl,
+    config.envKey,
+    config.clientId,
+    config.clientSecret,
+    {
+      poll: config.poll,
+      pollInterval: config.pollInterval,
+      pollMaxAttempts: config.pollMaxAttempts
+    }
+  );
+}
+
+/**
+ * Displays deployment results
+ * @param {Object} result - Deployment result
+ */
+function displayDeploymentResults(result) {
+  logger.log(chalk.green('\n✅ Deployment initiated successfully'));
+  if (result.deploymentUrl) {
+    logger.log(chalk.blue(`   URL: ${result.deploymentUrl}`));
+  }
+  if (result.deploymentId) {
+    logger.log(chalk.blue(`   Deployment ID: ${result.deploymentId}`));
+  }
+  if (result.status) {
+    const statusIcon = result.status.status === 'completed' ? '✅' :
+      result.status.status === 'failed' ? '❌' : '⏳';
+    logger.log(chalk.blue(`   Status: ${statusIcon} ${result.status.status}`));
   }
 }
 
@@ -129,70 +330,20 @@ async function deployApp(appName, options = {}) {
 
     validateAppName(appName);
 
-    if (!options.controller) {
-      throw new Error('Controller URL is required (--controller flag required)');
-    }
+    // 2. Load deployment configuration
+    const config = await loadDeploymentConfig(appName, options);
 
-    // 2. Load application configuration
-    const builderPath = path.join(process.cwd(), 'builder', appName);
-    try {
-      await fs.access(builderPath);
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        throw new Error(`Application '${appName}' not found in builder/. Run 'aifabrix create ${appName}' first`);
-      }
-      throw error;
-    }
+    // 3. Generate and validate manifest
+    const { manifest, manifestPath } = await generateAndValidateManifest(appName);
 
-    // 3. Generate deployment manifest
-    console.log(chalk.blue(`\n📋 Generating deployment manifest for ${appName}...`));
-    const generator = require('./generator');
-    const manifestPath = await generator.generateDeployJson(appName);
-    const manifest = JSON.parse(await fs.readFile(manifestPath, 'utf8'));
-
-    // 4. Validate manifest
-    const validation = generator.validateDeploymentJson(manifest);
-    if (!validation.valid) {
-      console.log(chalk.red('\n❌ Validation failed:'));
-      validation.errors.forEach(error => console.log(chalk.red(`   • ${error}`)));
-      throw new Error('Deployment manifest validation failed');
-    }
+    // 4. Display deployment info
+    displayDeploymentInfo(manifest, manifestPath);
 
-    if (validation.warnings.length > 0) {
-      console.log(chalk.yellow('\n⚠️  Warnings:'));
-      validation.warnings.forEach(warning => console.log(chalk.yellow(`   • ${warning}`)));
-    }
+    // 5. Execute deployment
+    const result = await executeDeployment(manifest, config);
 
-    // 5. Display deployment info
-    console.log(chalk.green(`✓ Manifest generated: ${manifestPath}`));
-    console.log(chalk.blue(`   Key: ${manifest.key}`));
-    console.log(chalk.blue(`   Display Name: ${manifest.displayName}`));
-    console.log(chalk.blue(`   Image: ${manifest.image}`));
-    console.log(chalk.blue(`   Port: ${manifest.port}`));
-
-    // 6. Deploy to controller
-    console.log(chalk.blue(`\n🚀 Deploying to ${options.controller}...`));
-    const deployer = require('./deployer');
-    const result = await deployer.deployToController(manifest, options.controller, {
-      environment: options.environment,
-      poll: options.poll !== false, // Poll by default
-      pollInterval: options.pollInterval || 5000,
-      pollMaxAttempts: options.pollMaxAttempts || 60
-    });
-
-    // 7. Display results
-    console.log(chalk.green('\n✅ Deployment initiated successfully'));
-    if (result.deploymentUrl) {
-      console.log(chalk.blue(`   URL: ${result.deploymentUrl}`));
-    }
-    if (result.deploymentId) {
-      console.log(chalk.blue(`   Deployment ID: ${result.deploymentId}`));
-    }
-    if (result.status) {
-      const statusIcon = result.status.status === 'completed' ? '✅' :
-        result.status.status === 'failed' ? '❌' : '⏳';
-      console.log(chalk.blue(`   Status: ${statusIcon} ${result.status.status}`));
-    }
+    // 6. Display results
+    displayDeploymentResults(result);
 
     return result;