backend-manager 5.2.18 → 5.3.0

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/defaults/CLAUDE.md

@@ -24,12 +24,12 @@ npx mgr logs:read         # read Cloud Functions logs (also: logs:tail to stream
 npx mgr firestore:get     # read a doc from Firestore (also: firestore:set / :query / :delete)
 npx mgr auth:get          # read an Auth user (also: auth:list / :delete / :set-claims)
 npx mgr install dev       # use LOCAL backend-manager source (to test framework edits)
-npx mgr install prod      # restore the published backend-manager from npm
+npx mgr install live      # restore the published backend-manager from npm
 ```
 
 All `npx mgr <cmd>` aliases — `npx bm <cmd>`, `npx bem <cmd>`, `npx backend-manager <cmd>` work too.
 
-> Editing the BEM framework source while working here? Run `npx mgr install dev` so this project picks up your uncommitted framework changes (it otherwise uses its installed `node_modules/backend-manager`). Run `npx mgr install prod` to switch back.
+> Editing the BEM framework source while working here? Run `npx mgr install dev` so this project picks up your uncommitted framework changes (it otherwise uses its installed `node_modules/backend-manager`). Run `npx mgr install live` to switch back.
 
 ## Where things live
 

package/src/defaults/test/_init.js

@@ -0,0 +1,14 @@
+/**
+ * Test lifecycle hook for this project. Runs before any test (not a test itself).
+ * See backend-manager/docs/testing.md → "test/_init.js".
+ */
+
+module.exports = ({ config }) => ({
+  // Extra test accounts (one per lifecycle this project exercises):
+  // { id, uid, email, properties }. email may use the {domain} placeholder.
+  accounts: [],
+
+  // Seed fixtures into the freshly-flushed emulator, after accounts are created.
+  async setup({ admin, accounts }) {
+  },
+});

package/src/manager/functions/_legacy/actions/create-post-handler.js

@@ -51,7 +51,7 @@ let Module = {
         assistant.error(response.error)
       } else {
         mailchimp = new Mailchimp(self.Manager.config?.mailchimp?.key ?? '');
-        await fetch(`${self.Manager.project.apiUrl}/backend-manager`, {
+        await fetch(`${self.Manager.getApiUrl()}/backend-manager`, {
           method: 'POST',
           response: 'json',
           body: {

package/src/manager/functions/core/actions/api/admin/edit-post.js

@@ -100,7 +100,7 @@ Module.prototype.fetchPost = function (url) {
   const payload = self.payload;
 
   return new Promise(async function(resolve, reject) {
-    fetch(`${Manager.project.apiUrl}/backend-manager`, {
+    fetch(`${Manager.getApiUrl()}/backend-manager`, {
       method: 'post',
       response: 'json',
       timeout: 190000,

package/src/manager/functions/core/actions/api/general/send-email.js

@@ -83,7 +83,7 @@ Module.prototype.main = function () {
     assistant.log('Email payload:', emailPayload);
 
     // Send the email via admin:send-email
-    await fetch(`${Manager.project.apiUrl}/backend-manager`, {
+    await fetch(`${Manager.getApiUrl()}/backend-manager`, {
       method: 'post',
       response: 'json',
       log: true,

package/src/manager/functions/core/actions/api/user/delete.js

@@ -29,7 +29,7 @@ Module.prototype.main = function () {
 
       // Signout of all sessions
       assistant.log(`Signout of all sessions...`);
-      await fetch(`${self.Manager.project.apiUrl}/backend-manager`, {
+      await fetch(`${self.Manager.getApiUrl()}/backend-manager`, {
         method: 'post',
         timeout: 60000,
         response: 'json',

package/src/manager/functions/core/actions/api/user/oauth2.js

@@ -40,7 +40,7 @@ Module.prototype.main = function () {
         : payload.data.payload.referrer
 
       payload.data.payload.serverUrl = typeof payload.data.payload.serverUrl === 'undefined'
-        ? `${Manager.project.apiUrl}/backend-manager`
+        ? `${Manager.getApiUrl()}/backend-manager`
         : payload.data.payload.serverUrl
 
       payload.data.payload.provider = payload.data.payload.provider || '';

package/src/manager/helpers/analytics.js

@@ -43,7 +43,9 @@ function Analytics(Manager, options) {
   // Fix options
   options.dataSource = options.dataSource || 'server';
   options.uuid = options.uuid || self.request.ip || Manager.SERVER_UUID;
-  options.isDevelopment = typeof options.isDevelopment === 'undefined' ? self.assistant.isDevelopment() : options.isDevelopment;
+  // Skip real analytics in ANY non-production environment (development OR testing) so
+  // test/dev runs never pollute GA4. Intentional `!isProduction()` check.
+  options.isDevelopment = typeof options.isDevelopment === 'undefined' ? !self.assistant.isProduction() : options.isDevelopment;
   options.pageview = typeof options.pageview === 'undefined' ? true : options.pageview;
   options.version = options.version || Manager.package.version;
   options.userProperties = options.userProperties || {};

package/src/manager/helpers/assistant.js

@@ -56,11 +56,13 @@ function tryUrl(self) {
     const host = req.get('host');
     const forwardedHost = req.get('x-forwarded-host');
     const path = req.path;
-    const functionsUrl = Manager.project.functionsUrl;
+    const functionsUrl = Manager.getFunctionsUrl();
 
     // Like this becuse "req.originalUrl" does NOT have path for all cases (like when calling https://us-central1-{id}.cloudfunctions.net/giftImport)
     if (projectType === 'firebase') {
-      if (self.isDevelopment()) {
+      // Non-production (development OR testing) reconstructs the URL from the local
+      // functions URL; production uses the request host.
+      if (!self.isProduction()) {
         return forwardedHost
           ? `${protocol}://${forwardedHost}${path}`
           : `${functionsUrl}/${self.meta.name}`;
