@aifabrix/builder 2.44.5 → 2.45.0

package/lib/app/run-reload-sync.js

@@ -0,0 +1,148 @@
+/**
+ * Mutagen sync for `aifabrix run --reload` when Docker runs on another host.
+ *
+ * @fileoverview ensureReloadSync extracted from run.js (size limits)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const { formatProgress } = require('../utils/cli-test-layout-chalk');
+const config = require('../core/config');
+const logger = require('../utils/logger');
+const mutagen = require('../utils/mutagen');
+const pathsUtil = require('../utils/paths');
+const {
+  isReloadBindMountOnEngineHost,
+  isLocalhostSyncSshHost
+} = require('../utils/docker-reload-mount');
+const { sectionTitle, headerKeyValue, metadata } = require('../utils/cli-test-layout-chalk');
+
+/**
+ * @typedef {Object} ReloadSyncSummaryBind
+ * @property {'bind-mount'} transport
+ * @property {string} hostPath - Host directory bind-mounted to /app in the container
+ */
+
+/**
+ * @typedef {Object} ReloadSyncSummaryMutagen
+ * @property {'mutagen'} transport
+ * @property {string} remotePath - Path on sync host used for Docker -v
+ * @property {string} sessionName - Mutagen session name
+ * @property {string} localPath - Local folder synced (same as build context)
+ * @property {string} syncSshHost - sync-ssh-host from config
+ * @property {string} sshUrl - Mutagen endpoint (user@host:path)
+ */
+
+/**
+ * @typedef {ReloadSyncSummaryBind|ReloadSyncSummaryMutagen} ReloadSyncSummary
+ */
+
+/**
+ * Install Mutagen if needed, create sync session, return summary for compose and UX.
+ * @param {string} appName
+ * @param {string} developerId
+ * @param {boolean} debug
+ * @param {string} codePath
+ * @param {string} [remoteSyncPath]
+ * @param {string} syncSshHost
+ * @returns {Promise<ReloadSyncSummaryMutagen>}
+ */
+async function startMutagenReloadSync(
+  appName,
+  developerId,
+  debug,
+  codePath,
+  remoteSyncPath,
+  syncSshHost
+) {
+  const [userMutagenFolder, syncSshUser] = await Promise.all([
+    config.getUserMutagenFolder(),
+    config.getSyncSshUser()
+  ]);
+  if (!userMutagenFolder || !syncSshUser || !syncSshHost) {
+    throw new Error(
+      'run --reload requires remote server sync settings. Run "aifabrix dev init" or set user-mutagen-folder, sync-ssh-user, sync-ssh-host in config.'
+    );
+  }
+  const mutagenPath = await mutagen.ensureMutagenPath(logger.log);
+  const remotePath = mutagen.getRemotePath(userMutagenFolder, appName, remoteSyncPath);
+  const sshUrl = mutagen.getSyncSshUrl(syncSshUser, syncSshHost, remotePath);
+  const sessionName = mutagen.getSessionName(developerId, appName);
+  const localPath = (codePath && typeof codePath === 'string') ? codePath : pathsUtil.getBuilderPath(appName);
+  if (debug) logger.log(chalk.gray(`[DEBUG] Mutagen sync: ${sessionName} ${localPath} <-> ${sshUrl}`));
+  logger.log(formatProgress('Reload: ensuring Mutagen sync (remote Docker engine)…'));
+  await mutagen.ensureSyncSession(mutagenPath, sessionName, localPath, sshUrl);
+  return {
+    transport: 'mutagen',
+    remotePath,
+    sessionName,
+    localPath,
+    syncSshHost,
+    sshUrl
+  };
+}
+
+/**
+ * When run --reload in dev with remote: ensure Mutagen sync session; return summary for mounts and CLI copy.
+ * Uses codePath (resolved build.context) as Mutagen local path so one config field drives both local and remote.
+ * Skips Mutagen when docker-endpoint targets this host (bind mount) or sync-ssh-host is localhost.
+ *
+ * @param {string} appName - Application name
+ * @param {string} developerId - Developer ID
+ * @param {boolean} debug - Debug flag
+ * @param {string} codePath - Resolved build.context (absolute path to app code)
+ * @param {string} [remoteSyncPath] - Optional relative path under user-mutagen-folder (from build.remoteSyncPath); when unset, defaults to dev/<appKey>
+ * @returns {Promise<ReloadSyncSummary>}
+ * @throws {Error} If --reload but remote not configured, or Mutagen install fails
+ */
+async function ensureReloadSync(appName, developerId, debug, codePath, remoteSyncPath) {
+  const endpoint = await config.getDockerEndpoint();
+  if (isReloadBindMountOnEngineHost(endpoint)) {
+    if (debug) {
+      logger.log(
+        chalk.gray('[DEBUG] Docker engine shares this host filesystem; skipping Mutagen for --reload')
+      );
+    }
+    return { transport: 'bind-mount', hostPath: codePath };
+  }
+  const syncSshHost = await config.getSyncSshHost();
+  if (isLocalhostSyncSshHost(syncSshHost || '')) {
+    if (debug) {
+      logger.log(chalk.gray('[DEBUG] sync-ssh-host is localhost; skipping Mutagen, using local path'));
+    }
+    return { transport: 'bind-mount', hostPath: codePath };
+  }
+  return startMutagenReloadSync(appName, developerId, debug, codePath, remoteSyncPath, syncSshHost);
+}
+
+/**
+ * Log how --reload is wired (bind vs Mutagen) after compose/env prep, before container start.
+ * @param {boolean} reload
+ * @param {ReloadSyncSummary|undefined} summary
+ */
+function logReloadDevSummary(reload, summary) {
+  if (!reload || !summary) {
+    return;
+  }
+  logger.log('');
+  logger.log(sectionTitle('Reload (dev)'));
+  if (summary.transport === 'bind-mount') {
+    logger.log(headerKeyValue('Transport:', 'Direct bind mount on the Docker host (no Mutagen).'));
+    logger.log(headerKeyValue('Host path → container:', `${summary.hostPath} → /app`));
+    logger.log(metadata('Edits under the host path are visible inside the container immediately.'));
+    logger.log('');
+    return;
+  }
+  logger.log(headerKeyValue('Transport:', 'Mutagen two-way sync (Docker engine on another host).'));
+  logger.log(headerKeyValue('Session:', summary.sessionName));
+  logger.log(headerKeyValue('Sync host:', summary.syncSshHost));
+  logger.log(headerKeyValue('Local folder:', summary.localPath));
+  logger.log(headerKeyValue('Remote mount (-v):', summary.remotePath));
+  logger.log(metadata(`Mutagen endpoint: ${summary.sshUrl}`));
+  logger.log('');
+}
+
+module.exports = { ensureReloadSync, logReloadDevSummary };

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

