@aifabrix/builder 2.44.5 → 2.45.0

package/lib/cli/setup-auth.js

@@ -23,9 +23,97 @@ Examples:
 const AUTH_HELP_AFTER = `
 Without options: show auth status (same as: aifabrix auth status).
 With --set-controller or --set-environment: write defaults to config.yaml.
+Omit the URL on --set-controller to pick from controllers already stored in config (device logins + default).
+For details on omitting the URL: aifabrix auth set-controller -h
+Aliases:
+  aifabrix auth set-controller [url]
+  aifabrix auth set-environment <env>
 Subcommand: auth status [--validate] for CI/scripts.
 `;
 
+const AUTH_SET_CONTROLLER_HELP_AFTER = `
+Argument:
+  [url]   Optional. When omitted, the CLI uses controllers already known in your config file
+          (the default controller value plus each device-token key). Requires an interactive TTY.
+
+Behavior:
+  - No saved controllers: error; run aifabrix login first, or pass a URL.
+  - One saved controller: if it is already the default, prints confirmation; otherwise sets it.
+  - Several saved controllers: interactive list to choose the default.
+  - Non-interactive shell: pass the URL explicitly (piped/CI shells cannot pick without a URL).
+
+Examples:
+  $ aifabrix auth set-controller
+    Pick default controller from config (TTY), or set the only saved one.
+
+  $ aifabrix auth set-controller http://localhost:3600
+    Set default controller to that URL (validated; same rules as aifabrix auth --set-controller).
+
+  $ aifabrix auth --set-controller
+    Same as omitting the URL on this subcommand (parent command flag).
+`;
+
+function createAuthStatusAction() {
+  return async(options) => {
+    try {
+      await handleAuthStatus(options);
+    } catch (error) {
+      handleCommandError(error, 'auth status');
+      process.exit(1);
+    }
+  };
+}
+
+function createAuthParentAction() {
+  return async(options) => {
+    try {
+      const setController = options.setController || options['set-controller'];
+      const setEnvironment = options.setEnvironment || options['set-environment'];
+      if (setController || setEnvironment) {
+        await handleAuthConfig({
+          setController,
+          setEnvironment
+        });
+        return;
+      }
+      await handleAuthStatus(options);
+    } catch (error) {
+      handleCommandError(error, 'auth');
+      process.exit(1);
+    }
+  };
+}
+
+function registerAuthSetControllerSubcommand(auth) {
+  const setControllerCmd = auth.command('set-controller [url]').description(
+    'Set config.controller to a URL, or omit the URL to pick from controllers already stored in config'
+  );
+  if (typeof setControllerCmd.summary === 'function') {
+    setControllerCmd.summary('Set or pick default controller URL in config');
+  }
+  setControllerCmd.addHelpText('after', AUTH_SET_CONTROLLER_HELP_AFTER).action(async(url) => {
+    try {
+      await handleAuthConfig({ setController: url || true });
+    } catch (error) {
+      handleCommandError(error, 'auth set-controller');
+      process.exit(1);
+    }
+  });
+}
+
+function registerAuthSetEnvironmentSubcommand(auth) {
+  auth.command('set-environment <env>')
+    .description('Set default environment in config (alias for auth --set-environment)')
+    .action(async(env) => {
+      try {
+        await handleAuthConfig({ setEnvironment: env });
+      } catch (error) {
+        handleCommandError(error, 'auth set-environment');
+        process.exit(1);
+      }
+    });
+}
+
 function setupLoginCommand(program) {
   program.command('login')
     .description('Sign in to Miso Controller (device or credentials flow)')
@@ -65,40 +153,23 @@ function setupLogoutCommand(program) {
 }
 
 function setupAuthSubcommands(program) {
-  const authStatusHandler = async(options) => {
-    try {
-      await handleAuthStatus(options);
-    } catch (error) {
-      handleCommandError(error, 'auth status');
-      process.exit(1);
-    }
-  };
   const auth = program.command('auth')
     .description('Show auth status or set default controller/environment')
     .addHelpText('after', AUTH_HELP_AFTER)
-    .option('--set-controller <url>', 'Set default controller URL in config')
+    .option(
+      '--set-controller [url]',
+      'Set default controller URL in config; omit url to choose from controllers registered in config'
+    )
     .option('--set-environment <env>', 'Set default environment in config')
-    .action(async(options) => {
-      try {
-        const setController = options.setController || options['set-controller'];
-        const setEnvironment = options.setEnvironment || options['set-environment'];
-        if (setController || setEnvironment) {
-          await handleAuthConfig({
-            setController,
-            setEnvironment
-          });
-          return;
-        }
-        await handleAuthStatus(options);
-      } catch (error) {
-        handleCommandError(error, 'auth');
-        process.exit(1);
-      }
-    });
+    .action(createAuthParentAction());
+
+  registerAuthSetControllerSubcommand(auth);
+  registerAuthSetEnvironmentSubcommand(auth);
+
   auth.command('status')
     .description('Show tokens/session for current controller and environment')
     .option('--validate', 'Exit with code 1 when not authenticated (for scripted use, e.g. manual test setup)')
-    .action(authStatusHandler);
+    .action(createAuthStatusAction());
 }
 
 /**

package/lib/cli/setup-dev-path-commands.js

@@ -1,5 +1,5 @@
 /**
- * Dev subcommands: set-home, set-work, print-home, print-work, set-format.
+ * Dev subcommands: set-home, set-work, print-home, print-work, shell-env, set-format.
  *
  * @fileoverview Path and format CLI registration for `aifabrix dev`
  * @author AI Fabrix Team
@@ -10,18 +10,35 @@
 const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
 
 const chalk = require('chalk');
+const path = require('path');
 const config = require('../core/config');
 const logger = require('../utils/logger');
 const paths = require('../utils/paths');
-const { registerAifabrixShellEnvFromConfig } = require('../utils/register-aifabrix-shell-env');
+const {
+  registerAifabrixShellEnvFromConfig,
+  buildShellEnvExportsFromConfig
+} = require('../utils/register-aifabrix-shell-env');
 const { handleCommandError } = require('../utils/cli-utils');
 
 async function runShellEnvRegistration() {
   try {
     await registerAifabrixShellEnvFromConfig(config.getConfig);
     logger.log(
-      chalk.gray('  User/shell environment updated. Open a new terminal for AIFABRIX_HOME / AIFABRIX_WORK.')
+      chalk.gray('  User/shell environment updated. New terminals pick up AIFABRIX_HOME / AIFABRIX_WORK.')
     );
+    if (process.platform !== 'win32') {
+      logger.log(
+        chalk.gray('  This terminal: ') +
+          chalk.cyan('eval "$(aifabrix dev shell-env)"') +
+          chalk.gray('  (or source the aifabrix-shell-env.sh next to config.yaml).')
+      );
+    } else {
+      logger.log(
+        chalk.gray('  This PowerShell session: ') +
+          chalk.cyan('aifabrix dev shell-env') +
+          chalk.gray(' then run the printed lines.')
+      );
+    }
   } catch (regErr) {
     throw new Error(`Config saved but environment registration failed: ${regErr.message}`);
   }
@@ -92,6 +109,36 @@ function addPrintHomeWorkCommands(dev) {
         process.exit(1);
       }
     });
+
+  dev
+    .command('shell-env')
+    .description(
+      'Print export lines for AIFABRIX_HOME / AIFABRIX_WORK (stdout only). POSIX: eval "$(aifabrix dev shell-env)"'
+    )
+    .action(async() => {
+      try {
+        if (process.platform === 'win32') {
+          const cfg = await config.getConfig();
+          const home = (cfg['aifabrix-home'] && String(cfg['aifabrix-home']).trim())
+            ? paths.resolveAifabrixHomeLikePath(String(cfg['aifabrix-home']).trim())
+            : null;
+          const work = (cfg['aifabrix-work'] && String(cfg['aifabrix-work']).trim())
+            ? path.resolve(String(cfg['aifabrix-work']).trim())
+            : null;
+          const esc = (s) => String(s).replace(/'/g, '\'\'');
+          const lines = ['# Paste into PowerShell for this session only.'];
+          if (home) lines.push(`$env:AIFABRIX_HOME = '${esc(home)}'`);
+          if (work) lines.push(`$env:AIFABRIX_WORK = '${esc(work)}'`);
+          process.stdout.write(`${lines.join('\n')}\n`);
+          return;
+        }
+        const body = await buildShellEnvExportsFromConfig(config.getConfig);
+        process.stdout.write(body);
+      } catch (error) {
+        handleCommandError(error, 'dev shell-env');
+        process.exit(1);
+      }
+    });
 }
 
 function addSetFormatCommand(dev, handleSetFormat) {

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
+};