@aifabrix/builder 2.43.0 → 2.44.0

package/lib/commands/datasource-unified-test-cli.options.js

@@ -0,0 +1,149 @@
+/**
+ * @fileoverview Shared option builders + help text for datasource test CLI commands.
+ */
+
+'use strict';
+
+function datasourceTestHelpAfter() {
+  return `
+Examples:
+  $ aifabrix datasource test hubspot-users
+  $ aifabrix datasource test hubspot-users --app test-e2e-hubspot -v
+  $ aifabrix datasource test hubspot-users -a test-e2e-hubspot --debug full
+  $ aifabrix datasource test hubspot-users --json
+
+Notes:
+  - For integration pipeline tests, use:
+      aifabrix datasource test-integration <datasourceKey>
+  - For system-level rollup across datasources, use:
+      aifabrix test <systemKey>
+`;
+}
+
+function datasourceTestIntegrationHelpAfter() {
+  return `
+Examples:
+  $ aifabrix datasource test-integration hubspot-users
+  $ aifabrix datasource test-integration hubspot-users --app test-e2e-hubspot --debug
+  $ aifabrix datasource test-integration hubspot-users -a test-e2e-hubspot -e tst --timeout 60000
+
+Notes:
+  - For structural/policy validation, use:
+      aifabrix datasource test <datasourceKey>
+  - For E2E capability execution, use:
+      aifabrix datasource test-e2e <datasourceKey>
+  - For system-level integration rollup across datasources, use:
+      aifabrix test-integration <systemKey>
+`;
+}
+
+function datasourceTestE2eHelpAfter() {
+  return `
+Examples:
+  $ aifabrix datasource test-e2e hubspot-users
+  $ aifabrix datasource test-e2e hubspot-users --app test-e2e-hubspot -v --debug
+  $ aifabrix datasource test-e2e hubspot-users -a test-e2e-hubspot --no-async
+  $ aifabrix datasource test-e2e hubspot-users read
+
+Notes:
+  - For structural/policy validation, use:
+      aifabrix datasource test <datasourceKey>
+  - For integration pipeline tests, use:
+      aifabrix datasource test-integration <datasourceKey>
+  - For system-level E2E rollup across datasources, use:
+      aifabrix test-e2e <systemKey>
+`;
+}
+
+/**
+ * @param {object} cmd - Commander command (chainable)
+ * @returns {object}
+ */
+function attachDatasourceWatchOptions(cmd) {
+  return cmd
+    .option(
+      '--watch',
+      'Re-run when watched files change (debounced; integration tree + optional paths)'
+    )
+    .option(
+      '--watch-path <path>',
+      'Extra file or directory to watch (repeatable)',
+      (value, previous) => (Array.isArray(previous) ? previous : []).concat(value),
+      []
+    )
+    .option('--watch-application-yaml', 'Include integration/<app>/application.yaml in the watch set')
+    .option('--watch-ci', 'Exit after the first run with the normal exit code (CI one-shot)')
+    .option('--watch-full-diff', 'Print full before/after fingerprint lines when the result changes');
+}
+
+/**
+ * Shared options for datasource-level `test`, `test-integration`, and `test-e2e`.
+ *
+ * Registration order matches intended `--help` order: core run flags → payload/timeout →
+ * `--sync` (pre-run publish) → machine/exit modifiers → async → watch (last before `--help`).
+ * Callers must append `addHelpText('after', …)` **after** any command-specific options (e.g. E2E).
+ *
+ * @param {object} cmd - Commander command (chainable)
+ * @param {Object} opts
+ * @param {boolean} [opts.includeNoAsync]
+ * @param {boolean} [opts.includePayload]
+ * @param {string} [opts.appHelp]
+ * @param {string} [opts.verboseHelp]
+ * @param {string} [opts.debugHelp]
+ * @param {string} [opts.timeoutHelp]
+ * @param {string} [opts.timeoutDefault]
+ * @returns {object}
+ */
+function attachDatasourceTestCommonOptions(cmd, opts) {
+  const includeNoAsync = opts.includeNoAsync === true;
+  const includePayload = opts.includePayload !== false;
+
+  cmd
+    .option(
+      '-a, --app <app>',
+      opts.appHelp ||
+        'Integration folder name (optional: resolve from cwd or datasource key if single match)'
+    )
+    .option('-e, --env <env>', 'Environment: dev, tst, or pro')
+    .option('-v, --verbose', opts.verboseHelp || 'Explain mode and detailed output where available')
+    .option(
+      '-d, --debug [level]',
+      opts.debugHelp ||
+        'includeDebug on request; TTY appendix: summary (default), full, or raw (not with --json)'
+    );
+
+  if (includePayload) {
+    cmd.option('-p, --payload <file>', 'Optional custom payload file (sets payloadTemplate on request)');
+  }
+
+  cmd
+    .option(
+      '--timeout <ms>',
+      opts.timeoutHelp || 'Aggregate timeout for POST + polls (ms)',
+      opts.timeoutDefault || '30000'
+    )
+    .option(
+      '--sync',
+      'Publish this datasource JSON from disk to the dataplane before running the test (requires login / same auth as upload)'
+    )
+    .option('--json', 'Print raw DatasourceTestRun JSON to stdout')
+    .option('--summary', 'Print compact summary line')
+    .option('--warnings-as-errors', 'Exit 1 when root status is warn')
+    .option('--require-cert', 'Exit 2 when certificate missing or not_passed');
+
+  if (includeNoAsync) {
+    cmd.option('--no-async', 'Do not poll; fail if report is not complete in first response');
+  }
+
+  attachDatasourceWatchOptions(cmd);
+  return cmd;
+}
+
+module.exports = {
+  datasourceTestHelpAfter,
+  datasourceTestIntegrationHelpAfter,
+  datasourceTestE2eHelpAfter,
+  attachDatasourceWatchOptions,
+  attachDatasourceTestCommonOptions
+};
+

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

