@aifabrix/builder 2.45.5 → 2.46.0

package/lib/commands/verify-trust-command-action.js

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview CLI action for `aifabrix verify-trust` (plan 150.0).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const logger = require('../utils/logger');
+const { handleCommandError } = require('../utils/cli-utils');
+const { runVerifyTrustForExternalSystem } = require('./verify-trust-external');
+const { normalizeTestTrustCliOptions } = require('./test-trust-cli-options');
+const { displayVerifyTrustTTY } = require('../lifecycle/report-display');
+const { exitCodeFromVerdict } = require('../lifecycle/exit-codes');
+const { buildJsonEnvelope } = require('../lifecycle/json-envelope');
+
+async function runVerifyTrustCommandAction(appName, options, cmd) {
+  const opts = normalizeTestTrustCliOptions(options, cmd);
+  const pathsUtil = require('../utils/paths');
+  const appType = await pathsUtil.detectAppType(appName).catch(() => null);
+  if (!appType || appType.baseDir !== 'integration') {
+    throw new Error(
+      'verify-trust applies to external integration folders only (integration/<systemKey>/).'
+    );
+  }
+
+  const result = await runVerifyTrustForExternalSystem(appName, {
+    env: opts.env,
+    verbose: opts.verbose,
+    debug: opts.debug,
+    noSync: opts.noSync === true,
+    revalidate: opts.revalidate === true,
+    timeout: opts.timeout
+  });
+
+  if (opts.json) {
+    const envelope = buildJsonEnvelope(
+      {
+        systemKey: result.systemKey,
+        command: result.command,
+        verdict: result.verdict,
+        businessContextConfidencePercent: result.businessContextConfidencePercent,
+        datasourceRows: opts.details ? result.datasourceRows : undefined
+      },
+      opts.details || opts.verbose
+    );
+    logger.log(JSON.stringify(envelope, null, 2));
+  } else {
+    displayVerifyTrustTTY(result.systemKey, result, { details: opts.verbose || opts.details });
+  }
+
+  const exitCode = exitCodeFromVerdict(result.verdict);
+  if (exitCode !== 0) {
+    process.exit(exitCode);
+  }
+}
+
+async function verifyTrustCommandHandler(appName, options, cmd) {
+  try {
+    await runVerifyTrustCommandAction(appName, options, cmd);
+  } catch (error) {
+    handleCommandError(error, 'verify-trust');
+    process.exit(3);
+  }
+}
+
+module.exports = {
+  runVerifyTrustCommandAction,
+  verifyTrustCommandHandler
+};

package/lib/commands/verify-trust-external.js

@@ -0,0 +1,67 @@
+/**
+ * @fileoverview verify-trust orchestration with product-model rollup (plan 150.0).
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { runTestTrustForExternalSystem } = require('./test-trust-external');
+const {
+  VERDICT,
+  verdictFromPassed,
+  worstConfidencePercent
+} = require('../lifecycle/product-model');
+
+/**
+ * @param {Array<Object>} rows
+ * @returns {Array<Object>}
+ */
+function mapTrustDatasourceRows(rows) {
+  return (rows || []).map(row => {
+    const tr = row.trustRun;
+    const confidencePercent =
+      tr && typeof tr.confidence === 'number' ? Math.round(tr.confidence * 100) : null;
+    const verdict = row.success ? VERDICT.VERIFIED : VERDICT.FAILED;
+    return {
+      datasourceKey: row.key,
+      verdict,
+      confidencePercent,
+      trustDecision: tr?.trustDecision,
+      error: row.error
+    };
+  });
+}
+
+/**
+ * @async
+ * @param {string} systemKey
+ * @param {Object} options
+ * @returns {Promise<Object>}
+ */
+async function runVerifyTrustForExternalSystem(systemKey, options = {}) {
+  const { success, results, systemKey: resolvedKey } = await runTestTrustForExternalSystem(
+    systemKey,
+    options
+  );
+  const datasourceRows = mapTrustDatasourceRows(results);
+  const confidences = datasourceRows
+    .map(r => (typeof r.confidencePercent === 'number' ? r.confidencePercent / 100 : null))
+    .filter(v => v !== null);
+  const businessContextConfidencePercent = worstConfidencePercent(confidences);
+  const verdict = verdictFromPassed(success);
+
+  return {
+    systemKey: resolvedKey || systemKey,
+    command: 'verify-trust',
+    verdict,
+    businessContextConfidencePercent,
+    datasourceRows,
+    results
+  };
+}
+
+module.exports = {
+  runVerifyTrustForExternalSystem,
+  mapTrustDatasourceRows
+};

