@aifabrix/builder 2.43.0 → 2.44.1

package/lib/datasource/unified-validation-run-body.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Build ValidationRunRequest body for unified datasource runs.
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const {
+  buildExternalDataSourceValidationRequest,
+  buildE2eOptionsFromCli,
+  includeDebugForRequest
+} = require('../utils/validation-run-request');
+const testHelpers = require('../utils/external-system-test-helpers');
+
+/**
+ * @param {Object} params
+ * @param {string} params.systemKey
+ * @param {string} params.datasourceKey
+ * @param {'test'|'integration'|'e2e'} params.runType
+ * @param {Object} params.datasource - Loaded datasource config
+ * @param {string} [params.payloadPath]
+ * @param {boolean} params.useAsync
+ * @param {Object} params.options - CLI options (debug, verbose, e2e fields, capabilityKey)
+ * @returns {Promise<import('../api/types/validation-run.types').ValidationRunRequestBody>}
+ */
+async function buildUnifiedValidationBody(params) {
+  const { systemKey, datasourceKey, runType, datasource, payloadPath, useAsync, options } = params;
+
+  let payloadTemplate;
+  if (payloadPath || runType === 'integration') {
+    const customPayload = await testHelpers.loadCustomPayload(payloadPath);
+    payloadTemplate = testHelpers.determinePayloadTemplate(datasource, datasourceKey, customPayload);
+    if (runType === 'integration' && !payloadTemplate) {
+      throw new Error(`No test payload found for datasource '${datasourceKey}'`);
+    }
+  }
+
+  const e2eExtra = options.capabilityKey
+    ? { capabilityKeys: [String(options.capabilityKey).trim()] }
+    : undefined;
+  const e2eOptions =
+    runType === 'e2e'
+      ? buildE2eOptionsFromCli({
+        debug: options.debug,
+        verbose: options.verbose,
+        testCrud: options.testCrud,
+        recordId: options.recordId,
+        cleanup: options.cleanup,
+        primaryKeyValue: options.primaryKeyValue,
+        minVectorHits: options.minVectorHits,
+        minProcessed: options.minProcessed,
+        minRecordCount: options.minRecordCount,
+        e2eOptionsExtra: e2eExtra
+      })
+      : undefined;
+
+  return buildExternalDataSourceValidationRequest({
+    systemKey,
+    datasourceKey,
+    runType,
+    payloadTemplate,
+    asyncRun: runType === 'e2e' && useAsync === true,
+    includeDebug: includeDebugForRequest(options.debug),
+    explain: options.verbose === true,
+    e2eOptions: e2eOptions && Object.keys(e2eOptions).length > 0 ? e2eOptions : undefined
+  });
+}
+
+module.exports = { buildUnifiedValidationBody };

package/lib/datasource/unified-validation-run-post.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview POST + optional poll for unified validation run (keeps main module small).
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { postValidationRunAndOptionalPoll } = require('../api/validation-runner');
+
+/**
+ * @param {Object} opts
+ * @param {string} opts.dataplaneUrl
+ * @param {Object} opts.authConfig
+ * @param {Object} opts.body
+ * @param {number} opts.timeoutMs
+ * @param {boolean} opts.useAsync
+ * @param {boolean} opts.noAsync
+ * @returns {Promise<{ envelope: Object|null, apiError: Object|null, pollTimedOut: boolean, incompleteNoAsync: boolean }>}
+ */
+/* eslint-disable max-lines-per-function, max-statements, complexity -- POST + poll orchestration */
+// Re-exported thin wrapper; single implementation lives in lib/api/validation-runner.js
+/* eslint-enable max-lines-per-function, max-statements, complexity */
+
+module.exports = { postValidationRunAndOptionalPoll };

