@aifabrix/builder 2.43.0 → 2.44.1

package/lib/commands/datasource-unified-test-e2e-cli-helpers.js

@@ -0,0 +1,106 @@
+/**
+ * @fileoverview E2E / envelope exit helpers for datasource unified test CLI (keeps main CLI file under max-lines).
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { displayIntegrationTestResults, displayE2EResults } = require('../utils/external-system-display');
+const { computeExitCodeFromDatasourceTestRun } = require('../utils/datasource-test-run-exit');
+const { analyzeCapabilityScope } = require('../utils/datasource-test-run-capability-scope');
+const {
+  resolveDebugDisplayMode,
+  formatDatasourceTestRunDebugBlock
+} = require('../utils/datasource-test-run-debug-display');
+const { formatCapabilityFocusSection } = require('../utils/datasource-test-run-display');
+const { emitCapabilityScopeDiagnostics } = require('./datasource-validation-cli');
+
+function logDatasourceTestRunDebugAppendix(envelope, debugOpt) {
+  const mode = resolveDebugDisplayMode(debugOpt);
+  if (!mode || !envelope) return;
+  const block = formatDatasourceTestRunDebugBlock(envelope, mode, process.stdout.isTTY);
+  if (block) logger.log(block);
+}
+
+function logE2eCapabilityFocusFromEnvelope(env, capabilityOpt) {
+  if (!env) return;
+  const capKey =
+    capabilityOpt !== undefined && capabilityOpt !== null
+      ? String(capabilityOpt).trim()
+      : '';
+  if (!capKey) return;
+  const sec = formatCapabilityFocusSection(env, capKey);
+  if (sec) logger.log(sec);
+}
+
+/**
+ * @param {Object|null|undefined} env
+ * @param {Object} options
+ * @returns {number|null} null if no envelope
+ */
+function exitCodeFromDatasourceTestRunEnvelope(env, options) {
+  if (!env || typeof env !== 'object') return null;
+  let code = computeExitCodeFromDatasourceTestRun(env, {
+    warningsAsErrors: options.warningsAsErrors === true,
+    requireCert: options.requireCert === true
+  });
+  const scope = analyzeCapabilityScope(env, options.capability);
+  if (options.strictCapabilityScope === true && scope.violated) {
+    code = Math.max(code, 1);
+  }
+  return code;
+}
+
+/**
+ * Legacy E2E display + exit code (no process.exit; watch mode).
+ * @param {Object} data
+ * @param {Object} options
+ * @returns {number}
+ */
+function finalizeDatasourceTestE2ELegacyPath(data, options) {
+  displayE2EResults(data, options.verbose);
+  logDatasourceTestRunDebugAppendix(data.datasourceTestRun, options.debug);
+  logE2eCapabilityFocusFromEnvelope(data.datasourceTestRun, options.capability);
+  const env = data.datasourceTestRun;
+  if (env) {
+    emitCapabilityScopeDiagnostics(env, { requestedCapabilityKey: options.capability });
+    const code = exitCodeFromDatasourceTestRunEnvelope(env, options);
+    return code === null ? 1 : code;
+  }
+  const steps = data.steps || data.completedActions || [];
+  const failed = data.success === false || steps.some(s => s.success === false || s.error);
+  return failed ? 1 : 0;
+}
+
+/**
+ * @param {string} datasourceKey
+ * @param {Object} env
+ * @param {Object} options
+ */
+function displayDatasourceTestE2EEnvelopeResults(datasourceKey, env, options) {
+  const success = env.status !== 'fail';
+  displayIntegrationTestResults(
+    {
+      systemKey: env.systemKey || 'unknown',
+      success,
+      datasourceResults: [{ key: datasourceKey, success, datasourceTestRun: env }]
+    },
+    options.verbose,
+    {
+      debug: options.debug,
+      runType: 'e2e',
+      requestedCapabilityKey: options.capability
+    }
+  );
+  logE2eCapabilityFocusFromEnvelope(env, options.capability);
+}
+
+module.exports = {
+  logDatasourceTestRunDebugAppendix,
+  logE2eCapabilityFocusFromEnvelope,
+  exitCodeFromDatasourceTestRunEnvelope,
+  finalizeDatasourceTestE2ELegacyPath,
+  displayDatasourceTestE2EEnvelopeResults
+};

package/lib/commands/datasource-validation-cli.js

