@xuda.io/account_module 1.2.2275 → 1.2.2277

package/index.mjs

@@ -54,6 +54,8 @@ const team_ms = await import(`${module_path}/team_module/index_ms.mjs`);
 const email_ms = await import(`${module_path}/email_module/index_ms.mjs`);
 const marketplace_ms = await import(`${module_path}/marketplace_module/index_ms.mjs`);
 const stripe_ms = await import(`${module_path}/stripe_module/index_ms.mjs`);
+// Awaitable app handle for the ops termination flow (power off / destroy).
+const app_ms = await import(`${module_path}/app_module/index_ms.mjs`);
 
 const ws_dashboard_msa = await import(`${module_path}/ws_dashboard_module/index_msa.mjs`);
 const drive_msa = await import(`${module_path}/drive_module/index_msa.mjs`);
@@ -1118,6 +1120,192 @@ export const get_account_info = async function (req) {
   });
 };
 
+// ===================================================================
+// OPS ACCOUNT TERMINATION FLOW (manual, superuser-only)
+// -------------------------------------------------------------------
+// Escalation ladder for non-payment, driven manually from the ops
+// dashboard (never automatic): suspend (services OFF) -> terminate
+// (services OFF + 14-day appeal window) -> finalize (permanent delete)
+// -> or reinstate. Every step notifies ops. `req.uid` is ALWAYS the
+// authenticated ops caller (the HTTP layer overwrites it from the
+// session), so the TARGET account is passed as `account_uid`.
+// ===================================================================
+const _OPS_SERVER_TYPES = ['datacenter', 'deployment', 'vps', 'managed_vps', 'instance', 'master'];
+const _ops_is_super = (req) => !!(req && req.uid && Array.isArray(_conf.superuser_account_ids) && _conf.superuser_account_ids.includes(req.uid));
+const _ops_host = () => (_conf.is_debug ? process.env.XUDA_HOSTNAME || _conf.domain : _conf.domain) || 'xuda.ai';
+const _ops_appeal_days = () => Number(_conf.termination?.appeal_days) || 14;
+
+const _ops_enum_apps = async (uid) => {
+  const ret = await db_module.find_couch_query('xuda_master', { selector: { app_uId: uid, docType: 'app' }, limit: 99999 }, true);
+  return ret.docs || [];
+};
+
+// Turn every server-type service for an account OFF (or back ON). Read the
+// power state via the canonical app_ms wrappers so DO/proxmox teardown is
+// handled correctly. Returns a small tally.
+const _ops_services_power = async (uid, on) => {
+  const servers = (await _ops_enum_apps(uid)).filter((a) => _OPS_SERVER_TYPES.includes(a.app_type));
+  let ok = 0, err = 0;
+  for (const a of servers) {
+    try {
+      const r = on ? await app_ms.turn_app_on({ app_id: a._id }) : await app_ms.turn_app_off({ app_id: a._id });
+      if (!r || r.code < 0) err++; else ok++;
+    } catch (e) { err++; console.error('[ops power]', a._id, e.message); }
+  }
+  return { total: servers.length, ok, err };
+};
+
+// OPS = the superuser accounts + info@xuda.ai. Sends both an email to info@ and
+// a system notification to every superuser. `ref` is shown in a small footer.
+const _ops_notify_ops = (subject, rows, ref) => {
+  try {
+    const esc = (v) => String(v == null ? '' : v).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const footer = ref ? `<p style="margin:16px 0 0 0;font-size:11px;color:#999">Ref: ${esc(ref)}</p>` : '';
+    const body = `<h2>${esc(subject)}</h2><table cellpadding="6" style="border-collapse:collapse;font-size:14px">${rows.map(([k, v]) => `<tr><td><strong>${esc(k)}</strong></td><td>${esc(v)}</td></tr>`).join('')}</table>${footer}`;
+    email_msa.send_email({ email: 'info@xuda.ai', subject: `[OPS] ${subject}`, body });
+    const supers = _conf.superuser_account_ids || [];
+    if (supers.length) notification_msa.submit_notification({ type: 'system', uid_arr: supers, system: true, subject: `[OPS] ${subject}`, body, delivery_method: ['banner', 'email'], display_type: 'warning' });
+  } catch (e) { console.error('[ops notify]', e.message); }
+};
+
+// Step 1a — SUSPEND: services off, no data loss.
+export const ops_suspend_account = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const account_uid = req.account_uid;
+    if (!account_uid) return { code: -1, data: 'account_uid is required' };
+    const ar = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    if (ar.code < 0 || !ar.data) return { code: -1, data: 'account not found' };
+    const account = ar.data;
+    account.account_suspension_status = 1;
+    account.account_suspension_date = Date.now();
+    account.suspension_reason = req.reason || '';
+    account.suspension_by_uid = req.uid;
+    const sr = await db_module.save_couch_doc('xuda_accounts', account);
+    if (sr.code < 0) return { code: -1, data: sr.data };
+    const power = await _ops_services_power(account_uid, false);
+    const host = _ops_host();
+    notification_msa.submit_notification({ type: 'account', uid_arr: [account_uid], topic: 'health_account_suspended', params: { billing_url: `https://${host}/dashboard/settings/billing` } });
+    _ops_notify_ops(`Account suspended: ${account.account_info?.email || account_uid}`, [['Account', account_uid], ['Email', account.account_info?.email], ['By', req.uid], ['Reason', req.reason || ''], ['Services off', `${power.ok}/${power.total}`]], 'A2');
+    logs_msa.add_account_log({ uid: account_uid, method: 'ops_suspend_account', source: 'ops dashboard', response_status_code: 200, response_data: `suspended by ${req.uid}; services off ${power.ok}/${power.total}` });
+    return { code: 1, data: { suspended: account_uid, services: power } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Step 1b — TERMINATE: services off + start the appeal window. No deletion.
+export const ops_terminate_account = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const account_uid = req.account_uid;
+    if (!account_uid) return { code: -1, data: 'account_uid is required' };
+    const ar = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    if (ar.code < 0 || !ar.data) return { code: -1, data: 'account not found' };
+    const account = ar.data;
+    const appeal_days = _ops_appeal_days();
+    account.account_termination_status = 1;
+    account.account_termination_date = Date.now();
+    account.termination_reason = req.reason || '';
+    account.termination_by_uid = req.uid;
+    account.termination_appeal_deadline = Date.now() + appeal_days * 86400000;
+    account.appeal_status = 'none';
+    account.termination_finalized_ts = null;
+    const sr = await db_module.save_couch_doc('xuda_accounts', account);
+    if (sr.code < 0) return { code: -1, data: sr.data };
+    const power = await _ops_services_power(account_uid, false);
+    const host = _ops_host();
+    notification_msa.submit_notification({ type: 'account', uid_arr: [account_uid], topic: 'health_account_terminated', params: { appeal_days, appeal_url: `https://${host}/dashboard/support` } });
+    _ops_notify_ops(`Account terminated (${appeal_days}d appeal): ${account.account_info?.email || account_uid}`, [['Account', account_uid], ['Email', account.account_info?.email], ['By', req.uid], ['Reason', req.reason || ''], ['Services off', `${power.ok}/${power.total}`], ['Appeal deadline', new Date(account.termination_appeal_deadline).toISOString()]], 'A3');
+    logs_msa.add_account_log({ uid: account_uid, method: 'ops_terminate_account', source: 'ops dashboard', response_status_code: 200, response_data: `terminated by ${req.uid}; appeal until ${new Date(account.termination_appeal_deadline).toISOString()}; services off ${power.ok}/${power.total}` });
+    return { code: 1, data: { terminated: account_uid, appeal_deadline: account.termination_appeal_deadline, services: power } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Step 3 — FINALIZE: NEVER destroys anything. It compiles the list of resources
+// that should be deleted for a terminated account and REPORTS it to ops, who
+// then delete manually. Superuser + terminated required.
+export const ops_finalize_termination = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const account_uid = req.account_uid;
+    if (!account_uid) return { code: -1, data: 'account_uid is required' };
+    const ar = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    if (ar.code < 0 || !ar.data) return { code: -1, data: 'account not found' };
+    const account = ar.data;
+    if (account.account_termination_status !== 1) return { code: -1, data: 'account is not in a terminated state' };
+
+    const apps = await _ops_enum_apps(account_uid);
+    const resources = apps.map((a) => ({
+      app_id: a._id,
+      app_type: a.app_type,
+      app_name: a.app_name || a._id,
+      ip: a.app_hosting_server?.ip || '',
+      region: a.app_hosting_server?.region_name || a.app_hosting_server?.provider || '',
+    }));
+    const appeal_window_elapsed = !!(account.termination_appeal_deadline && Date.now() >= account.termination_appeal_deadline);
+    account.termination_reported_ts = Date.now();
+    account.termination_reported_by_uid = req.uid;
+    await db_module.save_couch_doc('xuda_accounts', account);
+
+    const rows = [
+      ['Account', account_uid], ['Email', account.account_info?.email], ['Requested by', req.uid],
+      ['Appeal window elapsed', appeal_window_elapsed ? 'yes' : 'NO — still within appeal period'],
+      ['Resources to delete', resources.length],
+      ...resources.map((r, i) => [`#${i + 1} ${r.app_type}`, `${r.app_name} ${r.ip}`.trim()]),
+    ];
+    _ops_notify_ops(`Resources to delete (manual) for terminated account: ${account.account_info?.email || account_uid}`, rows, 'OPS-DELETE-LIST');
+    logs_msa.add_account_log({ uid: account_uid, method: 'ops_finalize_termination', security: true, source: 'ops dashboard', response_status_code: 200, response_data: `reported ${resources.length} resource(s) for manual deletion by ${req.uid}; appeal_elapsed=${appeal_window_elapsed}` });
+    return { code: 1, data: { account_uid, appeal_window_elapsed, resources } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Reinstate (appeal accepted): clear suspension/termination, services back on.
+export const ops_reinstate_account = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const account_uid = req.account_uid;
+    if (!account_uid) return { code: -1, data: 'account_uid is required' };
+    const ar = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    if (ar.code < 0 || !ar.data) return { code: -1, data: 'account not found' };
+    const account = ar.data;
+    if (account.termination_finalized_ts) return { code: -1, data: 'resources already deleted; cannot reinstate' };
+    account.account_suspension_status = 0;
+    account.account_termination_status = 0;
+    account.appeal_status = 'accepted';
+    account.reinstated_ts = Date.now();
+    account.reinstated_by_uid = req.uid;
+    const sr = await db_module.save_couch_doc('xuda_accounts', account);
+    if (sr.code < 0) return { code: -1, data: sr.data };
+    const power = await _ops_services_power(account_uid, true);
+    notification_msa.submit_notification({ type: 'account', uid_arr: [account_uid], subject: 'Your account has been reinstated', body: '<h2>Your account has been reinstated</h2><p>Your account is active again and your services are being restored. Thank you.</p><p style="margin:16px 0 0 0;font-size:11px;color:#999">Ref: OPS-REINST</p>', delivery_method: ['banner', 'email'], display_type: 'info' });
+    _ops_notify_ops(`Account reinstated: ${account.account_info?.email || account_uid}`, [['Account', account_uid], ['Email', account.account_info?.email], ['By', req.uid], ['Services on', `${power.ok}/${power.total}`]], 'OPS-REINST');
+    logs_msa.add_account_log({ uid: account_uid, method: 'ops_reinstate_account', source: 'ops dashboard', response_status_code: 200, response_data: `reinstated by ${req.uid}; services on ${power.ok}/${power.total}` });
+    return { code: 1, data: { reinstated: account_uid, services: power } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Ops dashboard queue: accounts currently suspended or terminated.
+export const ops_list_terminations = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const ret = await db_module.find_couch_query('xuda_accounts', { selector: { docType: 'account', $or: [{ account_suspension_status: 1 }, { account_termination_status: 1 }] }, limit: 9999 }, true);
+    const rows = (ret.docs || []).map((a) => ({
+      account_uid: a._id,
+      email: a.account_info?.email,
+      name: `${a.account_info?.first_name || ''} ${a.account_info?.last_name || ''}`.trim(),
+      suspended: a.account_suspension_status === 1,
+      suspension_date: a.account_suspension_date,
+      terminated: a.account_termination_status === 1,
+      termination_date: a.account_termination_date,
+      reason: a.termination_reason || a.suspension_reason || '',
+      by_uid: a.termination_by_uid || a.suspension_by_uid || '',
+      appeal_deadline: a.termination_appeal_deadline || null,
+      appeal_status: a.appeal_status || 'none',
+      finalized: !!a.termination_finalized_ts,
+    }));
+    return { code: 1, data: { rows } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
 const TIPS_FILE_PATH = path.join(process.env.XUDA_HOME, 'dist', 'tips', 'tips.json');
 let _did_you_know_tips_cache = null;
 let _did_you_know_tips_cache_mtime = 0;
@@ -2583,6 +2771,36 @@ export const onboarding_completed = async function (req, job_id, headers) {
   }
 };
 
+// One-time admin heads-up to info@xuda.ai on every new signup. Fired from
+// maybe_send_welcome_email (the universal once-per-account choke point) so it
+// covers every signup surface. Prod only (gated by the caller) and idempotent
+// (admin_signup_notified_ts). Fire-and-forget: never blocks or fails the caller.
+const notify_admin_new_signup = function (account_doc) {
+  try {
+    const info = account_doc.account_info || {};
+    const name = [info.first_name, info.last_name].filter(Boolean).join(' ') || info.username || 'Unknown';
+    const email = info.email || 'unknown';
+    const body = `
+      <h2 style="margin:0 0 14px">New signup on Xuda</h2>
+      <table cellpadding="6" style="border-collapse:collapse;font-size:14px">
+        <tr><td><strong>Name</strong></td><td>${_.escape(name)}</td></tr>
+        <tr><td><strong>Email</strong></td><td>${_.escape(email)}</td></tr>
+        <tr><td><strong>Username</strong></td><td>${_.escape(info.username || '')}</td></tr>
+        <tr><td><strong>Account ID</strong></td><td>${_.escape(account_doc._id || '')}</td></tr>
+        <tr><td><strong>Signed up (UTC)</strong></td><td>${new Date().toISOString()}</td></tr>
+      </table>`;
+    email_msa.send_email({
+      email: 'info@xuda.ai',
+      subject: `New signup: ${name} (${email})`,
+      body,
+      ref: account_doc._id,
+      app_id: null,
+    });
+  } catch (err) {
+    console.error('[notify_admin_new_signup]', err.message);
+  }
+};
+
 // Sends the welcome_aboard email exactly once per account. Safe to call from
 // multiple triggers (avatar-completion, onboarding_completed) and across every
 // signup surface (xuda.ai, Google OAuth, xuda.fashion, xuda.network, chat
@@ -2591,11 +2809,26 @@ export const maybe_send_welcome_email = async function (uid) {
   try {
     const account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
     if (!account_doc || !account_doc.account_info) return { code: -1, data: 'no account' };
+
+    // Admin new-signup notification (prod only), independent of the user-facing
+    // welcome email so it also covers suppressed ambassadors/mentors. Idempotent
+    // via admin_signup_notified_ts; the flag persists on whichever save below runs.
+    let admin_flag_needs_save = false;
+    if (!_conf.is_debug && !account_doc.admin_signup_notified_ts) {
+      notify_admin_new_signup(account_doc);
+      account_doc.admin_signup_notified_ts = Date.now();
+      admin_flag_needs_save = true;
+    }
+
     if (account_doc.account_info.is_xuda_network_ambassador === true) {
       console.log('[maybe_send_welcome_email] suppressing for xuda.network ambassador/mentor', uid);
+      if (admin_flag_needs_save) await db_module.save_couch_doc('xuda_accounts', account_doc);
       return { code: 0, data: 'ambassador' };
     }
-    if (account_doc.welcome_email_sent_ts) return { code: 0, data: 'already sent' };
+    if (account_doc.welcome_email_sent_ts) {
+      if (admin_flag_needs_save) await db_module.save_couch_doc('xuda_accounts', account_doc);
+      return { code: 0, data: 'already sent' };
+    }
 
     const host = _conf.is_debug ? process.env.XUDA_HOSTNAME || _conf.domain : _conf.domain;
     const username = account_doc.account_info.username || uid;
@@ -2620,6 +2853,179 @@ export const maybe_send_welcome_email = async function (uid) {
   }
 };
 
+// ---- Email bounce lifecycle helpers -----------------------------------------
+const _bounce_settings_url = () => {
+  const host = _conf.is_debug ? process.env.XUDA_HOSTNAME || _conf.domain : _conf.domain;
+  return `https://${host}/dashboard/settings`;
+};
+
+// Alert the user to update their email (banner + SMS per the topic's delivery
+// methods). SMS is gated/log-only in notification_module until sms_enabled.
+const _send_bounce_alert = async (account, attempt, max) => {
+  const eb = account.account_email_bounce || {};
+  return await notification_msa.submit_notification({
+    type: 'account',
+    app_id: null,
+    uid_arr: [account._id],
+    topic: 'email_bounce_update_required',
+    params: {
+      recipient_email: eb.recipient || account.account_info?.email || '',
+      settings_url: _bounce_settings_url(),
+      attempt,
+      max,
+    },
+  });
+};
+
+// Hard-email-bounce flag. Called (via account_ms RPC) by email_module's
+// scan_platform_bounces when a platform email to this account's address bounces
+// permanently (5.x.x). Records the flag and, on the FIRST transition into
+// flagged, fires alert #1 immediately (attempts 2..max + suspend are driven by
+// the daily sweep_email_bounces cron). Idempotent: repeated bounces for an
+// already-flagged/suspended account only refresh last_bounce_ts (no re-alert).
+export const flag_email_bounce = async function (req) {
+  const { uid, recipient, reason, status_code, message_id, source } = req || {};
+  if (!uid) return { code: -1, data: 'uid required' };
+  try {
+    const acct_ret = await db_module.get_couch_doc('xuda_accounts', uid);
+    if (acct_ret.code < 0) return { code: -1, data: 'account not found' };
+    const account = acct_ret.data;
+    const now = Date.now();
+    const eb = account.account_email_bounce || {};
+    const was_active = eb.status === 'flagged' || eb.status === 'suspended';
+    const max = Number(_conf.bounce_monitor?.suspend_after_alerts || 3);
+
+    eb.recipient = recipient || eb.recipient;
+    eb.reason = reason || eb.reason;
+    eb.status_code = status_code || eb.status_code;
+    eb.last_message_id = message_id || eb.last_message_id;
+    eb.source = source || eb.source || 'dsn';
+    eb.last_bounce_ts = now;
+    eb.bounce_count = (eb.bounce_count || 0) + 1;
+    if (eb.status !== 'suspended') {
+      eb.status = 'flagged';
+      eb.first_bounce_ts = eb.first_bounce_ts || now;
+      if (!was_active) {
+        // Fresh flag -> immediate first alert.
+        eb.attempt_count = 1;
+        eb.first_alert_ts = now;
+        eb.last_attempt_ts = now;
+      } else if (eb.attempt_count == null) {
+        eb.attempt_count = 0;
+      }
+    }
+
+    account.account_email_bounce = eb;
+    const save_ret = await db_module.save_couch_doc('xuda_accounts', account);
+    if (save_ret.code < 0) return save_ret;
+
+    if (!was_active) {
+      try { await _send_bounce_alert(account, 1, max); } catch (e) { console.error('flag_email_bounce alert #1 failed:', e.message); }
+    }
+    console.log(`flag_email_bounce: ${uid} <${recipient}> ${status_code || ''} -> status=${eb.status} attempt=${eb.attempt_count} bounce_count=${eb.bounce_count}${!was_active ? ' (alert #1 sent)' : ''}`);
+    return { code: 1, data: { uid, status: eb.status, attempt_count: eb.attempt_count, bounce_count: eb.bounce_count } };
+  } catch (err) {
+    console.error('flag_email_bounce error:', err);
+    return { code: -10, data: err.message };
+  }
+};
+
+// Daily retry/escalation sweep for flagged accounts (controller cron). For each
+// account with account_email_bounce.status === 'flagged':
+//   - if the user changed their email away from the bounced address -> CLEAR;
+//   - else if under the alert cap and >= alert_interval since last -> next alert;
+//   - else (cap reached) -> SUSPEND (account_email_bounce_suspended) + ops alert.
+// `req` overrides: { interval_ms, max, limit, uids }.
+export const sweep_email_bounces = async function (req = {}) {
+  const bm = _conf.bounce_monitor || {};
+  const DAY_MS = 24 * 60 * 60 * 1000;
+  const interval = Number(req.interval_ms ?? bm.alert_interval_ms ?? DAY_MS);
+  const max = Number(req.max ?? bm.suspend_after_alerts ?? 3);
+  const now = Date.now();
+  const summary = { flagged: 0, cleared: 0, alerted: 0, suspended: 0, skipped: 0 };
+  try {
+    const selector = { 'account_email_bounce.status': 'flagged' };
+    if (Array.isArray(req.uids) && req.uids.length) selector._id = { $in: req.uids };
+    const find_ret = await db_module.find_couch_query('xuda_accounts', {
+      selector,
+      fields: ['_id'],
+      limit: req.limit ?? 99999,
+    });
+    const rows = find_ret?.data?.docs || find_ret?.docs || [];
+    summary.flagged = rows.length;
+
+    for (const row of rows) {
+      const acct_ret = await db_module.get_couch_doc('xuda_accounts', row._id);
+      if (acct_ret.code < 0) continue;
+      const account = acct_ret.data;
+      const eb = account.account_email_bounce;
+      if (!eb || eb.status !== 'flagged') { summary.skipped++; continue; }
+
+      // CLEAR: the user updated their email away from the bounced address.
+      const cur_email = (account.account_info?.email || '').toLowerCase().trim();
+      if (cur_email && cur_email !== (eb.recipient || '').toLowerCase().trim()) {
+        eb.status = 'cleared';
+        eb.cleared_ts = now;
+        account.account_email_bounce = eb;
+        await db_module.save_couch_doc('xuda_accounts', account);
+        summary.cleared++;
+        continue;
+      }
+
+      // Cadence gate.
+      if (eb.last_attempt_ts && now - eb.last_attempt_ts < interval) { summary.skipped++; continue; }
+
+      if ((eb.attempt_count || 0) < max) {
+        const next = (eb.attempt_count || 0) + 1;
+        eb.attempt_count = next;
+        eb.last_attempt_ts = now;
+        account.account_email_bounce = eb;
+        await db_module.save_couch_doc('xuda_accounts', account);
+        try { await _send_bounce_alert(account, next, max); } catch (e) { console.error('bounce alert failed:', e.message); }
+        summary.alerted++;
+      } else {
+        // SUSPEND after the alert cap. Dedicated flag (enforced at
+        // router_module.validate_app_active_status alongside billing
+        // suspension) so we never clobber account_suspension_status.
+        eb.status = 'suspended';
+        eb.suspended_ts = now;
+        account.account_email_bounce = eb;
+        account.account_email_bounce_suspended = 1;
+        await db_module.save_couch_doc('xuda_accounts', account);
+
+        const host = _conf.is_debug ? process.env.XUDA_HOSTNAME || _conf.domain : _conf.domain;
+        const supers = _conf.superuser_account_ids || [];
+        if (supers.length) {
+          try {
+            await notification_msa.submit_notification({
+              type: 'account',
+              app_id: null,
+              uid_arr: supers,
+              topic: 'email_bounce_suspended',
+              system: true,
+              params: {
+                uid: account._id,
+                account_email: account.account_info?.email || eb.recipient || '',
+                recipient: eb.recipient || '',
+                reason: eb.reason || '',
+                status_code: eb.status_code || '',
+                attempts: eb.attempt_count || max,
+                domain: host,
+              },
+            });
+          } catch (e) { console.error('ops bounce-suspend alert failed:', e.message); }
+        }
+        summary.suspended++;
+      }
+    }
+    console.log('sweep_email_bounces:', JSON.stringify(summary));
+    return { code: 1, data: summary };
+  } catch (err) {
+    console.error('sweep_email_bounces error:', err);
+    return { code: -10, data: err.message };
+  }
+};
+
 // Every-3-days verification nudge for accounts still at stat 1 (unverified).
 // Runs from the controller's daily cron (master/dev only); the daily tick plus
 // the per-account 3-day gate below yields the every-3-days cadence. Each email

package/index_ms.mjs

@@ -89,6 +89,26 @@ export const get_account_info = async function (...args) {
   return await broker.send_to_queue("get_account_info", ...args);
 };
 
+export const ops_suspend_account = async function (...args) {
+  return await broker.send_to_queue("ops_suspend_account", ...args);
+};
+
+export const ops_terminate_account = async function (...args) {
+  return await broker.send_to_queue("ops_terminate_account", ...args);
+};
+
+export const ops_finalize_termination = async function (...args) {
+  return await broker.send_to_queue("ops_finalize_termination", ...args);
+};
+
+export const ops_reinstate_account = async function (...args) {
+  return await broker.send_to_queue("ops_reinstate_account", ...args);
+};
+
+export const ops_list_terminations = async function (...args) {
+  return await broker.send_to_queue("ops_list_terminations", ...args);
+};
+
 export const did_you_know_tips = async function (...args) {
   return await broker.send_to_queue("did_you_know_tips", ...args);
 };
@@ -209,6 +229,14 @@ export const maybe_send_welcome_email = async function (...args) {
   return await broker.send_to_queue("maybe_send_welcome_email", ...args);
 };
 
+export const flag_email_bounce = async function (...args) {
+  return await broker.send_to_queue("flag_email_bounce", ...args);
+};
+
+export const sweep_email_bounces = async function (...args) {
+  return await broker.send_to_queue("sweep_email_bounces", ...args);
+};
+
 export const send_verification_reminders = async function (...args) {
   return await broker.send_to_queue("send_verification_reminders", ...args);
 };

package/index_msa.mjs

@@ -89,6 +89,26 @@ export const get_account_info =  function (...args) {
    broker.send_to_queue_async("get_account_info", ...args);
 };
 
+export const ops_suspend_account =  function (...args) {
+   broker.send_to_queue_async("ops_suspend_account", ...args);
+};
+
+export const ops_terminate_account =  function (...args) {
+   broker.send_to_queue_async("ops_terminate_account", ...args);
+};
+
+export const ops_finalize_termination =  function (...args) {
+   broker.send_to_queue_async("ops_finalize_termination", ...args);
+};
+
+export const ops_reinstate_account =  function (...args) {
+   broker.send_to_queue_async("ops_reinstate_account", ...args);
+};
+
+export const ops_list_terminations =  function (...args) {
+   broker.send_to_queue_async("ops_list_terminations", ...args);
+};
+
 export const did_you_know_tips =  function (...args) {
    broker.send_to_queue_async("did_you_know_tips", ...args);
 };
@@ -209,6 +229,14 @@ export const maybe_send_welcome_email =  function (...args) {
    broker.send_to_queue_async("maybe_send_welcome_email", ...args);
 };
 
+export const flag_email_bounce =  function (...args) {
+   broker.send_to_queue_async("flag_email_bounce", ...args);
+};
+
+export const sweep_email_bounces =  function (...args) {
+   broker.send_to_queue_async("sweep_email_bounces", ...args);
+};
+
 export const send_verification_reminders =  function (...args) {
    broker.send_to_queue_async("send_verification_reminders", ...args);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/account_module",
-  "version": "1.2.2275",
+  "version": "1.2.2277",
   "description": "Xuda Account Server Module",
   "main": "index.mjs",
   "dependencies": {