@xuda.io/account_module 1.2.2258 → 1.2.2259

package/index.mjs

@@ -580,42 +580,9 @@ export const increment_account_usage = async function (req) {
 // app type?".
 const BILLABLE_APP_TYPES = ['vps', 'datacenter', 'instance', 'balancer'];
 
-// Stamp `app_cost.terminated_ts` on an app doc IMMEDIATELY, without
-// waiting for the destroy job to pick up. Called from the dashboard
-// the instant the user confirms a destroy so the billing UI reacts
-// without delay.
-//
-// Why we need this: destroy_app runs with { job: true } — i.e. the
-// HTTP call queues a background job and returns right away. The job
-// worker eventually executes destroy_app server-side, which marks
-// terminated_ts at the START of its own execution. But during the
-// window between "request returns" and "job worker starts", the
-// app doc still looks billable. The dashboard refresh in that
-// window sees the old state — exactly the "GUI doesn't react /
-// second refresh fixes it" symptom.
-//
-// This endpoint sidesteps the job queue entirely. It's a synchronous
-// 2-line write — no DO API calls, no destroy chain. The dashboard
-// calls it BEFORE the destroy_app job, returns can render the new
-// billing state without waiting on infra teardown.
-//
-// Idempotent: if terminated_ts is already set, returns immediately.
-export const mark_app_terminated = async function (req) {
-  const { app_id } = req || {};
-  if (!app_id) return { code: -1, data: 'app_id required' };
-  try {
-    const ret = await db_module.get_couch_doc('xuda_master', app_id);
-    if (ret.code < 0) return { code: -1, data: 'app not found' };
-    const app_doc = ret.data;
-    if (!app_doc.app_cost) return { code: 1, data: 'no app_cost — nothing to mark' };
-    if (app_doc.app_cost.terminated_ts) return { code: 1, data: 'already terminated' };
-    app_doc.app_cost.terminated_ts = Date.now();
-    await db_module.save_couch_doc('xuda_master', app_doc);
-    return { code: 1, data: { terminated_ts: app_doc.app_cost.terminated_ts } };
-  } catch (err) {
-    return { code: -1, data: err.message };
-  }
-};
+// `mark_app_terminated` was removed — its job is now done by
+// `pre_destroy_app` in app_module, wired up via http_module's
+// pre_dispatch hook on `destroy_app`. See cpi/app_module/index.mjs.
 
 // -------------------------------------------------------------------
 //  Abuse detection — see the "How can we detect abuse?" plan.
@@ -1023,8 +990,16 @@ export const get_account_data = async function (req) {
       support_plan_changed: acc_obj.support_plan_changed,
       ai_workspace_plan: acc_obj.ai_workspace_plan,
       storage_plan_changed: acc_obj.storage_plan_changed,
+      account_hosted_email: acc_obj.account_hosted_email || null,
       account_project_id: acc_obj.account_project_id,
-      is_boarded: acc_obj.isBoarded,
+      // Coerce to explicit boolean. New accounts have `isBoarded`
+      // undefined; without this, JSON serialization drops the field
+      // entirely. The dashboard's SAVE_user uses spread-merge which
+      // doesn't overwrite missing-from-response fields, so a stale
+      // `is_boarded: true` from a previous user's localStorage would
+      // never get cleared. Always sending an explicit false keeps the
+      // gate honest.
+      is_boarded: !!acc_obj.isBoarded,
 
       prices_info: acc_obj.prices_info,
       activity_usage: acc_obj.activity_usage,
@@ -1093,6 +1068,52 @@ export const get_account_instances = async function (req) {
     key: req.uid,
   });
 };