package/lib/datasource/unified-validation-run-resolve.js

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview Resolve datasource file path + parsed config for unified validation.
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const path = require('path');
+const { getIntegrationPath } = require('../utils/paths');
+const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+const { loadConfigFile } = require('../utils/config-format');
+
+/**
+ * @param {string} appKey
+ * @param {string} datasourceKey
+ * @param {Function} findDatasourceFileByKey - From integration-context
+ * @returns {{ datasource: Object, datasourcePath: string }}
+ */
+function loadDatasourceForApp(appKey, datasourceKey, findDatasourceFileByKey) {
+  const appPath = getIntegrationPath(appKey);
+  const config = loadConfigFile(resolveApplicationConfigPath(appPath));
+  const schemaBasePath = config.externalIntegration?.schemaBasePath || './';
+  const datasourceFiles = config.externalIntegration?.dataSources || [];
+  let datasourceFile = datasourceFiles.find(f => {
+    const base = path.basename(f, path.extname(f));
+    return base === datasourceKey || base.includes(datasourceKey);
+  });
+  if (!datasourceFile) {
+    datasourceFile = findDatasourceFileByKey(appPath, schemaBasePath, datasourceFiles, datasourceKey);
+  }
+  if (!datasourceFile) {
+    throw new Error(`Datasource '${datasourceKey}' not found in application config`);
+  }
+  const datasourcePath = path.isAbsolute(schemaBasePath)
+    ? path.join(schemaBasePath, datasourceFile)
+    : path.join(appPath, schemaBasePath, datasourceFile);
+  const datasource = loadConfigFile(datasourcePath);
+  if (datasource.key !== datasourceKey) {
+    throw new Error(`Datasource key mismatch: file has '${datasource.key}', expected '${datasourceKey}'`);
+  }
+  return { datasource, datasourcePath };
+}
+
+module.exports = { loadDatasourceForApp };

package/lib/datasource/unified-validation-run.js

@@ -0,0 +1,93 @@
+const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
+/**
+ * @fileoverview Run one persisted datasource through the dataplane unified validation flow (POST + optional poll via `lib/api/validation-run.api.js`).
+ *
+ * **CLI:** `aifabrix datasource test`, `test-integration`, and `test-e2e` use this module with different `runType` values.
+ * **User-facing permissions:** see `docs/commands/permissions.md` (Dataplane scopes may differ from the minimum noted on the HTTP helper JSDoc).
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const { resolveAppKeyForDatasource } = require('./resolve-app');
+const { setupIntegrationTestAuth } = require('../external-system/test-auth');
+const { getConfig } = require('../core/config');
+const { getSystemKeyFromAppKey, findDatasourceFileByKey } = require('./integration-context');
+const { loadDatasourceForApp } = require('./unified-validation-run-resolve');
+const { buildUnifiedValidationBody } = require('./unified-validation-run-body');
+const { postValidationRunAndOptionalPoll } = require('./unified-validation-run-post');
+const { publishDatasourceViaPipeline } = require('../api/pipeline.api');
+const { requireBearerForDataplanePipeline } = require('../utils/token-manager');
+const { formatApiError } = require('../utils/api-error-handler');
+const logger = require('../utils/logger');
+
+/**
+ * Resolve datasource JSON path and loaded object (same rules as test-integration).
+ * Re-export for tests.
+ */
+function loadDatasourceForAppExport(appKey, datasourceKey) {
+  return loadDatasourceForApp(appKey, datasourceKey, findDatasourceFileByKey);
+}
+
+/**
+ * Run unified validation for one persisted datasource.
+ * @async
+ * @param {string} datasourceKey
+ * @param {Object} options
+ * @param {boolean} [options.sync] - Publish local datasource JSON via pipeline before POST validation/run
+ * @returns {Promise<{ envelope: Object|null, apiError: Object|null, pollTimedOut: boolean, incompleteNoAsync: boolean }>}
+ */
+async function runUnifiedDatasourceValidation(datasourceKey, options) {
+  if (!datasourceKey || typeof datasourceKey !== 'string') {
+    throw new Error('Datasource key is required');
+  }
+  const runType = options.runType || 'test';
+  const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
+  const systemKey = await getSystemKeyFromAppKey(appKey);
+  const { datasource } = loadDatasourceForAppExport(appKey, datasourceKey);
+
+  const configObj = await getConfig();
+  const { authConfig, dataplaneUrl } = await setupIntegrationTestAuth(appKey, options, configObj);
+
+  if (options.sync === true) {
+    requireBearerForDataplanePipeline(authConfig);
+    logger.log(chalk.cyan('Syncing local config to dataplane…'));
+    const publishResponse = await publishDatasourceViaPipeline(dataplaneUrl, systemKey, authConfig, datasource);
+    if (!publishResponse || publishResponse.success === false) {
+      const msg =
+        (publishResponse && (publishResponse.formattedError || publishResponse.error)) ||
+        formatApiError(publishResponse, dataplaneUrl) ||
+        'Publish failed';
+      throw new Error(`Sync failed: ${msg}`);
+    }
+    logger.log(formatSuccessLine('Sync complete'));
+  }
+
+  const useAsync = options.noAsync ? false : options.async !== false;
+  const timeoutMs = parseInt(String(options.timeout || '30000'), 10) || 30000;
+
+  const body = await buildUnifiedValidationBody({
+    systemKey,
+    datasourceKey,
+    runType,
+    datasource,
+    payloadPath: options.payload,
+    useAsync,
+    options
+  });
+
+  return postValidationRunAndOptionalPoll({
+    dataplaneUrl,
+    authConfig,
+    body,
+    timeoutMs,
+    useAsync,
+    noAsync: options.noAsync === true || options.async === false,
+    verbosePoll: options.verbose === true
+  });
+}
+
+module.exports = {
+  runUnifiedDatasourceValidation,
+  loadDatasourceForApp: loadDatasourceForAppExport
+};

