@aifabrix/builder 2.44.3 → 2.44.5

package/lib/commands/datasource-unified-test-cli.js

@@ -94,7 +94,7 @@ async function runDatasourceUnifiedTestOnceForWatch(datasourceKey, runOpts, disp
   try {
     const result = await runUnifiedDatasourceValidation(datasourceKey, runOpts);
     const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, certCliOptions, 'datasource test');
+    await afterUnifiedValidationCertSync(exitCode, datasourceKey, certCliOptions, 'datasource test', result.envelope);
     return {
       exitCode,
       envelope: result.envelope
@@ -121,7 +121,7 @@ async function datasourceTestCommandAction(datasourceKey, options) {
           const result = await runUnifiedDatasourceValidation(datasourceKey, runOpts);
           await writeDatasourceTestDebugLogIfRequested(appKey, datasourceKey, result, options);
           const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-          await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test (watch)');
+          await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test (watch)', result.envelope);
           return {
             exitCode,
             envelope: result.envelope
@@ -140,7 +140,7 @@ async function datasourceTestCommandAction(datasourceKey, options) {
       }
     }
     const exitCode = finalizeUnifiedValidationResult(result, displayOpts);
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test');
+    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test', result.envelope);
     process.exit(exitCode);
   } catch (error) {
     logger.error(formatBlockingError('Datasource test failed:'), error.message);
@@ -195,7 +195,13 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
     if (unifiedModes) {
       const uni = unifiedCliResultFromIntegrationReturn(result);
       const exitCode = finalizeUnifiedValidationResult(uni, unifiedDisplayOpts);
-      await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration (watch)');
+      await afterUnifiedValidationCertSync(
+        exitCode,
+        datasourceKey,
+        options,
+        'datasource test-integration (watch)',
+        uni.envelope
+      );
       return { exitCode, envelope: uni.envelope };
     }
     displayIntegrationTestResults(
@@ -211,7 +217,13 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
       warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
       requireCert: unifiedDisplayOpts.requireCert === true
     });
-    await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration (watch)');
+    await afterUnifiedValidationCertSync(
+      exitCode,
+      datasourceKey,
+      options,
+      'datasource test-integration (watch)',
+      result.datasourceTestRun || null
+    );
     return { exitCode, envelope: result.datasourceTestRun || null };
   } catch (err) {
     logger.error(formatBlockingError('Integration test failed:'), err.message);
@@ -219,49 +231,67 @@ async function runIntegrationOnceForWatch(datasourceKey, integOpts, options, uni
   }
 }
 
+async function integrationTestCommandActionWatch(datasourceKey, options, integOpts, unifiedDisplayOpts) {
+  const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
+  await runDatasourceValidationWatchLoop({
+    appKey,
+    extraPaths: options.watchPath || [],
+    includeApplicationYaml: options.watchApplicationYaml === true,
+    watchCi: options.watchCi === true,
+    watchFullDiff: options.watchFullDiff === true,
+    runOnce: () => runIntegrationOnceForWatch(datasourceKey, integOpts, options, unifiedDisplayOpts)
+  });
+}
+
+async function integrationTestCommandActionNonWatch(datasourceKey, integOpts, options, unifiedDisplayOpts) {
+  const result = await runDatasourceTestIntegration(datasourceKey, integOpts);
+  const unifiedModes =
+    options.json || options.summary || options.warningsAsErrors || options.requireCert;
+  if (unifiedModes) {
+    const uni = unifiedCliResultFromIntegrationReturn(result);
+    const exitCode = finalizeUnifiedValidationResult(uni, unifiedDisplayOpts);
+    await afterUnifiedValidationCertSync(
+      exitCode,
+      datasourceKey,
+      options,
+      'datasource test-integration',
+      uni.envelope
+    );
+    process.exit(exitCode);
+    return;
+  }
+  displayIntegrationTestResults(
+    {
+      systemKey: result.systemKey || 'unknown',
+      datasourceResults: [result],
+      success: result.success
+    },
+    options.verbose,
+    { debug: options.debug, runType: 'integration' }
+  );
+  const integExit = finalizeAfterIntegrationDisplay(result, {
+    warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
+    requireCert: unifiedDisplayOpts.requireCert === true
+  });
+  await afterUnifiedValidationCertSync(
+    integExit,
+    datasourceKey,
+    options,
+    'datasource test-integration',
+    result.datasourceTestRun || null
+  );
+  process.exit(integExit);
+}
+
 async function integrationTestCommandAction(datasourceKey, options) {
   const integOpts = buildIntegrationTestOpts(options);
   const unifiedDisplayOpts = buildIntegrationUnifiedDisplayOpts(options);
   try {
     if (options.watch) {
-      const { appKey } = await resolveAppKeyForDatasource(datasourceKey, options.app);
-      await runDatasourceValidationWatchLoop({
-        appKey,
-        extraPaths: options.watchPath || [],
-        includeApplicationYaml: options.watchApplicationYaml === true,
-        watchCi: options.watchCi === true,
-        watchFullDiff: options.watchFullDiff === true,
-        runOnce: () => runIntegrationOnceForWatch(datasourceKey, integOpts, options, unifiedDisplayOpts)
-      });
-      return;
-    }
-    const result = await runDatasourceTestIntegration(datasourceKey, integOpts);
-    const unifiedModes =
-      options.json || options.summary || options.warningsAsErrors || options.requireCert;
-    if (unifiedModes) {
-      const exitCode = finalizeUnifiedValidationResult(
-        unifiedCliResultFromIntegrationReturn(result),
-        unifiedDisplayOpts
-      );
-      await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-integration');
-      process.exit(exitCode);
+      await integrationTestCommandActionWatch(datasourceKey, options, integOpts, unifiedDisplayOpts);
       return;
     }
-    displayIntegrationTestResults(
-      {
-        systemKey: result.systemKey || 'unknown',
-        datasourceResults: [result],
-        success: result.success
-      },
-      options.verbose,
-      { debug: options.debug, runType: 'integration' }
-    );
-    const integExit = finalizeAfterIntegrationDisplay(result, {
-      warningsAsErrors: unifiedDisplayOpts.warningsAsErrors === true,
-      requireCert: unifiedDisplayOpts.requireCert === true
-    });
-    await afterUnifiedValidationCertSync(integExit, datasourceKey, options, 'datasource test-integration');
-    process.exit(integExit);
+    await integrationTestCommandActionNonWatch(datasourceKey, integOpts, options, unifiedDisplayOpts);
   } catch (error) {
     logger.error(formatBlockingError('Integration test failed:'), error.message);
     process.exit(4);
@@ -296,9 +326,8 @@ async function runDatasourceTestE2ECliOnce(datasourceKey, options) {
     debug: options.debug,
     verbose: options.verbose,
     async: options.async !== false,
-    testCrud: options.testCrud,
-    recordId: options.recordId,
     cleanup: options.cleanup,
+    runScenarios: options.runScenarios,
     primaryKeyValue: options.primaryKeyValue,
     minVectorHits: options.minVectorHits,
     minProcessed: options.minProcessed,
@@ -340,8 +369,8 @@ async function runDatasourceTestE2ECliOnce(datasourceKey, options) {
 }
 
 async function runDatasourceTestE2ECliAction(datasourceKey, options) {
-  const { exitCode } = await runDatasourceTestE2ECliOnce(datasourceKey, options);
-  await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-e2e');
+  const { exitCode, envelope } = await runDatasourceTestE2ECliOnce(datasourceKey, options);
+  await afterUnifiedValidationCertSync(exitCode, datasourceKey, options, 'datasource test-e2e', envelope);
   process.exit(exitCode);
 }
 
@@ -371,7 +400,13 @@ async function e2eTestCommandAction(datasourceKey, capabilityKey, options) {
         runOnce: async() => {
           try {
             const r = await runDatasourceTestE2ECliOnce(datasourceKey, mergedOptions);
-            await afterUnifiedValidationCertSync(r.exitCode, datasourceKey, mergedOptions, 'datasource test-e2e (watch)');
+            await afterUnifiedValidationCertSync(
+              r.exitCode,
+              datasourceKey,
+              mergedOptions,
+              'datasource test-e2e (watch)',
+              r.envelope
+            );
             return r;
           } catch (err) {
             logger.error(formatBlockingError('E2E test failed:'), err.message);

package/lib/commands/datasource-unified-test-cli.options.js

@@ -166,8 +166,10 @@ function attachDatasourceTestE2eExclusiveOptions(cmd) {
       'Minimum record count assertion (e2eOptions.minRecordCount)',
       (v) => parseInt(String(v), 10)
     )
-    .option('--test-crud', 'Enable CRUD lifecycle test (e2eOptions.testCrud)')
-    .option('--record-id <id>', 'Record ID for test (e2eOptions.recordId)')
+    .option(
+      '--no-run-scenarios',
+      'Do not expand testPayload.scenarios in capacity step (e2eOptions.runScenarios: false)'
+    )
     .option('--no-cleanup', 'Disable cleanup after test (e2eOptions.cleanup: false)')
     .option(
       '--primary-key-value <value|@path>',

package/lib/commands/datasource.js

@@ -10,10 +10,10 @@
  */
 
 const path = require('path');
-const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { sectionTitle, headerKeyValue, metadata, formatSuccessLine, formatBlockingError } = require('../utils/cli-test-layout-chalk');
+const { formatBlockingError } = require('../utils/cli-test-layout-chalk');
 const { validateDatasourceFile } = require('../datasource/validate');
+const { logDatasourceValidateOutcome } = require('../datasource/datasource-validate-display');
 const { listDatasources } = require('../datasource/list');
 const { compareDatasources } = require('../datasource/diff');
 const { deployDatasource } = require('../datasource/deploy');
@@ -53,34 +53,6 @@ Examples:
   $ af ds upload ../integration/hubspot/hubspot-datasource-deals.json
 `;
 
-/**
- * TTY layout for local datasource JSON validation (aligned with cli-test-layout-chalk).
- * @param {{ valid: boolean, errors: string[], resolvedPath: string }} result
- * @param {string} trimmed - original CLI argument
- * @param {boolean} showMapping - show Key + File when key resolved to a path
- */
-function logDatasourceValidateOutcome(result, trimmed, showMapping) {
-  logger.log('');
-  logger.log(sectionTitle('Datasource validation'));
-  logger.log(metadata('Offline — JSON schema and integration wiring'));
-  logger.log('');
-  if (!result.valid) {
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-    logger.log('');
-    logger.log(formatBlockingError('Datasource file has errors:'));
-    result.errors.forEach(error => logger.log(chalk.red(`  • ${error}`)));
-    return;
-  }
-  if (showMapping) {
-    logger.log(headerKeyValue('Key:', trimmed));
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-  } else {
-    logger.log(headerKeyValue('File:', result.resolvedPath));
-  }
-  logger.log('');
-  logger.log(formatSuccessLine('Datasource file is valid.'));
-}
-
 function setupDatasourceValidateCommand(datasource) {
   datasource.command('validate <file-or-key>')
     .description('Validate datasource JSON (file path or datasource key under integration/<app>/)')
@@ -97,7 +69,7 @@ function setupDatasourceValidateCommand(datasource) {
           process.exit(1);
         }
       } catch (error) {
-        logger.error(formatBlockingError('Validation failed:'), error.message);
+        logger.error(formatBlockingError(`Validation failed: ${error.message}`));
         process.exit(1);
       }
     });

package/lib/commands/repair-datasource-keys.js

@@ -193,7 +193,7 @@ function normalizeDatasourceKeysAndFilenames(appPath, datasourceFiles, systemKey
   }
 
   if (updated && variables.externalIntegration && Array.isArray(variables.externalIntegration.dataSources)) {
-    variables.externalIntegration.dataSources = [...newDatasourceFiles].sort();
+    variables.externalIntegration.dataSources = [...newDatasourceFiles];
   }
 
   return { updated, datasourceFiles: newDatasourceFiles };

package/lib/commands/repair-datasource-openapi.js

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Repair OpenAPI block on external datasource JSON.
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+function hasNonEmptyObject(v) {
+  return !!v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0;
+}
+
+/**
+ * Repair `openapi` section:
+ * - If operations exist, ensure `openapi.enabled=true`
+ * - If enabled/operations and missing documentKey/fileId, default documentKey to datasource key (common convention)
+ * - If enabled+operations and autoRbac missing, default to true (wizard/fixtures expectation)
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Change log
+ * @returns {boolean} True if updated
+ */
+function repairOpenapiSection(parsed, changes) {
+  const openapi = parsed?.openapi;
+  if (!openapi || typeof openapi !== 'object') {
+    return false;
+  }
+
+  const hasOps = hasNonEmptyObject(openapi.operations);
+  const enabled = openapi.enabled === true;
+  let updated = false;
+
+  if (hasOps && openapi.enabled !== true) {
+    openapi.enabled = true;
+    changes.push('Set openapi.enabled=true (operations present)');
+    updated = true;
+  }
+
+  if ((enabled || hasOps) && !openapi.documentKey && !openapi.fileId) {
+    if (typeof parsed.key === 'string' && parsed.key.trim()) {
+      openapi.documentKey = parsed.key.trim();
+      changes.push(`Set openapi.documentKey=${openapi.documentKey}`);
+      updated = true;
+    }
+  }
+
+  if ((enabled || hasOps) && hasOps && openapi.autoRbac === undefined) {
+    openapi.autoRbac = true;
+    changes.push('Set openapi.autoRbac=true (enabled operations, default)');
+    updated = true;
+  }
+
+  return updated;
+}
+
+module.exports = { repairOpenapiSection };
+

package/lib/commands/repair-datasource.js

@@ -9,6 +9,8 @@
 
 'use strict';
 
+const { repairOpenapiSection } = require('./repair-datasource-openapi');
+
 const DEFAULT_SYNC = {
   mode: 'pull',
   batchSize: 500
@@ -446,6 +448,8 @@ function repairDatasourceFile(parsed, options = {}, changes = []) {
     updated = repairMetadataSchemaFromAttributes(parsed, out) || updated;
   }
 
+  updated = repairOpenapiSection(parsed, out) || updated;
+
   if (options.expose) {
     updated = repairExposeFromAttributes(parsed, out) || updated;
   }
@@ -472,6 +476,7 @@ module.exports = {
   repairExposeFromAttributes,
   repairSyncSection,
   repairTestPayload,
+  repairOpenapiSection,
   sanitizeTestPayloadTopLevel,
   repairDatasourceFile,
   DEFAULT_SYNC,

package/lib/commands/repair-internal.js

@@ -40,7 +40,6 @@ function discoverIntegrationFiles(appPath) {
     }
   }
   systemFiles.sort();
-  datasourceFiles.sort();
   return { systemFiles, datasourceFiles };
 }
 
@@ -48,8 +47,8 @@ function discoverIntegrationFiles(appPath) {
  * Builds the effective datasource file list from application.yaml and discovered files.
  * @param {string} appPath - Application directory path
  * @param {string[]} discoveredDatasourceFiles - Filenames from discoverIntegrationFiles
- * @param {string[]} [existingDataSources] - externalIntegration.dataSources from application.yaml
- * @returns {string[]} Sorted, deduplicated list of datasource filenames
+ * @param {string[]} [existingDataSources] - externalIntegration.dataSources from application config
+ * @returns {string[]} Deduplicated list of datasource filenames (application order first, then remaining discovered files in directory order)
  */
 function buildEffectiveDatasourceFiles(appPath, discoveredDatasourceFiles, existingDataSources) {
   const existing = Array.isArray(existingDataSources) ? existingDataSources : [];
@@ -75,7 +74,6 @@ function buildEffectiveDatasourceFiles(appPath, discoveredDatasourceFiles, exist
       seen.add(name);
     }
   }
-  result.sort();
   return result;
 }
 

package/lib/commands/repair-rbac.js

@@ -17,6 +17,22 @@ const { resolveRbacPath } = require('../utils/app-config-resolver');
 
 const DEFAULT_CAPABILITIES = ['list', 'get', 'create', 'update', 'delete'];
 
+/**
+ * Extracts roles and permissions from external system JSON for rbac.yaml (same rules as repair).
+ * @param {Object} system - Parsed system config
+ * @returns {Object|null} RBAC object or null
+ */
+function extractRbacFromSystem(system) {
+  if (!system || typeof system !== 'object') return null;
+  const hasRoles = system.roles && Array.isArray(system.roles) && system.roles.length > 0;
+  const hasPermissions = system.permissions && Array.isArray(system.permissions) && system.permissions.length > 0;
+  if (!hasRoles && !hasPermissions) return null;
+  const rbac = {};
+  if (hasRoles) rbac.roles = system.roles;
+  if (hasPermissions) rbac.permissions = system.permissions;
+  return rbac;
+}
+
 /**
  * Resolves capabilities from datasource (array or legacy object).
  * @param {Object} parsed - Parsed datasource
@@ -24,9 +40,15 @@ const DEFAULT_CAPABILITIES = ['list', 'get', 'create', 'update', 'delete'];
  */
 function getCapabilitiesFromDatasource(parsed) {
   const cap = parsed?.capabilities;
-  if (Array.isArray(cap)) return cap.filter(c => typeof c === 'string');
+  if (Array.isArray(cap)) {
+    const arr = cap.filter(c => typeof c === 'string');
+    if (arr.length > 0) return arr;
+    return [...DEFAULT_CAPABILITIES];
+  }
   if (cap && typeof cap === 'object') {
-    return Object.keys(cap).filter(k => cap[k] === true);
+    const keys = Object.keys(cap).filter(k => cap[k] === true);
+    if (keys.length > 0) return keys;
+    return [...DEFAULT_CAPABILITIES];
   }
   return [...DEFAULT_CAPABILITIES];
 }
@@ -159,6 +181,7 @@ function mergeRbacFromDatasources(appPath, systemParsed, datasourceFiles, extrac
 }
 
 module.exports = {
+  extractRbacFromSystem,
   getCapabilitiesFromDatasource,
   mergeRbacFromDatasources
 };

package/lib/commands/repair.js

@@ -26,7 +26,7 @@ const generator = require('../generator');
 const { repairEnvTemplate, normalizeSystemFileAuthAndConfig } = require('./repair-env-template');
 const { generateReadmeFromDeployJson } = require('../generator/split-readme');
 const { repairDatasourceFile } = require('./repair-datasource');
-const { mergeRbacFromDatasources } = require('./repair-rbac');
+const { mergeRbacFromDatasources, extractRbacFromSystem } = require('./repair-rbac');
 const { discoverIntegrationFiles, buildEffectiveDatasourceFiles } = require('./repair-internal');
 const { normalizeDatasourceKeysAndFilenames } = require('./repair-datasource-keys');
 
@@ -49,22 +49,6 @@ function inferExternalReadmeFileExt(appPath) {
   return '.json';
 }
 
-/**
- * Extracts roles and permissions from system object for rbac.yaml
- * @param {Object} system - Parsed system config
- * @returns {Object|null} RBAC object or null
- */
-function extractRbacFromSystem(system) {
-  if (!system || typeof system !== 'object') return null;
-  const hasRoles = system.roles && Array.isArray(system.roles) && system.roles.length > 0;
-  const hasPermissions = system.permissions && Array.isArray(system.permissions) && system.permissions.length > 0;
-  if (!hasRoles && !hasPermissions) return null;
-  const rbac = {};
-  if (hasRoles) rbac.roles = system.roles;
-  if (hasPermissions) rbac.permissions = system.permissions;
-  return rbac;
-}
-
 /**
  * Loads first system file and returns parsed object with key
  * @param {string} appPath - Application path
@@ -204,8 +188,7 @@ function alignSystemFileDataSources(appPath, systemParsed, datasourceFiles, syst
       keys.push(deriveDatasourceKeyFromFileName(fileName, systemKey));
     }
   }
-  keys.sort();
-  const prev = Array.isArray(systemParsed.dataSources) ? [...systemParsed.dataSources].sort() : [];
+  const prev = Array.isArray(systemParsed.dataSources) ? [...systemParsed.dataSources] : [];
   if (JSON.stringify(prev) === JSON.stringify(keys)) return false;
   systemParsed.dataSources = keys;
   changes.push(`dataSources: [${prev.join(', ') || '(none)'}] → [${keys.join(', ')}] (keys from each datasource file's "key" or filename)`);

package/lib/commands/test-e2e-external.js

@@ -42,8 +42,8 @@ function deriveDatasourceKeyFromFileName(fileName, systemKey) {
  * @param {Object} variables - Loaded application variables (externalIntegration.dataSources = filenames)
  * @param {string} systemKey - System key from system file
  * @param {Object} systemParsed - Parsed system config (may have dataSources array of keys)
- * @param {string[]} datasourceFiles - Discovered datasource filenames
- * @returns {string[]} Sorted list of datasource keys
+ * @param {string[]} datasourceFiles - Discovered datasource filenames (application order when built via repair)
+ * @returns {string[]} Datasource keys in declaration order (system JSON or file list — never sort; FK targets must run first)
  */
 function getDatasourceKeys(appPath, configPath, variables, systemKey, systemParsed, datasourceFiles) {
   const fromSystem = Array.isArray(systemParsed.dataSources) && systemParsed.dataSources.length > 0
@@ -54,11 +54,11 @@ function getDatasourceKeys(appPath, configPath, variables, systemKey, systemPars
   if (fromSystem) {
     fromSystem.forEach(k => {
       if (k && typeof k === 'string' && !seen.has(k)) {
-        keys.push(k.trim());
-        seen.add(k.trim());
+        const trimmed = k.trim();
+        keys.push(trimmed);
+        seen.add(trimmed);
       }
     });
-    keys.sort();
     return keys;
   }
   for (const fileName of datasourceFiles) {
@@ -81,18 +81,18 @@ function getDatasourceKeys(appPath, configPath, variables, systemKey, systemPars
       }
     }
   }
-  keys.sort();
   return keys;
 }
 
 /**
- * Full upload to dataplane when --sync (same path as `aifabrix upload <systemKey>`).
+ * Publish local integration files to the dataplane before E2E (same path as `aifabrix upload <systemKey>`),
+ * unless ``options.noSync`` is true.
  * @param {string} systemKey
  * @param {Object} options
  * @returns {Promise<void>}
  */
 async function syncLocalIfRequested(systemKey, options) {
-  if (options.sync !== true) return;
+  if (options.noSync === true) return;
   logger.log(chalk.cyan('Syncing local config to dataplane…'));
   const { uploadExternalSystem } = require('./upload');
   await uploadExternalSystem(systemKey, {
@@ -113,7 +113,7 @@ async function syncLocalIfRequested(systemKey, options) {
  * @param {boolean} [options.debug] - Include debug, write log
  * @param {boolean} [options.verbose] - Verbose output
  * @param {boolean} [options.async] - If false, sync mode (default true)
- * @param {boolean} [options.sync] - When true, run full upload (`uploadExternalSystem`) before per-datasource E2E
+ * @param {boolean} [options.noSync] - When true, skip upload (E2E uses dataplane config already deployed)
  * @returns {Promise<{ success: boolean, results: Array<{ key: string, success: boolean, error?: string }> }>}
  */
 async function runTestE2EForExternalSystem(externalSystem, options = {}) {

package/lib/commands/up-common.js

@@ -13,6 +13,8 @@ const path = require('path');
 const fs = require('fs');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
+const config = require('../core/config');
+const { getDefaultControllerUrl } = require('../utils/controller-url');
 const pathsUtil = require('../utils/paths');
 const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 const { isYamlPath } = require('../utils/config-format');
@@ -166,6 +168,28 @@ function patchEnvOutputPathForDeployOnly(appName) {
   }
 }
 
+/**
+ * For ``up-platform --force`` only: clear all stored auth tokens, set ``environment`` to ``dev``,
+ * set ``controller`` to the default URL for the current ``developer-id`` (``http://localhost`` +
+ * app port = 3000 + developerId × 100), and persist config. Does not change ``developer-id``.
+ * Builder dirs (keycloak, miso-controller, dataplane) are cleaned separately.
+ *
+ * @returns {Promise<void>}
+ */
+async function applyUpPlatformForceConfig() {
+  const deviceCleared = await config.clearAllDeviceTokens();
+  const clientCleared = await config.clearAllClientTokens();
+  await config.setCurrentEnvironment('dev');
+  const defaultControllerUrl = await getDefaultControllerUrl();
+  await config.setControllerUrl(defaultControllerUrl);
+  logger.log(
+    chalk.blue(
+      `--force: cleared ${deviceCleared} device token(s) and ${clientCleared} client token(s); ` +
+        `environment set to dev; default controller set to ${defaultControllerUrl} (run aifabrix login after platform is up)`
+    )
+  );
+}
+
 /**
  * Removes builder app directories for the given app names. Only removes paths under the builder root
  * to prevent path traversal. Uses getBuilderPath for each app and validates before removal.
@@ -231,6 +255,7 @@ async function ensureAppFromTemplate(appName) {
 }
 
 module.exports = {
+  applyUpPlatformForceConfig,
   cleanBuilderAppDirs,
   ensureAppFromTemplate,
   patchEnvOutputPathForDeployOnly,

package/lib/commands/upload.js

@@ -17,7 +17,8 @@ const { getIntegrationPath } = require('../utils/paths');
 const { pushCredentialSecrets } = require('../utils/credential-secrets-env');
 const {
   buildResolvedEnvMapForIntegration,
-  resolveConfigurationValues
+  resolveConfigurationValues,
+  collectResolvedVariableConfigurationNames
 } = require('../utils/configuration-env-resolver');
 const { validateExternalSystemComplete } = require('../validation/validate');
 const { displayValidationResults } = require('../validation/validate-display');
@@ -70,9 +71,11 @@ function buildUploadPayload(manifest) {
 /**
  * Resolves dataplane URL and auth (same pattern as download).
  * @param {string} systemKey - System key
+ * @param {{ silent?: boolean }} [opts] - silent: omit “Resolving dataplane URL…” and discovery success lines
  * @returns {Promise<{ dataplaneUrl: string, authConfig: Object, environment: string }>}
  */
-async function resolveDataplaneAndAuth(systemKey) {
+async function resolveDataplaneAndAuth(systemKey, opts = {}) {
+  const silent = opts.silent === true;
   const { resolveEnvironment } = require('../core/config');
   const environment = await resolveEnvironment();
   const controllerUrl = await resolveControllerUrl();
@@ -82,8 +85,10 @@ async function resolveDataplaneAndAuth(systemKey) {
     throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register <systemKey>" first.');
   }
 
-  logger.log(chalk.gray('Resolving dataplane URL...'));
-  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+  if (!silent) {
+    logger.log(chalk.gray('Resolving dataplane URL...'));
+  }
+  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig, { silent });
   return { dataplaneUrl, authConfig, environment };
 }
 
@@ -167,6 +172,15 @@ async function pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey,
   } else {
     logger.log(chalk.yellow('Secret push skipped'));
   }
+  const resolvedParamNames = collectResolvedVariableConfigurationNames(payload);
+  if (resolvedParamNames.length > 0) {
+    const nameList = ` (${resolvedParamNames.join(', ')})`;
+    logger.log(
+      formatSuccessLine(
+        `Resolved ${resolvedParamNames.length} integration parameter(s) from .env for publish${nameList}.`
+      )
+    );
+  }
   if (pushResult.warning) {
     logger.log(chalk.yellow(`Warning: ${pushResult.warning}`));
   }