backend-manager 5.2.5 → 5.2.7

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: {

package/src/manager/events/firestore/payments-webhooks/analytics.js

@@ -225,7 +225,7 @@ function fireMeta({ resolved, currency, uid, processor, assistant, config }) {
       method: 'post',
       response: 'json',
       body: payload,
-      timeout: 30000,
+      timeout: 60000,
       tries: 2,
     })
     .then(() => {
@@ -298,7 +298,7 @@ function fireTikTok({ resolved, currency, uid, processor, assistant, config }) {
         'Access-Token': accessToken,
       },
       body: { data: [payload] },
-      timeout: 30000,
+      timeout: 60000,
       tries: 2,
     })
     .then(() => {

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

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

package/src/manager/helpers/analytics.js

@@ -328,7 +328,7 @@ Analytics.prototype.event = function (payload, params) {
     method: 'post',
     response: 'text',
     tries: 2,
-    timeout: 30000,
+    timeout: 60000,
     // headers: {
     //   "Content-Type": "application/json"
     // },

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

@@ -517,7 +517,7 @@ async function fetchSources(parentUrl, categories, brandId, assistant) {
       const data = await fetch(`${parentUrl}/newsletter-sources`, {
         method: 'get',
         response: 'json',
-        timeout: 15000,
+        timeout: 60000,
         query: {
           category,
           limit: 3,
@@ -546,7 +546,7 @@ async function claimSources(parentUrl, sources, brandId, assistant) {
       await fetch(`${parentUrl}/newsletter-sources`, {
         method: 'put',
         response: 'json',
-        timeout: 10000,
+        timeout: 60000,
         body: {
           id: source.id,
           usedBy: brandId || 'unknown',

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

@@ -9,6 +9,11 @@ const { FIELDS, resolveFieldValues } = require('../constants.js');
 
 const BASE_URL = 'https://api.beehiiv.com/v2';
 
+// Beehiiv API spikes past 10s during their hiccups, dropping signups silently.
+// 60s is generous but harmless — caches are in place for metadata calls so a
+// slow first call costs nothing in steady state.
+const BEEHIIV_TIMEOUT_MS = 60000;
+
 // --- Internal helpers ---
 
 function headers() {
@@ -63,7 +68,7 @@ async function addSubscriber({ email, firstName, lastName, source, publicationId
       method: 'post',
       response: 'json',
       headers: headers(),
-      timeout: 15000,
+      timeout: BEEHIIV_TIMEOUT_MS,
       body,
     });
 
@@ -97,7 +102,7 @@ async function findSubscriber(email, publicationId) {
       {
         response: 'json',
         headers: headers(),
-        timeout: 60000,
+        timeout: BEEHIIV_TIMEOUT_MS,
       }
     );
 
@@ -135,7 +140,7 @@ async function removeSubscriber(email, publicationId) {
       {
         method: 'delete',
         headers: headers(),
-        timeout: 60000,
+        timeout: BEEHIIV_TIMEOUT_MS,
       }
     );
 
@@ -202,7 +207,7 @@ function getPublicationId() {
 //       const data = await fetch(`${BASE_URL}/publications?limit=${limit}&page=${page}`, {
 //         response: 'json',
 //         headers: headers(),
-//         timeout: 60000,
+//         timeout: BEEHIIV_TIMEOUT_MS,
 //       });
 //
 //       if (!data.data || data.data.length === 0) {
@@ -351,7 +356,7 @@ async function resolveSegmentIds() {
     const data = await fetch(`${BASE_URL}/publications/${publicationId}/segments?limit=100`, {
       response: 'json',
       headers: headers(),
-      timeout: 60000,
+      timeout: BEEHIIV_TIMEOUT_MS,
     });
 
     _segmentIdCache = {};
@@ -447,7 +452,7 @@ async function createPost(options) {
       method: 'post',
       response: 'json',
       headers: headers(),
-      timeout: 15000,
+      timeout: BEEHIIV_TIMEOUT_MS,
       body,
     });
 

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

@@ -115,7 +115,7 @@ async function upsertContacts({ contacts, listIds }) {
       method: 'put',
       response: 'json',
       headers: headers(),
-      timeout: 15000,
+      timeout: SENDGRID_TIMEOUT_MS,
       body,
     });
 
@@ -357,7 +357,7 @@ async function createSingleSend({ name, subject, preheader, templateId, from, se
       method: 'post',
       response: 'json',
       headers: headers(),
-      timeout: 15000,
+      timeout: SENDGRID_TIMEOUT_MS,
       body,
     });
 
@@ -385,7 +385,7 @@ async function scheduleSingleSend(singleSendId, sendAt) {
       method: 'put',
       response: 'json',
       headers: headers(),
-      timeout: 15000,
+      timeout: SENDGRID_TIMEOUT_MS,
       body: { send_at: sendAt },
     });
 
@@ -545,7 +545,7 @@ async function getSegmentContacts(segmentId, maxWaitMs = 60000) {
       method: 'post',
       response: 'json',
       headers: headers(),
-      timeout: 15000,
+      timeout: SENDGRID_TIMEOUT_MS,
       body: { segment_ids: [segmentId] },
     });
 
@@ -575,7 +575,7 @@ async function getSegmentContacts(segmentId, maxWaitMs = 60000) {
         // Download CSV — disable cacheBreaker to preserve presigned S3 URL signature
         const csvText = await fetch(statusData.urls[0], {
           response: 'text',
-          timeout: 30000,
+          timeout: 60000,
           cacheBreaker: false,
         });
 
@@ -639,7 +639,7 @@ async function bulkDeleteContacts(contactIds) {
       method: 'delete',
       response: 'json',
       headers: headers(),
-      timeout: 15000,
+      timeout: SENDGRID_TIMEOUT_MS,
     });
 
     if (data.job_id) {

package/src/manager/libraries/email/validation.js

@@ -133,7 +133,7 @@ async function validate(email, options = {}) {
     try {
       const data = await fetch(
         `https://api.zerobounce.net/v2/validate?api_key=${process.env.ZEROBOUNCE_API_KEY}&email=${encodeURIComponent(email)}`,
-        { response: 'json', timeout: 10000 }
+        { response: 'json', timeout: 60000 }
       );
 
       if (data.error) {