@aifabrix/builder 2.42.1 → 2.44.0

package/lib/app/run-env-compose.js

@@ -16,7 +16,6 @@ const pathsUtil = require('../utils/paths');
 const adminSecrets = require('../core/admin-secrets');
 const secretsEnvWrite = require('../core/secrets-env-write');
 const { getContainerPort } = require('../utils/port-resolver');
-const { getInfraDirName } = require('../infrastructure/helpers');
 
 /**
  * Clean applications directory: remove generated docker-compose.yaml and .env.* files.
@@ -58,12 +57,20 @@ function pgUserName(dbName) {
  * @param {Object} env - Merged env object (mutated)
  * @param {Object} appConfig - Application config (requires.databases or databases array)
  */
-function injectDatabaseNamesAndUsers(env, appConfig) {
+function injectDatabaseNamesAndUsers(env, appConfig, scopeOpts = null) {
   const databases = appConfig?.requires?.databases || appConfig?.databases;
   if (!Array.isArray(databases) || databases.length === 0) return;
+  const prefix =
+    scopeOpts &&
+    scopeOpts.effectiveEnvironmentScopedResources &&
+    scopeOpts.runEnvKey &&
+    (scopeOpts.runEnvKey === 'dev' || scopeOpts.runEnvKey === 'tst')
+      ? `${String(scopeOpts.runEnvKey).toLowerCase()}-`
+      : '';
   for (let i = 0; i < databases.length; i++) {
     const db = databases[i];
-    const name = db?.name || (appConfig?.app?.key || 'app');
+    const baseName = db?.name || (appConfig?.app?.key || 'app');
+    const name = prefix ? `${prefix}${baseName}` : baseName;
     env[`DB_${i}_NAME`] = name;
     env[`DB_${i}_USER`] = pgUserName(name);
   }
@@ -146,24 +153,6 @@ function buildDbInitOnlyEnv(merged) {
   return dbInit;
 }
 
-/**
- * Return pgpass paths under infra-dev* directories in aifabrix home (for fallback lookup).
- * @param {string} aifabrixDir - Aifabrix home directory
- * @returns {string[]} Paths to pgpass files
- */
-function getInfraDevPgpassPaths(aifabrixDir) {
-  if (!fsSync.existsSync(aifabrixDir)) return [];
-  let entries;
-  try {
-    entries = fsSync.readdirSync(aifabrixDir).sort();
-  } catch {
-    return [];
-  }
-  return entries
-    .filter((name) => name.startsWith('infra-dev'))
-    .map((name) => path.join(aifabrixDir, name, 'pgpass'));
-}
-
 /**
  * Read first password from a pgpass file (format host:port:db:user:password).
  * @param {string} pgpassPath - Path to pgpass file
@@ -178,34 +167,31 @@ async function readPasswordFromPgpassFile(pgpassPath) {
 }
 
 /**
- * Read POSTGRES_PASSWORD from an existing infra pgpass so db-init uses the same password as running Postgres.
- * Tries dev-specific, then default infra, then any infra-dev* dir (e.g. dev 1 run when only infra-dev06 has pgpass).
+ * Read POSTGRES_PASSWORD from `pgpass` next to the active infra compose (same as `resolveInfraStatePaths()`).
+ * Does not use `getAifabrixHome()` alone, so a stale pgpass under the wrong base directory (e.g. when
+ * `aifabrix-home` points at $HOME but compose lives under the config dir) cannot override admin-secrets.
  * @param {number|string} developerId - Developer ID
  * @returns {Promise<string|undefined>} Password or undefined
  */
 async function readPostgresPasswordFromPgpass(developerId) {
-  const home = pathsUtil.getAifabrixHome();
-  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-  const candidates = [path.join(home, getInfraDirName(developerId), 'pgpass')];
-  if (idNum !== 0) candidates.push(path.join(home, getInfraDirName(0), 'pgpass'));
-  const extra = getInfraDevPgpassPaths(home).filter((p) => !candidates.includes(p));
-  candidates.push(...extra);
-  for (const pgpassPath of candidates) {
-    if (!fsSync.existsSync(pgpassPath)) continue;
-    try {
-      const pwd = await readPasswordFromPgpassFile(pgpassPath);
-      if (pwd !== undefined) return pwd;
-    } catch {
-      // ignore
-    }
+  const { resolveInfraStatePaths } = require('../infrastructure/helpers');
+  const { infraDir } = resolveInfraStatePaths(developerId);
+  const pgpassPath = path.join(infraDir, 'pgpass');
+  if (!fsSync.existsSync(pgpassPath)) {
+    return undefined;
+  }
+  try {
+    const pwd = await readPasswordFromPgpassFile(pgpassPath);
+    return pwd;
+  } catch {
+    return undefined;
   }
-  return undefined;
 }
 
 /**
  * Build two run env files: .env.run (app-only, no admin secrets) and .env.run.admin (start-only, for db-init).
  * Admin password is never set in the app container; .env.run.admin is used only for start and then deleted.
- * When an infra pgpass exists, POSTGRES_PASSWORD is taken from it so db-init matches the running Postgres.
+ * When `pgpass` exists beside the active infra compose, POSTGRES_PASSWORD is taken from it so db-init matches Postgres.
  * @async
  * @param {string} appName - Application name
  * @param {Object} appConfig - Application configuration
@@ -213,24 +199,26 @@ async function readPostgresPasswordFromPgpass(developerId) {
  * @param {number|string} [developerId] - Developer ID (for pgpass lookup)
  * @returns {Promise<{ runEnvPath: string, runEnvAdminPath: string }>} Paths to .env.run and .env.run.admin
  */
-async function buildMergedRunEnvAndWrite(appName, appConfig, devDir, developerId) {
+async function buildMergedRunEnvAndWrite(appName, appConfig, devDir, developerId, scopeOpts = null) {
   const infra = require('../infrastructure');
   const ensureAdminSecretsFn = typeof infra.ensureAdminSecrets === 'function'
     ? infra.ensureAdminSecrets
     : require('../infrastructure/helpers').ensureAdminSecrets;
   await ensureAdminSecretsFn();
   const adminObj = await adminSecrets.readAndDecryptAdminSecrets();
+  const runEnvKey = scopeOpts && scopeOpts.runEnvKey ? String(scopeOpts.runEnvKey).toLowerCase() : 'dev';
   const appObj = await secretsEnvWrite.resolveAndGetEnvMap(appName, {
     environment: 'docker',
     secretsPath: null,
-    force: false
+    force: false,
+    runEnvKey
   });
   const merged = { ...adminObj, ...appObj };
   if (developerId !== undefined) {
     const pgpassPwd = await readPostgresPasswordFromPgpass(developerId);
     if (pgpassPwd !== undefined) merged.POSTGRES_PASSWORD = pgpassPwd;
   }
-  injectDatabaseNamesAndUsers(merged, appConfig);
+  injectDatabaseNamesAndUsers(merged, appConfig, scopeOpts);
   injectContainerPortForRun(merged, appConfig, appName);
 
   const runEnvPath = path.join(devDir, '.env.run');

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}`);