@@ -0,0 +1,129 @@
+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;
+  }
+  return computeExitCodeFromDatasourceTestRun(env, {
+    warningsAsErrors: exitOpts.warningsAsErrors === true,
+    requireCert: exitOpts.requireCert === true
+  });
+}
+
+/**
+ * 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; 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-integration / log-e2e    Show saved test logs
+`;
+
+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,92 +118,26 @@ 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);
-      } catch (error) {
-        logger.error(chalk.red('❌ 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')
-    .action(async(datasourceKey, options) => {
-      try {
-        const data = await runDatasourceTestE2E(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
-        });
-        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);
+        await deployDatasource(fileOrKey, options);
       } catch (error) {
-        logger.error(chalk.red('❌ E2E test failed:'), error.message);
+        logger.error(formatBlockingError('Upload failed:'), error.message);
         process.exit(1);
       }
     });
@@ -148,8 +145,11 @@ function setupDatasourceTestE2ECommand(datasource) {
 
 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)')
+    .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 {
@@ -159,7 +159,7 @@ function setupDatasourceLogE2ECommand(datasource) {
           logType: 'test-e2e'
         });
       } catch (error) {
-        logger.error(chalk.red('❌ log-e2e failed:'), error.message);
+        logger.error(formatBlockingError('log-e2e failed:'), error.message);
         process.exit(1);
       }
     });
@@ -167,8 +167,11 @@ function setupDatasourceLogE2ECommand(datasource) {
 
 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)')
+    .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 {
@@ -178,7 +181,7 @@ function setupDatasourceLogIntegrationCommand(datasource) {
           logType: 'test-integration'
         });
       } catch (error) {
-        logger.error(chalk.red('❌ log-integration failed:'), error.message);
+        logger.error(formatBlockingError('log-integration failed:'), error.message);
         process.exit(1);
       }
     });
@@ -189,7 +192,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,6 +203,7 @@ function setupDatasourceCommands(program) {
   setupDatasourceListCommand(datasource);
   setupDatasourceDiffCommand(datasource);
   setupDatasourceUploadCommand(datasource);
+  setupDatasourceTestCommand(datasource);
   setupDatasourceTestIntegrationCommand(datasource);
   setupDatasourceTestE2ECommand(datasource);
   setupDatasourceLogE2ECommand(datasource);

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);
   }
 }