package/lib/commands/wizard-config-normalizer.js

@@ -17,6 +17,7 @@ const VALID_ENTITY_TYPES = new Set([
   'none'
 ]);
 const VALID_PORTAL_FIELDS = new Set(['text', 'textarea', 'select', 'json', 'boolean', 'number']);
+const { repairTestPayload } = require('./repair-datasource-test-payload');
 
 /**
  * Normalize system config fields to schema constraints
@@ -34,6 +35,45 @@ function normalizeSystemConfig(systemConfig) {
   return systemConfig;
 }
 
+/**
+ * @param {Object} datasourceConfig - Datasource config (mutated)
+ */
+function normalizePortalInput(datasourceConfig) {
+  if (!Array.isArray(datasourceConfig.portalInput)) return;
+  datasourceConfig.portalInput = datasourceConfig.portalInput.filter(item => {
+    if (!item || typeof item !== 'object') return false;
+    if (!item.name || !item.field || !item.label) return false;
+    return VALID_PORTAL_FIELDS.has(item.field);
+  });
+}
+
+/**
+ * @param {Object} datasourceConfig - Datasource config (mutated)
+ */
+function normalizeCipOutputModes(datasourceConfig) {
+  const operations = datasourceConfig.execution?.cip?.operations;
+  if (!operations) return;
+  for (const operation of Object.values(operations)) {
+    if (!operation || !Array.isArray(operation.steps)) continue;
+    for (const step of operation.steps) {
+      if (step?.output?.mode && step.output.mode !== 'records') {
+        step.output.mode = 'records';
+      }
+    }
+  }
+}
+
+/**
+ * @param {Object} datasourceConfig - Datasource config (mutated)
+ */
+function normalizeWizardTestPayload(datasourceConfig) {
+  const attrs = datasourceConfig.fieldMappings?.attributes;
+  if (!datasourceConfig.metadataSchema || !attrs || Object.keys(attrs).length === 0) {
+    return;
+  }
+  repairTestPayload(datasourceConfig, []);
+}
+
 /**
  * Normalize datasource config fields to schema constraints
  * @function normalizeDatasourceConfig
@@ -47,29 +87,9 @@ function normalizeDatasourceConfig(datasourceConfig) {
   if (datasourceConfig.entityType && !VALID_ENTITY_TYPES.has(datasourceConfig.entityType)) {
     datasourceConfig.entityType = ENTITY_TYPE_FALLBACK;
   }
-  if (Array.isArray(datasourceConfig.portalInput)) {
-    datasourceConfig.portalInput = datasourceConfig.portalInput.filter(item => {
-      if (!item || typeof item !== 'object') {
-        return false;
-      }
-      if (!item.name || !item.field || !item.label) {
-        return false;
-      }
-      return VALID_PORTAL_FIELDS.has(item.field);
-    });
-  }
-  if (datasourceConfig.execution?.cip?.operations) {
-    for (const operation of Object.values(datasourceConfig.execution.cip.operations)) {
-      if (!operation || !Array.isArray(operation.steps)) {
-        continue;
-      }
-      for (const step of operation.steps) {
-        if (step?.output?.mode && step.output.mode !== 'records') {
-          step.output.mode = 'records';
-        }
-      }
-    }
-  }
+  normalizePortalInput(datasourceConfig);
+  normalizeCipOutputModes(datasourceConfig);
+  normalizeWizardTestPayload(datasourceConfig);
   return datasourceConfig;
 }
 

package/lib/commands/wizard-core.js

@@ -512,7 +512,9 @@ async function setupDataplaneAndAuth(options, appName) {
   } catch (error) {
     throw new Error(`Authentication failed: ${error.message}`);
   }
+  const { applyLabDataplaneApiKeyBearer } = require('../utils/token-manager');
   requireBearerForDataplanePipeline(authConfig);
+  applyLabDataplaneApiKeyBearer(authConfig);
   const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
   let dataplaneUrl;
   try {

package/lib/core/admin-password-generator.js

@@ -0,0 +1,38 @@
+/**
+ * Cryptographically strong passwords for pro setup autogenerate.
+ *
+ * @fileoverview Pro installation password generation (show-once in setup wizard)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+
+const PRO_PASSWORD_BYTE_LENGTH = 18;
+
+/**
+ * One random password suitable for admin roles (URL-safe, no quotes).
+ * @returns {string}
+ */
+function generateRandomAdminPassword() {
+  return crypto.randomBytes(PRO_PASSWORD_BYTE_LENGTH).toString('base64url');
+}
+
+/**
+ * Distinct passwords for infra, Keycloak install, and platform UI login.
+ * @returns {{ infra: string, keycloak: string, platform: string }}
+ */
+function generateProAdminPasswords() {
+  return {
+    infra: generateRandomAdminPassword(),
+    keycloak: generateRandomAdminPassword(),
+    platform: generateRandomAdminPassword()
+  };
+}
+
+module.exports = {
+  generateRandomAdminPassword,
+  generateProAdminPasswords
+};

