@aifabrix/builder 2.47.4 → 2.49.0

package/lib/build/index.js

@@ -1,6 +1,5 @@
 const {
   formatSuccessLine,
-  formatSuccessParagraph,
   formatProgress,
   formatWarningLine,
   sectionTitle,
@@ -31,12 +30,10 @@ const secrets = require('../core/secrets');
 const config = require('../core/config');
 const logger = require('../utils/logger');
 const dockerfileUtils = require('../utils/dockerfile-utils');
-const dockerBuild = require('../utils/docker-build');
 const buildCopy = require('../utils/build-copy');
 const { resolveBuildDockerTagNames } = require('../utils/build-resolve-image');
 const buildHelpers = require('../utils/build-helpers');
-const { ensureRunSecretsForApp } = require('../app/run-env-compose');
-const { resolveDockerBuildArgsForApp } = require('./docker-build-args');
+const { runStandardDockerBuild } = require('./standard-docker-build');
 
 /**
  * Loads application config for an application
@@ -353,18 +350,6 @@ function prepareBuildContext(buildConfig, devDir) {
   return contextPath;
 }
 
-/**
- * Handle Dockerfile generation
- * @async
- * @param {string} appName - Application name
- * @param {Object} params - Parameters
- * @param {string} params.devDir - Developer directory
- * @param {Object} params.buildConfig - Build configuration
- * @param {string} params.contextPath - Build context path
- * @param {Object} params.appConfig - Application configuration
- * @param {Object} options - Build options
- * @returns {Promise<string>} Dockerfile path
- */
 async function handleDockerfileGeneration(appName, params, options, buildHelpers) {
   const { devDir, buildConfig, contextPath, appConfig } = params;
   const appDockerfilePath = path.join(devDir, 'Dockerfile');
@@ -393,38 +378,6 @@ async function handleDockerfileGeneration(appName, params, options, buildHelpers
   }, generateDockerfile);
 }
 
-/**
- * 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 { emitManifestMetadataLineIfTTY } = require('../utils/manifest-source-emit');
-  const { appPath } = await detectAppType(appName);
-  emitManifestMetadataLineIfTTY(logger, { appKey: appName, appPath, envOnly: false, json: false });
-  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, contextPath);
-  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
@@ -458,4 +411,14 @@ async function buildApp(appName, options = {}) {
     throw new Error(`Build failed: ${error.message}`);
   }
 }
-module.exports = { loadVariablesYaml, resolveContextPath, detectLanguage, generateDockerfile, buildApp, postBuildTasks };
+module.exports = {
+  loadVariablesYaml,
+  resolveContextPath,
+  detectLanguage,
+  generateDockerfile,
+  buildApp,
+  postBuildTasks,
+  prepareDevDirectory,
+  prepareBuildContext,
+  handleDockerfileGeneration
+};

package/lib/build/integration-docker-staging.js

@@ -0,0 +1,35 @@
+/**
+ * Pre-build integration manifest staging for Docker context.
+ * @fileoverview Runs scripts/stage_integration_for_docker.py when present in build context
+ */
+
+'use strict';
+
+const fsSync = require('fs');
+const path = require('path');
+const { promisify } = require('util');
+const { exec } = require('child_process');
+const logger = require('../utils/logger');
+const {
+  formatProgress,
+  formatSuccessLine
+} = require('../utils/cli-test-layout-chalk');
+
+const run = promisify(exec);
+
+/**
+ * When repo ships scripts/stage_integration_for_docker.py, run it before docker build.
+ * @param {string} contextPath
+ * @returns {Promise<void>}
+ */
+async function maybeStageIntegrationForDockerBuild(contextPath) {
+  const scriptPath = path.join(contextPath, 'scripts/stage_integration_for_docker.py');
+  if (!fsSync.existsSync(scriptPath)) {
+    return;
+  }
+  logger.log(formatProgress('Staging integration runtime manifests for Docker…'));
+  await run('python3 scripts/stage_integration_for_docker.py', { cwd: contextPath });
+  logger.log(formatSuccessLine('Integration staging ready'));
+}
+
+module.exports = { maybeStageIntegrationForDockerBuild };

