backend-manager 5.2.3 → 5.2.6

package/scripts/test-helper-providers.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+/**
+ * Test Helper — direct provider lookups + removals via API
+ *
+ * Lets the live-test checklist verify SendGrid + Beehiiv state without
+ * clicking around in dashboards. Reuses the same provider helpers that
+ * BEM uses in production (findContact / removeContact).
+ *
+ * Usage (run from a consumer project's functions/ dir):
+ *
+ *   node ../../../backend-manager/scripts/test-helper-providers.js find  user@example.com
+ *   node ../../../backend-manager/scripts/test-helper-providers.js purge user@example.com
+ *
+ * Or symlink: `ln -s ../../../backend-manager/scripts/test-helper-providers.js ./prov`
+ * then: `node ./prov find user@example.com`
+ *
+ * - find:  prints whether the contact exists in SendGrid + Beehiiv (and the data shape).
+ * - purge: removes the contact from BOTH providers (idempotent; safe if absent).
+ *
+ * The script picks up:
+ *   - SENDGRID_API_KEY, BEEHIIV_API_KEY from <cwd>/.env (functions/.env)
+ *   - marketing.sendgrid.listId, marketing.beehiiv.publicationId from <cwd>/backend-manager-config.json
+ *   - service-account from <cwd>/service-account.json
+ *
+ * Exit codes: 0 ok, 1 usage error, 2 provider error.
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const cwd = process.cwd();
+const envPath = path.join(cwd, '.env');
+const configPath = path.join(cwd, 'backend-manager-config.json');
+const serviceAccountPath = path.join(cwd, 'service-account.json');
+
+// --- sanity checks ---
+if (!fs.existsSync(envPath)) {
+  console.error(`✗ Missing ${envPath} — run from the consumer's functions/ dir`);
+  process.exit(1);
+}
+if (!fs.existsSync(configPath)) {
+  console.error(`✗ Missing ${configPath} — run from the consumer's functions/ dir`);
+  process.exit(1);
+}
+if (!fs.existsSync(serviceAccountPath)) {
+  console.error(`✗ Missing ${serviceAccountPath} — run from the consumer's functions/ dir`);
+  process.exit(1);
+}
+
+// --- parse args ---
+const [, , cmd, email] = process.argv;
+const VALID_CMDS = ['find', 'purge'];
+
+if (!cmd || !VALID_CMDS.includes(cmd) || !email) {
+  console.error('Usage:');
+  console.error('  node test-helper-providers.js find  <email>');
+  console.error('  node test-helper-providers.js purge <email>');
+  process.exit(1);
+}
+
+// --- bootstrap env (dotenv style, minimal) ---
+require('dotenv').config({ path: envPath });
+
+if (!process.env.SENDGRID_API_KEY) {
+  console.error('✗ SENDGRID_API_KEY not set in .env');
+  process.exit(1);
+}
+if (!process.env.BEEHIIV_API_KEY) {
+  console.error('✗ BEEHIIV_API_KEY not set in .env');
+  process.exit(1);
+}
+
+// --- bootstrap Manager so providers can read Manager.config.marketing.* ---
+// The providers require '../../../index.js' which is the Manager singleton.
+// We need to load BEM from the consumer's node_modules (not the BEM repo's own src)
+// so it picks up the consumer's config + service account.
+let Manager;
+try {
+  const BackendManager = require(path.join(cwd, 'node_modules', 'backend-manager'));
+  Manager = (new BackendManager()).init({}, { setupFunctionsLegacy: false, log: false });
+} catch (e) {
+  console.error('✗ Failed to bootstrap Manager from consumer node_modules:', e.message);
+  process.exit(2);
+}
+
+// --- load providers via the BEM Manager.libraries surface (preferred) or direct path ---
+const sendgridProviderPath = path.join(cwd, 'node_modules', 'backend-manager', 'src', 'manager', 'libraries', 'email', 'providers', 'sendgrid.js');
+const beehiivProviderPath = path.join(cwd, 'node_modules', 'backend-manager', 'src', 'manager', 'libraries', 'email', 'providers', 'beehiiv.js');
+
+const sendgrid = require(sendgridProviderPath);
+const beehiiv = require(beehiivProviderPath);
+
+// --- commands ---
+async function find(email) {
+  console.log(`Looking up ${email} on both providers...`);
+
+  const [sgContact, bhContact] = await Promise.all([
+    sendgrid.findContact(email).catch(e => ({ _error: e.message })),
+    beehiiv.findContact(email).catch(e => ({ _error: e.message })),
+  ]);
+
+  console.log('\n── SendGrid ──');
+  if (sgContact?._error) {
+    console.log(`  ✗ error: ${sgContact._error}`);
+  } else if (!sgContact) {
+    console.log('  ⊘ not found');
+  } else {
+    console.log(`  ✓ found — id=${sgContact.id || '?'}, email=${sgContact.email || '?'}`);
+  }
+
+  console.log('\n── Beehiiv ──');
+  if (bhContact?._error) {
+    console.log(`  ✗ error: ${bhContact._error}`);
+  } else if (!bhContact) {
+    console.log('  ⊘ not found');
+  } else {
+    console.log(`  ✓ found — id=${bhContact.id || '?'}, email=${bhContact.email || '?'}, status=${bhContact.status || '?'}`);
+  }
+
+  return { sgContact, bhContact };
+}
+
+async function purge(email) {
+  console.log(`Removing ${email} from both providers...`);
+
+  const [sgResult, bhResult] = await Promise.all([
+    sendgrid.removeContact(email).catch(e => ({ _error: e.message })),
+    beehiiv.removeContact(email).catch(e => ({ _error: e.message })),
+  ]);
+
+  console.log('\n── SendGrid ──');
+  if (sgResult?._error) {
+    console.log(`  ✗ error: ${sgResult._error}`);
+  } else {
+    console.log(`  ✓ ${JSON.stringify(sgResult)}`);
+  }
+
+  console.log('\n── Beehiiv ──');
+  if (bhResult?._error) {
+    console.log(`  ✗ error: ${bhResult._error}`);
+  } else {
+    console.log(`  ✓ ${JSON.stringify(bhResult)}`);
+  }
+
+  return { sgResult, bhResult };
+}
+
+// --- main ---
+(async () => {
+  try {
+    if (cmd === 'find') {
+      await find(email);
+    } else if (cmd === 'purge') {
+      await purge(email);
+    }
+    process.exit(0);
+  } catch (e) {
+    console.error('✗ Unexpected error:', e);
+    process.exit(2);
+  }
+})();

package/src/cli/commands/base-command.js

@@ -236,7 +236,7 @@ class BaseCommand {
     this.log(chalk.gray('  (Stripe webhook forwarding is currently disabled - coming soon!)\n'));
     return null;
 
-    // Load .env so STRIPE_SECRET_KEY and BACKEND_MANAGER_KEY are available
+    // Load .env so STRIPE_SECRET_KEY and BACKEND_MANAGER_WEBHOOK_KEY are available
     const envPath = path.join(functionsDir, '.env');
     if (jetpack.exists(envPath)) {
       require('dotenv').config({ path: envPath, quiet: true });
@@ -248,9 +248,9 @@ class BaseCommand {
       return null;
     }
 
-    // Check for Backend Manager key
-    if (!process.env.BACKEND_MANAGER_KEY) {
-      this.log(chalk.gray('  (Stripe webhook forwarding disabled - BACKEND_MANAGER_KEY not set in .env)\n'));
+    // Check for Backend Manager webhook key
+    if (!process.env.BACKEND_MANAGER_WEBHOOK_KEY) {
+      this.log(chalk.gray('  (Stripe webhook forwarding disabled - BACKEND_MANAGER_WEBHOOK_KEY not set in .env)\n'));
       return null;
     }
 
@@ -276,7 +276,7 @@ class BaseCommand {
       }
     }
 
-    const forwardUrl = `http://localhost:${hostingPort}/backend-manager/payments/webhook?processor=stripe&key=${process.env.BACKEND_MANAGER_KEY}`;
+    const forwardUrl = `http://localhost:${hostingPort}/backend-manager/payments/webhook?processor=stripe&key=${process.env.BACKEND_MANAGER_WEBHOOK_KEY}`;
 
     this.log(chalk.gray(`  Stripe webhook forwarding -> localhost:${hostingPort}\n`));
 

package/src/cli/commands/emulator.js

@@ -1,15 +1,20 @@
 const BaseCommand = require('./base-command');
 const path = require('path');
 const fs = require('fs');
+const { spawn } = require('child_process');
 const chalk = require('chalk').default;
 const jetpack = require('fs-jetpack');
 const JSON5 = require('json5');
-const powertools = require('node-powertools');
 const WatchCommand = require('./watch');
 const { DEFAULT_EMULATOR_PORTS } = require('./setup-tests/emulator-config');
 const { EXTENDED_MODE_WARNING } = require('../../test/utils/extended-mode-warning');
 const { writeTestMode, captureSyncedEnv } = require('../../test/utils/test-mode-file');
 
+// Used by both `npx mgr emulator` and `npx mgr test` auto-start path.
+// Note: `emulators:start` enables the UI by default (controlled by firebase.json's
+// `emulators.ui.enabled`), so no `--ui` flag here — that flag only exists on `:exec`.
+const EMULATOR_FLAGS = '--only functions,firestore,auth,database,hosting,pubsub';
+
 class EmulatorCommand extends BaseCommand {
   async execute() {
     this.log(chalk.cyan('\n  Starting Firebase emulator (keep-alive mode)...\n'));
@@ -45,23 +50,40 @@ class EmulatorCommand extends BaseCommand {
     // Start Stripe webhook forwarding in background
     this.startStripeWebhookForwarding();
 
-    // Run emulator with keep-alive command (use single quotes since runWithEmulator wraps in double quotes)
-    const keepAliveCommand = "echo ''; echo 'Emulator ready. Press Ctrl+C to shut down...'; sleep 86400";
-
+    // Keep-alive: boot emulators and wait for Ctrl+C. No "command" subprocess —
+    // the emulator child IS the foreground process from the user's perspective.
     try {
-      await this.runWithEmulator(keepAliveCommand);
-    } catch (error) {
-      // User pressed Ctrl+C - this is expected
+      const { shutdown, exitPromise } = await this.startEmulators();
+
+      this.log(chalk.gray('\n  Emulator ready. Press Ctrl+C to shut down...\n'));
+
+      const onSigint = async () => {
+        this.log(chalk.gray('\n  Shutting down emulator...'));
+        await shutdown();
+        this.log(chalk.gray('  Emulator stopped.\n'));
+        process.exit(0);
+      };
+      process.once('SIGINT', onSigint);
+
+      // Resolve if the emulator dies on its own (crash, port conflict, etc.)
+      await exitPromise;
+      process.removeListener('SIGINT', onSigint);
       this.log(chalk.gray('\n  Emulator stopped.\n'));
+    } catch (error) {
+      this.logError(`Emulator error: ${error.message || error}`);
+      process.exit(1);
     }
   }
 
   /**
-   * Run a command with Firebase emulator
-   * @param {string} command - The command to execute inside the Firebase emulator
-   * @returns {Promise<void>}
+   * Boot Firebase emulators as a long-running child process.
+   * Stdout/stderr are teed to console + emulator.log.
+   * Resolves once the emulator hub is listening (i.e., emulators are ready).
+   * Caller is responsible for calling shutdown() to send SIGTERM and wait for exit.
+   *
+   * @returns {Promise<{ child: ChildProcess, shutdown: () => Promise<void>, emulatorPorts: object }>}
    */
