@xuda.io/account_module 1.2.2296 → 1.2.2298

package/index.mjs

@@ -1925,8 +1925,18 @@ export const ops_reinstate_account = async function (req = {}) {
 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) => ({
+    // Suspended OR terminated. CouchDB Mango uses one index per query, so it
+    // cannot serve an $or across two different fields and would full-scan every
+    // account (logs "documents examined is high"). Query each branch separately
+    // (each hits its own [docType, account_*_status] index) and merge, deduping
+    // accounts flagged as both.
+    const [susp_ret, term_ret] = await Promise.all([
+      db_module.find_couch_query('xuda_accounts', { selector: { docType: 'account', account_suspension_status: 1 }, limit: 9999 }, true),
+      db_module.find_couch_query('xuda_accounts', { selector: { docType: 'account', account_termination_status: 1 }, limit: 9999 }, true),
+    ]);
+    const by_id = new Map();
+    for (const a of [...(susp_ret?.docs || []), ...(term_ret?.docs || [])]) by_id.set(a._id, a);
+    const rows = [...by_id.values()].map((a) => ({
       account_uid: a._id,
       email: a.account_info?.email,
       name: `${a.account_info?.first_name || ''} ${a.account_info?.last_name || ''}`.trim(),
@@ -1999,10 +2009,10 @@ export const ops_account_snapshot = async function (req = {}) {
     const a = ar.data;
     let credits = { max: 0, used: 0, remaining: 0 };
     try {
-      const cr = await get_account_ai_usage({ uid: account_uid });
+      const cr = await get_account_ai_usage({ uid: account_uid, ..._LIFETIME_WINDOW });
       if (cr && cr.code === 55) {
         const max = Math.round((cr.data?.credits?.total || 0) * 100) / 100;
-        const used = Math.round((cr.data?.usage?.total || 0) * 100) / 100;
+        const used = Math.round(_usage_total(cr.data?.usage) * 100) / 100;
         credits = { max, used, remaining: Math.round((max - used) * 100) / 100, by_source: cr.data?.credits || {} };
       }
     } catch (e) { console.error('[ops snapshot credits]', e.message); }
@@ -6471,11 +6481,13 @@ export const save_cache_hit = async function (_id) {
 ///////////////////////////////
 
 export const get_account_ai_usage = async function (req, job_id, headers) {
-  const d = new Date();
-  const curr_month = Number(String(d.getMonth() + 1).padStart(2, '0')); // months are 0-based
-  const curr_year = d.getFullYear();
-
-  const { uid, year_from = curr_year, month_from = curr_month, day_from = 0, year_to = curr_year, month_to = curr_month, day_to = 99 } = req;
+  // Default to the LIFETIME window (all-time spend) — the credit model is a
+  // remaining-pool ledger (see _LIFETIME_WINDOW + the Credit Management page).
+  // Callers that want a specific range (the usage chart in WorkspaceUsage.vue)
+  // pass explicit year/month/day. The nav meter + ring call with no window, so
+  // this makes them read lifetime "used" and match the Credit Management page
+  // instead of a current-month slice against a lifetime pool.
+  const { uid, year_from = 2000, month_from = 1, day_from = 1, year_to = 2999, month_to = 12, day_to = 31 } = req;
   try {
     const app_id = await get_account_default_project_id(uid);
 
@@ -6499,8 +6511,13 @@ export const get_account_ai_usage = async function (req, job_id, headers) {
 
     // console.log('ai_usage', ai_usage.rows);
 
-    let total_usage = response.total_usage;
     let profile = response.profiles;
+    // The ai_usage2 list function emits per-profile spend but sometimes a null
+    // rolled-up total. Roll it up HERE at the source so every consumer gets a real
+    // usage.total — including the dashboard nav (shared-store fetchCredits reads
+    // data.usage.total directly). Without this, Number(null) -> 0 hid all spend in
+    // the meter/ring and disabled the account-wide credit cap.
+    let total_usage = _usage_total({ total: response.total_usage, profile });
 
     const ai_credits = await db_module.get_couch_view('xuda_billing', 'ai_credits', {
       startkey: [uid, ''],
@@ -6610,6 +6627,23 @@ const _fold_usage = function (profile_map) {
   return { by_profile, by_user };
 };
 
+// Single source of truth for an account's rolled-up AI-credit usage. The usage
+// view reliably emits per-profile spend but sometimes returns a null rolled-up
+// total (usage.total); Number(null)||0 then collapsed "used" to 0 EVERYWHERE —
+// hiding spend in the nav/meter AND making the account-wide credit cap never
+// fire. Prefer the view's own total when finite, otherwise sum the per-profile
+// fold (same source, same credit unit).
+const _usage_total = function (usage_data) {
+  // NOTE: Number(null) === 0 (and IS finite), which is exactly what collapsed
+  // "used" to 0 — so guard on the RAW type, not the coerced number. Only trust
+  // the view's own total when it is a real finite number; otherwise roll up the
+  // per-profile fold.
+  const t = usage_data?.total;
+  if (typeof t === 'number' && Number.isFinite(t)) return t;
+  const { by_profile } = _fold_usage(usage_data?.profile);
+  return Object.values(by_profile).reduce((a, b) => a + (Number(b) || 0), 0);
+};
+
 // Wide window so "used" reads as all-time spend (the lifetime / remaining-pool model).
 const _LIFETIME_WINDOW = { year_from: 2000, month_from: 1, day_from: 1, year_to: 2999, month_to: 12, day_to: 31 };
 
@@ -6625,8 +6659,8 @@ const _get_scoped_usage = async function (owner_uid, need_raw) {
   if (cached && now - cached.ts < _SCOPED_USAGE_TTL && (!need_raw || cached.has_raw)) return cached.data;
 
   const usage_ret = await get_account_ai_usage({ uid: owner_uid, ..._LIFETIME_WINDOW });
-  const total = Number(usage_ret?.data?.usage?.total) || 0;
   const { by_profile, by_user } = _fold_usage(usage_ret?.data?.usage?.profile);
+  const total = _usage_total(usage_ret?.data?.usage);
 
   let by_model = {};
   let by_source = {};
@@ -6757,8 +6791,8 @@ export const evaluate_credit_gate = async function (req) {
 
     // Back-compat: no rules or disabled => legacy single ledger cap, byte-for-byte.
     if (!rules || rules.enabled === false) {
-      const usage = await get_account_ai_usage({ uid: owner });
-      const over = (Number(usage?.data?.credits?.total) || 0) - (Number(usage?.data?.usage?.total) || 0) < -0.5;
+      const usage = await get_account_ai_usage({ uid: owner, ..._LIFETIME_WINDOW });
+      const over = (Number(usage?.data?.credits?.total) || 0) - _usage_total(usage?.data?.usage) < -0.5;
       return { block: over, scope: over ? 'pool' : null, reason: over ? _SCOPE_REASON.ledger : '', hard_breached: over ? [{ scope: 'pool', key: 'ledger' }] : [], soft_breached: [], account_id: owner };
     }
 
@@ -7105,10 +7139,13 @@ export const broadcast_credits = function (uid) {
   _credits_broadcast_timers[uid] = setTimeout(async () => {
     delete _credits_broadcast_timers[uid];
     try {
-      const ret = await get_account_ai_usage({ uid });
+      // Lifetime window (matches the Credit Management meter) + the same null-total
+      // rollup as _get_scoped_usage — get_account_ai_usage can return a null
+      // rolled-up usage.total, which otherwise broadcasts used:0 to the live nav.
+      const ret = await get_account_ai_usage({ uid, ..._LIFETIME_WINDOW });
       if (!ret || ret.code !== 55) return;
       const max = Math.round((ret.data?.credits?.total || 0) * 100) / 100;
-      const used = Math.round((ret.data?.usage?.total || 0) * 100) / 100;
+      const used = Math.round(_usage_total(ret.data?.usage) * 100) / 100;
       ws_dashboard_msa.emit_message_to_dashboard({
         service: 'credits_update',
         to: [uid],
@@ -7547,6 +7584,26 @@ const _nl_one = async (db, docType) => {
   }
 })();
 
+// The abuse-review queue (the flagged-accounts list, see ~line 1014) selects on
+// `abuse_signals.flagged` with no index, so Couch full-scans xuda_accounts and
+// logs "No matching index found". xuda_accounts lives locally on dev + master;
+// ensure the index at module load, idempotent, on those content-home nodes only.
+(async () => {
+  const host = process.env.XUDA_HOSTNAME;
+  if (host !== 'dev.xuda.ai' && host !== 'master.xuda.ai') return;
+  try {
+    const ret = await db_module.create_couch_index('xuda_accounts', {
+      index: { fields: ['abuse_signals.flagged'] },
+      name: 'idx_abuse_signals_flagged',
+      ddoc: 'idx_abuse_signals_flagged',
+      type: 'json',
+    });
+    if (ret?.error) console.error('[abuse] xuda_accounts abuse_signals.flagged index create failed:', ret.error);
+  } catch (err) {
+    console.error('[abuse] xuda_accounts abuse_signals.flagged index init failed:', err?.message || err);
+  }
+})();
+
 const _nl_fashion_url = (p) => {
   const rel = p.custom_url || (p.slug ? '/' + p.slug : '');
   return `https://xuda.fashion${rel}`;
@@ -7907,7 +7964,12 @@ export const newsletter_generate = async function (req = {}) {
     if (!req.system && !_ops_is_super(req)) return { code: -403, data: 'superuser only' };
     // Master-only (dev exempt for testing): the issue DB must never be created
     // on a regional couch, and the weekly coupon/sample flow belongs to master.
-    if (!_conf.is_debug && process.env.XUDA_HOSTNAME !== 'master.xuda.ai') return { code: -1, data: 'newsletter_generate runs on master only' };
+    // MASTER ONLY, dev included. Dev is is_debug but still sends real [SAMPLE]/
+    // [OPS] mail and keeps its own issue counter, so a "Generate now" on dev
+    // blasts live info@ inboxes and creates dev-only drafts that never appear in
+    // the master Newsletter Manager (dev does not replicate to master). Preview /
+    // Test still work on dev for reviewing render; only issuing is locked here.
+    if (process.env.XUDA_HOSTNAME !== 'master.xuda.ai') return { code: -1, data: 'newsletter_generate runs on master only' };
     await _nl_ensure_storage();
 
     // Two DISTINCT tips: one for "Did you know?", one for "Tip of the week".
@@ -8068,7 +8130,9 @@ export const newsletter_publish = async function (req = {}) {
     if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
     // Same master-only gate as generate: the blast must run where xuda_newsletter
     // and the authoritative xuda_accounts live (dev exempt for testing).
-    if (!_conf.is_debug && process.env.XUDA_HOSTNAME !== 'master.xuda.ai') return { code: -1, data: 'newsletter_publish runs on master only' };
+    // MASTER ONLY, dev included: a publish on dev would blast dev's opted-in
+    // accounts with real mail. Locked so only the real master issues a newsletter.
+    if (process.env.XUDA_HOSTNAME !== 'master.xuda.ai') return { code: -1, data: 'newsletter_publish runs on master only' };
     const id = req.id || `nl_issue_${req.issue_number}`;
     const gret = await db_module.get_couch_doc(NEWSLETTER_DB, id);
     if (gret.code < 0 || !gret.data) return { code: -1, data: 'issue not found' };