@aifabrix/builder 2.44.6 → 2.45.5

package/lib/cli/setup-auth.js

@@ -23,12 +23,123 @@ 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-controller [url]
   aifabrix auth set-environment <env>
-Subcommand: auth status [--validate] for CI/scripts.
+Subcommand: auth status [--validate] for CI/scripts (exit codes 0/1/3).
 `;
 
+const AUTH_STATUS_HELP_AFTER = `
+Examples:
+  $ aifabrix auth status
+  $ aifabrix auth status --validate
+
+Exit codes (--validate only):
+  0  Authenticated and Builder CLI meets dataplane minimum (or no minimum configured)
+  1  Not authenticated — run aifabrix login
+  3  Authenticated but Builder CLI is older than dataplane minimum
+
+Config cache (written on status when dataplane is reachable):
+  ~/.aifabrix/config.yaml → device.<controllerUrl>:
+    dataplane-version         — last dataplane version from health
+    dataplane-min-cli-version — minimum Builder CLI required (when enforced)
+
+What is blocked when CLI is too old:
+  Dataplane commands (upload, wizard, datasource upload, deploy to dataplane, …)
+What still works:
+  Local validate, aifabrix run, up-infra, file generation without dataplane API calls
+
+Troubleshooting:
+  • "Upgrade required" but you upgraded — run auth status again to refresh cache
+  • No min version shown — dataplane MIN_BUILDER_CLI_VERSION not set (ops)
+  • CI exit 3 — pin @aifabrix/builder version in pipeline to ≥ dataplane-min-cli-version
+`;
+
+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)')
@@ -68,63 +179,24 @@ 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);
-      }
-    });
-
-  auth.command('set-controller <url>')
-    .description('Set default controller URL in config (alias for auth --set-controller)')
-    .action(async(url) => {
-      try {
-        await handleAuthConfig({ setController: url });
-      } catch (error) {
-        handleCommandError(error, 'auth set-controller');
-        process.exit(1);
-      }
-    });
+    .action(createAuthParentAction());
 
-  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);
-      }
-    });
+  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);
+    .addHelpText('after', AUTH_STATUS_HELP_AFTER)
+    .option('--validate', 'Exit 1 when not authenticated, 3 when Builder CLI < dataplane minimum, 0 otherwise (for CI/scripts)')
+    .action(createAuthStatusAction());
 }
 
 /**
@@ -137,4 +209,4 @@ function setupAuthCommands(program) {
   setupAuthSubcommands(program);
 }
 
-module.exports = { setupAuthCommands };
+module.exports = { setupAuthCommands, AUTH_STATUS_HELP_AFTER };

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

@@ -42,8 +42,11 @@ function setupDownloadCommand(program) {
 
 function setupUploadCommand(program) {
   program.command('upload <systemKey>')
-    .description('Validate, publish to dataplane, and register with controller (draft application)')
+    .description('Validate, publish to dataplane, and register with controller (draft application); or upload .protection batch')
     .option('--dry-run', 'Validate and build payload only; no API calls')
+    .option('--no-sync', 'For .protection: skip datasource sync after upload')
+    .option('--json', 'For .protection: JSON output')
+    .option('--warnings-as-errors', 'For .protection: pass strict=true to dataplane validate')
     .option('-v, --verbose', 'Run server-side pipeline validate and print warnings before publish')
     .option('--probe', 'After publish, run dataplane runtime checks (validation/run); slower')
     .option('--minimal', 'Print only a short readiness summary after upload')
@@ -54,6 +57,26 @@ function setupUploadCommand(program) {
     )
     .action(async(systemKey, options) => {
       try {
+        const { isProtectionScope } = require('../protection/scope');
+        if (isProtectionScope(systemKey)) {
+          const { uploadProtectionBatchCommand } = require('../protection/upload-batch');
+          const logger = require('../utils/logger');
+          const code = await uploadProtectionBatchCommand(
+            {
+              env: options.env,
+              dryRun: options.dryRun === true,
+              noSync: options.noSync === true,
+              json: options.json === true,
+              verbose: options.verbose === true,
+              warningsAsErrors: options.warningsAsErrors === true
+            },
+            logger
+          );
+          if (code !== 0) {
+            process.exit(code);
+          }
+          return;
+        }
         const upload = require('../commands/upload');
         const probeTimeout =
           options.probeTimeout === undefined || options.probeTimeout === null
@@ -79,6 +102,17 @@ function setupDeleteCommand(program) {
     .option('--force', 'Skip confirmation prompt (alias for --yes)')
     .action(async(systemKey, options) => {
       try {
+        const { isProtectionScope } = require('../protection/scope');
+        if (isProtectionScope(systemKey)) {
+          const logger = require('../utils/logger');
+          const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
+          logger.error(
+            formatBlockingError(
+              'delete .protection is not supported. Use: aifabrix protection delete <datasourceKey>'
+            )
+          );
+          process.exit(1);
+        }
         const externalDelete = require('../external-system/delete');
         await externalDelete.deleteExternalSystem(systemKey, options);
       } catch (error) {
@@ -186,8 +220,8 @@ async function runTestIntegrationCommand(appName, options) {
 
 function setupExternalSystemTestCommands(program) {
   // 'test <app>' is registered in setup-app.js and dispatches by app type (builder vs external)
-  program.command('test-integration <app>')
-    .description('Integration tests: builder in container; external via dataplane')
+  program.command('test-integration <appKey|systemKey>')
+    .description('Integration tests: builder appKey in container; external systemKey via dataplane')
     .option('-e, --env <env>', 'Environment: dev, tst, or pro (builder: dev/tst for container)', 'dev')
     .option('-v, --verbose', 'Show detailed test output')
     .option('-d, --debug', 'Include debug output and write log to integration/<systemKey>/logs/')

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