package/lib/build/standard-docker-build.js

@@ -0,0 +1,113 @@
+/**
+ * Standard Docker build orchestration (dev-promote shortcut + full build).
+ * @fileoverview Extracted from lib/build/index.js for file-size limits
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { detectAppType } = require('../utils/paths');
+const logger = require('../utils/logger');
+const dockerBuild = require('../utils/docker-build');
+const buildHelpers = require('../utils/build-helpers');
+const { ensureRunSecretsForApp } = require('../app/run-env-compose');
+const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+const { resolveDockerBuildArgsForApp } = require('./docker-build-args');
+const { maybeStageIntegrationForDockerBuild } = require('./integration-docker-staging');
+
+/**
+ * Lazy require breaks circular dependency with lib/build/index.js.
+ * @returns {Object}
+ */
+function getBuildIndexDeps() {
+  return require('./index');
+}
+
+/**
+ * When --from-dev --base: tag dev image as base and skip docker build when possible.
+ * @param {string} appName
+ * @param {Object} options
+ * @returns {Promise<string|null>} image ref when promote completed; null to continue full build
+ */
+async function tryCompleteDevPromoteBuild(appName, options) {
+  const { shouldAttemptDevPromote, tryPromoteDevImageToBase } = require('../utils/promote-dev-docker-image');
+  if (!shouldAttemptDevPromote(options)) {
+    return null;
+  }
+  const promotedRef = await tryPromoteDevImageToBase(appName, options);
+  if (!promotedRef) {
+    logger.log(chalk.blue('No local dev-scoped image found; building base image...'));
+    return null;
+  }
+  const { buildConfig } = await buildHelpers.loadAndValidateConfig(appName);
+  const { postBuildTasks } = getBuildIndexDeps();
+  await postBuildTasks(appName, buildConfig);
+  logger.log(formatSuccessParagraph('Build completed successfully! (promoted from dev image)'));
+  return promotedRef;
+}
+
+/**
+ * Run docker build after workspace prep (shared by standard build path).
+ * @param {string} appName
+ * @param {Object} options
+ * @param {Object} buildConfig
+ * @returns {Promise<string>}
+ */
+async function executeDockerImageBuild(appName, options, buildConfig) {
+  const { emitManifestMetadataLineIfTTY } = require('../utils/manifest-source-emit');
+  const {
+    prepareDevDirectory,
+    prepareBuildContext,
+    handleDockerfileGeneration,
+    postBuildTasks
+  } = getBuildIndexDeps();
+  const { appPath } = await detectAppType(appName);
+  emitManifestMetadataLineIfTTY(logger, { appKey: appName, appPath, envOnly: false, json: false });
+  const { devDir, effectiveImageName, imageName, appConfig } = await prepareDevDirectory(
+    appName,
+    buildConfig,
+    options
+  );
+  const contextPath = prepareBuildContext(buildConfig, devDir);
+  await maybeStageIntegrationForDockerBuild(contextPath);
+  const dockerfilePath = await handleDockerfileGeneration(
+    appName,
+    { devDir, buildConfig, contextPath, appConfig },
+    options,
+    buildHelpers
+  );
+  await ensureRunSecretsForApp(appName);
+  const buildArgs = await resolveDockerBuildArgsForApp(appName, contextPath);
+  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,
+    { ...options, buildArgs }
+  );
+  await postBuildTasks(appName, buildConfig);
+  logger.log(formatSuccessParagraph('Build completed successfully!'));
+  return `${effectiveImageName}:${tag}`;
+}
+
+/**
+ * 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 promotedRef = await tryCompleteDevPromoteBuild(appName, options);
+  if (promotedRef) {
+    return promotedRef;
+  }
+  const { buildConfig } = await buildHelpers.loadAndValidateConfig(appName);
+  return executeDockerImageBuild(appName, options, buildConfig);
+}
+
+module.exports = { runStandardDockerBuild };

package/lib/cli/infra-guided-auth.js

@@ -16,6 +16,7 @@ const { withMutedLogger } = require('../utils/with-muted-logger');
 const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
 const { isAuthenticationError } = require('../utils/cli-utils');
 const { resolveControllerUrl, isPlatformAuthValidForController } = require('../utils/controller-url');
+const { canUseBootstrapProvision } = require('../commands/up-dataplane-bootstrap');
 
 /**
  * @param {Object} authOpts
@@ -59,7 +60,10 @@ async function runGuidedDeviceLogin(handleLoginFn, controllerUrl, opts = {}) {
     compact: true,
     skipControllerUrlPersist: Boolean(opts.tokenControllerUrl),
     skipDataplaneVersionRefresh: opts.skipDataplaneVersionRefresh === true,
-    exitOnFailure: false
+    exitOnFailure: false,
+    guidedInstall: opts.guidedInstall === true,
+    onProgressText: opts.onProgressText,
+    suppressSuccessLine: opts.suppressSuccessLine === true
   });
 }
 
@@ -74,12 +78,17 @@ async function runGuidedAuthStep(handleLoginFn, authOpts, spinners) {
   const spin = spinners.startSpinner('Authenticating...');
   const { apiUrl, tokenUrl } = await resolveGuidedAuthControllerUrls(authOpts);
   const loginOpts = { skipDataplaneVersionRefresh: true, tokenControllerUrl: tokenUrl };
+  const bootstrapEligible = await canUseBootstrapProvision({ skipInfraCheck: true });
   const skipLogin =
+    bootstrapEligible ||
     authOpts.skipLoginIfAuthenticated === true ||
     (await isPlatformAuthValidForController(tokenUrl));
   try {
     if (skipLogin) {
-      spinners.stopSpinnerSuccess(spin, 'Already authenticated');
+      spinners.stopSpinnerSuccess(
+        spin,
+        bootstrapEligible ? 'Bootstrap provision (no device login)' : 'Already authenticated'
+      );
       return;
     }
     await runGuidedDeviceLogin(handleLoginFn, apiUrl, loginOpts);
@@ -103,9 +112,17 @@ async function runGuidedAuthStep(handleLoginFn, authOpts, spinners) {
  * @param {Function} handleUpDataplane
  * @param {Function} handleLoginFn
  * @param {string} controllerUrl
+ * @param {{ onSpinnerText?: (text: string) => void }} [ui]
  * @returns {Promise<void>}
  */