package/lib/datasource/validate.js

@@ -8,33 +8,172 @@
  * @version 2.0.0
  */
 
+const path = require('path');
 const fs = require('fs');
+const pathsUtil = require('../utils/paths');
 const { loadExternalDataSourceSchema } = require('../utils/schema-loader');
 const { formatValidationErrors } = require('../utils/error-formatter');
 const { validateFieldReferences } = require('./field-reference-validator');
 const { validateAbac } = require('./abac-validator');
 
+const EXCLUDE_JSON_NAMES = new Set(['application.json', 'rbac.json', 'package.json', 'package-lock.json']);
+
+/**
+ * Resolve identifier to an existing file path, or null.
+ * If `fs.statSync` is unavailable (partial Jest mocks), `existsSync` alone implies a file.
+ * @param {string} identifier
+ * @returns {string|null} Absolute path
+ */
+function tryResolveAsExistingFile(identifier) {
+  const candidates = [...new Set([identifier, path.resolve(identifier)])];
+  for (const p of candidates) {
+    try {
+      if (!fs.existsSync(p)) continue;
+      try {
+        const st = fs.statSync(p);
+        if (st && typeof st.isFile === 'function' && st.isFile()) {
+          return path.resolve(p);
+        }
+      } catch {
+        return path.resolve(p);
+      }
+    } catch {
+      // ignore
+    }
+  }
+  return null;
+}
+
+/**
+ * Pick integration app folder for a datasource `key` (longest matching prefix wins).
+ * @param {string} datasourceKey
+ * @param {string[]} appNames
+ * @returns {string|null}
+ */
+function pickIntegrationAppForDatasourceKey(datasourceKey, appNames) {
+  const matches = appNames.filter((app) => datasourceKey === app || datasourceKey.startsWith(`${app}-`));
+  if (matches.length === 0) return null;
+  matches.sort((a, b) => b.length - a.length);
+  return matches[0];
+}
+
+/**
+ * @param {string} fileName
+ * @returns {boolean}
+ */
+function shouldScanJsonDatasourceCandidate(fileName) {
+  const lower = fileName.toLowerCase();
+  if (!lower.endsWith('.json')) return false;
+  if (EXCLUDE_JSON_NAMES.has(fileName)) return false;
+  if (lower.endsWith('-deploy.json') || lower.endsWith('-system.json')) return false;
+  return true;
+}
+
+/**
+ * @param {string} fileName
+ * @returns {boolean}
+ */
+function isDatasourceNamedJson(fileName) {
+  return fileName.toLowerCase().includes('datasource');
+}
+
+/**
+ * @param {string} dir
+ * @param {string[]} scanOrder
+ * @param {string} datasourceKey
+ * @returns {string[]}
+ */
+function collectJsonPathsMatchingDatasourceKey(dir, scanOrder, datasourceKey) {
+  const hits = [];
+  for (const name of scanOrder) {
+    const full = path.join(dir, name);
+    let parsed;
+    try {
+      parsed = JSON.parse(fs.readFileSync(full, 'utf8'));
+    } catch {
+      continue;
+    }
+    if (parsed && typeof parsed === 'object' && parsed.key === datasourceKey) {
+      hits.push(full);
+    }
+  }
+  return hits;
+}
+
+/**
+ * Find integration JSON whose parsed `key` equals datasourceKey.
+ * @param {string} datasourceKey
+ * @returns {string} Absolute file path
+ * @throws {Error}
+ */
+function resolvePathFromIntegrationDatasourceKey(datasourceKey) {
+  const appNames = pathsUtil.listIntegrationAppNames();
+  const appName = pickIntegrationAppForDatasourceKey(datasourceKey, appNames);
+  if (!appName) {
+    throw new Error(
+      `No integration/<app>/ folder matches datasource key "${datasourceKey}". ` +
+        'Pass a path to the JSON file, or use a key whose prefix matches an app under integration/ ' +
+        '(e.g. app test-e2e-hubspot for key test-e2e-hubspot-users).'
+    );
+  }
+  const dir = pathsUtil.getIntegrationPath(appName);
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    throw new Error(`Integration folder not found: ${dir}`);
+  }
+  const entries = fs.readdirSync(dir);
+  const jsonFiles = entries.filter(shouldScanJsonDatasourceCandidate);
+  const prefer = jsonFiles.filter(isDatasourceNamedJson);
+  const scanOrder = [...prefer, ...jsonFiles.filter((f) => !prefer.includes(f))];
+  const hits = collectJsonPathsMatchingDatasourceKey(dir, scanOrder, datasourceKey);
+  if (hits.length === 0) {
+    throw new Error(
+      `No datasource JSON with key "${datasourceKey}" under integration/${appName}/. ` +
+        `Checked: ${scanOrder.length ? scanOrder.join(', ') : '(no JSON candidates)'}`
+    );
+  }
+  if (hits.length > 1) {
+    throw new Error(`Ambiguous: multiple files declare key "${datasourceKey}": ${hits.join(', ')}`);
+  }
+  return hits[0];
+}
+
+/**
+ * @param {string} identifier - File path or datasource `key`
+ * @returns {string} Absolute path to JSON file
+ * @throws {Error}
+ */
+function resolveValidateInputPath(identifier) {
+  const trimmed = String(identifier || '').trim();
+  if (!trimmed) {
+    throw new Error('File path is required and must be a string');
+  }
+  const asFile = tryResolveAsExistingFile(trimmed);
+  if (asFile) return asFile;
+  if (trimmed.toLowerCase().endsWith('.json')) {
+    throw new Error(`File not found: ${trimmed}`);
+  }
+  return resolvePathFromIntegrationDatasourceKey(trimmed);
+}
+
 /**
  * Validates a datasource file against external-datasource schema
  *
  * @async
  * @function validateDatasourceFile
- * @param {string} filePath - Path to the datasource JSON file
- * @returns {Promise<Object>} Validation result with errors and warnings
+ * @param {string} filePathOrKey - Path to the datasource JSON file, or datasource `key` resolved under integration/<app>/
+ * @returns {Promise<Object>} Validation result with errors, warnings, and `resolvedPath` (absolute JSON path)
  * @throws {Error} If file cannot be read or parsed
  *
  * @example
  * const result = await validateDatasourceFile('./hubspot-deal.json');
- * // Returns: { valid: true, errors: [], warnings: [] }
+ * // Returns: { valid: true, errors: [], warnings: [], resolvedPath: '...' }
  */
