@aifabrix/builder 2.46.0 → 2.47.0

package/lib/cli/setup-utility-resolve.js

@@ -60,8 +60,8 @@ async function runResolveJsonOutput(appName, appPath, envOnly, envPath, options,
  */
 async function runResolveHumanOutput(appName, envPath, envOnly, options, environment) {
   logger.log(`✔ Generated .env file: ${envPath}`);
-  if (options.fresh) {
-    logger.log(chalk.gray('  Wrote full resolved content (--fresh; did not merge with an existing .env).'));
+  if (options.fresh || options.force) {
+    logger.log(chalk.gray('  Wrote full resolved content (replaced existing .env from env.template; no merge).'));
   }
   if (environment === 'local') {
     logger.log(chalk.gray('  Resolved for local use (host ports; no Docker port rewrite).'));
@@ -130,7 +130,7 @@ async function runResolveAppAction(appName, options) {
       skipOutputPath: false,
       preserveFromPath: null,
       preferLocalEnvOutputPath,
-      freshEnv: options.fresh === true
+      freshEnv: options.fresh === true || options.force === true
     }
   );
   if (jsonMode) {
@@ -148,10 +148,13 @@ function setupResolveCommand(program) {
   program.command('resolve <appKey|systemKey>')
     .description('Generate .env from template (builder/<appKey>/ or integration/<systemKey>/); optional validate after')
     .addHelpText('after', RESOLVE_HELP_AFTER)
-    .option('-f, --force', 'Generate missing secret keys in secrets file')
+    .option(
+      '-f, --force',
+      'Seed missing secret keys and replace .env from env.template (no merge with existing .env or envOutputPath)'
+    )
     .option(
       '--fresh',
-      'Replace .env from env.template (no merge with existing .env or envOutputPath; same as deleting .env first)'
+      'Same full .env replace as --force without seeding missing secret keys in the secrets file'
     )
     .option('--skip-validation', 'Skip file validation after generating .env')
     .option('--json', 'Print JSON summary (envPath, manifestSource, optional validation)')

package/lib/commands/app-logs.js

@@ -13,6 +13,10 @@ const logger = require('../utils/logger');
 const config = require('../core/config');
 const containerHelpers = require('../utils/app-run-containers');
 const { validateAppName } = require('../app/push');
+const {
+  getCeleryCompanionAppKeys,
+  loadBuilderApplicationConfig
+} = require('../utils/celery-companion-apps');
 
 const { execWithDockerEnv } = require('../utils/docker-exec');
 const { maskEnvLine } = require('../utils/log-redaction');
@@ -295,6 +299,36 @@ async function runDockerLogsFollow(containerName, tail, minLevel) {
   });
 }
 
+function parseLogLevelOption(options) {
+  const rawLevel =
+    options.level !== undefined && options.level !== null && options.level !== ''
+      ? String(options.level).trim()
+      : undefined;
+  const level = rawLevel ? rawLevel.toLowerCase() : undefined;
+  if (level !== undefined && level !== null && !LOG_LEVELS.includes(level)) {
+    throw new Error(
+      `Invalid log level '${rawLevel}'; use one of: ${LOG_LEVELS.join(', ')}`
+    );
+  }
+  return level;
+}
+
+async function logFollowStream(companionKeys, containerName, tail, level) {
+  await runDockerLogsFollow(containerName, tail, level);
+  if (companionKeys.length > 0) {
+    const hint = companionKeys.map((key) => `aifabrix logs ${key}`).join(' or ');
+    logger.log(chalk.gray(`Tip: sidecar logs — ${hint}`));
+  }
+}
+
+async function logContainerSnapshot(containerName, tail, level) {
+  try {
+    await runDockerLogs(containerName, { tail, level });
+  } catch (err) {
+    logger.log(chalk.yellow(`No logs for ${containerName}: ${err.message}`));
+  }
+}
+
 /**
  * Run app logs command: optional env dump (masked), then docker logs
  * @async
@@ -307,39 +341,33 @@ async function runDockerLogsFollow(containerName, tail, minLevel) {
  */
 async function runAppLogs(appKey, options = {}) {
   validateAppName(appKey);
-  const rawLevel =
-    options.level !== undefined && options.level !== null && options.level !== ''
-      ? String(options.level).trim()
-      : undefined;
-  const level = rawLevel ? rawLevel.toLowerCase() : undefined;
-  if (level !== undefined && level !== null && !LOG_LEVELS.includes(level)) {
-    throw new Error(
-      `Invalid log level '${rawLevel}'; use one of: ${LOG_LEVELS.join(', ')}`
-    );
-  }
-
+  const level = parseLogLevelOption(options);
   const developerId = await config.getDeveloperId();
-  const containerName = containerHelpers.getContainerName(appKey, developerId);
-
   const follow = !!options.follow;
   const tail = typeof options.tail === 'number' ? options.tail : DEFAULT_TAIL_LINES;
+  const appConfig = loadBuilderApplicationConfig(appKey);
+  const companionKeys = getCeleryCompanionAppKeys(appKey, appConfig);
+  const appKeysToLog = follow ? [appKey] : [appKey, ...companionKeys];
 
-  logger.log(chalk.blue(`Container: ${containerName}\n`));
+  for (const key of appKeysToLog) {
+    const containerName = containerHelpers.getContainerName(key, developerId);
 
-  if (!follow) {
-    await dumpMaskedEnv(containerName);
-  }
+    logger.log(chalk.blue(`Container: ${containerName}\n`));
 
-  if (follow) {
-    await runDockerLogsFollow(containerName, tail, level);
-    return;
-  }
+    if (!follow) {
+      await dumpMaskedEnv(containerName);
+    }
 
-  try {
-    await runDockerLogs(containerName, { tail, level });
-  } catch (err) {
-    logger.log(chalk.red(`Error: ${err.message}`));
-    throw new Error(`Failed to show logs: ${err.message}`);
+    if (follow) {
+      await logFollowStream(companionKeys, containerName, tail, level);
+      return;
+    }
+
+    await logContainerSnapshot(containerName, tail, level);
+
+    if (key !== appKeysToLog[appKeysToLog.length - 1]) {
+      logger.log('');
+    }
   }
 }
 

package/lib/commands/app.js

@@ -17,6 +17,8 @@ const { registerApplication } = require('../app/register');
 const { rotateSecret } = require('../app/rotate-secret');
 const { showApp } = require('../app/show');
 const { runAppDeploymentList } = require('./deployment-list');
+const { isChannelTargetKey } = require('../channels/channel-targets');
+const { addChannelCommand } = require('../channels/add-channel');
 
 const APP_HELP_AFTER = `
 Subcommands:
@@ -25,6 +27,7 @@ Subcommands:
   rotate-secret <key>   New ClientSecret (shown once)
   show <key>            From controller (like show --online)
   deployment <key>      Deployment history for app
+  add-channel <target>  Configure assistant channel install (after deploy)
 
 Requires: aifabrix login
 `;
@@ -118,6 +121,43 @@ function setupAppDeploymentCommand(app) {
     });
 }
 
+function setupAppAddChannelCommand(app) {
+  app.command('add-channel <channelTarget>')
+    .description(
+      'Configure assistant channel install (teams-bot, slack, …) after aifabrix deploy <target>'
+    )
+    .requiredOption('-n, --name <name>', 'Customer-visible channel name')
+    .option('-d, --description <text>', 'Channel description (default generated)')
+    .option('--icon <path>', 'Path to channel icon asset')
+    .option('--template <name>', 'Template override (default from channel target)')
+    .option('--dry-run', 'Generate artifacts only; do not patch external system or credentials')
+    .option('--force', 'Regenerate artifacts and patch config (does not rotate secrets)')
+    .option('--probe', 'After install, validate callbacks and assistant catalog')
+    .action(async(channelTarget, options) => {
+      try {
+        if (!isChannelTargetKey(channelTarget)) {
+          throw new Error(
+            `Unknown channel target "${channelTarget}". Use teams-bot, slack, microsoft-copilot, or chatgpt.`
+          );
+        }
+        await addChannelCommand(channelTarget, {
+          name: options.name,
+          description: options.description,
+          icon: options.icon,
+          template: options.template,
+          dryRun: options.dryRun === true,
+          force: options.force === true,
+          probe: options.probe === true
+        });
+      } catch (error) {
+        if (!error.message?.includes('Authentication required')) {
+          logger.error(formatBlockingError('Channel install failed:'), error.message);
+        }
+        process.exit(1);
+      }
+    });
+}
+
 /**
  * Setup application management commands
  * @param {Command} program - Commander program instance
@@ -129,6 +169,7 @@ function setupAppCommands(program) {
   setupAppRotateSecretCommand(app);
   setupAppShowCommand(app);
   setupAppDeploymentCommand(app);
+  setupAppAddChannelCommand(app);
 }
 
 module.exports = { setupAppCommands };

package/lib/commands/auth-status-dataplane-version.js

@@ -17,7 +17,8 @@
 const { fetchDataplaneGeneralHealth } = require('../api/dataplane-health.api');
 const {
   updateDeviceDataplaneVersions,
-  getDeviceDataplaneVersions
+  getDeviceDataplaneVersions,
+  isCacheStale
 } = require('../core/config-device-dataplane');
 const {
   getInstalledCliVersion
@@ -25,10 +26,10 @@ const {
 const { isAtLeast, isValidSemver } = require('../utils/semver-compare');
 
 /** Max wall time for post-login version cache refresh (silent after success banner). */
-const LOGIN_POST_REFRESH_BUDGET_MS = 12000;
+const LOGIN_POST_REFRESH_BUDGET_MS = 8000;
 
-/** Per health probe during login refresh (two endpoints may be tried). */
-const LOGIN_HEALTH_PROBE_TIMEOUT_MS = 6000;
+/** Per health probe during login refresh (legacy /health first, then v1). */
+const LOGIN_HEALTH_PROBE_TIMEOUT_MS = 3000;
 
 /**
  * Resolve when `promise` settles or when `timeoutMs` elapses (returns undefined).
@@ -79,29 +80,32 @@ async function safeReadCache(controllerUrl) {
 }
 
 /**
- * Refresh dataplane health, persist `device.<controllerUrl>` version cache,
- * and derive the compatibility verdict against the installed Builder CLI.
- * Falls back to the cached entry when the live probe fails so `auth status`
- * still shows the last-known values offline.
- *
- * @async
- * @param {string} controllerUrl - Controller URL (cache key)
- * @param {string} dataplaneUrl - Dataplane base URL for the health probe
- * @returns {Promise<{
- *   dataplaneVersion: string|undefined,
- *   minBuilderCliVersion: string|undefined,
- *   cliVersion: string,
- *   compatible: boolean
- * }>}
+ * Build optional fetch args for {@link fetchDataplaneGeneralHealth}.
+ * @param {Object} [options]
+ * @returns {Object}
  */
-async function refreshDataplaneVersionInfo(controllerUrl, dataplaneUrl, options = {}) {
-  const cliVersion = getInstalledCliVersion();
-  let dataplaneVersion;
-  let minBuilderCliVersion;
+function buildHealthFetchOptions(options = {}) {
   const healthOpts = {};
   if (options.healthTimeoutMs !== undefined && options.healthTimeoutMs !== null) {
     healthOpts.timeoutMs = options.healthTimeoutMs;
   }
+  if (options.endpointOrder) {
+    healthOpts.endpointOrder = options.endpointOrder;
+  }
+  return healthOpts;
+}
+
+/**
+ * Probe dataplane health and persist version fields when available.
+ * @async
+ * @param {string} controllerUrl
+ * @param {string} dataplaneUrl
+ * @param {Object} healthOpts
+ * @returns {Promise<{ dataplaneVersion: string|undefined, minBuilderCliVersion: string|undefined }>}
+ */
+async function fetchAndPersistHealthSnapshot(controllerUrl, dataplaneUrl, healthOpts) {
+  let dataplaneVersion;
+  let minBuilderCliVersion;
 
   try {
     const snapshot = await fetchDataplaneGeneralHealth(dataplaneUrl, healthOpts);
@@ -121,14 +125,63 @@ async function refreshDataplaneVersionInfo(controllerUrl, dataplaneUrl, options
     // ignore — fall through to cached values
   }
 
-  if (!dataplaneVersion && !minBuilderCliVersion) {
-    const cached = await safeReadCache(controllerUrl);
-    if (cached) {
-      dataplaneVersion = cached.version;
-      minBuilderCliVersion = cached.minBuilderCliVersion;
-    }
+  return { dataplaneVersion, minBuilderCliVersion };
+}
+
+/**
+ * Fill missing version fields from the device cache when live probe failed.
+ * @async
+ * @param {string} controllerUrl
+ * @param {string|undefined} dataplaneVersion
+ * @param {string|undefined} minBuilderCliVersion
+ * @returns {Promise<{ dataplaneVersion: string|undefined, minBuilderCliVersion: string|undefined }>}
+ */
+async function resolveVersionFieldsFromCache(controllerUrl, dataplaneVersion, minBuilderCliVersion) {
+  if (dataplaneVersion || minBuilderCliVersion) {
+    return { dataplaneVersion, minBuilderCliVersion };
   }
 
+  const cached = await safeReadCache(controllerUrl);
+  if (!cached) {
+    return { dataplaneVersion, minBuilderCliVersion };
+  }
+
+  return {
+    dataplaneVersion: cached.version,
+    minBuilderCliVersion: cached.minBuilderCliVersion
+  };
+}
+
+/**
+ * Refresh dataplane health, persist `device.<controllerUrl>` version cache,
+ * and derive the compatibility verdict against the installed Builder CLI.
+ * Falls back to the cached entry when the live probe fails so `auth status`
+ * still shows the last-known values offline.
+ *
+ * @async
+ * @param {string} controllerUrl - Controller URL (cache key)
+ * @param {string} dataplaneUrl - Dataplane base URL for the health probe
+ * @returns {Promise<{
+ *   dataplaneVersion: string|undefined,
+ *   minBuilderCliVersion: string|undefined,
+ *   cliVersion: string,
+ *   compatible: boolean
+ * }>}
+ */
+async function refreshDataplaneVersionInfo(controllerUrl, dataplaneUrl, options = {}) {
+  const cliVersion = getInstalledCliVersion();
+  const healthOpts = buildHealthFetchOptions(options);
+  let { dataplaneVersion, minBuilderCliVersion } = await fetchAndPersistHealthSnapshot(
+    controllerUrl,
+    dataplaneUrl,
+    healthOpts
+  );
+  ({ dataplaneVersion, minBuilderCliVersion } = await resolveVersionFieldsFromCache(
+    controllerUrl,
+    dataplaneVersion,
+    minBuilderCliVersion
+  ));
+
   const compatible = computeCompatibility(cliVersion, minBuilderCliVersion);
   return { dataplaneVersion, minBuilderCliVersion, cliVersion, compatible };
 }
@@ -184,33 +237,6 @@ async function resolveAuthConfigAfterLogin(controllerUrl, environment, loginOpti
   }
 }
 
-/**
- * Resolve dataplane URL after login (mirrors auth-status silent resolver).
- * @private
- * @async
- * @param {string} controllerUrl
- * @param {string} environment
- * @param {Object} authConfig
- * @returns {Promise<string|null>}
- */
-async function resolveDataplaneUrlAfterLogin(controllerUrl, environment, authConfig) {
-  const { findDataplaneServiceAppKey } = require('./wizard-dataplane');
-  const { getDataplaneUrl } = require('../datasource/deploy');
-  try {
-    const dataplaneAppKey = await findDataplaneServiceAppKey(
-      controllerUrl,
-      environment,
-      authConfig
-    );
-    if (dataplaneAppKey) {
-      return await getDataplaneUrl(controllerUrl, dataplaneAppKey, environment, authConfig);
-    }
-    return await getDataplaneUrl(controllerUrl, 'dataplane', environment, authConfig);
-  } catch (_resolveError) {
-    return null;
-  }
-}
-
 /**
  * Best-effort health refresh after login when dataplane URL is discoverable.
  * Never throws — cache failures must not block login success.
@@ -222,7 +248,13 @@ async function resolveDataplaneUrlAfterLogin(controllerUrl, environment, authCon
  * @returns {Promise<void>}
  */
 async function tryRefreshDataplaneVersionAfterLoginWork(controllerUrl, loginOptions = {}) {
+  const cached = await safeReadCache(controllerUrl);
+  if (cached && !isCacheStale(cached)) {
+    return;
+  }
+
   const { resolveEnvironment } = require('../core/config');
+  const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
   const environment = await resolveEnvironment();
   const authConfig = await resolveAuthConfigAfterLogin(
     controllerUrl,
@@ -232,14 +264,18 @@ async function tryRefreshDataplaneVersionAfterLoginWork(controllerUrl, loginOpti
   if (!authConfig) {
     return;
   }
-  const dataplaneUrl = await resolveDataplaneUrlAfterLogin(
-    controllerUrl,
-    environment,
-    authConfig
-  );
+  let dataplaneUrl = null;
+  try {
+    dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig, {
+      silent: true
+    });
+  } catch (_resolveError) {
+    return;
+  }
   if (dataplaneUrl) {
     await refreshDataplaneVersionInfo(controllerUrl, dataplaneUrl, {
-      healthTimeoutMs: LOGIN_HEALTH_PROBE_TIMEOUT_MS
+      healthTimeoutMs: LOGIN_HEALTH_PROBE_TIMEOUT_MS,
+      endpointOrder: 'legacy-first'
     });
   }
 }

package/lib/commands/auth-status.js

@@ -14,8 +14,7 @@ const logger = require('../utils/logger');
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
 const { getAuthUser } = require('../api/auth.api');
 const { resolveControllerUrl } = require('../utils/controller-url');
-const { findDataplaneServiceAppKey } = require('./wizard-dataplane');
-const { getDataplaneUrl } = require('../datasource/deploy');
+const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
 const { checkDataplaneHealth } = require('../utils/dataplane-health');
 const {
   displayDataplaneVersionSection,
@@ -211,11 +210,7 @@ function displayTokenInfo(tokenInfo) {
  */
 async function resolveDataplaneUrlSilent(controllerUrl, environment, authConfig) {
   try {
-    const dataplaneAppKey = await findDataplaneServiceAppKey(controllerUrl, environment, authConfig);
-    if (dataplaneAppKey) {
-      return await getDataplaneUrl(controllerUrl, dataplaneAppKey, environment, authConfig);
-    }
-    return await getDataplaneUrl(controllerUrl, 'dataplane', environment, authConfig);
+    return await resolveDataplaneUrl(controllerUrl, environment, authConfig, { silent: true });
   } catch {
     return null;
   }

package/lib/commands/channel.js

@@ -0,0 +1,58 @@
+/**
+ * Channel CLI commands (plan 152).
+ *
+ * @fileoverview Scaffold communication external systems for channel deploy step 1
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { formatSuccessLine, formatBlockingError, sectionTitle, metadata } = require('../utils/cli-test-layout-chalk');
+const { CHANNEL_TARGET_KEYS, isChannelTargetKey } = require('../channels/channel-targets');
+const { scaffoldChannelIntegration } = require('../channels/channel-integration-generator');
+
+/**
+ * @param {import('commander').Command} program
+ */
+function setupChannelCommands(program) {
+  const channel = program
+    .command('channel')
+    .description('Assistant channel integration scaffolds (plan 152)');
+
+  channel
+    .command('scaffold <channelTarget>')
+    .description('Generate integration/<target>/ communication external system for deploy step 1')
+    .option('--force', 'Overwrite generated scaffold files when folder exists')
+    .option('--allow-experimental', 'Allow web-embed scaffold')
+    .action(async(channelTarget, options) => {
+      try {
+        if (!isChannelTargetKey(channelTarget)) {
+          throw new Error(
+            `Unknown channel target "${channelTarget}". Expected: ${CHANNEL_TARGET_KEYS.join(', ')}`
+          );
+        }
+        const result = scaffoldChannelIntegration(channelTarget, {
+          force: options.force === true,
+          allowExperimental: options.allowExperimental === true
+        });
+        logger.log(sectionTitle(`${channelTarget} channel scaffold`));
+        logger.log('');
+        logger.log(formatSuccessLine(`Created integration at ${result.integrationDir}`));
+        for (const file of result.files) {
+          logger.log(metadata(file));
+        }
+        logger.log('');
+        logger.log(chalk.white('Next steps:'));
+        logger.log(chalk.gray(`  aifabrix deploy ${channelTarget}`));
+        logger.log(chalk.gray(`  aifabrix app add-channel ${channelTarget} --name "Your Assistant"`));
+      } catch (error) {
+        logger.error(formatBlockingError(error.message || String(error)));
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupChannelCommands };

package/lib/commands/datasource.js

@@ -97,7 +97,7 @@ Omit [prefix] to list all datasources for the active environment.
 
 function setupDatasourceValidateCommand(datasource) {
   datasource.command('validate <file-or-key>')
-    .description('Validate datasource JSON (file path or datasource key under integration/<app>/)')
+    .description('Validate datasource YAML/JSON (file path or datasource key under integration/<app>/)')
     .addHelpText('after', DATASOURCE_VALIDATE_HELP_AFTER)
     .action(async(fileOrKey) => {
       try {

package/lib/commands/identity-apply-sync.js

@@ -7,14 +7,15 @@
 'use strict';
 
 const logger = require('../utils/logger');
-const { formatBlockingError, formatSuccessLine } = require('../utils/cli-layout-chalk');
+const { formatSuccessLine, headerKeyValue } = require('../utils/cli-layout-chalk');
 const {
   resolveControllerAndAuth,
   resolveEnvKey,
   requireNonEmpty,
   unwrapControllerData,
   throwIfApiFailed,
-  assertSyncStatsOk
+  assertSyncStatsOk,
+  logIdentityCliError
 } = require('./identity-shared');
 const { clearAuthCache } = require('../api/auth-cache.api');
 const { fullSyncToDataplane } = require('../api/dataplane-sync.api');
@@ -70,7 +71,7 @@ function setupIdentityApplyCommand(identityCmd) {
           );
         }
       } catch (e) {
-        logger.error(formatBlockingError(e.message));
+        logIdentityCliError(e.message);
         process.exit(1);
       }
     });
@@ -103,6 +104,46 @@ async function maybePurgeCache(controllerUrl, authConfig, purgeCache) {
   logger.log(formatSuccessLine('Controller cache cleared'));
 }
 
+/**
+ * @param {string} controllerUrl
+ * @param {string} envKey
+ * @param {Object} authConfig
+ * @returns {Promise<string>}
+ */
+async function resolveSyncDataplaneUrl(controllerUrl, envKey, authConfig) {
+  try {
+    const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
+    return await resolveDataplaneUrl(controllerUrl, envKey, authConfig, { silent: true });
+  } catch {
+    return '—';
+  }
+}
+
+/**
+ * @param {Object} params
+ * @param {string} params.controllerUrl
+ * @param {string} params.envKey
+ * @param {Object} params.authConfig
+ * @param {Object|null|undefined} params.stats
+ */
+async function printIdentitySyncSuccess({ controllerUrl, envKey, authConfig, stats }) {
+  const dataplaneUrl = await resolveSyncDataplaneUrl(controllerUrl, envKey, authConfig);
+  const usersProcessed = Number(stats?.usersProcessed ?? 0);
+  const groupsProcessed = Number(stats?.groupsProcessed ?? 0);
+  const syncErrors = Number(stats?.errors ?? 0);
+
+  logger.log('');
+  logger.log(formatSuccessLine(`Identity synced to dataplane (${envKey})`));
+  logger.log(headerKeyValue('  Controller:', controllerUrl));
+  logger.log(headerKeyValue('  Dataplane:', dataplaneUrl));
+  logger.log('');
+  logger.log(`  Users:   ${usersProcessed} processed`);
+  logger.log(`  Groups:  ${groupsProcessed} processed`);
+  if (syncErrors > 0) {
+    logger.log(`  Errors:  ${syncErrors}`);
+  }
+}
+
 async function runIdentitySyncAction(options) {
   try {
     const { controllerUrl, authConfig } = await resolveControllerAndAuth();
@@ -116,16 +157,16 @@ async function runIdentitySyncAction(options) {
       printJson(stats);
       return;
     }
-    logger.log(formatSuccessLine(`Identity synced to dataplane (${envKey})`));
-    logger.log(`  usersProcessed=${stats?.usersProcessed ?? 0}`);
-    logger.log(`  groupsProcessed=${stats?.groupsProcessed ?? 0}`);
+    await printIdentitySyncSuccess({ controllerUrl, envKey, authConfig, stats });
   } catch (e) {
-    logger.error(formatBlockingError(e.message));
+    logIdentityCliError(e.message);
     process.exit(1);
   }
 }
 
 module.exports = {
   setupIdentityApplyCommand,
-  setupIdentitySyncCommand
+  setupIdentitySyncCommand,
+  printIdentitySyncSuccess,
+  resolveSyncDataplaneUrl
 };