@@ -0,0 +1,143 @@
+const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
+/**
+ * @fileoverview Shared CLI handling for unified validation (DatasourceTestRun + exit matrix).
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { computeExitCodeFromDatasourceTestRun, exitCodeForPollTimeout } = require('../utils/datasource-test-run-exit');
+const { analyzeCapabilityScope } = require('../utils/datasource-test-run-capability-scope');
+const ttyLog = require('../utils/datasource-test-run-tty-log');
+const { logEnvelopeForInteractiveCli } = ttyLog;
+
+/**
+ * Build unified CLI result from integration test return shape.
+ * @param {Object} r - runDatasourceTestIntegration result
+ * @returns {{ envelope: Object|null, apiError: Object|null, pollTimedOut: boolean, incompleteNoAsync: boolean }}
+ */
+function unifiedCliResultFromIntegrationReturn(r) {
+  const meta = r.runMeta || {};
+  return {
+    apiError: meta.apiError || null,
+    pollTimedOut: meta.pollTimedOut === true,
+    incompleteNoAsync: meta.incompleteNoAsync === true,
+    envelope: r.datasourceTestRun || null
+  };
+}
+
+function logApiError(apiError) {
+  logger.error(
+    formatBlockingError('Dataplane request failed:'),
+    apiError.formattedError || apiError.error || 'Request failed'
+  );
+  if (apiError.status) {
+    logger.error(chalk.gray(`  HTTP ${apiError.status}`));
+  }
+}
+
+/**
+ * Print unified validation outcome and return exit code (plan §3.14 watch — no process.exit).
+ * @param {Object} result - From runUnifiedDatasourceValidation
+ * @param {Object} options - CLI flags
+ * @returns {number}
+ */
+function finalizeUnifiedValidationResult(result, options = {}) {
+  if (result.apiError) {
+    logApiError(result.apiError);
+    return 3;
+  }
+  if (result.pollTimedOut) {
+    logger.error(formatBlockingError('Report incomplete: timeout'));
+    return exitCodeForPollTimeout(result.envelope);
+  }
+  if (result.incompleteNoAsync) {
+    logger.error(
+      chalk.red(
+        '✖ Report incomplete: async polling disabled (--no-async) but server returned partial/minimal report.'
+      )
+    );
+    return 3;
+  }
+
+  const envelope = result.envelope;
+  logEnvelopeForInteractiveCli(envelope, options);
+
+  let exitCode = computeExitCodeFromDatasourceTestRun(envelope, {
+    warningsAsErrors: options.warningsAsErrors === true,
+    requireCert: options.requireCert === true
+  });
+  const scope = analyzeCapabilityScope(envelope, options.requestedCapabilityKey);
+  if (options.strictCapabilityScope === true && scope.violated) {
+    exitCode = Math.max(exitCode, 1);
+  }
+  if (
+    exitCode === 2 &&
+    options.requireCert &&
+    !envelope.certificate
+  ) {
+    logger.error(formatBlockingError('Certification not returned; cannot verify.'));
+  }
+  return exitCode;
+}
+
+/**
+ * Handle unified validation result: logs, stdout JSON, process.exit.
+ * @param {Object} result - From runUnifiedDatasourceValidation
+ * @param {Object} options - CLI flags
+ * @returns {void} Exits process
+ */
+function exitFromUnifiedValidationResult(result, options = {}) {
+  process.exit(finalizeUnifiedValidationResult(result, options));
+}
+
+/**
+ * Compute exit code after integration CLI display (no process.exit; plan §3.14 watch).
+ * @param {Object} integrationResult - From runDatasourceTestIntegration
+ * @param {Object} [exitOpts]
+ * @returns {number}
+ */
+function finalizeAfterIntegrationDisplay(integrationResult, exitOpts = {}) {
+  const env = integrationResult.datasourceTestRun;
+  if (!env) {
+    return integrationResult.success ? 0 : 1;
+  }
+  let exitCode = computeExitCodeFromDatasourceTestRun(env, {
+    warningsAsErrors: exitOpts.warningsAsErrors === true,
+    requireCert: exitOpts.requireCert === true
+  });
+  if (exitOpts.strictCapabilityScope === true) {
+    const scope = analyzeCapabilityScope(env, exitOpts.requestedCapabilityKey);
+    if (scope.violated) {
+      exitCode = Math.max(exitCode, 1);
+    }
+  }
+  if (
+    exitCode === 2 &&
+    exitOpts.requireCert &&
+    !env.certificate
+  ) {
+    logger.error(formatBlockingError('Certification not returned; cannot verify.'));
+  }
+  return exitCode;
+}
+
+/**
+ * Exit after integration CLI when not using raw unified output modes.
+ * @param {Object} integrationResult - From runDatasourceTestIntegration
+ * @param {Object} [exitOpts]
+ */
+function exitAfterIntegrationDisplay(integrationResult, exitOpts = {}) {
+  process.exit(finalizeAfterIntegrationDisplay(integrationResult, exitOpts));
+}
+
+module.exports = {
+  exitFromUnifiedValidationResult,
+  finalizeUnifiedValidationResult,
+  emitReportVersionDiagnostics: ttyLog.emitReportVersionDiagnostics,
+  emitCapabilityScopeDiagnostics: ttyLog.emitCapabilityScopeDiagnostics,
+  unifiedCliResultFromIntegrationReturn,
+  finalizeAfterIntegrationDisplay,
+  exitAfterIntegrationDisplay
+};