-async function validateDatasourceFile(filePath) {
-  if (!filePath || typeof filePath !== 'string') {
+async function validateDatasourceFile(filePathOrKey) {
+  if (!filePathOrKey || typeof filePathOrKey !== 'string') {
     throw new Error('File path is required and must be a string');
   }
 
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`File not found: ${filePath}`);
-  }
+  const filePath = resolveValidateInputPath(filePathOrKey.trim());
 
   const content = fs.readFileSync(filePath, 'utf8');
   let parsed;
@@ -45,7 +184,8 @@ async function validateDatasourceFile(filePath) {
     return {
       valid: false,
       errors: [`Invalid JSON syntax: ${error.message}`],
-      warnings: []
+      warnings: [],
+      resolvedPath: filePath
     };
   }
 
@@ -56,7 +196,8 @@ async function validateDatasourceFile(filePath) {
     return {
       valid: false,
       errors: formatValidationErrors(validate.errors),
-      warnings: []
+      warnings: [],
+      resolvedPath: filePath
     };
   }
 
@@ -67,18 +208,21 @@ async function validateDatasourceFile(filePath) {
     return {
       valid: false,
       errors: postSchemaErrors,
-      warnings: []
+      warnings: [],
+      resolvedPath: filePath
     };
   }
 
   return {
     valid: true,
     errors: [],
-    warnings: []
+    warnings: [],
+    resolvedPath: filePath
   };
 }
 
 module.exports = {
-  validateDatasourceFile
+  validateDatasourceFile,
+  resolveValidateInputPath
 };
 