package/lib/core/admin-secrets-bundle.js

@@ -0,0 +1,111 @@
+/**
+ * Map setup password bundles onto admin-secrets.env keys.
+ *
+ * @fileoverview Single (dev) vs split (pro) admin credential bundles
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const DEFAULT_REDIS_HOST = 'local:redis:6379:0:';
+const DEFAULT_REDIS_COMMANDER_USER = 'admin';
+const DEFAULT_KEYCLOAK_ADMIN_USERNAME = 'admin';
+
+/**
+ * @typedef {'single'|'split'} AdminPasswordBundleMode
+ */
+
+/**
+ * @typedef {Object} AdminPasswordBundleSingle
+ * @property {'single'} mode
+ * @property {string} password
+ */
+
+/**
+ * @typedef {Object} AdminPasswordBundleSplit
+ * @property {'split'} mode
+ * @property {string} infra
+ * @property {string} keycloak
+ * @property {string} platform
+ */
+
+/**
+ * @param {string} password
+ * @returns {AdminPasswordBundleSingle}
+ */
+function singlePasswordBundle(password) {
+  return { mode: 'single', password: String(password) };
+}
+
+/**
+ * @param {{ infra: string, keycloak: string, platform: string }} parts
+ * @returns {AdminPasswordBundleSplit}
+ */
+function splitPasswordBundle(parts) {
+  return {
+    mode: 'split',
+    infra: String(parts.infra),
+    keycloak: String(parts.keycloak),
+    platform: String(parts.platform)
+  };
+}
+
+/**
+ * Apply bundle onto a decrypted admin-secrets object (mutates copy).
+ * @param {Object.<string, string>} adminObj
+ * @param {AdminPasswordBundleSingle|AdminPasswordBundleSplit} bundle
+ * @returns {Object.<string, string>}
+ */
+function applyPasswordBundleToAdminObj(adminObj, bundle) {
+  const merged = { ...(adminObj || {}) };
+  merged.REDIS_HOST = merged.REDIS_HOST || DEFAULT_REDIS_HOST;
+  merged.REDIS_COMMANDER_USER = merged.REDIS_COMMANDER_USER || DEFAULT_REDIS_COMMANDER_USER;
+  merged.KEYCLOAK_ADMIN_USERNAME = DEFAULT_KEYCLOAK_ADMIN_USERNAME;
+
+  if (bundle.mode === 'single') {
+    const p = bundle.password;
+    merged.POSTGRES_PASSWORD = p;
+    merged.PGADMIN_DEFAULT_PASSWORD = p;
+    merged.REDIS_COMMANDER_PASSWORD = p;
+    merged.KEYCLOAK_ADMIN_PASSWORD = p;
+    merged.PLATFORM_ADMIN_PASSWORD = p;
+    return merged;
+  }
+
+  merged.POSTGRES_PASSWORD = bundle.infra;
+  merged.PGADMIN_DEFAULT_PASSWORD = bundle.infra;
+  merged.REDIS_COMMANDER_PASSWORD = bundle.infra;
+  merged.KEYCLOAK_ADMIN_PASSWORD = bundle.keycloak;
+  merged.PLATFORM_ADMIN_PASSWORD = bundle.platform;
+  return merged;
+}
+
+/**
+ * Build bundle from setup / up-infra CLI options.
+ * @param {Object} [options]
+ * @returns {AdminPasswordBundleSingle|AdminPasswordBundleSplit|null}
+ */
+function passwordBundleFromCliOptions(options = {}) {
+  if (options.passwordBundle && options.passwordBundle.mode) {
+    return options.passwordBundle;
+  }
+  const infra = String(options.infraAdminPassword || '').trim();
+  const keycloak = String(options.keycloakAdminPassword || '').trim();
+  const platform = String(options.platformAdminPassword || '').trim();
+  if (infra && keycloak && platform) {
+    return splitPasswordBundle({ infra, keycloak, platform });
+  }
+  const single = String(options.adminPassword || options.adminPwd || '').trim();
+  if (single) {
+    return singlePasswordBundle(single);
+  }
+  return null;
+}
+
+module.exports = {
+  singlePasswordBundle,
+  splitPasswordBundle,
+  applyPasswordBundleToAdminObj,
+  passwordBundleFromCliOptions
+};

