@aifabrix/builder 2.8.0 → 2.10.0

package/lib/app.js

@@ -24,6 +24,7 @@ const { loadTemplateVariables, updateTemplateVariables, mergeTemplateVariables }
 const logger = require('./utils/logger');
 const auditLogger = require('./audit-logger');
 const { downApp } = require('./app-down');
+const { getAppPath } = require('./utils/paths');
 
 /**
  * Displays success message after app creation
@@ -31,10 +32,15 @@ const { downApp } = require('./app-down');
  * @param {Object} config - Final configuration
  * @param {string} envConversionMessage - Environment conversion message
  */
-function displaySuccessMessage(appName, config, envConversionMessage, hasAppFiles = false) {
+function displaySuccessMessage(appName, config, envConversionMessage, hasAppFiles = false, appPath = null) {
   logger.log(chalk.green('\n✓ Application created successfully!'));
   logger.log(chalk.blue(`\nApplication: ${appName}`));
-  logger.log(chalk.blue(`Location: builder/${appName}/`));
+
+  // Determine location based on app type
+  const baseDir = config.type === 'external' ? 'integration' : 'builder';
+  const location = appPath ? path.relative(process.cwd(), appPath) : `${baseDir}/${appName}/`;
+  logger.log(chalk.blue(`Location: ${location}`));
+
   if (hasAppFiles) {
     logger.log(chalk.blue(`Application files: apps/${appName}/`));
   }
@@ -43,7 +49,7 @@ function displaySuccessMessage(appName, config, envConversionMessage, hasAppFile
     logger.log(chalk.blue('Type: External System'));
     logger.log(chalk.blue(`System Key: ${config.systemKey || appName}`));
     logger.log(chalk.green('\nNext steps:'));
-    logger.log(chalk.white('1. Edit external system JSON files in builder/' + appName + '/schemas/'));
+    logger.log(chalk.white('1. Edit external system JSON files in ' + location));
     logger.log(chalk.white('2. Run: aifabrix app register ' + appName + ' --environment dev'));
     logger.log(chalk.white('3. Run: aifabrix build ' + appName + ' (deploys to dataplane)'));
     logger.log(chalk.white('4. Run: aifabrix deploy ' + appName + ' (publishes to dataplane)'));
@@ -83,6 +89,16 @@ async function validateAppDirectoryNotExists(appPath, appName, baseDir = 'builde
   }
 }
 
+/**
+ * Gets the base directory path for an app based on its type
+ * @param {string} appName - Application name
+ * @param {string} appType - Application type ('external' or other)
+ * @returns {string} Base directory path ('integration' or 'builder')
+ */
+function getBaseDirForAppType(appType) {
+  return appType === 'external' ? 'integration' : 'builder';
+}
+
 /**
  * Handles GitHub workflow generation if requested
  * @async
@@ -124,9 +140,9 @@ async function handleGitHubWorkflows(options, config) {
  * @param {string} appPath - Application directory path
  * @throws {Error} If validation fails
  */
-async function validateAppCreation(appName, options, appPath) {
+async function validateAppCreation(appName, options, appPath, baseDir = 'builder') {
   validateAppName(appName);
-  await validateAppDirectoryNotExists(appPath, appName, 'builder');
+  await validateAppDirectoryNotExists(appPath, appName, baseDir);
 
   if (!options.app) {
     return;
@@ -272,10 +288,13 @@ async function createApp(appName, options = {}) {
       throw new Error('Application name is required');
     }
 
-    const builderPath = path.join(process.cwd(), 'builder');
-    const appPath = path.join(builderPath, appName);
+    // Determine app type from options (will be confirmed during prompts)
+    // For now, check if type is explicitly set in options
+    const initialType = options.type || 'webapp';
+    const baseDir = getBaseDirForAppType(initialType);
+    const appPath = getAppPath(appName, initialType);
 
-    await validateAppCreation(appName, options, appPath);
+    await validateAppCreation(appName, options, appPath, baseDir);
 
     if (options.template) {
       await validateTemplate(options.template);
@@ -285,28 +304,37 @@ async function createApp(appName, options = {}) {
     const mergedOptions = mergeTemplateVariables(options, templateVariables);
     const config = await promptForOptions(appName, mergedOptions);
 
-    await fs.mkdir(appPath, { recursive: true });
-    await processTemplateFiles(options.template, appPath, appName, options, config);
+    // Update appPath based on final config type (may have changed during prompts)
+    const finalBaseDir = getBaseDirForAppType(config.type);
+    const finalAppPath = getAppPath(appName, config.type);
+
+    // If path changed, validate the new path
+    if (finalAppPath !== appPath) {
+      await validateAppDirectoryNotExists(finalAppPath, appName, finalBaseDir);
+    }
+
+    await fs.mkdir(finalAppPath, { recursive: true });
+    await processTemplateFiles(options.template, finalAppPath, appName, options, config);
 
     const existingEnv = await readExistingEnv(process.cwd());
     const envConversionMessage = existingEnv
       ? '\n✓ Found existing .env file - sensitive values will be converted to kv:// references'
       : '';
 
-    await generateConfigFiles(appPath, appName, config, existingEnv);
+    await generateConfigFiles(finalAppPath, appName, config, existingEnv);
 
     // Generate external system files if type is external
     if (config.type === 'external') {
       const externalGenerator = require('./external-system-generator');
-      await externalGenerator.generateExternalSystemFiles(appPath, appName, config);
+      await externalGenerator.generateExternalSystemFiles(finalAppPath, appName, config);
     }
 
     if (options.app) {
-      await setupAppFiles(appName, appPath, config, options);
+      await setupAppFiles(appName, finalAppPath, config, options);
     }
 
     await handleGitHubWorkflows(options, config);
-    displaySuccessMessage(appName, config, envConversionMessage, options.app);
+    displaySuccessMessage(appName, config, envConversionMessage, options.app, finalAppPath);
 
     // Log application creation for audit trail
     await auditLogger.logApplicationCreation(appName, {

package/lib/build.js

@@ -14,6 +14,7 @@ const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
 const paths = require('./utils/paths');
+const { detectAppType } = require('./utils/paths');
 const { exec } = require('child_process');
 const { promisify } = require('util');
 const chalk = require('chalk');
@@ -68,9 +69,17 @@ async function copyTemplateFilesToDevDir(templatePath, devDir, _language) {
     const sourcePath = path.join(templatePath, entry);
     const targetPath = path.join(devDir, entry);
 
-    const entryStats = await fs.stat(sourcePath);
-    if (entryStats.isFile()) {
-      await fs.copyFile(sourcePath, targetPath);
+    // Skip if source file doesn't exist (e.g., .gitignore might not be in template)
+    try {
+      const entryStats = await fs.stat(sourcePath);
+      if (entryStats.isFile()) {
+        await fs.copyFile(sourcePath, targetPath);
+      }
+    } catch (error) {
+      // Skip files that don't exist (e.g., .gitignore might not be in template)
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
     }
   }
 }
@@ -82,7 +91,9 @@ async function copyTemplateFilesToDevDir(templatePath, devDir, _language) {
  * @throws {Error} If file cannot be loaded or parsed
  */
 async function loadVariablesYaml(appName) {
-  const variablesPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appName);
+  const variablesPath = path.join(appPath, 'variables.yaml');
 
   if (!fsSync.existsSync(variablesPath)) {
     throw new Error(`Configuration not found. Run 'aifabrix create ${appName}' first.`);
@@ -335,11 +346,12 @@ async function postBuildTasks(appName, buildConfig) {
  * // Returns: 'myapp:latest'
  */
 async function buildApp(appName, options = {}) {
-  // Check if app type is external - deploy to dataplane instead of Docker build
+  // Check if app type is external - generate JSON files only (not deploy)
   const variables = await loadVariablesYaml(appName);
   if (variables.app && variables.app.type === 'external') {
-    const externalDeploy = require('./external-system-deploy');
-    await externalDeploy.buildExternalSystem(appName, options);
+    const generator = require('./generator');
+    const jsonPath = await generator.generateDeployJson(appName);
+    logger.log(chalk.green(`✓ Generated deployment JSON: ${jsonPath}`));
     return null;
   }
 
@@ -482,12 +494,4 @@ async function buildApp(appName, options = {}) {
   }
 }
 
-module.exports = {
-  loadVariablesYaml,
-  resolveContextPath,
-  executeDockerBuild: dockerBuild.executeDockerBuild,
-  detectLanguage,
-  generateDockerfile,
-  buildApp,
-  postBuildTasks
-};
+module.exports = { loadVariablesYaml, resolveContextPath, executeDockerBuild: dockerBuild.executeDockerBuild, detectLanguage, generateDockerfile, buildApp, postBuildTasks };

package/lib/cli.js

@@ -341,12 +341,13 @@ function setupCommands(program) {
     });
 
   program.command('json <app>')
-    .description('Generate deployment JSON')
+    .description('Generate deployment JSON (aifabrix-deploy.json for normal apps, application-schema.json for external systems)')
     .action(async(appName) => {
       try {
         const result = await generator.generateDeployJsonWithValidation(appName);
         if (result.success) {
-          logger.log(`✓ Generated deployment JSON: ${result.path}`);
+          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:');
@@ -563,6 +564,64 @@ function setupCommands(program) {
         process.exit(1);
       }
     });
+
+  // External system download command
+  program.command('download <system-key>')
+    .description('Download external system from dataplane to local development structure')
+    .option('-e, --environment <env>', 'Environment (dev, tst, pro)', 'dev')
+    .option('-c, --controller <url>', 'Controller URL')
+    .option('--dry-run', 'Show what would be downloaded without actually downloading')
+    .action(async(systemKey, options) => {
+      try {
+        const download = require('./external-system-download');
+        await download.downloadExternalSystem(systemKey, options);
+      } catch (error) {
+        handleCommandError(error, 'download');
+        process.exit(1);
+      }
+    });
+
+  // Unit test command (local validation)
+  program.command('test <app>')
+    .description('Run unit tests for external system (local validation, no API calls)')
+    .option('-d, --datasource <key>', 'Test specific datasource only')
+    .option('-v, --verbose', 'Show detailed validation output')
+    .action(async(appName, options) => {
+      try {
+        const test = require('./external-system-test');
+        const results = await test.testExternalSystem(appName, options);
+        test.displayTestResults(results, options.verbose);
+        if (!results.valid) {
+          process.exit(1);
+        }
+      } catch (error) {
+        handleCommandError(error, 'test');
+        process.exit(1);
+      }
+    });
+
+  // Integration test command (via dataplane)
+  program.command('test-integration <app>')
+    .description('Run integration tests via dataplane pipeline API')
+    .option('-d, --datasource <key>', 'Test specific datasource only')
+    .option('-p, --payload <file>', 'Path to custom test payload file')
+    .option('-e, --environment <env>', 'Environment (dev, tst, pro)', 'dev')
+    .option('-c, --controller <url>', 'Controller URL')
+    .option('-v, --verbose', 'Show detailed test output')
+    .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
+    .action(async(appName, options) => {
+      try {
+        const test = require('./external-system-test');
+        const results = await test.testExternalSystemIntegration(appName, options);
+        test.displayIntegrationTestResults(results, options.verbose);
+        if (!results.success) {
+          process.exit(1);
+        }
+      } catch (error) {
+        handleCommandError(error, 'test-integration');
+        process.exit(1);
+      }
+    });
 }
 
 module.exports = {

package/lib/commands/login.js

@@ -359,7 +359,13 @@ async function handleDeviceCodeLogin(controllerUrl, environment, offline, scope)
     );
 
   } catch (deviceError) {
-    logger.error(chalk.red(`\n❌ Device code flow failed: ${deviceError.message}`));
+    // Display formatted error if available (includes detailed validation info)
+    if (deviceError.formattedError) {
+      logger.error(chalk.red('\n❌ Device code flow failed:'));
+      logger.log(deviceError.formattedError);
+    } else {
+      logger.error(chalk.red(`\n❌ Device code flow failed: ${deviceError.message}`));
+    }
     process.exit(1);
   }
 }

package/lib/datasource-deploy.js

@@ -129,39 +129,33 @@ async function deployDatasource(appKey, filePath, options) {
   const dataplaneUrl = await getDataplaneUrl(options.controller, appKey, options.environment, authConfig);
   logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
 
-  // Deploy to dataplane
-  logger.log(chalk.blue('\n🚀 Deploying to dataplane...'));
-  const deployEndpoint = `${dataplaneUrl}/api/v1/pipeline/${systemKey}/deploy`;
+  // Publish to dataplane (using publish endpoint)
+  logger.log(chalk.blue('\n🚀 Publishing datasource to dataplane...'));
+  const publishEndpoint = `${dataplaneUrl}/api/v1/pipeline/${systemKey}/publish`;
 
-  // Prepare deployment request
-  const deployRequest = {
-    datasource: datasourceConfig
-  };
-
-  // Make API call to dataplane
-  // This is a placeholder - actual API structure may vary
-  let deployResponse;
+  // Prepare publish request - send datasource configuration directly
+  let publishResponse;
   if (authConfig.type === 'bearer' && authConfig.token) {
-    deployResponse = await authenticatedApiCall(
-      deployEndpoint,
+    publishResponse = await authenticatedApiCall(
+      publishEndpoint,
       {
         method: 'POST',
-        body: JSON.stringify(deployRequest)
+        body: JSON.stringify(datasourceConfig)
       },
       authConfig.token
     );
   } else {
-    throw new Error('Bearer token authentication required for dataplane deployment');
+    throw new Error('Bearer token authentication required for dataplane publish');
   }
 
-  if (!deployResponse.success) {
-    const formattedError = deployResponse.formattedError || formatApiError(deployResponse);
-    logger.error(chalk.red('❌ Deployment failed:'));
+  if (!publishResponse.success) {
+    const formattedError = publishResponse.formattedError || formatApiError(publishResponse);
+    logger.error(chalk.red('❌ Publish failed:'));
     logger.error(formattedError);
-    throw new Error(`Dataplane deployment failed: ${formattedError}`);
+    throw new Error(`Dataplane publish failed: ${formattedError}`);
   }
 
-  logger.log(chalk.green('\n✓ Datasource deployed successfully!'));
+  logger.log(chalk.green('\n✓ Datasource published successfully!'));
   logger.log(chalk.blue(`\nDatasource: ${datasourceConfig.key || datasourceConfig.displayName}`));
   logger.log(chalk.blue(`System: ${systemKey}`));
   logger.log(chalk.blue(`Environment: ${options.environment}`));

package/lib/external-system-deploy.js

@@ -10,6 +10,7 @@
  */
 
 const fs = require('fs').promises;
+const fsSync = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
@@ -18,6 +19,8 @@ const { getDeploymentAuth } = require('./utils/token-manager');
 const { getConfig } = require('./config');
 const logger = require('./utils/logger');
 const { getDataplaneUrl } = require('./datasource-deploy');
+const { detectAppType, getDeployJsonPath } = require('./utils/paths');
+const { generateExternalSystemApplicationSchema } = require('./generator');
 
 /**
  * Loads variables.yaml for an application
@@ -28,7 +31,9 @@ const { getDataplaneUrl } = require('./datasource-deploy');
  * @throws {Error} If file cannot be loaded
  */
 async function loadVariablesYaml(appName) {
-  const variablesPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appName);
+  const variablesPath = path.join(appPath, 'variables.yaml');
   const content = await fs.readFile(variablesPath, 'utf8');
   return yaml.load(content);
 }
@@ -48,43 +53,69 @@ async function validateExternalSystemFiles(appName) {
     throw new Error('externalIntegration block not found in variables.yaml');
   }
 
-  const appPath = path.join(process.cwd(), 'builder', appName);
-  const schemasPath = path.join(appPath, variables.externalIntegration.schemaBasePath || './schemas');
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appName);
+
+  // For new structure, files are in same folder (schemaBasePath is usually './')
+  // For backward compatibility, support old schemas/ subfolder
+  const schemaBasePath = variables.externalIntegration.schemaBasePath || './';
+  const schemasPath = path.isAbsolute(schemaBasePath)
+    ? schemaBasePath
+    : path.join(appPath, schemaBasePath);
 
   // Validate system files
   const systemFiles = [];
   if (variables.externalIntegration.systems && variables.externalIntegration.systems.length > 0) {
     for (const systemFile of variables.externalIntegration.systems) {
-      const systemPath = path.join(schemasPath, systemFile);
-      try {
-        await fs.access(systemPath);
-        systemFiles.push(systemPath);
-      } catch {
-        throw new Error(`External system file not found: ${systemPath}`);
+      // Try new naming first: <app-name>-deploy.json in same folder
+      const newSystemPath = getDeployJsonPath(appName, 'external', true);
+      if (fsSync.existsSync(newSystemPath)) {
+        systemFiles.push(newSystemPath);
+      } else {
+        // Fall back to specified path
+        const systemPath = path.join(schemasPath, systemFile);
+        try {
+          await fs.access(systemPath);
+          systemFiles.push(systemPath);
+        } catch {
+          throw new Error(`External system file not found: ${systemPath} (also checked: ${newSystemPath})`);
+        }
       }
     }
   } else {
     throw new Error('No external system files specified in externalIntegration.systems');
   }
 
-  // Validate datasource files
+  // Validate datasource files (naming: <app-name>-deploy-<datasource-key>.json)
   const datasourceFiles = [];
   if (variables.externalIntegration.dataSources && variables.externalIntegration.dataSources.length > 0) {
     for (const datasourceFile of variables.externalIntegration.dataSources) {
-      const datasourcePath = path.join(schemasPath, datasourceFile);
+      // Try same folder first (new structure)
+      const datasourcePath = path.join(appPath, datasourceFile);
       try {
         await fs.access(datasourcePath);
         datasourceFiles.push(datasourcePath);
       } catch {
-        throw new Error(`External datasource file not found: ${datasourcePath}`);
+        // Fall back to schemaBasePath
+        const fallbackPath = path.join(schemasPath, datasourceFile);
+        try {
+          await fs.access(fallbackPath);
+          datasourceFiles.push(fallbackPath);
+        } catch {
+          throw new Error(`External datasource file not found: ${datasourcePath} or ${fallbackPath}`);
+        }
       }
     }
   }
 
+  // Extract systemKey from system file (remove -deploy.json suffix if present)
+  const systemFileName = path.basename(systemFiles[0], '.json');
+  const systemKey = systemFileName.replace(/-deploy$/, '');
+
   return {
     systemFiles,
     datasourceFiles,
-    systemKey: path.basename(systemFiles[0], '.json')
+    systemKey
   };
 }
 
@@ -172,11 +203,16 @@ async function buildExternalSystem(appName, options = {}) {
 }
 
 /**
- * Publishes external system to dataplane (deploy step - publish)
+ * Publishes external system to dataplane using application-level workflow
+ * Uses upload → validate → publish workflow for atomic deployment
  * @async
  * @function deployExternalSystem
  * @param {string} appName - Application name
  * @param {Object} options - Deployment options
+ * @param {string} [options.environment] - Environment (dev, tst, pro)
+ * @param {string} [options.controller] - Controller URL
+ * @param {boolean} [options.skipValidation] - Skip validation step and go straight to publish
+ * @param {boolean} [options.generateMcpContract] - Generate MCP contract (default: true)
  * @returns {Promise<void>} Resolves when deployment completes
  * @throws {Error} If deployment fails
  */
@@ -185,7 +221,12 @@ async function deployExternalSystem(appName, options = {}) {
     logger.log(chalk.blue(`\n🚀 Publishing external system: ${appName}`));
 
     // Validate files
-    const { systemFiles, datasourceFiles, systemKey } = await validateExternalSystemFiles(appName);
+    const { systemFiles: _systemFiles, datasourceFiles, systemKey } = await validateExternalSystemFiles(appName);
+
+    // Generate application-schema.json structure
+    logger.log(chalk.blue('📋 Generating application schema...'));
+    const applicationSchema = await generateExternalSystemApplicationSchema(appName);
+    logger.log(chalk.green('✓ Application schema generated'));
 
     // Get authentication
     const config = await getConfig();
@@ -202,53 +243,95 @@ async function deployExternalSystem(appName, options = {}) {
     const dataplaneUrl = await getDataplaneUrl(controllerUrl, appName, environment, authConfig);
     logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
 
-    // Publish external system
-    logger.log(chalk.blue(`Publishing external system: ${systemKey}...`));
-    const systemContent = await fs.readFile(systemFiles[0], 'utf8');
-    const systemJson = JSON.parse(systemContent);
-
-    const systemResponse = await authenticatedApiCall(
-      `${dataplaneUrl}/api/v1/pipeline/publish`,
+    // Step 1: Upload application
+    logger.log(chalk.blue('📤 Uploading application configuration...'));
+    const uploadResponse = await authenticatedApiCall(
+      `${dataplaneUrl}/api/v1/pipeline/upload`,
       {
         method: 'POST',
-        body: JSON.stringify(systemJson)
+        body: JSON.stringify(applicationSchema)
       },
       authConfig.token
     );
 
-    if (!systemResponse.success) {
-      throw new Error(`Failed to publish external system: ${systemResponse.error || systemResponse.formattedError}`);
+    if (!uploadResponse.success || !uploadResponse.data) {
+      throw new Error(`Failed to upload application: ${uploadResponse.error || uploadResponse.formattedError || 'Unknown error'}`);
     }
 
-    logger.log(chalk.green(`✓ External system published: ${systemKey}`));
+    const uploadData = uploadResponse.data.data || uploadResponse.data;
+    const uploadId = uploadData.uploadId || uploadData.id;
 
-    // Publish datasources
-    for (const datasourceFile of datasourceFiles) {
-      const datasourceName = path.basename(datasourceFile, '.json');
-      logger.log(chalk.blue(`Publishing datasource: ${datasourceName}...`));
+    if (!uploadId) {
+      throw new Error('Upload ID not found in upload response');
+    }
 
-      const datasourceContent = await fs.readFile(datasourceFile, 'utf8');
-      const datasourceJson = JSON.parse(datasourceContent);
+    logger.log(chalk.green(`✓ Upload successful (ID: ${uploadId})`));
 
-      const datasourceResponse = await authenticatedApiCall(
-        `${dataplaneUrl}/api/v1/pipeline/${systemKey}/publish`,
+    // Step 2: Validate upload (optional, can be skipped)
+    if (!options.skipValidation) {
+      logger.log(chalk.blue('🔍 Validating upload...'));
+      const validateResponse = await authenticatedApiCall(
+        `${dataplaneUrl}/api/v1/pipeline/upload/${uploadId}/validate`,
         {
-          method: 'POST',
-          body: JSON.stringify(datasourceJson)
+          method: 'POST'
         },
         authConfig.token
       );
 
-      if (!datasourceResponse.success) {
-        throw new Error(`Failed to publish datasource ${datasourceName}: ${datasourceResponse.error || datasourceResponse.formattedError}`);
+      if (!validateResponse.success || !validateResponse.data) {
+        throw new Error(`Validation failed: ${validateResponse.error || validateResponse.formattedError || 'Unknown error'}`);
       }
 
-      logger.log(chalk.green(`✓ Datasource published: ${datasourceName}`));
+      const validateData = validateResponse.data.data || validateResponse.data;
+
+      // Display changes
+      if (validateData.changes && validateData.changes.length > 0) {
+        logger.log(chalk.blue('\n📋 Changes to be published:'));
+        for (const change of validateData.changes) {
+          const changeType = change.type || 'unknown';
+          const changeEntity = change.entity || change.key || 'unknown';
+          const emoji = changeType === 'new' ? '➕' : changeType === 'modified' ? '✏️' : '🗑️';
+          logger.log(chalk.gray(`  ${emoji} ${changeType}: ${changeEntity}`));
+        }
+      }
+
+      if (validateData.summary) {
+        logger.log(chalk.blue(`\n📊 Summary: ${validateData.summary}`));
+      }
+
+      logger.log(chalk.green('✓ Validation successful'));
+    } else {
+      logger.log(chalk.yellow('⚠ Skipping validation step'));
+    }
+
+    // Step 3: Publish application
+    const generateMcpContract = options.generateMcpContract !== false; // Default to true
+    logger.log(chalk.blue(`📢 Publishing application (MCP contract: ${generateMcpContract ? 'enabled' : 'disabled'})...`));
+
+    const publishResponse = await authenticatedApiCall(
+      `${dataplaneUrl}/api/v1/pipeline/upload/${uploadId}/publish?generateMcpContract=${generateMcpContract}`,
+      {
+        method: 'POST'
+      },
+      authConfig.token
+    );
+
+    if (!publishResponse.success || !publishResponse.data) {
+      throw new Error(`Failed to publish application: ${publishResponse.error || publishResponse.formattedError || 'Unknown error'}`);
     }
 
+    const publishData = publishResponse.data.data || publishResponse.data;
+
     logger.log(chalk.green('\n✅ External system published successfully!'));
     logger.log(chalk.blue(`System: ${systemKey}`));
-    logger.log(chalk.blue(`Datasources: ${datasourceFiles.length}`));
+    if (publishData.systems && publishData.systems.length > 0) {
+      logger.log(chalk.blue(`Published systems: ${publishData.systems.length}`));
+    }
+    if (publishData.dataSources && publishData.dataSources.length > 0) {
+      logger.log(chalk.blue(`Published datasources: ${publishData.dataSources.length}`));
+    } else {
+      logger.log(chalk.blue(`Datasources: ${datasourceFiles.length}`));
+    }
   } catch (error) {
     throw new Error(`Failed to deploy external system: ${error.message}`);
   }