-async function runGuidedDataplaneWithAuthRecovery(options, handleUpDataplane, handleLoginFn, controllerUrl) {
+async function runGuidedDataplaneWithAuthRecovery(
+  options,
+  handleUpDataplane,
+  handleLoginFn,
+  controllerUrl,
+  ui = {}
+) {
+  const onSpinnerText = typeof ui.onSpinnerText === 'function' ? ui.onSpinnerText : null;
   try {
     await withMutedLogger(() =>
       handleUpDataplane({ ...options, platformInstall: true, skipInfraCheck: true })
@@ -114,10 +131,29 @@ async function runGuidedDataplaneWithAuthRecovery(options, handleUpDataplane, ha
     if (!isAuthenticationError(error)) {
       throw error;
     }
+    const bootstrapEligible = await canUseBootstrapProvision({
+      skipInfraCheck: true,
+      allowNonDev: options.allowNonDev
+    });
+    if (bootstrapEligible) {
+      throw error;
+    }
     const loginUrl = error.controllerUrl || controllerUrl || (await resolveControllerUrl());
-    logger.log('');
-    logger.log(chalk.yellow('Device login required to register and deploy Dataplane.'));
-    await runGuidedDeviceLogin(handleLoginFn, loginUrl, { skipDataplaneVersionRefresh: false });
+    if (onSpinnerText) {
+      onSpinnerText('Authenticating...');
+    } else {
+      logger.log('');
+      logger.log(chalk.yellow('Device login required to register and deploy Dataplane.'));
+    }
+    await runGuidedDeviceLogin(handleLoginFn, loginUrl, {
+      skipDataplaneVersionRefresh: false,
+      compact: true,
+      guidedInstall: true,
+      onProgressText: onSpinnerText || undefined
+    });
+    if (onSpinnerText) {
+      onSpinnerText('Validating Dataplane...');
+    }
     await withMutedLogger(() =>
       handleUpDataplane({ ...options, platformInstall: true, skipInfraCheck: true })
     );

package/lib/cli/infra-guided-footers.js

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview Footer and header layout for guided infra/platform CLI flows.
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const config = require('../core/config');
+const { computeAppBaseUrl, resolvePlatformControllerUrl } = require('../utils/platform-controller-url');
+const { successGlyph } = require('../utils/cli-test-layout-chalk');
+
+const SEPARATOR = '────────────────────────────────────────';
+
+function title(text) {
+  return chalk.bold(text);
+}
+
+function logSection(label, value) {
+  logger.log(title(label));
+  logger.log(`  ${value}`);
+  logger.log('');
+}
+
+function logFooterStart(label) {
+  logger.log('');
+  logger.log(SEPARATOR);
+  logger.log(title(label));
+  logger.log(SEPARATOR);
+  logger.log('');
+}
+
+function logFooterEnd() {
+  logger.log(SEPARATOR);
+}
+
+/**
+ * @async
+ * @returns {Promise<string>}
+ */
+async function resolvePlatformControllerUrlForDisplay() {
+  const stored = await config.getPlatformControllerUrl();
+  if (stored) {
+    return stored;
+  }
+  return resolvePlatformControllerUrl();
+}
+
+async function logPlatformReadyFooter() {
+  const [controllerUrl, dataplaneUrl, keycloakUrl] = await Promise.all([
+    resolvePlatformControllerUrlForDisplay(),
+    computeAppBaseUrl('dataplane'),
+    computeAppBaseUrl('keycloak')
+  ]);
+  const cfg = await config.getConfig();
+  const env = cfg && cfg.environment ? cfg.environment : 'dev';
+
+  logFooterStart('Platform Ready');
+  logSection('Environment', env);
+  logSection('Miso Controller', controllerUrl);
+  logSection('Dataplane (DEV)', dataplaneUrl);
+  logSection('Keycloak', keycloakUrl);
+  logSection('API Documentation', `${dataplaneUrl}/api/docs`);
+  logSection('Knowledge Base', 'https://docs.aifabrix.ai');
+  logSection('Getting Started', 'https://docs.aifabrix.ai/get-started');
+  logFooterEnd();
+}
+
+async function logMisoReadyFooter() {
+  const [controllerUrl, keycloakUrl] = await Promise.all([
+    resolvePlatformControllerUrlForDisplay(),
+    computeAppBaseUrl('keycloak')
+  ]);
+  logFooterStart('Miso Ready');
+  logSection('Miso Controller', controllerUrl);
+  logSection('Keycloak', keycloakUrl);
+  logFooterEnd();
+}
+
+async function logDataplaneReadyFooter() {
+  const dataplaneUrl = await computeAppBaseUrl('dataplane');
+  const cfg = await config.getConfig();
+  const env = cfg && cfg.environment ? cfg.environment : 'dev';
+  logFooterStart('Dataplane Ready');
+  logSection('Environment', env);
+  logSection('Dataplane (DEV)', dataplaneUrl);
+  logSection('API Documentation', `${dataplaneUrl}/api/docs`);
+  logFooterEnd();
+}
+
+/**
+ * @param {'platform'|'dataplane'} [scope]
+ */
+function logPlatformSetupDurationHint(scope = 'platform') {
+  const line =
+    scope === 'dataplane'
+      ? 'Installation may take a few minutes. Authenticating and starting Dataplane — please wait.'
+      : 'Installation may take a few minutes. Keycloak, Miso Controller, and Dataplane are starting — please wait.';
+  logger.log(chalk.yellow(`⚠ ${line}`));
+}
+
+function logGuidedPlatformSetupHeader() {
+  logger.log('');
+  logger.log(title('AI Fabrix Platform Setup'));
+  logger.log(SEPARATOR);
+  logger.log('');
+  logPlatformSetupDurationHint('platform');
+  logger.log('');
+}
+
+/**
+ * @param {{ deviceCleared: number, clientCleared: number, environment: string, defaultControllerUrl: string }} forceSummary
+ * @param {string[]} cleanedApps
+ */
+function logUpPlatformForceCleanSummary(forceSummary, cleanedApps) {
+  const { isSetupQuietOutput } = require('../utils/setup-quiet-output');
+  if (isSetupQuietOutput()) return;
+  const check = successGlyph();
+  logger.log(chalk.bold('Clean installation files'));
+  logger.log(
+    chalk.gray(
+      ` ${check} Cleared ${forceSummary.deviceCleared} device token(s) and ${forceSummary.clientCleared} client token(s)`
+    )
+  );
+  logger.log(chalk.gray(` ${check} Environment set to ${forceSummary.environment}`));
+  logger.log(
+    chalk.gray(
+      ` ${check} Default controller set to ${forceSummary.defaultControllerUrl} (run aifabrix login after platform is up)`
+    )
+  );
+  for (const appName of cleanedApps || []) {
+    logger.log(chalk.gray(` ${check} Cleaned builder/${appName}`));
+  }
+  logger.log('');
+}
+
+/**
+ * @param {Object} cfg
+ */
+function logStoppedServices(cfg) {
+  logger.log(title('Stopped'));
+  logger.log('  postgres');
+  logger.log('  redis');
+  if (cfg.pgadmin !== false) logger.log('  pgadmin');
+  if (cfg.redisCommander !== false) logger.log('  redis-commander');
+  if (cfg.traefik) logger.log('  traefik');
+  logger.log('');
+}
+
+module.exports = {
+  SEPARATOR,
+  title,
+  logSection,
+  logFooterStart,
+  logFooterEnd,
+  resolvePlatformControllerUrlForDisplay,
+  logPlatformReadyFooter,
+  logMisoReadyFooter,
+  logDataplaneReadyFooter,
+  logPlatformSetupDurationHint,
+  logGuidedPlatformSetupHeader,
+  logUpPlatformForceCleanSummary,
+  logStoppedServices
+};

package/lib/cli/infra-guided-spinners.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Spinner helpers for guided infra/platform CLI flows.
+ */
+
+'use strict';
+
+const ora = require('ora');
+const logger = require('../utils/logger');
+const { formatProgress, formatSuccessLine } = require('../utils/cli-test-layout-chalk');
+
+function shouldUseSpinner() {
+  return Boolean(process && process.stdout && process.stdout.isTTY);
+}
+
+/**
+ * @param {string} text
+ * @returns {import('ora').Ora|null}
+ */
+function startSpinner(text) {
+  if (!shouldUseSpinner()) {
+    logger.log(formatProgress(text));
+    return null;
+  }
+  return ora({ text, spinner: 'dots' }).start();
+}
+
+/**
+ * @param {import('ora').Ora|null} spinner
+ * @param {string} text
+ */
+function stopSpinnerSuccess(spinner, text) {
+  if (!spinner) {
+    logger.log(formatSuccessLine(text));
+    return;
+  }
+  spinner.succeed(text);
+}
+
+/**
+ * @param {import('ora').Ora|null} spinner
+ * @returns {(text: string) => void}
+ */
+function createSpinnerTextUpdater(spinner) {
+  return (text) => {
+    if (spinner) {
+      spinner.text = text;
+      return;
+    }
+    logger.log(formatProgress(text));
+  };
+}
+
+module.exports = {
+  startSpinner,
+  stopSpinnerSuccess,
+  createSpinnerTextUpdater
+};