-  async runWithEmulator(command) {
+  async startEmulators() {
     const projectDir = this.main.firebaseProjectPath;
 
     // Load emulator ports from firebase.json
@@ -73,24 +95,13 @@ class EmulatorCommand extends BaseCommand {
       throw new Error('Port conflicts could not be resolved');
     }
 
-    // Wipe stale firebase-tools debug logs + any leftover BEM logs from older
-    // versions. Keeps the project tree clean across runs.
+    // Wipe stale firebase-tools debug logs + any leftover BEM logs from older versions.
     this.sweepStaleLogs();
 
-    // BEM_TESTING=true is passed so Functions skip external API calls (emails, SendGrid)
-    // hosting is included so localhost:5002 rewrites work (e.g., /backend-manager -> bm_api)
-    // pubsub is included so scheduled functions (bm_cronDaily) can be triggered in tests
-    // Use double quotes for command wrapper since the command may contain single quotes (JSON strings)
-    const envPrefix = process.env.TEST_EXTENDED_MODE
-      ? 'BEM_TESTING=true TEST_EXTENDED_MODE=true'
-      : 'BEM_TESTING=true';
-    const emulatorCommand = `${envPrefix} firebase emulators:exec --only functions,firestore,auth,database,hosting,pubsub --ui "${command}"`;
-
-    // Set up log file in the project directory.
-    // We use a mutable `currentStream` so the test command can request a fresh log
-    // by touching emulator.log.reset — the watcher below detects it, closes the
-    // current stream, reopens with flags: 'w' (truncating cleanly from our process'
-    // perspective, no sparse-file issue), and deletes the sentinel.
+    // Set up log file + reset-sentinel watcher.
+    // Mutable `currentStream` so the test command can request a fresh log by touching
+    // emulator.log.reset — the watcher detects it, closes the current stream, and
+    // reopens with flags: 'w' (truncating cleanly from our process' perspective).
     const logPath = this.getLogsPath('emulator.log');
     const resetSentinelPath = this.getTempPath('emulator.log.reset');
     const stripAnsi = (str) => str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
@@ -103,11 +114,9 @@ class EmulatorCommand extends BaseCommand {
       }
     }
 
-    // Clean up any stale sentinel from a prior crashed emulator run
+    // Clean up any stale sentinel from a prior crashed run
     try { fs.unlinkSync(resetSentinelPath); } catch (e) { /* not present, ok */ }
 
-    // Watch for the test command's request to roll the log.
-    // Poll every 500ms — cheap, no fs.watch quirks across platforms.
     const resetWatcher = setInterval(() => {
       if (!fs.existsSync(resetSentinelPath)) {
         return;
@@ -129,37 +138,175 @@ class EmulatorCommand extends BaseCommand {
       writeToLog('\n');
     }
 
-    this.log(chalk.gray(`  Logs saving to: ${logPath}\n`));
+    this.log(chalk.gray(`  Logs saving to: ${logPath}`));
+
+    // BEM_TESTING=true is passed so Functions skip external API calls (emails, SendGrid)
+    // hosting is included so localhost:5002 rewrites work (e.g., /backend-manager -> bm_api)
+    // pubsub is included so scheduled functions (bm_cronDaily) can be triggered in tests
+    const env = {
+      ...process.env,
+      FORCE_COLOR: '1',
+      BEM_TESTING: 'true',
+    };
 
-    await powertools.execute(emulatorCommand, {
-      log: false,
+    // Spawn `firebase emulators:start` as a background child. Use `sh -c` so the
+    // user's shell PATH resolves `firebase` consistently with the interactive shell.
+    //
+    // `detached: true` puts the child into its own process group. We need this so that
+    // shutdown() can kill the entire group (sh → firebase → java emulators) by
+    // signalling the negative pgid. Without it, SIGTERM to the shell doesn't propagate
+    // to firebase or its java grandchildren, leaving orphan firestore/pubsub processes.
+    const child = spawn('sh', ['-c', `firebase emulators:start ${EMULATOR_FLAGS}`], {
       cwd: projectDir,
-      config: {
-        stdio: ['inherit', 'pipe', 'pipe'],
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: true,
+    });
+
+    // Wire readiness detection into the stdout/stderr handlers.
+    //
+    // We watch for firebase-tools' explicit "All emulators ready!" line — that's the
+    // signal that function discovery + load is complete and the runtime can serve HTTP.
+    // Port-listening alone isn't enough: firebase-tools binds the functions socket
+    // ~5-10s before user functions are actually loadable, so HTTP requests fail with
+    // ECONNREFUSED / "fetch failed" if we proceed when only the port is open.
+    let readyResolve;
+    let readyReject;
+    const readyPromise = new Promise((resolve, reject) => {
+      readyResolve = resolve;
+      readyReject = reject;
+    });
+    let ready = false;
+    const READY_MARKER = /All emulators ready/i;
+
+    child.stdout.on('data', (data) => {
+      process.stdout.write(data);
+      writeToLog(data);
+      if (!ready && READY_MARKER.test(data.toString())) {
+        ready = true;
+        readyResolve();
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      process.stderr.write(data);
+      writeToLog(data);
+      // firebase-tools prints the ready line to stderr sometimes — watch both.
+      if (!ready && READY_MARKER.test(data.toString())) {
+        ready = true;
+        readyResolve();
+      }
+    });
+
+    // Track exit state so shutdown() can resolve when the process is gone
+    let exitPromiseResolve;
+    const exitPromise = new Promise((resolve) => {
+      exitPromiseResolve = resolve;
+    });
+
+    child.on('close', (code, signal) => {
+      clearInterval(resetWatcher);
+      if (currentStream && !currentStream.destroyed) {
+        currentStream.end();
+      }
+      try { fs.unlinkSync(resetSentinelPath); } catch (e) { /* ok */ }
+      exitPromiseResolve({ code, signal });
+      // If we exited before becoming ready, fail the readiness wait too
+      if (!ready) {
+        readyReject(new Error(`Emulator child exited before ready (code=${code}, signal=${signal})`));
+      }
+    });
+
+    // Race the readiness marker against a 60s timeout
+    const readyTimeoutMs = 60000;
+    await Promise.race([
+      readyPromise,
+      new Promise((_, reject) => setTimeout(
+        () => reject(new Error(`Emulator did not print "All emulators ready" within ${readyTimeoutMs}ms`)),
+        readyTimeoutMs,
+      )),
+    ]);
+
+    // shutdown() signals the entire emulator process group (sh + firebase + java
+    // grandchildren), waits up to 10s for clean exit, then escalates to SIGKILL.
+    //
+    // We use `process.kill(-pgid, ...)` instead of `child.kill(...)` because firebase
+    // tools spawns several Java subprocesses (firestore + pubsub) that survive if
+    // only the sh wrapper is killed. The negative PID targets the whole process group
+    // (made possible by `detached: true` above).
+    const killGroup = (signal) => {
+      try {
+        process.kill(-child.pid, signal);
+      } catch (e) {
+        // ESRCH = group already dead, that's fine
+        if (e.code !== 'ESRCH') throw e;
+      }
+    };
+
+    const shutdown = async () => {
+      if (child.exitCode !== null || child.signalCode !== null) {
+        return; // already gone
+      }
+
+      killGroup('SIGTERM');
+
+      const killTimer = setTimeout(() => {
+        if (child.exitCode === null && child.signalCode === null) {
+          killGroup('SIGKILL');
+        }
+      }, 10000);
+
+      await exitPromise;
+      clearTimeout(killTimer);
+    };
+
+    return { child, shutdown, emulatorPorts, exitPromise };
+  }
+
+  /**
+   * Boot emulators and run a single command against them. Sends SIGTERM to the emulator
+   * when the command exits (or this process is interrupted) and waits for clean shutdown.
+   *
+   * Used by `npx mgr emulator` for the keep-alive flow (command is a no-op sleep).
+   * `npx mgr test`'s auto-start path uses startEmulators() directly so it can tee the
+   * test command's output to its own log (test.log) separate from emulator.log.
+   *
+   * @param {string} command - shell command to run while emulators are up
+   */
+  async runWithEmulator(command) {
+    const { shutdown, exitPromise } = await this.startEmulators();
+
+    // SIGINT (Ctrl+C) → graceful shutdown
+    const onSigint = async () => {
+      await shutdown();
+      process.exit(0);
+    };
+    process.once('SIGINT', onSigint);
+
+    try {
+      // Run the user command; when it exits we tear down the emulator.
+      const cmdChild = spawn('sh', ['-c', command], {
+        cwd: this.main.firebaseProjectPath,
         env: { ...process.env, FORCE_COLOR: '1' },
-      },
-    }, (child) => {
-      // Tee stdout to both console and log file (strip ANSI codes for clean log)
-      child.stdout.on('data', (data) => {
-        process.stdout.write(data);
-        writeToLog(data);
+        stdio: 'inherit',
       });
 
-      // Tee stderr to both console and log file (strip ANSI codes for clean log)
-      child.stderr.on('data', (data) => {
-        process.stderr.write(data);
-        writeToLog(data);
+      const cmdExit = await new Promise((resolve) => {
+        cmdChild.on('close', (code, signal) => resolve({ code, signal }));
       });
 
-      // Clean up log stream + watcher when child exits
-      child.on('close', () => {
-        clearInterval(resetWatcher);
-        if (currentStream && !currentStream.destroyed) {
-          currentStream.end();
-        }
-        try { fs.unlinkSync(resetSentinelPath); } catch (e) { /* ok */ }
-      });
-    });
+      process.removeListener('SIGINT', onSigint);
+      await shutdown();
+      await exitPromise;
+
+      if (cmdExit.code !== 0) {
+        throw Object.assign(new Error(`Command exited with code ${cmdExit.code}`), { code: cmdExit.code });
+      }
+    } catch (e) {
+      process.removeListener('SIGINT', onSigint);
+      await shutdown();
+      throw e;
+    }
   }
 
   /**

package/src/cli/commands/test.js

@@ -1,6 +1,7 @@
 const BaseCommand = require('./base-command');
 const path = require('path');
 const fs = require('fs');
+const { spawn } = require('child_process');
 const chalk = require('chalk').default;
 const jetpack = require('fs-jetpack');
 const JSON5 = require('json5');
@@ -69,7 +70,7 @@ class TestCommand extends BaseCommand {
       await this.runTestsDirectly(testCommand, functionsDir, emulatorPorts);
     } else {
       this.log(chalk.cyan('Starting emulator and running tests...'));
-      await this.runEmulatorTests(testCommand);
+      await this.runEmulatorTests(testCommand, functionsDir);
     }
   }
 
@@ -123,6 +124,7 @@ class TestCommand extends BaseCommand {
 
     // Derive computed values (not in config file)
     const backendManagerKey = argv.key || process.env.BACKEND_MANAGER_KEY;
+    const backendManagerWebhookKey = argv.webhookKey || process.env.BACKEND_MANAGER_WEBHOOK_KEY;
     const contactEmail = config.brand?.contact?.email || '';
     const domain = contactEmail.includes('@') ? contactEmail.split('@')[1] : '';
 
@@ -138,6 +140,12 @@ class TestCommand extends BaseCommand {
       return null;
     }
 
+    if (!backendManagerWebhookKey) {
+      this.logError('Error: Missing backend manager webhook key');
+      this.log(chalk.gray('  Set BACKEND_MANAGER_WEBHOOK_KEY in your .env file or pass --webhook-key flag'));
+      return null;
+    }
+
     if (!config.brand?.id) {
       this.logError('Error: Missing brand.id in backend-manager-config.json');
       return null;
@@ -152,6 +160,7 @@ class TestCommand extends BaseCommand {
     return {
       ...config,
       backendManagerKey,
+      backendManagerWebhookKey,
       domain,
     };
   }
@@ -280,23 +289,85 @@ class TestCommand extends BaseCommand {
   }
 
   /**
-   * Run tests with Firebase emulator (starts emulator, runs tests, shuts down)
+   * Run tests with Firebase emulator (starts emulator, runs tests, shuts down).
+   *
+   * Two real child processes are used so emulator output and test-runner output
+   * land in separate log files:
+   *   - `emulator.log` — `firebase emulators:start` stdout/stderr (managed by EmulatorCommand)
+   *   - `test.log`     — the test-runner subprocess stdout/stderr (managed here)
    */
-  async runEmulatorTests(testCommand) {
+  async runEmulatorTests(testCommand, functionsDir) {
     this.log(chalk.gray('  Starting Firebase emulator...\n'));
 
-    // Use EmulatorCommand to run tests with emulator
     const emulatorCmd = new EmulatorCommand(this.main);
+    let started;
 
     try {
-      await emulatorCmd.runWithEmulator(testCommand);
+      started = await emulatorCmd.startEmulators();
     } catch (error) {
-      // Only exit with error if it wasn't a user-initiated exit
-      if (error.code !== 0) {
-        this.logError(`Emulator error: ${error.message || error}`);
-      }
+      this.logError(`Emulator error: ${error.message || error}`);
       process.exit(1);
     }
+
+    const { shutdown, exitPromise, emulatorPorts } = started;
+
+    // Forward Ctrl+C to a clean emulator shutdown
+    const onSigint = async () => {
+      this.log(chalk.gray('\n  Shutting down emulator...'));
+      await shutdown();
+      process.exit(130);
+    };
+    process.once('SIGINT', onSigint);
+
+    // Print the same connection summary the existing-emulator path shows
+    this.log('');
+    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}`));
+    this.log(chalk.gray(`  UI: http://127.0.0.1:${emulatorPorts.ui}`));
+
+    // Spawn the test runner as its own child so its stdout/stderr can be teed to test.log
+    const logPath = this.getLogsPath('test.log');
+    const logStream = fs.createWriteStream(logPath, { flags: 'w' });
+    const stripAnsi = (str) => str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+
+    this.log(chalk.gray(`  Logs saving to: ${logPath}\n`));
+
+    let testExitCode = 0;
+
+    try {
+      const testChild = spawn('sh', ['-c', testCommand], {
+        cwd: functionsDir,
+        env: { ...process.env, FORCE_COLOR: '1' },
+        stdio: ['inherit', 'pipe', 'pipe'],
+      });
+
+      testChild.stdout.on('data', (data) => {
+        process.stdout.write(data);
+        if (!logStream.destroyed) logStream.write(stripAnsi(data.toString()));
+      });
+
+      testChild.stderr.on('data', (data) => {
+        process.stderr.write(data);
+        if (!logStream.destroyed) logStream.write(stripAnsi(data.toString()));
+      });
+
+      testExitCode = await new Promise((resolve) => {
+        testChild.on('close', (code) => {
+          if (!logStream.destroyed) logStream.end();
+          resolve(code ?? 1);
+        });
+      });
+    } catch (error) {
+      this.logError(`Test runner error: ${error.message || error}`);
+      testExitCode = 1;
+    } finally {
+      process.removeListener('SIGINT', onSigint);
+      await shutdown();
+      await exitPromise;
+    }
+
+    process.exit(testExitCode);
   }
 }
 

package/src/manager/events/cron/daily/ghostii-auto-publisher.js

@@ -103,7 +103,7 @@ function buildBrandConfig(config) {
  */
 function fetchRemoteBrand(brandUrl) {
   return fetch(`${brandUrl}/backend-manager/brand`, {
-    timeout: 30000,
+    timeout: 120000,
     tries: 3,
     response: 'json',
   });
@@ -174,7 +174,7 @@ async function harvest(assistant, settings) {
 
 function getURLContent(url) {
   return fetch(url, {
-    timeout: 30000,
+    timeout: 120000,
     tries: 3,
     response: 'raw',
     headers: {