@aifabrix/builder 2.42.1 → 2.44.0

package/lib/utils/app-run-containers.js

@@ -1,3 +1,4 @@
+const { formatSuccessLine } = require('./cli-test-layout-chalk');
 /**
  * AI Fabrix Builder - App Run Container Helpers
  *
@@ -9,12 +10,13 @@
  * @version 2.0.0
  */
 
-const { exec } = require('child_process');
-const { promisify } = require('util');
 const chalk = require('chalk');
 const logger = require('./logger');
-
-const execAsync = promisify(exec);
+const { execWithDockerEnv } = require('./docker-exec');
+const {
+  resolveRunContainerName,
+  buildDefaultLocalContainerName
+} = require('./environment-scoped-resources');
 
 /**
  * Checks if Docker image exists for the application
@@ -30,7 +32,7 @@ async function checkImageExists(imageName, tag = 'latest', debug = false) {
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Executing: ${cmd}`));
     }
-    const { stdout } = await execAsync(cmd);
+    const { stdout } = await execWithDockerEnv(cmd);
     const lines = stdout.trim().split('\n').filter(line => line.trim() !== '');
     const exists = lines.some(line => line.trim() === fullImageName);
     if (debug) {
@@ -57,11 +59,15 @@ async function checkImageExists(imageName, tag = 'latest', debug = false) {
  * @function getContainerName
  * @param {string} appName - Application name
  * @param {number|string} developerId - Developer ID
+ * @param {{ effectiveEnvironmentScopedResources?: boolean, env?: string }|null} [scopeOpts] - When set (run --env dev|tst + gates), uses env-scoped name
  * @returns {string} Container name
  */
