@aifabrix/builder 2.44.6 → 2.45.0

package/lib/cli/setup-infra-up-dataplane-action.js

@@ -0,0 +1,111 @@
+/**
+ * `aifabrix up-dataplane` action body (keeps setup-infra.js under size limits).
+ *
+ * @fileoverview up-dataplane CLI action
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { formatProgress } = require('../utils/cli-test-layout-chalk');
+const { handleCommandError, isAuthenticationError } = require('../utils/cli-utils');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { handleLogin } = require('../commands/login');
+const { handleUpDataplane } = require('../commands/up-dataplane');
+const { cleanBuilderAppDirs } = require('../commands/up-common');
+const { runGuidedUpDataplane } = require('./infra-guided');
+const { recordInfraInstallationCommand } = require('./installation-log-command');
+
+/**
+ * @param {Object} options
+ * @returns {Promise<string[]>}
+ */
+async function runUpDataplaneWork(options) {
+  let cleanedAppKeys = [];
+  if (options.force) {
+    const c = await cleanBuilderAppDirs(['dataplane']);
+    cleanedAppKeys = Array.isArray(c) ? c : [];
+  }
+  if (!options.verbose) {
+    await runGuidedUpDataplane(options, handleUpDataplane);
+  } else {
+    await handleUpDataplane(options);
+  }
+  return cleanedAppKeys;
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<void>}
+ */
+async function logDataplaneOutcome(params) {
+  const { options, startedAt, outcome, error, cleanedAppKeys } = params;
+  await recordInfraInstallationCommand({
+    command: 'up-dataplane',
+    options,
+    startedAt,
+    outcome,
+    error,
+    platformAppList: ['dataplane'],
+    cleanup: cleanedAppKeys.length > 0 ? { cleanedAppKeys } : undefined
+  });
+}
+
+/**
+ * @param {Object} options
+ * @param {Date} startedAt
+ * @param {string[]} cleanedAppKeys
+ * @param {string} controllerUrl
+ * @returns {Promise<void>}
+ */
+async function runDataplaneAuthRecovery(options, startedAt, cleanedAppKeys, controllerUrl) {
+  if (!options.verbose) {
+    logger.log(formatProgress('Authenticating...'));
+  } else {
+    logger.log(chalk.blue('\nAuthentication required. Running aifabrix login...\n'));
+  }
+  await handleLogin({ method: 'device', controller: controllerUrl, compact: !options.verbose });
+  await handleUpDataplane(options);
+  await logDataplaneOutcome({ options, startedAt, outcome: 'success', cleanedAppKeys });
+}
+
+/**
+ * @param {Object} options
+ * @returns {Promise<void>}
+ */
+async function handleUpDataplaneCliAction(options) {
+  const startedAt = new Date();
+  let cleanedAppKeys = [];
+  try {
+    cleanedAppKeys = await runUpDataplaneWork(options);
+    await logDataplaneOutcome({ options, startedAt, outcome: 'success', cleanedAppKeys });
+  } catch (error) {
+    if (isAuthenticationError(error)) {
+      const controllerUrl = error.controllerUrl || await resolveControllerUrl();
+      try {
+        await runDataplaneAuthRecovery(options, startedAt, cleanedAppKeys, controllerUrl);
+        return;
+      } catch (loginOrRetryError) {
+        await logDataplaneOutcome({
+          options,
+          startedAt,
+          outcome: 'failure',
+          error: loginOrRetryError,
+          cleanedAppKeys
+        });
+        handleCommandError(loginOrRetryError, 'up-dataplane');
+        process.exit(1);
+      }
+    }
+    await logDataplaneOutcome({ options, startedAt, outcome: 'failure', error, cleanedAppKeys });
+    handleCommandError(error, 'up-dataplane');
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  handleUpDataplaneCliAction
+};

package/lib/cli/setup-infra-up-platform-action.js

@@ -0,0 +1,131 @@
+/**
+ * `aifabrix up-platform` action body (keeps setup-infra.js under size limits).
+ *
+ * @fileoverview up-platform CLI action
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { formatProgress } = require('../utils/cli-test-layout-chalk');
+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');
+const {
+  applyUpPlatformForceConfig,
+  cleanBuilderAppDirs,
+  prepareUrlsLocalRegistryForUpPlatform
+} = require('../commands/up-common');
+const { runGuidedUpPlatform } = require('./infra-guided');
+const { recordInfraInstallationCommand } = require('./installation-log-command');
+
+const PLATFORM_APPS = ['keycloak', 'miso-controller', 'dataplane'];
+
+/**
+ * @param {Object} options
+ * @returns {Promise<string[]>}
+ */
+async function runUpPlatformWork(options) {
+  let cleanedAppKeys = [];
+  let platformForceCleanSummary = null;
+  if (options.force) {
+    const forceSummary = await applyUpPlatformForceConfig({ silent: !options.verbose });
+    const cleanedApps = await cleanBuilderAppDirs(PLATFORM_APPS, {
+      silent: !options.verbose
+    });
+    cleanedAppKeys = Array.isArray(cleanedApps) ? cleanedApps : [];
+    if (!options.verbose) {
+      platformForceCleanSummary = { forceSummary, cleanedApps: cleanedAppKeys };
+    }
+  }
+
+  if (!options.verbose) {
+    await runGuidedUpPlatform(
+      options,
+      handleUpMiso,
+      handleUpDataplane,
+      handleLogin,
+      platformForceCleanSummary
+    );
+  } else {
+    await prepareUrlsLocalRegistryForUpPlatform();
+    await handleUpMiso(options);
+    await handleUpDataplane(options);
+  }
+  return cleanedAppKeys;
+}
+
+/**
+ * @param {Object} params
+ * @returns {Promise<void>}
+ */
+async function logUpPlatformOutcome(params) {
+  const { options, startedAt, outcome, error, cleanedAppKeys } = params;
+  await recordInfraInstallationCommand({
+    command: 'up-platform',
+    options,
+    startedAt,
+    outcome,
+    error,
+    platformAppList: PLATFORM_APPS,
+    cleanup: cleanedAppKeys.length > 0 ? { cleanedAppKeys } : undefined,
+    upPlatformForce: options.force === true
+  });
+}
+
+async function maybeHandleUpPlatformAuthRetry(error, options) {
+  if (!isAuthenticationError(error)) {
+    return false;
+  }
+  const controllerUrl = error.controllerUrl || await resolveControllerUrl();
+  if (!options.verbose) {
+    logger.log(formatProgress('Authenticating...'));
+  } else {
+    logger.log(chalk.blue('\nAuthentication required. Running aifabrix login...\n'));
+  }
+  await handleLogin({ method: 'device', controller: controllerUrl, compact: !options.verbose });
+  await handleUpDataplane(options);
+  return true;
+}
+
+/**
+ * @param {Object} options
+ * @returns {Promise<void>}
+ */
+async function handleUpPlatformCliAction(options) {
+  const startedAt = new Date();
+  let cleanedAppKeys = [];
+  try {
+    cleanedAppKeys = await runUpPlatformWork(options);
+    await logUpPlatformOutcome({ options, startedAt, outcome: 'success', cleanedAppKeys });
+  } catch (error) {
+    try {
+      if (await maybeHandleUpPlatformAuthRetry(error, options)) {
+        await logUpPlatformOutcome({ options, startedAt, outcome: 'success', cleanedAppKeys });
+        return;
+      }
+    } catch (loginOrRetryError) {
+      await logUpPlatformOutcome({
+        options,
+        startedAt,
+        outcome: 'failure',
+        error: loginOrRetryError,
+        cleanedAppKeys
+      });
+      handleCommandError(loginOrRetryError, 'up-platform');
+      process.exit(1);
+    }
+    await logUpPlatformOutcome({ options, startedAt, outcome: 'failure', error, cleanedAppKeys });
+    handleCommandError(error, 'up-platform');
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  handleUpPlatformCliAction
+};

package/lib/cli/setup-infra.js

@@ -12,22 +12,14 @@ const {
  * @version 2.0.0
  */
 
-const chalk = require('chalk');
 const infra = require('../infrastructure');
 const appLib = require('../app');
 const config = require('../core/config');
 const logger = require('../utils/logger');
-const { handleCommandError, isAuthenticationError } = require('../utils/cli-utils');
-const { resolveControllerUrl } = require('../utils/controller-url');
-const { handleLogin } = require('../commands/login');
+const { handleCommandError } = require('../utils/cli-utils');
 const { handleUpMiso } = require('../commands/up-miso');
-const { handleUpDataplane } = require('../commands/up-dataplane');
-const {
-  applyUpPlatformForceConfig,
-  cleanBuilderAppDirs,
-  prepareUrlsLocalRegistryForUpPlatform
-} = require('../commands/up-common');
-const { runGuidedUpInfra, runGuidedUpMiso, runGuidedUpDataplane, runGuidedUpPlatform, runGuidedDownInfra } = require('./infra-guided');
+const { cleanBuilderAppDirs } = require('../commands/up-common');
+const { runGuidedUpInfra, runGuidedUpMiso, runGuidedDownInfra } = require('./infra-guided');
 const {
   loadInfraStatusSummary,
   formatInfraStatusTitleLine,
@@ -40,6 +32,11 @@ const {
   buildRestartInfraHelpLines
 } = require('../constants/infra-compose-service-names');
 
+const {
+  computeEffectiveInfraOptionalFlags,
+  persistMissingInfraOptionalServiceFlags
+} = require('../utils/infra-optional-service-flags');
+
 const UP_INFRA_HELP_AFTER = `
 Typical sequence:
   $ aifabrix up-infra
@@ -83,19 +80,6 @@ async function persistTlsEnabledFlag(cfg, value) {
   ));
 }
 
-/**
- * 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);
-}
-
 /**
  * @param {Object} options - Commander options
  * @returns {Promise<number|null>} Developer ID or null
@@ -152,31 +136,18 @@ async function runUpInfraCommand(options) {
   await maybePersistTlsFromUpInfra(options, cfg);
   const adminPass = options.adminPassword || options.adminPwd;
   const tlsEnabledEffective = cfg.tlsEnabled === true;
+  const effective = computeEffectiveInfraOptionalFlags(cfg, options);
   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),
+    traefik: effective.traefik,
+    pgadmin: effective.pgadmin,
+    redisCommander: effective.redisCommander,
     adminPassword: adminPass,
     adminPwd: adminPass,
     adminEmail: options.adminEmail,
     userPassword: options.userPassword,
     tlsEnabled: tlsEnabledEffective
   });
-}
-
-async function maybeHandleUpPlatformAuthRetry(error, options) {
-  if (!isAuthenticationError(error)) {
-    return false;
-  }
-  const controllerUrl = error.controllerUrl || await resolveControllerUrl();
-  if (!options.verbose) {
-    logger.log(formatProgress('Authenticating...'));
-  } else {
-    logger.log(chalk.blue('\nAuthentication required. Running aifabrix login...\n'));
-  }
-  await handleLogin({ method: 'device', controller: controllerUrl, compact: !options.verbose });
-  await handleUpDataplane(options);
-  return true;
+  await persistMissingInfraOptionalServiceFlags(cfg, effective);
 }
 
 function setupUpInfraCommand(program) {
@@ -197,14 +168,28 @@ function setupUpInfraCommand(program) {
     .option('--tls', 'Enable TLS mode; save tlsEnabled (${TLS_ENABLED}=true, ${HTTP_ENABLED}=false in application.yaml)')
     .option('--no-tls', 'Disable TLS mode (${TLS_ENABLED}=false, ${HTTP_ENABLED}=true)')
     .action(async(options) => {
+      const startedAt = new Date();
+      const { recordInfraInstallationCommand } = require('./installation-log-command');
       try {
         if (!options.verbose) {
           await runGuidedUpInfra(options, runUpInfraCommand);
-          return;
+        } else {
+          await runUpInfraCommand(options);
         }
-
-        await runUpInfraCommand(options);
+        await recordInfraInstallationCommand({
+          command: 'up-infra',
+          options,
+          startedAt,
+          outcome: 'success'
+        });
       } catch (error) {
+        await recordInfraInstallationCommand({
+          command: 'up-infra',
+          options,
+          startedAt,
+          outcome: 'failure',
+          error
+        });
         handleCommandError(error, 'up-infra');
         process.exit(1);
       }
@@ -223,45 +208,9 @@ function setupUpPlatformCommand(program) {
       '-f, --force',
       'Reset CLI auth (clear all device/client tokens, set environment to dev, set default controller URL from developer-id), clean builder/keycloak, builder/miso-controller, builder/dataplane, then re-fetch from templates'
     )
-    .action(async(options) => {
-      try {
-        let platformForceCleanSummary = null;
-        if (options.force) {
-          const forceSummary = await applyUpPlatformForceConfig({ silent: !options.verbose });
-          const cleanedApps = await cleanBuilderAppDirs(['keycloak', 'miso-controller', 'dataplane'], {
-            silent: !options.verbose
-          });
-          if (!options.verbose) {
-            platformForceCleanSummary = { forceSummary, cleanedApps };
-          }
-        }
-
-        if (!options.verbose) {
-          await runGuidedUpPlatform(
-            options,
-            handleUpMiso,
-            handleUpDataplane,
-            handleLogin,
-            platformForceCleanSummary
-          );
-          return;
-        }
-
-        await prepareUrlsLocalRegistryForUpPlatform();
-        await handleUpMiso(options);
-        await handleUpDataplane(options);
-      } catch (error) {
-        try {
-          if (await maybeHandleUpPlatformAuthRetry(error, options)) {
-            return;
-          }
-        } catch (loginOrRetryError) {
-          handleCommandError(loginOrRetryError, 'up-platform');
-          process.exit(1);
-        }
-        handleCommandError(error, 'up-platform');
-        process.exit(1);
-      }
+    .action((options) => {
+      const { handleUpPlatformCliAction } = require('./setup-infra-up-platform-action');
+      return handleUpPlatformCliAction(options);
     });
 }
 
@@ -275,17 +224,37 @@ function setupUpMisoCommand(program) {
     .option('-f, --force', 'Clean builder/keycloak and builder/miso-controller and re-fetch from templates')
     .option('--verbose', 'Show full orchestration output (default is guided summary)')
     .action(async(options) => {
+      const startedAt = new Date();
+      const { recordInfraInstallationCommand } = require('./installation-log-command');
+      let cleanedAppKeys = [];
       try {
         if (options.force) {
-          await cleanBuilderAppDirs(['keycloak', 'miso-controller']);
+          const c = await cleanBuilderAppDirs(['keycloak', 'miso-controller']);
+          cleanedAppKeys = Array.isArray(c) ? c : [];
         }
         if (!options.verbose) {
           await runGuidedUpMiso(options, handleUpMiso);
-          return;
+        } else {
+          await handleUpMiso(options);
         }
-
-        await handleUpMiso(options);
+        await recordInfraInstallationCommand({
+          command: 'up-miso',
+          options,
+          startedAt,
+          outcome: 'success',
+          platformAppList: ['keycloak', 'miso-controller'],
+          cleanup: cleanedAppKeys.length > 0 ? { cleanedAppKeys } : undefined
+        });
       } catch (error) {
+        await recordInfraInstallationCommand({
+          command: 'up-miso',
+          options,
+          startedAt,
+          outcome: 'failure',
+          error,
+          platformAppList: ['keycloak', 'miso-controller'],
+          cleanup: cleanedAppKeys.length > 0 ? { cleanedAppKeys } : undefined
+        });
         handleCommandError(error, 'up-miso');
         process.exit(1);
       }
@@ -301,37 +270,9 @@ function setupUpDataplaneCommand(program) {
     .option('--base', 'Resolve dataplane image from manifest only when running locally (default: true)', true)
     .option('-f, --force', 'Clean builder/dataplane and re-fetch from templates')
     .option('--verbose', 'Show full orchestration output (default is guided summary)')
-    .action(async(options) => {
-      try {
-        if (options.force) {
-          await cleanBuilderAppDirs(['dataplane']);
-        }
-        if (!options.verbose) {
-          await runGuidedUpDataplane(options, handleUpDataplane);
-          return;
-        }
-
-        await handleUpDataplane(options);
-      } catch (error) {
-        if (isAuthenticationError(error)) {
-          const controllerUrl = error.controllerUrl || await resolveControllerUrl();
-          if (!options.verbose) {
-            logger.log(formatProgress('Authenticating...'));
-          } else {
-            logger.log(chalk.blue('\nAuthentication required. Running aifabrix login...\n'));
-          }
-          try {
-            await handleLogin({ method: 'device', controller: controllerUrl, compact: !options.verbose });
-            await handleUpDataplane(options);
-            return;
-          } catch (loginOrRetryError) {
-            handleCommandError(loginOrRetryError, 'up-dataplane');
-            process.exit(1);
-          }
-        }
-        handleCommandError(error, 'up-dataplane');
-        process.exit(1);
-      }
+    .action((options) => {
+      const { handleUpDataplaneCliAction } = require('./setup-infra-up-dataplane-action');
+      return handleUpDataplaneCliAction(options);
     });
 }
 

package/lib/cli/setup-platform.js

@@ -23,7 +23,7 @@ const { handleTeardown } = require('../commands/teardown');
 
 const SETUP_HELP_AFTER = `
 What this command does:
-  - With no infra running: prompts for admin email/password (used for Postgres, pgAdmin, Keycloak), prompts for an AI tool (OpenAI or Azure OpenAI) only when keys are not already set, then runs up-infra and up-platform.
+  - With no infra running: prompts for admin email/password (used for Postgres, pgAdmin, Keycloak). The email is saved as adminEmail in config.yaml so the next setup can show it as the default (you can still change it). Prompts for an AI tool (OpenAI or Azure OpenAI) only when keys are not already set, then runs up-infra and up-platform.
   - With infra running: shows a mode menu:
       1) Re-install — stop infra and remove all volumes, then up-infra + up-platform --force.
       2) Wipe data — drop every database and DB user, then up-infra + up-platform --force.

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

@@ -0,0 +1,132 @@
+/**
+ * `aifabrix resolve <app>` command wiring (split from setup-utility for file/function size limits).
+ *
+ * @fileoverview Resolve CLI command
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const secrets = require('../core/secrets');
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+const coreConfig = require('../core/config');
+const { resolvePreferLocalEnvOutputPathFlag } = require('../utils/applications-config-defaults');
+const { getResolveAppPath } = require('../utils/paths');
+
+/**
+ * @param {string} appName
+ * @param {string} appPath
+ * @param {boolean} envOnly
+ * @param {string} envPath
+ * @param {{ skipValidation?: boolean }} options
+ * @param {{ getManifestSourcePayload: function }} manifestEmit
+ * @returns {Promise<void>}
+ */
+async function runResolveJsonOutput(appName, appPath, envOnly, envPath, options, manifestEmit) {
+  /** @type {Record<string, unknown>} */
+  const payload = {
+    app: appName,
+    appPath,
+    envOnly,
+    envPath,
+    manifestSource: envOnly ? null : manifestEmit.getManifestSourcePayload(appName, appPath)
+  };
+  if (!envOnly && !options.skipValidation) {
+    const validate = require('../validation/validate');
+    payload.validation = await validate.validateAppOrFile(appName);
+  }
+  logger.log(JSON.stringify(payload, null, 2));
+  const v = payload.validation;
+  if (v && typeof v === 'object' && v.valid === false) {
+    process.exit(1);
+  }
+}
+
+/**
+ * @param {string} appName
+ * @param {string} envPath
+ * @param {boolean} envOnly
+ * @param {{ skipValidation?: boolean }} options
+ * @returns {Promise<void>}
+ */
+async function runResolveHumanOutput(appName, envPath, envOnly, options) {
+  logger.log(`✔ Generated .env file: ${envPath}`);
+  logger.log(chalk.gray('  Note: up-platform / up-miso / up-dataplane / register / build resolve secrets in memory only.'));
+  logger.log(chalk.gray(`  Re-run "aifabrix resolve ${appName}" whenever you need an on-disk .env again.`));
+  if (envOnly) {
+    logger.log(chalk.gray('  (env-only mode: validation skipped; no application config file)'));
+    return;
+  }
+  if (options.skipValidation) {
+    return;
+  }
+  const validate = require('../validation/validate');
+  const result = await validate.validateAppOrFile(appName);
+  validate.displayValidationResults(result);
+  if (!result.valid) {
+    logger.log(chalk.yellow('\n⚠  Validation found errors. Fix them before deploying.'));
+    process.exit(1);
+  }
+}
+
+/**
+ * @param {string} appName
+ * @param {{ force?: boolean, skipValidation?: boolean, json?: boolean }} options
+ * @returns {Promise<void>}
+ */
+async function runResolveAppAction(appName, options) {
+  const jsonMode = options.json === true;
+  const { appPath, envOnly } = await getResolveAppPath(appName);
+  const manifestEmit = require('../utils/manifest-source-emit');
+  manifestEmit.emitManifestMetadataLineIfTTY(logger, {
+    appKey: appName,
+    appPath,
+    envOnly,
+    json: jsonMode
+  });
+  const userCfg = await coreConfig.getConfig();
+  const preferLocalEnvOutputPath = await resolvePreferLocalEnvOutputPathFlag(userCfg, appName);
+  const envPath = await secrets.generateEnvFile(
+    appName,
+    undefined,
+    'docker',
+    options.force,
+    {
+      appPath,
+      envOnly,
+      skipOutputPath: false,
+      preserveFromPath: null,
+      preferLocalEnvOutputPath
+    }
+  );
+  if (jsonMode) {
+    await runResolveJsonOutput(appName, appPath, envOnly, envPath, options, manifestEmit);
+    return;
+  }
+  await runResolveHumanOutput(appName, envPath, envOnly, options);
+}
+
+/**
+ * @param {import('commander').Command} program
+ * @returns {void}
+ */
+function setupResolveCommand(program) {
+  program.command('resolve <app>')
+    .description('Generate .env from template; optional validate after')
+    .option('-f, --force', 'Generate missing secret keys in secrets file')
+    .option('--skip-validation', 'Skip file validation after generating .env')
+    .option('--json', 'Print JSON summary (envPath, manifestSource, optional validation)')
+    .action(async(appName, options) => {
+      try {
+        await runResolveAppAction(appName, options);
+      } catch (error) {
+        handleCommandError(error, 'resolve');
+        process.exit(1);
+      }
+    });
+}
+
+module.exports = { setupResolveCommand };