@aifabrix/builder 2.1.6 → 2.2.0

package/lib/app-deploy.js

@@ -15,6 +15,8 @@ const yaml = require('js-yaml');
 const chalk = require('chalk');
 const pushUtils = require('./push');
 const logger = require('./utils/logger');
+const config = require('./config');
+const { getDeploymentAuth } = require('./utils/token-manager');
 
 /**
  * Validate application name format
@@ -22,8 +24,8 @@ const logger = require('./utils/logger');
  * @throws {Error} If app name is invalid
  */
 function validateAppName(appName) {
-  if (!appName || typeof appName !== 'string') {
-    throw new Error('Application name is required');
+  if (!appName || typeof appName !== 'string' || appName.trim().length === 0) {
+    throw new Error('App name is required');
   }
 
   // App name should be lowercase, alphanumeric with dashes, 3-40 characters
@@ -183,9 +185,7 @@ async function loadVariablesFile(variablesPath) {
 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,
+    envKey: options.environment || variables.deployment?.environment,
     poll: options.poll !== false,
     pollInterval: options.pollInterval || 5000,
     pollMaxAttempts: options.pollMaxAttempts || 60
@@ -194,24 +194,24 @@ function extractDeploymentConfig(options, variables) {
 
 /**
  * Validates required deployment configuration
- * @param {Object} config - Deployment configuration
+ * @param {Object} deploymentConfig - Deployment configuration
  * @throws {Error} If configuration is invalid
  */
-function validateDeploymentConfig(config) {
-  if (!config.controllerUrl) {
+function validateDeploymentConfig(deploymentConfig) {
+  if (!deploymentConfig.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');
+  if (!deploymentConfig.auth) {
+    throw new Error('Authentication is required. Run "aifabrix login" first or ensure credentials are in secrets.local.yaml');
   }
 }
 
 /**
- * Loads deployment configuration from variables.yaml
+ * Loads deployment configuration from variables.yaml and gets/refreshes token
  * @async
  * @param {string} appName - Application name
  * @param {Object} options - CLI options
- * @returns {Promise<Object>} Deployment configuration
+ * @returns {Promise<Object>} Deployment configuration with token
  * @throws {Error} If configuration is invalid
  */
 async function loadDeploymentConfig(appName, options) {
@@ -221,10 +221,44 @@ async function loadDeploymentConfig(appName, options) {
   const variablesPath = path.join(builderPath, 'variables.yaml');
   const variables = await loadVariablesFile(variablesPath);
 
-  const config = extractDeploymentConfig(options, variables);
-  validateDeploymentConfig(config);
+  const deploymentConfig = extractDeploymentConfig(options, variables);
 
-  return config;
+  // Update root-level environment if provided
+  if (options.environment) {
+    await config.setCurrentEnvironment(options.environment);
+  }
+
+  // Get current environment from root-level config
+  const currentEnvironment = await config.getCurrentEnvironment();
+  deploymentConfig.envKey = deploymentConfig.envKey || currentEnvironment;
+
+  // Get controller URL
+  if (!deploymentConfig.controllerUrl) {
+    throw new Error('Controller URL is required. Set it in variables.yaml or use --controller flag');
+  }
+
+  // Get deployment authentication (device token → client token → credentials)
+  try {
+    const authConfig = await getDeploymentAuth(
+      deploymentConfig.controllerUrl,
+      deploymentConfig.envKey,
+      appName
+    );
+    if (!authConfig || !authConfig.controller) {
+      throw new Error('Invalid authentication configuration: missing controller URL');
+    }
+    if (!authConfig.token) {
+      throw new Error('Authentication is required');
+    }
+    deploymentConfig.auth = authConfig;
+    deploymentConfig.controllerUrl = authConfig.controller;
+  } catch (error) {
+    throw new Error(`Failed to get authentication: ${error.message}`);
+  }
+
+  validateDeploymentConfig(deploymentConfig);
+
+  return deploymentConfig;
 }
 
 /**
@@ -264,22 +298,21 @@ function displayDeploymentInfo(manifest, manifestPath) {
  * Executes deployment to controller
  * @async
  * @param {Object} manifest - Deployment manifest
- * @param {Object} config - Deployment configuration
+ * @param {Object} deploymentConfig - Deployment configuration
  * @returns {Promise<Object>} Deployment result
  */
-async function executeDeployment(manifest, config) {
-  logger.log(chalk.blue(`\n🚀 Deploying to ${config.controllerUrl} (environment: ${config.envKey})...`));
+async function executeDeployment(manifest, deploymentConfig) {
+  logger.log(chalk.blue(`\n🚀 Deploying to ${deploymentConfig.controllerUrl} (environment: ${deploymentConfig.envKey})...`));
   const deployer = require('./deployer');
   return await deployer.deployToController(
     manifest,
-    config.controllerUrl,
-    config.envKey,
-    config.clientId,
-    config.clientSecret,
+    deploymentConfig.controllerUrl,
+    deploymentConfig.envKey,
+    deploymentConfig.auth,
     {
-      poll: config.poll,
-      pollInterval: config.pollInterval,
-      pollMaxAttempts: config.pollMaxAttempts
+      poll: deploymentConfig.poll,
+      pollInterval: deploymentConfig.pollInterval,
+      pollMaxAttempts: deploymentConfig.pollMaxAttempts
     }
   );
 }
@@ -312,7 +345,7 @@ function displayDeploymentResults(result) {
  * @param {string} appName - Name of the application to deploy
  * @param {Object} options - Deployment options
  * @param {string} options.controller - Controller URL (required)
- * @param {string} [options.environment] - Target environment (dev/tst/pro)
+ * @param {string} [options.environment] - Target environment (miso/dev/tst/pro)
  * @param {boolean} [options.poll] - Poll for deployment status
  * @param {number} [options.pollInterval] - Polling interval in milliseconds
  * @returns {Promise<Object>} Deployment result
@@ -322,16 +355,20 @@ function displayDeploymentResults(result) {
  * await deployApp('myapp', { controller: 'https://controller.aifabrix.ai', environment: 'dev' });
  */
 async function deployApp(appName, options = {}) {
+  let controllerUrl = null;
+  let config = null;
+
   try {
     // 1. Input validation
-    if (!appName || typeof appName !== 'string') {
+    if (!appName || typeof appName !== 'string' || appName.trim().length === 0) {
       throw new Error('App name is required');
     }
 
     validateAppName(appName);
 
     // 2. Load deployment configuration
-    const config = await loadDeploymentConfig(appName, options);
+    config = await loadDeploymentConfig(appName, options);
+    controllerUrl = config.controllerUrl || options.controller || 'unknown';
 
     // 3. Generate and validate manifest
     const { manifest, manifestPath } = await generateAndValidateManifest(appName);
@@ -348,7 +385,14 @@ async function deployApp(appName, options = {}) {
     return result;
 
   } catch (error) {
-    throw new Error(`Failed to deploy application: ${error.message}`);
+    // Use unified error handler from deployer
+    // Check if error was already logged (from deployer.js)
+    const alreadyLogged = error._logged === true;
+    const url = controllerUrl || options.controller || 'unknown';
+
+    const deployer = require('./deployer');
+    // handleDeploymentErrors will log, format, and throw the error
+    await deployer.handleDeploymentErrors(error, appName, url, alreadyLogged);
   }
 }
 

package/lib/app-list.js

@@ -0,0 +1,132 @@
+/**
+ * AI Fabrix Builder - App List Command
+ *
+ * Handles listing applications in an environment
+ *
+ * @fileoverview App list command implementation for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const { getConfig } = require('./config');
+const { getOrRefreshDeviceToken } = require('./utils/token-manager');
+const { authenticatedApiCall } = require('./utils/api');
+const { formatApiError } = require('./utils/api-error-handler');
+const logger = require('./utils/logger');
+
+/**
+ * Extract applications array from API response
+ * Handles multiple response formats:
+ * 1. Wrapped format: { success: true, data: { success: true, data: [...] } }
+ * 2. Direct array: { success: true, data: [...] }
+ * 3. Paginated format: { success: true, data: { items: [...] } }
+ * 4. Wrapped paginated: { success: true, data: { success: true, data: { items: [...] } } }
+ * @param {Object} response - API response from authenticatedApiCall
+ * @returns {Array} Array of applications
+ * @throws {Error} If response format is invalid
+ */
+function extractApplications(response) {
+  const apiResponse = response.data;
+  let applications;
+
+  // Check if apiResponse.data is an array (wrapped format)
+  if (apiResponse && apiResponse.data && Array.isArray(apiResponse.data)) {
+    applications = apiResponse.data;
+  } else if (Array.isArray(apiResponse)) {
+    // Check if apiResponse is directly an array
+    applications = apiResponse;
+  } else if (apiResponse && Array.isArray(apiResponse.items)) {
+    // Check if apiResponse.items is an array (paginated format)
+    applications = apiResponse.items;
+  } else if (apiResponse && apiResponse.data && apiResponse.data.items && Array.isArray(apiResponse.data.items)) {
+    // Check if apiResponse.data.items is an array (wrapped paginated format)
+    applications = apiResponse.data.items;
+  } else {
+    logger.error(chalk.red('❌ Invalid response: expected data array or items array'));
+    logger.error(chalk.gray('\nAPI response type:'), typeof apiResponse);
+    logger.error(chalk.gray('API response:'), JSON.stringify(apiResponse, null, 2));
+    logger.error(chalk.gray('\nFull response for debugging:'));
+    logger.error(chalk.gray(JSON.stringify(response, null, 2)));
+    throw new Error('Invalid response format');
+  }
+
+  return applications;
+}
+
+/**
+ * Display applications list
+ * @param {Array} applications - Array of application objects
+ * @param {string} environment - Environment name or key
+ */
+function displayApplications(applications, environment) {
+  const environmentName = environment || 'miso';
+  const header = `Applications in ${environmentName} environment`;
+
+  if (applications.length === 0) {
+    logger.log(chalk.bold(`\n📱 ${header}:\n`));
+    logger.log(chalk.gray('  No applications found in this environment.\n'));
+    return;
+  }
+
+  logger.log(chalk.bold(`\n📱 ${header}:\n`));
+  applications.forEach((app) => {
+    const hasPipeline = app.configuration?.pipeline?.isActive ? '✓' : '✗';
+    logger.log(`${hasPipeline} ${chalk.cyan(app.key)} - ${app.displayName} (${app.status || 'unknown'})`);
+  });
+  logger.log('');
+}
+
+/**
+ * List applications in an environment
+ * @async
+ * @param {Object} options - Command options
+ * @param {string} options.environment - Environment ID or key
+ * @throws {Error} If listing fails
+ */
+async function listApplications(options) {
+  const config = await getConfig();
+
+  // Try to get device token
+  let controllerUrl = null;
+  let token = null;
+
+  if (config.device) {
+    const deviceUrls = Object.keys(config.device);
+    if (deviceUrls.length > 0) {
+      controllerUrl = deviceUrls[0];
+      const deviceToken = await getOrRefreshDeviceToken(controllerUrl);
+      if (deviceToken && deviceToken.token) {
+        token = deviceToken.token;
+        controllerUrl = deviceToken.controller;
+      }
+    }
+  }
+
+  if (!token || !controllerUrl) {
+    logger.error(chalk.red('❌ Not logged in. Run: aifabrix login'));
+    logger.error(chalk.gray('   Use device code flow: aifabrix login --method device --controller <url>'));
+    process.exit(1);
+  }
+
+  const response = await authenticatedApiCall(
+    `${controllerUrl}/api/v1/environments/${options.environment}/applications`,
+    {},
+    token
+  );
+
+  if (!response.success || !response.data) {
+    const formattedError = response.formattedError || formatApiError(response);
+    logger.error(formattedError);
+    // Log full response for debugging
+    logger.error(chalk.gray('\nFull response for debugging:'));
+    logger.error(chalk.gray(JSON.stringify(response, null, 2)));
+    process.exit(1);
+  }
+
+  const applications = extractApplications(response);
+  displayApplications(applications, options.environment);
+}
+
+module.exports = { listApplications };
+

package/lib/app-readme.js

@@ -69,16 +69,23 @@ function generateReadmeMd(appName, config) {
   // Extract registry from nested structure (config.image.registry) or flattened (config.registry)
   const registry = config.image?.registry || config.registry || 'myacr.azurecr.io';
 
+  const hasDatabase = config.database || config.requires?.database || false;
+  const hasRedis = config.redis || config.requires?.redis || false;
+  const hasStorage = config.storage || config.requires?.storage || false;
+  const hasAuthentication = config.authentication || false;
+  const hasAnyService = hasDatabase || hasRedis || hasStorage || hasAuthentication;
+
   const context = {
     appName,
     displayName,
     imageName,
     port,
     registry,
-    hasDatabase: config.database || config.requires?.database || false,
-    hasRedis: config.redis || config.requires?.redis || false,
-    hasStorage: config.storage || config.requires?.storage || false,
-    hasAuthentication: config.authentication || false
+    hasDatabase,
+    hasRedis,
+    hasStorage,
+    hasAuthentication,
+    hasAnyService
   };
 
   return template(context);