@xuda.io/account_module 1.2.2298 → 1.2.2300

package/index.mjs

@@ -2,7 +2,8 @@ import path from 'path';
 import fs from 'fs';
 import crypto from 'node:crypto';
 import _ from 'lodash';
-import { execFile } from 'child_process';
+import { execFile, spawn } from 'child_process';
+import os from 'os';
 import { promisify } from 'util';
 import { createRequire } from 'module';
 import { parsePhoneNumber } from 'libphonenumber-js';
@@ -306,7 +307,6 @@ export const update_account_info = async function (req, job_id, headers) {
 
   if (account_obj.account_info?.profile_picture) {
     if (!account_obj.account_info?.profile_avatar && account_obj.account_info.profile_avatar_stat !== 2) {
-      debugger;
       set_account_profile_picture(uid, uid, account_obj.account_info, job_id, headers, account_profile_info);
     }
   }
@@ -2529,17 +2529,61 @@ const _ops_validate_modules = (modules) => {
   return { list, unknown: list.filter((m) => !universe.includes(m)) };
 };
 
-// Spawn utils/hotfix_prod.mjs against explicit WG hosts. execFile rejects on a
-// non-zero exit (hotfix_prod exits 1 if ANY host failed), which we translate to
-// ok:false rather than throwing, keeping stdout for the summary either way.
-const _ops_run_hotfix = async ({ hosts, modules, dry_run, timeout_ms }) => {
-  const args = [_HOTFIX_TOOL(), '--hosts', hosts.map((h) => h.ssh).join(','), ...(modules || []), ...(dry_run ? ['--dry-run'] : [])];
+// Run `node <args>` DETACHED, with its own process group and its own log file (not
+// our stdio pipes). This account proc is the deploy orchestrator, and pm2 WATCHES
+// common/ + cpi/account_module, so a stray file change restarts it. A rollout spawned
+// as a normal child would then be torn down mid-flight, leaving boxes half-patched.
+// detached:true = the child leads its own session and survives a signal aimed at our
+// process group; the log file = a broken parent pipe cannot SIGPIPE it. We still await
+// its exit for the summary; if we get bounced mid-run the child finishes on its own,
+// and a re-run is a safe no-op (hotfix_prod skips already-current modules). Never
+// rejects: failures come back as { ok:false, exit, stderr }. stdout+stderr are merged
+// into the log, so a fatal error stays visible in the tail the UI shows.
+const _ops_run_node_detached = ({ args, timeout_ms, env }) => {
+  const logfile = path.join(os.tmpdir(), `xuda_ops_${Date.now()}_${Math.random().toString(36).slice(2, 8)}.log`);
+  let fd;
   try {
-    const { stdout, stderr } = await _execFileP('node', args, { maxBuffer: 32 * 1024 * 1024, timeout: timeout_ms || 300000, env: { ...process.env } });
-    return { ok: true, exit: 0, stdout: String(stdout || ''), stderr: String(stderr || '') };
+    fd = fs.openSync(logfile, 'a');
   } catch (e) {
-    return { ok: false, exit: e && typeof e.code === 'number' ? e.code : 1, stdout: String((e && e.stdout) || ''), stderr: String((e && (e.stderr || e.message)) || e) };
-  }
+    return Promise.resolve({ ok: false, exit: 1, stdout: '', stderr: 'could not open run log: ' + e.message });
+  }
+  return new Promise((resolve) => {
+    let done = false;
+    let timer = null;
+    const settle = ({ exit, stderr }) => {
+      if (done) return;
+      done = true;
+      if (timer) clearTimeout(timer);
+      try { fs.closeSync(fd); } catch (e) {}
+      let stdout = '';
+      try { stdout = fs.readFileSync(logfile, 'utf8'); } catch (e) {}
+      try { fs.unlinkSync(logfile); } catch (e) {}
+      resolve({ ok: exit === 0, exit, stdout, stderr: stderr || '' });
+    };
+    let child;
+    try {
+      child = spawn('node', args, { detached: true, stdio: ['ignore', fd, fd], env: env || { ...process.env } });
+    } catch (e) {
+      settle({ exit: 1, stderr: 'spawn failed: ' + e.message });
+      return;
+    }
+    timer = setTimeout(() => {
+      try { process.kill(-child.pid, 'SIGKILL'); } catch (e) {}
+      settle({ exit: 124, stderr: `timed out after ${Math.round((timeout_ms || 300000) / 1000)}s` });
+    }, timeout_ms || 300000);
+    child.on('error', (e) => settle({ exit: 1, stderr: e.message }));
+    child.on('exit', (code, signal) => settle({ exit: code == null ? 1 : code, stderr: signal ? 'killed by ' + signal : '' }));
+    child.unref();
+  });
+};
+
+// Spawn utils/hotfix_prod.mjs against explicit WG hosts, DETACHED (see above), so a
+// pm2 file-watch restart of this orchestrator cannot kill an in-flight rollout.
+// hotfix_prod exits 1 if ANY host failed; that becomes ok:false, keeping stdout for
+// the summary either way.
+const _ops_run_hotfix = ({ hosts, modules, dry_run, timeout_ms }) => {
+  const args = [_HOTFIX_TOOL(), '--hosts', hosts.map((h) => h.ssh).join(','), ...(modules || []), ...(dry_run ? ['--dry-run'] : [])];
+  return _ops_run_node_detached({ args, timeout_ms });
 };
 
 // Pull hotfix_prod's human summary block + a tail for the UI.
@@ -3177,7 +3221,6 @@ export const get_hosting_plan = function (req) {
     if (_conf.PRICE_OBJ.server_slugs[app_obj.app_hosting.app_server_type]) {
       return _conf.PRICE_OBJ.server_slugs[app_obj.app_hosting.app_server_type];
     }
-    debugger;
     console.error('error: ' + app_obj.app_hosting.app_server_type + ' not found in PRICE_OBJ.server_slugs');
     return { cpu: 0, price: 0 };
   }
@@ -5898,13 +5941,26 @@ export const get_account_profile_info = async function (uid, contact_profile_doc
   if (account_info_ret.code < 0) {
     return;
   }
-  if (!doc.profile_avatar) {
+  // The main profile IS the account's own face: always mirror the account
+  // avatar/picture on it, so the main-profile card matches the account avatar.
+  // A divergent value stored on the main profile doc (e.g. a stale AI-generated
+  // avatar) must not win. Non-main profiles keep their own, falling back to the
+  // account avatar only when they have none.
+  if (doc.main || !doc.profile_avatar) {
     doc.profile_avatar = account_info_ret.data.profile_avatar;
   }
-  if (!doc.profile_picture) {
+  if (doc.main || !doc.profile_picture) {
     doc.profile_picture = account_info_ret.data.profile_picture;
   }
 
+  // The main profile is the account's OWN identity: it must never auto-respond
+  // (you don't auto-reply to yourself). Force it off in the read model so the
+  // card hides the control and no read-based consumer treats it as on. The
+  // runtime (ai_module.auto_response) also hard-skips the main profile.
+  if (doc.main) {
+    doc.auto_respond = false;
+  }
+
   if (!doc.account_type) {
     doc.account_type = account_info_ret.data.account_type;
   }
@@ -7047,7 +7103,6 @@ export const get_account_ai_usage_old = async function (req, job_id, headers) {
       group_level: 999,
     });
     // console.log('ai_usage', ai_usage.rows);
-    debugger;
     let total_usage = 0;
     let profile = {};
 
@@ -7455,8 +7510,10 @@ setTimeout(async () => {
 // 10% monthly Stripe coupon, saves a NUMBERED draft issue to xuda_newsletter, and
 // emails a sample to ops (info@xuda.ai) + a superuser notification for review.
 // Nothing goes to subscribers until a superuser hits Publish in the dashboard
-// (newsletter_publish), which blasts to every preferences.newsletter_opt_in
-// account with a per-recipient unsubscribe link + List-Unsubscribe header.
+// (newsletter_publish), which blasts to every account that has NOT opted out
+// (preferences.newsletter_opt_in !== false, so a missing flag counts as opted
+// in), minus the xuda.network seed personas, with a per-recipient unsubscribe
+// link + List-Unsubscribe header. See _newsletter_blast for why both rules exist.
 // Opt-out flips the same flag the router /newsletter/unsubscribe route reads.
 // ============================================================================
 const NEWSLETTER_DB = 'xuda_newsletter';
@@ -8089,8 +8146,25 @@ const _newsletter_blast = async (issue, by_uid) => {
   const [pool, ppool] = await Promise.all([_nl_fashion_pool(), _nl_partner_pool()]);
   let sent = 0, failed = 0, total = 0;
   try {
-    const rret = await db_module.find_couch_query('xuda_accounts', { selector: { docType: 'account', stat: 3, 'preferences.newsletter_opt_in': true }, limit: 100000 }, true);
-    const recipients = rret.docs || [];
+    // Opt-in is OPT-OUT by design: the three signup surfaces stamp
+    // preferences.newsletter_opt_in=true, but every account created before the
+    // newsletter shipped has NO such field. Selecting on `=== true` therefore
+    // matched 1 of 456 accounts on master and the audience was silently empty
+    // (issue #4 reported "1 sent"). Treat a MISSING flag as opted in, and only
+    // an explicit false as opted out.
+    //
+    // EXCLUDE the xuda.network personas. They are seed accounts on
+    // @ambassadors.xuda.network / @mentors.xuda.network, domains with no mail
+    // service, so mailing them is 420 guaranteed hard bounces in one blast,
+    // which the bounce handler turns into 420 suspensions plus real damage to
+    // the sending reputation. `source` starts with xuda_network_ on every one of
+    // them and agrees with the address on all 420, so it is the reliable marker.
+    // Filtering here rather than in the Mango selector: it is a few hundred docs,
+    // and $ne against a MISSING field is exactly the semantic that caused this bug.
+    const rret = await db_module.find_couch_query('xuda_accounts', { selector: { docType: 'account', stat: 3 }, limit: 100000 }, true);
+    const recipients = (rret.docs || []).filter(
+      (a) => !String(a.source || '').startsWith('xuda_network_') && a.preferences?.newsletter_opt_in !== false,
+    );
     total = recipients.length;
     for (const acct of recipients) {
       const email = acct.account_info && acct.account_info.email;

package/package.json

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