package/lib/deployment/deployer.js

@@ -1,3 +1,4 @@
+const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
 /**
  * AI Fabrix Builder Deployment Module
  *
@@ -139,7 +140,7 @@ async function validateDeployment(url, envKey, manifest, authConfig, options = {
       const shouldRetry = attempt < maxRetries && error.status && error.status >= 500;
       if (shouldRetry) {
         const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
-        logger.log(chalk.yellow(`⚠️  Validation attempt ${attempt} failed, retrying in ${delay}ms...`));
+        logger.log(chalk.yellow(`⚠  Validation attempt ${attempt} failed, retrying in ${delay}ms...`));
         await new Promise(resolve => setTimeout(resolve, delay));
       } else {
         throw error;
@@ -266,7 +267,7 @@ async function sendDeploymentRequest(url, envKey, validateToken, authConfig, opt
       lastError = error;
       if (attempt < maxRetries) {
         const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
-        logger.log(chalk.yellow(`⚠️  Deployment attempt ${attempt} failed, retrying in ${delay}ms...`));
+        logger.log(chalk.yellow(`⚠  Deployment attempt ${attempt} failed, retrying in ${delay}ms...`));
         await new Promise(resolve => setTimeout(resolve, delay));
       }
     }
@@ -365,7 +366,7 @@ async function sendDeployment(url, validatedEnvKey, manifest, authConfig, option
     throw new Error('Validation failed: validateToken not received');
   }
 
-  logger.log(chalk.green('✓ Validation successful'));
+  logger.log(formatSuccessLine('Validation successful'));
   if (validateResult.draftDeploymentId) {
     logger.log(chalk.gray(`   Draft Deployment ID: ${validateResult.draftDeploymentId}`));
   }

package/lib/deployment/environment.js

@@ -1,3 +1,4 @@
+const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
 /**
  * AI Fabrix Builder Environment Deployment Module
  *
@@ -276,16 +277,16 @@ async function pollEnvironmentStatus(deploymentId, controllerUrl, envKey, authCo
  * @param {Object} result - Deployment result
  */
 function displayDeploymentResults(result) {
-  logger.log(chalk.green('\n✅ Environment deployed successfully'));
+  logger.log(formatSuccessParagraph('Environment deployed successfully'));
   logger.log(chalk.blue(`   Environment: ${result.environment}`));
-  logger.log(chalk.blue(`   Status: ${result.status === 'ready' ? '✅ ready' : result.status}`));
+  logger.log(chalk.blue(`   Status: ${result.status === 'ready' ? '✔ ready' : result.status}`));
   if (result.url) {
     logger.log(chalk.blue(`   URL: ${result.url}`));
   }
   if (result.deploymentId) {
     logger.log(chalk.blue(`   Deployment ID: ${result.deploymentId}`));
   }
-  logger.log(chalk.green('\n✓ Environment is ready for application deployments'));
+  logger.log(formatSuccessParagraph('Environment is ready for application deployments'));
 }
 
 /**
@@ -340,8 +341,8 @@ async function prepareEnvironmentDeployment(envKey, controllerUrl, options) {
   // Get authentication (device token)
   logger.log(chalk.blue(`\n📋 Deploying environment '${envKey}' to ${controllerUrl}...`));
   const authConfig = await getEnvironmentAuth(controllerUrl);
-  logger.log(chalk.green('✓ Environment validated'));
-  logger.log(chalk.green('✓ Authentication successful'));
+  logger.log(formatSuccessLine('Environment validated'));
+  logger.log(formatSuccessLine('Authentication successful'));
 
   return authConfig;
 }
@@ -412,7 +413,7 @@ async function deployEnvironment(envKey, options = {}) {
     // Error handling is done in sendEnvironmentDeployment and pollEnvironmentStatus
     // Re-throw with context
     if (error._logged !== true) {
-      logger.error(chalk.red(`\n❌ Environment deployment failed: ${error.message}`));
+      logger.error(chalk.red(`\n✖ Environment deployment failed: ${error.message}`));
     }
     throw error;
   }

package/lib/deployment/push.js

@@ -1,3 +1,4 @@
+const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
 /**
  * AI Fabrix Builder Push Utilities
  *
@@ -170,7 +171,7 @@ async function authenticateACR(registry) {
     // On Windows, use shell option to ensure proper command resolution
     const options = process.platform === 'win32' ? { shell: true } : {};
     await execAsync(`az acr login --name ${registryName}`, { ...options, timeout: AZ_ACR_LOGIN_TIMEOUT_MS });
-    logger.log(chalk.green(`✓ Authenticated with ${registry}`));
+    logger.log(formatSuccessLine(`Authenticated with ${registry}`));
   } catch (error) {
     const msg = error.message || String(error);
     if (msg.includes('ETIMEDOUT') || msg.includes('timeout')) {
@@ -196,7 +197,9 @@ async function authenticateExternalRegistry(registry, username, password) {
     // Use cross-platform approach: write password to stdin directly
     // This works on Windows, Linux, and macOS
     const { spawn } = require('child_process');
-    const dockerLogin = spawn('docker', ['login', registry, '-u', username, '--password-stdin']);
+    const { getDockerExecEnv } = require('../utils/remote-docker-env');
+    const dockerEnv = await getDockerExecEnv();
+    const dockerLogin = spawn('docker', ['login', registry, '-u', username, '--password-stdin'], { env: dockerEnv });
 
     return new Promise((resolve, reject) => {
       let errorOutput = '';
@@ -214,7 +217,7 @@ async function authenticateExternalRegistry(registry, username, password) {
 
       dockerLogin.on('close', (code) => {
         if (code === 0) {
-          logger.log(chalk.green(`✓ Authenticated with ${registry}`));
+          logger.log(formatSuccessLine(`Authenticated with ${registry}`));
           resolve();
         } else {
           reject(new Error(`Docker login failed: ${errorOutput || `Exit code ${code}`}`));
@@ -238,8 +241,10 @@ async function authenticateExternalRegistry(registry, username, password) {
  */
 async function checkLocalImageExists(imageName, tag = 'latest') {
   try {
+    const { getDockerExecEnv } = require('../utils/remote-docker-env');
+    const env = await getDockerExecEnv();
     // Use Docker's native filtering for cross-platform compatibility (Windows-safe)
-    const { stdout } = await execAsync(`docker images --format "{{.Repository}}:{{.Tag}}" --filter "reference=${imageName}:${tag}"`);
+    const { stdout } = await execAsync(`docker images --format "{{.Repository}}:{{.Tag}}" --filter "reference=${imageName}:${tag}"`, { env });
     const lines = stdout.trim().split('\n').filter(line => line.trim() !== '');
     return lines.some(line => line.trim() === `${imageName}:${tag}`);
   } catch (error) {
@@ -255,9 +260,11 @@ async function checkLocalImageExists(imageName, tag = 'latest') {
  */
 async function tagImage(sourceImage, targetImage) {
   try {
+    const { getDockerExecEnv } = require('../utils/remote-docker-env');
+    const env = await getDockerExecEnv();
     logger.log(chalk.blue(`Tagging ${sourceImage} as ${targetImage}...`));
-    await execAsync(`docker tag ${sourceImage} ${targetImage}`);
-    logger.log(chalk.green(`✓ Tagged: ${targetImage}`));
+    await execAsync(`docker tag ${sourceImage} ${targetImage}`, { env });
+    logger.log(formatSuccessLine(`Tagged: ${targetImage}`));
   } catch (error) {
     throw new Error(`Failed to tag image: ${error.message}`);
   }
@@ -271,9 +278,11 @@ async function tagImage(sourceImage, targetImage) {
  */
 async function pushImage(imageWithTag, registry = null) {
   try {
+    const { getDockerExecEnv } = require('../utils/remote-docker-env');
+    const env = await getDockerExecEnv();
     logger.log(chalk.blue(`Pushing ${imageWithTag}...`));
-    await execAsync(`docker push ${imageWithTag}`);
-    logger.log(chalk.green(`✓ Pushed: ${imageWithTag}`));
+    await execAsync(`docker push ${imageWithTag}`, { env });
+    logger.log(formatSuccessLine(`Pushed: ${imageWithTag}`));
   } catch (error) {
     const errorMessage = error.message || error.stderr || String(error);
     const isAuthError = errorMessage.includes('authentication required') ||

package/lib/external-system/delete.js

@@ -9,6 +9,7 @@
  */
 
 'use strict';
+const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
 
 const chalk = require('chalk');
 const inquirer = require('inquirer');
@@ -97,7 +98,7 @@ async function confirmDeletion(systemKey, datasources, options) {
     return true;
   }
 
-  logger.log(chalk.yellow(`\n⚠️  Warning: Deleting external system '${systemKey}' will also delete all associated datasources:`));
+  logger.log(chalk.yellow(`\n⚠  Warning: Deleting external system '${systemKey}' will also delete all associated datasources:`));
   if (datasources.length > 0) {
     datasources.forEach(ds => logger.log(chalk.yellow(` - ${ds}`)));
   } else {
@@ -141,8 +142,8 @@ async function deleteExternalSystemCommand(systemKey, options = {}) {
     throw new Error(response?.error || response?.formattedError || `Failed to delete external system '${systemKey}'`);
   }
 
-  logger.log(chalk.green(`✓ External system '${systemKey}' deleted successfully`));
-  logger.log(chalk.green('✓ All associated datasources have been removed'));
+  logger.log(formatSuccessLine(`External system '${systemKey}' deleted successfully`));
+  logger.log(formatSuccessLine('All associated datasources have been removed'));
 }
 
 module.exports = {