@aifabrix/builder 2.39.2 → 2.40.0

package/lib/cli/setup-external-system.js

@@ -8,11 +8,7 @@
 
 const { handleCommandError } = require('../utils/cli-utils');
 
-/**
- * Sets up external system commands
- * @param {Command} program - Commander program instance
- */
-function setupExternalSystemCommands(program) {
+function setupDownloadCommand(program) {
   program.command('download <system-key>')
     .description('Download external system from dataplane to local development structure')
     .option('--dry-run', 'Show what would be downloaded without actually downloading')
@@ -25,17 +21,32 @@ function setupExternalSystemCommands(program) {
         process.exit(1);
       }
     });
+}
+
+function setupUploadCommand(program) {
+  program.command('upload <system-key>')
+    .description('Upload external system to dataplane (upload → validate → publish; no controller deploy)')
+    .option('--dry-run', 'Validate and build payload only; no API calls')
+    .option('--dataplane <url>', 'Dataplane URL (default: discovered from controller)')
+    .action(async(systemKey, options) => {
+      try {
+        const upload = require('../commands/upload');
+        await upload.uploadExternalSystem(systemKey, options);
+      } catch (error) {
+        handleCommandError(error, 'upload');
+        process.exit(1);
+      }
+    });
+}
 
+function setupDeleteCommand(program) {
   program.command('delete <system-key>')
     .description('Delete external system from dataplane (also deletes all associated datasources)')
-    .option('--type <type>', 'Application type (external) - required for external systems')
+    .option('--type <type>', 'Application type (default: external; use "external" to target integration/<app>)')
     .option('--yes', 'Skip confirmation prompt')
     .option('--force', 'Skip confirmation prompt (alias for --yes)')
     .action(async(systemKey, options) => {
       try {
-        if (options.type !== 'external') {
-          throw new Error('Delete command for external systems requires --type external');
-        }
         const externalDelete = require('../external-system/delete');
         await externalDelete.deleteExternalSystem(systemKey, options);
       } catch (error) {
@@ -43,7 +54,9 @@ function setupExternalSystemCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupExternalSystemTestCommands(program) {
   program.command('test <app>')
     .description('Run unit tests for external system (local validation, no API calls)')
     .option('-d, --datasource <key>', 'Test specific datasource only')
@@ -53,15 +66,12 @@ function setupExternalSystemCommands(program) {
         const test = require('../external-system/test');
         const results = await test.testExternalSystem(appName, options);
         test.displayTestResults(results, options.verbose);
-        if (!results.valid) {
-          process.exit(1);
-        }
+        if (!results.valid) process.exit(1);
       } catch (error) {
         handleCommandError(error, 'test');
         process.exit(1);
       }
     });
-
   program.command('test-integration <app>')
     .description('Run integration tests via dataplane pipeline API')
     .option('-d, --datasource <key>', 'Test specific datasource only')
@@ -74,9 +84,7 @@ function setupExternalSystemCommands(program) {
         const test = require('../external-system/test');
         const results = await test.testExternalSystemIntegration(appName, options);
         test.displayIntegrationTestResults(results, options.verbose);
-        if (!results.success) {
-          process.exit(1);
-        }
+        if (!results.success) process.exit(1);
       } catch (error) {
         handleCommandError(error, 'test-integration');
         process.exit(1);
@@ -84,4 +92,15 @@ function setupExternalSystemCommands(program) {
     });
 }
 
+/**
+ * Sets up external system commands
+ * @param {Command} program - Commander program instance
+ */
+function setupExternalSystemCommands(program) {
+  setupDownloadCommand(program);
+  setupUploadCommand(program);
+  setupDeleteCommand(program);
+  setupExternalSystemTestCommands(program);
+}
+
 module.exports = { setupExternalSystemCommands };

package/lib/cli/setup-infra.js

@@ -48,11 +48,7 @@ async function runUpInfraCommand(options) {
   await infra.startInfra(developerId, { traefik: useTraefik });
 }
 
-/**
- * Sets up infrastructure commands
- * @param {Command} program - Commander program instance
- */
-function setupInfraCommands(program) {
+function setupUpInfraCommand(program) {
   program.command('up-infra')
     .description('Start local infrastructure: Postgres, Redis, optional Traefik')
     .option('-d, --developer <id>', 'Set developer ID and start infrastructure')
@@ -66,7 +62,9 @@ function setupInfraCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupUpPlatformCommand(program) {
   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)')
@@ -81,7 +79,9 @@ function setupInfraCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupUpMisoCommand(program) {
   program.command('up-miso')
     .description('Install keycloak and miso-controller from images (no build). Infra must be up. For dataplane use up-dataplane. Uses auto-generated secrets for testing.')
     .option('-r, --registry <url>', 'Override registry for all apps (e.g. myacr.azurecr.io)')
@@ -95,7 +95,9 @@ function setupInfraCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupUpDataplaneCommand(program) {
   program.command('up-dataplane')
     .description('Register, deploy, then run dataplane app locally in dev (always local deployment; requires login, environment must be dev)')
     .option('-r, --registry <url>', 'Override registry for dataplane image')
@@ -109,7 +111,9 @@ function setupInfraCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupDownInfraCommand(program) {
   program.command('down-infra [app]')
     .description('Stop and remove local infrastructure services or a specific application')
     .option('-v, --volumes', 'Remove volumes (deletes all data)')
@@ -118,34 +122,30 @@ function setupInfraCommands(program) {
         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();
-          }
+          if (options.volumes) await infra.stopInfraWithVolumes();
+          else await infra.stopInfra();
         }
       } catch (error) {
         handleCommandError(error, 'down-infra');
         process.exit(1);
       }
     });
+}
 
+function setupDoctorCommand(program) {
   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();
@@ -158,37 +158,35 @@ function setupInfraCommands(program) {
             logger.log('\n🏥 Infrastructure: Not running');
           }
         }
-
         logger.log('');
       } catch (error) {
         handleCommandError(error, 'doctor');
         process.exit(1);
       }
     });