@@ -6,7 +6,10 @@
 
 'use strict';
 
+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');
 
 /**
  * @param {string} appName
@@ -18,4 +21,51 @@ function resolveRunImage(appName, appConfig, runOptions) {
   return resolveDockerImageRef(appName, appConfig, runOptions);
 }
 
-module.exports = { resolveRunImage };
+/**
+ * Resolves which local image to run: developer-scoped ref first when present, else manifest base.
+ * With {@link runOptions.base} true, uses manifest base only (no dev-first probe).
+ *
+ * @async
+ * @param {string} appName
+ * @param {Object} appConfig
+ * @param {Object} [runOptions]
+ * @param {string} [runOptions.image] - Full override (skips fallback logic)
+ * @param {boolean} [runOptions.base] - When true, manifest base ref only
+ * @returns {Promise<{ imageName: string, imageTag: string }>}
+ */
+async function resolveRunImageWithLocalFallback(appName, appConfig, runOptions = {}) {
+  const opts = runOptions || {};
+  if (opts.image) {
+    return resolveDockerImageRef(appName, appConfig, opts);
+  }
+
+  const baseRef = resolveDockerImageRef(appName, appConfig, opts);
+
+  if (opts.base === true) {
+    return baseRef;
+  }
+
+  const developerId = await config.getDeveloperId();
+  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
+  if (!Number.isFinite(idNum) || idNum === 0) {
+    return baseRef;
+  }
+
+  const tag = baseRef.imageTag;
+  const devRepo = buildDevImageRepositoryPath(baseRef.imageName, developerId);
+  const devExists = await checkImageExists(devRepo, tag, false);
+  if (devExists) {
+    return { imageName: devRepo, imageTag: tag };
+  }
+  const baseExists = await checkImageExists(baseRef.imageName, tag, false);
+  if (baseExists) {
+    return baseRef;
+  }
+
+  throw new Error(
+    `Docker image not found (tried ${devRepo}:${tag} then ${baseRef.imageName}:${tag})\n` +
+      `Run 'aifabrix build ${appName}' or pull the manifest image, or use --base after pulling the base image.`
+  );
+}
+
+module.exports = { resolveRunImage, resolveRunImageWithLocalFallback };

package/lib/app/run.js

@@ -10,16 +10,25 @@
  */
 
 const chalk = require('chalk');
+const {
+  formatWarningLine,
+  sectionTitle,
+  headerKeyValue,
+  metadata,
+  formatNextActions
+} = require('../utils/cli-test-layout-chalk');
 const config = require('../core/config');
 const logger = require('../utils/logger');
 const pathsUtil = require('../utils/paths');
 const { checkPortAvailable, waitForHealthCheck } = require('../utils/health-check');
 const composeGenerator = require('../utils/compose-generator');
 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 { ensureReloadSync, logReloadDevSummary } = require('./run-reload-sync');
+const { logRestartDevMountSummary } = require('./restart-display');
 const { execWithDockerEnv } = require('../utils/docker-exec');
+const { isRunCliNoProxy } = require('../utils/run-cli-flags');
 
 /**
  * True if host is localhost or 127.0.0.1 (case-insensitive).
@@ -60,7 +69,7 @@ function isLocalhostEndpoint(urlOrEndpoint) {
  * @async
  * @param {string} appName - Application name
  * @param {boolean} _debug - Debug flag (unused)
- * @returns {Promise<boolean>} True if should continue, false if external system
+ * @returns {Promise<boolean>} True if run should continue, false if app is integration-scoped or external (not a runnable container app)
  * @throws {Error} If app name is invalid
  */
 async function validateAppForRun(appName, _debug) {
@@ -73,8 +82,23 @@ 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.blue('Use "aifabrix build" to deploy to dataplane, then test via OpenAPI endpoints.'));
+      logger.log('');
+      logger.log(sectionTitle('Run'));
+      logger.log(headerKeyValue('Application:', appName));
+      logger.log(
+        formatWarningLine('External integrations are not started as local Docker containers.')
+      );
+      logger.log(
+        metadata(
+          'Publish config to the dataplane (upload) or through the controller (deploy), then use the integration APIs from your environment.'
+        )
+      );
+      logger.log(
+        formatNextActions([
+          `aifabrix upload ${appName}`,
+          `aifabrix deploy ${appName}`
+        ])
+      );
       return false;
     }
   } catch (error) {
@@ -114,7 +138,7 @@ async function checkAndStopContainer(appName, appConfig, options, debug) {
   }
 
   const containerName = containerHelpers.getContainerName(appName, developerId, scopeOpts);
-  logger.log(chalk.yellow(`Container ${containerName} is already running`));
+  logger.log(formatWarningLine(`Container ${containerName} is already running`));
   await helpers.stopAndRemoveContainer(appName, developerId, debug, scopeOpts);
 }
 
@@ -149,48 +173,6 @@ async function calculateHostPort(appConfig, options, debug) {
   return hostPort;
 }
 
-/**
- * When run --reload in dev with remote: ensure Mutagen sync session; return remote path for compose mount.
- * Uses codePath (resolved build.context) as Mutagen local path so one config field drives both local and remote.
- * When Docker endpoint, remote-server, or sync-ssh-host is localhost/127.0.0.1, returns null (no sync; use local path).
- *
- * @param {string} appName - Application name
- * @param {string} developerId - Developer ID
- * @param {boolean} debug - Debug flag
- * @param {string} codePath - Resolved build.context (absolute path to app code)
- * @param {string} [remoteSyncPath] - Optional relative path under user-mutagen-folder (from build.remoteSyncPath); when unset, defaults to dev/<appKey>
- * @returns {Promise<string|null>} Remote path for -v mount or null if not remote/reload or already on server (localhost)
- * @throws {Error} If --reload but remote not configured, or Mutagen install fails
- */
-async function ensureReloadSync(appName, developerId, debug, codePath, remoteSyncPath) {
-  const endpoint = await config.getDockerEndpoint();
-  const serverUrl = await config.getRemoteServer();
-  if (!endpoint && !serverUrl) return null;
-  const syncSshHost = await config.getSyncSshHost();
-  if (isLocalhostEndpoint(endpoint) || isLocalhostEndpoint(serverUrl) || isLocalhostHost(syncSshHost || '')) {
-    if (debug) logger.log(chalk.gray('[DEBUG] Docker/remote/sync host is localhost; skipping Mutagen, using local path'));
-    return null;
-  }
-  const [userMutagenFolder, syncSshUser] = await Promise.all([
-    config.getUserMutagenFolder(),
-    config.getSyncSshUser()
-  ]);
-  if (!userMutagenFolder || !syncSshUser || !syncSshHost) {
-    throw new Error(
-      'run --reload requires remote server sync settings. Run "aifabrix dev init" or set user-mutagen-folder, sync-ssh-user, sync-ssh-host in config.'
-    );
-  }
-  const mutagenPath = await mutagen.ensureMutagenPath(logger.log);
-  const remotePath = mutagen.getRemotePath(userMutagenFolder, appName, remoteSyncPath);
-  const sshUrl = mutagen.getSyncSshUrl(syncSshUser, syncSshHost, remotePath);
-  const sessionName = mutagen.getSessionName(developerId, appName);
-  const localPath = (codePath && typeof codePath === 'string') ? codePath : pathsUtil.getBuilderPath(appName);
-  if (debug) logger.log(chalk.gray(`[DEBUG] Mutagen sync: ${sessionName} ${localPath} <-> ${sshUrl}`));
-  logger.log(chalk.blue('Ensuring Mutagen sync session...'));
-  await mutagen.ensureSyncSession(mutagenPath, sessionName, localPath, sshUrl);
-  return remotePath;
-}
-
 /**
  * Load and configure application
  * @async
@@ -238,12 +220,21 @@ async function startAppContainer(appName, tempComposePath, hostPort, appConfig,
       devMountPath,
       misoEnvironment
     });
-    await helpers.displayRunStatus(appName, hostPort, appConfig, opts.runScopeOpts || null);
+    await helpers.displayRunStatus(
+      appName,
+      hostPort,
+      appConfig,
+      opts.runScopeOpts || null,
+      runOptions || {}
+    );
   } catch (error) {
-    logger.log(chalk.yellow(`\n⚠️  Compose file preserved at: ${tempComposePath}`));
-    logger.log(chalk.yellow('   Review the file to debug issues'));
+    logger.log('');
+    logger.log(formatWarningLine(`Compose file preserved at ${tempComposePath}`));
+    logger.log(metadata('  Review the compose file, fix the issue, then run again.'));
     if (runEnvPath || runEnvAdminPath) {
-      logger.log(chalk.yellow('   Run .env file(s) (contain secrets) were not deleted; remove them manually if desired.'));
+      logger.log(
+        metadata('  Run .env file(s) contain secrets and were not deleted; remove manually if needed.')
+      );
     }
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Error during container start: ${error.message}`));
@@ -271,30 +262,46 @@ async function resolveRunOptions(appName, appConfig, options, envKey, debug, eff
   const codePath = pathsUtil.resolveBuildContext(builderPath, appConfig.build?.context || '.');
   if (options.reload && envKey === 'dev') {
     const remoteSyncPath = appConfig.build?.remoteSyncPath;
-    const remotePath = await ensureReloadSync(appName, appConfig.developerId, debug, codePath, remoteSyncPath);
-    runOptions.devMountPath = remotePath || codePath;
+    const reloadSummary = await ensureReloadSync(appName, appConfig.developerId, debug, codePath, remoteSyncPath);
+    runOptions.reloadSyncSummary = reloadSummary;
+    runOptions.devMountPath =
+      reloadSummary.transport === 'mutagen' ? reloadSummary.remotePath : codePath;
   }
   return runOptions;
 }
 
 /**
- * Prepare run: validate app, load config, check prereqs, stop existing container, resolve port and reload, prepare env.
- * @param {string} appName - Application name
- * @param {Object} options - Run options
- * @param {boolean} debug - Debug flag
- * @returns {Promise<{ appConfig: Object, tempComposePath: string, hostPort: number }|null>} Prepared run context or null if should not continue
+ * When Traefik is enabled in user config and this run should use proxy hints (`runOptions.noProxy` is false), enable Traefik/DNS URL hints.
+ * @param {Object} runOptions
+ * @param {Object} userCfg
  */
