@aifabrix/builder 2.39.3 → 2.40.2

package/lib/commands/auth-status.js

@@ -317,10 +317,11 @@ function displayStatus(controllerUrl, environment, tokenInfo, dataplaneInfo) {
  * Controller and environment come from config.yaml (set via aifabrix login or aifabrix auth config).
  * @async
  * @function handleAuthStatus
- * @param {Object} _options - Command options (unused; controller/environment from config only)
+ * @param {Object} options - Command options
+ * @param {boolean} [options.validate] - If true, exit with code 1 when not authenticated
  * @returns {Promise<void>} Resolves when status is displayed
  */
-async function handleAuthStatus(_options) {
+async function handleAuthStatus(options = {}) {
   const { resolveEnvironment } = require('../core/config');
   const controllerUrl = await resolveControllerUrl();
   const environment = await resolveEnvironment();
@@ -342,6 +343,38 @@ async function handleAuthStatus(_options) {
   }
 
   displayStatus(controllerUrl, environment, tokenInfo, dataplaneInfo);
+
+  if (options.validate && (!tokenInfo || !tokenInfo.authenticated)) {
+    process.exit(1);
+  }
+}
+
+/**
+ * Get resolved auth context (controller URL, environment, authConfig) for use after validation.
+ * Call only when auth status --validate has already passed (e.g. in manual tests).
+ * @async
+ * @function getValidatedAuthContext
+ * @returns {Promise<{controllerUrl: string, environment: string, authConfig: Object, dataplaneUrl: string|null}>}
+ * @throws {Error} If not authenticated
+ */
+async function getValidatedAuthContext() {
+  const { resolveEnvironment } = require('../core/config');
+  const controllerUrl = await resolveControllerUrl();
+  const environment = await resolveEnvironment();
+
+  let tokenInfo = await checkDeviceToken(controllerUrl);
+  if (!tokenInfo) {
+    tokenInfo = await checkClientToken(controllerUrl, environment);
+  }
+
+  if (!tokenInfo || !tokenInfo.authenticated || !tokenInfo.token) {
+    throw new Error('Not authenticated. Run "aifabrix login" or configure client credentials.');
+  }
+
+  const authConfig = { type: 'bearer', token: tokenInfo.token };
+  const dataplaneUrl = await resolveDataplaneUrlSilent(controllerUrl, environment, authConfig);
+
+  return { controllerUrl, environment, authConfig, dataplaneUrl };
 }
 
-module.exports = { handleAuthStatus };
+module.exports = { handleAuthStatus, getValidatedAuthContext };

package/lib/commands/convert.js

@@ -0,0 +1,202 @@
+/**
+ * Convert command: convert integration/external system and datasource config files between JSON and YAML.
+ *
+ * Process: validate first, then (unless --force) prompt for confirmation, then convert (write new files),
+ * update application config links, then delete old files.
+ *
+ * @fileoverview Convert config format (JSON/YAML) for external integration files
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const readline = require('readline');
+const { detectAppType } = require('../utils/paths');
+const { logOfflinePathWhenType } = require('../utils/cli-utils');
+const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
+
+const TARGET_EXT = { yaml: '.yaml', json: '.json' };
+const APP_CONFIG_NAMES = { yaml: 'application.yaml', json: 'application.json' };
+
+/**
+ * Prompts the user for confirmation (y/N).
+ *
+ * @param {string} message - Prompt message
+ * @returns {Promise<boolean>} True if user confirms (y/yes), false otherwise
+ */
+function promptConfirm(message) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise(resolve => {
+    rl.question(message, answer => {
+      rl.close();
+      const normalized = (answer || '').trim().toLowerCase();
+      resolve(normalized === 'y' || normalized === 'yes');
+    });
+  });
+}
+
+/**
+ * Returns the target filename for a given file path and format (same base name, new extension).
+ *
+ * @param {string} filePath - Current file path
+ * @param {string} format - Target format: 'json' or 'yaml'
+ * @returns {string} New filename (basename only)
+ */
+function targetFileName(filePath, format) {
+  const base = path.basename(filePath, path.extname(filePath));
+  const ext = TARGET_EXT[format] || (format === 'json' ? '.json' : '.yaml');
+  return base + ext;
+}
+
+/**
+ * Converts a single config file to the target format: writes to new path, returns old and new paths.
+ *
+ * @param {string} sourcePath - Absolute path to existing file
+ * @param {string} targetPath - Absolute path for new file
+ * @param {string} format - 'json' or 'yaml'
+ * @returns {{ oldPath: string, newPath: string }}
+ */
+function convertOneFile(sourcePath, targetPath, format) {
+  const obj = loadConfigFile(sourcePath);
+  writeConfigFile(targetPath, obj, format);
+  return { oldPath: sourcePath, newPath: targetPath };
+}
+
+/**
+ * Converts a list of config files (system or datasource) in a directory; skips missing files.
+ *
+ * @param {string} schemaBasePath - Base directory for files
+ * @param {string[]} fileNames - List of filenames
+ * @param {string} format - 'json' or 'yaml'
+ * @returns {{ converted: string[], toDelete: string[], newNames: string[] }}
+ */
+function convertFileList(schemaBasePath, fileNames, format) {
+  const converted = [];
+  const toDelete = [];
+  const newNames = [];
+  for (const fileName of fileNames) {
+    const sourcePath = path.join(schemaBasePath, fileName);
+    if (!fs.existsSync(sourcePath)) {
+      newNames.push(fileName);
+      continue;
+    }
+    const newFileName = targetFileName(sourcePath, format);
+    const targetPath = path.join(schemaBasePath, newFileName);
+    convertOneFile(sourcePath, targetPath, format);
+    converted.push(targetPath);
+    newNames.push(newFileName);
+    if (path.normalize(sourcePath) !== path.normalize(targetPath)) {
+      toDelete.push(sourcePath);
+    }
+  }
+  return { converted, toDelete, newNames };
+}
+
+/**
+ * Validates app and prompts for confirmation unless opts.force.
+ *
+ * @param {Object} opts - Options
+ * @param {string} opts.appName - Application name
+ * @param {Object} opts.cmdOptions - Command options (force, type)
+ * @param {string} opts.schemaBasePath - Base path for external files
+ * @param {string[]} opts.systemFiles - System file names
+ * @param {string[]} opts.datasourceFiles - Datasource file names
+ * @param {string} opts.configPath - Current application config path
+ * @param {string} opts.format - Target format
+ * @throws {Error} If validation fails or user cancels
+ */
+async function validateAndPrompt(opts) {
+  const validate = require('../validation/validate');
+  const result = await validate.validateAppOrFile(opts.appName, opts.cmdOptions);
+  if (!result.valid) {
+    validate.displayValidationResults(result);
+    throw new Error('Validation failed. Fix errors before converting.');
+  }
+  const { configPath, format, schemaBasePath, systemFiles, datasourceFiles } = opts;
+  const appConfigName = APP_CONFIG_NAMES[format];
+  const targetConfigPath = path.join(path.dirname(configPath), appConfigName);
+  const willConvertAppConfig = path.normalize(configPath) !== path.normalize(targetConfigPath) ||
+    path.extname(configPath) !== (format === 'json' ? '.json' : '.yaml');
+  const summaryLines = [...systemFiles, ...datasourceFiles]
+    .filter(Boolean)
+    .map(f => `  • ${f} → ${targetFileName(path.join(schemaBasePath, f), format)}`);
+  if (willConvertAppConfig) summaryLines.push(`  • application config → ${appConfigName}`);
+  summaryLines.push('  Old files will be removed after writing new ones.');
+  if (!opts.cmdOptions.force) {
+    const confirmed = await promptConfirm(`Convert the following to ${format}?\n${summaryLines.join('\n')}\nAre you sure? (y/N) `);
+    if (!confirmed) throw new Error('Convert cancelled.');
+  }
+}
+
+/**
+ * Converts files, updates application config, and deletes old files.
+ *
+ * @param {Object} variables - Current application config
+ * @param {string} configPath - Current application config path
+ * @param {string} schemaBasePath - Base path for external files
+ * @param {string[]} systemFiles - System file names
+ * @param {string[]} datasourceFiles - Datasource file names
+ * @param {string} format - Target format
+ * @returns {{ converted: string[], deleted: string[] }}
+ */
+function executeConversion(variables, configPath, schemaBasePath, systemFiles, datasourceFiles, format) {
+  const sys = convertFileList(schemaBasePath, systemFiles, format);
+  const ds = convertFileList(schemaBasePath, datasourceFiles, format);
+  const converted = [...sys.converted, ...ds.converted];
+  const toDelete = [...sys.toDelete, ...ds.toDelete];
+  const updatedVariables = { ...variables };
+  if (updatedVariables.externalIntegration) {
+    updatedVariables.externalIntegration = { ...updatedVariables.externalIntegration };
+    updatedVariables.externalIntegration.systems = sys.newNames;
+    updatedVariables.externalIntegration.dataSources = ds.newNames;
+  }
+  const appConfigName = APP_CONFIG_NAMES[format];
+  const targetConfigPath = path.join(path.dirname(configPath), appConfigName);
+  writeConfigFile(targetConfigPath, updatedVariables, format);
+  converted.push(targetConfigPath);
+  if (path.normalize(configPath) !== path.normalize(targetConfigPath)) toDelete.push(configPath);
+  toDelete.forEach(oldPath => {
+    if (fs.existsSync(oldPath)) fs.unlinkSync(oldPath);
+  });
+  return { converted, deleted: toDelete };
+}
+
+/**
+ * Runs conversion: validate first, optional prompt, convert files, update app config links, delete old files.
+ *
+ * @param {string} appName - Application name
+ * @param {Object} options - Command options
+ * @param {string} options.format - Target format: 'json' or 'yaml'
+ * @param {boolean} [options.force] - Skip confirmation prompt
+ *
+ * @returns {Promise<{ converted: string[], deleted: string[] }>} Lists of converted and deleted file paths
+ * @throws {Error} If validation fails, user aborts, or conversion fails
+ */
+async function runConvert(appName, options) {
+  const format = (options.format || '').toLowerCase();
+  if (format !== 'json' && format !== 'yaml') {
+    throw new Error('Option --format is required and must be \'json\' or \'yaml\'');
+  }
+  const { appPath } = await detectAppType(appName);
+  logOfflinePathWhenType(appPath);
+  const configPath = resolveApplicationConfigPath(appPath);
+  const variables = loadConfigFile(configPath);
+  const schemaBasePath = path.resolve(path.dirname(configPath), variables.externalIntegration?.schemaBasePath || './');
+  const systemFiles = variables.externalIntegration?.systems || [];
+  const datasourceFiles = variables.externalIntegration?.dataSources || [];
+  await validateAndPrompt({
+    appName, cmdOptions: options, schemaBasePath, systemFiles, datasourceFiles, configPath, format
+  });
+  return executeConversion(variables, configPath, schemaBasePath, systemFiles, datasourceFiles, format);
+}
+
+module.exports = {
+  runConvert,
+  promptConfirm,
+  targetFileName,
+  convertOneFile
+};

package/lib/commands/credential-list.js

@@ -1,6 +1,7 @@
 /**
- * Credential list command – list credentials from controller/dataplane
+ * Credential list command – list credentials from Dataplane
  * GET /api/v1/credential. Used by `aifabrix credential list`.
+ * The Controller does not expose this endpoint; credentials are listed from the Dataplane.
  *
  * @fileoverview Credential list command implementation
  * @author AI Fabrix Team
@@ -11,7 +12,8 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { resolveControllerUrl } = require('../utils/controller-url');
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
-const { normalizeControllerUrl } = require('../core/config');
+const { normalizeControllerUrl, resolveEnvironment } = require('../core/config');
+const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
 const { listCredentials } = require('../api/credentials.api');
 
 const DEFAULT_PAGE_SIZE = 50;
@@ -48,10 +50,10 @@ function extractCredentials(response) {
 /**
  * Display credential list to user
  * @param {Array} list - Credentials array
- * @param {string} controllerUrl - Controller URL for header
+ * @param {string} baseUrl - Dataplane (or base) URL for header
  */
-function displayCredentialList(list, controllerUrl) {
-  logger.log(chalk.bold(`\n🔐 Credentials (${controllerUrl}):\n`));
+function displayCredentialList(list, baseUrl) {
+  logger.log(chalk.bold(`\n🔐 Credentials (${baseUrl}):\n`));
   if (list.length === 0) {
     logger.log(chalk.gray('  No credentials found.\n'));
     return;
@@ -65,36 +67,95 @@ function displayCredentialList(list, controllerUrl) {
 }
 
 /**
- * Run credential list command: call GET /api/v1/credential and display results
+ * Ensure controller URL and auth; exit on failure. Returns { controllerUrl, authConfig } when valid.
  * @async
- * @param {Object} options - CLI options
- * @param {string} [options.controller] - Controller URL override
- * @param {boolean} [options.activeOnly] - List only active credentials
- * @param {number} [options.pageSize] - Items per page
- * @returns {Promise<void>}
+ * @param {Object} options - CLI options with optional controller
+ * @returns {Promise<{controllerUrl: string, authConfig: Object}>}
  */
-async function runCredentialList(options = {}) {
+async function ensureControllerAndAuth(options) {
   const controllerUrl = options.controller || (await resolveControllerUrl());
   if (!controllerUrl) {
     logger.error(chalk.red('❌ Controller URL is required. Run "aifabrix login" first.'));
     process.exit(1);
-    return;
   }
   const authResult = await getCredentialListAuth(controllerUrl);
   if (!authResult || !authResult.token) {
     logger.error(chalk.red(`❌ No authentication token for controller: ${controllerUrl}`));
     logger.error(chalk.gray('Run: aifabrix login'));
     process.exit(1);
-    return;
   }
-  const authConfig = { type: 'bearer', token: authResult.token };
+  return {
+    controllerUrl,
+    authConfig: { type: 'bearer', token: authResult.token }
+  };
+}
+
+/**
+ * Resolve Dataplane URL for credential list (override or discover from controller + environment)
+ * @async
+ * @param {string} controllerUrl - Controller base URL
+ * @param {Object} authConfig - Auth config with token
+ * @param {Object} options - CLI options
+ * @param {string} [options.dataplane] - Optional Dataplane URL override
+ * @returns {Promise<string>} Dataplane base URL
+ * @throws {Error} When resolution fails (caller should exit)
+ */
+async function resolveCredentialListDataplaneUrl(controllerUrl, authConfig, options) {
+  if (options.dataplane) {
+    return options.dataplane.replace(/\/$/, '');
+  }
+  const environment = await resolveEnvironment();
+  return await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+}
+
+/**
+ * Call Dataplane credential API and display results; exits on failure
+ * @param {string} dataplaneUrl - Dataplane base URL
+ * @param {Object} authConfig - Auth config
+ * @param {Object} listOptions - pageSize, activeOnly
+ */
+async function fetchAndDisplayCredentials(dataplaneUrl, authConfig, listOptions) {
+  const response = await listCredentials(dataplaneUrl, authConfig, listOptions);
+  displayCredentialList(extractCredentials(response), dataplaneUrl);
+}
+
+/**
+ * Resolve Dataplane URL or log error and exit
+ * @async
+ * @param {string} controllerUrl - Controller URL
+ * @param {Object} authConfig - Auth config
+ * @param {Object} options - CLI options
+ * @returns {Promise<string>} Dataplane URL (never returns on failure; process.exit(1))
+ */
+async function resolveDataplaneUrlOrExit(controllerUrl, authConfig, options) {
+  try {
+    return await resolveCredentialListDataplaneUrl(controllerUrl, authConfig, options);
+  } catch (err) {
+    logger.error(chalk.red(`❌ Could not resolve Dataplane URL: ${err.message}`));
+    logger.error(chalk.gray('Use --dataplane <url> to specify the Dataplane URL directly.'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Run credential list command: call GET /api/v1/credential on Dataplane and display results
+ * @async
+ * @param {Object} options - CLI options
+ * @param {string} [options.controller] - Controller URL override
+ * @param {string} [options.dataplane] - Dataplane URL override (default: resolved from controller + environment)
+ * @param {boolean} [options.activeOnly] - List only active credentials
+ * @param {number} [options.pageSize] - Items per page
+ * @returns {Promise<void>}
+ */
+async function runCredentialList(options = {}) {
+  const { controllerUrl, authConfig } = await ensureControllerAndAuth(options);
+  const dataplaneUrl = await resolveDataplaneUrlOrExit(controllerUrl, authConfig, options);
   const listOptions = {
     pageSize: options.pageSize || DEFAULT_PAGE_SIZE,
     activeOnly: options.activeOnly
   };
   try {
-    const response = await listCredentials(authResult.controllerUrl, authConfig, listOptions);
-    displayCredentialList(extractCredentials(response), authResult.controllerUrl);
+    await fetchAndDisplayCredentials(dataplaneUrl, authConfig, listOptions);
   } catch (error) {
     logger.error(chalk.red(`❌ Failed to list credentials: ${error.message}`));
     process.exit(1);

package/lib/commands/datasource.js

@@ -16,18 +16,8 @@ const { listDatasources } = require('../datasource/list');
 const { compareDatasources } = require('../datasource/diff');
 const { deployDatasource } = require('../datasource/deploy');
 
-/**
- * Setup datasource management commands
- * @param {Command} program - Commander program instance
- */
-function setupDatasourceCommands(program) {
-  const datasource = program
-    .command('datasource')
-    .description('Manage external data sources');
-
-  // Validate command
-  datasource
-    .command('validate <file>')
+function setupDatasourceValidateCommand(datasource) {
+  datasource.command('validate <file>')
     .description('Validate external datasource JSON file')
     .action(async(file) => {
       try {
@@ -36,9 +26,7 @@ function setupDatasourceCommands(program) {
           logger.log(chalk.green(`\n✓ Datasource file is valid: ${file}`));
         } else {
           logger.log(chalk.red(`\n✗ Datasource file has errors: ${file}`));
-          result.errors.forEach(error => {
-            logger.log(chalk.red(`  • ${error}`));
-          });
+          result.errors.forEach(error => logger.log(chalk.red(`  • ${error}`)));
           process.exit(1);
         }
       } catch (error) {
@@ -46,10 +34,10 @@ function setupDatasourceCommands(program) {
         process.exit(1);
       }
     });
+}
 
-  // List command
-  datasource
-    .command('list')
+function setupDatasourceListCommand(datasource) {
+  datasource.command('list')
     .description('List datasources from environment (uses environment from config.yaml)')
     .action(async() => {
       try {
@@ -59,10 +47,10 @@ function setupDatasourceCommands(program) {
         process.exit(1);
       }
     });
+}
 
-  // Diff command
-  datasource
-    .command('diff <file1> <file2>')
+function setupDatasourceDiffCommand(datasource) {
+  datasource.command('diff <file1> <file2>')
     .description('Compare two datasource configuration files (for dataplane)')
     .action(async(file1, file2) => {
       try {
@@ -72,10 +60,10 @@ function setupDatasourceCommands(program) {
         process.exit(1);
       }
     });
+}
 
-  // Deploy command
-  datasource
-    .command('deploy <myapp> <file>')
+function setupDatasourceDeployCommand(datasource) {
+  datasource.command('deploy <myapp> <file>')
     .description('Deploy datasource to dataplane')
     .action(async(myapp, file, options) => {
       try {
@@ -87,5 +75,17 @@ function setupDatasourceCommands(program) {
     });
 }
 
+/**
+ * Setup datasource management commands
+ * @param {Command} program - Commander program instance
+ */
+function setupDatasourceCommands(program) {
+  const datasource = program.command('datasource').description('Manage external data sources');
+  setupDatasourceValidateCommand(datasource);
+  setupDatasourceListCommand(datasource);
+  setupDatasourceDiffCommand(datasource);
+  setupDatasourceDeployCommand(datasource);
+}
+
 module.exports = { setupDatasourceCommands };
 

package/lib/commands/deployment-list.js

@@ -36,13 +36,19 @@ async function getDeploymentListAuth(controllerUrl) {
 }
 
 /**
- * Extract deployments array from API response
- * @param {Object} response - API response
+ * Extract deployments array from API response.
+ * Supports OpenAPI/SDK paginated format: { meta, data: Deployment[], links }
+ * and legacy shapes: { data: { items } }, { data: { deployments } }, or { data: [] }.
+ * @param {Object} response - API response (from ApiClient: { success, data: body, status })
  * @returns {Array}
  */
 function extractDeployments(response) {
-  const data = response?.data ?? response;
-  const items = data?.items ?? data?.deployments ?? (Array.isArray(data) ? data : []);
+  const body = response?.data ?? response;
+  const items =
+    (Array.isArray(body?.data) ? body.data : undefined) ??
+    body?.items ??
+    body?.deployments ??
+    (Array.isArray(body) ? body : []);
   return Array.isArray(items) ? items : [];
 }
 
@@ -60,10 +66,11 @@ function displayDeploymentList(deployments, environment, controllerUrl) {
   }
   deployments.forEach((d) => {
     const id = d.id ?? d.deploymentId ?? '-';
-    const appKey = d.applicationKey ?? d.appKey ?? d.application?.key ?? '-';
+    const target =
+      d.applicationKey ?? d.appKey ?? d.targetId ?? d.application?.key ?? '-';
     const status = d.status ?? '-';
     const createdAt = d.createdAt ?? d.created ?? '';
-    logger.log(`  ${chalk.cyan(id)} ${appKey} ${status} ${chalk.gray(createdAt)}`);
+    logger.log(`  ${chalk.cyan(id)} ${target} ${status} ${chalk.gray(createdAt)}`);
   });
   logger.log('');
 }