+// Standalone VPS list for the sidenav — lets the dashboard refresh DATA.vps
+// after a deploy without a full account reload (SideNavData calls this). Same
+// user_vps view that the initial account load uses.
+export const get_account_vps = async function (req) {
+  return await db_module.get_couch_view('xuda_master', 'user_vps', {
+    key: req.uid,
+  });
+};
+
+// Advertising campaigns are apps (app_type:'advertising'). A Mango query by
+// owner avoids needing a dedicated CouchDB view; shaped like get_couch_view
+// ({code, data:{rows:[{id,value}]}}) so SideNavData buckets them into
+// DATA.advertising exactly like deployments/vps.
+export const get_account_advertising = async function (req) {
+  try {
+    // Superuser sees EVERY campaign across all accounts; everyone else only their own.
+    const isSuper = _conf.superuser_account_ids?.includes(req.uid);
+    const selector = isSuper ? { app_type: 'advertising', docType: 'app' } : { app_uId: req.uid, app_type: 'advertising', docType: 'app' };
+    const ret = await db_module.find_couch_query('xuda_master', {
+      selector,
+      limit: 1000,
+    });
+    const rows = (ret?.docs || []).map((d) => ({ id: d._id, value: d }));
+    return { code: 1, data: { rows } };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+// Static websites are apps (app_type:'static_website') created via create_app, but
+// they aren't emitted by any user_* CouchDB view, so they never surface in a sidenav
+// bucket. Same Mango-query approach as get_account_advertising → DATA.static_website.
+export const get_account_static_websites = async function (req) {
+  try {
+    const isSuper = _conf.superuser_account_ids?.includes(req.uid);
+    const selector = isSuper ? { app_type: 'static_website', docType: 'app' } : { app_uId: req.uid, app_type: 'static_website', docType: 'app' };
+    const ret = await db_module.find_couch_query('xuda_master', {
+      selector,
+      limit: 1000,
+    });
+    const rows = (ret?.docs || []).map((d) => ({ id: d._id, value: d }));
+    return { code: 1, data: { rows } };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
 
 export const get_account_info = async function (req) {
   return await get_account_data({
@@ -1393,6 +1414,11 @@ export const verify_account = async function (req) {
 export const validate_user_plan = async function (req) {
   const { account_id, app_obj } = req;
 
+  // Advertising campaigns are charged per-campaign (Stripe), NOT plan-capped — they
+  // (and their team sharing) are available on EVERY plan, free included. Exempt them
+  // from the plan gate so free accounts can invite collaborators to a campaign.
+  if (app_obj?.app_type === 'advertising') return { code: 1, data: { membership_plan: 'advertising_exempt' } };
+
   const apps_ret = await db_module.get_couch_view('xuda_master', 'user_apps_count', {
     startkey: [account_id, ''],
     endkey: [account_id, 'ZZZZZ'],
@@ -1420,8 +1446,13 @@ export const validate_user_plan = async function (req) {
     return { code: -7, data: 'error - no plan defined' };
   }
 
-  // validate number of projects
-  if (app_obj.app_type === 'master' && ret_obj.master >= plan.features.projects) {
+  // validate number of projects.
+  // The system account-project (is_account_project) backs login + the user
+  // drive and is created automatically by login_maintenance_fix — it must
+  // NEVER be blocked by the plan's project cap, or an account at the limit can
+  // never be provisioned and gets permanently locked out (get_gtp_token_info
+  // throws "fix: account_project_id" -> 401). Exempt it from the count.
+  if (app_obj.app_type === 'master' && !app_obj.is_account_project && ret_obj.master >= plan.features.projects) {
     return {
       code: -8,
       data: `Number of projects (${ret.data.membership_plan}) exceeds to the ${plan.features.projects} plan limits`,
@@ -2289,52 +2320,34 @@ export const validate_account_topup = async function (uid, items = []) {
   if (code < 0) {
     throw new Error(data);
   }
-  let topup = 0;
-  for (const item of items) {
-    topup += get_prices(uid, item);
-  }
+  // POSTPAID billing: paid features (VPS, custom domain, xuda subdomain, add-ons)
+  // now bill on the Stripe invoice at cycle close — we NO LONGER require a prepaid
+  // credit balance up front, only a working payment method. `items` is kept for
+  // call-site compatibility but is no longer used to gate on a prepaid amount.
 
+  // Gate 1: there must be a card on file to bill against.
   if (!data?.customer_obj?.default_source) {
     let err = new Error('no card on file');
     err.code = -90;
     err.billing_problem = true;
     throw err;
-    // throw new Error('no card on file');
   }
 
+  // Gate 2: a prior invoice that failed to charge is a real billing problem —
+  // block new paid usage until the card is fixed (otherwise unpaid usage runs
+  // unbounded). This is "pay your overdue invoice", not a prepaid top-up.
   if (data?.balance?.past_due) {
     let err = new Error(`past due ${data.balance.past_due}`);
     err.code = -91;
     err.billing_problem = true;
-    err.topup = topup + data.balance.past_due;
+    err.topup = data.balance.past_due;
     err.open_invoices = data?.open_invoices;
     throw err;
   }
-  // if (data?.balance?.past_due) {
-  //   let err = new Error(`past_due ${data?.balance?.past_due}`);
-  //   err.code = -91;
-  //   err.billing_problem = true;
-  //   err.topup = topup;
-  //   throw err;
-  // }
-
-  const balance = data?.balance?.account || 0; // minus balance represents positive balance
-
-  if (balance > 0) {
-    let err = new Error(`negative balance ${-balance}`);
-    err.code = -92;
-    err.billing_problem = true;
-    err.topup = topup - balance; // ask for whole balance
-    throw err;
-  }
 
-  if (topup + balance > 0) {
-    let err = new Error(`not enough balance ${topup + balance}`);
-    err.code = -93;
-    err.billing_problem = true;
-    err.topup = topup;
-    throw err;
-  }
+  // No prepaid-credit / "not enough balance" gate anymore — usage accrues on the
+  // app_cost ledger and is charged on the next invoice (Stripe applies any credit
+  // balance first, then the card).
 
   await release_account_billing_hold_if_current(uid);
 
@@ -2519,19 +2532,11 @@ export const onboarding_completed = async function (req, job_id, headers) {
     account_doc.isBoarded = true;
     const save_ret = await db_module.save_couch_doc('xuda_accounts', account_doc);
 
-    if (account_doc.account_info?.is_xuda_network_ambassador === true) {
-      console.log('[onboarding_completed] suppressing welcome_aboard for xuda.network ambassador', uid, account_doc.account_info.email);
-    } else {
-      notification_msa.submit_notification({
-        type: 'account',
-        app_id: null,
-        uid_arr: [uid],
-        topic: 'welcome_aboard',
-        params: { name: account_doc.account_info.first_name, email: account_doc.account_info.email, dashboard_url: 'https://xuda.ai/dashboard' },
-        ref: null,
-        email: null,
-      });
-    }
+    // Welcome email is sent once per account by maybe_send_welcome_email, which
+    // is also triggered when avatar generation completes (so it reaches every
+    // signup surface, not only the dashboard onboarding form). It is idempotent
+    // (welcome_email_sent_ts) and suppresses mentors/ambassadors.
+    maybe_send_welcome_email(uid);
 
     return save_ret;
   } catch (err) {
@@ -2539,6 +2544,55 @@ export const onboarding_completed = async function (req, job_id, headers) {
   }
 };
 
+// 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
+// widget, public profile). Skips mentors/ambassadors (is_xuda_network_ambassador).
+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' };
+    if (account_doc.account_info.is_xuda_network_ambassador === true) {
+      console.log('[maybe_send_welcome_email] suppressing for xuda.network ambassador/mentor', uid);
+      return { code: 0, data: 'ambassador' };
+    }
+    if (account_doc.welcome_email_sent_ts) 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;
+    const base = `https://${host}`;
+    const public_url = `${base}/public_profiles/${encodeURIComponent(username)}`;
+    const params = {
+      name: account_doc.account_info.first_name || 'there',
+      dashboard_url: `${base}/dashboard`,
+      public_url,
+      public_page_label: `${host}/public_profiles/${username}`,
+      qr: `${public_url}/qr.png`,
+      gif_base: `${base}/dist/images/email`,
+    };
+    await notification_msa.submit_notification({ type: 'account', app_id: null, uid_arr: [uid], topic: 'welcome_aboard', params, ref: null, email: null });
+
+    account_doc.welcome_email_sent_ts = Date.now();
+    await db_module.save_couch_doc('xuda_accounts', account_doc);
+    return { code: 1, data: 'sent' };
+  } catch (err) {
+    console.error('[maybe_send_welcome_email]', err.message);
+    return { code: -1, data: err.message };
+  }
+};
+
+// Resolve an account uid from a public username (account_info.username).
+// Used by the public-profile route so /public_profiles/<username> resolves.
+export const get_uid_by_username = async function (username) {
+  if (!username) return null;
+  const ret = await db_module.find_couch_query('xuda_accounts', {
+    selector: { 'account_info.username': username },
+    fields: ['_id'],
+    limit: 1,
+  });
+  return ret?.docs?.[0]?._id || null;
+};
+
 export const ts_contact = async function (uid, contact_id) {
   try {
     const contact_doc = await get_contact(uid, contact_id);
@@ -2632,6 +2686,9 @@ const set_account_profile_picture = async function (uid, account_uid, metadata,
 
       const account_save_ret = await db_module.save_couch_doc('xuda_accounts', account_obj);
       await update_account_profile_picture_status(account_uid, 3);
+      // Avatar finished generating -> the account is fully set up; send the
+      // one-time welcome email (idempotent, skips mentors/ambassadors).
+      maybe_send_welcome_email(account_uid);
     }
   } catch (err) {
     await update_account_profile_picture_status(account_uid, 1, err.message);
@@ -4350,6 +4407,34 @@ export const get_account_ai_usage_old = async function (req, job_id, headers) {
   }
 };
 
+// Push the account's live AI-credit balance to its dashboard WS room, so every
+// meter (the AiPrompt meter, the sidenav ring, the usage popup) updates the
+// instant credits are spent or topped up — no refresh. Debounced per-uid so a
+// burst of usage records (a streaming chat writing many chunks) collapses into a
+// single balance recompute + emit. Reuses get_account_ai_usage (the ledger read)
+// and emit_message_to_dashboard (the same uid-room push used for account updates).
+const _credits_broadcast_timers = {};
+export const broadcast_credits = function (uid) {
+  if (!uid || uid === 'system' || uid === 'webhook') return;
+  clearTimeout(_credits_broadcast_timers[uid]);
+  _credits_broadcast_timers[uid] = setTimeout(async () => {
+    delete _credits_broadcast_timers[uid];
+    try {
+      const ret = await get_account_ai_usage({ uid });
+      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;
+      ws_dashboard_msa.emit_message_to_dashboard({
+        service: 'credits_update',
+        to: [uid],
+        data: { used, max, remaining: Math.round((max - used) * 100) / 100, by_source: ret.data?.credits || {} },
+      });
+    } catch (e) {
+      console.error('[broadcast_credits]', e?.message || e);
+    }
+  }, 800);
+};
+
 export const record_ai_usage = async function (uid, input_tokens, output_tokens, source, prompt, model, metadata = {}, account_profile_info, tools) {
   try {
     if (!account_profile_info) throw new Error('missing account_profile_info');
@@ -4378,6 +4463,7 @@ export const record_ai_usage = async function (uid, input_tokens, output_tokens,
     };
     const save_ret = await db_module.save_couch_doc('xuda_usage', usage_doc);
     // console.log(save_ret);
+    broadcast_credits(uid); // live meter: this account just spent credits
   } catch (err) {
     console.error(err);
   }
@@ -4413,6 +4499,7 @@ export const record_ai_credit = async function (uid, credits = 0, source, detail
     };
     const save_ret = await db_module.save_couch_doc('xuda_billing', credit_doc);
     // console.log(save_ret);
+    broadcast_credits(credited_uid); // live meter: this account just gained credits
     return save_ret;
   } catch (err) {
     if (!err?.message?.includes('already credited!')) {

package/index_ms.mjs

@@ -33,9 +33,8 @@ export const increment_account_usage = async function (...args) {
   return await broker.send_to_queue("increment_account_usage", ...args);
 };
 
-export const mark_app_terminated = async function (...args) {
-  return await broker.send_to_queue("mark_app_terminated", ...args);
-};
+// mark_app_terminated removed — replaced by app_module.pre_destroy_app
+// invoked via http_module's pre_dispatch hook on destroy_app.
 
 export const recompute_abuse_signals = async function (...args) {
   return await broker.send_to_queue("recompute_abuse_signals", ...args);
@@ -97,6 +96,10 @@ export const get_account_name = async function (...args) {
   return await broker.send_to_queue("get_account_name", ...args);
 };
 
+export const get_uid_by_username = async function (...args) {
+  return await broker.send_to_queue("get_uid_by_username", ...args);
+};
+
 export const account_validate_username = async function (...args) {
   return await broker.send_to_queue("account_validate_username", ...args);
 };
@@ -352,3 +355,15 @@ export const read_accounts_emails = async function (...args) {
 export const process_accounts_emails = async function (...args) {
   return await broker.send_to_queue("process_accounts_emails", ...args);
 };
+
+export const get_account_vps = async function (...args) {
+  return await broker.send_to_queue("get_account_vps", ...args);
+};
+
+export const get_account_advertising = async function (...args) {
+  return await broker.send_to_queue("get_account_advertising", ...args);
+};
+
+export const get_account_static_websites = async function (...args) {
+  return await broker.send_to_queue("get_account_static_websites", ...args);
+};

package/index_msa.mjs

@@ -33,9 +33,8 @@ export const increment_account_usage =  function (...args) {
    broker.send_to_queue_async("increment_account_usage", ...args);
 };
 
-export const mark_app_terminated =  function (...args) {
-   broker.send_to_queue_async("mark_app_terminated", ...args);
-};
+// mark_app_terminated removed — replaced by app_module.pre_destroy_app
+// invoked via http_module's pre_dispatch hook on destroy_app.
 
 export const recompute_abuse_signals =  function (...args) {
    broker.send_to_queue_async("recompute_abuse_signals", ...args);
@@ -73,6 +72,14 @@ export const get_account_deployments =  function (...args) {
    broker.send_to_queue_async("get_account_deployments", ...args);
 };
 
+export const get_account_advertising =  function (...args) {
+   broker.send_to_queue_async("get_account_advertising", ...args);
+};
+
+export const get_account_static_websites =  function (...args) {
+   broker.send_to_queue_async("get_account_static_websites", ...args);
+};
+
 export const get_account_instances =  function (...args) {
    broker.send_to_queue_async("get_account_instances", ...args);
 };

package/package.json

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