@aifabrix/builder 2.44.6 → 2.45.0

package/lib/commands/setup.js

@@ -29,6 +29,7 @@ const {
 
 const setupPrompts = require('./setup-prompts');
 const setupModes = require('./setup-modes');
+const installationLog = require('../utils/installation-log');
 
 const MODE = setupPrompts.MODE;
 
@@ -57,19 +58,25 @@ async function runFreshInstallFlow(options) {
   await maybePinDeveloperIdForFreshInstall(options.developer);
   logger.log(infoLine('No infrastructure detected; starting fresh install.'));
   const adminCreds = await setupPrompts.promptAdminCredentials();
+  await config.setAdminEmail(adminCreds.adminEmail);
   await setupModes.runFreshInstall(adminCreds);
   logger.log(formatSuccessParagraph('aifabrix setup complete (fresh install).'));
 }
 
+/**
+ * @param {boolean} assumeYes
+ * @returns {Promise<{ aborted: boolean, mode: string|null }>}
+ */
 async function runExistingInfraFlow(assumeYes) {
   const mode = await setupPrompts.promptModeSelection();
   const proceed = await setupPrompts.confirmDestructiveMode(mode, assumeYes);
   if (!proceed) {
     logger.log(chalk.yellow('Aborted by user.'));
-    return;
+    return { aborted: true, mode };
   }
   await dispatchMode(mode);
   logger.log(formatSuccessParagraph(`aifabrix setup complete (mode: ${mode}).`));
+  return { aborted: false, mode };
 }
 
 /**
@@ -116,6 +123,89 @@ async function dispatchMode(mode) {
   }
 }
 
+/**
+ * @param {Object} options
+ * @param {boolean} assumeYes
+ * @returns {Promise<{ outcome: string, setupMode: string|null }>}
+ */
+async function runSetupMainPath(options, assumeYes) {
+  logSetupHeader();
+  logger.log(formatProgress('Detecting current installation state...'));
+  const running = await isInfraRunning();
+  if (!running) {
+    await runFreshInstallFlow(options);
+    return { outcome: 'success', setupMode: 'fresh' };
+  }
+  const r = await runExistingInfraFlow(assumeYes);
+  const outcome = r.aborted ? 'aborted' : 'success';
+  return { outcome, setupMode: r.mode };
+}
+
+async function readConfigSnapshotForSetupLog() {
+  try {
+    return await config.getConfig();
+  } catch {
+    return {};
+  }
+}
+
+function tryCollectPlatformImagesForLog(outcome) {
+  if (outcome !== 'success') return undefined;
+  try {
+    return installationLog.collectPlatformAppImages(['keycloak', 'miso-controller', 'dataplane'], {});
+  } catch {
+    return undefined;
+  }
+}
+
+async function readSetupLogUrlFields() {
+  let controllerUrl;
+  try {
+    controllerUrl = await installationLog.resolveControllerUrlForLog();
+  } catch {
+    controllerUrl = undefined;
+  }
+  let adminEmail;
+  try {
+    adminEmail = await installationLog.resolveAdminEmailPresence();
+  } catch {
+    adminEmail = 'unset';
+  }
+  return { controllerUrl, adminEmail };
+}
+
+/**
+ * @param {Object} payload
+ * @param {string} payload.outcome
+ * @param {Date} payload.startedAt
+ * @param {Date} payload.completedAt
+ * @param {Object} payload.options
+ * @param {string|null} payload.setupMode
+ * @param {Error|null} payload.err
+ */
+async function appendSetupInstallationRecord(payload) {
+  const cfg = await readConfigSnapshotForSetupLog();
+  const platformApps = tryCollectPlatformImagesForLog(payload.outcome);
+  const { controllerUrl, adminEmail } = await readSetupLogUrlFields();
+  try {
+    await installationLog.appendInstallationRecord({
+      command: 'setup',
+      outcome: payload.outcome,
+      startedAt: payload.startedAt,
+      completedAt: payload.completedAt,
+      options: payload.options,
+      setupMode: payload.setupMode || undefined,
+      infra: cfg && typeof cfg === 'object' ? { cfg, options: {} } : undefined,
+      platformApps,
+      configExtra: { controllerUrl, adminEmail },
+      error: payload.err || undefined,
+      errorCode: payload.err && payload.err.code ? String(payload.err.code) : undefined
+    });
+  } catch {
+    // never block setup on log failure
+  }
+}
+
 /**
  * Run the setup wizard / dispatcher.
  *
@@ -129,17 +219,32 @@ async function dispatchMode(mode) {
  */
 async function handleSetup(options = {}) {
   const assumeYes = options.yes === true || options.assumeYes === true;
+  const startedAt = new Date();
+  let outcome = 'success';
+  let setupMode = null;
+  let err = null;
 
-  logSetupHeader();
-
-  logger.log(formatProgress('Detecting current installation state...'));
-  const running = await isInfraRunning();
+  try {
+    const main = await runSetupMainPath(options, assumeYes);
+    outcome = main.outcome;
+    setupMode = main.setupMode;
+  } catch (e) {
+    outcome = 'failure';
+    err = e;
+  } finally {
+    await appendSetupInstallationRecord({
+      outcome,
+      startedAt,
+      completedAt: new Date(),
+      options,
+      setupMode,
+      err
+    });
+  }
 
-  if (!running) {
-    await runFreshInstallFlow(options);
-    return;
+  if (err) {
+    throw err;
   }
-  await runExistingInfraFlow(assumeYes);
 }
 
 module.exports = {

package/lib/commands/teardown.js

@@ -24,6 +24,7 @@ const chalk = require('chalk');
 const ora = require('ora');
 
 const config = require('../core/config');
+const installationLog = require('../utils/installation-log');
 const infra = require('../infrastructure');
 const pathsUtil = require('../utils/paths');
 const logger = require('../utils/logger');
@@ -193,6 +194,47 @@ function cleanFilesWithSpinner() {
   return result;
 }
 
+async function appendTeardownAbortedLog(options) {
+  const t = new Date();
+  try {
+    await installationLog.appendInstallationRecord({
+      command: 'teardown',
+      outcome: 'aborted',
+      startedAt: t,
+      completedAt: t,
+      options
+    });
+  } catch {
+    // ignore
+  }
+}
+
+async function appendTeardownSuccessLog(options, startedAt) {
+  let cfg = {};
+  try {
+    cfg = await config.getConfig();
+  } catch {
+    cfg = {};
+  }
+  try {
+    await installationLog.appendInstallationRecord({
+      command: 'teardown',
+      outcome: 'success',
+      startedAt,
+      completedAt: new Date(),
+      options,
+      infra: { cfg, options: {} },
+      cleanup: { volumesRemoved: true, configPreserved: true },
+      configExtra: {
+        controllerUrl: await installationLog.resolveControllerUrlForLog(),
+        adminEmail: await installationLog.resolveAdminEmailPresence()
+      }
+    });
+  } catch {
+    // ignore
+  }
+}
+
 /**
  * Run the teardown.
  *
@@ -208,15 +250,22 @@ async function handleTeardown(options = {}) {
 
   const ok = await confirmTeardown(assumeYes);
   if (!ok) {
+    await appendTeardownAbortedLog(options);
     logger.log(chalk.yellow('Aborted by user.'));
     return;
   }
-  await stopInfraQuietly();
-  const { removed, failed } = cleanFilesWithSpinner();
-  const devStr = await buildDeveloperLabel();
-  logTeardownFooter({ devStr, removedCount: removed.length, failedCount: failed.length });
 
-  logger.log(formatSuccessParagraph('aifabrix teardown complete.'));
+  const startedAt = new Date();
+  try {
+    await stopInfraQuietly();
+    const { removed, failed } = cleanFilesWithSpinner();
+    const devStr = await buildDeveloperLabel();
+    logTeardownFooter({ devStr, removedCount: removed.length, failedCount: failed.length });
+
+    logger.log(formatSuccessParagraph('aifabrix teardown complete.'));
+  } finally {
+    await appendTeardownSuccessLog(options, startedAt);
+  }
 }
 
 module.exports = {

package/lib/commands/up-common.js

@@ -22,6 +22,23 @@ const { copyTemplateFiles } = require('../validation/template');
 const { ensureReadmeForAppPath, ensureReadmeForApp } = require('../app/readme');
 const { refreshUrlsLocalRegistryFromBuilder } = require('../utils/urls-local-registry');
 
+/**
+ * @param {string[]} entries
+ * @returns {string[]}
+ */
+function uniqueResolvedRoots(entries) {
+  const seen = new Set();
+  const out = [];
+  for (const e of entries) {
+    const r = path.resolve(e);
+    if (!seen.has(r)) {
+      seen.add(r);
+      out.push(r);
+    }
+  }
+  return out;
+}
+
 /**
  * Copy template to a target path if application config is missing there.
  * After copy, generates README.md from templates/applications/README.md.hbs.
@@ -226,7 +243,11 @@ function isUnderAllowedBuilderRoot(resolvedAppPath, allowedRoots) {
 async function cleanBuilderAppDirs(appNames, opts = {}) {
   const silent = Boolean(opts.silent);
   if (!Array.isArray(appNames) || appNames.length === 0) return;
-  const allowedRoots = [path.resolve(pathsUtil.getBuilderRoot()), path.resolve(pathsUtil.getSystemBuilderRoot())];
+  const allowedRoots = uniqueResolvedRoots([
+    path.join(process.cwd(), 'builder'),
+    pathsUtil.getBuilderRoot(),
+    pathsUtil.getSystemBuilderRoot()
+  ]);
   const cleaned = [];
   for (const appName of appNames) {
     if (!appName || typeof appName !== 'string') continue;
@@ -253,8 +274,9 @@ async function cleanBuilderAppDirs(appNames, opts = {}) {
  * Uses AIFABRIX_BUILDER_DIR when set (e.g. by up-miso/up-dataplane from config aifabrix-env-config).
  * When `process.env.AIFABRIX_BUILDER_DIR` is set and the primary app path differs from
  * `cwd/builder/<appName>`, also copies into `cwd/builder/<appName>` so the repo tree is not empty
- * while using a custom builder root. Skips that extra copy when no custom dir is in use (e.g.
- * platform apps materialized only under the system builder root).
+ * while using a custom builder root. Skips that extra copy for platform apps (`keycloak`,
+ * `miso-controller`, `dataplane`) so they materialize only under the system builder root, and when
+ * no custom dir is in use.
  *
  * @async
  * @function ensureAppFromTemplate
@@ -281,7 +303,8 @@ async function ensureAppFromTemplate(appName) {
   const cwdBuilderPath = path.join(process.cwd(), 'builder', appName);
   if (
     envBuilderRoot &&
-    path.resolve(cwdBuilderPath) !== path.resolve(appPath)
+    path.resolve(cwdBuilderPath) !== path.resolve(appPath) &&
+    !pathsUtil.isSystemBuilderAppName(appName)
   ) {
     const cwdCopied = await ensureTemplateAtPath(appName, cwdBuilderPath);
     if (cwdCopied) {
@@ -295,22 +318,32 @@ async function ensureAppFromTemplate(appName) {
 }
 
 /**
- * For `aifabrix up-platform` only: align builder dir env with up-miso/up-dataplane, materialize all three
- * platform apps from templates if missing, then refresh `~/.aifabrix/urls.local.yaml` so declarative
- * `url://` expansion (e.g. cross-references between miso-controller, dataplane, keycloak) sees every
- * app's port and pattern before Keycloak or Miso resolve their `.env` files.
+ * Merge builder/packages `application.yaml` into `~/.aifabrix/urls.local.yaml`.
+ * Same scan as the end of {@link prepareUrlsLocalRegistryForUpPlatform}; call after platform app
+ * templates exist (e.g. `up-miso`, `up-dataplane`) so declarative `url://` and tooling see ports/patterns.
+ */
+function refreshUrlsLocalRegistryForCurrentProject() {
+  try {
+    refreshUrlsLocalRegistryFromBuilder(pathsUtil.getProjectRoot());
+  } catch (error) {
+    logger.warn(chalk.yellow(`⚠  Could not refresh URLs registry: ${error.message}`));
+  }
+}
+
+/**
+ * For `aifabrix up-platform` only: materialize all three platform apps from templates if missing
+ * (paths follow cwd / material `builder/` only — no `AIFABRIX_BUILDER_DIR` override), then refresh
+ * `~/.aifabrix/urls.local.yaml` so declarative `url://` expansion (e.g. cross-references between
+ * miso-controller, dataplane, keycloak) sees every app's port and pattern before Keycloak or Miso
+ * resolve their `.env` files.
  *
  * @returns {Promise<void>}
  */
 async function prepareUrlsLocalRegistryForUpPlatform() {
-  const builderDir = await config.getAifabrixBuilderDir();
-  if (builderDir) {
-    process.env.AIFABRIX_BUILDER_DIR = path.resolve(builderDir);
-  }
   await ensureAppFromTemplate('keycloak');
   await ensureAppFromTemplate('miso-controller');
   await ensureAppFromTemplate('dataplane');
-  refreshUrlsLocalRegistryFromBuilder(pathsUtil.getProjectRoot());
+  refreshUrlsLocalRegistryForCurrentProject();
 }
 
 module.exports = {
@@ -320,5 +353,6 @@ module.exports = {
   patchEnvOutputPathForDeployOnly,
   validateEnvOutputPathFolderOrNull,
   getEnvOutputPathFolder,
-  prepareUrlsLocalRegistryForUpPlatform
+  prepareUrlsLocalRegistryForUpPlatform,
+  refreshUrlsLocalRegistryForCurrentProject
 };

package/lib/commands/up-dataplane.js

@@ -12,7 +12,6 @@ const { formatSuccessLine, formatSuccessParagraph } = require('../utils/cli-test
  * @version 2.0.0
  */
 
-const path = require('path');
 const readline = require('readline');
 const chalk = require('chalk');
 const pathsUtil = require('../utils/paths');
@@ -30,7 +29,7 @@ const { checkHealthEndpoint } = require('../utils/health-check');
 const { validateControllerUrl } = require('../utils/auth-config-validator');
 const app = require('../app');
 const { assertDevInfraUp } = require('./dev-infra-gate');
-const { ensureAppFromTemplate, validateEnvOutputPathFolderOrNull } = require('./up-common');
+const { ensureAppFromTemplate, validateEnvOutputPathFolderOrNull, refreshUrlsLocalRegistryForCurrentProject } = require('./up-common');
 
 const CONTROLLER_HEALTH_PATH = '/health';
 
@@ -168,14 +167,17 @@ function buildDataplaneImageRef(options = {}) {
   }
 }
 
-/**
- * Sets `AIFABRIX_BUILDER_DIR` when configured (shared by deploy/run paths).
- * @returns {Promise<void>}
- */
-async function applyAifabrixBuilderDirEnv() {
-  const builderDir = await config.getAifabrixBuilderDir();
-  if (builderDir) {
-    process.env.AIFABRIX_BUILDER_DIR = path.resolve(builderDir);
+function emitDataplaneManifestLineFromBuilder() {
+  const { emitSystemBuilderAppManifestLineIfTTY } = require('../utils/manifest-source-emit');
+  emitSystemBuilderAppManifestLineIfTTY(logger, 'dataplane');
+}
+
+function assertDevEnvironmentForDataplane(cfg) {
+  const environment = (cfg && cfg.environment) ? cfg.environment : 'dev';
+  if (environment !== 'dev') {
+    throw new Error(
+      'Dataplane is only supported in dev environment. Set with: aifabrix auth --set-environment dev.'
+    );
   }
 }
 
@@ -195,7 +197,6 @@ async function applyAifabrixBuilderDirEnv() {
  * @throws {Error} If infra not up, controller unavailable, not logged in, environment not dev, or any step fails
  */
 async function handleUpDataplane(options = {}) {
-  await applyAifabrixBuilderDirEnv();
   logger.log(chalk.blue('Starting up-dataplane (register/rotate, deploy, then run dataplane locally)...\n'));
 
   if (options.skipInfraCheck !== true) {
@@ -207,18 +208,19 @@ async function handleUpDataplane(options = {}) {
   const authConfig = await checkAuthentication(controllerUrl, environmentKey, { throwOnFailure: true });
 
   const cfg = await config.getConfig();
-  const environment = (cfg && cfg.environment) ? cfg.environment : 'dev';
-  if (environment !== 'dev') {
-    throw new Error(
-      'Dataplane is only supported in dev environment. Set with: aifabrix auth --set-environment dev.'
-    );
-  }
+  assertDevEnvironmentForDataplane(cfg);
   logger.log(formatSuccessLine('Logged in and environment is dev'));
 
   await ensureAppFromTemplate('dataplane');
   // If envOutputPath target folder does not exist, set envOutputPath to null
   validateEnvOutputPathFolderOrNull('dataplane');
 
+  refreshUrlsLocalRegistryForCurrentProject();
+
+  if (options.platformInstall !== true) {
+    emitDataplaneManifestLineFromBuilder();
+  }
+
   await registerOrRotateDataplane(options, controllerUrl, environmentKey, authConfig);
 
   await deployDataplaneToController(options);
@@ -226,7 +228,8 @@ async function handleUpDataplane(options = {}) {
   await app.runApp('dataplane', {
     skipEnvOutputPath: true,
     registry: options.registry || undefined,
-    base: options.base !== false
+    base: options.base !== false,
+    skipManifestMetadataLine: true
   });
 
   logger.log(formatSuccessParagraph('up-dataplane complete. Dataplane is registered, deployed in dev, and running locally.'));

package/lib/commands/up-miso.js

@@ -10,13 +10,16 @@ const { formatSuccessParagraph } = require('../utils/cli-test-layout-chalk');
  * @version 2.0.0
  */
 
-const path = require('path');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
-const config = require('../core/config');
 const app = require('../app');
 const { assertDevInfraUp } = require('./dev-infra-gate');
-const { ensureAppFromTemplate, patchEnvOutputPathForDeployOnly, validateEnvOutputPathFolderOrNull } = require('./up-common');
+const {
+  ensureAppFromTemplate,
+  patchEnvOutputPathForDeployOnly,
+  validateEnvOutputPathFolderOrNull,
+  refreshUrlsLocalRegistryForCurrentProject
+} = require('./up-common');
 
 /**
  * Parse --image options array into map { keycloak?: string, 'miso-controller'?: string }
@@ -51,7 +54,8 @@ async function runMisoApps(options) {
     registryMode: options.registryMode,
     skipEnvOutputPath: true,
     skipInfraCheck: true,
-    base: useBaseImage
+    base: useBaseImage,
+    skipManifestMetadataLine: true
   };
   const keycloakRunOpts = { ...common };
   if (imageMap.keycloak) {
@@ -61,9 +65,12 @@ async function runMisoApps(options) {
   if (imageMap['miso-controller']) {
     misoRunOpts.image = imageMap['miso-controller'];
   }
+  const { emitSystemBuilderAppManifestLineIfTTY } = require('../utils/manifest-source-emit');
   logger.log(chalk.blue('Starting keycloak...'));
+  emitSystemBuilderAppManifestLineIfTTY(logger, 'keycloak');
   await app.runApp('keycloak', keycloakRunOpts);
   logger.log(chalk.blue('Starting miso-controller...'));
+  emitSystemBuilderAppManifestLineIfTTY(logger, 'miso-controller');
   await app.runApp('miso-controller', misoRunOpts);
 }
 
@@ -80,10 +87,6 @@ async function runMisoApps(options) {
  * @throws {Error} If infra not up or any step fails
  */
 async function handleUpMiso(options = {}) {
-  const builderDir = await config.getAifabrixBuilderDir();
-  if (builderDir) {
-    process.env.AIFABRIX_BUILDER_DIR = path.resolve(builderDir);
-  }
   logger.log(chalk.blue('Starting up-miso (keycloak + miso-controller from images)...\n'));
   await assertDevInfraUp();
   await ensureAppFromTemplate('keycloak');
@@ -94,6 +97,7 @@ async function handleUpMiso(options = {}) {
   // Deploy-only: do not copy .env to repo paths; patch variables so envOutputPath is null
   patchEnvOutputPathForDeployOnly('keycloak');
   patchEnvOutputPathForDeployOnly('miso-controller');
+  refreshUrlsLocalRegistryForCurrentProject();
   await runMisoApps(options);
   logger.log(formatSuccessParagraph('up-miso complete. Keycloak and miso-controller are running.') +
     chalk.gray('\n  Run onboarding and register Keycloak from the miso-controller repo if needed. Use \'aifabrix up-dataplane\' for dataplane.'));

package/lib/commands/upload.js

@@ -279,8 +279,10 @@ async function buildValidatedUploadManifestPayload(systemKey, _opts = {}) {
 }
 
 /**
- * Upload local `integration/<systemKey>/openapi/*.json` specs when present so pipeline can resolve
- * each datasource `openapi.documentKey` (same behavior as repair --api OpenAPI sync).
+ * Upload local `integration/<systemKey>/openapi/*.json` specs when present so dataplane can store
+ * vendor OpenAPI keyed by each datasource `openapi.documentKey` (same behavior as repair --api OpenAPI sync).
+ * Call this **after** a successful pipeline publish: list/upload endpoints require the external system row.
+ * First publish still succeeds because pipeline materializes internal specs from `openapi.operations` when needed.
  *
  * @param {string} systemKey
  * @param {Object} manifest
@@ -374,9 +376,9 @@ async function runUploadPublishAndSummary(systemKey, options, manifest, payload)
     await maybeRunVerboseServerValidation(dataplaneUrl, authConfig, payload);
   }
   await pushAndLogCredentialSecrets(dataplaneUrl, authConfig, systemKey, payload);
-  await logAndSyncLocalOpenApiForUpload(systemKey, manifest);
 
   const rawRes = await runUploadValidatePublish(dataplaneUrl, authConfig, payload);
+  await logAndSyncLocalOpenApiForUpload(systemKey, manifest);
   await handlePublicationAndFollowups({
     systemKey,
     options,

package/lib/core/audit-logger.js

@@ -15,6 +15,7 @@ const fs = require('fs').promises;
 const path = require('path');
 const os = require('os');
 const paths = require('../utils/paths');
+const { maskSensitiveData } = require('../utils/log-redaction');
 
 // Audit log file path (beside config.yaml / CLI system dir for compliance)
 let auditLogPath = null;
@@ -51,40 +52,6 @@ async function getAuditLogPath() {
   return auditLogPath;
 }
 
-/**
- * Masks sensitive data in strings
- * Prevents secrets, keys, and passwords from appearing in logs
- *
- * @param {string} value - Value to mask
- * @returns {string} Masked value
- */
-function maskSensitiveData(value) {
-  if (!value || typeof value !== 'string') {
-    return value;
-  }
-
-  // Mask patterns: passwords, secrets, keys, tokens
-  const sensitivePatterns = [
-    { pattern: /password[=:]\s*([^\s]+)/gi, replacement: 'password=***' },
-    { pattern: /secret[=:]\s*([^\s]+)/gi, replacement: 'secret=***' },
-    { pattern: /key[=:]\s*([^\s]+)/gi, replacement: 'key=***' },
-    { pattern: /token[=:]\s*([^\s]+)/gi, replacement: 'token=***' },
-    { pattern: /api[_-]?key[=:]\s*([^\s]+)/gi, replacement: 'api_key=***' }
-  ];
-
-  let masked = value;
-  for (const { pattern, replacement } of sensitivePatterns) {
-    masked = masked.replace(pattern, replacement);
-  }
-
-  // If value looks like a hash/key (long hex string), mask it
-  if (/^[a-f0-9]{32,}$/i.test(masked.trim())) {
-    return '***';
-  }
-
-  return masked;
-}
-
 /**
  * Creates an audit log entry with ISO 27001 compliance
  *

package/lib/core/config-admin-email.js

@@ -0,0 +1,56 @@
+/**
+ * Admin email field in `config.yaml` (Keycloak / pgAdmin), written by `aifabrix setup`.
+ *
+ * @fileoverview config.yaml adminEmail helpers (keeps config.js under max-lines)
+ * @author AI Fabrix Team
+ * @version 1.0.0
+ */
+
+'use strict';
+
+/**
+ * @param {unknown} email
+ * @returns {string} Trimmed valid email
+ * @throws {Error} When empty or not a plausible email
+ */
+function validateAdminEmailForConfig(email) {
+  const value = String(email ?? '').trim();
+  if (!value) {
+    throw new Error('Admin email must be a non-empty string');
+  }
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+    throw new Error('Admin email must be a valid email address');
+  }
+  return value;
+}
+
+/**
+ * @param {() => Promise<Object>} getConfig
+ * @returns {Promise<string>}
+ */
+async function getAdminEmailFromConfig(getConfig) {
+  const cfg = await getConfig();
+  if (cfg && typeof cfg.adminEmail === 'string' && cfg.adminEmail.trim()) {
+    return cfg.adminEmail.trim();
+  }
+  return '';
+}
+
+/**
+ * @param {() => Promise<Object>} getConfig
+ * @param {(data: Object) => Promise<void>} saveConfig
+ * @param {string} email
+ * @returns {Promise<void>}
+ */
+async function setAdminEmailInConfig(getConfig, saveConfig, email) {
+  const trimmed = validateAdminEmailForConfig(email);
+  const cfg = await getConfig();
+  cfg.adminEmail = trimmed;
+  await saveConfig(cfg);
+}
+
+module.exports = {
+  validateAdminEmailForConfig,
+  getAdminEmailFromConfig,
+  setAdminEmailInConfig
+};