package/lib/commands/datasource.js

@@ -1,40 +1,103 @@
 /**
  * AI Fabrix Builder - Datasource Commands
  *
- * Handles datasource validation, listing, comparison, and deployment
- * Commands: datasource validate, datasource list, datasource diff, datasource upload
+ * Handles datasource validation, listing, comparison, deployment, and online validation runs.
+ * Subcommands `test`, `test-integration`, and `test-e2e` call the dataplane unified validation API; `log-test` / `log-integration` / `log-e2e` read saved debug JSON locally. Permissions are summarized in `docs/commands/permissions.md`.
  *
  * @fileoverview Datasource management commands for AI Fabrix Builder
  * @author AI Fabrix Team
  * @version 2.0.0
  */
 
+const path = require('path');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
+const { sectionTitle, headerKeyValue, metadata, formatSuccessLine, formatBlockingError } = require('../utils/cli-test-layout-chalk');
 const { validateDatasourceFile } = require('../datasource/validate');
 const { listDatasources } = require('../datasource/list');
 const { compareDatasources } = require('../datasource/diff');
 const { deployDatasource } = require('../datasource/deploy');
-const { runDatasourceTestIntegration } = require('../datasource/test-integration');
-const { runDatasourceTestE2E } = require('../datasource/test-e2e');
 const { runLogViewer } = require('../datasource/log-viewer');
