@aifabrix/builder 2.46.0 → 2.47.0

package/lib/commands/resource-type.js

@@ -0,0 +1,371 @@
+/**
+ * Resource type catalog commands (Controller).
+ *
+ * Commands:
+ * - aifabrix resource-type create
+ * - aifabrix resource-type import
+ * - aifabrix resource-type get
+ * - aifabrix resource-type list
+ *
+ * @fileoverview Resource type CLI commands
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+const { resolveControllerUrl } = require('../utils/controller-url');
+const { normalizeControllerUrl, resolveEnvironment } = require('../core/config');
+const { getOrRefreshDeviceToken } = require('../utils/token-manager');
+const {
+  readResourceTypeCreateFile,
+  readResourceTypeCatalogFile
+} = require('../resolvers/resource-type-file');
+const {
+  formatBlockingError,
+  formatSuccessLine,
+  infoLine,
+  headerKeyValue
+} = require('../utils/cli-layout-chalk');
+const {
+  listResourceTypes,
+  getResourceType,
+  createResourceTypeIdempotent
+} = require('../api/resource-types.api');
+
+const RESOURCE_TYPE_KEY_PATTERN = /^[a-z][a-z0-9-]*$/;
+
+/** Parent help for `aifabrix resource-type -h`. */
+const RESOURCE_TYPE_HELP_AFTER = `
+
+Examples:
+  $ aifabrix resource-type create --key customer --display-name "Customer"
+  $ aifabrix resource-type get customer
+  $ aifabrix resource-type list --search customer
+
+Per-command help:  aifabrix resource-type <command> --help
+`;
+
+const RESOURCE_TYPE_IMPORT_HELP_AFTER = `
+
+Examples:
+  $ aifabrix resource-type import --file ./baseline-resourcetypes.json
+  $ aifabrix resource-type import --file /path/to/catalog.json
+
+`;
+
+const RESOURCE_TYPE_CREATE_HELP_AFTER = `
+
+Examples:
+  $ aifabrix resource-type create --key customer --display-name "Customer"
+  $ aifabrix resource-type create --key deal --display-name "Deal" --category business --default-risk-level medium
+  $ aifabrix resource-type create --file ./customer.json
+
+`;
+
+const RESOURCE_TYPE_GET_HELP_AFTER = `
+
+Examples:
+  $ aifabrix resource-type get customer
+  $ aifabrix resource-type get clx1234567890abcdef
+
+`;
+
+const RESOURCE_TYPE_LIST_HELP_AFTER = `
+
+Examples:
+  $ aifabrix resource-type list
+  $ aifabrix resource-type list --page 1 --page-size 50
+  $ aifabrix resource-type list --search customer
+
+`;
+
+/**
+ * @param {string} raw
+ * @returns {string}
+ */
+function requireResourceTypeKey(raw) {
+  const key = String(raw || '').trim();
+  if (!key) {
+    throw new Error('Resource type key is required (--key <key> or --file <path>).');
+  }
+  if (!RESOURCE_TYPE_KEY_PATTERN.test(key)) {
+    throw new Error(
+      'Resource type key must start with a lowercase letter and contain only lowercase letters, numbers, and hyphens.'
+    );
+  }
+  return key;
+}
+
+/**
+ * @param {Object} options
+ * @returns {Promise<{ controllerUrl: string, authConfig: Object }>}
+ */
+async function resolveControllerAndAuth(_options) {
+  const controllerUrl = await resolveControllerUrl();
+  if (!controllerUrl) {
+    throw new Error('Controller URL is required. Run "aifabrix login" first.');
+  }
+  const normalized = normalizeControllerUrl(controllerUrl);
+  const deviceToken = await getOrRefreshDeviceToken(normalized);
+  if (!deviceToken || !deviceToken.token) {
+    throw new Error(
+      `Not authenticated for controller: ${controllerUrl}. ` +
+        'Run "aifabrix login" and try again.'
+    );
+  }
+  return {
+    controllerUrl: deviceToken.controller || normalized,
+    authConfig: { type: 'bearer', token: deviceToken.token }
+  };
+}
+
+async function resolveHeaderContext() {
+  const env = await resolveEnvironment();
+  const controllerUrl = await resolveControllerUrl();
+  const normalized = normalizeControllerUrl(controllerUrl);
+  return { environment: env || 'dev', controllerUrl: normalized };
+}
+
+/**
+ * @param {Object} options
+ * @returns {Object}
+ */
+function buildCreatePayload(options) {
+  let base = {};
+  if (options.file) {
+    base = readResourceTypeCreateFile(options.file);
+  }
+  const payload = { ...base };
+  if (options.key) payload.key = options.key;
+  if (options.displayName) payload.displayName = options.displayName;
+  if (options.description !== undefined) payload.description = options.description;
+  if (options.category) payload.category = options.category;
+  if (options.defaultRiskLevel) payload.defaultRiskLevel = options.defaultRiskLevel;
+  if (options.status) payload.status = options.status;
+  payload.key = requireResourceTypeKey(payload.key);
+  if (!payload.displayName) {
+    throw new Error('displayName is required (--display-name <name> or in --file).');
+  }
+  return payload;
+}
+
+/**
+ * @param {Object} response
+ * @returns {any}
+ */
+function unwrapControllerData(response) {
+  return response?.data?.data ?? response?.data ?? response;
+}
+
+/**
+ * @param {import('commander').Command} rt
+ */
+/**
+ * @param {Object[]} rows
+ * @param {string} controllerUrl
+ * @param {Object} authConfig
+ * @returns {Promise<{ created: number, existed: number, total: number }>}
+ */
+async function importResourceTypeRows(rows, controllerUrl, authConfig) {
+  let created = 0;
+  let existed = 0;
+  for (const row of rows) {
+    const payload = { ...row };
+    payload.key = requireResourceTypeKey(payload.key);
+    const out = await createResourceTypeIdempotent(controllerUrl, authConfig, payload);
+    if (out.created) {
+      created += 1;
+      continue;
+    }
+    existed += 1;
+  }
+  return { created, existed, total: rows.length };
+}
+
+function setupResourceTypeImportCommand(rt) {
+  rt
+    .command('import')
+    .description('Import resource types from baseline catalog JSON (idempotent)')
+    .addHelpText('after', RESOURCE_TYPE_IMPORT_HELP_AFTER)
+    .requiredOption('--file <path>', 'Baseline catalog (resourceTypes[]) or JSON array')
+    .action(async(options) => {
+      try {
+        const { controllerUrl, authConfig } = await resolveControllerAndAuth(options);
+        const rows = readResourceTypeCatalogFile(options.file);
+        const summary = await importResourceTypeRows(rows, controllerUrl, authConfig);
+        logger.log(
+          formatSuccessLine(
+            `Resource types imported: ${summary.total} total ` +
+              `(${summary.created} created, ${summary.existed} already existed)`
+          )
+        );
+      } catch (e) {
+        logger.error(formatBlockingError(e.message));
+        process.exit(1);
+      }
+    });
+}
+
+function setupResourceTypeCreateCommand(rt) {
+  rt
+    .command('create')
+    .description('Create resource type (idempotent; success if it already exists)')
+    .addHelpText('after', RESOURCE_TYPE_CREATE_HELP_AFTER)
+    .option('--file <path>', 'Read resource type create payload from JSON file')
+    .option('--key <key>', 'Catalog key (lowercase letters, digits, hyphens)')
+    .option('--display-name <name>', 'Display name')
+    .option('--description <text>', 'Description')
+    .option(
+      '--category <category>',
+      'business | collaboration | governance | content | communication | people'
+    )
+    .option('--default-risk-level <level>', 'low | medium | high | critical')
+    .option('--status <status>', 'draft | active | deprecated | retired')
+    .action(async(options) => {
+      try {
+        const { controllerUrl, authConfig } = await resolveControllerAndAuth(options);
+        const payload = buildCreatePayload(options);
+        const out = await createResourceTypeIdempotent(controllerUrl, authConfig, payload);
+        const row = unwrapControllerData(out.response);
+        const category = row.category || payload.category || 'business';
+        const risk = row.defaultRiskLevel || payload.defaultRiskLevel || 'medium';
+        if (out.created) {
+          logger.log(
+            formatSuccessLine(`Resource type created: ${row.key} (category: ${category}, risk: ${risk})`)
+          );
+          return;
+        }
+        logger.log(formatSuccessLine(`Resource type exists: ${row.key} (category: ${category}, risk: ${risk})`));
+        logger.log(infoLine('No changes were needed.'));
+      } catch (e) {
+        logger.error(formatBlockingError(e.message));
+        process.exit(1);
+      }
+    });
+}
+
+function setupResourceTypeGetCommand(rt) {
+  rt
+    .command('get <resourceTypeIdOrKey>')
+    .description('Get resource type by id or key')
+    .addHelpText('after', RESOURCE_TYPE_GET_HELP_AFTER)
+    .action(async(resourceTypeIdOrKey, options) => {
+      try {
+        const { environment, controllerUrl: headerControllerUrl } = await resolveHeaderContext();
+        const { controllerUrl, authConfig } = await resolveControllerAndAuth(options);
+        const res = await getResourceType(controllerUrl, authConfig, String(resourceTypeIdOrKey).trim());
+        const row = unwrapControllerData(res);
+        logger.log(
+          chalk.bold(`\n🏷️  Resource type in ${environment} environment (${headerControllerUrl}):\n`)
+        );
+        logger.log(headerKeyValue('Key:', row.key || '—'));
+        logger.log(headerKeyValue('Display:', row.displayName || '—'));
+        logger.log(headerKeyValue('Category:', row.category || '—'));
+        logger.log(headerKeyValue('Default risk:', row.defaultRiskLevel || '—'));
+        logger.log(headerKeyValue('Status:', row.status || '—'));
+        if (row.description) {
+          logger.log(headerKeyValue('Description:', row.description));
+        }
+        logger.log('');
+      } catch (e) {
+        logger.error(formatBlockingError(e.message));
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * @param {Array<Object>} items
+ * @param {string} environment
+ * @param {string} controllerUrl
+ */
+function displayResourceTypeList(items, environment, controllerUrl) {
+  logger.log(
+    chalk.bold(`\n🏷️  Resource types in ${environment} environment (${controllerUrl}):\n`)
+  );
+  if (!Array.isArray(items) || items.length === 0) {
+    logger.log(chalk.gray('  No resource types found.\n'));
+    return;
+  }
+
+  const KEY_WIDTH = 22;
+  const DISPLAY_WIDTH = 30;
+  const CATEGORY_WIDTH = 16;
+  const RISK_WIDTH = 10;
+  const STATUS_WIDTH = 12;
+  const SEP_LEN = KEY_WIDTH + DISPLAY_WIDTH + CATEGORY_WIDTH + RISK_WIDTH + STATUS_WIDTH;
+
+  const keyCol = 'Key'.padEnd(KEY_WIDTH);
+  const displayCol = 'Display'.padEnd(DISPLAY_WIDTH);
+  const categoryCol = 'Category'.padEnd(CATEGORY_WIDTH);
+  const riskCol = 'Risk'.padEnd(RISK_WIDTH);
+  const statusCol = 'Status'.padEnd(STATUS_WIDTH);
+  logger.log(chalk.gray(`${keyCol}${displayCol}${categoryCol}${riskCol}${statusCol}`));
+  logger.log(chalk.gray('-'.repeat(SEP_LEN)));
+
+  items.forEach((d) => {
+    const key = (d?.key ?? '—').toString().padEnd(KEY_WIDTH);
+    const displayName = (d?.displayName ?? '—').toString().padEnd(DISPLAY_WIDTH);
+    const category = (d?.category ?? '—').toString().padEnd(CATEGORY_WIDTH);
+    const risk = (d?.defaultRiskLevel ?? '—').toString().padEnd(RISK_WIDTH);
+    const status = (d?.status ?? '—').toString().padEnd(STATUS_WIDTH);
+    logger.log(`${key}${displayName}${category}${risk}${status}`);
+  });
+  logger.log('');
+}
+
+function setupResourceTypeListCommand(rt) {
+  rt
+    .command('list')
+    .description('List resource types')
+    .addHelpText('after', RESOURCE_TYPE_LIST_HELP_AFTER)
+    .option('--page <n>', 'Page', (v) => parseInt(v, 10))
+    .option('--page-size <n>', 'Page size', (v) => parseInt(v, 10))
+    .option('--search <text>', 'Search by key/displayName/description')
+    .option('--category <category>', 'Filter by category')
+    .option('--status <status>', 'Filter by status')
+    .action(async(options) => {
+      try {
+        const { environment, controllerUrl: headerControllerUrl } = await resolveHeaderContext();
+        const { controllerUrl, authConfig } = await resolveControllerAndAuth(options);
+        const res = await listResourceTypes(controllerUrl, authConfig, {
+          page: options.page,
+          pageSize: options.pageSize,
+          search: options.search,
+          category: options.category,
+          status: options.status
+        });
+        const payload = unwrapControllerData(res);
+        const items = payload?.data ?? payload ?? [];
+        displayResourceTypeList(items, environment, headerControllerUrl);
+      } catch (e) {
+        logger.error(formatBlockingError(e.message));
+        process.exit(1);
+      }
+    });
+}
+
+/**
+ * @param {import('commander').Command} program
+ */
+function setupResourceTypeCommands(program) {
+  const rt = program
+    .command('resource-type')
+    .description('Manage the Controller Resource Type Catalog (COM)')
+    .addHelpText('after', RESOURCE_TYPE_HELP_AFTER);
+  setupResourceTypeCreateCommand(rt);
+  setupResourceTypeImportCommand(rt);
+  setupResourceTypeGetCommand(rt);
+  setupResourceTypeListCommand(rt);
+}
+
+module.exports = {
+  setupResourceTypeCommands,
+  requireResourceTypeKey,
+  buildCreatePayload,
+  unwrapControllerData,
+  importResourceTypeRows
+};

package/lib/commands/setup-modes.js

@@ -263,7 +263,7 @@ async function runUpPlatform(opts = {}) {
   if (opts.force === true && opts.skipForceClean !== true) {
     const cleanedApps =
       preflight.skipClean !== true
-        ? await upCommon.cleanBuilderAppDirs(PLATFORM_APPS, { silent: true })
+        ? await upCommon.cleanBuilderAppDirs(upCommon.PLATFORM_BUILDER_CLEAN_APP_KEYS, { silent: true })
         : [];
     forceCleanSummary = { forceSummary: authCtx.forceSummary, cleanedApps };
   }

package/lib/commands/setup-prompts-platform-mode.js

@@ -1,5 +1,5 @@
 /**
- * Setup prompts for platform topology mode (single vs full).
+ * Setup prompts for platform topology mode (single vs single-traefik; full via CLI only).
  *
  * @fileoverview Setup platform mode prompt + CLI option normalization
  * @author AI Fabrix Team
@@ -9,31 +9,43 @@
 'use strict';
 
 const inquirer = require('inquirer');
-const { normalizeSetupPlatformMode, SETUP_PLATFORM_MODE } = require('../core/setup-platform-mode');
+const {
+  normalizeSetupPlatformMode,
+  SETUP_PLATFORM_MODE,
+  SETUP_PLATFORM_MODE_CLI_VALUES,
+  getSetupPlatformModePromptChoices
+} = require('../core/setup-platform-mode');
 
 /**
  * Resolve platform mode from CLI options, if provided.
  * @param {Object} [options]
- * @returns {'single'|'full'|null}
+ * @returns {'single'|'single-traefik'|'full'|null}
  */
 function resolvePlatformModeFromOptions(options = {}) {
   const raw = options.platform;
   if (raw === undefined || raw === null || String(raw).trim() === '') {
     return null;
   }
-  const normalized = normalizeSetupPlatformMode(raw);
-  // Guard: only accept exact canonical values from CLI; reject unexpected to avoid silent typos.
   const rawNorm = String(raw).trim().toLowerCase();
-  if (rawNorm !== 'single' && rawNorm !== 'full') {
-    throw new Error('--platform must be single or full (example: aifabrix setup --platform full)');
+  const isCanonical = SETUP_PLATFORM_MODE_CLI_VALUES.includes(rawNorm);
+  const isAlias =
+    rawNorm === 'ingress' ||
+    rawNorm === 'single-ingress' ||
+    rawNorm === 'traefik' ||
+    rawNorm === 'all' ||
+    rawNorm === 'full-platform' ||
+    rawNorm === 'platform-full';
+  if (!isCanonical && !isAlias) {
+    const allowed = SETUP_PLATFORM_MODE_CLI_VALUES.join(', ');
+    throw new Error(`--platform must be one of: ${allowed} (example: aifabrix setup --platform single-traefik)`);
   }
-  return normalized;
+  return normalizeSetupPlatformMode(raw);
 }
 
 /**
  * @async
  * @param {Object} [options]
- * @returns {Promise<'single'|'full'>}
+ * @returns {Promise<'single'|'single-traefik'|'full'>}
  */
 async function promptSetupPlatformMode(options = {}) {
   const fromCli = resolvePlatformModeFromOptions(options);
@@ -44,16 +56,7 @@ async function promptSetupPlatformMode(options = {}) {
       type: 'list',
       name: 'mode',
       message: 'Platform mode:',
-      choices: [
-        {
-          name: 'Single environment — direct ports (no Traefik front door)',
-          value: SETUP_PLATFORM_MODE.SINGLE
-        },
-        {
-          name: 'Full platform — Traefik front door + miso/dev/tst/pro (shared infra)',
-          value: SETUP_PLATFORM_MODE.FULL
-        }
-      ],
+      choices: getSetupPlatformModePromptChoices(),
       default: SETUP_PLATFORM_MODE.SINGLE
     }
   ]);
@@ -62,6 +65,6 @@ async function promptSetupPlatformMode(options = {}) {
 
 module.exports = {
   resolvePlatformModeFromOptions,
-  promptSetupPlatformMode
+  promptSetupPlatformMode,
+  getSetupPlatformModePromptChoices
 };
-

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

@@ -1,7 +1,7 @@
 /**
- * @fileoverview verify-trust <systemKey> — semantic agent metadata validation for all datasources.
+ * @fileoverview verify-trust <systemKey> — dual-confidence AI Trust via dataplane (433.0).
  * @author AI Fabrix Team
- * @version 1.0.0
+ * @version 2.0.0
  */
 
 'use strict';
@@ -10,83 +10,20 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { getConfig } = require('../core/config');
 const { setupIntegrationTestAuth } = require('../external-system/test-auth');
-const { runDatasourceAgentTrust } = require('../datasource/agent-trust-run');
+const { runSystemVerifyTrust } = require('../api/lifecycle.api');
 const {
   resolveExternalIntegrationContext,
   syncLocalIfRequested
 } = require('./test-e2e-external');
 
-function pushTrustResult(results, key, trustRun, apiError) {
-  const failed =
-    apiError ||
-    !trustRun ||
-    trustRun.trustDecision === 'notTrusted' ||
-    trustRun.validationStatus === 'failed';
-  results.push({
-    key,
-    success: !failed,
-    error: failed
-      ? apiError
-        ? apiError.message || String(apiError)
-        : trustRun.summary || 'Trust validation failed'
-      : undefined,
-    trustRun
-  });
-}
-
 /**
  * @async
- * @param {Object|null} uploadCtx
  * @param {string} externalSystem
  * @param {Object} options
- * @returns {Promise<{ authConfig: Object, dataplaneUrl: string }>}
- */
-async function resolveTrustAuthContext(uploadCtx, externalSystem, options) {
-  if (uploadCtx) {
-    return { authConfig: uploadCtx.authConfig, dataplaneUrl: uploadCtx.dataplaneUrl };
-  }
-  const configObj = await getConfig();
-  return setupIntegrationTestAuth(
-    externalSystem,
-    {
-      environment: options.env,
-      authConfig: options.authConfig,
-      dataplaneUrl: options.dataplaneUrl,
-      silentResolve: options.silentResolve === true
-    },
-    configObj
-  );
-}
-
-/**
- * @async
- * @param {string[]} keys
- * @param {Object} runOpts
- * @param {Array<Object>} results
- */
-async function runTrustForDatasourceKeys(keys, runOpts, results) {
-  for (const key of keys) {
-    try {
-      const { trustRun, apiError } = await runDatasourceAgentTrust(key, runOpts);
-      pushTrustResult(results, key, trustRun, apiError);
-    } catch (err) {
-      results.push({ key, success: false, error: err.message, trustRun: null });
-    }
-  }
-}
-
-/**
- * @async
- * @param {string} externalSystem
- * @param {Object} options
- * @returns {Promise<{ success: boolean, results: Array<Object>, systemKey: string }>}
+ * @returns {Promise<{ success: boolean, results: Array<Object>, systemKey: string, trustReport?: Object }>}
  */
 async function runTestTrustForExternalSystem(externalSystem, options = {}) {
-  const { systemKey, keys } = resolveExternalIntegrationContext(externalSystem);
-  if (keys.length === 0) {
-    logger.log(chalk.yellow(`No datasources found for ${externalSystem}.`));
-    return { success: true, results: [], systemKey };
-  }
+  const { systemKey } = resolveExternalIntegrationContext(externalSystem);
 
   const uploadCtx = await syncLocalIfRequested(systemKey, options);
   if (uploadCtx?.authConfig && uploadCtx?.dataplaneUrl) {
@@ -95,30 +32,42 @@ async function runTestTrustForExternalSystem(externalSystem, options = {}) {
     options.silentResolve = true;
   }
   if (options.revalidate === true) {
-    logger.log(chalk.cyan('Forcing revalidation (cache bypass) for each datasource…'));
+    logger.log(chalk.cyan('Forcing revalidation (cache bypass)…'));
   }
 
-  const { authConfig, dataplaneUrl } = await resolveTrustAuthContext(
-    uploadCtx,
-    externalSystem,
-    options
-  );
-  const results = [];
-  await runTrustForDatasourceKeys(
-    keys,
-    {
-      app: externalSystem,
-      environment: options.env,
-      noSync: true,
-      revalidate: options.revalidate === true,
-      summary: options.summary === true,
-      timeout: options.timeout,
-      authConfig,
-      dataplaneUrl
-    },
-    results
-  );
-  return { success: results.every(r => r.success), results, systemKey };
+  let authConfig = options.authConfig;
+  let dataplaneUrl = options.dataplaneUrl;
+  if (!authConfig || !dataplaneUrl) {
+    const configObj = await getConfig();
+    const auth = await setupIntegrationTestAuth(
+      externalSystem,
+      {
+        environment: options.env,
+        authConfig: options.authConfig,
+        dataplaneUrl: options.dataplaneUrl,
+        silentResolve: options.silentResolve === true
+      },
+      configObj
+    );
+    authConfig = auth.authConfig;
+    dataplaneUrl = auth.dataplaneUrl;
+  }
+
+  const trustReport = await runSystemVerifyTrust(dataplaneUrl, authConfig, systemKey, {
+    forceRevalidate: options.revalidate === true
+  });
+
+  const results = (trustReport.datasourceRows || []).map(row => ({
+    key: row.datasourceKey,
+    success: trustReport.verdict === 'VERIFIED' || trustReport.verdict !== 'FAILED',
+    trustRun: {
+      trustDecision: row.trustDecision,
+      validationStatus: row.validationStatus
+    }
+  }));
+
+  const success = trustReport.verdict === 'VERIFIED';
+  return { success, results, systemKey, trustReport };
 }
 
 module.exports = {

package/lib/commands/up-common.js

@@ -328,6 +328,35 @@ async function ensureAppFromTemplate(appName, opts = {}) {
   return primaryCopied;
 }
 
+/** Dataplane app key materialized for dataplane install (worker/beat are compose sidecars). */
+const DATAPLANE_BUILDER_APP_KEYS = Object.freeze(['dataplane']);
+
+/** Builder dirs removed on up-platform / setup force (includes Celery companions). */
+const PLATFORM_BUILDER_CLEAN_APP_KEYS = Object.freeze([
+  'keycloak',
+  'miso-controller',
+  ...DATAPLANE_BUILDER_APP_KEYS
+]);
+
+/**
+ * Ensure dataplane application manifest exists under the builder root.
+ * Worker/beat sidecars are resolved from parent application.yaml at run/compose time.
+ *
+ * @param {object} [opts]
+ * @param {boolean} [opts.silent]
+ * @returns {Promise<boolean>} True if any app template was copied
+ */
+async function ensureDataplaneAppsFromTemplate(opts = {}) {
+  let anyCopied = false;
+  for (const appName of DATAPLANE_BUILDER_APP_KEYS) {
+    const copied = await ensureAppFromTemplate(appName, opts);
+    if (copied) {
+      anyCopied = true;
+    }
+  }
+  return anyCopied;
+}
+
 /**
  * Merge builder/packages `application.yaml` into `~/.aifabrix/urls.local.yaml`.
  * Same scan as the end of {@link prepareUrlsLocalRegistryForUpPlatform}; call after platform app
@@ -354,14 +383,17 @@ async function prepareUrlsLocalRegistryForUpPlatform(opts = {}) {
   const templateOpts = { silent: Boolean(opts.silent) };
   await ensureAppFromTemplate('keycloak', templateOpts);
   await ensureAppFromTemplate('miso-controller', templateOpts);
-  await ensureAppFromTemplate('dataplane', templateOpts);
+  await ensureDataplaneAppsFromTemplate(templateOpts);
   refreshUrlsLocalRegistryForCurrentProject();
 }
 
 module.exports = {
   applyUpPlatformForceConfig,
   cleanBuilderAppDirs,
+  DATAPLANE_BUILDER_APP_KEYS,
+  PLATFORM_BUILDER_CLEAN_APP_KEYS,
   ensureAppFromTemplate,
+  ensureDataplaneAppsFromTemplate,
   patchEnvOutputPathForDeployOnly,
   validateEnvOutputPathFolderOrNull,
   getEnvOutputPathFolder,