package/lib/core/admin-secrets-env-overlay.js

@@ -0,0 +1,62 @@
+/**
+ * Map decrypted admin-secrets.env into platform container env keys.
+ *
+ * @fileoverview Overlay KEYCLOAK_* / ONBOARDING_* from admin-secrets (plan 185 Phase 2)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * @param {Object.<string, string>} adminObj
+ * @returns {Object.<string, string>}
+ */
+function buildPlatformEnvOverlayFromAdminSecrets(adminObj) {
+  if (!adminObj || typeof adminObj !== 'object') return {};
+  const platformPwd =
+    adminObj.PLATFORM_ADMIN_PASSWORD ||
+    adminObj.ONBOARDING_ADMIN_PASSWORD ||
+    adminObj.MISO_ADMIN_PASSWORD ||
+    '';
+  const overlay = {};
+  if (adminObj.KEYCLOAK_ADMIN_USERNAME) {
+    overlay.KEYCLOAK_ADMIN_USERNAME = adminObj.KEYCLOAK_ADMIN_USERNAME;
+  }
+  if (adminObj.KEYCLOAK_ADMIN_PASSWORD) {
+    overlay.KEYCLOAK_ADMIN_PASSWORD = adminObj.KEYCLOAK_ADMIN_PASSWORD;
+    // Keycloak image reads KC_BOOTSTRAP_* on first start; keep in sync with admin-secrets (pro split bundles).
+    overlay.KC_BOOTSTRAP_ADMIN_PASSWORD = adminObj.KEYCLOAK_ADMIN_PASSWORD;
+    overlay.KC_BOOTSTRAP_ADMIN_USERNAME =
+      adminObj.KEYCLOAK_ADMIN_USERNAME || adminObj.KC_BOOTSTRAP_ADMIN_USERNAME || 'admin';
+  }
+  if (platformPwd) {
+    overlay.PLATFORM_ADMIN_PASSWORD = platformPwd;
+    overlay.ONBOARDING_ADMIN_PASSWORD = platformPwd;
+    overlay.MISO_ADMIN_PASSWORD = platformPwd;
+  }
+  const email = adminObj.PGADMIN_DEFAULT_EMAIL || adminObj.ONBOARDING_ADMIN_EMAIL;
+  if (email) {
+    overlay.ONBOARDING_ADMIN_EMAIL = email;
+  }
+  return overlay;
+}
+
+/**
+ * Apply admin-secrets values over resolved app env (admin-secrets wins for platform keys).
+ * @param {Object.<string, string>} envMap
+ * @param {Object.<string, string>} adminObj
+ */
+function applyAdminSecretsPlatformOverlay(envMap, adminObj) {
+  const overlay = buildPlatformEnvOverlayFromAdminSecrets(adminObj);
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value !== undefined && value !== null && String(value).trim() !== '') {
+      envMap[key] = String(value);
+    }
+  }
+}
+
+module.exports = {
+  buildPlatformEnvOverlayFromAdminSecrets,
+  applyAdminSecretsPlatformOverlay
+};

