@aifabrix/builder 2.36.2 → 2.37.5

package/lib/cli/setup-infra.js

@@ -0,0 +1,219 @@
+/**
+ * CLI infrastructure command setup (up-infra, up-platform, up-miso, up-dataplane, down-infra, doctor, status, restart).
+ *
+ * @fileoverview Infrastructure command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const infra = require('../infrastructure');
+const appLib = require('../app');
+const validator = require('../validation/validator');
+const config = require('../core/config');
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+const { handleUpMiso } = require('../commands/up-miso');
+const { handleUpDataplane } = require('../commands/up-dataplane');
+
+/**
+ * Runs the up-infra command: resolves developer ID, traefik, and starts infra.
+ * @param {Object} options - Commander options (developer, traefik)
+ * @returns {Promise<void>}
+ */
+async function runUpInfraCommand(options) {
+  await config.ensureSecretsEncryptionKey();
+  let developerId = null;
+  if (options.developer) {
+    const id = parseInt(options.developer, 10);
+    if (isNaN(id) || id < 0) {
+      throw new Error('Developer ID must be a non-negative number (0 = default infra, > 0 = developer-specific)');
+    }
+    await config.setDeveloperId(id);
+    process.env.AIFABRIX_DEVELOPERID = id.toString();
+    developerId = id;
+    logger.log(chalk.green(`✓ Developer ID set to ${id}`));
+  }
+  const cfg = await config.getConfig();
+  if (options.traefik === true) {
+    cfg.traefik = true;
+    await config.saveConfig(cfg);
+    logger.log(chalk.green('✓ Traefik enabled and saved to config'));
+  } else if (options.traefik === false) {
+    cfg.traefik = false;
+    await config.saveConfig(cfg);
+    logger.log(chalk.green('✓ Traefik disabled and saved to config'));
+  }
+  const useTraefik = options.traefik === true ? true : (options.traefik === false ? false : !!(cfg.traefik));
+  await infra.startInfra(developerId, { traefik: useTraefik });
+}
+
+/**
+ * Sets up infrastructure commands
+ * @param {Command} program - Commander program instance
+ */
+function setupInfraCommands(program) {
+  program.command('up-infra')
+    .description('Start local infrastructure: Postgres, Redis, optional Traefik')
+    .option('-d, --developer <id>', 'Set developer ID and start infrastructure')
+    .option('--traefik', 'Include Traefik reverse proxy and save to config')
+    .option('--no-traefik', 'Exclude Traefik and save to config')
+    .action(async(options) => {
+      try {
+        await runUpInfraCommand(options);
+      } catch (error) {
+        handleCommandError(error, 'up-infra');
+        process.exit(1);
+      }
+    });
+
+  program.command('up-platform')
+    .description('Start platform (Keycloak, Miso Controller, Dataplane) from community images; infra must be up')
+    .option('-r, --registry <url>', 'Override registry for all apps (e.g. myacr.azurecr.io)')
+    .option('--registry-mode <mode>', 'Override registry mode (acr|external)')
+    .option('-i, --image <key>=<value>', 'Override image (e.g. keycloak=myreg/k:v1, miso-controller=myreg/m:v1, dataplane=myreg/d:v1); can be repeated', (v, prev) => (prev || []).concat([v]))
+    .action(async(options) => {
+      try {
+        await handleUpMiso(options);
+        await handleUpDataplane(options);
+      } catch (error) {
+        handleCommandError(error, 'up-platform');
+        process.exit(1);
+      }
+    });
+
+  program.command('up-miso')
+    .description('Install keycloak, miso-controller, and dataplane from images (no build). Infra must be up. Uses auto-generated secrets for testing.')
+    .option('-r, --registry <url>', 'Override registry for all apps (e.g. myacr.azurecr.io)')
+    .option('--registry-mode <mode>', 'Override registry mode (acr|external)')
+    .option('-i, --image <key>=<value>', 'Override image (e.g. keycloak=myreg/k:v1, miso-controller=myreg/m:v1, dataplane=myreg/d:v1); can be repeated', (v, prev) => (prev || []).concat([v]))
+    .action(async(options) => {
+      try {
+        await handleUpMiso(options);
+      } catch (error) {
+        handleCommandError(error, 'up-miso');
+        process.exit(1);
+      }
+    });
+
+  program.command('up-dataplane')
+    .description('Register and deploy dataplane app in dev (requires login, environment must be dev)')
+    .option('-r, --registry <url>', 'Override registry for dataplane image')
+    .option('--registry-mode <mode>', 'Override registry mode (acr|external)')
+    .option('-i, --image <ref>', 'Override dataplane image reference (e.g. myreg/dataplane:latest)')
+    .action(async(options) => {
+      try {
+        await handleUpDataplane(options);
+      } catch (error) {
+        handleCommandError(error, 'up-dataplane');
+        process.exit(1);
+      }
+    });
+
+  program.command('down-infra [app]')
+    .description('Stop and remove local infrastructure services or a specific application')
+    .option('-v, --volumes', 'Remove volumes (deletes all data)')
+    .action(async(appName, options) => {
+      try {
+        if (typeof appName === 'string' && appName.trim().length > 0) {
+          await appLib.downApp(appName, { volumes: !!options.volumes });
+        } else {
+          if (options.volumes) {
+            await infra.stopInfraWithVolumes();
+          } else {
+            await infra.stopInfra();
+          }
+        }
+      } catch (error) {
+        handleCommandError(error, 'down-infra');
+        process.exit(1);
+      }
+    });
+
+  program.command('doctor')
+    .description('Check environment and configuration')
+    .action(async() => {
+      try {
+        const result = await validator.checkEnvironment();
+        logger.log('\n🔍 AI Fabrix Environment Check\n');
+
+        logger.log(`Docker: ${result.docker === 'ok' ? '✅ Running' : '❌ Not available'}`);
+        logger.log(`Ports: ${result.ports === 'ok' ? '✅ Available' : '⚠️  Some ports in use'}`);
+        logger.log(`Secrets: ${result.secrets === 'ok' ? '✅ Configured' : '❌ Missing'}`);
+
+        if (result.recommendations.length > 0) {
+          logger.log('\n📋 Recommendations:');
+          result.recommendations.forEach(rec => logger.log(`  • ${rec}`));
+        }
+
+        if (result.docker === 'ok') {
+          try {
+            const health = await infra.checkInfraHealth();
+            logger.log('\n🏥 Infrastructure Health:');
+            Object.entries(health).forEach(([service, status]) => {
+              const icon = status === 'healthy' ? '✅' : status === 'unknown' ? '❓' : '❌';
+              logger.log(`  ${icon} ${service}: ${status}`);
+            });
+          } catch (error) {
+            logger.log('\n🏥 Infrastructure: Not running');
+          }
+        }
+
+        logger.log('');
+      } catch (error) {
+        handleCommandError(error, 'doctor');
+        process.exit(1);
+      }
+    });
+
+  program.command('status')
+    .description('Show detailed infrastructure service status and running applications')
+    .action(async() => {
+      try {
+        const status = await infra.getInfraStatus();
+        logger.log('\n📊 Infrastructure Status\n');
+
+        Object.entries(status).forEach(([service, info]) => {
+          const normalizedStatus = String(info.status).trim().toLowerCase();
+          const icon = normalizedStatus === 'running' ? '✅' : '❌';
+          logger.log(`${icon} ${service}:`);
+          logger.log(`   Status: ${info.status}`);
+          logger.log(`   Port: ${info.port}`);
+          logger.log(`   URL: ${info.url}`);
+          logger.log('');
+        });
+
+        const apps = await infra.getAppStatus();
+        if (apps.length > 0) {
+          logger.log('📱 Running Applications\n');
+          apps.forEach((appInfo) => {
+            const normalizedStatus = String(appInfo.status).trim().toLowerCase();
+            const icon = normalizedStatus.includes('running') || normalizedStatus.includes('up') ? '✅' : '❌';
+            logger.log(`${icon} ${appInfo.name}:`);
+            logger.log(`   Container: ${appInfo.container}`);
+            logger.log(`   Port: ${appInfo.port}`);
+            logger.log(`   Status: ${appInfo.status}`);
+            logger.log(`   URL: ${appInfo.url}`);
+            logger.log('');
+          });
+        }
+      } catch (error) {
+        handleCommandError(error, 'status');
+        process.exit(1);
+      }
+    });
+
+  program.command('restart <service>')
+    .description('Restart a specific infrastructure service')
+    .action(async(service) => {
+      try {
+        await infra.restartService(service);
+        logger.log(`✅ ${service} service restarted successfully`);
+      } catch (error) {
+        handleCommandError(error, 'restart');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupInfraCommands };

package/lib/cli/setup-secrets.js

@@ -0,0 +1,48 @@
+/**
+ * CLI secrets and security command setup (secrets set, secure).
+ *
+ * @fileoverview Secrets command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { handleCommandError } = require('../utils/cli-utils');
+const { handleSecretsSet } = require('../commands/secrets-set');
+const { handleSecure } = require('../commands/secure');
+
+/**
+ * Sets up secrets and security commands
+ * @param {Command} program - Commander program instance
+ */
+function setupSecretsCommands(program) {
+  const secretsCmd = program
+    .command('secrets')
+    .description('Manage secrets in secrets files');
+
+  secretsCmd
+    .command('set <key> <value>')
+    .description('Set a secret value in secrets file')
+    .option('--shared', 'Save to general secrets file (from config.yaml aifabrix-secrets) instead of user secrets')
+    .action(async(key, value, options) => {
+      try {
+        await handleSecretsSet(key, value, options);
+      } catch (error) {
+        handleCommandError(error, 'secrets set');
+        process.exit(1);
+      }
+    });
+
+  program.command('secure')
+    .description('Encrypt secrets in secrets.local.yaml files for ISO 27001 compliance')
+    .option('--secrets-encryption <key>', 'Encryption key (32 bytes, hex or base64)')
+    .action(async(options) => {
+      try {
+        await handleSecure(options);
+      } catch (error) {
+        handleCommandError(error, 'secure');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupSecretsCommands };

package/lib/cli/setup-utility.js

@@ -0,0 +1,202 @@
+/**
+ * CLI utility command setup (resolve, json, split-json, genkey, show, validate, diff).
+ *
+ * @fileoverview Utility command definitions for AI Fabrix Builder CLI
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const secrets = require('../core/secrets');
+const generator = require('../generator');
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+const { detectAppType, getDeployJsonPath } = require('../utils/paths');
+
+/**
+ * Handles split-json command logic
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - Command options
+ * @returns {Promise<Object>} Paths to generated files
+ */
+async function handleSplitJsonCommand(appName, options) {
+  const { appPath, appType } = await detectAppType(appName, options);
+
+  const outputDir = options.output || appPath;
+  if (appType === 'external') {
+    const schemaPath = path.join(appPath, 'application-schema.json');
+    if (!fs.existsSync(schemaPath)) {
+      throw new Error(`application-schema.json not found: ${schemaPath}`);
+    }
+    return generator.splitExternalApplicationSchema(schemaPath, outputDir);
+  }
+
+  const deployJsonPath = getDeployJsonPath(appName, appType, true);
+  if (!fs.existsSync(deployJsonPath)) {
+    throw new Error(`Deployment JSON file not found: ${deployJsonPath}`);
+  }
+
+  return generator.splitDeployJson(deployJsonPath, outputDir);
+}
+
+/**
+ * Logs split-json results
+ * @param {Object} result - Generated file paths
+ * @returns {void}
+ */
+function logSplitJsonResult(result) {
+  logger.log(chalk.green('\n✓ Successfully split deployment JSON into component files:'));
+  logger.log(`  • env.template: ${result.envTemplate}`);
+  logger.log(`  • variables.yaml: ${result.variables}`);
+  if (result.rbac) {
+    logger.log(`  • rbac.yml: ${result.rbac}`);
+  }
+  logger.log(`  • README.md: ${result.readme}`);
+}
+
+/**
+ * Sets up utility commands
+ * @param {Command} program - Commander program instance
+ */
+function setupUtilityCommands(program) {
+  program.command('resolve <app>')
+    .description('Generate .env file from template and validate application files')
+    .option('-f, --force', 'Generate missing secret keys in secrets file')
+    .option('--skip-validation', 'Skip file validation after generating .env')
+    .action(async(appName, options) => {
+      try {
+        const envPath = await secrets.generateEnvFile(appName, undefined, 'docker', options.force);
+        logger.log(`✓ Generated .env file: ${envPath}`);
+
+        if (!options.skipValidation) {
+          const validate = require('../validation/validate');
+          const result = await validate.validateAppOrFile(appName);
+          validate.displayValidationResults(result);
+          if (!result.valid) {
+            logger.log(chalk.yellow('\n⚠️  Validation found errors. Fix them before deploying.'));
+            process.exit(1);
+          }
+        }
+      } catch (error) {
+        handleCommandError(error, 'resolve');
+        process.exit(1);
+      }
+    });
+
+  program.command('json <app>')
+    .description('Generate deployment JSON to disk (<app>-deploy.json). Use before commit so version control has the correct file.')
+    .option('--type <type>', 'Application type (external) - if set, only checks integration folder')
+    .action(async(appName, options) => {
+      try {
+        const result = await generator.generateDeployJsonWithValidation(appName, options);
+        if (result.success) {
+          const fileName = result.path.includes('application-schema.json') ? 'application-schema.json' : 'deployment JSON';
+          logger.log(`✓ Generated ${fileName}: ${result.path}`);
+
+          if (result.validation.warnings && result.validation.warnings.length > 0) {
+            logger.log('\n⚠️  Warnings:');
+            result.validation.warnings.forEach(warning => logger.log(`   • ${warning}`));
+          }
+        } else {
+          logger.log('❌ Validation failed:');
+          if (result.validation.errors && result.validation.errors.length > 0) {
+            result.validation.errors.forEach(error => logger.log(`   • ${error}`));
+          }
+          process.exit(1);
+        }
+      } catch (error) {
+        handleCommandError(error, 'json');
+        process.exit(1);
+      }
+    });
+
+  program.command('split-json <app>')
+    .description('Split deployment JSON into component files (env.template, variables.yaml, rbac.yml, README.md)')
+    .option('-o, --output <dir>', 'Output directory for component files (defaults to same directory as JSON)')
+    .option('--type <type>', 'Application type (external) - if set, only checks integration folder')
+    .action(async(appName, options) => {
+      try {
+        const result = await handleSplitJsonCommand(appName, options);
+        logSplitJsonResult(result);
+      } catch (error) {
+        handleCommandError(error, 'split-json');
+        process.exit(1);
+      }
+    });
+
+  program.command('genkey <app>')
+    .description('Generate deployment key')
+    .action(async(appName) => {
+      try {
+        const jsonPath = await generator.generateDeployJson(appName);
+
+        const jsonContent = fs.readFileSync(jsonPath, 'utf8');
+        const deployment = JSON.parse(jsonContent);
+
+        const key = deployment.deploymentKey;
+
+        if (!key) {
+          throw new Error('deploymentKey not found in generated JSON');
+        }
+
+        logger.log(`\nDeployment key for ${appName}:`);
+        logger.log(key);
+        logger.log(chalk.gray(`\nGenerated from: ${jsonPath}`));
+      } catch (error) {
+        handleCommandError(error, 'genkey');
+        process.exit(1);
+      }
+    });
+
+  program.command('show <appKey>')
+    .description('Show application info from local builder/ or integration/ (offline) or from controller (--online)')
+    .option('--online', 'Fetch application data from the controller')
+    .option('--json', 'Output as JSON')
+    .action(async(appKey, options) => {
+      try {
+        const { showApp } = require('../app/show');
+        await showApp(appKey, { online: options.online, json: options.json });
+      } catch (error) {
+        logger.error(chalk.red(`Error: ${error.message}`));
+        process.exit(1);
+      }
+    });
+
+  program.command('validate <appOrFile>')
+    .description('Validate application or external integration file')
+    .option('--type <type>', 'Application type (external) - if set, only checks integration folder')
+    .action(async(appOrFile, options) => {
+      try {
+        const validate = require('../validation/validate');
+        const result = await validate.validateAppOrFile(appOrFile, options);
+        validate.displayValidationResults(result);
+        if (!result.valid) {
+          process.exit(1);
+        }
+      } catch (error) {
+        handleCommandError(error, 'validate');
+        process.exit(1);
+      }
+    });
+
+  program.command('diff <file1> <file2>')
+    .description('Compare two configuration files (for deployment pipeline)')
+    .action(async(file1, file2) => {
+      try {
+        const diff = require('../core/diff');
+        const result = await diff.compareFiles(file1, file2);
+        diff.formatDiffOutput(result);
+        if (!result.identical) {
+          process.exit(1);
+        }
+      } catch (error) {
+        handleCommandError(error, 'diff');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupUtilityCommands };