@aifabrix/builder 2.44.5 → 2.44.6

package/lib/api/types/dimensions.types.js

@@ -0,0 +1,31 @@
+/**
+ * @fileoverview Dimensions API type definitions (Controller)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Dimension create/update payload (Controller catalog)
+ * @typedef {Object} DimensionCreateRequest
+ * @property {string} key
+ * @property {string} displayName
+ * @property {string} [description]
+ * @property {'string'|'number'|'boolean'} dataType
+ * @property {boolean} [isRequired]
+ */
+
+/**
+ * Dimension entity
+ * @typedef {Object} Dimension
+ * @property {string} id
+ * @property {string} key
+ * @property {string} displayName
+ * @property {string|null} [description]
+ * @property {'string'|'number'|'boolean'} dataType
+ * @property {boolean} isRequired
+ * @property {string|null} [createdBy]
+ * @property {string|null} [updatedBy]
+ * @property {string} [createdAt]
+ * @property {string} [updatedAt]
+ */
+

package/lib/api/types/integration-clients.types.js

@@ -0,0 +1,45 @@
+/**
+ * @fileoverview Integration clients API type definitions (Controller camelCase)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Integration client create request body (builder → controller)
+ * @typedef {Object} IntegrationClientCreateRequest
+ * @property {string} key - Stable key (lowercase alphanumeric + hyphens)
+ * @property {string} displayName - Human-readable name
+ * @property {string[]} redirectUris - Allowed redirect URIs for OAuth2 (min 1)
+ * @property {string[]} [groupNames] - Optional group names (RBAC); omit or empty for OAuth-only clients
+ * @property {string} [description] - Optional description
+ * @property {string} [keycloakClientId] - Optional fixed Keycloak client id
+ */
+
+/**
+ * Create response (clientSecret is one-time-only)
+ * @typedef {Object} IntegrationClientCreateResponseData
+ * @property {Object} [integrationClient] - Created record
+ * @property {string} [integrationClient.id] - Integration client id
+ * @property {string} [integrationClient.key] - Key
+ * @property {string} [integrationClient.displayName] - Display name
+ * @property {string} [integrationClient.keycloakClientId] - OAuth client id in Keycloak
+ * @property {string} [integrationClient.status] - Status
+ * @property {string} [clientSecret] - One-time secret
+ */
+
+/**
+ * Single integration client in list response
+ * @typedef {Object} ListIntegrationClientItem
+ * @property {string} id - Integration client id
+ * @property {string} [key] - Key
+ * @property {string} [displayName] - Display name
+ * @property {string} [keycloakClientId] - OAuth client id
+ * @property {string} [status] - Status (e.g. active)
+ */
+
+/**
+ * Regenerate secret response
+ * @typedef {Object} RegenerateIntegrationClientSecretResponse
+ * @property {Object} [data] - Nested data
+ * @property {string} [data.clientSecret] - New secret (one-time)
+ */

package/lib/api/validation-runner.js

@@ -9,6 +9,8 @@
 const { extractTestRunId } = require('./validation-run.api');
 const { postValidationRunWithTransportRetry } = require('../utils/validation-run-post-retry');
 const { pollValidationRunUntilComplete } = require('../utils/validation-run-poll');
+const { createValidationPollHandlers } = require('../utils/validation-poll-ui');
+const logger = require('../utils/logger');
 
 /**
  * POST /api/v1/validation/run and (when async) poll GET until reportCompleteness is full.
@@ -20,6 +22,8 @@ const { pollValidationRunUntilComplete } = require('../utils/validation-run-poll
  * @param {number} opts.timeoutMs
  * @param {boolean} opts.useAsync
  * @param {boolean} opts.noAsync
+ * @param {boolean} [opts.verbosePoll] - Throttled poll lines when no TTY poll UI (see validation-run-poll)
+ * @param {Function} [opts.onPollProgress] - Extra hook: `(envelope, attemptIndex, meta)` during poll
  * @returns {Promise<{ envelope: Object|null, apiError: Object|null, pollTimedOut: boolean, incompleteNoAsync: boolean }>}
  */
 /* eslint-disable max-lines-per-function, max-statements, complexity -- POST + poll orchestration */