package/lib/core/admin-secrets.js

@@ -16,6 +16,31 @@ const config = require('./config');
 const { decryptSecret, isEncrypted } = require('../utils/secrets-encryption');
 const { ensureSecureFilePermissions } = require('../utils/secure-file-permissions');
 
+/**
+ * Whether an admin-secrets.env value must be double-quoted for safe round-trip parsing.
+ * @param {string} value
+ * @returns {boolean}
+ */
+function needsAdminEnvQuoting(value) {
+  const s = String(value ?? '');
+  return /[,\s#=]/.test(s) || s !== s.trim();
+}
+
+/**
+ * Format one KEY=value line for admin-secrets.env (quotes when needed).
+ * @param {string} key
+ * @param {string} value - Plaintext value (not yet encrypted)
+ * @returns {string}
+ */
+function formatAdminEnvLine(key, value) {
+  const safe = String(value ?? '').replace(/\n/g, ' ').trim();
+  if (!needsAdminEnvQuoting(safe)) {
+    return `${key}=${safe}`;
+  }
+  const escaped = safe.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+  return `${key}="${escaped}"`;
+}
+
 /**
  * Parse .env-style content into key-value map (excludes comments and empty lines).
  * Values are trimmed; does not unescape quotes.
@@ -33,7 +58,9 @@ function parseAdminEnvContent(content) {
     if (eq > 0) {
       const key = trimmed.substring(0, eq).trim();
       let value = trimmed.substring(eq + 1);
-      if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith('\'') && value.endsWith('\''))) {
+      if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
+        value = value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+      } else if (value.length >= 2 && value.startsWith('\'') && value.endsWith('\'')) {
         value = value.slice(1, -1);
       }
       map[key] = value.trim();
@@ -94,8 +121,7 @@ function envObjectToContent(obj) {
   const lines = [];
   for (const [key, value] of Object.entries(obj)) {
     if (key === undefined || key === '') continue;
-    const safe = String(value ?? '').replace(/\n/g, ' ').trim();
-    lines.push(`${key}=${safe}`);
+    lines.push(formatAdminEnvLine(key, value));
   }
   return lines.join('\n');
 }
@@ -103,5 +129,7 @@ function envObjectToContent(obj) {
 module.exports = {
   readAndDecryptAdminSecrets,
   parseAdminEnvContent,
-  envObjectToContent
+  envObjectToContent,
+  needsAdminEnvQuoting,
+  formatAdminEnvLine
 };

package/lib/core/config-attach-extensions.js

@@ -41,6 +41,9 @@ function attachConfigExtensions(exportsObj, deps) {
 
   const { createScopedResourcesPreferenceFunctions } = require('../utils/config-scoped-resources-preference');
   Object.assign(exportsObj, createScopedResourcesPreferenceFunctions(getConfig, saveConfig));
+
+  const { createSecretsPathFunctions } = require('../utils/config-secrets-path');
+  Object.assign(exportsObj, createSecretsPathFunctions(getConfig, saveConfig));
 }
 
 module.exports = { attachConfigExtensions };

package/lib/core/config-platform-controller.js

@@ -0,0 +1,44 @@
+/**
+ * `platform-controller` field in `config.yaml` — absolute Miso URL for setup / platform flows.
+ *
+ * @fileoverview config.yaml platform-controller helpers
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * @param {() => Promise<Object>} getConfig
+ * @returns {Promise<string|null>}
+ */
+async function getPlatformControllerUrlFromConfig(getConfig) {
+  const cfg = await getConfig();
+  const raw = cfg && cfg['platform-controller'];
+  if (typeof raw === 'string' && raw.trim()) {
+    return raw.trim().replace(/\/+$/, '');
+  }
+  return null;
+}
+
+/**
+ * @param {() => Promise<Object>} getConfig
+ * @param {(data: Object) => Promise<void>} saveConfig
+ * @param {(url: string) => string} normalizeControllerUrl
+ * @param {string} url
+ * @returns {Promise<void>}
+ */
+async function setPlatformControllerUrlInConfig(getConfig, saveConfig, normalizeControllerUrl, url) {
+  if (!url || typeof url !== 'string') {
+    throw new Error('Platform controller URL is required and must be a string');
+  }
+  const normalized = normalizeControllerUrl(url);
+  const cfg = await getConfig();
+  cfg['platform-controller'] = normalized;
+  await saveConfig(cfg);
+}
+
+module.exports = {
+  getPlatformControllerUrlFromConfig,
+  setPlatformControllerUrlInConfig
+};

package/lib/core/config-setup-installation-profile.js

@@ -0,0 +1,42 @@
+/**
+ * `setupInstallationProfile` field in `config.yaml` (`dev` | `pro`).
+ *
+ * @fileoverview Persists setup wizard installation profile
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const { normalizeInstallationProfile, INSTALLATION_PROFILE } = require('./setup-installation-profile');
+
+/**
+ * @param {() => Promise<Object>} getConfig
+ * @returns {Promise<'dev'|'pro'>}
+ */
+async function getSetupInstallationProfileFromConfig(getConfig) {
+  const cfg = await getConfig();
+  if (cfg && cfg.setupInstallationProfile) {
+    return normalizeInstallationProfile(cfg.setupInstallationProfile);
+  }
+  return INSTALLATION_PROFILE.DEV;
+}
+
+/**
+ * @param {() => Promise<Object>} getConfig
+ * @param {(data: Object) => Promise<void>} saveConfig
+ * @param {unknown} profile
+ * @returns {Promise<'dev'|'pro'>}
+ */
+async function setSetupInstallationProfileInConfig(getConfig, saveConfig, profile) {
+  const normalized = normalizeInstallationProfile(profile);
+  const cfg = await getConfig();
+  cfg.setupInstallationProfile = normalized;
+  await saveConfig(cfg);
+  return normalized;
+}
+
+module.exports = {
+  getSetupInstallationProfileFromConfig,
+  setSetupInstallationProfileInConfig
+};

package/lib/core/config-setup-platform-mode.js

@@ -0,0 +1,46 @@
+/**
+ * `setupPlatformMode` field in `config.yaml` (`single` | `full`).
+ *
+ * @fileoverview Persists setup wizard platform mode
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const {
+  normalizeSetupPlatformMode,
+  SETUP_PLATFORM_MODE
+} = require('./setup-platform-mode');
+
+/**
+ * @param {() => Promise<Object>} getConfig
+ * @returns {Promise<'single'|'full'>}
+ */
+async function getSetupPlatformModeFromConfig(getConfig) {
+  const cfg = await getConfig();
+  if (cfg && cfg.setupPlatformMode) {
+    return normalizeSetupPlatformMode(cfg.setupPlatformMode);
+  }
+  return SETUP_PLATFORM_MODE.SINGLE;
+}
+
+/**
+ * @param {() => Promise<Object>} getConfig
+ * @param {(data: Object) => Promise<void>} saveConfig
+ * @param {unknown} mode
+ * @returns {Promise<'single'|'full'>}
+ */
+async function setSetupPlatformModeInConfig(getConfig, saveConfig, mode) {
+  const normalized = normalizeSetupPlatformMode(mode);
+  const cfg = await getConfig();
+  cfg.setupPlatformMode = normalized;
+  await saveConfig(cfg);
+  return normalized;
+}
+
+module.exports = {
+  getSetupPlatformModeFromConfig,
+  setSetupPlatformModeInConfig
+};
+