+}
 
+function setupStatusCommand(program) {
   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' ? '✅' : '❌';
+          const icon = String(info.status).trim().toLowerCase() === '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') ? '✅' : '❌';
+            const s = String(appInfo.status).trim().toLowerCase();
+            const icon = s.includes('running') || s.includes('up') ? '✅' : '❌';
             logger.log(`${icon} ${appInfo.name}:`);
             logger.log(`   Container: ${appInfo.container}`);
             logger.log(`   Port: ${appInfo.port}`);
@@ -202,13 +200,22 @@ function setupInfraCommands(program) {
         process.exit(1);
       }
     });
+}
 
+const INFRA_SERVICES = ['postgres', 'redis', 'pgadmin', 'redis-commander', 'traefik'];
+
+function setupRestartCommand(program) {
   program.command('restart <service>')
-    .description('Restart a specific infrastructure service')
+    .description('Restart an infrastructure service or a Docker application (builder/<app>)')
     .action(async(service) => {
       try {
-        await infra.restartService(service);
-        logger.log(`✅ ${service} service restarted successfully`);
+        if (INFRA_SERVICES.includes(service)) {
+          await infra.restartService(service);
+          logger.log(`✅ ${service} service restarted successfully`);
+        } else {
+          await appLib.restartApp(service);
+          logger.log(`✅ ${service} restarted successfully`);
+        }
       } catch (error) {
         handleCommandError(error, 'restart');
         process.exit(1);
@@ -216,4 +223,19 @@ function setupInfraCommands(program) {
     });
 }
 
+/**
+ * Sets up infrastructure commands
+ * @param {Command} program - Commander program instance
+ */
+function setupInfraCommands(program) {
+  setupUpInfraCommand(program);
+  setupUpPlatformCommand(program);
+  setupUpMisoCommand(program);
+  setupUpDataplaneCommand(program);
+  setupDownInfraCommand(program);
+  setupDoctorCommand(program);
+  setupStatusCommand(program);
+  setupRestartCommand(program);
+}
+
 module.exports = { setupInfraCommands };

package/lib/cli/setup-utility.js

@@ -12,9 +12,21 @@ 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 { handleCommandError, logOfflinePathWhenType } = require('../utils/cli-utils');
 const { detectAppType, getDeployJsonPath } = require('../utils/paths');
 
+/**
+ * Resolve app path and type for split-json (integration first, then builder).
+ *
+ * @param {string} appName - Application name
+ * @param {Object} [_options] - Command options (reserved)
+ * @returns {Promise<{appPath: string, appType: string}>}
+ */
+async function resolveSplitJsonApp(appName, _options) {
+  const { appPath, appType } = await detectAppType(appName);
+  return { appPath, appType };
+}
+
 /**
  * Handles split-json command logic
  * @async
@@ -23,15 +35,22 @@ const { detectAppType, getDeployJsonPath } = require('../utils/paths');
  * @returns {Promise<Object>} Paths to generated files
  */
 async function handleSplitJsonCommand(appName, options) {
-  const { appPath, appType } = await detectAppType(appName, options);
+  const { appPath, appType } = await resolveSplitJsonApp(appName, options);
+  logOfflinePathWhenType(appPath);
 
   const outputDir = options.output || appPath;
   if (appType === 'external') {
+    const deployJsonPath = getDeployJsonPath(appName, 'external', true);
+    if (fs.existsSync(deployJsonPath)) {
+      return generator.splitDeployJson(deployJsonPath, outputDir);
+    }
     const schemaPath = path.join(appPath, 'application-schema.json');
-    if (!fs.existsSync(schemaPath)) {
-      throw new Error(`application-schema.json not found: ${schemaPath}`);
+    if (fs.existsSync(schemaPath)) {
+      return generator.splitExternalApplicationSchema(schemaPath, outputDir);
     }
-    return generator.splitExternalApplicationSchema(schemaPath, outputDir);
+    throw new Error(
+      `No deployment or schema file found. Expected one of:\n  • ${deployJsonPath}\n  • ${schemaPath}\n\nRun "aifabrix json ${appName}" to generate the deploy JSON, or provide application-schema.json.`
+    );
   }
 
   const deployJsonPath = getDeployJsonPath(appName, appType, true);
@@ -50,18 +69,20 @@ async function handleSplitJsonCommand(appName, options) {
 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}`);
+  logger.log(`  • application.yaml: ${result.variables}`);
+  if (result.systemFile) {
+    logger.log(`  • system: ${result.systemFile}`);
+  }
+  if (result.datasourceFiles && result.datasourceFiles.length > 0) {
+    result.datasourceFiles.forEach(filePath => logger.log(`  • datasource: ${filePath}`));
+  }
   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) {
+function setupResolveCommand(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')
@@ -70,7 +91,6 @@ function setupUtilityCommands(program) {
       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);
@@ -85,26 +105,24 @@ function setupUtilityCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupJsonCommand(program) {
   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}`));
+            result.validation.warnings.forEach(w => logger.log(`   • ${w}`));
           }
         } else {
           logger.log('❌ Validation failed:');
-          if (result.validation.errors && result.validation.errors.length > 0) {
-            result.validation.errors.forEach(error => logger.log(`   • ${error}`));
-          }
+          (result.validation.errors || []).forEach(e => logger.log(`   • ${e}`));
           process.exit(1);
         }
       } catch (error) {
@@ -112,21 +130,41 @@ function setupUtilityCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupSplitJsonConvertShowCommands(program) {
   program.command('split-json <app>')
-    .description('Split deployment JSON into component files (env.template, variables.yaml, rbac.yml, README.md)')
+    .description('Split deployment JSON into component files (env.template, application.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);
+        logSplitJsonResult(await handleSplitJsonCommand(appName, options));
       } catch (error) {
         handleCommandError(error, 'split-json');
         process.exit(1);
       }
     });
 