-function getContainerName(appName, developerId) {
+function getContainerName(appName, developerId, scopeOpts = null) {
   const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-  return idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+  if (scopeOpts && scopeOpts.effectiveEnvironmentScopedResources && scopeOpts.env) {
+    return resolveRunContainerName(appName, developerId, true, scopeOpts.env);
+  }
+  return buildDefaultLocalContainerName(appName, developerId, idNum);
 }
 
 /**
@@ -72,21 +78,21 @@ function getContainerName(appName, developerId) {
  */
 async function logContainerDebugInfo(containerName) {
   const statusCmd = `docker ps --filter "name=${containerName}" --format "{{.Status}}"`;
-  const { stdout: status } = await execAsync(statusCmd);
+  const { stdout: status } = await execWithDockerEnv(statusCmd);
   const portsCmd = `docker ps --filter "name=${containerName}" --format "{{.Ports}}"`;
-  const { stdout: ports } = await execAsync(portsCmd);
+  const { stdout: ports } = await execWithDockerEnv(portsCmd);
   logger.log(chalk.gray(`[DEBUG] Container status: ${status.trim()}`));
   logger.log(chalk.gray(`[DEBUG] Container ports: ${ports.trim()}`));
 }
 
-async function checkContainerRunning(appName, developerId, debug = false) {
+async function checkContainerRunning(appName, developerId, debug = false, scopeOpts = null) {
   try {
-    const containerName = getContainerName(appName, developerId);
+    const containerName = getContainerName(appName, developerId, scopeOpts);
     const cmd = `docker ps --filter "name=${containerName}" --format "{{.Names}}"`;
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Executing: ${cmd}`));
     }
-    const { stdout } = await execAsync(cmd);
+    const { stdout } = await execWithDockerEnv(cmd);
     const isRunning = stdout.trim() === containerName;
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Container ${containerName} running: ${isRunning}`));
@@ -109,28 +115,26 @@ async function checkContainerRunning(appName, developerId, debug = false) {
  * @param {number|string} developerId - Developer ID (0 = default infra, > 0 = developer-specific; string allowed)
  * @param {boolean} [debug=false] - Enable debug logging
  */
-async function stopAndRemoveContainer(appName, developerId, debug = false) {
+async function stopAndRemoveContainer(appName, developerId, debug = false, scopeOpts = null) {
   try {
-    const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-    const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+    const containerName = getContainerName(appName, developerId, scopeOpts);
     logger.log(chalk.yellow(`Stopping existing container ${containerName}...`));
     const stopCmd = `docker stop ${containerName}`;
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Executing: ${stopCmd}`));
     }
-    await execAsync(stopCmd);
+    await execWithDockerEnv(stopCmd);
     const rmCmd = `docker rm ${containerName}`;
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Executing: ${rmCmd}`));
     }
-    await execAsync(rmCmd);
-    logger.log(chalk.green(`✓ Container ${containerName} stopped and removed`));
+    await execWithDockerEnv(rmCmd);
+    logger.log(formatSuccessLine(`Container ${containerName} stopped and removed`));
   } catch (error) {
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Stop/remove container error: ${error.message}`));
     }
-    const idNum2 = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-    const containerName = idNum2 === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+    const containerName = getContainerName(appName, developerId, scopeOpts);
     logger.log(chalk.gray(`Container ${containerName} was not running`));
   }
 }
@@ -144,9 +148,9 @@ async function stopAndRemoveContainer(appName, developerId, debug = false) {
 async function logContainerStatus(containerName, debug) {
   if (debug) {
     const statusCmd = `docker ps --filter "name=${containerName}" --format "{{.Status}}"`;
-    const { stdout: status } = await execAsync(statusCmd);
+    const { stdout: status } = await execWithDockerEnv(statusCmd);
     const portsCmd = `docker ps --filter "name=${containerName}" --format "{{.Ports}}"`;
-    const { stdout: ports } = await execAsync(portsCmd);
+    const { stdout: ports } = await execWithDockerEnv(portsCmd);
     logger.log(chalk.gray(`[DEBUG] Container status: ${status.trim()}`));
     logger.log(chalk.gray(`[DEBUG] Container ports: ${ports.trim()}`));
   }

package/lib/utils/app-scoped-config.js

@@ -0,0 +1,31 @@
+/**
+ * Read per-application environmentScopedResources from application.yaml (or json).
+ *
+ * @fileoverview Plan 117 application gate
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { loadConfigFile } = require('./config-format');
+const { resolveApplicationConfigPath } = require('./app-config-resolver');
+
+/**
+ * @param {string|null|undefined} appPath - Builder app directory
+ * @returns {boolean} True when application.yaml sets environmentScopedResources: true
+ */
+function readAppEnvironmentScopedFlagForAppPath(appPath) {
+  if (!appPath || typeof appPath !== 'string') {
+    return false;
+  }
+  try {
+    const cfgPath = resolveApplicationConfigPath(appPath);
+    const cfg = loadConfigFile(cfgPath);
+    return cfg.environmentScopedResources === true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = { readAppEnvironmentScopedFlagForAppPath };

package/lib/utils/app-service-env-from-builder.js

@@ -0,0 +1,164 @@
+/**
+ * Derive PREFIX_HOST, PREFIX_PORT, PREFIX_PUBLIC_PORT from each builder app application.yaml.
+ * Merged after infra + legacy static fallbacks so workspace manifests override hardcoded defaults.
+ *
+ * @fileoverview Plan 126 — app connectivity from YAML when present
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const yaml = require('js-yaml');
+const fsRealSync = require('../internal/fs-real-sync');
+const { localHostPort } = require('./declarative-url-ports');
+
+/**
+ * Maps application.yaml `app.key` to env var prefix (MISO_HOST, DATAPLANE_PORT, …).
+ * Generic keys not listed are skipped (no guessed PREFIX).
+ */
+const APP_KEY_TO_ENV_PREFIX = Object.freeze({
+  dataplane: 'DATAPLANE',
+  keycloak: 'KEYCLOAK',
+  'miso-controller': 'MISO',
+  'mori-controller': 'MORI',
+  openwebui: 'OPENWEBUI',
+  flowise: 'FLOWISE'
+});
+
+/**
+ * @param {object|null|undefined} doc
+ * @returns {number|null}
+ */
+function manifestPortOrNull(doc) {
+  if (!doc || typeof doc !== 'object') {
+    return null;
+  }
+  if (typeof doc.port === 'number' && doc.port > 0) {
+    return doc.port;
+  }
+  if (typeof doc.port === 'string' && /^\d+$/.test(doc.port.trim())) {
+    return parseInt(doc.port.trim(), 10);
+  }
+  return null;
+}
+
+/**
+ * In-container listen port (same rules as port-resolver; no require to avoid infra↔resolver cycle).
+ * @param {object} doc
+ * @param {number} manifestPort
+ * @returns {number}
+ */
+function containerListenFromDoc(doc, manifestPort) {
+  const cp = doc.build && doc.build.containerPort;
+  const useMain =
+    cp === undefined ||
+    cp === null ||
+    (typeof cp === 'string' && cp.trim() === '');
+  if (!useMain && typeof cp === 'number' && cp > 0) {
+    return cp;
+  }
+  if (!useMain && typeof cp === 'string' && /^\d+$/.test(cp.trim())) {
+    return parseInt(cp.trim(), 10);
+  }
+  return manifestPort;
+}
+
+/**
+ * Local workstation ports: manifest-only when published ≠ container (e.g. Keycloak); else port+10 rule.
+ * @param {object} doc
+ * @returns {{ port: number, publicPort: number }}
+ */
+function localWorkstationPortsForDoc(doc) {
+  const manifest = manifestPortOrNull(doc);
+  if (manifest === null) {
+    return { port: 0, publicPort: 0 };
+  }
+  const container = containerListenFromDoc(doc, manifest);
+  if (container === manifest) {
+    const p = localHostPort(manifest, 0);
+    return { port: p, publicPort: p };
+  }
+  return { port: manifest, publicPort: manifest };
+}
+
+/**
+ * @param {Record<string, unknown>} overlayDocker
+ * @param {Record<string, unknown>} overlayLocal
+ * @param {object} doc
+ * @param {string} folderName
+ */
+function mergeDocIntoOverlay(overlayDocker, overlayLocal, doc, folderName) {
+  const appKey = (doc.app && doc.app.key) || folderName;
+  const prefix = APP_KEY_TO_ENV_PREFIX[appKey];
+  if (!prefix) {
+    return;
+  }
+  const manifestPort = manifestPortOrNull(doc);
+  if (manifestPort === null || manifestPort <= 0) {
+    return;
+  }
+  const containerPort = containerListenFromDoc(doc, manifestPort);
+  const localP = localWorkstationPortsForDoc(doc);
+  overlayDocker[`${prefix}_HOST`] = appKey;
+  overlayDocker[`${prefix}_PORT`] = containerPort;
+  overlayDocker[`${prefix}_PUBLIC_PORT`] = manifestPort;
+  overlayLocal[`${prefix}_HOST`] = 'localhost';
+  overlayLocal[`${prefix}_PORT`] = localP.port;
+  overlayLocal[`${prefix}_PUBLIC_PORT`] = localP.publicPort;
+}
+
+/**
+ * @param {string} projectRoot
+ * @returns {Array<{ doc: object, folderName: string }>}
+ */
+function listBuilderApplicationDocs(projectRoot) {
+  const builderDir = path.join(projectRoot, 'builder');
+  if (!fsRealSync.existsSync(builderDir) || !fsRealSync.statSync(builderDir).isDirectory()) {
+    return [];
+  }
+  const out = [];
+  for (const ent of fsRealSync.readdirSync(builderDir, { withFileTypes: true })) {
+    if (!ent.isDirectory()) {
+      continue;
+    }
+    const cfg = path.join(builderDir, ent.name, 'application.yaml');
+    if (!fsRealSync.existsSync(cfg)) {
+      continue;
+    }
+    let doc;
+    try {
+      doc = yaml.load(fsRealSync.readFileSync(cfg, 'utf8'));
+    } catch {
+      continue;
+    }
+    if (doc && typeof doc === 'object') {
+      out.push({ doc, folderName: ent.name });
+    }
+  }
+  return out;
+}
+
+/**
+ * @param {string|null|undefined} projectRoot
+ * @returns {{ docker: Record<string, unknown>, local: Record<string, unknown> }}
+ */
+function buildAppServiceEnvOverlay(projectRoot) {
+  const overlayDocker = {};
+  const overlayLocal = {};
+  if (!projectRoot || !fsRealSync.existsSync(projectRoot)) {
+    return { docker: overlayDocker, local: overlayLocal };
+  }
+  for (const { doc, folderName } of listBuilderApplicationDocs(projectRoot)) {
+    mergeDocIntoOverlay(overlayDocker, overlayLocal, doc, folderName);
+  }
+  return { docker: overlayDocker, local: overlayLocal };
+}
+
+module.exports = {
+  APP_KEY_TO_ENV_PREFIX,
+  buildAppServiceEnvOverlay,
+  localWorkstationPortsForDoc,
+  manifestPortOrNull
+};

package/lib/utils/build-copy.js

@@ -28,7 +28,7 @@ const paths = require('./paths');
  *
  * @example
  * const devPath = await copyBuilderToDevDirectory('myapp', 1);
- * // Returns: '~/.aifabrix/applications-dev-1'
+ * // Returns: '<configDir>/applications-dev-1' (e.g. ~/.aifabrix/... when config lives there)
  */
 async function copyBuilderToDevDirectory(appName, developerId) {
   const builderPath = paths.getBuilderPath(appName);

package/lib/utils/build-helpers.js

@@ -9,10 +9,10 @@
  * @version 2.0.0
  */
 
+const { formatSuccessLine } = require('./cli-test-layout-chalk');
 const path = require('path');
 const dockerfileUtils = require('./dockerfile-utils');
 const logger = require('./logger');
-const chalk = require('chalk');
 
 /**
  * Determine Dockerfile path (template, custom, or generate)
@@ -26,23 +26,30 @@ async function determineDockerfile(appName, options, generateDockerfileFn) {
   // Use dev directory if provided, otherwise fall back to builder directory
   const searchPath = options.devDir || path.join(process.cwd(), 'builder', appName);
 
+  // Prefer application.yaml `build.dockerfile` over a stale Dockerfile copied into ~/.aifabrix/.../Dockerfile
+  const customDockerfile = dockerfileUtils.checkProjectDockerfile(
+    searchPath,
+    appName,
+    options.buildConfig,
+    options.contextPath,
+    options.forceTemplate
+  );
+  if (customDockerfile) {
+    logger.log(formatSuccessLine(`Using custom Dockerfile: ${options.buildConfig.dockerfile}`));
+    return customDockerfile;
+  }
+
   const templateDockerfile = dockerfileUtils.checkTemplateDockerfile(searchPath, appName, options.forceTemplate);
   if (templateDockerfile) {
     const relativePath = path.relative(process.cwd(), templateDockerfile);
-    logger.log(chalk.green(`✓ Using existing Dockerfile: ${relativePath}`));
+    logger.log(formatSuccessLine(`Using existing Dockerfile: ${relativePath}`));
     return templateDockerfile;
   }
 
-  const customDockerfile = dockerfileUtils.checkProjectDockerfile(searchPath, appName, options.buildConfig, options.contextPath, options.forceTemplate);
-  if (customDockerfile) {
-    logger.log(chalk.green(`✓ Using custom Dockerfile: ${options.buildConfig.dockerfile}`));
-    return customDockerfile;
-  }
-
   // Generate Dockerfile in dev directory if provided
   const dockerfilePath = await generateDockerfileFn(appName, options.language, options.config, options.buildConfig, options.devDir);
   const relativePath = path.relative(process.cwd(), dockerfilePath);
-  logger.log(chalk.green(`✓ Generated Dockerfile from template: ${relativePath}`));
+  logger.log(formatSuccessLine(`Generated Dockerfile from template: ${relativePath}`));
   return dockerfilePath;
 }
 
@@ -56,6 +63,8 @@ async function determineDockerfile(appName, options, generateDockerfileFn) {
 async function loadAndValidateConfig(appName) {
   const { loadVariablesYaml } = require('../build');
   const validator = require('../validation/validator');
+  const config = require('../core/config');
+  const { resolveBuildImageRepositoryName } = require('./build-resolve-image');
 
   const variables = await loadVariablesYaml(appName);
 
@@ -65,17 +74,8 @@ async function loadAndValidateConfig(appName) {
     throw new Error(`Configuration validation failed:\n${validation.errors.join('\n')}`);
   }
 
-  // Extract image name
-  let imageName;
-  if (typeof variables.image === 'string') {
-    imageName = variables.image.split(':')[0];
-  } else if (variables.image?.name) {
-    imageName = variables.image.name;
-  } else if (variables.app?.key) {
-    imageName = variables.app.key;
-  } else {
-    imageName = appName;
-  }
+  const developerId = await config.getDeveloperId();
+  const imageName = await resolveBuildImageRepositoryName(appName, variables, developerId);
 
   // Extract build config
   const buildConfig = variables.build || {};

package/lib/utils/build-resolve-image.js

@@ -0,0 +1,165 @@
+/**
+ * Resolve Docker image repository for `aifabrix build` from manifest or local Docker.
+ *
+ * @fileoverview When application.yaml omits image, discover repository from `docker images`
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('./logger');
+const { execWithDockerEnv } = require('./docker-exec');
+const {
+  resolveDockerImageRef,
+  getRepositoryPathFromConfig
+} = require('./resolve-docker-image-ref');
+
+/**
+ * True when build should try local Docker to infer the repository path.
+ * @param {Object} variables - Loaded application manifest
+ * @returns {boolean}
+ */
+function wantsLocalDockerImageDiscovery(variables) {
+  const img = variables && variables.image;
+  if (img === undefined || img === null) {
+    return true;
+  }
+  if (typeof img === 'string') {
+    return !img.trim();
+  }
+  if (typeof img !== 'object') {
+    return false;
+  }
+  return Object.keys(img).length === 0;
+}
+
+/**
+ * @param {string} repoPath
+ * @returns {string}
+ */
+function repositoryTail(repoPath) {
+  if (!repoPath || typeof repoPath !== 'string') {
+    return '';
+  }
+  const parts = repoPath.split('/');
+  return parts[parts.length - 1] || repoPath;
+}
+
+/**
+ * Strip dev-scoped or -extra suffix from a Docker repository path.
+ * @param {string} repo
+ * @returns {string}
+ */
+function baseRepositoryFromDevScoped(repo) {
+  const devMatch = repo.match(/^(.*)-dev\d+$/);
+  if (devMatch) {
+    return devMatch[1];
+  }
+  if (repo.endsWith('-extra')) {
+    return repo.slice(0, -'-extra'.length);
+  }
+  return repo;
+}
+
+/**
+ * @param {string} appName
+ * @param {string} repository - Docker repository (no tag)
+ * @returns {boolean}
+ */
+function repoMatchesAppName(appName, repository) {
+  const base = baseRepositoryFromDevScoped(repository);
+  if (repository === appName || base === appName) {
+    return true;
+  }
+  if (repositoryTail(base) === appName) {
+    return true;
+  }
+  if (repositoryTail(repository) === appName) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * @param {string} appName
+ * @param {string[]} lines - docker images output lines repository:tag
+ * @param {string|number} developerId
+ * @returns {string|null}
+ */
+function pickBaseFromDockerLines(appName, lines, developerId) {
+  const candidates = [];
+  for (const line of lines) {
+    if (!line || line.includes('<none>')) {
+      continue;
+    }
+    const colon = line.lastIndexOf(':');
+    const repository = colon > 0 ? line.slice(0, colon) : line;
+    if (!repository) {
+      continue;
+    }
+    if (!repoMatchesAppName(appName, repository)) {
+      continue;
+    }
+    candidates.push({
+      repository,
+      base: baseRepositoryFromDevScoped(repository)
+    });
+  }
+  if (!candidates.length) {
+    return null;
+  }
+  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : Number(developerId);
+  if (Number.isFinite(idNum) && idNum > 0) {
+    const suffix = `-dev${idNum}`;
+    const preferred = candidates.find((c) => c.repository.endsWith(suffix));
+    if (preferred) {
+      return preferred.base;
+    }
+  }
+  return candidates[0].base;
+}
+
+/**
+ * Infer repository path from local Docker images when manifest has no image block.
+ * @param {string} appName
+ * @param {string|number} developerId
+ * @returns {Promise<string|null>}
+ */
+async function discoverLocalBaseImageRepository(appName, developerId) {
+  try {
+    const { stdout } = await execWithDockerEnv(
+      'docker images --format "{{.Repository}}:{{.Tag}}"'
+    );
+    const lines = stdout.trim().split('\n').filter(Boolean);
+    return pickBaseFromDockerLines(appName, lines, developerId);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Repository path (may include registry prefix) used for `docker build -t`.
+ * @param {string} appName
+ * @param {Object} variables - application manifest
+ * @param {string|number} developerId
+ * @returns {Promise<string>}
+ */
+async function resolveBuildImageRepositoryName(appName, variables, developerId) {
+  if (!wantsLocalDockerImageDiscovery(variables)) {
+    return resolveDockerImageRef(appName, variables, {}).imageName;
+  }
+  const discovered = await discoverLocalBaseImageRepository(appName, developerId);
+  if (discovered) {
+    logger.log(chalk.blue(`Using image repository from local Docker: ${discovered}`));
+    return discovered;
+  }
+  return getRepositoryPathFromConfig(variables, appName);
+}
+
+module.exports = {
+  resolveBuildImageRepositoryName,
+  wantsLocalDockerImageDiscovery,
+  pickBaseFromDockerLines
+};

package/lib/utils/cli-layout-chalk.js

@@ -0,0 +1,8 @@
+/**
+ * @fileoverview Re-export of CLI layout chalk helpers (same API as cli-test-layout-chalk).
+ * Prefer this path for non-test modules; see `.cursor/plans/layout.md` contributor appendix.
+ */
+
+'use strict';
+
+module.exports = require('./cli-test-layout-chalk');