backend-manager 5.1.4 → 5.2.0

package/src/cli/commands/serve.js

@@ -25,11 +25,63 @@ class ServeCommand extends BaseCommand {
     // Start Stripe webhook forwarding in background
     this.startStripeWebhookForwarding();
 
-    // Set up log file in the project directory
+    // Set up log file in the project directory.
+    // Mirrors the emulator.js pattern: the file is truncated on boot and on every
+    // hot reload. Two reset signals are honored:
+    //   1. Sentinel file (serve.log.reset) — used by the BEM watcher when source
+    //      changes in backend-manager itself trigger a reload.
+    //   2. Reload marker on stdout (`Using node@22 from host.`) — catches reloads
+    //      triggered by firebase serve's own internal watcher (any change inside
+    //      the consumer's functions/ directory). MUST be the line firebase-tools
+    //      prints at the START of each reload cycle, not somewhere in the middle.
+    //      If we rolled mid-cycle (e.g. on "Loaded functions definitions"), the
+    //      tail of the reload sequence still gets captured into the fresh log;
+    //      but firebase serve sometimes only emits the trailing function-initialized
+    //      lines on the first cycle (subsequent cycles route those elsewhere), so
+    //      we'd end up with a near-empty log. Rolling at the START of the cycle
+    //      lets us capture whatever firebase-tools does emit, complete-or-not.
     const logPath = path.join(projectDir, 'functions', 'serve.log');
-    const logStream = fs.createWriteStream(logPath, { flags: 'w' });
+    const resetSentinelPath = `${logPath}.reset`;
+    // Match any node version: "Using node@22 from host.", "Using node@20 from host.", etc.
+    const RELOAD_MARKER = /Using node@\d+ from host\./;
     const stripAnsi = (str) => str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
 
+    let currentStream = fs.createWriteStream(logPath, { flags: 'w' });
+    let reloadCount = 0; // skip rolling on the first marker (initial boot, not a reload)
+
+    function rollLog() {
+      try {
+        const oldStream = currentStream;
+        currentStream = fs.createWriteStream(logPath, { flags: 'w' });
+        oldStream.end();
+      } catch (e) {
+        // Best-effort. If roll fails, serve keeps running with the existing stream.
+      }
+    }
+
+    function writeToLog(data) {
+      if (currentStream && !currentStream.destroyed) {
+        currentStream.write(stripAnsi(data.toString()));
+      }
+    }
+
+    // Clean up any stale sentinel from a prior crashed serve run
+    try { fs.unlinkSync(resetSentinelPath); } catch (e) { /* not present, ok */ }
+
+    // Poll every 500ms for the reset sentinel — cheap, no fs.watch quirks
+    const resetWatcher = setInterval(() => {
+      if (!fs.existsSync(resetSentinelPath)) {
+        return;
+      }
+
+      try {
+        rollLog();
+        fs.unlinkSync(resetSentinelPath);
+      } catch (e) {
+        // Best-effort.
+      }
+    }, 500);
+
     this.log(chalk.gray(`  Logs saving to: ${logPath}\n`));
 
     // Execute with tee to log file
@@ -42,21 +94,35 @@ class ServeCommand extends BaseCommand {
           env: { ...process.env, FORCE_COLOR: '1' },
         },
       }, (child) => {
-        // Tee stdout to both console and log file (strip ANSI codes for clean log)
+        // Tee stdout to both console and log file (strip ANSI codes for clean log).
+        // Watch each chunk for the reload marker — when seen (after the initial boot),
+        // roll the log BEFORE writing this chunk so the marker becomes the first
+        // line of the fresh file.
         child.stdout.on('data', (data) => {
           process.stdout.write(data);
-          logStream.write(stripAnsi(data.toString()));
+          const text = data.toString();
+          if (RELOAD_MARKER.test(text)) {
+            reloadCount++;
+            if (reloadCount > 1) {
+              rollLog();
+            }
+          }
+          writeToLog(data);
         });
 
         // Tee stderr to both console and log file (strip ANSI codes for clean log)
         child.stderr.on('data', (data) => {
           process.stderr.write(data);
-          logStream.write(stripAnsi(data.toString()));
+          writeToLog(data);
         });
 
-        // Clean up log stream when child exits
+        // Clean up log stream + watcher when child exits
         child.on('close', () => {
-          logStream.end();
+          clearInterval(resetWatcher);
+          if (currentStream && !currentStream.destroyed) {
+            currentStream.end();
+          }
+          try { fs.unlinkSync(resetSentinelPath); } catch (e) { /* ok */ }
         });
       });
     } catch (error) {

package/src/cli/commands/test.js

@@ -51,7 +51,7 @@ class TestCommand extends BaseCommand {
     // Use hosting URL for all API requests (rewrites to bm_api function)
     const testConfig = {
       ...projectConfig,
-      hostingUrl: `http://127.0.0.1:${emulatorPorts.hosting}`,
+      apiUrl: `http://127.0.0.1:${emulatorPorts.hosting}`,
       projectDir,
       testPaths,
       emulatorPorts,
@@ -185,12 +185,58 @@ class TestCommand extends BaseCommand {
     return this.isPortInUse(emulatorPorts.functions);
   }
 
+  /**
+   * Signal the running emulator process to roll emulator.log.
+   *
+   * Mechanism: write a sentinel file at emulator.log.reset. The emulator command
+   * (src/cli/commands/emulator.js) polls for it and, on detection, closes its
+   * current write stream and reopens with flags: 'w' (truncating cleanly from its
+   * own perspective — avoids the sparse-file problem caused by external truncation).
+   *
+   * Waits up to 2s for the sentinel to be consumed. If it's still there after 2s
+   * the emulator isn't watching (probably running an older BEM or started outside
+   * `npx mgr emulator`); we delete the sentinel and proceed — tests still run, the
+   * log just won't be reset for this run.
+   */
+  async requestEmulatorLogReset(projectDir) {
+    const logPath = path.join(projectDir, 'functions', 'emulator.log');
+    const sentinelPath = `${logPath}.reset`;
+
+    try {
+      fs.writeFileSync(sentinelPath, '');
+    } catch (e) {
+      return; // Can't write — skip, not fatal
+    }
+
+    // Poll for the emulator to consume the sentinel (it deletes the file when done)
+    const maxWaitMs = 2000;
+    const pollIntervalMs = 100;
+    const start = Date.now();
+
+    while (Date.now() - start < maxWaitMs) {
+      if (!fs.existsSync(sentinelPath)) {
+        return; // Emulator picked it up and rolled the log
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+
+    // Timed out — emulator didn't see the sentinel. Clean up so we don't leave it behind.
+    try { fs.unlinkSync(sentinelPath); } catch (e) { /* ok */ }
+  }
+
   /**
    * Run tests directly (emulator already running)
    */
   async runTestsDirectly(testCommand, functionsDir, emulatorPorts) {
     const projectDir = this.main.firebaseProjectPath;
 
+    // Ask the running emulator process to roll emulator.log so this test run gets a
+    // clean slate. We touch a sentinel file the emulator polls for (every ~500ms) and
+    // wait briefly for it to be consumed. If the emulator isn't watching (older BEM
+    // version, or not started via `npx mgr emulator`), we time out silently — the log
+    // just won't be fresh, tests still run normally.
+    await this.requestEmulatorLogReset(projectDir);
+
     this.log(chalk.gray(`  Hosting: http://127.0.0.1:${emulatorPorts.hosting}`));
     this.log(chalk.gray(`  Firestore: 127.0.0.1:${emulatorPorts.firestore}`));
     this.log(chalk.gray(`  Auth: 127.0.0.1:${emulatorPorts.auth}`));

package/src/cli/commands/watch.js

@@ -53,13 +53,21 @@ class WatchCommand extends BaseCommand {
     // So we must: 1) ensure file exists, 2) wait for FS to settle, 3) write new content
     // --on-change-only: only run exec when files change, not on initial startup
     // --delay 1: debounce multiple rapid changes into one trigger
+    //
+    // The exec also drops <log>.reset sentinels so the parent serve/emulator command
+    // rolls its log file cleanly on every hot reload (mirrors the emulator log-roll
+    // pattern used by the test runner). Sentinels are best-effort — if a parent
+    // command isn't watching, the file is harmless and gets cleaned up by the next
+    // boot's stale-sentinel sweep.
     const triggerFile = config.triggerFile;
+    const serveLogResetPath = path.join(config.functionsDir, 'serve.log.reset');
+    const emulatorLogResetPath = path.join(config.functionsDir, 'emulator.log.reset');
     const nodemon = spawn(nodemonPath, [
       '--on-change-only',
       '--delay', '1',
       '--watch', config.bemSrcDir,
       '--ext', 'js,json',
-      '--exec', `node -e "var f='${triggerFile}',fs=require('fs');if(!fs.existsSync(f)){fs.writeFileSync(f,'// init');require('child_process').execSync('sleep 0.1');}fs.writeFileSync(f,'// '+Date.now())" && echo "  [BEM] Triggered hot reload"`,
+      '--exec', `node -e "var f='${triggerFile}',fs=require('fs');if(!fs.existsSync(f)){fs.writeFileSync(f,'// init');require('child_process').execSync('sleep 0.1');}fs.writeFileSync(f,'// '+Date.now());try{fs.writeFileSync('${serveLogResetPath}','');}catch(e){}try{fs.writeFileSync('${emulatorLogResetPath}','');}catch(e){}" && echo "  [BEM] Triggered hot reload"`,
     ], {
       stdio: 'inherit',
       detached: false,
@@ -93,11 +101,15 @@ class WatchCommand extends BaseCommand {
       jetpack.write(config.triggerFile, `// BEM reload trigger\n`);
     }
 
-    // Use nodemon to watch the BEM src directory and touch the trigger file on changes
+    // Use nodemon to watch the BEM src directory and touch the trigger file on changes.
+    // Also drop <log>.reset sentinels so any sibling serve/emulator command rolls its
+    // log file on each reload (mirrors the test runner's log-roll pattern).
+    const serveLogResetPath = path.join(config.functionsDir, 'serve.log.reset');
+    const emulatorLogResetPath = path.join(config.functionsDir, 'emulator.log.reset');
     const nodemon = spawn(nodemonPath, [
       '--watch', config.bemSrcDir,
       '--ext', 'js,json',
-      '--exec', `touch "${config.triggerFile}" && echo "  → Triggered hot reload"`,
+      '--exec', `touch "${config.triggerFile}" "${serveLogResetPath}" "${emulatorLogResetPath}" && echo "  → Triggered hot reload"`,
     ], {
       stdio: 'inherit',
       cwd: config.bemDir,

package/src/manager/helpers/user.js

@@ -147,6 +147,35 @@ const SCHEMA = {
       page: { type: 'string', default: null, nullable: true },
     },
   },
+  consent: {
+    legal: {
+      status: { type: 'string', default: 'revoked' },
+      grantedAt: {
+        timestamp: { type: 'string', default: null, nullable: true },
+        timestampUNIX: { type: 'number', default: null, nullable: true },
+        source: { type: 'string', default: null, nullable: true },
+        ip: { type: 'string', default: null, nullable: true },
+        text: { type: 'string', default: null, nullable: true },
+      },
+    },
+    marketing: {
+      status: { type: 'string', default: 'revoked' },
+      grantedAt: {
+        timestamp: { type: 'string', default: null, nullable: true },
+        timestampUNIX: { type: 'number', default: null, nullable: true },
+        source: { type: 'string', default: null, nullable: true },
+        ip: { type: 'string', default: null, nullable: true },
+        text: { type: 'string', default: null, nullable: true },
+      },
+      revokedAt: {
+        timestamp: { type: 'string', default: null, nullable: true },
+        timestampUNIX: { type: 'number', default: null, nullable: true },
+        source: { type: 'string', default: null, nullable: true },
+        ip: { type: 'string', default: null, nullable: true },
+        text: { type: 'string', default: null, nullable: true },
+      },
+    },
+  },
 };
 
 /**

package/src/manager/index.js

@@ -210,6 +210,35 @@ Manager.prototype.init = function (exporter, options) {
       : self.config.brand?.url || '';
   };
 
+  // Resolve the parent BEM's website URL (the parent's brand domain, NO `api.` subdomain).
+  // - If config.parent === 'self', THIS BEM is the parent — returns this brand's own URL.
+  // - If config.parent is a URL, returns it as-is.
+  // - Returns '' if neither is configured.
+  // Use getParentApiUrl() for the API URL (with `api.` subdomain inserted).
+  self.getParentUrl = function() {
+    const parent = self.config.parent;
+    if (parent === 'self') {
+      return self.config.brand?.url || '';
+    }
+    return parent || '';
+  };
+
+  // Resolve the parent BEM's API URL (`https://api.{parent-host}`).
+  // ALWAYS returns the live production URL — even when THIS brand is running
+  // in dev/test mode. The parent's API is a real remote server (no localhost
+  // equivalent), so dev-mode does NOT redirect to localhost the way getApiUrl()
+  // does. Use this when you need to call the parent's API from any environment.
+  self.getParentApiUrl = function() {
+    const base = self.getParentUrl().replace(/^https?:\/\//, '');
+    return base ? `https://api.${base}` : '';
+  };
+
+  // Returns true when this BEM IS the parent (config.parent === 'self').
+  // Gates parent-only routes like /marketing/webhook/forward.
+  self.isParent = function() {
+    return self.config.parent === 'self';
+  };
+
   // Set more properties (need to wait for assistant to determine if DEV)
   self.project.functionsUrl = self.getFunctionsUrl();
 

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

@@ -242,6 +242,7 @@
   "ac20mail.in",
   "academiccommunity.com",
   "academywe.us",
+  "acanok.com",
   "acc1s.com",
   "acc1s.net",
   "accclone.com",
@@ -653,6 +654,7 @@
   "biojuris.com",
   "bione.co",
   "bipochub.com",
+  "bitmah.com",
   "bitmens.com",
   "bitwhites.top",
   "bitymails.us",
@@ -1072,6 +1074,7 @@
   "dao.pp.ua",
   "daouse.com",
   "dapurx.me",
+  "dardr.com",
   "darkharvestfilms.com",
   "daryxfox.net",
   "dasdasdascyka.tk",
@@ -1937,6 +1940,7 @@
   "getairmail.gq",
   "getairmail.ml",
   "getairmail.tk",
+  "getasail.com",
   "geteit.com",
   "getfun.men",
   "getmail1.com",
@@ -2164,6 +2168,7 @@
   "hidemail.pro",
   "hidemail.us",
   "hidesmail.net",
+  "hidevak.com",
   "hidingmail.net",
   "hidmail.org",
   "hidzz.com",
@@ -2173,6 +2178,7 @@
   "highstar.shop",
   "hihi.lol",
   "hikuhu.com",
+  "hilostar.com",
   "hiltonvr.com",
   "him6.com",
   "himail.infos.st",
@@ -2190,6 +2196,7 @@
   "holio.day",
   "holl.ga",
   "homecut.pro",
+  "homvela.com",
   "honesthirianinda.net",
   "honeys.be",
   "honor-8.com",
@@ -2434,6 +2441,7 @@
   "itcompu.com",
   "itfast.net",
   "itmo.edu.pl",
+  "itquoted.com",
   "itsbds.com",
   "itsedit.click",
   "itsjiff.com",

package/src/manager/libraries/email/generators/newsletter.js

@@ -77,7 +77,7 @@ async function generate(Manager, assistant, settings, opts = {}) {
       return null;
     }
 
-    const parentUrl = Manager.config?.parent;
+    const parentUrl = Manager.getParentApiUrl();
 
     if (!parentUrl) {
       assistant.log('Newsletter generator: no parent URL configured');
@@ -311,7 +311,7 @@ async function generate(Manager, assistant, settings, opts = {}) {
 
   // 4. Mark sources as used on parent server (unless caller opted out)
   if (!opts.skipClaim) {
-    const parentUrl = Manager.config?.parent;
+    const parentUrl = Manager.getParentApiUrl();
 
     if (parentUrl) {
       await claimSources(parentUrl, sources, brand?.id, assistant);

package/src/manager/libraries/email/providers/beehiiv.js

@@ -415,6 +415,7 @@ async function createPost(options) {
 module.exports = {
   // Resolution
   resolveSegmentIds,
+  getPublicationId,
 
   // Contacts
   addContact,

package/src/manager/libraries/payment/processors/stripe.js

@@ -452,6 +452,18 @@ function resolveProduct(raw, config) {
     return { id: 'basic', name: 'Basic' };
   }
 
+  // Test-mode sentinel: the test processor synthesizes "_test_<id>" when no real
+  // Stripe product is configured. Map it back to the matching BEM product so the
+  // pipeline can be exercised end-to-end without real Stripe credentials.
+  if (typeof stripeProductId === 'string' && stripeProductId.startsWith('_test_')) {
+    const bemId = stripeProductId.slice('_test_'.length);
+    const product = config.payment.products.find((p) => p.id === bemId);
+    if (product) {
+      return { id: product.id, name: product.name || product.id };
+    }
+    return { id: 'basic', name: 'Basic' };
+  }
+
   for (const product of config.payment.products) {
     // Match current product ID
     if (product.stripe?.productId === stripeProductId) {

package/src/manager/libraries/payment/processors/test.js

@@ -174,5 +174,12 @@ function resolveStripeProductId(productId, config) {
 
   const product = config.payment.products.find(p => p.id === productId);
 
-  return product?.stripe?.productId || null;
+  if (!product) {
+    return null;
+  }
+
+  // Real Stripe product ID if configured, otherwise the "_test_<id>" sentinel that the
+  // Stripe resolver recognizes and maps back to the BEM product. Lets reconstruction
+  // work in brands without real Stripe (Somiibo uses PayPal, Chargebee, etc.).
+  return product.stripe?.productId || `_test_${product.id}`;
 }

package/src/manager/routes/admin/infer-contact/post.js

@@ -16,8 +16,9 @@ module.exports = async ({ assistant, user, settings }) => {
     return assistant.respond('Admin required.', { code: 403 });
   }
 
-  // Accept single email or array of emails
-  const emails = Array.isArray(settings.emails)
+  // Accept single email or array of emails. Schema defaults `emails` to [], so check length:
+  // an empty default should NOT shadow a provided single `email`.
+  const emails = Array.isArray(settings.emails) && settings.emails.length > 0
     ? settings.emails
     : [settings.email];