@@ -54,31 +58,48 @@ async function postValidationRunAndOptionalPoll(opts) {
   if (needsPoll && testRunId) {
     const elapsed = Date.now() - started;
     const remaining = Math.max(0, timeoutMs - elapsed);
-    const pollResult = await pollValidationRunUntilComplete({
-      dataplaneUrl,
-      authConfig,
-      testRunId,
-      budgetMs: remaining,
-      verbosePoll: verbosePoll === true,
-      pollRequestTimeoutMs:
-        Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined
-    });
-    if (!pollResult.lastApiResult || !pollResult.lastApiResult.success) {
-      return {
-        envelope: pollResult.envelope,
-        apiError: pollResult.lastApiResult,
-        pollTimedOut: pollResult.timedOut,
-        incompleteNoAsync: false
-      };
-    }
-    envelope = pollResult.envelope;
-    if (pollResult.timedOut) {
-      return {
-        envelope,
-        apiError: null,
-        pollTimedOut: true,
-        incompleteNoAsync: false
-      };
+    const deadlineMs = Date.now() + remaining;
+
+    logger.log('');
+    const pollUi = createValidationPollHandlers(deadlineMs);
+    const mergeOnPollProgress =
+      typeof opts.onPollProgress === 'function'
+        ? (envelope, attemptIndex, meta) => {
+          pollUi.onPollProgress(envelope, attemptIndex, meta);
+          opts.onPollProgress(envelope, attemptIndex, meta);
+        }
+        : pollUi.onPollProgress;
+
+    try {
+      const pollResult = await pollValidationRunUntilComplete({
+        dataplaneUrl,
+        authConfig,
+        testRunId,
+        budgetMs: remaining,
+        verbosePoll: verbosePoll === true,
+        pollRequestTimeoutMs:
+          Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : undefined,
+        onPollProgress: mergeOnPollProgress
+      });
+      if (!pollResult.lastApiResult || !pollResult.lastApiResult.success) {
+        return {
+          envelope: pollResult.envelope,
+          apiError: pollResult.lastApiResult,
+          pollTimedOut: pollResult.timedOut,
+          incompleteNoAsync: false
+        };
+      }
+      envelope = pollResult.envelope;
+      if (pollResult.timedOut) {
+        return {
+          envelope,
+          apiError: null,
+          pollTimedOut: true,
+          incompleteNoAsync: false
+        };
+      }
+    } finally {
+      pollUi.finish();
     }
   }
 

package/lib/app/deploy-config.js

@@ -62,11 +62,21 @@ async function extractDeploymentConfig(options, _variables) {
   const controllerUrl = await resolveControllerUrl();
   const envKey = await resolveEnvironment();
 
+  const pollIntervalExplicit =
+    options.pollInterval !== undefined && options.pollInterval !== null
+      ? Number(options.pollInterval)
+      : undefined;
+
   return {
     controllerUrl,
     envKey,
     poll: options.poll !== false,
-    pollInterval: options.pollInterval || 5000,
+    // When true, polling still happens but is not rendered (no nested ora spinner).
+    // Used by guided installers which already show a top-level spinner.
+    silentPoll: options.silentPoll === true,
+    repositoryUrl: options.repositoryUrl,
+    // Omit default here so deployer can resolve 2s vs 5s from controller deploymentType (GET /api/v1/health)
+    pollInterval: Number.isFinite(pollIntervalExplicit) ? pollIntervalExplicit : undefined,
     pollMaxAttempts: options.pollMaxAttempts || 60
   };
 }

package/lib/app/deploy-status-display.js

@@ -5,8 +5,8 @@
  * @version 2.0.0
  */
 
-const chalk = require('chalk');
 const logger = require('../utils/logger');
+const { formatSuccessLine, metadata } = require('../utils/cli-test-layout-chalk');
 const { getApplicationStatus } = require('../api/applications.api');
 
 /**
@@ -69,9 +69,9 @@ async function displayAppUrlFromController(controllerUrl, envKey, appKey, authCo
     url = buildAppUrlFromControllerAndPort(controllerUrl, port);
   }
   if (url) {
-    logger.log(chalk.green(`   ✔ App running at ${url}`));
+    logger.log(formatSuccessLine(`App running at ${url}`));
   } else {
-    logger.log(chalk.blue('   ✔ App deployed. Get URL from controller dashboard.'));
+    logger.log(metadata('App deployed. Resolve URL from the controller dashboard.'));
   }
 }
 

package/lib/app/deploy.js

@@ -1,4 +1,10 @@
-const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+const {
+  formatSuccessLine,
+  formatSuccessParagraph,
+  sectionTitle,
+  headerKeyValue,
+  metadata
+} = require('../utils/cli-test-layout-chalk');
 /**
  * AI Fabrix Builder Application Deployment Module
  *
@@ -13,6 +19,8 @@ const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test
 const fs = require('fs').promises;
 const chalk = require('chalk');
 const pushUtils = require('../deployment/push');
+
+const SEP = chalk.gray('────────────────────────────────────────');
 const logger = require('../utils/logger');
 const { detectAppType, getBuilderPath, getIntegrationPath } = require('../utils/paths');
 const { checkApplicationExists } = require('../utils/app-existence');
@@ -156,7 +164,10 @@ async function pushApp(appName, options = {}) {
  * @throws {Error} If generation or validation fails
  */
 async function generateAndValidateManifest(appName, options = {}) {
-  logger.log(chalk.blue(`\n📋 Generating deployment manifest for ${appName}...`));
+  logger.log('');
+  logger.log(sectionTitle('Deployment manifest'));
+  logger.log(SEP);
+  logger.log(metadata(`Generating manifest for ${appName}...`));
   const generator = require('../generator');
 
   // generateDeployJson already validates against schema and throws on error
@@ -175,10 +186,10 @@ async function generateAndValidateManifest(appName, options = {}) {
  */
 function displayDeploymentInfo(manifest, manifestPath) {
   logger.log(formatSuccessLine(`Manifest generated: ${manifestPath}`));
-  logger.log(chalk.blue(`   Key: ${manifest.key}`));
-  logger.log(chalk.blue(`   Display Name: ${manifest.displayName}`));
-  logger.log(chalk.blue(`   Image: ${manifest.image}`));
-  logger.log(chalk.blue(`   Port: ${manifest.port}`));
+  logger.log(headerKeyValue('Key:', manifest.key));
+  logger.log(headerKeyValue('Display Name:', manifest.displayName));
+  logger.log(headerKeyValue('Image:', manifest.image));
+  logger.log(headerKeyValue('Port:', String(manifest.port)));
 }
 
 /**
@@ -189,7 +200,11 @@ function displayDeploymentInfo(manifest, manifestPath) {
  * @returns {Promise<Object>} Deployment result
  */
 async function executeDeployment(manifest, deploymentConfig) {
-  logger.log(chalk.blue(`\n🚀 Deploying to ${deploymentConfig.controllerUrl} (environment: ${deploymentConfig.envKey})...`));
+  logger.log('');
+  logger.log(sectionTitle('Deploy to controller'));
+  logger.log(SEP);
+  logger.log(headerKeyValue('URL:', deploymentConfig.controllerUrl));
+  logger.log(headerKeyValue('Environment:', deploymentConfig.envKey));
   const deployer = require('../deployment/deployer');
   return await deployer.deployToController(
     manifest,
@@ -199,7 +214,9 @@ async function executeDeployment(manifest, deploymentConfig) {
     {
       poll: deploymentConfig.poll,
       pollInterval: deploymentConfig.pollInterval,
-      pollMaxAttempts: deploymentConfig.pollMaxAttempts
+      pollMaxAttempts: deploymentConfig.pollMaxAttempts,
+      repositoryUrl: deploymentConfig.repositoryUrl,
+      silentPoll: deploymentConfig.silentPoll === true
     }
   );
 }
@@ -209,17 +226,22 @@ async function executeDeployment(manifest, deploymentConfig) {
  * @param {Object} result - Deployment result
  */
 function displayDeploymentResults(result) {
-  logger.log(chalk.green('\n✅ Deployment initiated successfully'));
+  logger.log(formatSuccessParagraph('Deployment initiated successfully'));
   if (result.deploymentUrl) {
-    logger.log(chalk.blue(`   URL: ${result.deploymentUrl}`));
+    logger.log(headerKeyValue('URL:', result.deploymentUrl));
   }
   if (result.deploymentId) {
-    logger.log(chalk.blue(`   Deployment ID: ${result.deploymentId}`));
+    logger.log(headerKeyValue('Deployment ID:', result.deploymentId));
   }
   if (result.status) {
-    const statusIcon = result.status.status === 'completed' ? '✔' :
-      result.status.status === 'failed' ? '✖' : '⏳';
-    logger.log(chalk.blue(`   Status: ${statusIcon} ${result.status.status}`));
+    const st = result.status.status;
+    const statusText =
+      st === 'completed'
+        ? formatSuccessLine(st)
+        : st === 'failed' || st === 'cancelled'
+          ? chalk.red(`✖ ${st}`)
+          : chalk.yellow(`⏳ ${st}`);
+    logger.log(`${chalk.gray('Status:')} ${statusText}`);
   }
 }
 

package/lib/app/display.js

@@ -1,4 +1,4 @@
-const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+const { formatNextActions, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
 /**
  * Application Display Utilities
  *
@@ -24,11 +24,13 @@ const logger = require('../utils/logger');
 function displayExternalSystemSuccess(appName, config, location) {
   logger.log(chalk.blue('Type: External System'));
   logger.log(chalk.blue(`System Key: ${config.systemKey || appName}`));
-  logger.log(chalk.green('\nNext steps:'));
-  logger.log(chalk.white('1. Edit external system JSON files in ' + location));
-  logger.log(chalk.white('2. Run: aifabrix validate ' + appName));
-  logger.log(chalk.white('3. Run: aifabrix login'));
-  logger.log(chalk.white('4. Run: aifabrix deploy ' + appName));
+  logger.log('');
+  logger.log(formatNextActions([
+    `Edit external system JSON files in ${location}`,
+    `Run: aifabrix validate ${appName}`,
+    'Run: aifabrix login',
+    `Run: aifabrix deploy ${appName}`
+  ]));
 }
 
 /**
@@ -49,11 +51,13 @@ function displayWebappSuccess(appName, config, envConversionMessage) {
 
   logger.log(chalk.gray(envConversionMessage));
 
-  logger.log(chalk.green('\nNext steps:'));
-  logger.log(chalk.white('1. Copy env.template to .env and fill in your values'));
-  logger.log(chalk.white('2. Run: aifabrix up-infra'));
-  logger.log(chalk.white('3. Run: aifabrix build ' + appName));
-  logger.log(chalk.white('4. Run: aifabrix run ' + appName));
+  logger.log('');
+  logger.log(formatNextActions([
+    'Copy env.template to .env and fill in your values',
+    'Run: aifabrix up-infra',
+    `Run: aifabrix build ${appName}`,
+    `Run: aifabrix run ${appName}`
+  ]));
 }
 
 /**

package/lib/app/push.js

@@ -1,4 +1,12 @@
-const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
+const {
+  formatSuccessLine,
+  formatSuccessParagraph,
+  sectionTitle,
+  headerKeyValue,
+  metadata,
+  formatWarningLine,
+  formatNextActions
+} = require('../utils/cli-test-layout-chalk');
 /**
  * Application Push Utilities
  *
@@ -9,9 +17,9 @@ const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test
  * @version 2.0.0
  */
 
-const chalk = require('chalk');
 const pushUtils = require('../deployment/push');
 const logger = require('../utils/logger');
+const { detectAppType } = require('../utils/paths');
 
 /**
  * Validate application name format
@@ -150,6 +158,33 @@ async function authenticateWithRegistry(registry) {
   }
 }
 
+/**
+ * Layout-aligned notice when push is skipped for external integrations.
+ * @param {string} appName
+ */
+function logExternalIntegrationPushNotice(appName) {
+  logger.log('');
+  logger.log(sectionTitle('Push'));
+  logger.log(headerKeyValue('Application:', appName));
+  logger.log(formatWarningLine('External integrations have no application image to push.'));
+  logger.log(metadata('Use upload or deploy for integration artifacts.'));
+  logger.log(formatNextActions([`aifabrix upload ${appName}`, `aifabrix deploy ${appName}`]));
+}
+
+/**
+ * Header after validation passes for a regular (non-external) push.
+ * @param {string} appName
+ * @param {string} registry
+ * @param {string} imageName
+ */
+function logPushCommandHeader(appName, registry, imageName) {
+  logger.log('');
+  logger.log(sectionTitle('Push'));
+  logger.log(headerKeyValue('Application:', appName));
+  logger.log(metadata(`Registry: ${registry}`));
+  logger.log(metadata(`Repository: ${imageName}`));
+}
+
 /**
  * Pushes image tags to registry
  * @async
@@ -171,7 +206,9 @@ async function pushImageTags(imageName, registry, tags) {
                         (errorMessage.includes('authentication') && errorMessage.includes('401'));
 
     if (isAuthError) {
-      logger.log(chalk.yellow('⚠ Authentication expired, re-authenticating...'));
+      logger.log(
+        formatWarningLine('Registry authentication expired; re-authenticating, then retrying push.')
+      );
       await authenticateWithRegistry(registry);
       // Retry push after re-authentication
       await Promise.all(tags.map(async(tag) => {
@@ -190,9 +227,9 @@ async function pushImageTags(imageName, registry, tags) {
  * @param {Array<string>} tags - Image tags
  */
 function displayPushResults(registry, imageName, tags) {
-  logger.log(formatSuccessParagraph(`Successfully pushed ${tags.length} tag(s) to ${registry}`));
-  logger.log(chalk.gray(`Image: ${registry}/${imageName}:*`));
-  logger.log(chalk.gray(`Tags: ${tags.join(', ')}`));
+  logger.log(formatSuccessParagraph(`Pushed ${tags.length} tag(s) to ${registry}`));
+  logger.log(headerKeyValue('Image:', `${registry}/${imageName}`));
+  logger.log(headerKeyValue('Tags:', tags.join(', ')));
 }
 
 /**
@@ -204,38 +241,25 @@ function displayPushResults(registry, imageName, tags) {
  * @returns {Promise<void>} Resolves when push is complete
  */
 async function pushApp(appName, options = {}) {
-  // Check if app type is external - skip push
-  const { detectAppType } = require('../utils/paths');
   try {
     const { isExternal } = await detectAppType(appName);
     if (isExternal) {
-      logger.log(chalk.yellow('⚠  External systems don\'t require Docker images. Skipping push...'));
+      logExternalIntegrationPushNotice(appName);
       return;
     }
-  } catch (error) {
+  } catch (_error) {
     // If detection fails, continue with normal push
     // (detectAppType throws if app doesn't exist, which is fine for push command)
   }
   try {
-    // Validate app name
     validateAppName(appName);
-
-    // Load configuration
     const { registry, imageName } = await loadPushConfig(appName, options);
-
-    // Validate push configuration
     await validatePushConfig(registry, imageName, appName);
-
-    // Authenticate with registry
+    logPushCommandHeader(appName, registry, imageName);
     await authenticateWithRegistry(registry);
-
-    // Push image tags
     const tags = options.tag ? options.tag.split(',').map(t => t.trim()) : ['latest'];
     await pushImageTags(imageName, registry, tags);
-
-    // Display results
     displayPushResults(registry, imageName, tags);
-
   } catch (error) {
     throw new Error(`Failed to push application: ${error.message}`);
   }
@@ -245,4 +269,3 @@ module.exports = {
   pushApp,
   validateAppName
 };
-

package/lib/app/register.js

@@ -99,7 +99,7 @@ async function saveLocalCredentials(responseData, apiUrl) {
 
     // Regenerate .env file with updated credentials
     try {
-      await generateEnvFile(registeredAppKey, null, 'local');
+      await generateEnvFile(registeredAppKey, null, 'local', true);
       logger.log(formatSuccessLine('.env file updated with new credentials'));
     } catch (error) {
       logger.warn(chalk.yellow(`⚠  Could not regenerate .env file: ${error.message}`));

package/lib/app/restart-display.js

@@ -0,0 +1,95 @@
+/**
+ * After `docker restart`, describe dev workspace mounts for developer clarity.
+ *
+ * @fileoverview Bind mount vs remote-engine hints (aligns with run --reload messaging)
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const config = require('../core/config');
+const { execWithDockerEnv } = require('../utils/docker-exec');
+const { sectionTitle, headerKeyValue, metadata } = require('../utils/cli-test-layout-chalk');
+const { isReloadBindMountOnEngineHost } = require('../utils/docker-reload-mount');
+
+/**
+ * @param {unknown} mounts - docker inspect .Mounts
+ * @returns {{ Type: string, Source: string, Destination: string }|null}
+ */
+function findAppBindMount(mounts) {
+  if (!Array.isArray(mounts)) {
+    return null;
+  }
+  const hit = mounts.find((m) => m && m.Type === 'bind' && m.Destination === '/app');
+  return hit && typeof hit.Source === 'string' ? hit : null;
+}
+
+/**
+ * @param {string} stdout
+ * @returns {unknown|null}
+ */
+function parseInspectMountsStdout(stdout) {
+  try {
+    return JSON.parse(String(stdout || '').trim());
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * @param {string} containerName
+ * @returns {Promise<unknown|null>}
+ */
+async function fetchContainerMountsJson(containerName) {
+  try {
+    const { stdout } = await execWithDockerEnv(
+      `docker inspect --format '{{json .Mounts}}' ${containerName}`,
+      { maxBuffer: 2 * 1024 * 1024 }
+    );
+    return parseInspectMountsStdout(stdout);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Log workspace transport after a successful container restart (mounts unchanged).
+ * @param {string} containerName - Docker container name
+ * @returns {Promise<void>}
+ */
+async function logRestartDevMountSummary(containerName) {
+  if (!containerName || typeof containerName !== 'string') {
+    return;
+  }
+  const mounts = await fetchContainerMountsJson(containerName);
+  const appBind = findAppBindMount(mounts);
+  if (!appBind) {
+    return;
+  }
+  const endpoint = await config.getDockerEndpoint();
+  const localEngine = isReloadBindMountOnEngineHost(endpoint);
+
+  logger.log('');
+  logger.log(sectionTitle('Dev workspace (unchanged by restart)'));
+  if (localEngine) {
+    logger.log(headerKeyValue('Transport:', 'Direct bind mount on the Docker host (no Mutagen).'));
+    logger.log(headerKeyValue('Host path → container:', `${appBind.Source} → /app`));
+    logger.log(metadata('Edits under the host path are visible inside the container immediately.'));
+  } else {
+    logger.log(
+      headerKeyValue(
+        'Transport:',
+        'Bind mount on the Docker engine (see path below; Mutagen may sync to this path when using --reload).'
+      )
+    );
+    logger.log(headerKeyValue('Engine path → container:', `${appBind.Source} → /app`));
+  }
+  logger.log('');
+}
+
+module.exports = {
+  findAppBindMount,
+  logRestartDevMountSummary
+};

package/lib/app/rotate-secret.js

@@ -287,7 +287,7 @@ async function saveCredentialsLocally(appKey, credentials, actualControllerUrl)
 
       // Regenerate .env file with updated credentials
       try {
-        await generateEnvFile(appKey, null, 'local');
+        await generateEnvFile(appKey, null, 'local', true);
         logger.log(formatSuccessLine('.env file updated with new credentials'));
       } catch (error) {
         logger.warn(chalk.yellow(`⚠  Could not regenerate .env file: ${error.message}`));

package/lib/app/run-container-start.js

@@ -5,7 +5,11 @@
  */
 
 'use strict';
-const { formatSuccessLine } = require('../utils/cli-test-layout-chalk');
+const {
+  formatSuccessLine,
+  formatProgress,
+  formatWarningLine
+} = require('../utils/cli-test-layout-chalk');
 
 const fs = require('fs').promises;
 const chalk = require('chalk');
@@ -31,8 +35,8 @@ const execAsync = promisify(exec);
 async function emitAndRunDockerFallback(appName, appConfig, port, opts) {
   const { debug, runEnvPath, runOptions, misoEnvironment } = opts;
   logger.log(
-    chalk.yellow(
-      'Docker Compose not found; using docker run (apps without database/redis only). ' +
+    formatWarningLine(
+      'Docker Compose not found; using docker run (apps without Postgres/Redis only). ' +
         'Install docker-compose-plugin for full compose support.'
     )
   );
@@ -116,7 +120,7 @@ async function waitForHealthyAndCleanupEnvFiles(appName, port, appConfig, o) {
   const displayUrl = (healthUrl && typeof healthUrl === 'string')
     ? healthUrl
     : `http://localhost:${port}${healthCheckPath}`;
-  logger.log(chalk.blue(`Waiting for application to be healthy at ${displayUrl}...`));
+  logger.log(formatProgress(`Waiting for healthy: ${displayUrl}…`));
   await healthCheck.waitForHealthCheck(appName, 90, port, appConfig, debug, ro);
 
   for (const p of [runEnvPath, runEnvAdminPath]) {
@@ -124,7 +128,9 @@ async function waitForHealthyAndCleanupEnvFiles(appName, port, appConfig, o) {
       try {
         await fs.unlink(p);
       } catch (err) {
-        if (err.code !== 'ENOENT') logger.log(chalk.yellow(`Warning: could not remove run .env: ${err.message}`));
+        if (err.code !== 'ENOENT') {
+          logger.log(formatWarningLine(`Could not remove run .env: ${err.message}`));
+        }
       }
     }
   }
@@ -148,7 +154,7 @@ async function startContainer(appName, composePath, port, appConfig = null, opts
     devMountPath = null,
     misoEnvironment = 'dev'
   } = opts;
-  logger.log(chalk.blue(`Starting ${appName}...`));
+  logger.log(formatProgress(`Starting ${appName}…`));
 
   let composeCmdBase;
   let usedDockerRunFallback = false;