-const { displayIntegrationTestResults, displayE2EResults } = require('../utils/external-system-display');
+const {
+  setupDatasourceTestCommand,
+  setupDatasourceTestIntegrationCommand,
+  setupDatasourceTestE2ECommand
+} = require('./datasource-unified-test-cli');
+
+const DATASOURCE_HELP_AFTER = `
+Subcommands:
+  validate <file-or-key>       Validate datasource JSON (path or datasource key under integration/<app>/)
+  list                         List datasources (env from config)
+  upload <file-or-key>         Deploy one datasource JSON to the dataplane (path or key; systemKey in file)
+  diff                         Compare two datasource JSON files
+  test <key>                   Structural/policy validation via unified dataplane API (DatasourceTestRun)
+  test-integration / test-e2e  Integration or E2E run via the same unified validation API
+  log-test / log-integration / log-e2e  Show saved debug logs (structural, integration, E2E)
+`;
+
+const DATASOURCE_VALIDATE_HELP_AFTER = `
+Examples:
+  $ aifabrix datasource validate test-e2e-hubspot-users
+  $ aifabrix datasource validate integration/myapp/myapp-datasource-contacts.json
+  $ aifabrix datasource validate ./test-e2e-hubspot-datasource-users.json
+  $ aifabrix datasource validate /path/to/system-datasource-entity.json
+  $ af ds validate ../integration/hubspot/hubspot-datasource-deals.json
+`;
+
+const DATASOURCE_UPLOAD_HELP_AFTER = `
+Examples:
+  $ aifabrix datasource upload test-e2e-hubspot-users
+  $ aifabrix datasource upload integration/myapp/myapp-datasource-contacts.json
+  $ aifabrix datasource upload ./test-e2e-hubspot-datasource-users.json
+  $ aifabrix datasource upload /path/to/system-datasource-entity.json
+  $ af ds upload ../integration/hubspot/hubspot-datasource-deals.json
+`;
+
+/**
+ * TTY layout for local datasource JSON validation (aligned with cli-test-layout-chalk).
+ * @param {{ valid: boolean, errors: string[], resolvedPath: string }} result
+ * @param {string} trimmed - original CLI argument
+ * @param {boolean} showMapping - show Key + File when key resolved to a path
+ */
+function logDatasourceValidateOutcome(result, trimmed, showMapping) {
+  logger.log('');
+  logger.log(sectionTitle('Datasource validation'));
+  logger.log(metadata('Offline — JSON schema and integration wiring'));
+  logger.log('');
+  if (!result.valid) {
+    logger.log(headerKeyValue('File:', result.resolvedPath));
+    logger.log('');
+    logger.log(formatBlockingError('Datasource file has errors:'));
+    result.errors.forEach(error => logger.log(chalk.red(`  • ${error}`)));
+    return;
+  }
+  if (showMapping) {
+    logger.log(headerKeyValue('Key:', trimmed));
+    logger.log(headerKeyValue('File:', result.resolvedPath));
+  } else {
+    logger.log(headerKeyValue('File:', result.resolvedPath));
+  }
+  logger.log('');
+  logger.log(formatSuccessLine('Datasource file is valid.'));
+}
 
 function setupDatasourceValidateCommand(datasource) {
-  datasource.command('validate <file>')
-    .description('Validate external datasource JSON file')
-    .action(async(file) => {
+  datasource.command('validate <file-or-key>')
+    .description('Validate datasource JSON (file path or datasource key under integration/<app>/)')
+    .addHelpText('after', DATASOURCE_VALIDATE_HELP_AFTER)
+    .action(async(fileOrKey) => {
       try {
-        const result = await validateDatasourceFile(file);
-        if (result.valid) {
-          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}`)));
+        const trimmed = fileOrKey.trim();
+        const result = await validateDatasourceFile(trimmed);
+        const resolvedPath = result.resolvedPath;
+        const argResolved = path.resolve(trimmed);
+        const showMapping = resolvedPath && argResolved !== resolvedPath && trimmed !== resolvedPath;
+        logDatasourceValidateOutcome(result, trimmed, showMapping);
+        if (!result.valid) {
           process.exit(1);
         }
       } catch (error) {
-        logger.error(chalk.red('❌ Validation failed:'), error.message);
+        logger.error(formatBlockingError('Validation failed:'), error.message);
         process.exit(1);
       }
     });
@@ -42,12 +105,12 @@ function setupDatasourceValidateCommand(datasource) {
 
 function setupDatasourceListCommand(datasource) {
   datasource.command('list')
-    .description('List datasources from environment (uses environment from config.yaml)')
+    .description('List datasources for environment in config')
     .action(async() => {
       try {
         await listDatasources({});
       } catch (error) {
-        logger.error(chalk.red('❌ Failed to list datasources:'), error.message);
+        logger.error(formatBlockingError('Failed to list datasources:'), error.message);
         process.exit(1);
       }
     });
@@ -55,130 +118,92 @@ function setupDatasourceListCommand(datasource) {
 
 function setupDatasourceDiffCommand(datasource) {
   datasource.command('diff <file1> <file2>')
-    .description('Compare two datasource configuration files (for dataplane)')
+    .description('Diff two datasource JSON files')
     .action(async(file1, file2) => {
       try {
         await compareDatasources(file1, file2);
       } catch (error) {
-        logger.error(chalk.red('❌ Diff failed:'), error.message);
+        logger.error(formatBlockingError('Diff failed:'), error.message);
         process.exit(1);
       }
     });
 }
 
 function setupDatasourceUploadCommand(datasource) {
-  datasource.command('upload <myapp> <file>')
-    .description('Upload datasource to dataplane')
-    .action(async(myapp, file, options) => {
+  datasource.command('upload <file-or-key>')
+    .description('Deploy datasource JSON to dataplane (file path or datasource key under integration/<app>/)')
+    .addHelpText('after', DATASOURCE_UPLOAD_HELP_AFTER)
+    .action(async(fileOrKey, options) => {
       try {
-        await deployDatasource(myapp, file, options);
+        await deployDatasource(fileOrKey, options);
       } catch (error) {
-        logger.error(chalk.red('❌ Upload failed:'), error.message);
+        logger.error(formatBlockingError('Upload failed:'), error.message);
         process.exit(1);
       }
     });
 }
 
-function setupDatasourceTestIntegrationCommand(datasource) {
-  datasource.command('test-integration <datasourceKey>')
-    .description('Run integration (config) test for one datasource via dataplane pipeline')
-    .option('-a, --app <appKey>', 'App key (optional: resolve from cwd or datasource key if single match)')
-    .option('-p, --payload <file>', 'Path to custom test payload file')
-    .option('-e, --env <env>', 'Environment: dev, tst, or pro')
-    .option('-v, --verbose', 'Show detailed step and validation output')
-    .option('--debug', 'Include debug output and write log to integration/<appKey>/logs/')
-    .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
-    .action(async(datasourceKey, options) => {
-      try {
-        const result = await runDatasourceTestIntegration(datasourceKey, {
-          app: options.app,
-          payload: options.payload,
-          environment: options.env,
-          debug: options.debug,
-          timeout: options.timeout
-        });
-        displayIntegrationTestResults({
-          systemKey: result.systemKey || 'unknown',
-          datasourceResults: [result],
-          success: result.success
-        }, options.verbose);
-        if (!result.success) process.exit(1);
-      } catch (error) {
-        logger.error(chalk.red('❌ Integration test failed:'), error.message);
-        process.exit(1);
-      }
-    });
-}
-
-function setupDatasourceTestE2ECommand(datasource) {
-  datasource.command('test-e2e <datasourceKey>')
-    .description('Run E2E test for one datasource (config, credential, sync, data, CIP) via dataplane')
-    .option('-a, --app <appKey>', 'App key (default: resolve from cwd if inside integration/<appKey>/)')
-    .option('-e, --env <env>', 'Environment: dev, tst, or pro')
-    .option('-v, --verbose', 'Show detailed step output and poll progress')
-    .option('--debug', 'Include debug output and write log to integration/<appKey>/logs/')
-    .option('--test-crud', 'Enable CRUD lifecycle test (body testCrud: true)')
-    .option('--record-id <id>', 'Record ID for test (body recordId)')
-    .option('--no-cleanup', 'Disable cleanup after test (body cleanup: false)')
-    .option('--primary-key-value <value|@path>', 'Primary key value or path to JSON file (e.g. @pk.json) for body primaryKeyValue')
-    .option('--no-async', 'Use sync mode (no polling); single POST, no asyncRun')
+function setupDatasourceLogE2ECommand(datasource) {
+  datasource.command('log-e2e <datasourceKey>')
+    .description('Show E2E test log (latest or --file)')
+    .option(
+      '-a, --app <app>',
+      'Integration folder name (optional: resolve from cwd or datasource key if single match)'
+    )
+    .option('-f, --file <path>', 'Path to log file (default: latest in app logs folder)')
     .action(async(datasourceKey, options) => {
       try {
-        const data = await runDatasourceTestE2E(datasourceKey, {
+        await runLogViewer(datasourceKey, {
           app: options.app,
-          environment: options.env,
-          debug: options.debug,
-          verbose: options.verbose,
-          async: options.async !== false,
-          testCrud: options.testCrud,
-          recordId: options.recordId,
-          cleanup: options.cleanup,
-          primaryKeyValue: options.primaryKeyValue
+          file: options.file,
+          logType: 'test-e2e'
         });
-        displayE2EResults(data, options.verbose);
-        const steps = data.steps || data.completedActions || [];
-        const failed = data.success === false || steps.some(s => s.success === false || s.error);
-        if (failed) process.exit(1);
       } catch (error) {
-        logger.error(chalk.red('❌ E2E test failed:'), error.message);
+        logger.error(formatBlockingError('log-e2e failed:'), error.message);
         process.exit(1);
       }
     });
 }
 
-function setupDatasourceLogE2ECommand(datasource) {
-  datasource.command('log-e2e <datasourceKey>')
-    .description('Display latest or specified E2E test log in readable format')
-    .option('-a, --app <appKey>', 'App key (optional: resolve from cwd or datasource key if single match)')
+function setupDatasourceLogIntegrationCommand(datasource) {
+  datasource.command('log-integration <datasourceKey>')
+    .description('Show integration test log (latest or --file)')
+    .option(
+      '-a, --app <app>',
+      'Integration folder name (optional: resolve from cwd or datasource key if single match)'
+    )
     .option('-f, --file <path>', 'Path to log file (default: latest in app logs folder)')
     .action(async(datasourceKey, options) => {
       try {
         await runLogViewer(datasourceKey, {
           app: options.app,
           file: options.file,
-          logType: 'test-e2e'
+          logType: 'test-integration'
         });
       } catch (error) {
-        logger.error(chalk.red('❌ log-e2e failed:'), error.message);
+        logger.error(formatBlockingError('log-integration failed:'), error.message);
         process.exit(1);
       }
     });
 }
 
-function setupDatasourceLogIntegrationCommand(datasource) {
-  datasource.command('log-integration <datasourceKey>')
-    .description('Display latest or specified integration test log in readable format')
-    .option('-a, --app <appKey>', 'App key (optional: resolve from cwd or datasource key if single match)')
-    .option('-f, --file <path>', 'Path to log file (default: latest in app logs folder)')
+function setupDatasourceLogTestCommand(datasource) {
+  datasource.command('log-test <datasourceKey>')
+    .description('Show structural validation log from datasource test (latest test-*.json or --file)')
+    .option(
+      '-a, --app <app>',
+      'Integration folder name (optional: resolve from cwd or datasource key if single match)'
+    )
+    .option('-f, --file <path>', 'Path to log file (default: latest structural log in app logs folder)')
     .action(async(datasourceKey, options) => {
       try {
         await runLogViewer(datasourceKey, {
           app: options.app,
           file: options.file,
-          logType: 'test-integration'
+          logType: 'test'
         });
       } catch (error) {
-        logger.error(chalk.red('❌ log-integration failed:'), error.message);
+        logger.error(formatBlockingError('log-test failed:'), error.message);
         process.exit(1);
       }
     });
@@ -189,7 +214,10 @@ function setupDatasourceLogIntegrationCommand(datasource) {
  * @param {Command} program - Commander program instance
  */
 function setupDatasourceCommands(program) {
-  const datasource = program.command('datasource').description('Manage external data sources');
+  const datasource = program
+    .command('datasource')
+    .description('Datasource JSON: validate, list, deploy, test, logs')
+    .addHelpText('after', DATASOURCE_HELP_AFTER);
   if (typeof datasource.alias === 'function') {
     datasource.alias('ds');
   }
@@ -197,10 +225,12 @@ function setupDatasourceCommands(program) {
   setupDatasourceListCommand(datasource);
   setupDatasourceDiffCommand(datasource);
   setupDatasourceUploadCommand(datasource);
+  setupDatasourceTestCommand(datasource);
   setupDatasourceTestIntegrationCommand(datasource);
   setupDatasourceTestE2ECommand(datasource);
   setupDatasourceLogE2ECommand(datasource);
   setupDatasourceLogIntegrationCommand(datasource);
+  setupDatasourceLogTestCommand(datasource);
 }
 
 module.exports = { setupDatasourceCommands };

package/lib/commands/deployment-list.js

@@ -1,3 +1,4 @@
+const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
 /**
  * Deployment list commands – list deployments for environment or for an app
  * Uses GET .../deployments and GET .../applications/{appKey}/deployments.
@@ -97,7 +98,7 @@ async function runDeploymentList(options = {}) {
     );
     displayDeploymentList(extractDeployments(response), environment, authResult.controllerUrl);
   } catch (error) {
-    logger.error(chalk.red(`❌ Failed to list deployments: ${error.message}`));
+    logger.error(formatBlockingError(`Failed to list deployments: ${error.message}`));
     process.exit(1);
   }
 }
@@ -133,13 +134,13 @@ function displayAppDeploymentList(deployments, appKey, environment, controllerUr
 async function resolveDeploymentListContext(options) {
   const controllerUrl = options.controller || (await resolveControllerUrl());
   if (!controllerUrl) {
-    logger.error(chalk.red('❌ Controller URL is required. Run "aifabrix login" first.'));
+    logger.error(formatBlockingError('Controller URL is required. Run "aifabrix login" first.'));
     process.exit(1);
   }
   const environment = options.environment || (await resolveEnvironment());
   const authResult = await getDeploymentListAuth(controllerUrl);
   if (!authResult || !authResult.token) {
-    logger.error(chalk.red(`❌ No authentication token for controller: ${controllerUrl}`));
+    logger.error(formatBlockingError(`No authentication token for controller: ${controllerUrl}`));
     logger.error(chalk.gray('Run: aifabrix login'));
     process.exit(1);
   }
@@ -158,7 +159,7 @@ async function resolveDeploymentListContext(options) {
  */
 async function runAppDeploymentList(appKey, options = {}) {
   if (!appKey || typeof appKey !== 'string') {
-    logger.error(chalk.red('❌ Application key is required.'));
+    logger.error(formatBlockingError('Application key is required.'));
     process.exit(1);
     return;
   }
@@ -180,7 +181,7 @@ async function runAppDeploymentList(appKey, options = {}) {
       authResult.controllerUrl
     );
   } catch (error) {
-    logger.error(chalk.red(`❌ Failed to list deployments for ${appKey}: ${error.message}`));
+    logger.error(formatBlockingError(`Failed to list deployments for ${appKey}: ${error.message}`));
     process.exit(1);
   }
 }