+  program.command('convert <app>')
+    .description('Convert integration/external system and datasource config files between JSON and YAML')
+    .option('--format <format>', 'Target format: json | yaml (required)')
+    .option('-f, --force', 'Skip confirmation prompt')
+    .action(async(appName, options) => {
+      try {
+        const { runConvert } = require('../commands/convert');
+        const { converted, deleted } = await runConvert(appName, { format: options.format, force: options.force });
+        logger.log(chalk.green('\n✓ Convert complete.'));
+        converted.forEach(p => logger.log(`  • ${p}`));
+        if (deleted.length > 0) {
+          logger.log(chalk.gray('  Removed old files:'));
+          deleted.forEach(p => logger.log(chalk.gray(`    ${p}`)));
+        }
+      } catch (error) {
+        handleCommandError(error, 'convert');
+        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')
@@ -140,18 +178,17 @@ function setupUtilityCommands(program) {
         process.exit(1);
       }
     });
+}
 
+function setupValidateDiffCommands(program) {
   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);
-        }
+        if (!result.valid) process.exit(1);
       } catch (error) {
         handleCommandError(error, 'validate');
         process.exit(1);
@@ -160,14 +197,14 @@ function setupUtilityCommands(program) {
 
   program.command('diff <file1> <file2>')
     .description('Compare two configuration files (for deployment pipeline)')
-    .action(async(file1, file2) => {
+    .option('--no-validate', 'Skip schema validation (type check still applied)')
+    .action(async(file1, file2, cmd) => {
       try {
         const diff = require('../core/diff');
-        const result = await diff.compareFiles(file1, file2);
+        const opts = cmd.opts();
+        const result = await diff.compareFiles(file1, file2, { validate: opts.validate !== false });
         diff.formatDiffOutput(result);
-        if (!result.identical) {
-          process.exit(1);
-        }
+        if (!result.identical) process.exit(1);
       } catch (error) {
         handleCommandError(error, 'diff');
         process.exit(1);
@@ -175,4 +212,15 @@ function setupUtilityCommands(program) {
     });
 }
 
+/**
+ * Sets up utility commands
+ * @param {Command} program - Commander program instance
+ */
+function setupUtilityCommands(program) {
+  setupResolveCommand(program);
+  setupJsonCommand(program);
+  setupSplitJsonConvertShowCommands(program);
+  setupValidateDiffCommands(program);
+}
+
 module.exports = { setupUtilityCommands };