@@ -116,6 +118,26 @@ BackendAssistant.prototype.init = function (ref, options) {
   self.settings = null;
   self.schema = null;
 
+  // Set ref FIRST so self.Manager is available below — meta.environment forwards to the
+  // Manager's canonical getEnvironment() (the Manager is the SSOT), so the Manager ref must
+  // be wired before we resolve the environment.
+  ref = ref || {};
+
+  // An assistant has no independent identity — it's a request-scoped face for its Manager,
+  // and forwards environment/url resolution to it. A Manager ref is REQUIRED; constructing
+  // one without it is a programming error (use Manager.Assistant(), which injects it).
+  if (!ref.Manager || typeof ref.Manager.getEnvironment !== 'function') {
+    throw new Error('BackendAssistant.init(): a Manager reference is required (ref.Manager). Construct via Manager.Assistant() so it is injected automatically.');
+  }
+
+  self.ref = {};
+  self.ref.req = ref.req || {};
+  self.ref.res = ref.res || {};
+  self.ref.admin = ref.admin || {};
+  self.ref.functions = ref.functions || {};
+  self.ref.Manager = ref.Manager;
+  self.Manager = self.ref.Manager;
+
   // Set meta
   self.meta = {};
 
@@ -127,16 +149,6 @@ BackendAssistant.prototype.init = function (ref, options) {
   self.meta.environment = options.environment || self.getEnvironment();
   self.meta.type = options.functionType || process.env.FUNCTION_SIGNATURE_TYPE || 'unknown';
 
-  // Set ref
-  self.ref = {};
-  ref = ref || {};
-  self.ref.req = ref.req || {};
-  self.ref.res = ref.res || {};
-  self.ref.admin = ref.admin || {};
-  self.ref.functions = ref.functions || {};
-  self.ref.Manager = ref.Manager || {};
-  self.Manager = self.ref.Manager;
-
   // Set ID
   try {
     const headers = self?.ref?.req.headers || {};
@@ -274,39 +286,31 @@ BackendAssistant.prototype.init = function (ref, options) {
   return self;
 };
 
+// Environment helpers — the Manager is the SINGLE SOURCE OF TRUTH (see index.js). The
+// assistant is a request-scoped face for its Manager and FORWARDS these straight through,
+// so request handlers can call `assistant.getEnvironment()` / `assistant.isTesting()` and
+// get exactly the same answer as `Manager.getEnvironment()`. No duplicated env-var logic
+// lives here — there is one implementation, on the Manager. A Manager ref is guaranteed by
+// init() (it throws otherwise), so these never need a fallback.
+//
+// Returns exactly ONE of 'development' | 'testing' | 'production' (mutually exclusive,
+// testing wins). isDevelopment() is NOT true in testing; isProduction() is a real positive
+// check (never `!isDevelopment()`). Gate "anything non-production" with `!isProduction()`
+// or `isDevelopment() || isTesting()` intentionally.
 BackendAssistant.prototype.getEnvironment = function () {
-  // return (process.env.FUNCTIONS_EMULATOR === true || process.env.FUNCTIONS_EMULATOR === 'true' || process.env.ENVIRONMENT !== 'production' ? 'development' : 'production')
-  if (process.env.ENVIRONMENT === 'production') {
-    return 'production';
-  } else if (
-    process.env.ENVIRONMENT === 'development'
-    || process.env.FUNCTIONS_EMULATOR === true
-    || process.env.FUNCTIONS_EMULATOR === 'true'
-    || process.env.TERM_PROGRAM === 'Apple_Terminal'
-    || process.env.TERM_PROGRAM === 'vscode'
-  ) {
-    return 'development';
-  } else {
-    return 'production'
-  }
-};
+  return this.Manager.getEnvironment();
+}
 
 BackendAssistant.prototype.isDevelopment = function () {
-  const self = this;
-
-  return self.meta.environment === 'development';
+  return this.Manager.isDevelopment();
 }
 
 BackendAssistant.prototype.isProduction = function () {
-  const self = this;
-
-  return self.meta.environment === 'production';
+  return this.Manager.isProduction();
 }
 
 BackendAssistant.prototype.isTesting = function () {
-  const self = this;
-
-  return process.env.BEM_TESTING === 'true';
+  return this.Manager.isTesting();
 }
 
 BackendAssistant.prototype.logProd = function () {
@@ -330,10 +334,11 @@ BackendAssistant.prototype._log = function () {
   if (LOG_LEVELS[level]) {
     logs.splice(1, 1);
 
-    // Determine how to log
+    // Determine how to log. Console for any non-production environment (development OR
+    // testing); the Firebase Cloud logger only in production.
     if (level in console) {
       console[level].apply(console, logs);
-    } else if (self.isDevelopment()) {
+    } else if (!self.isProduction()) {
       console.log.apply(console, logs);
     } else {
       self.ref.functions.logger.write({

package/src/manager/index.js

@@ -179,6 +179,54 @@ Manager.prototype.init = function (exporter, options) {
     });
   }
 
+  // Environment helpers — the Manager is the SINGLE SOURCE OF TRUTH (mirrors EM/UJM/BXM,
+  // where the Manager owns these). getEnvironment() is the ONLY place that reads the raw
+  // env vars (BEM_TESTING / ENVIRONMENT / FUNCTIONS_EMULATOR / TERM_PROGRAM); the three
+  // is*() checks derive from it live on every call. They return exactly ONE of three
+  // mutually-exclusive values — testing wins, then production, else development.
+  // The assistant exposes the same methods but FORWARDS to these (assistant.isTesting()
+  // → Manager.isTesting()), so request handlers can keep calling `assistant.*`.
+  // Defined BEFORE the assistant is constructed so the assistant's own init() can call back.
+  self.getEnvironment = function() {
+    // Testing takes precedence — set by the test runner / emulator (BEM_TESTING=true).
+    if (process.env.BEM_TESTING === 'true') {
+      return 'testing';
+    }
+    if (process.env.ENVIRONMENT === 'production') {
+      return 'production';
+    } else if (
+      process.env.ENVIRONMENT === 'development'
+      || process.env.FUNCTIONS_EMULATOR === true
+      || process.env.FUNCTIONS_EMULATOR === 'true'
+      || process.env.TERM_PROGRAM === 'Apple_Terminal'
+      || process.env.TERM_PROGRAM === 'vscode'
+    ) {
+      return 'development';
+    } else {
+      // Default: production. BEM's deployed RUNTIME can legitimately lack a dev signal — a
+      // live Cloud Function has no FUNCTIONS_EMULATOR and often no ENVIRONMENT var, so
+      // "no signal" IS the normal production state. Defaulting to development here would make
+      // every deployed function skip real side effects (emails/analytics/webhooks).
+      // (Contrast UJM/BXM, whose deployed artifacts always carry their signal, so they default
+      // to development — a bare context there is just build tooling.)
+      return 'production';
+    }
+  };
+
+  // The three checks are mutually exclusive — each true for ONLY its own environment.
+  // isDevelopment() is NOT true in testing; isProduction() is a real positive check
+  // (never `!isDevelopment()`). Gate "anything non-production" with `!isProduction()`
+  // or `isDevelopment() || isTesting()` intentionally.
+  self.isDevelopment = function() {
+    return self.getEnvironment() === 'development';
+  };
+  self.isProduction = function() {
+    return self.getEnvironment() === 'production';
+  };
+  self.isTesting = function() {
+    return self.getEnvironment() === 'testing';
+  };
+
   // Init assistant
   self.assistant = self.Assistant().init({
     req: null,
@@ -190,21 +238,33 @@ Manager.prototype.init = function (exporter, options) {
 
   // Helper functions for URLs based on environment
   self.getFunctionsUrl = function(env) {
-    const isDev = env === 'development' || (!env && self.assistant.isDevelopment());
+    // Auto-detect (no explicit env): development OR testing → local URLs. Test runs
+    // hit the local emulator, so getApiUrl/getFunctionsUrl/getWebsiteUrl must resolve
+    // to localhost. NOTE: getParentApiUrl/getParentUrl are intentionally NOT changed —
+    // the parent is a real remote server with no localhost equivalent.
+    const isDev = env === 'development' || (!env && (self.isDevelopment() || self.isTesting()));
     return isDev
       ? `http://localhost:5001/${self.project.projectId}/${self.project.resourceZone}`
       : `https://${self.project.resourceZone}-${self.project.projectId}.cloudfunctions.net`;
   };
 
   self.getApiUrl = function(env) {
-    const isDev = env === 'development' || (!env && self.assistant.isDevelopment());
+    // Auto-detect (no explicit env): development OR testing → local URLs. Test runs
+    // hit the local emulator, so getApiUrl/getFunctionsUrl/getWebsiteUrl must resolve
+    // to localhost. NOTE: getParentApiUrl/getParentUrl are intentionally NOT changed —
+    // the parent is a real remote server with no localhost equivalent.
+    const isDev = env === 'development' || (!env && (self.isDevelopment() || self.isTesting()));
     return isDev
       ? 'http://localhost:5002'
       : `https://api.${(self.config.brand?.url || '').replace(/^https?:\/\//, '')}`;
   };
 
   self.getWebsiteUrl = function(env) {
-    const isDev = env === 'development' || (!env && self.assistant.isDevelopment());
+    // Auto-detect (no explicit env): development OR testing → local URLs. Test runs
+    // hit the local emulator, so getApiUrl/getFunctionsUrl/getWebsiteUrl must resolve
+    // to localhost. NOTE: getParentApiUrl/getParentUrl are intentionally NOT changed —
+    // the parent is a real remote server with no localhost equivalent.
+    const isDev = env === 'development' || (!env && (self.isDevelopment() || self.isTesting()));
     return isDev
       ? 'https://localhost:4000'
       : self.config.brand?.url || '';
@@ -254,7 +314,7 @@ Manager.prototype.init = function (exporter, options) {
   self.project.websiteUrl = self.getWebsiteUrl();
 
   // Set environment
-  process.env.ENVIRONMENT = process.env.ENVIRONMENT || self.assistant.meta.environment;
+  process.env.ENVIRONMENT = process.env.ENVIRONMENT || self.getEnvironment();
 
   // Set BEM env variables
   process.env.BEM_FUNCTIONS_URL = self.project.functionsUrl;
@@ -262,9 +322,10 @@ Manager.prototype.init = function (exporter, options) {
   process.env.BEM_WEBSITE_URL = self.project.websiteUrl;
 
   // Use the working Firebase logger that they disabled for whatever reason
+  // Load the Firebase logger compat shim only in production (NOT development or testing).
   if (
     process.env.GCLOUD_PROJECT
-    && self.assistant.meta.environment !== 'development'
+    && self.isProduction()
     && options.useFirebaseLogger
   ) {
     // require('firebase-functions/lib/logger/compat'); // Old way
@@ -272,7 +333,7 @@ Manager.prototype.init = function (exporter, options) {
   }
 
   // Handle test environment
-  if (self.assistant.isTesting()) {
+  if (self.isTesting()) {
     self.assistant.log('⚠️⚠️⚠️ Running in TEST environment, some features may be disabled ⚠️⚠️⚠️');
 
     // Install the test-mode-file watcher exactly once. Lets the test command
@@ -283,7 +344,7 @@ Manager.prototype.init = function (exporter, options) {
   }
 
   // Handle dev environments
-  if (self.assistant.isDevelopment()) {
+  if (self.isDevelopment()) {
     const version = require('wonderful-version');
     const nodeUsing = version.major(process.versions.node);
     const nodeRequired = version.major(self.package?.engines?.node || '0.0.0');
@@ -331,14 +392,17 @@ Manager.prototype.init = function (exporter, options) {
       dsn: sentryDSN,
       release: sentryRelease,
       beforeSend(event, hint) {
-        if (self.assistant.isDevelopment() && !self.options.reportErrorsInDev) {
-          self.assistant.error(new Error('[Sentry] Skipping Sentry because we\'re in development'), hint)
+        // Skip Sentry in any non-production environment (development OR testing) unless
+        // explicitly opted in. Intentional positive check — we never want test-run errors
+        // polluting production Sentry.
+        if (!self.isProduction() && !self.options.reportErrorsInDev) {
+          self.assistant.error(new Error('[Sentry] Skipping Sentry because we\'re not in production'), hint)
           return null;
         }
         event.tags = event.tags || {};
         event.tags['function.name'] = self.assistant.meta.name;
         event.tags['function.type'] = self.assistant.meta.type;
-        event.tags['environment'] = self.assistant.meta.environment;
+        event.tags['environment'] = self.getEnvironment();
         return event;
       },
     });
@@ -381,7 +445,7 @@ Manager.prototype.init = function (exporter, options) {
   }
 
   // Fetch stats
-  if (self.assistant.isDevelopment() && options.fetchStats) {
+  if (self.isDevelopment() && options.fetchStats) {
     setTimeout(function () {
       self.assistant.log('Fetching meta/stats...');
       self.libraries.admin
@@ -677,7 +741,7 @@ Manager.prototype.storage = function (options) {
     // Clear temporary storage
     if (
       options.temporary
-      && self.assistant.isDevelopment()
+      && self.isDevelopment()
       && options.clear
     ) {
       self.assistant.log('Removed temporary file @', location);