@aifabrix/builder 2.43.0 → 2.44.0

package/lib/app/run-helpers.js

@@ -1,3 +1,4 @@
+const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
 /**
  * AI Fabrix Builder - App Run Helpers
  *
@@ -13,24 +14,20 @@ const fs = require('fs').promises;
 const fsSync = require('fs');
 const path = require('path');
 const chalk = require('chalk');
-const { exec } = require('child_process');
 const { loadConfigFile } = require('../utils/config-format');
-const { promisify } = require('util');
 const validator = require('../validation/validator');
 const config = require('../core/config');
 const buildCopy = require('../utils/build-copy');
 const logger = require('../utils/logger');
-const { waitForHealthCheck } = require('../utils/health-check');
 const composeGenerator = require('../utils/compose-generator');
-const dockerUtils = require('../utils/docker');
 const containerHelpers = require('../utils/app-run-containers');
 const pathsUtil = require('../utils/paths');
 const runEnvCompose = require('./run-env-compose');
+const { getAppInfraRequirements } = require('./run-infra-requirements');
+const { resolveRunImage } = require('./run-resolve-image');
+const { startContainer } = require('./run-container-start');
 const { resolveEnvOutputPath, writeEnvOutputForReload, writeEnvOutputForLocal } = require('../utils/env-copy');
 const { resolveVersionForApp } = require('../utils/image-version');
-const { parseImageOverride } = require('../utils/parse-image-ref');
-
-const execAsync = promisify(exec);
 
 /** Template apps (keycloak, miso-controller, dataplane) - never update application config when running */
 const TEMPLATE_APP_KEYS = ['keycloak', 'miso-controller', 'dataplane'];
@@ -123,6 +120,9 @@ async function validateAppConfiguration(appName) {
     throw new Error('Application name is required');
   }
 
+  const { assertRemoteBuilderDeveloperId } = require('../utils/remote-builder-validation');
+  assertRemoteBuilderDeveloperId(await config.getRemoteServer(), await config.getDeveloperId());
+
   // Check if running from builder directory
   checkBuilderDirectory(appName);
 
@@ -161,28 +161,6 @@ async function resolveAndUpdateVersion(appName, appConfig, debug) {
   }
 }
 
-/**
- * Resolve image name and tag from app config and optional run override.
- * @param {string} appName - Application name
- * @param {Object} appConfig - Application configuration
- * @param {Object} runOptions - Run options; runOptions.image overrides config
- * @returns {{ imageName: string, imageTag: string }} imageName and imageTag
- */
-function resolveRunImage(appName, appConfig, runOptions) {
-  const imageOverride = runOptions && runOptions.image;
-  if (imageOverride) {
-    const parsed = parseImageOverride(imageOverride);
-    return {
-      imageName: parsed ? parsed.name : composeGenerator.getImageName(appConfig, appName),
-      imageTag: parsed ? parsed.tag : (appConfig.image && appConfig.image.tag) || 'latest'
-    };
-  }
-  return {
-    imageName: composeGenerator.getImageName(appConfig, appName),
-    imageTag: (appConfig.image && appConfig.image.tag) || 'latest'
-  };
-}
-
 /**
  * Checks prerequisites: Docker image and (optionally) infrastructure
  * @async
@@ -210,12 +188,12 @@ async function checkPrerequisites(appName, appConfig, debug = false, skipInfraCh
       : `Run 'aifabrix build ${appName}' first`;
     throw new Error(`Docker image ${fullImageName} not found\n${hint}`);
   }
-  logger.log(chalk.green(`✓ Image ${fullImageName} found`));
+  logger.log(formatSuccessLine(`Image ${fullImageName} found`));
 
   await resolveAndUpdateVersion(appName, appConfig, debug);
 
   if (!skipInfraCheck) {
-    await checkInfraHealthOrThrow(debug);
+    await checkInfraHealthOrThrow(debug, appConfig);
   }
 }
 
@@ -223,12 +201,28 @@ async function checkPrerequisites(appName, appConfig, debug = false, skipInfraCh
  * Checks infrastructure health and throws if unhealthy
  * @async
  * @param {boolean} debug - Enable debug logging
+ * @param {Object} [appConfig] - Application configuration (for selective infra checks)
  * @throws {Error} If infrastructure is not healthy
  */
