@aifabrix/builder 2.44.4 → 2.44.6

package/lib/app/run.js

@@ -10,15 +10,23 @@
  */
 
 const chalk = require('chalk');
+const {
+  formatWarningLine,
+  sectionTitle,
+  headerKeyValue,
+  metadata,
+  formatNextActions
+} = require('../utils/cli-test-layout-chalk');
 const config = require('../core/config');
 const logger = require('../utils/logger');
 const pathsUtil = require('../utils/paths');
 const { checkPortAvailable, waitForHealthCheck } = require('../utils/health-check');
 const composeGenerator = require('../utils/compose-generator');
 const containerHelpers = require('../utils/app-run-containers');
-const mutagen = require('../utils/mutagen');
 // Helper functions extracted to reduce file size and complexity
 const helpers = require('./run-helpers');
+const { ensureReloadSync, logReloadDevSummary } = require('./run-reload-sync');
+const { logRestartDevMountSummary } = require('./restart-display');
 const { execWithDockerEnv } = require('../utils/docker-exec');
 
 /**
@@ -73,8 +81,16 @@ async function validateAppForRun(appName, _debug) {
   try {
     const { isExternal, baseDir } = await detectAppType(appName);
     if (baseDir !== 'builder' || isExternal) {
-      logger.log(chalk.yellow('⚠  External systems don\'t run as Docker containers.'));
-      logger.log(chalk.blue('Use "aifabrix build" to deploy to dataplane, then test via OpenAPI endpoints.'));
+      logger.log('');
+      logger.log(sectionTitle('Run'));
+      logger.log(headerKeyValue('Application:', appName));
+      logger.log(
+        formatWarningLine('External integrations are not started as local Docker containers.')
+      );
+      logger.log(
+        metadata('Build and deploy the integration, then use its APIs from your environment.')
+      );
+      logger.log(formatNextActions([`aifabrix build ${appName}`]));
       return false;
     }
   } catch (error) {
@@ -114,7 +130,7 @@ async function checkAndStopContainer(appName, appConfig, options, debug) {
   }
 
   const containerName = containerHelpers.getContainerName(appName, developerId, scopeOpts);
-  logger.log(chalk.yellow(`Container ${containerName} is already running`));
+  logger.log(formatWarningLine(`Container ${containerName} is already running`));
   await helpers.stopAndRemoveContainer(appName, developerId, debug, scopeOpts);
 }
 
@@ -149,48 +165,6 @@ async function calculateHostPort(appConfig, options, debug) {
   return hostPort;
 }
 
-/**
- * When run --reload in dev with remote: ensure Mutagen sync session; return remote path for compose mount.
- * Uses codePath (resolved build.context) as Mutagen local path so one config field drives both local and remote.
- * When Docker endpoint, remote-server, or sync-ssh-host is localhost/127.0.0.1, returns null (no sync; use local path).
- *
- * @param {string} appName - Application name
- * @param {string} developerId - Developer ID
- * @param {boolean} debug - Debug flag
- * @param {string} codePath - Resolved build.context (absolute path to app code)
- * @param {string} [remoteSyncPath] - Optional relative path under user-mutagen-folder (from build.remoteSyncPath); when unset, defaults to dev/<appKey>
- * @returns {Promise<string|null>} Remote path for -v mount or null if not remote/reload or already on server (localhost)
- * @throws {Error} If --reload but remote not configured, or Mutagen install fails
- */
-async function ensureReloadSync(appName, developerId, debug, codePath, remoteSyncPath) {
-  const endpoint = await config.getDockerEndpoint();
-  const serverUrl = await config.getRemoteServer();
-  if (!endpoint && !serverUrl) return null;
-  const syncSshHost = await config.getSyncSshHost();
-  if (isLocalhostEndpoint(endpoint) || isLocalhostEndpoint(serverUrl) || isLocalhostHost(syncSshHost || '')) {
-    if (debug) logger.log(chalk.gray('[DEBUG] Docker/remote/sync host is localhost; skipping Mutagen, using local path'));
-    return null;
-  }
-  const [userMutagenFolder, syncSshUser] = await Promise.all([
-    config.getUserMutagenFolder(),
-    config.getSyncSshUser()
-  ]);
-  if (!userMutagenFolder || !syncSshUser || !syncSshHost) {
-    throw new Error(
-      'run --reload requires remote server sync settings. Run "aifabrix dev init" or set user-mutagen-folder, sync-ssh-user, sync-ssh-host in config.'
-    );
-  }
-  const mutagenPath = await mutagen.ensureMutagenPath(logger.log);
-  const remotePath = mutagen.getRemotePath(userMutagenFolder, appName, remoteSyncPath);
-  const sshUrl = mutagen.getSyncSshUrl(syncSshUser, syncSshHost, remotePath);
-  const sessionName = mutagen.getSessionName(developerId, appName);
-  const localPath = (codePath && typeof codePath === 'string') ? codePath : pathsUtil.getBuilderPath(appName);
-  if (debug) logger.log(chalk.gray(`[DEBUG] Mutagen sync: ${sessionName} ${localPath} <-> ${sshUrl}`));
-  logger.log(chalk.blue('Ensuring Mutagen sync session...'));
-  await mutagen.ensureSyncSession(mutagenPath, sessionName, localPath, sshUrl);
-  return remotePath;
-}
-
 /**
  * Load and configure application
  * @async
@@ -238,12 +212,21 @@ async function startAppContainer(appName, tempComposePath, hostPort, appConfig,
       devMountPath,
       misoEnvironment
     });
-    await helpers.displayRunStatus(appName, hostPort, appConfig, opts.runScopeOpts || null);
+    await helpers.displayRunStatus(
+      appName,
+      hostPort,
+      appConfig,
+      opts.runScopeOpts || null,
+      runOptions || {}
+    );
   } catch (error) {
-    logger.log(chalk.yellow(`\n⚠️  Compose file preserved at: ${tempComposePath}`));
-    logger.log(chalk.yellow('   Review the file to debug issues'));
+    logger.log('');
+    logger.log(formatWarningLine(`Compose file preserved at ${tempComposePath}`));
+    logger.log(metadata('  Review the compose file, fix the issue, then run again.'));
     if (runEnvPath || runEnvAdminPath) {
-      logger.log(chalk.yellow('   Run .env file(s) (contain secrets) were not deleted; remove them manually if desired.'));
+      logger.log(
+        metadata('  Run .env file(s) contain secrets and were not deleted; remove manually if needed.')
+      );
     }
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Error during container start: ${error.message}`));
@@ -271,30 +254,46 @@ async function resolveRunOptions(appName, appConfig, options, envKey, debug, eff
   const codePath = pathsUtil.resolveBuildContext(builderPath, appConfig.build?.context || '.');
   if (options.reload && envKey === 'dev') {
     const remoteSyncPath = appConfig.build?.remoteSyncPath;
-    const remotePath = await ensureReloadSync(appName, appConfig.developerId, debug, codePath, remoteSyncPath);
-    runOptions.devMountPath = remotePath || codePath;
+    const reloadSummary = await ensureReloadSync(appName, appConfig.developerId, debug, codePath, remoteSyncPath);
+    runOptions.reloadSyncSummary = reloadSummary;
+    runOptions.devMountPath =
+      reloadSummary.transport === 'mutagen' ? reloadSummary.remotePath : codePath;
   }
   return runOptions;
 }
 
 /**
- * Prepare run: validate app, load config, check prereqs, stop existing container, resolve port and reload, prepare env.
- * @param {string} appName - Application name
- * @param {Object} options - Run options
- * @param {boolean} debug - Debug flag
- * @returns {Promise<{ appConfig: Object, tempComposePath: string, hostPort: number }|null>} Prepared run context or null if should not continue
+ * When Traefik is enabled in user config, pass through for health checks (DNS + localhost order).
+ * @param {Object} runOptions
+ * @param {Object} userCfg
  */
