backend-manager 5.2.18 → 5.2.19

package/src/cli/commands/setup.js

@@ -11,6 +11,7 @@ const bem_allRulesRegex = /(\/\/\/---backend-manager---\/\/\/)(.*?)(\/\/\/------
 class SetupCommand extends BaseCommand {
   async execute() {
     const self = this.main;
+    const ui = this.ui;
 
     // Load config
     await this.loadConfig();
@@ -24,7 +25,7 @@ class SetupCommand extends BaseCommand {
       attempt++;
 
       if (maxAttempts > 1) {
-        this.logSuccess(`\n==== SETUP ATTEMPT ${attempt}/${maxAttempts} ====`);
+        ui.section(`Attempt ${attempt}/${maxAttempts}`);
       }
 
       // Reset counters so each attempt starts fresh
@@ -35,16 +36,13 @@ class SetupCommand extends BaseCommand {
 
       const allPassed = self.testCount === self.testTotal;
       if (allPassed) {
-        if (maxAttempts > 1 && attempt > 1) {
-          this.logSuccess(`\nAll checks passed on attempt ${attempt}/${maxAttempts}.`);
-        }
         return;
       }
 
       if (attempt < maxAttempts) {
-        this.logWarning(`\nAttempt ${attempt}/${maxAttempts} had failures. Retrying...`);
+        ui.status('warn', `Attempt ${attempt}/${maxAttempts} had failures — retrying…`);
       } else if (maxAttempts > 1) {
-        this.logWarning(`\nReached retry limit (${maxAttempts}). Some checks still failing.`);
+        ui.status('warn', `Reached retry limit (${maxAttempts}) — some checks still failing`);
       }
     }
   }
@@ -61,9 +59,15 @@ class SetupCommand extends BaseCommand {
 
   async runSetup() {
     const self = this.main;
+    const ui = this.ui;
     let cwd = jetpack.cwd();
 
-    this.logSuccess(`\n---- RUNNING SETUP v${self.default.version} ----`);
+    // OMEGA-style banner. Replaces the old `---- RUNNING SETUP ---- ` line.
+    ui.banner(`Backend Manager ${chalk.dim(`v${self.default.version}`)}`);
+
+    // Fresh summary collector for this run (the test runner records into it and
+    // prints it on a hard failure; we print it here on success).
+    self.setupSummary = new ui.Summary().start();
 
     // Load files
     self.package = loadJSON(`${self.firebaseProjectPath}/functions/package.json`);
@@ -76,14 +80,16 @@ class SetupCommand extends BaseCommand {
 
     // Check if package exists
     if (!hasContent(self.package)) {
-      this.logError(`Missing functions/package.json :(`);
-      return;
+      ui.status('fail', `Missing ${chalk.bold('functions/package.json')}`);
+      ui.note(`Run ${chalk.bold('npx mgr setup')} from inside the ${chalk.bold('functions')} folder of a Firebase project.`);
+      process.exit(1);
     }
 
     // Check if we're running from the functions folder
     if (!cwd.endsWith('functions') && !cwd.endsWith('functions/')) {
-      this.logError(`Please run ${chalk.bold('npx bm setup')} from the ${chalk.bold('functions')} folder. Run ${chalk.bold('cd functions')}.`);
-      return;
+      ui.status('fail', `Wrong directory`);
+      ui.note(`Run ${chalk.bold('npx mgr setup')} from the ${chalk.bold('functions')} folder. Try ${chalk.bold('cd functions')} first.`);
+      process.exit(1);
     }
 
     // Load the rules files
@@ -96,9 +102,12 @@ class SetupCommand extends BaseCommand {
     self.projectUrl = `https://console.firebase.google.com/project/${self.projectId}`;
     self.apiUrl = `https://api.${(self.bemConfigJSON.brand?.url || '').replace(/^https?:\/\//, '')}`;
 
-    // Log
-    this.log(`ID: `, chalk.bold(`${self.projectId}`));
-    this.log(`URL:`, chalk.bold(`${self.projectUrl}`));
+    // Divider-wrapped header with the project name + Firebase console link.
+    const brandName = self.bemConfigJSON.brand?.name || self.projectId;
+    ui.header(brandName, { subtitle: self.projectUrl });
+    ui.blank();
+    ui.field('Project', self.projectId, { pad: 9 });
+    ui.field('API', self.apiUrl, { pad: 9, valueColor: chalk.cyan });
 
     if (!self.package || !self.package.engines || !self.package.engines.node) {
       throw new Error('Missing <engines.node> in package.json');
@@ -109,26 +118,26 @@ class SetupCommand extends BaseCommand {
 
     // Copy / merge defaults into consumer project root (matches EM/BXM/UJM pattern).
     // Runs BEFORE tests so any test that inspects scaffolded files sees the merged state.
+    ui.section('Defaults');
     this.copyDefaults();
 
     // Run all tests
+    ui.section('Checks');
     await this.runTests();
 
-    // Log if using local backend-manager
+    // Warn if using local backend-manager
     if (self.package.dependencies['backend-manager'].includes('file:')) {
-      this.log('\n' + chalk.yellow(chalk.bold('Warning: ') + 'You are using the local ' + chalk.bold('backend-manager')));
-    } else {
-      this.log('\n');
+      ui.section('Notices');
+      ui.status('warn', `Using the local ${chalk.bold('backend-manager')} source (file: dependency)`, { level: 2 });
     }
 
     // Fetch stats
+    ui.section('Stats');
     await this.fetchStats();
 
-    // Log results
-    this.logSuccess(`Checks finished. Passed ${self.testCount}/${self.testTotal} tests.`);
-    if (self.testCount !== self.testTotal) {
-      this.logWarning(`You should continue to run ${chalk.bold('npx bm setup')} until you pass all tests and fix all errors.`);
-    }
+    // Everything passed (a hard failure would have exited via haltSetup). Print
+    // the OMEGA-style summary block.
+    self.setupSummary.print();
 
     // Notify parent if exists
     if (process.send) {
@@ -162,10 +171,12 @@ class SetupCommand extends BaseCommand {
   //   # ========== Custom Values ==========    (consumer-owned)
   copyDefaults() {
     const self = this.main;
+    const ui = this.ui;
     const defaultsDir = path.resolve(`${__dirname}/../../defaults`);
 
     if (!jetpack.exists(defaultsDir)) {
       // Defaults dir is optional — older BEM versions didn't have one. If missing, skip silently.
+      ui.note('No defaults to scaffold', 2);
       return;
     }
 
@@ -175,6 +186,9 @@ class SetupCommand extends BaseCommand {
     // matches the EM/BXM/UJM contract if we ever add them.
     const MERGEABLE_BASENAMES = new Set(['.env', '.gitignore', 'CLAUDE.md']);
 
+    // Track whether we emitted any line so we can show an "up to date" note when nothing changed.
+    let touched = 0;
+
     const files = jetpack.find(defaultsDir, { matching: '**/*', recursive: true, files: true, directories: false });
 
     for (const src of files) {
@@ -201,10 +215,12 @@ class SetupCommand extends BaseCommand {
             const merged   = mergeLineBasedFiles(existing, incoming, basename);
             if (merged !== existing) {
               jetpack.write(dest, merged);
-              this.logSuccess(`Merged default → ${target}`);
+              ui.status('change', `Merged ${chalk.cyan(target)}`, { level: 2 });
+              touched++;
             }
           } catch (e) {
-            this.logWarning(`Failed to merge ${target}: ${e.message}`);
+            ui.status('warn', `Failed to merge ${chalk.cyan(target)}`, { detail: e.message, level: 2 });
+            touched++;
           }
           continue;
         }
@@ -215,7 +231,12 @@ class SetupCommand extends BaseCommand {
 
       // First time: copy as-is.
       jetpack.copy(src, dest);
-      this.logSuccess(`Copied default → ${target}`);
+      ui.status('add', `Copied ${chalk.cyan(target)}`, { level: 2 });
+      touched++;
+    }
+
+    if (touched === 0) {
+      ui.note('All defaults up to date', 2);
     }
   }
 
@@ -281,12 +302,15 @@ class SetupCommand extends BaseCommand {
     .then(json => json)
     .catch(e => e);
 
+    const ui = this.ui;
     if (statsFetchResult instanceof Error) {
-      if (!statsFetchResult.message.includes('network timeout')) {
-        this.logWarning(`Ran into error while fetching stats endpoint (${url})`, statsFetchResult);
+      if (statsFetchResult.message.includes('network timeout')) {
+        ui.status('skip', 'Skipped stats fetch', { detail: 'network timeout', level: 2 });
+      } else {
+        ui.status('warn', 'Could not fetch stats endpoint', { detail: statsFetchResult.message, level: 2 });
       }
     } else {
-      this.logSuccess(`Stats fetched/created properly.`);
+      ui.status('pass', 'Stats fetched/created', { level: 2 });
     }
   }
 }

package/src/cli/index.js

@@ -164,47 +164,76 @@ Main.prototype.process = async function (args) {
 // Test method for setup command
 Main.prototype.test = async function(name, fn, fix, args) {
   const self = this;
-  let status;
   const chalk = require('chalk').default;
-
-  return new Promise(async function(resolve, reject) {
-    let passed = await fn();
-
-    if (passed instanceof Error) {
-      console.log(chalk.red(passed));
-      process.exit(0);
-    } else if (passed) {
-      status = chalk.green('passed');
-      self.testCount++;
-      self.testTotal++;
-    } else {
-      status = chalk.red('failed');
-      self.testTotal++;
-    }
-    console.log(chalk.bold(`[${self.testTotal}]`), `${name}:`, status);
-    if (!passed) {
-      console.log(chalk.yellow(`Fixing...`));
-      fix(self, args)
-      .then((r) => {
-        console.log(chalk.green(`...done~!`));
-        resolve();
-      })
-      .catch((e) => {
-        console.log(chalk.red(`Failed to fix: ${e}`));
-        if (self.options['--continue']) {
-          console.log(chalk.yellow('⚠️ Continuing despite error because of --continue flag\n'));
-          setTimeout(function () {
-            resolve();
-          }, 5000);
-        } else {
-          console.log(chalk.yellow('To force the setup to continue, run with the --continue flag\n'));
-          reject();
-        }
-      });
-    } else {
-      resolve();
+  const ui = require('./utils/ui');
+
+  // Prints `    [N] <symbol> <name>` — the OMEGA-style per-check status line
+  // (indented one level under the `[CHECKS]` section label).
+  const printLine = (index, kind, label) => {
+    const colorByKind = { pass: chalk.green, fail: chalk.red, warn: chalk.yellow };
+    const color = colorByKind[kind] || chalk.white;
+    const suffix = label ? ` ${chalk.dim(label)}` : '';
+    console.log(`${ui.indent(2)}${chalk.dim(`[${index}]`)} ${color(ui.SYMBOLS[kind])} ${name}${suffix}`);
+  };
+
+  let passed = await fn();
+
+  // A check that returns an Error is a hard, unrecoverable failure (e.g. wrong
+  // Node version). Print it cleanly and stop — no auto-fix is possible.
+  if (passed instanceof Error) {
+    self.testTotal++;
+    printLine(self.testTotal, 'fail', '');
+    const message = passed.message || String(passed);
+    ui.status('fail', chalk.red(message), { level: 3 });
+    if (self.setupSummary) { self.setupSummary.fail(name, [chalk.red(message)]); }
+    self.haltSetup();
+    return;
+  }
+
+  if (passed) {
+    self.testCount++;
+    self.testTotal++;
+    if (self.setupSummary) { self.setupSummary.pass(); }
+    printLine(self.testTotal, 'pass', '');
+    return;
+  }
+
+  // Failed → attempt a fix.
+  self.testTotal++;
+  printLine(self.testTotal, 'warn', '— fixing…');
+
+  try {
+    await fix(self, args);
+    self.testCount++;
+    if (self.setupSummary) { self.setupSummary.pass(); }
+    ui.status('pass', chalk.green('fixed'), { level: 3 });
+  } catch (e) {
+    // The fix couldn't complete. `e.summaryDetails` (if present) is an array of
+    // pre-formatted detail lines the failing check wants surfaced in the summary.
+    const message = e && e.message ? e.message : String(e);
+    const details = (e && Array.isArray(e.summaryDetails)) ? e.summaryDetails : [chalk.red(message)];
+    ui.status('fail', chalk.red(`Could not fix: ${message}`), { level: 3 });
+    if (self.setupSummary) { self.setupSummary.fail(name, details); }
+
+    if (self.options['--continue']) {
+      ui.status('warn', chalk.yellow('Continuing despite error (--continue flag)'), { level: 3 });
+      return;
     }
-  });
+
+    self.haltSetup();
+  }
+};
+
+// Halt the setup run on an unfixable failure. The failing check must already be
+// recorded via `setupSummary.fail(...)` by the caller; this prints the summary
+// block + a re-run hint and exits with code 1 — instead of rejecting a promise
+// with no reason (which surfaced as an ugly `UnhandledPromiseRejection: undefined`).
+Main.prototype.haltSetup = function() {
+  if (this.setupSummary) {
+    this.setupSummary.print({ hint: `Fix the above, then run ${require('chalk').default.bold('npx mgr setup')} again.` });
+  }
+
+  process.exit(1);
 };
 
 module.exports = Main;

package/src/cli/utils/ui.js

@@ -0,0 +1,270 @@
+const chalk = require('chalk').default;
+
+/**
+ * Shared CLI styling helpers — the SSOT for BEM's console output look.
+ *
+ * Mirrors the OMEGA Manager (omega-manager) styling conventions so every BEM
+ * command renders with the same dividers, indentation, timestamps, colors, and
+ * status symbols. Pull these helpers into any command (setup/serve/deploy/test/
+ * emulator/...) instead of hand-rolling chalk + console.log.
+ *
+ * Conventions (matching OMEGA):
+ *   - 70-char `━` horizontal rules wrap section titles.
+ *   - Indentation is 2 spaces per level (level 1 = 2 spaces, level 2 = 4, ...).
+ *   - Dimmed labels (`ID:`, `URL:`, `Local:`) with normal-weight values.
+ *   - Status symbols: → (running) ✓ (pass) ✗ (fail) ⊘ (skip) ⚠ (warn) ✅ (done).
+ *   - Timestamps via `new Date().toLocaleTimeString()` (e.g. "7:47:12 PM").
+ */
+
+// Divider width + character (OMEGA uses 70 × `━`).
+const RULE_WIDTH = 70;
+const RULE_CHAR = '━';
+
+// Status symbols — the single source of truth for BEM's CLI iconography.
+const SYMBOLS = {
+  running: '→',
+  pass: '✓',
+  fail: '✗',
+  skip: '⊘',
+  warn: '⚠',
+  done: '✅',
+  rocket: '🚀',
+  add: '+',
+  change: '↻',
+};
+
+/** Two-space-per-level indentation. */
+function indent(level = 1) {
+  return '  '.repeat(level);
+}
+
+/** Locale time string, e.g. "7:47:12 PM". */
+function timestamp() {
+  return new Date().toLocaleTimeString();
+}
+
+/** A full-width horizontal rule in the given chalk color (default cyan). */
+function rule(color = chalk.cyan) {
+  return color(RULE_CHAR.repeat(RULE_WIDTH));
+}
+
+/** Print a blank line. */
+function blank() {
+  console.log('');
+}
+
+/**
+ * Print the top-level program banner, e.g. `🚀 Backend Manager`.
+ * @param {string} title
+ */
+function banner(title) {
+  blank();
+  console.log(chalk.bold.cyan(`${SYMBOLS.rocket} ${title}`));
+  blank();
+}
+
+/**
+ * Print a divider-wrapped section header with an optional subtitle + timestamp.
+ *
+ *   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ *     Title  subtitle  @ 7:47:12 PM
+ *   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+ *
+ * @param {string} title - Bold white title.
+ * @param {object} [opts]
+ * @param {string} [opts.subtitle] - Dimmed/colored text after the title (e.g. a URL).
+ * @param {Function} [opts.subtitleColor] - chalk fn for the subtitle (default cyan).
+ * @param {boolean} [opts.time=true] - Append `@ <time>`.
+ * @param {Function} [opts.color] - chalk fn for the rules (default cyan).
+ */
+function header(title, opts = {}) {
+  const color = opts.color || chalk.cyan;
+  const subtitleColor = opts.subtitleColor || chalk.cyan;
+  const time = opts.time !== false;
+
+  const parts = [chalk.bold.white(title)];
+  if (opts.subtitle) {
+    parts.push(subtitleColor(opts.subtitle));
+  }
+  if (time) {
+    parts.push(chalk.dim(`@ ${timestamp()}`));
+  }
+
+  console.log(rule(color));
+  console.log(`${indent(1)}${parts.join('  ')}`);
+  console.log(rule(color));
+}
+
+/**
+ * Print a magenta section label like `[SETUP]`.
+ * @param {string} label
+ */
+function section(label) {
+  blank();
+  console.log(`${indent(1)}${chalk.bold.magenta(`[${String(label).toUpperCase()}]`)}`);
+}
+
+/**
+ * Print a dimmed `Label: value` line at a given indent level.
+ * @param {string} label
+ * @param {string} value
+ * @param {object} [opts]
+ * @param {number} [opts.level=1]
+ * @param {number} [opts.pad] - Pad the label (incl. trailing colon) to this width for alignment.
+ * @param {Function} [opts.valueColor] - chalk fn for the value (default none).
+ */
+function field(label, value, opts = {}) {
+  const level = opts.level || 1;
+  let labelText = `${label}:`;
+  if (opts.pad) {
+    labelText = labelText.padEnd(opts.pad);
+  }
+  const valueText = opts.valueColor ? opts.valueColor(value) : value;
+  console.log(`${indent(level)}${chalk.dim(labelText)} ${valueText}`);
+}
+
+/**
+ * Print a status line: `<symbol> <text>` at a given indent level.
+ * @param {('running'|'pass'|'fail'|'skip'|'warn'|'add'|'change')} kind
+ * @param {string} text
+ * @param {object} [opts]
+ * @param {number} [opts.level=1]
+ * @param {string} [opts.detail] - Dimmed trailing detail.
+ */
+function status(kind, text, opts = {}) {
+  const level = opts.level || 1;
+  const colorByKind = {
+    running: chalk.dim,
+    pass: chalk.green,
+    fail: chalk.red,
+    skip: chalk.dim,
+    warn: chalk.yellow,
+    add: chalk.green,
+    change: chalk.yellow,
+  };
+  const color = colorByKind[kind] || chalk.white;
+  const symbol = SYMBOLS[kind] || '';
+  const detail = opts.detail ? ` ${chalk.dim(opts.detail)}` : '';
+  console.log(`${indent(level)}${color(symbol)} ${text}${detail}`);
+}
+
+/** Print a plain dimmed note line. */
+function note(text, level = 1) {
+  console.log(`${indent(level)}${chalk.dim(text)}`);
+}
+
+/**
+ * Collects setup-check results and prints an OMEGA-style summary block.
+ *
+ * Used by the setup command's test runner. `start()` stamps a wall-clock so the
+ * summary can report duration; `passed()` / `failed()` record outcomes; the
+ * failing check (if any) carries optional detail lines to surface in the block.
+ */
+class Summary {
+  constructor() {
+    this.startTime = null;
+    this.passes = 0;
+    this.fails = [];
+  }
+
+  start() {
+    this.startTime = Date.now();
+    return this;
+  }
+
+  pass() {
+    this.passes++;
+  }
+
+  /**
+   * @param {string} name - Check name.
+   * @param {string[]} [details] - Pre-formatted detail lines to show under the failure.
+   */
+  fail(name, details = []) {
+    this.fails.push({ name, details });
+  }
+
+  get total() {
+    return this.passes + this.fails.length;
+  }
+
+  /**
+   * Format milliseconds into "Xs" / "Xm Ys" / "Xh Ym Zs".
+   * @param {number} ms
+   */
+  _formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60) {
+      return `${seconds}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remSeconds = seconds % 60;
+    if (minutes < 60) {
+      return `${minutes}m ${remSeconds}s`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remMinutes = minutes % 60;
+    return `${hours}h ${remMinutes}m ${remSeconds}s`;
+  }
+
+  /**
+   * Print the summary block. Green ✅ when everything passed, yellow ⚠ otherwise.
+   * @param {object} [opts]
+   * @param {string} [opts.hint] - A closing call-to-action line (e.g. how to re-run).
+   */
+  print(opts = {}) {
+    const hasErrors = this.fails.length > 0;
+    const headerColor = hasErrors ? chalk.yellow : chalk.green;
+    const icon = hasErrors ? SYMBOLS.warn : SYMBOLS.done;
+    const elapsed = this.startTime ? this._formatDuration(Date.now() - this.startTime) : '0s';
+
+    blank();
+    console.log(headerColor(RULE_CHAR.repeat(RULE_WIDTH)));
+    console.log(`${indent(1)}${headerColor.bold(`${icon} Summary`)}`);
+    console.log(headerColor(RULE_CHAR.repeat(RULE_WIDTH)));
+
+    blank();
+    field('Checks', String(this.total), { pad: 11 });
+    field('Duration', elapsed, { pad: 11 });
+    const failText = hasErrors
+      ? chalk.red(`${this.fails.length} failed`)
+      : chalk.dim('0 failed');
+    field('Results', `${chalk.green(`${this.passes} passed`)}${chalk.dim(', ')}${failText}`, { pad: 11 });
+
+    if (hasErrors) {
+      blank();
+      for (const { name, details } of this.fails) {
+        console.log(`${indent(1)}${chalk.red(SYMBOLS.fail)} ${chalk.bold(name)}`);
+        for (const line of details) {
+          console.log(`${indent(3)}${line}`);
+        }
+      }
+    }
+
+    if (opts.hint) {
+      blank();
+      console.log(`${indent(1)}${chalk.dim(SYMBOLS.running)} ${opts.hint}`);
+    }
+
+    blank();
+    console.log(headerColor(RULE_CHAR.repeat(RULE_WIDTH)));
+  }
+}
+
+module.exports = {
+  chalk,
+  RULE_WIDTH,
+  RULE_CHAR,
+  SYMBOLS,
+  indent,
+  timestamp,
+  rule,
+  blank,
+  banner,
+  header,
+  section,
+  field,
+  status,
+  note,
+  Summary,
+};

package/src/manager/libraries/email/data/disposable-domains.json

@@ -1277,6 +1277,7 @@
   "doobb.com",
   "doojazz.com",
   "doquier.tk",
+  "doreact.com",
   "dotapodemail.com",
   "dotman.de",
   "dotmsg.com",

package/src/utils/merge-line-files.js

@@ -61,8 +61,10 @@ function mergeLineBasedFiles(existingContent, newContent, fileName) {
           continue;
         }
         if (existingCustomKeys.has(key)) {
-          // Key the user moved to custom — leave it in custom; emit empty default value.
-          emit(line);
+          // The framework newly adopted a key the user had in their Custom section.
+          // Promote it UP into Default with the user's value, and drop the Custom copy
+          // (handled below) so the key isn't duplicated / left empty.
+          emit(findKeyLine(existingCustom, key));
           continue;
         }
       }
@@ -97,10 +99,19 @@ function mergeLineBasedFiles(existingContent, newContent, fileName) {
     }
   }
 
-  // The user's Custom section is preserved verbatim — except .env values get
-  // normalized to double-quoted form so the file's quoting style is consistent.
+  // The user's Custom section is preserved — except (a) .env values get normalized
+  // to double-quoted form for consistent quoting, and (b) any key the framework just
+  // adopted into its Default section is dropped here, since it was promoted UP into
+  // Default above (otherwise the key would appear in both sections).
   const finalCustom = isEnvFile
-    ? existingCustom.map((line) => normalizeEnvLine(line))
+    ? existingCustom
+        .filter((line) => {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith('#')) return true;
+          const key = trimmed.split('=')[0].trim();
+          return !(key && newDefaultKeys.has(key));
+        })
+        .map((line) => normalizeEnvLine(line))
     : existingCustom;
 
   const result = [];

package/templates/_.env

@@ -34,6 +34,7 @@ SENDGRID_API_KEY=""
 BEEHIIV_API_KEY=""
 ZEROBOUNCE_API_KEY=""
 UNSUBSCRIBE_HMAC_KEY=""
+APOLLO_API_KEY=""
 
 # ========== Custom Values ==========
 # Add your custom environment variables below this line