-async function checkInfraHealthOrThrow(debug) {
+async function checkInfraHealthOrThrow(debug, appConfig) {
+  const requirements = getAppInfraRequirements(appConfig);
+  if (requirements && !requirements.needsPostgres && !requirements.needsRedis) {
+    logger.log(
+      chalk.blue('Skipping infrastructure check (application does not require database or redis)...')
+    );
+    return;
+  }
+
   logger.log(chalk.blue('Checking infrastructure health...'));
   const infra = require('../infrastructure');
-  const infraHealth = await infra.checkInfraHealth();
+  const healthOptions =
+    requirements === null
+      ? {}
+      : {
+        postgres: requirements.needsPostgres,
+        redis: requirements.needsRedis
+      };
+  const infraHealth = await infra.checkInfraHealth(null, healthOptions);
   if (debug) {
     logger.log(chalk.gray(`[DEBUG] Infrastructure health: ${JSON.stringify(infraHealth, null, 2)}`));
   }
@@ -239,7 +233,7 @@ async function checkInfraHealthOrThrow(debug) {
   if (unhealthyServices.length > 0) {
     throw new Error(`Infrastructure services not healthy: ${unhealthyServices.join(', ')}\nRun 'aifabrix up-infra' first`);
   }
-  logger.log(chalk.green('✓ Infrastructure is running'));
+  logger.log(formatSuccessLine('Infrastructure is running'));
 }
 
 /**
@@ -334,15 +328,31 @@ async function writeEnvOutputIfConfigured(appName, appConfig, runEnvPath, option
 async function prepareEnvironment(appName, appConfig, options) {
   const developerId = await config.getDeveloperId();
   const devDir = await ensureDevDirectory(appName, developerId);
+  const runEnvKey = (options.env || 'dev').toLowerCase();
+  const userCfg = await config.getConfig();
+  const { computeEffectiveEnvironmentScopedResources } = require('../utils/environment-scoped-resources');
+  const effectiveEnvironmentScopedResources = computeEffectiveEnvironmentScopedResources(
+    Boolean(userCfg.useEnvironmentScopedResources),
+    appConfig.environmentScopedResources === true,
+    runEnvKey
+  );
 
   runEnvCompose.cleanApplicationsDir(developerId);
   logger.log(chalk.blue('Building merged .env (admin + app secrets)...'));
-  const { runEnvPath, runEnvAdminPath } = await runEnvCompose.buildMergedRunEnvAndWrite(appName, appConfig, devDir, developerId);
+  const { runEnvPath, runEnvAdminPath } = await runEnvCompose.buildMergedRunEnvAndWrite(
+    appName,
+    appConfig,
+    devDir,
+    developerId,
+    { runEnvKey, effectiveEnvironmentScopedResources }
+  );
 
   const composeOptions = {
     ...options,
     envFilePath: runEnvPath,
-    dbInitEnvFilePath: runEnvAdminPath
+    dbInitEnvFilePath: runEnvAdminPath,
+    effectiveEnvironmentScopedResources,
+    env: runEnvKey
   };
   composeOptions.port = calculateComposePort(composeOptions, appConfig, developerId);
   const composePath = await generateComposeFile(appName, appConfig, composeOptions, devDir);
@@ -352,105 +362,18 @@ async function prepareEnvironment(appName, appConfig, options) {
   return { composePath, runEnvPath, runEnvAdminPath };
 }
 
-/**
- * Prepare environment variables for docker compose (no secrets in host env; compose uses env_file).
- * @async
- * @param {boolean} debug - Enable debug logging
- * @returns {Promise<Object>} Environment variables object for child process
- */
-async function prepareContainerEnv(debug) {
-  const env = { ...process.env };
-
-  if (typeof process.getuid === 'function' && typeof process.getgid === 'function') {
-    env.AIFABRIX_UID = String(process.getuid());
-    env.AIFABRIX_GID = String(process.getgid());
-  } else {
-    env.AIFABRIX_UID = '1000';
-    env.AIFABRIX_GID = '1000';
-  }
-
-  const { getRemoteDockerEnv } = require('../utils/remote-docker-env');
-  const remoteDocker = await getRemoteDockerEnv();
-  Object.assign(env, remoteDocker);
-
-  if (debug) {
-    logger.log(chalk.gray('[DEBUG] Container env prepared (secrets via env_file)'));
-  }
-
-  return env;
-}
-
-/**
- * Execute docker-compose up command. Services get env from env_file in the compose (e.g. .env.run).
- * @async
- * @param {string} composeCmdBase - Base compose command
- * @param {string} composePath - Path to compose file
- * @param {Object} env - Environment variables for the child process
- * @param {boolean} debug - Enable debug logging
- */
-async function executeComposeUp(composeCmdBase, composePath, env, debug) {
-  const composeCmd = `${composeCmdBase} -f "${composePath}" up -d`;
-  if (debug) {
-    logger.log(chalk.gray(`[DEBUG] Executing: ${composeCmd}`));
-    logger.log(chalk.gray(`[DEBUG] Compose file: ${composePath}`));
-  }
-  await execAsync(composeCmd, { env });
-}
-
-/**
- * Starts the container and waits for health check. Deletes run .env files after success (ISO 27K).
- * @async
- * @param {string} appName - Application name
- * @param {string} composePath - Path to Docker Compose file
- * @param {number} port - Application port
- * @param {Object} appConfig - Application configuration
- * @param {Object} [opts] - Options
- * @param {boolean} [opts.debug=false] - Enable debug logging
- * @param {string|null} [opts.runEnvPath=null] - Path to .env.run (app-only) to delete after successful start
- * @param {string|null} [opts.runEnvAdminPath=null] - Path to .env.run.admin (start-only) to delete after successful start
- * @throws {Error} If container fails to start or become healthy
- */
-async function startContainer(appName, composePath, port, appConfig = null, opts = {}) {
-  const { debug = false, runEnvPath = null, runEnvAdminPath = null } = opts;
-  logger.log(chalk.blue(`Starting ${appName}...`));
-
-  const composeCmdBase = await dockerUtils.ensureDockerAndCompose().then(() => dockerUtils.getComposeCommand());
-  const env = await prepareContainerEnv(debug);
-  await executeComposeUp(composeCmdBase, composePath, env, debug);
-
-  const idNum = typeof appConfig.developerId === 'string' ? parseInt(appConfig.developerId, 10) : appConfig.developerId;
-  const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${appConfig.developerId}-${appName}`;
-  logger.log(chalk.green(`✓ Container ${containerName} started`));
-  await containerHelpers.logContainerStatus(containerName, debug);
-
-  const healthCheckPath = appConfig?.healthCheck?.path || '/health';
-  logger.log(chalk.blue(`Waiting for application to be healthy at http://localhost:${port}${healthCheckPath}...`));
-  await waitForHealthCheck(appName, 90, port, appConfig, debug);
-
-  for (const p of [runEnvPath, runEnvAdminPath]) {
-    if (p && typeof p === 'string') {
-      try {
-        await fs.unlink(p);
-      } catch (err) {
-        if (err.code !== 'ENOENT') logger.log(chalk.yellow(`Warning: could not remove run .env: ${err.message}`));
-      }
-    }
-  }
-}
-
 /**
  * Displays run status after successful start
  * @param {string} appName - Application name
  * @param {number} port - Application port
  * @param {Object} appConfig - Application configuration (with developerId property)
  */
-async function displayRunStatus(appName, port, appConfig) {
-  const idNum = typeof appConfig.developerId === 'string' ? parseInt(appConfig.developerId, 10) : appConfig.developerId;
-  const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${appConfig.developerId}-${appName}`;
+async function displayRunStatus(appName, port, appConfig, runScopeOpts = null) {
+  const containerName = containerHelpers.getContainerName(appName, appConfig.developerId, runScopeOpts);
   const healthCheckPath = appConfig?.healthCheck?.path || '/health';
   const healthCheckUrl = `http://localhost:${port}${healthCheckPath}`;
 
-  logger.log(chalk.green(`\n✓ App running at http://localhost:${port}`));
+  logger.log(formatSuccessParagraph(`App running at http://localhost:${port}`));
   logger.log(chalk.blue(`Health check: ${healthCheckUrl}`));
   logger.log(chalk.gray(`Container: ${containerName}`));
 }

package/lib/app/run-infra-requirements.js

@@ -0,0 +1,30 @@
+/**
+ * Derives local infra (Postgres/Redis) needs from application.yaml for `run`.
+ *
+ * @fileoverview Shared by infra health skip and docker-run-without-compose fallback
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+/**
+ * Reads application.yaml `requires` to decide which local infra services apply.
+ * Missing `requires` → null (legacy: assume Postgres + Redis may be required).
+ *
+ * @param {Object} appConfig - Application configuration from application.yaml
+ * @returns {null|{ needsPostgres: boolean, needsRedis: boolean }}
+ */
+function getAppInfraRequirements(appConfig) {
+  const r = appConfig && appConfig.requires;
+  if (!r || typeof r !== 'object') {
+    return null;
+  }
+  const needsPostgres =
+    r.database === true ||
+    (Array.isArray(r.databases) && r.databases.length > 0);
+  const needsRedis = r.redis === true;
+  return { needsPostgres, needsRedis };
+}
+
+module.exports = { getAppInfraRequirements };

package/lib/app/run-resolve-image.js

@@ -0,0 +1,21 @@
+/**
+ * Resolve Docker image name/tag for run (config + optional --image / --registry overrides).
+ *
+ * @fileoverview Shared by checkPrerequisites and container start / docker run fallback
+ */
+
+'use strict';
+
+const { resolveDockerImageRef } = require('../utils/resolve-docker-image-ref');
+
+/**
+ * @param {string} appName
+ * @param {Object} appConfig
+ * @param {Object} runOptions - runOptions.image / runOptions.registry override config
+ * @returns {{ imageName: string, imageTag: string }}
+ */
+function resolveRunImage(appName, appConfig, runOptions) {
+  return resolveDockerImageRef(appName, appConfig, runOptions);
+}
+
+module.exports = { resolveRunImage };

package/lib/app/run.js

@@ -10,8 +10,6 @@
  */
 
 const chalk = require('chalk');
-const { exec } = require('child_process');
-const { promisify } = require('util');
 const config = require('../core/config');
 const logger = require('../utils/logger');
 const pathsUtil = require('../utils/paths');
@@ -21,8 +19,7 @@ const containerHelpers = require('../utils/app-run-containers');
 const mutagen = require('../utils/mutagen');
 // Helper functions extracted to reduce file size and complexity
 const helpers = require('./run-helpers');
-
-const execAsync = promisify(exec);
+const { execWithDockerEnv } = require('../utils/docker-exec');
 
 /**
  * True if host is localhost or 127.0.0.1 (case-insensitive).
@@ -76,7 +73,7 @@ async function validateAppForRun(appName, _debug) {
   try {
     const { isExternal, baseDir } = await detectAppType(appName);
     if (baseDir !== 'builder' || isExternal) {
-      logger.log(chalk.yellow('⚠️  External systems don\'t run as Docker containers.'));
+      logger.log(chalk.yellow('⚠  External systems don\'t run as Docker containers.'));
       logger.log(chalk.blue('Use "aifabrix build" to deploy to dataplane, then test via OpenAPI endpoints.'));
       return false;
     }
@@ -98,17 +95,27 @@ async function validateAppForRun(appName, _debug) {
  * @param {boolean} debug - Debug flag
  * @returns {Promise<void>}
  */
-async function checkAndStopContainer(appName, developerId, debug) {
-  const containerRunning = await helpers.checkContainerRunning(appName, developerId, debug);
+async function checkAndStopContainer(appName, appConfig, options, debug) {
+  const developerId = appConfig.developerId;
+  const runEnvKey = (options.env || 'dev').toLowerCase();
+  const userCfg = await config.getConfig();
+  const { computeEffectiveEnvironmentScopedResources } = require('../utils/environment-scoped-resources');
+  const effectiveEnvironmentScopedResources = computeEffectiveEnvironmentScopedResources(
+    Boolean(userCfg.useEnvironmentScopedResources),
+    appConfig.environmentScopedResources === true,
+    runEnvKey
+  );
+  const scopeOpts = effectiveEnvironmentScopedResources
+    ? { effectiveEnvironmentScopedResources: true, env: runEnvKey }
+    : null;
+  const containerRunning = await helpers.checkContainerRunning(appName, developerId, debug, scopeOpts);
   if (!containerRunning) {
     return;
   }
 
-  // Dev 0: aifabrix-{appName} (no dev-0 suffix), Dev > 0: aifabrix-dev{id}-{appName}
-  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-  const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+  const containerName = containerHelpers.getContainerName(appName, developerId, scopeOpts);
   logger.log(chalk.yellow(`Container ${containerName} is already running`));
-  await helpers.stopAndRemoveContainer(appName, developerId, debug);
+  await helpers.stopAndRemoveContainer(appName, developerId, debug, scopeOpts);
 }
 
 /**
@@ -214,10 +221,24 @@ async function loadAndConfigureApp(appName, debug) {
  * @throws {Error} If container start fails
  */
 async function startAppContainer(appName, tempComposePath, hostPort, appConfig, opts) {
-  const { debug, runEnvPath = null, runEnvAdminPath = null } = opts;
+  const {
+    debug,
+    runEnvPath = null,
+    runEnvAdminPath = null,
+    runOptions = {},
+    devMountPath = null
+  } = opts;
+  const misoEnvironment = opts.misoEnvironment ?? composeGenerator.resolveMisoEnvironment(runOptions);
   try {
-    await helpers.startContainer(appName, tempComposePath, hostPort, appConfig, { debug, runEnvPath, runEnvAdminPath });
-    await helpers.displayRunStatus(appName, hostPort, appConfig);
+    await helpers.startContainer(appName, tempComposePath, hostPort, appConfig, {
+      debug,
+      runEnvPath,
+      runEnvAdminPath,
+      runOptions,
+      devMountPath,
+      misoEnvironment
+    });
+    await helpers.displayRunStatus(appName, hostPort, appConfig, opts.runScopeOpts || null);
   } catch (error) {
     logger.log(chalk.yellow(`\n⚠️  Compose file preserved at: ${tempComposePath}`));
     logger.log(chalk.yellow('   Review the file to debug issues'));
@@ -240,8 +261,12 @@ async function startAppContainer(appName, tempComposePath, hostPort, appConfig,
  * @param {boolean} debug - Debug flag
  * @returns {Promise<Object>} Run options with optional devMountPath
  */
-async function resolveRunOptions(appName, appConfig, options, envKey, debug) {
-  const runOptions = { ...options, env: envKey };
+async function resolveRunOptions(appName, appConfig, options, envKey, debug, effectiveEnvironmentScopedResources) {
+  const runOptions = {
+    ...options,
+    env: envKey,
+    effectiveEnvironmentScopedResources: Boolean(effectiveEnvironmentScopedResources)
+  };
   const builderPath = pathsUtil.getBuilderPath(appName);
   const codePath = pathsUtil.resolveBuildContext(builderPath, appConfig.build?.context || '.');
   if (options.reload && envKey === 'dev') {
@@ -269,12 +294,37 @@ async function prepareAppRun(appName, options, debug) {
     return null;
   }
   const appConfig = await loadAndConfigureApp(appName, debug);
+  const userCfg = await config.getConfig();
+  const { computeEffectiveEnvironmentScopedResources } = require('../utils/environment-scoped-resources');
+  const effectiveEnvironmentScopedResources = computeEffectiveEnvironmentScopedResources(
+    Boolean(userCfg.useEnvironmentScopedResources),
+    appConfig.environmentScopedResources === true,
+    envKey
+  );
+  const runScopeOpts = effectiveEnvironmentScopedResources
+    ? { effectiveEnvironmentScopedResources: true, env: envKey }
+    : null;
   await helpers.checkPrerequisites(appName, appConfig, debug, options.skipInfraCheck === true, options);
-  await checkAndStopContainer(appName, appConfig.developerId, debug);
+  await checkAndStopContainer(appName, appConfig, options, debug);
   const hostPort = await calculateHostPort(appConfig, options, debug);
-  const runOptions = await resolveRunOptions(appName, appConfig, options, envKey, debug);
+  const runOptions = await resolveRunOptions(
+    appName,
+    appConfig,
+    options,
+    envKey,
+    debug,
+    effectiveEnvironmentScopedResources
+  );
   const { composePath: tempComposePath, runEnvPath, runEnvAdminPath } = await helpers.prepareEnvironment(appName, appConfig, runOptions);
-  const result = { appConfig, tempComposePath, hostPort, runEnvPath, runEnvAdminPath };
+  const result = {
+    appConfig,
+    tempComposePath,
+    hostPort,
+    runEnvPath,
+    runEnvAdminPath,
+    runScopeOpts,
+    mergedRunOptions: runOptions
+  };
   if (runOptions.devMountPath) result.devMountPath = runOptions.devMountPath;
   return result;
 }
@@ -317,7 +367,10 @@ async function runApp(appName, options = {}) {
     await startAppContainer(appName, prepared.tempComposePath, prepared.hostPort, prepared.appConfig, {
       debug,
       runEnvPath: prepared.runEnvPath,
-      runEnvAdminPath: prepared.runEnvAdminPath
+      runEnvAdminPath: prepared.runEnvAdminPath,
+      runOptions: prepared.mergedRunOptions,
+      devMountPath: prepared.devMountPath,
+      runScopeOpts: prepared.runScopeOpts
     });
   } catch (error) {
     if (debug) {
@@ -347,7 +400,7 @@ async function restartApp(appName) {
   const developerId = await config.getDeveloperId();
   const containerName = containerHelpers.getContainerName(appName, developerId);
   try {
-    await execAsync(`docker restart ${containerName}`);
+    await execWithDockerEnv(`docker restart ${containerName}`);
   } catch (error) {
     const msg = (error.stderr || error.stdout || error.message || '').toLowerCase();
     if (msg.includes('no such container') || msg.includes('is not running')) {

package/lib/app/show-display.js

@@ -81,7 +81,7 @@ function logApplicationExternalIntegration(ei, options = {}) {
   logger.log(`    systems: [${(ei.systems || []).join(', ')}]`);
   logger.log(`    dataSources: [${(ei.dataSources || []).join(', ')}]`);
   if (!options.skipHint) {
-    logger.log(chalk.gray('\n  For external system data as on dataplane, run: aifabrix show <appKey> --online or aifabrix app show <appKey>.'));
+    logger.log(chalk.gray('\n  For external system data as on dataplane, run: aifabrix show <app> --online or aifabrix app show <app>.'));
   }
 }
 

package/lib/app/show.js

@@ -440,7 +440,7 @@ function formatBuildForDisplay(build) {
   if (!build) return '—';
   const parts = [];
   if (build.language) parts.push(build.language);
-  const port = build.port ?? build.localPort;
+  const port = build.port;
   if (port !== undefined && port !== null) parts.push(`port ${port}`);
   if (build.dockerfile) parts.push('dockerfile');
   if (build.envOutputPath) parts.push(`envOutputPath: ${build.envOutputPath}`);

package/lib/build/index.js

@@ -1,3 +1,4 @@
+const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
 /**
  * AI Fabrix Builder Build Functions
  *
@@ -127,7 +128,9 @@ async function generateDockerfile(appNameOrPath, language, config, buildConfig =
 
   const template = dockerfileUtils.loadDockerfileTemplate(language);
   const isAppFlag = buildConfig.context === '../..';
-  const appSourcePath = isAppFlag ? `apps/${appName}/` : '.';
+  // Use "./" (not ".") so Dockerfile lines are "COPY ./requirements*.txt" — a bare "."
+  // concatenates with "requirements" and becomes ".requirements*.txt", which matches nothing.
+  const appSourcePath = isAppFlag ? `apps/${appName}/` : './';
 
   const templateVars = {
     port: config.port || 3000,
@@ -185,11 +188,11 @@ async function generateDockerfile(appNameOrPath, language, config, buildConfig =
 async function postBuildTasks(appName, buildConfig) {
   try {
     const envPath = await secrets.generateEnvFile(appName, buildConfig.secrets, 'docker');
-    logger.log(chalk.green(`✓ Generated .env file: ${envPath}`));
+    logger.log(formatSuccessLine(`Generated .env file: ${envPath}`));
     // Note: processEnvVariables is already called by generateEnvFile to generate local .env
     // at the envOutputPath, so we don't need to manually copy the docker .env file
   } catch (error) {
-    logger.log(chalk.yellow(`⚠️  Warning: Could not generate .env file: ${error.message}`));
+    logger.log(chalk.yellow(`⚠  Warning: Could not generate .env file: ${error.message}`));
   }
 }
 
@@ -229,7 +232,7 @@ async function copyApplicationSourceFiles(appName, devDir) {
   const appsPath = path.join(process.cwd(), 'apps', appName);
   if (fsSync.existsSync(appsPath)) {
     await buildCopy.copyAppSourceFiles(appsPath, devDir);
-    logger.log(chalk.green(`✓ Copied application source files from apps/${appName}`));
+    logger.log(formatSuccessLine(`Copied application source files from apps/${appName}`));
     return true;
   }
   return false;
@@ -253,12 +256,12 @@ async function copyTemplateFilesIfNeeded(devDir, language, buildConfig, options)
     const projectRoot = getProjectRoot();
     const templatePath = path.join(projectRoot, 'templates', 'typescript');
     await buildCopy.copyTemplateFilesToDevDir(templatePath, devDir, detectedLanguage);
-    logger.log(chalk.green(`✓ Generated application files from ${detectedLanguage} template`));
+    logger.log(formatSuccessLine(`Generated application files from ${detectedLanguage} template`));
   } else if (detectedLanguage === 'python' && !fsSync.existsSync(requirementsPath)) {
     const projectRoot = getProjectRoot();
     const templatePath = path.join(projectRoot, 'templates', 'python');
     await buildCopy.copyTemplateFilesToDevDir(templatePath, devDir, detectedLanguage);
-    logger.log(chalk.green(`✓ Generated application files from ${detectedLanguage} template`));
+    logger.log(formatSuccessLine(`Generated application files from ${detectedLanguage} template`));
   }
 }
 
@@ -268,7 +271,7 @@ async function prepareDevDirectory(appName, buildConfig, options) {
   const directoryName = idNum === 0 ? 'applications' : `dev-${developerId}`;
   logger.log(chalk.blue(`Copying files to developer-specific directory (${directoryName})...`));
   const devDir = await buildCopy.copyBuilderToDevDirectory(appName, developerId);
-  logger.log(chalk.green(`✓ Files copied to: ${devDir}`));
+  logger.log(formatSuccessLine(`Files copied to: ${devDir}`));
 
   const { config: appConfig, imageName } = await buildHelpers.loadAndValidateConfig(appName);
   const effectiveImageName = buildDevImageName(imageName, developerId);
@@ -294,7 +297,7 @@ function prepareBuildContext(buildConfig, devDir) {
   // Check if context is using old format (../appName) - these are incompatible with dev directory structure
   if (buildConfig.context && buildConfig.context.startsWith('../') && buildConfig.context !== '../..') {
     // Old format detected - always use devDir instead
-    logger.log(chalk.yellow(`⚠️  Warning: Build context uses old format: ${buildConfig.context}`));
+    logger.log(chalk.yellow(`⚠  Warning: Build context uses old format: ${buildConfig.context}`));
     logger.log(chalk.yellow(`   Using dev directory instead: ${devDir}`));
     contextPath = devDir;
   } else if (buildConfig.context && buildConfig.context !== '../..') {
@@ -353,7 +356,7 @@ async function handleDockerfileGeneration(appName, params, options, buildHelpers
     language = 'typescript';
   }
   if (!hasExistingDockerfile) {
-    logger.log(chalk.green(`✓ Detected language: ${language}`));
+    logger.log(formatSuccessLine(`Detected language: ${language}`));
   }
 
   // Determine Dockerfile (needs context path to generate in correct location)
@@ -425,7 +428,7 @@ async function buildApp(appName, options = {}) {
     // 7. Post-build tasks
     await postBuildTasks(appName, buildConfig);
 
-    logger.log(chalk.green('\n✅ Build completed successfully!'));
+    logger.log(formatSuccessParagraph('Build completed successfully!'));
     return `${imageName}:${tag}`;
 
   } catch (error) {

package/lib/cli/index.js

@@ -17,6 +17,7 @@ const { setupEnvironmentCommands } = require('./setup-environment');
 const { setupUtilityCommands } = require('./setup-utility');
 const { setupDevCommands } = require('./setup-dev');
 const { setupSecretsCommands } = require('./setup-secrets');
+const { setupParametersCommands } = require('./setup-parameters');
 const { setupExternalSystemCommands } = require('./setup-external-system');
 const { setupAppCommands: setupAppManagementCommands } = require('../commands/app');
 const { setupDatasourceCommands } = require('../commands/datasource');
@@ -40,6 +41,7 @@ function setupCommands(program) {
   setupExternalSystemCommands(program);
   setupDevCommands(program);
   setupSecretsCommands(program);
+  setupParametersCommands(program);
 }
 
 module.exports = {