@aifabrix/builder 2.46.0 → 2.47.0

package/lib/api/wizard.api.js

@@ -205,6 +205,12 @@ async function getPlatformConfig(dataplaneUrl, authConfig, platformKey, config)
   });
 }
 
+/**
+ * Wizard AI generation can exceed the default 30s HTTP timeout (OpenAPI + LLM).
+ * @constant {number}
+ */
+const WIZARD_GENERATE_CONFIG_TIMEOUT_MS = 120000;
+
 /**
  * Generate configuration via AI (OpenAPI-based)
  * POST /api/v1/wizard/generate-config
@@ -235,7 +241,8 @@ async function getPlatformConfig(dataplaneUrl, authConfig, platformKey, config)
 async function generateConfig(dataplaneUrl, authConfig, config) {
   const client = createDataplaneApiClient(dataplaneUrl, authConfig);
   return await client.post('/api/v1/wizard/generate-config', {
-    body: config
+    body: config,
+    timeoutMs: WIZARD_GENERATE_CONFIG_TIMEOUT_MS
   });
 }
 
@@ -254,7 +261,8 @@ async function generateConfig(dataplaneUrl, authConfig, config) {
 async function generateConfigStream(dataplaneUrl, authConfig, config) {
   const client = createDataplaneApiClient(dataplaneUrl, authConfig);
   return await client.post('/api/v1/wizard/generate-config-stream', {
-    body: config
+    body: config,
+    timeoutMs: WIZARD_GENERATE_CONFIG_TIMEOUT_MS
   });
 }
 

package/lib/app/down.js

@@ -18,6 +18,13 @@ const logger = require('../utils/logger');
 const config = require('../core/config');
 const helpers = require('./run-helpers');
 const { validateAppName } = require('./push');
+const buildCopy = require('../utils/build-copy');
+const {
+  getCeleryCompanionAppKeys,
+  loadBuilderApplicationConfig
+} = require('../utils/celery-companion-apps');
+const fsSync = require('fs');
+const path = require('path');
 
 /**
  * Executes a shell command asynchronously.
@@ -74,6 +81,53 @@ function getAppVolumeNameCandidates(appName, developerId) {
   return suffixes.map((suffix) => `aifabrix_dev${suffix}_${appName}_data`);
 }
 
+function buildVolumeRemovalCandidates(appName, developerId) {
+  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
+  const primaryName = getAppVolumeName(appName, developerId);
+  const legacyDev0Name = idNum === 0 ? `aifabrix_dev0_${appName}_data` : null;
+  return Array.from(new Set([primaryName, legacyDev0Name].filter(Boolean)));
+}
+
+async function removeVolumeIfPresent(volumeName) {
+  logger.log(chalk.yellow(`Removing volume ${volumeName}...`));
+  try {
+    await execAsync(`docker volume rm -f ${volumeName}`);
+    logger.log(formatSuccessLine(`Volume ${volumeName} removed`));
+  } catch (volErr) {
+    logger.log(chalk.gray(`Volume ${volumeName} not found or already removed`));
+  }
+}
+
+async function removeAppVolumes(appName, developerId) {
+  for (const volumeName of buildVolumeRemovalCandidates(appName, developerId)) {
+    await removeVolumeIfPresent(volumeName);
+  }
+}
+
+async function stopAppContainers(appName, companionKeys, developerId) {
+  const devDir = buildCopy.getDevDirectory(appName, developerId);
+  const composePath = path.join(devDir, 'docker-compose.yaml');
+
+  if (companionKeys.length > 0 && fsSync.existsSync(composePath)) {
+    try {
+      await execAsync(`docker compose -f "${composePath}" down`);
+      return;
+    } catch (composeErr) {
+      logger.log(chalk.gray(`Compose down: ${composeErr.message}; stopping containers individually`));
+      for (const companionKey of companionKeys) {
+        await helpers.stopAndRemoveContainer(companionKey, developerId, false);
+      }
+      await helpers.stopAndRemoveContainer(appName, developerId, false);
+      return;
+    }
+  }
+
+  await helpers.stopAndRemoveContainer(appName, developerId, false);
+  for (const companionKey of companionKeys) {
+    await helpers.stopAndRemoveContainer(companionKey, developerId, false);
+  }
+}
+
 /**
  * Stops and removes a specific application's container.
  * If --volumes is passed, attempts to remove the app's named Docker volume.
@@ -93,42 +147,20 @@ function getAppVolumeNameCandidates(appName, developerId) {
  */
 async function downApp(appName, options = {}) {
   try {
-    // Input validation
     if (!appName || typeof appName !== 'string') {
       throw new Error('Application name is required and must be a string');
     }
     validateAppName(appName);
 
     const volumes = !!options.volumes;
-
-    // Load developer ID
     const developerId = await config.getDeveloperId();
+    const appConfig = loadBuilderApplicationConfig(appName);
+    const companionKeys = getCeleryCompanionAppKeys(appName, appConfig);
 
-    // Stop and remove container (idempotent handling in helper logs when not running)
-    await helpers.stopAndRemoveContainer(appName, developerId, false);
+    await stopAppContainers(appName, companionKeys, developerId);
 
-    // Optionally remove named Docker volume (ignore if it doesn't exist)
     if (volumes) {
-      const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-      // Primary expected name
-      const primaryName = getAppVolumeName(appName, developerId);
-      // Legacy name used when devId \"0\" was treated as string in templates
-      const legacyDev0Name = idNum === 0 ? `aifabrix_dev0_${appName}_data` : null;
-      // Build list of candidates, unique and non-empty
-      const candidates = Array.from(
-        new Set([primaryName, legacyDev0Name].filter(Boolean))
-      );
-
-      for (const volumeName of candidates) {
-        logger.log(chalk.yellow(`Removing volume ${volumeName}...`));
-        try {
-          await execAsync(`docker volume rm -f ${volumeName}`);
-          logger.log(formatSuccessLine(`Volume ${volumeName} removed`));
-        } catch (volErr) {
-          // Swallow errors for missing volume; provide neutral message
-          logger.log(chalk.gray(`Volume ${volumeName} not found or already removed`));
-        }
-      }
+      await removeAppVolumes(appName, developerId);
     }
   } catch (error) {
     // Provide meaningful error while avoiding sensitive info

package/lib/app/index.js

@@ -93,7 +93,7 @@ function validateAppNameAndSetup(appName, options) {
 
   const initialType = options.type || 'external';
   const baseDir = getBaseDirForAppType(initialType);
-  const appPath = paths.getAppPath(appName, initialType);
+  const appPath = paths.getAppCreatePath(appName, initialType);
 
   return { initialType, baseDir, appPath };
 }
@@ -124,7 +124,7 @@ async function handleTemplateSetup(options) {
  */
 async function prepareFinalAppPath(appName, config, initialAppPath) {
   const finalBaseDir = getBaseDirForAppType(config.type);
-  const finalAppPath = paths.getAppPath(appName, config.type);
+  const finalAppPath = paths.getAppCreatePath(appName, config.type);
 
   // If path changed, validate the new path
   if (finalAppPath !== initialAppPath) {

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

@@ -10,6 +10,7 @@ const config = require('../core/config');
 const { resolveDockerImageRef } = require('../utils/resolve-docker-image-ref');
 const { checkImageExists } = require('../utils/app-run-containers');
 const { buildDevImageRepositoryPath } = require('../utils/image-name');
+const { wantsLocalDockerImageDiscovery } = require('../utils/build-resolve-image');
 
 /**
  * @param {string} appName
@@ -41,7 +42,7 @@ async function resolveRunImageWithLocalFallback(appName, appConfig, runOptions =
 
   const baseRef = resolveDockerImageRef(appName, appConfig, opts);
 
-  if (opts.base === true) {
+  if (opts.base === true || !wantsLocalDockerImageDiscovery(appConfig)) {
     return baseRef;
   }
 

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

@@ -0,0 +1,113 @@
+/**
+ * Stop running app containers (and celery companions) before `aifabrix run`.
+ *
+ * @fileoverview Pre-run container teardown for port reuse
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { formatWarningLine } = require('../utils/cli-test-layout-chalk');
+const config = require('../core/config');
+const logger = require('../utils/logger');
+const containerHelpers = require('../utils/app-run-containers');
+const helpers = require('./run-helpers');
+const { computeEffectiveEnvironmentScopedResources } = require('../utils/environment-scoped-resources');
+const { getCeleryCompanionAppKeys } = require('../utils/celery-companion-apps');
+
+/**
+ * @param {Object} appConfig
+ * @param {Object} options
+ * @returns {Promise<{ effectiveEnvironmentScopedResources: true, env: string }|null>}
+ */
+async function resolveRunScopeOpts(appConfig, options) {
+  const runEnvKey = (options.env || 'dev').toLowerCase();
+  const userCfg = await config.getConfig();
+  const effectiveEnvironmentScopedResources = computeEffectiveEnvironmentScopedResources(
+    Boolean(userCfg.useEnvironmentScopedResources),
+    appConfig.environmentScopedResources === true,
+    runEnvKey
+  );
+  if (!effectiveEnvironmentScopedResources) {
+    return null;
+  }
+  return { effectiveEnvironmentScopedResources: true, env: runEnvKey };
+}
+
+/**
+ * @param {string[]} companionKeys
+ * @param {string|number} developerId
+ * @param {boolean} debug
+ * @param {Object|null} scopeOpts
+ * @returns {Promise<string[]>}
+ */
+async function findRunningCompanionKeys(companionKeys, developerId, debug, scopeOpts) {
+  const running = [];
+  for (const companionKey of companionKeys) {
+    if (await helpers.checkContainerRunning(companionKey, developerId, debug, scopeOpts)) {
+      running.push(companionKey);
+    }
+  }
+  return running;
+}
+
+/**
+ * @param {string[]} companionKeys
+ * @param {string|number} developerId
+ * @param {boolean} debug
+ * @param {Object|null} scopeOpts
+ * @returns {Promise<void>}
+ */
+async function stopCompanionContainers(companionKeys, developerId, debug, scopeOpts) {
+  for (const companionKey of companionKeys) {
+    const companionName = containerHelpers.getContainerName(companionKey, developerId, scopeOpts);
+    logger.log(formatWarningLine(`Stopping companion container ${companionName}`));
+    await helpers.stopAndRemoveContainer(companionKey, developerId, debug, scopeOpts);
+  }
+}
+
+/**
+ * Check if container is running and stop it (and celery companions) if needed.
+ *
+ * @async
+ * @param {string} appName
+ * @param {Object} appConfig
+ * @param {Object} options
+ * @param {boolean} debug
+ * @returns {Promise<void>}
+ */
+async function checkAndStopContainer(appName, appConfig, options, debug) {
+  const developerId = appConfig.developerId;
+  const scopeOpts = await resolveRunScopeOpts(appConfig, options);
+  const companionKeys = getCeleryCompanionAppKeys(appName, appConfig);
+  const companionsToStop = await findRunningCompanionKeys(
+    companionKeys,
+    developerId,
+    debug,
+    scopeOpts
+  );
+  const containerRunning = await helpers.checkContainerRunning(
+    appName,
+    developerId,
+    debug,
+    scopeOpts
+  );
+  if (!containerRunning && companionsToStop.length === 0) {
+    return;
+  }
+  await stopCompanionContainers(companionsToStop, developerId, debug, scopeOpts);
+  if (!containerRunning) {
+    return;
+  }
+  const containerName = containerHelpers.getContainerName(appName, developerId, scopeOpts);
+  logger.log(formatWarningLine(`Container ${containerName} is already running`));
+  await helpers.stopAndRemoveContainer(appName, developerId, debug, scopeOpts);
+}
+
+module.exports = {
+  checkAndStopContainer,
+  resolveRunScopeOpts,
+  findRunningCompanionKeys,
+  stopCompanionContainers
+};

package/lib/app/run.js

@@ -27,6 +27,7 @@ const containerHelpers = require('../utils/app-run-containers');
 const helpers = require('./run-helpers');
 const { ensureReloadSync, logReloadDevSummary } = require('./run-reload-sync');
 const { logRestartDevMountSummary } = require('./restart-display');
+const { checkAndStopContainer } = require('./run-stop-containers');
 const { execWithDockerEnv } = require('../utils/docker-exec');
 const { isRunCliNoProxy } = require('../utils/run-cli-flags');
 
@@ -111,37 +112,6 @@ async function validateAppForRun(appName, _debug) {
   return true;
 }
 
-/**
- * Check if container is running and stop it if needed
- * @async
- * @param {string} appName - Application name
- * @param {number|string} developerId - Developer ID
- * @param {boolean} debug - Debug flag
- * @returns {Promise<void>}
- */
-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;
-  }
-
-  const containerName = containerHelpers.getContainerName(appName, developerId, scopeOpts);
-  logger.log(formatWarningLine(`Container ${containerName} is already running`));
-  await helpers.stopAndRemoveContainer(appName, developerId, debug, scopeOpts);
-}
-
 /**
  * Calculate host port and validate it's available
  * @async

package/lib/app/show-display.js

@@ -49,6 +49,40 @@ function logApplicationOptional(a) {
   });
 }
 
+function localRunProfileDiffers(application, localRunProfile) {
+  if (!localRunProfile || !application) return false;
+  if (localRunProfile.url && localRunProfile.url !== application.url) return true;
+  if (localRunProfile.internalUrl && localRunProfile.internalUrl !== application.internalUrl) {
+    return true;
+  }
+  return (
+    localRunProfile.port !== undefined &&
+    localRunProfile.port !== null &&
+    localRunProfile.port !== application.port
+  );
+}
+
+function logLocalRunProfileSection(summary) {
+  const local = summary.localRunProfile;
+  if (!local || summary.source !== 'online' || !localRunProfileDiffers(summary.application, local)) {
+    return;
+  }
+  logger.log('');
+  logger.log(chalk.gray('  Local run profile (docker manifest url://):'));
+  if (local.url && local.url !== summary.application.url) {
+    logger.log(chalk.gray(`    URL:           ${local.url}`));
+  }
+  if (local.internalUrl && local.internalUrl !== summary.application.internalUrl) {
+    logger.log(chalk.gray(`    Internal URL:  ${local.internalUrl}`));
+  }
+  if (local.port !== undefined && local.port !== summary.application.port) {
+    logger.log(chalk.gray(`    Port:          ${local.port}`));
+  }
+  logger.log(
+    chalk.gray('    Controller registry values above are what identity sync and pipeline use.')
+  );
+}
+
 function logApplicationFields(a) {
   logApplicationRequired(a);
   logApplicationOptional(a);
@@ -96,6 +130,7 @@ function logApplicationSection(a, summary) {
   } else {
     logApplicationFields(a);
   }
+  logLocalRunProfileSection(summary);
   if (summary.runReloadDefault && !summary.isExternal) {
     logger.log(`  ${'Run default:'.padEnd(16)} reload on (config)`);
   }

package/lib/app/show.js

@@ -54,10 +54,22 @@ function attachRunDefaultsFromUserConfig(summary, appKey, userCfg) {
 
 /**
  * Overlay `application.url` / `application.internalUrl` from declarative url:// rules (same profile as run `.env`, default `docker`).
- * Used for offline and **online** show so controller metadata does not stale local proxy/TLS hints.
+ * Offline: replaces URL fields for local run hints. Online: keeps controller registry on `application` and adds `localRunProfile` when it differs.
  * @param {Object} summary
  * @param {string} appKey
  */
+function portFromShowUrl(url) {
+  if (!url || typeof url !== 'string') return undefined;
+  try {
+    const parsed = new URL(url);
+    if (!parsed.port) return undefined;
+    const port = Number(parsed.port);
+    return Number.isFinite(port) ? port : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 async function attachDeclarativeUrlsToShowApplication(summary, appKey) {
   if (!summary || summary.isExternal) return;
   const t = summary.application && summary.application.type;
@@ -68,8 +80,24 @@ async function attachDeclarativeUrlsToShowApplication(summary, appKey) {
     const variablesPath = resolveApplicationConfigPath(appPath);
     const urls = await resolveDeclarativeShowUrlsForApp(appKey, appPath, variablesPath, 'docker');
     if (!urls) return;
+
+    const localPort = portFromShowUrl(urls.publicUrl);
+    const localRunProfile = {
+      url: urls.publicUrl,
+      internalUrl: urls.internalUrl,
+      port: localPort ?? summary.application.port
+    };
+
+    if (summary.source === 'online') {
+      summary.localRunProfile = localRunProfile;
+      return;
+    }
+
     summary.application.url = urls.publicUrl;
     summary.application.internalUrl = urls.internalUrl;
+    if (localPort !== undefined) {
+      summary.application.port = localPort;
+    }
   } catch {
     /* display-only */
   }
@@ -830,6 +858,9 @@ function outputOnlineJson(summary, permissionsOnly, manifestSource) {
     out.runReloadDefault = true;
   }
   out.runProxyDefault = Boolean(summary.runProxyDefault);
+  if (summary.localRunProfile) {
+    out.localRunProfile = summary.localRunProfile;
+  }
   if (summary.externalSystem !== undefined && summary.externalSystem !== null) {
     out.externalSystem = summary.externalSystem && summary.externalSystem.error
       ? { error: summary.externalSystem.error }

package/lib/build/index.js

@@ -33,10 +33,11 @@ const logger = require('../utils/logger');
 const dockerfileUtils = require('../utils/dockerfile-utils');
 const dockerBuild = require('../utils/docker-build');
 const buildCopy = require('../utils/build-copy');
-const { buildDevImageName } = require('../utils/image-name');
+const { resolveBuildDockerTagNames } = require('../utils/build-resolve-image');
 const buildHelpers = require('../utils/build-helpers');
 const secretsEnvWrite = require('../core/secrets-env-write');
 const { ensureRunSecretsForApp } = require('../app/run-env-compose');
+const { assertMisoControllerNpmSdkDeps } = require('./miso-controller-npm-sdk-guard');
 
 /**
  * Loads application config for an application
@@ -286,8 +287,15 @@ async function prepareDevDirectory(appName, buildConfig, options) {
   const devDir = await buildCopy.copyBuilderToDevDirectory(appName, developerId);
   logger.log(formatSuccessLine(`Workspace ready: ${devDir}`));
 
-  const { config: appConfig, imageName } = await buildHelpers.loadAndValidateConfig(appName);
-  const effectiveImageName = buildDevImageName(imageName, developerId);
+  const { config: appConfig } = await buildHelpers.loadAndValidateConfig(appName);
+  const { buildImageName, compatBaseName } = await resolveBuildDockerTagNames(
+    appName,
+    appConfig,
+    developerId,
+    options
+  );
+  const effectiveImageName = buildImageName;
+  const imageName = compatBaseName || buildImageName;
 
   // Check if application source files exist, if not copy from templates
   const filesCopied = await copyApplicationSourceFiles(appName, devDir);
@@ -389,9 +397,10 @@ async function handleDockerfileGeneration(appName, params, options, buildHelpers
 /**
  * Resolve Docker build-args from resolved env map and merged BASH_* secrets.
  * @param {string} appName
+ * @param {string} [contextPath] Docker build context (repo root for miso-controller)
  * @returns {Promise<Object.<string, string>>}
  */
-async function resolveDockerBuildArgsForApp(appName) {
+async function resolveDockerBuildArgsForApp(appName, contextPath) {
   const envMap = await secretsEnvWrite.resolveAndGetEnvMap(appName, { environment: 'docker' });
   const { getBashPrefixedProcessEnvOverlay } = require('../utils/bash-secret-env');
   const bashOverlay = await getBashPrefixedProcessEnvOverlay(null, appName);
@@ -406,6 +415,9 @@ async function resolveDockerBuildArgsForApp(appName) {
   const shellPypi = typeof process.env.PYPI_TOKEN === 'string' ? process.env.PYPI_TOKEN.trim() : '';
   if (shellNpm) buildArgs.NPM_TOKEN = shellNpm;
   if (shellPypi) buildArgs.PYPI_TOKEN = shellPypi;
+  if (appName === 'miso-controller' && contextPath) {
+    assertMisoControllerNpmSdkDeps(path.resolve(contextPath));
+  }
   return buildArgs;
 }
 
@@ -429,7 +441,7 @@ async function runStandardDockerBuild(appName, options) {
     appConfig
   }, options, buildHelpers);
   await ensureRunSecretsForApp(appName);
-  const buildArgs = await resolveDockerBuildArgsForApp(appName);
+  const buildArgs = await resolveDockerBuildArgsForApp(appName, contextPath);
   const buildOptions = { ...options, buildArgs };
   const tag = options.tag || 'latest';
   if (typeof tag === 'string' && tag.includes(',')) {

package/lib/build/miso-controller-npm-sdk-guard.js

@@ -0,0 +1,25 @@
+/**
+ * Ensure miso-controller SDK deps are npm semver before Docker build (no file: vendor hacks).
+ * @fileoverview miso-controller npm SDK guard for builder
+ */
+
+const { execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * @param {string} repoRoot - aifabrix-miso repo root (Docker build context)
+ * @throws {Error} When guard script is missing or deps use file:
+ */
+function assertMisoControllerNpmSdkDeps(repoRoot) {
+  const script = path.join(
+    repoRoot,
+    'packages/miso-controller/scripts/assert-npm-sdk-deps.js'
+  );
+  if (!fs.existsSync(script)) {
+    throw new Error(`miso-controller SDK guard not found: ${script}`);
+  }
+  execFileSync('node', [script], { cwd: repoRoot, stdio: 'inherit' });
+}
+
+module.exports = { assertMisoControllerNpmSdkDeps };