-async function prepareAppRun(appName, options, debug) {
-  const envKey = (options.env || 'dev').toLowerCase();
+function applyTraefikFlagToRunOptions(runOptions, userCfg) {
+  if (userCfg && userCfg.traefik === true) {
+    runOptions.traefikEnabled = true;
+  }
+}
+
+/**
+ * @param {string} envKey
+ * @throws {Error} If env is not dev, tst, or pro
+ */
+function assertValidRunEnvKey(envKey) {
   if (envKey !== 'dev' && envKey !== 'tst' && envKey !== 'pro') {
     throw new Error('--env must be dev, tst, or pro');
   }
-  const shouldContinue = await validateAppForRun(appName, debug);
-  if (!shouldContinue) {
-    return null;
-  }
-  const appConfig = await loadAndConfigureApp(appName, debug);
-  const userCfg = await config.getConfig();
+}
+
+/**
+ * Image resolution, prereqs, port, compose env — after app config and user config are loaded.
+ * @param {string} appName
+ * @param {Object} appConfig
+ * @param {Object} options - Original run options
+ * @param {string} envKey
+ * @param {Object} userCfg - getConfig() result
+ * @param {boolean} debug
+ * @returns {Promise<Object>} Prepared run context (same shape as prepareAppRun return)
+ */
+async function computeRunPreparationCore(appName, appConfig, options, envKey, userCfg, debug) {
   const { computeEffectiveEnvironmentScopedResources } = require('../utils/environment-scoped-resources');
   const effectiveEnvironmentScopedResources = computeEffectiveEnvironmentScopedResources(
     Boolean(userCfg.useEnvironmentScopedResources),
@@ -304,17 +303,24 @@ async function prepareAppRun(appName, options, debug) {
   const runScopeOpts = effectiveEnvironmentScopedResources
     ? { effectiveEnvironmentScopedResources: true, env: envKey }
     : null;
-  await helpers.checkPrerequisites(appName, appConfig, debug, options.skipInfraCheck === true, options);
-  await checkAndStopContainer(appName, appConfig, options, debug);
-  const hostPort = await calculateHostPort(appConfig, options, debug);
+  const { resolveRunImageWithLocalFallback } = require('./run-resolve-image');
+  const resolvedRef = await resolveRunImageWithLocalFallback(appName, appConfig, options);
+  const effectiveRunOptions = {
+    ...options,
+    image: `${resolvedRef.imageName}:${resolvedRef.imageTag}`
+  };
+  await helpers.checkPrerequisites(appName, appConfig, debug, effectiveRunOptions.skipInfraCheck === true, effectiveRunOptions);
+  await checkAndStopContainer(appName, appConfig, effectiveRunOptions, debug);
+  const hostPort = await calculateHostPort(appConfig, effectiveRunOptions, debug);
   const runOptions = await resolveRunOptions(
     appName,
     appConfig,
-    options,
+    effectiveRunOptions,
     envKey,
     debug,
     effectiveEnvironmentScopedResources
   );
+  applyTraefikFlagToRunOptions(runOptions, userCfg);
   const { composePath: tempComposePath, runEnvPath, runEnvAdminPath } = await helpers.prepareEnvironment(appName, appConfig, runOptions);
   const result = {
     appConfig,
@@ -329,6 +335,28 @@ async function prepareAppRun(appName, options, debug) {
   return result;
 }
 
+/**
+ * Prepare run: validate app, load config, check prereqs, stop existing container, resolve port and reload, prepare env.
+ * @param {string} appName - Application name
+ * @param {Object} options - Run options
+ * @param {boolean} debug - Debug flag
+ * @returns {Promise<{ appConfig: Object, tempComposePath: string, hostPort: number }|null>} Prepared run context or null if should not continue
+ */
+async function prepareAppRun(appName, options, debug) {
+  const envKey = (options.env || 'dev').toLowerCase();
+  assertValidRunEnvKey(envKey);
+  const shouldContinue = await validateAppForRun(appName, debug);
+  if (!shouldContinue) {
+    return null;
+  }
+  logger.log('');
+  logger.log(sectionTitle('Run'));
+  logger.log(headerKeyValue('Application:', appName));
+  const appConfig = await loadAndConfigureApp(appName, debug);
+  const userCfg = await config.getConfig();
+  return computeRunPreparationCore(appName, appConfig, options, envKey, userCfg, debug);
+}
+
 /**
  * Runs the application locally using Docker
  * Starts container with proper port mapping and environment
@@ -360,10 +388,7 @@ async function runApp(appName, options = {}) {
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Compose file generated: ${prepared.tempComposePath}`));
     }
-    if (options.reload && prepared.devMountPath) {
-      logger.log(chalk.gray('With --reload: workspace mounted from host at /app (container runs as your user for write access).'));
-      logger.log(chalk.gray(`  Host path: ${prepared.devMountPath}`));
-    }
+    logReloadDevSummary(Boolean(options.reload), prepared.mergedRunOptions.reloadSyncSummary);
     await startAppContainer(appName, prepared.tempComposePath, prepared.hostPort, prepared.appConfig, {
       debug,
       runEnvPath: prepared.runEnvPath,
@@ -401,6 +426,7 @@ async function restartApp(appName) {
   const containerName = containerHelpers.getContainerName(appName, developerId);
   try {
     await execWithDockerEnv(`docker restart ${containerName}`);
+    await logRestartDevMountSummary(containerName);
   } catch (error) {
     const msg = (error.stderr || error.stdout || error.message || '').toLowerCase();
     if (msg.includes('no such container') || msg.includes('is not running')) {

package/lib/build/index.js

@@ -1,4 +1,13 @@
-const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+const {
+  formatSuccessLine,
+  formatSuccessParagraph,
+  formatProgress,
+  formatWarningLine,
+  sectionTitle,
+  headerKeyValue,
+  metadata,
+  formatNextActions
+} = require('../utils/cli-test-layout-chalk');
 /**
  * AI Fabrix Builder Build Functions
  *
@@ -18,7 +27,6 @@ const paths = require('../utils/paths');
 const { detectAppType, getProjectRoot } = require('../utils/paths');
 const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
 const { loadConfigFile } = require('../utils/config-format');
-const chalk = require('chalk');
 const secrets = require('../core/secrets');
 const config = require('../core/config');
 const logger = require('../utils/logger');
@@ -28,6 +36,7 @@ const buildCopy = require('../utils/build-copy');
 const { buildDevImageName } = require('../utils/image-name');
 const buildHelpers = require('../utils/build-helpers');
 const secretsEnvWrite = require('../core/secrets-env-write');
+const { ensureRunSecretsForApp } = require('../app/run-env-compose');
 
 /**
  * Loads application config for an application
@@ -192,7 +201,7 @@ async function postBuildTasks(appName, buildConfig) {
     // Note: processEnvVariables is already called by generateEnvFile to generate local .env
     // at the envOutputPath, so we don't need to manually copy the docker .env file
   } catch (error) {
-    logger.log(chalk.yellow(`⚠  Warning: Could not generate .env file: ${error.message}`));
+    logger.log(formatWarningLine(`Could not generate .env file: ${error.message}`));
   }
 }
 
@@ -205,8 +214,11 @@ async function postBuildTasks(appName, buildConfig) {
 async function checkExternalAppType(appName) {
   const variables = await loadVariablesYaml(appName);
   if (variables.app && variables.app.type === 'external') {
-    logger.log(chalk.blue(`External system: ${appName}`));
-    logger.log(chalk.gray('To regenerate deployment JSON, run: aifabrix json ' + appName));
+    logger.log('');
+    logger.log(sectionTitle('External integration'));
+    logger.log(headerKeyValue('Application:', appName));
+    logger.log(metadata('No Docker image is built for external systems.'));
+    logger.log(formatNextActions([`aifabrix json ${appName}`]));
     return true;
   }
   return false;
@@ -269,9 +281,9 @@ async function prepareDevDirectory(appName, buildConfig, options) {
   const developerId = await config.getDeveloperId();
   const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
   const directoryName = idNum === 0 ? 'applications' : `dev-${developerId}`;
-  logger.log(chalk.blue(`Copying files to developer-specific directory (${directoryName})...`));
+  logger.log(formatProgress(`Copying workspace (${directoryName})…`));
   const devDir = await buildCopy.copyBuilderToDevDirectory(appName, developerId);
-  logger.log(formatSuccessLine(`Files copied to: ${devDir}`));
+  logger.log(formatSuccessLine(`Workspace ready: ${devDir}`));
 
   const { config: appConfig, imageName } = await buildHelpers.loadAndValidateConfig(appName);
   const effectiveImageName = buildDevImageName(imageName, developerId);
@@ -297,8 +309,11 @@ function prepareBuildContext(buildConfig, devDir) {
   // Check if context is using old format (../appName) - these are incompatible with dev directory structure
   if (buildConfig.context && buildConfig.context.startsWith('../') && buildConfig.context !== '../..') {
     // Old format detected - always use devDir instead
-    logger.log(chalk.yellow(`⚠  Warning: Build context uses old format: ${buildConfig.context}`));
-    logger.log(chalk.yellow(`   Using dev directory instead: ${devDir}`));
+    logger.log(
+      formatWarningLine(
+        `Build context uses legacy path (${buildConfig.context}). Using dev workspace: ${devDir}`
+      )
+    );
     contextPath = devDir;
   } else if (buildConfig.context && buildConfig.context !== '../..') {
     // Resolve relative context path from dev directory
@@ -370,6 +385,53 @@ async function handleDockerfileGeneration(appName, params, options, buildHelpers
   }, generateDockerfile);
 }
 
+/**
+ * Resolve Docker build-args from resolved env map and merged BASH_* secrets.
+ * @param {string} appName
+ * @returns {Promise<Object.<string, string>>}
+ */
+async function resolveDockerBuildArgsForApp(appName) {
+  const envMap = await secretsEnvWrite.resolveAndGetEnvMap(appName, { environment: 'docker' });
+  const { getBashPrefixedProcessEnvOverlay } = require('../utils/bash-secret-env');
+  const bashOverlay = await getBashPrefixedProcessEnvOverlay(null, appName);
+  const buildArgs = {};
+  if (envMap.NPM_TOKEN) buildArgs.NPM_TOKEN = envMap.NPM_TOKEN;
+  if (envMap.PYPI_TOKEN) buildArgs.PYPI_TOKEN = envMap.PYPI_TOKEN;
+  for (const [k, v] of Object.entries(bashOverlay)) {
+    if (v && buildArgs[k] === undefined) buildArgs[k] = v;
+  }
+  return buildArgs;
+}
+
+/**
+ * Standard Docker build path after CLI header is printed (non-external apps).
+ * @param {string} appName
+ * @param {Object} options
+ * @returns {Promise<string>} Built image ref e.g. name:tag
+ */
+async function runStandardDockerBuild(appName, options) {
+  const { buildConfig } = await buildHelpers.loadAndValidateConfig(appName);
+  const { devDir, effectiveImageName, imageName, appConfig } = await prepareDevDirectory(appName, buildConfig, options);
+  const contextPath = prepareBuildContext(buildConfig, devDir);
+  const dockerfilePath = await handleDockerfileGeneration(appName, {
+    devDir,
+    buildConfig,
+    contextPath,
+    appConfig
+  }, options, buildHelpers);
+  await ensureRunSecretsForApp(appName);
+  const buildArgs = await resolveDockerBuildArgsForApp(appName);
+  const buildOptions = { ...options, buildArgs };
+  const tag = options.tag || 'latest';
+  if (typeof tag === 'string' && tag.includes(',')) {
+    throw new Error('Use a single image tag per build (comma-separated multiple tags are not supported).');
+  }
+  await dockerBuild.executeDockerBuildWithTag(effectiveImageName, imageName, dockerfilePath, contextPath, tag, buildOptions);
+  await postBuildTasks(appName, buildConfig);
+  logger.log(formatSuccessParagraph('Build completed successfully!'));
+  return `${effectiveImageName}:${tag}`;
+}
+
 /**
  * Builds a container image for the specified application
  * Auto-detects runtime and generates Dockerfile if needed
@@ -395,42 +457,10 @@ async function buildApp(appName, options = {}) {
   }
 
   try {
-    logger.log(chalk.blue(`\n🔨 Building application: ${appName}`));
-
-    // 1. Load and validate configuration
-    const { buildConfig } = await buildHelpers.loadAndValidateConfig(appName);
-
-    // 2. Prepare dev directory and copy files
-    const { devDir, effectiveImageName, imageName, appConfig } = await prepareDevDirectory(appName, buildConfig, options);
-
-    // 3. Prepare build context
-    const contextPath = prepareBuildContext(buildConfig, devDir);
-
-    // 4. Handle Dockerfile generation
-    const dockerfilePath = await handleDockerfileGeneration(appName, {
-      devDir,
-      buildConfig,
-      contextPath,
-      appConfig
-    }, options, buildHelpers);
-
-    // 5. Resolve NPM_TOKEN/PYPI_TOKEN for private registries and pass as build-args
-    const envMap = await secretsEnvWrite.resolveAndGetEnvMap(appName, { environment: 'docker' });
-    const buildArgs = {};
-    if (envMap.NPM_TOKEN) buildArgs.NPM_TOKEN = envMap.NPM_TOKEN;
-    if (envMap.PYPI_TOKEN) buildArgs.PYPI_TOKEN = envMap.PYPI_TOKEN;
-    const buildOptions = { ...options, buildArgs };
-
-    // 6. Execute Docker build
-    const tag = options.tag || 'latest';
-    await dockerBuild.executeDockerBuildWithTag(effectiveImageName, imageName, dockerfilePath, contextPath, tag, buildOptions);
-
-    // 7. Post-build tasks
-    await postBuildTasks(appName, buildConfig);
-
-    logger.log(formatSuccessParagraph('Build completed successfully!'));
-    return `${imageName}:${tag}`;
-
+    logger.log('');
+    logger.log(sectionTitle('Build'));
+    logger.log(headerKeyValue('Application:', appName));
+    return await runStandardDockerBuild(appName, options);
   } catch (error) {
     throw new Error(`Build failed: ${error.message}`);
   }

package/lib/cli/doctor-check.js

@@ -0,0 +1,117 @@
+/**
+ * @fileoverview `aifabrix doctor` action: environment validation + optional infra health.
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const {
+  sectionTitle,
+  formatBulletSection,
+  formatDatasourceListRow,
+  formatWarningLine,
+  metadata
+} = require('../utils/cli-test-layout-chalk');
+const validator = require('../validation/validator');
+const config = require('../core/config');
+const infra = require('../infrastructure');
+const logger = require('../utils/logger');
+
+/**
+ * @param {string} label
+ * @param {'ok'|'warning'|'fail'} variant
+ * @param {{ ok?: string, warn?: string, fail?: string }} text
+ * @returns {string}
+ */
+function formatDoctorEnvSummaryLine(label, variant, text) {
+  const base = chalk.gray(`${label}:`);
+  if (variant === 'ok') return `${base} ${chalk.green('✔')} ${chalk.white(text.ok || '')}`;
+  if (variant === 'warning') return `${base} ${chalk.yellow('⚠')} ${chalk.white(text.warn || '')}`;
+  return `${base} ${chalk.red('✖')} ${chalk.white(text.fail || '')}`;
+}
+
+/**
+ * @param {string} statusRaw
+ * @returns {'ok'|'warn'|'fail'}
+ */
+function doctorInfraRowAggregate(statusRaw) {
+  const s = String(statusRaw).trim().toLowerCase();
+  if (s === 'healthy') return 'ok';
+  if (s === 'unknown') return 'warn';
+  return 'fail';
+}
+
+/**
+ * @param {Object} result - `validator.checkEnvironment()` payload
+ */
+function logDoctorEnvironmentSection(result) {
+  logger.log('');
+  logger.log(sectionTitle('Environment check'));
+  logger.log('');
+  logger.log(
+    formatDoctorEnvSummaryLine(
+      'Docker',
+      result.docker === 'ok' ? 'ok' : 'fail',
+      { ok: 'Running', fail: 'Not available' }
+    )
+  );
+  logger.log(
+    formatDoctorEnvSummaryLine(
+      'Ports',
+      result.ports === 'ok' ? 'ok' : 'warning',
+      { ok: 'Available', warn: 'Some ports in use' }
+    )
+  );
+  logger.log(
+    formatDoctorEnvSummaryLine(
+      'Secrets',
+      result.secrets === 'ok' ? 'ok' : 'fail',
+      { ok: 'Configured', fail: 'Missing' }
+    )
+  );
+  if (result.recommendations.length > 0) {
+    logger.log('');
+    logger.log(formatBulletSection('Recommendations:', result.recommendations));
+  }
+}
+
+/**
+ * @param {Object} result - `validator.checkEnvironment()` payload
+ */
+async function logDoctorInfraHealthSection(result) {
+  if (result.docker !== 'ok') {
+    logger.log('');
+    logger.log(metadata('Infrastructure health skipped (Docker not available).'));
+    return;
+  }
+  try {
+    const cfg = await config.getConfig();
+    const health = await infra.checkInfraHealth(null, {
+      pgadmin: cfg.pgadmin !== false,
+      redisCommander: cfg.redisCommander !== false,
+      traefik: !!cfg.traefik
+    });
+    logger.log('');
+    logger.log(sectionTitle('Infrastructure health'));
+    Object.entries(health).forEach(([service, status]) => {
+      const agg = doctorInfraRowAggregate(status);
+      logger.log(formatDatasourceListRow(agg, `${service}: ${status}`, null));
+    });
+  } catch (_err) {
+    logger.log('');
+    logger.log(formatWarningLine('Infrastructure is not running or health could not be read.'));
+  }
+}
+
+/**
+ * Runs the doctor checks and prints the TTY summary.
+ * @returns {Promise<void>}
+ */
+async function runDoctorCheck() {
+  const result = await validator.checkEnvironment();
+  logDoctorEnvironmentSection(result);
+  await logDoctorInfraHealthSection(result);
+  logger.log('');
+}
+
+module.exports = { runDoctorCheck };

package/lib/cli/index.js

@@ -21,8 +21,11 @@ const { setupParametersCommands } = require('./setup-parameters');
 const { setupExternalSystemCommands } = require('./setup-external-system');
 const { setupAppCommands: setupAppManagementCommands } = require('../commands/app');
 const { setupDatasourceCommands } = require('../commands/datasource');
+const { setupDimensionCommands } = require('../commands/dimension');
+const { setupDimensionValueCommands } = require('../commands/dimension-value');
 const { setupCredentialDeploymentCommands } = require('./setup-credential-deployment');
-const { setupServiceUserCommands } = require('./setup-service-user');
+const { setupIntegrationClientCommands } = require('./setup-integration-client');
+const { setupPlatformCommands } = require('./setup-platform');
 
 /**
  * Sets up all CLI commands on the Commander program instance
@@ -35,13 +38,16 @@ function setupCommands(program) {
   setupEnvironmentCommands(program);
   setupAppManagementCommands(program);
   setupDatasourceCommands(program);
+  setupDimensionCommands(program);
+  setupDimensionValueCommands(program);
   setupUtilityCommands(program);
   setupCredentialDeploymentCommands(program);
-  setupServiceUserCommands(program);
+  setupIntegrationClientCommands(program);
   setupExternalSystemCommands(program);
   setupDevCommands(program);
   setupSecretsCommands(program);
   setupParametersCommands(program);
+  setupPlatformCommands(program);
 }
 
 module.exports = {