-async function prepareAppRun(appName, options, debug) {
-  const envKey = (options.env || 'dev').toLowerCase();
+function applyTraefikFlagToRunOptions(runOptions, userCfg) {
+  if (userCfg && userCfg.traefik === true && !runOptions.noProxy) {
+    runOptions.traefikEnabled = true;
+  }
+}
+
+/**
+ * @param {string} envKey
+ * @throws {Error} If env is not dev, tst, or pro
+ */
+function assertValidRunEnvKey(envKey) {
   if (envKey !== 'dev' && envKey !== 'tst' && envKey !== 'pro') {
     throw new Error('--env must be dev, tst, or pro');
   }
-  const shouldContinue = await validateAppForRun(appName, debug);
-  if (!shouldContinue) {
-    return null;
-  }
-  const appConfig = await loadAndConfigureApp(appName, debug);
-  const userCfg = await config.getConfig();
+}
+
+/**
+ * Image resolution, prereqs, port, compose env — after app config and user config are loaded.
+ * @param {string} appName
+ * @param {Object} appConfig
+ * @param {Object} options - Original run options
+ * @param {string} envKey
+ * @param {Object} userCfg - getConfig() result
+ * @param {boolean} debug
+ * @returns {Promise<Object>} Prepared run context (same shape as prepareAppRun return)
+ */
+async function computeRunPreparationCore(appName, appConfig, options, envKey, userCfg, debug) {
   const { computeEffectiveEnvironmentScopedResources } = require('../utils/environment-scoped-resources');
   const effectiveEnvironmentScopedResources = computeEffectiveEnvironmentScopedResources(
     Boolean(userCfg.useEnvironmentScopedResources),
@@ -304,17 +311,24 @@ async function prepareAppRun(appName, options, debug) {
   const runScopeOpts = effectiveEnvironmentScopedResources
     ? { effectiveEnvironmentScopedResources: true, env: envKey }
     : null;
-  await helpers.checkPrerequisites(appName, appConfig, debug, options.skipInfraCheck === true, options);
-  await checkAndStopContainer(appName, appConfig, options, debug);
-  const hostPort = await calculateHostPort(appConfig, options, debug);
+  const { resolveRunImageWithLocalFallback } = require('./run-resolve-image');
+  const resolvedRef = await resolveRunImageWithLocalFallback(appName, appConfig, options);
+  const effectiveRunOptions = {
+    ...options,
+    image: `${resolvedRef.imageName}:${resolvedRef.imageTag}`
+  };
+  await helpers.checkPrerequisites(appName, appConfig, debug, effectiveRunOptions.skipInfraCheck === true, effectiveRunOptions);
+  await checkAndStopContainer(appName, appConfig, effectiveRunOptions, debug);
+  const hostPort = await calculateHostPort(appConfig, effectiveRunOptions, debug);
   const runOptions = await resolveRunOptions(
     appName,
     appConfig,
-    options,
+    effectiveRunOptions,
     envKey,
     debug,
     effectiveEnvironmentScopedResources
   );
+  applyTraefikFlagToRunOptions(runOptions, userCfg);
   const { composePath: tempComposePath, runEnvPath, runEnvAdminPath } = await helpers.prepareEnvironment(appName, appConfig, runOptions);
   const result = {
     appConfig,
@@ -329,6 +343,59 @@ async function prepareAppRun(appName, options, debug) {
   return result;
 }
 
+/**
+ * Gray **Manifest:** line before container start (skipped when orchestration already emitted).
+ * @param {string} appName
+ * @param {Object} options
+ * @returns {void}
+ */
+function emitRunManifestMetadataIfRequested(appName, options) {
+  if (options.skipManifestMetadataLine === true) return;
+  const { emitManifestMetadataLineIfTTY } = require('../utils/manifest-source-emit');
+  emitManifestMetadataLineIfTTY(logger, {
+    appKey: appName,
+    appPath: pathsUtil.getBuilderPath(appName),
+    envOnly: false,
+    json: false
+  });
+}
+
+/**
+ * Prepare run: validate app, load config, check prereqs, stop existing container, resolve port and reload, prepare env.
+ * @param {string} appName - Application name
+ * @param {Object} options - Run options
+ * @param {boolean} [options.skipManifestMetadataLine] - When true, skip gray **Manifest:** line (caller already emitted for platform orchestration)
+ * @param {boolean} debug - Debug flag
+ * @returns {Promise<{ appConfig: Object, tempComposePath: string, hostPort: number }|null>} Prepared run context or null if should not continue
+ */
+async function prepareAppRun(appName, options, debug) {
+  const envKey = (options.env || 'dev').toLowerCase();
+  assertValidRunEnvKey(envKey);
+  const shouldContinue = await validateAppForRun(appName, debug);
+  if (!shouldContinue) {
+    return null;
+  }
+  let userCfg = await config.getConfig();
+  const appsDefaults = require('../utils/applications-config-defaults');
+  await appsDefaults.persistApplicationRunProxyFlag(appName, !isRunCliNoProxy(options));
+  if (envKey === 'dev') {
+    await appsDefaults.persistApplicationReloadFlag(appName, options.reload === true);
+  }
+  userCfg = await config.getConfig();
+  const savedProxyHint = appsDefaults.getApplicationsRunProxyHint(userCfg, appName);
+  const mergedOpts = {
+    ...options,
+    reload: options.reload === true,
+    noProxy: isRunCliNoProxy(options) || !savedProxyHint
+  };
+  logger.log('');
+  logger.log(sectionTitle('Run'));
+  logger.log(headerKeyValue('Application:', appName));
+  const appConfig = await loadAndConfigureApp(appName, debug);
+  emitRunManifestMetadataIfRequested(appName, options);
+  return computeRunPreparationCore(appName, appConfig, mergedOpts, envKey, userCfg, debug);
+}
+
 /**
  * Runs the application locally using Docker
  * Starts container with proper port mapping and environment
@@ -339,6 +406,7 @@ async function prepareAppRun(appName, options, debug) {
  * @param {Object} options - Run options
  * @param {number} [options.port] - Override local port
  * @param {boolean} [options.debug] - Enable debug output
+ * @param {boolean} [options.skipManifestMetadataLine] - When true, skip gray **Manifest:** line in prepare (orchestration already emitted)
  * @returns {Promise<void>} Resolves when app is running
  * @throws {Error} If run fails or app is not built
  *
@@ -360,10 +428,7 @@ async function runApp(appName, options = {}) {
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Compose file generated: ${prepared.tempComposePath}`));
     }
-    if (options.reload && prepared.devMountPath) {
-      logger.log(chalk.gray('With --reload: workspace mounted from host at /app (container runs as your user for write access).'));
-      logger.log(chalk.gray(`  Host path: ${prepared.devMountPath}`));
-    }
+    logReloadDevSummary(Boolean(prepared.mergedRunOptions.reload), prepared.mergedRunOptions.reloadSyncSummary);
     await startAppContainer(appName, prepared.tempComposePath, prepared.hostPort, prepared.appConfig, {
       debug,
       runEnvPath: prepared.runEnvPath,
@@ -397,10 +462,18 @@ async function restartApp(appName) {
   if (!appName || typeof appName !== 'string') {
     throw new Error('Application name is required and must be a string');
   }
+  const { emitManifestMetadataLineIfTTY } = require('../utils/manifest-source-emit');
+  emitManifestMetadataLineIfTTY(logger, {
+    appKey: appName,
+    appPath: pathsUtil.getBuilderPath(appName),
+    envOnly: false,
+    json: false
+  });
   const developerId = await config.getDeveloperId();
   const containerName = containerHelpers.getContainerName(appName, developerId);
   try {
     await execWithDockerEnv(`docker restart ${containerName}`);
+    await logRestartDevMountSummary(containerName, appName);
   } catch (error) {
     const msg = (error.stderr || error.stdout || error.message || '').toLowerCase();
     if (msg.includes('no such container') || msg.includes('is not running')) {
@@ -413,6 +486,7 @@ async function restartApp(appName) {
 module.exports = {
   runApp,
   restartApp,
+  validateAppForRun,
   ensureReloadSync,
   isLocalhostHost,
   isLocalhostEndpoint,

package/lib/app/show-display.js

@@ -96,6 +96,13 @@ function logApplicationSection(a, summary) {
   } else {
     logApplicationFields(a);
   }
+  if (summary.runReloadDefault && !summary.isExternal) {
+    logger.log(`  ${'Run default:'.padEnd(16)} reload on (config)`);
+  }
+  if (!summary.isExternal) {
+    const proxyOn = summary.runProxyDefault === true;
+    logger.log(`  ${'Run default:'.padEnd(16)} proxy ${proxyOn ? 'on' : 'off'} (config)`);
+  }
   /* External integration is logged after Dataplane block in display() when external */
 }