@aifabrix/builder 2.40.2 → 2.42.0

package/lib/cli/setup-dev.js

@@ -1,5 +1,5 @@
 /**
- * CLI developer configuration command setup (dev config, dev set-id).
+ * CLI developer configuration command setup (dev config, dev set-id, dev init, dev add/update/pin/delete/list).
  *
  * @fileoverview Developer command definitions for AI Fabrix Builder CLI
  * @author AI Fabrix Team
@@ -11,20 +11,38 @@ const config = require('../core/config');
 const devConfig = require('../utils/dev-config');
 const logger = require('../utils/logger');
 const { handleCommandError } = require('../utils/cli-utils');
+const { runDevInit, runDevRefresh } = require('../commands/dev-init');
+const {
+  handleDevList,
+  handleDevAdd,
+  handleDevUpdate,
+  handleDevPin,
+  handleDevDelete
+} = require('../commands/dev-cli-handlers');
 
 /**
- * Display developer configuration
+ * Display developer configuration (local ports and config; remote/settings keys always shown).
+ * Always shows environment, controller, and remote keys (value or "(not set)").
  * @param {string} devId - Developer ID
  * @returns {Promise<void>}
  */
 async function displayDevConfig(devId) {
   const devIdNum = parseInt(devId, 10);
   const ports = devConfig.getDevPorts(devIdNum);
-  const configVars = [
+  const environment = await config.getCurrentEnvironment();
+  const controller = await config.getControllerUrl();
+
+  const optionalConfigVars = [
+    { key: 'format', value: (await config.getFormat()) ?? '(not set)' },
     { key: 'aifabrix-home', value: await config.getAifabrixHomeOverride() },
     { key: 'aifabrix-secrets', value: await config.getAifabrixSecretsPath() },
-    { key: 'aifabrix-env-config', value: await config.getAifabrixEnvConfigPath() }
-  ].filter(v => v.value);
+    { key: 'aifabrix-env-config', value: await config.getAifabrixEnvConfigPath() },
+    { key: 'remote-server', value: await config.getRemoteServer() },
+    { key: 'docker-endpoint', value: await config.getDockerEndpoint() },
+    { key: 'user-mutagen-folder', value: await config.getUserMutagenFolder() },
+    { key: 'sync-ssh-user', value: await config.getSyncSshUser() },
+    { key: 'sync-ssh-host', value: await config.getSyncSshHost() }
+  ];
 
   logger.log('\n🔧 Developer Configuration\n');
   logger.log(`Developer ID: ${devId}`);
@@ -35,22 +53,30 @@ async function displayDevConfig(devId) {
   logger.log(`  pgAdmin: ${ports.pgadmin}`);
   logger.log(`  Redis Commander: ${ports.redisCommander}`);
 
-  if (configVars.length > 0) {
-    logger.log('\nConfiguration:');
-    configVars.forEach(v => logger.log(`  ${v.key}: ${v.value}`));
-  }
+  logger.log('\nConfiguration:');
+  logger.log(`  environment: '${environment}'`);
+  logger.log(controller ? `  controller: '${controller}'` : '  controller: (not set)');
+  optionalConfigVars.forEach(v => logger.log(`  ${v.key}: ${v.value || '(not set)'}`));
   logger.log('');
 }
 
 /**
- * Sets up developer configuration commands
- * @param {Command} program - Commander program instance
+ * Handle dev set-format command
+ * @param {string} format - Format value (json | yaml)
+ * @returns {Promise<void>}
  */
-function setupDevCommands(program) {
-  const dev = program
-    .command('dev')
-    .description('Developer configuration and isolation');
+async function handleSetFormat(format) {
+  await config.setFormat(format);
+  logger.log(chalk.green(`✓ Format set to ${format.toLowerCase()}`));
+  const devId = await config.getDeveloperId();
+  await displayDevConfig(devId);
+}
 
+/**
+ * Register dev config and set-id commands.
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevConfigCommands(dev) {
   dev
     .command('config')
     .description('Show or set developer configuration')
@@ -69,7 +95,6 @@ function setupDevCommands(program) {
           await displayDevConfig(setIdValue);
           return;
         }
-
         const devId = await config.getDeveloperId();
         await displayDevConfig(devId);
       } catch (error) {
@@ -78,6 +103,18 @@ function setupDevCommands(program) {
       }
     });
 
+  dev
+    .command('set-format <format>')
+    .description('Set default output format for download/convert (json | yaml); used when --format not passed')
+    .action(async(format) => {
+      try {
+        await handleSetFormat(format);
+      } catch (error) {
+        handleCommandError(error, 'dev set-format');
+        process.exit(1);
+      }
+    });
+
   dev
     .command('set-id <id>')
     .description('Set developer ID (convenience alias for "dev config --set-id")')
@@ -98,4 +135,157 @@ function setupDevCommands(program) {
     });
 }
 
+/**
+ * Register dev init and refresh commands.
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevInitCommand(dev) {
+  dev
+    .command('init')
+    .description('Onboard with Builder Server (issue certificate, fetch settings, register SSH key for Mutagen)')
+    .requiredOption('--developer-id <id>', 'Developer ID (same as dev add; e.g. 01)')
+    .requiredOption('--server <url>', 'Builder Server base URL (e.g. https://dev.aifabrix.dev)')
+    .requiredOption('--pin <pin>', 'One-time PIN from your admin')
+    .option('-y, --yes', 'Auto-install development CA without prompt when certificate is untrusted')
+    .option('--no-install-ca', 'Do not offer CA install; fail with manual instructions on untrusted certificate')
+    .action(async(options) => {
+      try {
+        await runDevInit(options);
+      } catch (error) {
+        handleCommandError(error, 'dev init');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('refresh')
+    .description('Fetch settings from Builder Server and update config; refresh certificate if expiring within 14 days or --cert')
+    .option('--cert', 'Force certificate refresh (create PIN + issue-cert) even when cert is still valid')
+    .action(async(options) => {
+      try {
+        await runDevRefresh(options);
+      } catch (error) {
+        handleCommandError(error, 'dev refresh');
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Register dev list and add commands (remote only).
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevListAddCommands(dev) {
+  dev
+    .command('list')
+    .description('List developer users (remote Builder Server only)')
+    .action(async() => {
+      try {
+        await handleDevList();
+      } catch (error) {
+        handleCommandError(error, 'dev list');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('add')
+    .description('Register a new developer (remote Builder Server only; admin)')
+    .requiredOption('--developer-id <id>', 'Developer ID (unique, e.g. 01)')
+    .requiredOption('--name <name>', 'Display name')
+    .requiredOption('--email <email>', 'Email address')
+    .option('--groups <items>', 'Comma-separated groups (admin, secret-manager, developer)', 'developer')
+    .action(async(options) => {
+      try {
+        await handleDevAdd(options);
+      } catch (error) {
+        handleCommandError(error, 'dev add');
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Register dev update/pin/delete commands (remote only).
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevUpdatePinDeleteCommands(dev) {
+  dev
+    .command('update [developerId]')
+    .description('Update a developer (name, email, groups); use --developer-id like dev add')
+    .option('--developer-id <id>', 'Developer ID (same as dev add)')
+    .option('--name <name>', 'Display name')
+    .option('--email <email>', 'Email address')
+    .option('--groups <items>', 'Comma-separated groups (admin, secret-manager, developer)')
+    .action(async(developerId, options) => {
+      try {
+        await handleDevUpdate(developerId, options);
+      } catch (error) {
+        handleCommandError(error, 'dev update');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('pin [developerId]')
+    .description('Create or regenerate one-time PIN for onboarding (admin; show once to developer)')
+    .action(async(developerId) => {
+      try {
+        await handleDevPin(developerId);
+      } catch (error) {
+        handleCommandError(error, 'dev pin');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('delete <developerId>')
+    .description('Remove a developer (remote Builder Server only; admin)')
+    .action(async(developerId) => {
+      try {
+        await handleDevDelete(developerId);
+      } catch (error) {
+        handleCommandError(error, 'dev delete');
+        process.exit(1);
+      }
+    });
+
+  dev
+    .command('down')
+    .description('Stop Mutagen sync sessions for this developer (and optionally app containers)')
+    .option('--apps', 'Also stop running app containers for this developer')
+    .action(async(options) => {
+      try {
+        const { handleDevDown } = require('../commands/dev-down');
+        await handleDevDown(options);
+      } catch (error) {
+        handleCommandError(error, 'dev down');
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * Register dev list/add/update/pin/delete commands (remote only).
+ * @param {Command} dev - dev subcommand group
+ */
+function setupDevUserCommands(dev) {
+  setupDevListAddCommands(dev);
+  setupDevUpdatePinDeleteCommands(dev);
+}
+
+/**
+ * Sets up developer configuration commands
+ * @param {Command} program - Commander program instance
+ */
+function setupDevCommands(program) {
+  const dev = program
+    .command('dev')
+    .description('Developer configuration and isolation');
+
+  setupDevConfigCommands(dev);
+  setupDevInitCommand(dev);
+  setupDevUserCommands(dev);
+}
+
 module.exports = { setupDevCommands };

package/lib/cli/setup-environment.js

@@ -25,28 +25,38 @@ function setupEnvironmentCommands(program) {
 
   const environment = program
     .command('environment')
-    .description('Manage environments');
+    .description('Deploy and manage Miso Controller environments (dev, tst, pro, miso)');
+
+  const deployExamples = `
+Examples:
+  $ aifabrix environment deploy dev
+  $ aifabrix environment deploy tst --preset m
+  $ aifabrix environment deploy dev --config ./env-config.json --no-poll`;
 
   environment
     .command('deploy <env>')
-    .description('Deploy/setup environment in Miso Controller')
-    .option('--config <file>', 'Environment configuration file')
+    .description('Deploy environment infrastructure in Miso Controller (run before deploy <app>)')
+    .option('--config <file>', 'Environment configuration file (optional if --preset is used)')
+    .option('--preset <size>', 'Environment size preset: s, m, l, xl (default: s)', 's')
     .option('--skip-validation', 'Skip environment validation')
     .option('--poll', 'Poll for deployment status', true)
     .option('--no-poll', 'Do not poll for status')
+    .addHelpText('after', deployExamples)
     .action(deployEnvHandler);
 
   const env = program
     .command('env')
-    .description('Environment management (alias for environment)');
+    .description('Deploy and manage Miso Controller environments (alias for environment)');
 
   env
     .command('deploy <env>')
-    .description('Deploy/setup environment in Miso Controller')
-    .option('--config <file>', 'Environment configuration file')
+    .description('Deploy environment infrastructure in Miso Controller (run before deploy <app>)')
+    .option('--config <file>', 'Environment configuration file (optional if --preset is used)')
+    .option('--preset <size>', 'Environment size preset: s, m, l, xl (default: s)', 's')
     .option('--skip-validation', 'Skip environment validation')
     .option('--poll', 'Poll for deployment status', true)
     .option('--no-poll', 'Do not poll for status')
+    .addHelpText('after', deployExamples)
     .action(deployEnvHandler);
 }
 

package/lib/cli/setup-external-system.js

@@ -1,9 +1,17 @@
 /**
- * CLI external system command setup (download, delete, test, test-integration).
+ * CLI external system command setup (download, upload, delete, test-integration).
+ *
+ * Registers these commands on the Commander program:
+ * - download <system-key> – Download external system from dataplane to integration/<system-key>/
+ * - upload <system-key> – Upload to dataplane (validate → publish; no controller deploy)
+ * - delete <system-key> – Delete external system and associated datasources from dataplane
+ * - test-integration <app> – Run integration tests (builder: in container; external: via dataplane pipeline)
  *
  * @fileoverview External system command definitions for AI Fabrix Builder CLI
  * @author AI Fabrix Team
  * @version 2.0.0
+ * @see docs/commands/external-integration.md - User-facing command reference
+ * @see docs/external-systems.md - External systems guide and workflow
  */
 
 const { handleCommandError } = require('../utils/cli-utils');
@@ -11,11 +19,18 @@ const { handleCommandError } = require('../utils/cli-utils');
 function setupDownloadCommand(program) {
   program.command('download <system-key>')
     .description('Download external system from dataplane to local development structure')
+    .option('--format <format>', 'Output format: json | yaml (default: yaml or config format)')
     .option('--dry-run', 'Show what would be downloaded without actually downloading')
+    .option('--force', 'Overwrite existing README.md without prompting')
     .action(async(systemKey, options) => {
       try {
+        const config = require('../core/config');
+        const effectiveFormat = (options.format || (await config.getFormat()) || 'yaml').trim().toLowerCase();
+        if (effectiveFormat !== 'json' && effectiveFormat !== 'yaml') {
+          throw new Error('Option --format must be \'json\' or \'yaml\'');
+        }
         const download = require('../external-system/download');
-        await download.downloadExternalSystem(systemKey, options);
+        await download.downloadExternalSystem(systemKey, { ...options, format: effectiveFormat });
       } catch (error) {
         handleCommandError(error, 'download');
         process.exit(1);
@@ -27,7 +42,6 @@ function setupUploadCommand(program) {
   program.command('upload <system-key>')
     .description('Upload external system to dataplane (upload → validate → publish; no controller deploy)')
     .option('--dry-run', 'Validate and build payload only; no API calls')
-    .option('--dataplane <url>', 'Dataplane URL (default: discovered from controller)')
     .action(async(systemKey, options) => {
       try {
         const upload = require('../commands/upload');
@@ -56,35 +70,86 @@ function setupDeleteCommand(program) {
     });
 }
 
+/**
+ * Try to run builder-style test integration when app is not in builder or has no externalIntegration.
+ * @param {string} appName - App or system key
+ * @param {Object} options - CLI options
+ * @returns {Promise<boolean>} True if builder test was run, false otherwise
+ */
+async function tryBuilderTestIntegration(appName, options) {
+  const fsSync = require('fs');
+  const pathsUtil = require('../utils/paths');
+  const { getIntegrationPath, getBuilderPath } = pathsUtil;
+  const { resolveApplicationConfigPath } = require('../utils/app-config-resolver');
+  const { loadConfigFile } = require('../utils/config-format');
+  const integrationPath = getIntegrationPath(appName);
+  let hasExternalIntegration = false;
+  try {
+    const integrationConfig = loadConfigFile(resolveApplicationConfigPath(integrationPath));
+    hasExternalIntegration = !!(integrationConfig && integrationConfig.externalIntegration);
+  } catch {
+    // integration path or config missing
+  }
+  if (!hasExternalIntegration) {
+    const builderPath = getBuilderPath(appName);
+    const builderConfigPath = resolveApplicationConfigPath(builderPath);
+    if (fsSync.existsSync(builderPath) && fsSync.existsSync(builderConfigPath)) {
+      const { runAppTestIntegration } = require('../commands/app-test');
+      const opts = { env: options.env || options.environment || 'dev' };
+      await runAppTestIntegration(appName, opts);
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Run external system integration test via dataplane and exit on failure.
+ * @param {string} appName - App or system key
+ * @param {Object} options - CLI options
+ * @returns {Promise<void>}
+ */
+async function runExternalSystemTestIntegration(appName, options) {
+  const test = require('../external-system/test');
+  const opts = { ...options, environment: options.env || options.environment, debug: options.debug };
+  const results = await test.testExternalSystemIntegration(appName, opts);
+  test.displayIntegrationTestResults(results, options.verbose);
+  if (!results.success) process.exit(1);
+}
+
+/**
+ * Run test-integration command: builder app in container or external system via dataplane.
+ * @param {string} appName - App or system key
+ * @param {Object} options - CLI options (datasource, payload, env, verbose, timeout)
+ * @returns {Promise<void>}
+ */
+async function runTestIntegrationCommand(appName, options) {
+  const pathsUtil = require('../utils/paths');
+  const appType = await pathsUtil.detectAppType(appName).catch(() => null);
+  if (appType && appType.baseDir === 'builder') {
+    const { runAppTestIntegration } = require('../commands/app-test');
+    const opts = { env: options.env || options.environment || 'dev' };
+    await runAppTestIntegration(appName, opts);
+    return;
+  }
+  const ranBuilder = await tryBuilderTestIntegration(appName, options);
+  if (ranBuilder) return;
+  await runExternalSystemTestIntegration(appName, options);
+}
+
 function setupExternalSystemTestCommands(program) {
-  program.command('test <app>')
-    .description('Run unit tests for external system (local validation, no API calls)')
-    .option('-d, --datasource <key>', 'Test specific datasource only')
-    .option('-v, --verbose', 'Show detailed validation output')
-    .action(async(appName, options) => {
-      try {
-        const test = require('../external-system/test');
-        const results = await test.testExternalSystem(appName, options);
-        test.displayTestResults(results, options.verbose);
-        if (!results.valid) process.exit(1);
-      } catch (error) {
-        handleCommandError(error, 'test');
-        process.exit(1);
-      }
-    });
+  // 'test <app>' is registered in setup-app.js and dispatches by app type (builder vs external)
   program.command('test-integration <app>')
-    .description('Run integration tests via dataplane pipeline API')
+    .description('Run integration tests (builder/docker app: in container; external system: via dataplane pipeline API)')
     .option('-d, --datasource <key>', 'Test specific datasource only')
     .option('-p, --payload <file>', 'Path to custom test payload file')
-    .option('--dataplane <url>', 'Dataplane URL (default: discovered from controller)')
+    .option('-e, --env <env>', 'Environment: dev, tst, or pro (default: from aifabrix auth config)')
     .option('-v, --verbose', 'Show detailed test output')
+    .option('--debug', 'Include debug output and write log to integration/<app>/logs/')
     .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
     .action(async(appName, options) => {
       try {
-        const test = require('../external-system/test');
-        const results = await test.testExternalSystemIntegration(appName, options);
-        test.displayIntegrationTestResults(results, options.verbose);
-        if (!results.success) process.exit(1);
+        await runTestIntegrationCommand(appName, options);
       } catch (error) {
         handleCommandError(error, 'test-integration');
         process.exit(1);

package/lib/cli/setup-infra.js

@@ -12,13 +12,41 @@ const appLib = require('../app');
 const validator = require('../validation/validator');
 const config = require('../core/config');
 const logger = require('../utils/logger');
-const { handleCommandError } = require('../utils/cli-utils');
+const { handleCommandError, isAuthenticationError } = require('../utils/cli-utils');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { handleLogin } = require('../commands/login');
 const { handleUpMiso } = require('../commands/up-miso');
 const { handleUpDataplane } = require('../commands/up-dataplane');
 
 /**
- * Runs the up-infra command: resolves developer ID, traefik, and starts infra.
- * @param {Object} options - Commander options (developer, traefik)
+ * Persists optional service flag to config when explicitly set.
+ * @param {Object} cfg - Config object (mutated)
+ * @param {string} key - Config key (traefik, pgadmin, redisCommander)
+ * @param {boolean} value - Value to set
+ * @param {string} label - Label for log message
+ */
+async function persistOptionalServiceFlag(cfg, key, value, label) {
+  cfg[key] = value;
+  await config.saveConfig(cfg);
+  logger.log(chalk.green(`✓ ${label} ${value ? 'enabled' : 'disabled'} and saved to config`));
+}
+
+/**
+ * Resolves effective boolean from option vs config.
+ * @param {*} optValue - options.traefik | options.pgAdmin | options.redisAdmin
+ * @param {*} cfgValue - cfg.traefik | cfg.pgadmin | cfg.redisCommander
+ * @param {boolean} defaultWhenUndef - Default when config value is undefined
+ * @returns {boolean}
+ */
+function resolveFlag(optValue, cfgValue, defaultWhenUndef = true) {
+  if (optValue === true) return true;
+  if (optValue === false) return false;
+  return cfgValue !== false && (cfgValue === true || defaultWhenUndef);
+}
+
+/**
+ * Runs the up-infra command: resolves developer ID, traefik, pgAdmin, redisAdmin, and starts infra.
+ * @param {Object} options - Commander options (developer, traefik, pgAdmin, redisAdmin)
  * @returns {Promise<void>}
  */
 async function runUpInfraCommand(options) {
@@ -35,23 +63,33 @@ async function runUpInfraCommand(options) {
     logger.log(chalk.green(`✓ Developer ID set to ${id}`));
   }
   const cfg = await config.getConfig();
-  if (options.traefik === true) {
-    cfg.traefik = true;
-    await config.saveConfig(cfg);
-    logger.log(chalk.green('✓ Traefik enabled and saved to config'));
-  } else if (options.traefik === false) {
-    cfg.traefik = false;
-    await config.saveConfig(cfg);
-    logger.log(chalk.green('✓ Traefik disabled and saved to config'));
+  const flagSpecs = [
+    { opt: options.traefik, key: 'traefik', label: 'Traefik' },
+    { opt: options.pgAdmin, key: 'pgadmin', label: 'pgAdmin' },
+    { opt: options.redisAdmin, key: 'redisCommander', label: 'Redis Commander' }
+  ];
+  for (const { opt, key, label } of flagSpecs) {
+    if (opt === true || opt === false) {
+      await persistOptionalServiceFlag(cfg, key, opt, label);
+    }
   }
-  const useTraefik = options.traefik === true ? true : (options.traefik === false ? false : !!(cfg.traefik));
-  await infra.startInfra(developerId, { traefik: useTraefik });
+  await infra.startInfra(developerId, {
+    traefik: resolveFlag(options.traefik, cfg.traefik, false),
+    pgadmin: resolveFlag(options.pgAdmin, cfg.pgadmin, true),
+    redisCommander: resolveFlag(options.redisAdmin, cfg.redisCommander, true),
+    adminPwd: options.adminPwd
+  });
 }
 
 function setupUpInfraCommand(program) {
   program.command('up-infra')
-    .description('Start local infrastructure: Postgres, Redis, optional Traefik')
+    .description('Start local infrastructure: Postgres, Redis, optional pgAdmin, Redis Commander, Traefik')
     .option('-d, --developer <id>', 'Set developer ID and start infrastructure')
+    .option('--adminPwd <password>', 'Override default admin password for new install (Postgres, pgAdmin, Redis Commander)')
+    .option('--pgAdmin', 'Include pgAdmin web UI and save to config')
+    .option('--no-pgAdmin', 'Exclude pgAdmin and save to config')
+    .option('--redisAdmin', 'Include Redis Commander web UI and save to config')
+    .option('--no-redisAdmin', 'Exclude Redis Commander and save to config')
     .option('--traefik', 'Include Traefik reverse proxy and save to config')
     .option('--no-traefik', 'Exclude Traefik and save to config')
     .action(async(options) => {
@@ -75,6 +113,18 @@ function setupUpPlatformCommand(program) {
         await handleUpMiso(options);
         await handleUpDataplane(options);
       } catch (error) {
+        if (isAuthenticationError(error)) {
+          const controllerUrl = error.controllerUrl || await resolveControllerUrl();
+          logger.log(chalk.blue('\nAuthentication required. Running aifabrix login...\n'));
+          try {
+            await handleLogin({ method: 'device', controller: controllerUrl });
+            await handleUpDataplane(options);
+            return;
+          } catch (loginOrRetryError) {
+            handleCommandError(loginOrRetryError, 'up-platform');
+            process.exit(1);
+          }
+        }
         handleCommandError(error, 'up-platform');
         process.exit(1);
       }
@@ -107,6 +157,18 @@ function setupUpDataplaneCommand(program) {
       try {
         await handleUpDataplane(options);
       } catch (error) {
+        if (isAuthenticationError(error)) {
+          const controllerUrl = error.controllerUrl || await resolveControllerUrl();
+          logger.log(chalk.blue('\nAuthentication required. Running aifabrix login...\n'));
+          try {
+            await handleLogin({ method: 'device', controller: controllerUrl });
+            await handleUpDataplane(options);
+            return;
+          } catch (loginOrRetryError) {
+            handleCommandError(loginOrRetryError, 'up-dataplane');
+            process.exit(1);
+          }
+        }
         handleCommandError(error, 'up-dataplane');
         process.exit(1);
       }
@@ -148,7 +210,12 @@ function setupDoctorCommand(program) {
         }
         if (result.docker === 'ok') {
           try {
-            const health = await infra.checkInfraHealth();
+            const cfg = await config.getConfig();
+            const health = await infra.checkInfraHealth(null, {
+              pgadmin: cfg.pgadmin !== false,
+              redisCommander: cfg.redisCommander !== false,
+              traefik: !!cfg.traefik
+            });
             logger.log('\n🏥 Infrastructure Health:');
             Object.entries(health).forEach(([service, status]) => {
               const icon = status === 'healthy' ? '✅' : status === 'unknown' ? '❓' : '❌';