@xuda.io/account_module 1.2.2272 → 1.2.2273

package/index.mjs.premerge.bak

@@ -0,0 +1,4725 @@
+import path from 'path';
+import fs from 'fs';
+import _ from 'lodash';
+// import { exec } from 'child_process';
+// import util from 'util';
+import { parsePhoneNumber } from 'libphonenumber-js';
+import { countryCodeEmoji } from 'country-code-emoji';
+
+const account_info_properties = [
+  'account_type',
+  'business_name',
+  'bio',
+  'phone_number',
+  'address',
+  'city',
+  'state',
+  'zip',
+  'country',
+  'email',
+  'first_name',
+  'last_name',
+  'mainCategory',
+  'subCategory',
+  'profile_picture',
+  'profile_picture_obj',
+  'username',
+  'website',
+  'profile_avatar_stat',
+  'active_account_profile_id',
+  'profile_avatar',
+  'profile_avatar_obj',
+  'is_xuda_network_ambassador',
+  'network_profile_url',
+  'network_lang',
+  'network_country_code',
+  'network_city_slug',
+  'public_profile_disabled',
+];
+
+global._conf = (
+  await import(path.join(process.env.XUDA_HOME, process.env.XUDA_CONFIG), {
+    with: { type: 'json' },
+  })
+).default;
+
+const _common = await import(path.join(process.env.XUDA_HOME, 'common', 'xuda_node_common.mjs'));
+const _utils = await import(path.join(process.env.XUDA_HOME, 'common', 'xuda-cpi-utils.mjs'));
+
+// Module Paths
+const module_path = path.join(process.env.XUDA_HOME, 'cpi') + (!_conf.is_debug ? '/node_modules/@xuda.io' : '');
+
+const db_module = await import(`${module_path}/db_module/index.mjs`);
+
+const ai_ms = await import(`${module_path}/ai_module/index_ms.mjs`);
+const drive_ms = await import(`${module_path}/drive_module/index_ms.mjs`);
+
+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`);
+
+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`);
+const email_msa = await import(`${module_path}/email_module/index_msa.mjs`);
+const logs_msa = await import(`${module_path}/logs_module/index_msa.mjs`);
+const ai_msa = await import(`${module_path}/ai_module/index_msa.mjs`);
+const notification_msa = await import(`${module_path}/notification_module/index_msa.mjs`);
+
+export const update_account_info = async function (req, job_id, headers) {
+  const { uid } = req;
+  const data = req;
+
+  // delete data.profile_avatar;
+
+  const account_profile_info = await get_active_account_profile_info(uid);
+
+  function validate_input(string, max_length, is_mandatory, is_pass) {
+    if (!/^[a-zA-Z0-9,.@ ]*$/.test(string) && !is_pass) {
+      // if (!preg_match('^[a-zA-Z0-9,.@ ]*$', string) && !is_pass) {
+
+      return -1;
+    } else if ((is_mandatory && !string) || string.length < 2) {
+      return -2;
+    } else if (string.count > max_length) {
+      return -3;
+    } else {
+      return 1;
+    }
+  }
+
+  const ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  var account_obj = ret.data;
+  account_obj.ts = Date.now();
+  var change = '';
+  var account_info_changes_arr = [];
+  var error = {};
+
+  await marketplace_ms.marketplace_save_user({ uid });
+
+  for (const key of account_info_properties) {
+    let val = data[key];
+    if (typeof val === 'undefined') continue;
+    if (account_obj.account_info[key] !== val) {
+      if (!key.includes('obj')) {
+        change += ' from ' + account_obj.account_info[key] + ' to ' + val;
+      }
+      account_info_changes_arr.push(key);
+
+      if (key === 'profile_picture') {
+        const current_profile_picture = account_obj.account_info?.profile_picture || '';
+        if (current_profile_picture.includes('googleusercontent')) {
+          account_obj.account_info['profile_picture_google'] = val;
+        } else {
+          //delete old profile picture
+          // const profile_picture = path.basename(account_obj?.account_info?.['profile_picture'] || '');
+          // if (profile_picture) {
+          //   drive_module.delete_drive_files({ uid, drive_type: 'user', files_arr: [profile_picture] });
+          // }
+        }
+
+        const profile_avatar_obj = account_obj?.account_info?.profile_avatar_obj || '';
+        const profile_avatar_file = profile_avatar_obj?.data || profile_avatar_obj;
+        if (profile_avatar_file?.file_path && profile_avatar_file?.filename) {
+          drive_msa.delete_drive_files({ uid, drive_type: 'user', files_arr: [{ type: 'file', file_path: path.join(profile_avatar_file.file_path, profile_avatar_file.filename) }] });
+        } else if (profile_avatar_obj) {
+          console.warn('Skipping profile avatar cleanup, missing file path data', {
+            uid,
+            profile_avatar_obj,
+          });
+        }
+      }
+
+      account_obj.account_info[key] = val;
+
+      if (account_obj.account_info.account_type === 'business') {
+        if (key === 'business_name' && validate_input(val, 150, true, false) < 0) {
+          error[key] = 'Invalid business name';
+        }
+      }
+      if (key === 'first_name' && !validate_input(val, 35, true, false)) {
+        // print_r(validate_input($val, 35, true, false)<0);
+        // exit;
+        error[key] = 'Invalid first name';
+      }
+      if (key === 'last_name' && !validate_input(val, 35, true, false)) {
+        error[key] = 'Invalid last name';
+      }
+      if (key === 'email' && (!validator.isEmail(val) || !val || val.length < 2)) {
+        error[key] = 'Invalid email';
+      }
+      // if (key === 'phone_number' && (!/^[0-9]{3}-[0-9]{4}-[0-9]{4}$/.test(val) || !val || val.length < 2)) {
+      //   // if (key === "phone_number" && (!preg_match("/^[0-9]{3}-[0-9]{4}-[0-9]{4}$/", $val) || !$val || count($val) < 2)) {
+      //   error[key] = 'Invalid phone number';
+      // }
+      if (key === 'address' && !/^[a-z0-9- ]+$/i.test(val)) {
+        // if (key === "address" && !preg_match('/^[a-z0-9- ]+$/i', $val)) {
+        error[key] = 'Invalid address';
+      }
+      if (key === 'city' && !validate_input(val, 255, false, false)) {
+        error[key] = 'Invalid city';
+      }
+      if (key === 'state' && !validate_input(val, 50, false, false)) {
+        error[key] = 'Invalid state';
+      }
+      if (key === 'zip' && validate_input(val, 9, false, false) < 0) {
+        error[key] = 'Invalid zip';
+      }
+      if (key === 'country' && !validate_input(val, 55, false, false)) {
+        error[key] = 'Invalid country';
+      }
+      if (key === 'is_xuda_network_ambassador' && typeof val !== 'boolean') {
+        error[key] = 'Invalid ambassador flag';
+      }
+      if (key === 'network_profile_url') {
+        let url_ok = false;
+        try {
+          url_ok = new URL(val).protocol === 'https:';
+        } catch (_) {
+          /* invalid */
+        }
+        if (!url_ok) {
+          error[key] = 'Invalid network profile url';
+        }
+      }
+      if (key === 'network_lang' && !/^[a-z]{2}$/.test(val)) {
+        error[key] = 'Invalid network lang';
+      }
+      if (key === 'network_country_code' && !/^[a-z]{2}$/.test(val)) {
+        error[key] = 'Invalid network country code';
+      }
+      if (key === 'network_city_slug' && !/^[a-z0-9-]{2,64}$/.test(val)) {
+        error[key] = 'Invalid network city slug';
+      }
+    }
+  }
+
+  if (!_.isEmpty(error)) {
+    return { code: -1310, data: error };
+  }
+  if (!change) {
+    if (account_obj.account_info?.profile_picture && !account_obj.account_info?.profile_avatar && account_obj.account_info.profile_avatar_stat !== 2) {
+      set_account_profile_picture(uid, uid, account_obj.account_info, job_id, headers, account_profile_info);
+    }
+    return { code: 1300, data: 'no change' };
+  }
+
+  account_obj.account_info.full_name = `${account_obj.account_info.first_name} ${account_obj.account_info.last_name}`;
+
+  //clean up received from req
+  delete account_obj.account_info.gtp_token;
+  delete account_obj.account_info.client_id;
+  delete account_obj.account_info.uid;
+  delete account_obj.account_info.token_ret;
+  delete account_obj.account_info.job_id;
+  delete account_obj.account_info.app_id;
+
+  const save_ret = await db_module.save_couch_doc('xuda_accounts', account_obj);
+
+  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);
+    }
+  }
+
+  // Opportunistic Stripe consolidation. Any time the user updates
+  // their account info, also check if they're still on the legacy
+  // 3-subscription model and migrate them to the consolidated
+  // 1-subscription-with-3-items model in the background. The
+  // migration helper is idempotent — already-consolidated accounts
+  // and accounts without a stripe_customer_id return immediately
+  // with no side effects — so this is cheap to run on every save.
+  //
+  // Fire-and-forget: we don't await it so the user's update_account_info
+  // response isn't blocked on Stripe API calls (creating a new sub +
+  // scheduling 3 cancels can take several seconds). The migration
+  // logs its own errors; if it fails for a particular account the
+  // user can still operate normally on the legacy model and we'll
+  // retry on the next update_account_info call.
+  if (account_obj.stripe_customer_id && !account_obj.stripe_subscription_id) {
+    stripe_ms
+      .migrate_account_to_consolidated({ uid })
+      .then((r) => {
+        if (r?.code === 1) {
+          console.log(`[update_account_info] migration result for ${uid}:`, typeof r.data === 'string' ? r.data : `migrated → ${r.data?.new_sub_id}`);
+        } else if (r?.code < 0) {
+          console.warn(`[update_account_info] migration failed for ${uid}:`, r?.data);
+        }
+      })
+      .catch((err) => {
+        console.warn(`[update_account_info] migration errored for ${uid}:`, err?.message || err);
+      });
+  } else if (account_obj.stripe_subscription_id) {
+    // Already on the consolidated model — but if the original
+    // migration used `trial_end` (older code path) the Stripe
+    // dashboard still shows the sub as "trialing". Idempotently
+    // swap it for a no-trial equivalent (cancel + recreate with
+    // `billing_cycle_anchor`). First invoice date stays exactly
+    // the same so the customer sees no billing change.
+    stripe_ms
+      .end_consolidated_trial({ uid })
+      .then((r) => {
+        if (r?.code === 1) {
+          const data = r.data;
+          if (typeof data === 'object' && data?.new_sub_id) {
+            console.log(`[update_account_info] trial removed for ${uid}: new sub ${data.new_sub_id}`);
+          }
+          // Quiet otherwise — "no consolidated sub" / "no active
+          // trial" are the common no-op cases and would spam logs.
+        } else if (r?.code < 0) {
+          console.warn(`[update_account_info] end_consolidated_trial failed for ${uid}:`, r?.data);
+        }
+      })
+      .catch((err) => {
+        console.warn(`[update_account_info] end_consolidated_trial errored for ${uid}:`, err?.message || err);
+      });
+  }
+
+  if (save_ret.code > 0) {
+    return { code: 1300, data: 'ok' };
+  }
+  return save_ret;
+};
+export const update_account_preferences = async function (req) {
+  const { uid, hide_create_button, default_dashboard, sidebar_style, enable_thumbnail_avatar_generation } = req;
+  try {
+    let account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+    account_doc.ts = Date.now();
+
+    account_doc.preferences = { hide_create_button, default_dashboard, sidebar_style, enable_thumbnail_avatar_generation };
+
+    const save_ret = await db_module.save_couch_doc('xuda_accounts', account_doc);
+    if (save_ret.code < 0) {
+      throw new Error(save_ret.data);
+    }
+    return { code: 1300, data: account_doc.preferences };
+  } catch (err) {
+    return { code: -13, data: err.message };
+  }
+};
+
+export const save_admin_presets = async function (req) {
+  const ret = await db_module.get_couch_doc('xuda_master', req.app_id);
+  if (ret.code < 0) {
+    return ret;
+  }
+  var app_obj = ret.data;
+  app_obj.deploy_data.admin_presets = req.admin_presets;
+  app_obj.deploy_data.preset_id = req.preset_id;
+
+  const ret3 = await db_module.save_app_obj(app_obj, null, req.app_id);
+  var obj = {};
+  if (ret3.code > -1) {
+    obj = {
+      code: 1,
+      data: 'ok',
+      app_obj: _common.get_clean_app_obj(app_obj),
+    };
+  } else {
+    obj = ret3;
+  }
+
+  return obj;
+};
+
+export const increment_account_usage = async function (req) {
+  const { uid } = req;
+
+  var opt = {};
+  if (uid) {
+    opt.key = uid;
+  }
+  const accounts_ret = await db_module.get_couch_view_raw('xuda_accounts', 'all_accounts', opt);
+
+  function bytesToGB(bytes) {
+    return bytes / 1073741824; // or bytes / (1024 ** 3)
+  }
+
+  // check if last calculation made at least hour ago
+  const interval = 3600 * 1000; //6000; // 3600 * 1000;
+
+  const run_account_drive = async function (account_data) {
+    try {
+      const usage_id = await _common.xuda_get_uuid('usage');
+
+      const usage_ret = await db_module.get_couch_view_raw('xuda_usage', 'open_drive_usage', {
+        key: account_data._id,
+      });
+
+      var doc = {
+        _id: usage_id,
+        docType: 'user_drive_usage',
+        date_created: new Date(),
+        stat: 1,
+        uid: account_data._id,
+        stripe_customer_id: account_data.stripe_customer_id,
+        account_name: account_data.account_info.first_name + ' ' + account_data.account_info.last_name,
+        size: 0,
+        price: 0,
+        hours: 0,
+        ts: 0,
+        subscription_id: account_data.stripe_membership_subscription_id,
+      };
+
+      if (usage_ret?.rows?.[0]) {
+        doc = usage_ret.rows[0].value;
+      }
+
+      if (Date.now() - doc.ts >= interval) {
+        const plan = _conf.PLAN_OBJ[account_data.membership_plan];
+        if (!plan) throw new Error(`${account_data.account_info.first_name + ' ' + account_data.account_info.last_name} has no plan in file`);
+        const drive_size_total = account_data.user_drive_size + account_data.studio_drive_size + account_data.workspace_drive_size + account_data.builds_drive_size + account_data.plugins_drive_size;
+        if (bytesToGB(drive_size_total) > plan.features.drive) {
+          var price_per_hour = (bytesToGB(drive_size_total) * _conf.PRICE_OBJ.price_per_gb_drive) / _conf.PRICE_OBJ.avg_hours_in_month;
+
+          doc.hours++;
+          doc.size = drive_size_total;
+          doc.price += price_per_hour;
+
+          doc.ts = Date.now();
+          await db_module.save_couch_doc('xuda_usage', doc);
+        }
+      }
+    } catch (err) {
+      console.error(err.message);
+    }
+  };
+
+  const run_account_apps = async function (account_data) {
+    const apps_ret = await db_module.get_couch_view('xuda_master', 'user_apps', {
+      startkey: [account_data._id, ''],
+      endkey: [account_data._id, 'ZZZZZ'],
+      include_docs: true,
+    });
+
+    try {
+      for await (let app of apps_ret.data.rows) {
+        if (app.value.app_type === 'master') {
+          let size_ret = await drive_ms.get_drive_size({
+            drive_type: 'studio',
+            app_id: app.id,
+          });
+          if (size_ret.code > -1) account_data.studio_drive_size += size_ret.data;
+
+          size_ret = await drive_ms.get_drive_size({
+            drive_type: 'workspace',
+            app_id: app.id,
+          });
+          if (size_ret.code > -1) account_data.workspace_drive_size += size_ret.data;
+
+          size_ret = await drive_ms.get_drive_size({
+            drive_type: 'builds',
+            app_id: app.id,
+          });
+          if (size_ret.code > -1) account_data.builds_drive_size += size_ret.data;
+
+          size_ret = await drive_ms.get_drive_size({
+            drive_type: 'plugins',
+            app_id: app.id,
+          });
+          if (size_ret.code > -1) account_data.plugins_drive_size += size_ret.data;
+
+          // db data
+          const couch_info_ret = await db_module.get_couch_app_info(app.id);
+          account_data.project_data_size += couch_info_ret?.data?.sizes?.active || 0;
+        }
+
+        const usage_id = await _common.xuda_get_uuid('usage');
+
+        const usage_ret = await db_module.get_couch_view_raw('xuda_usage', 'open_app_usage', {
+          key: [app.id, app.doc?.app_hosting?.app_server_type || app.doc.app_type],
+        });
+
+        var doc = {
+          _id: usage_id,
+          docType: 'app_usage',
+          date_created: new Date(),
+          stat: 1,
+          uid: account_data._id,
+          stripe_customer_id: account_data.stripe_customer_id,
+          account_name: account_data.account_info.first_name + ' ' + account_data.account_info.last_name,
+          app_id: app.id,
+          price: 0,
+          hours: 0,
+          ts: 0,
+          name: app.value.app_name,
+          app_type: app.value.app_type,
+
+          subscription_id: account_data.stripe_membership_subscription_id,
+        };
+
+        if (doc.app_type === 'user_group') {
+          doc = {
+            ...doc,
+            ...{
+              user_group_members: 0,
+              user_group_members_accumulated: 0,
+              user_group_members_avg: 0,
+              price_user_group: 0,
+            },
+          };
+        }
+
+        if (usage_ret?.rows?.[0]) {
+          doc = usage_ret.rows[0].value;
+        }
+
+        var price_per_hour;
+
+        // check if last calculation made at least hour ago
+        const interval = 6000; // 3600 * 1000;
+        if (Date.now() - doc.ts >= interval) {
+          doc.hours++;
+
+          switch (doc.app_type) {
+            case 'backup':
+              if (app.value.app_hosting) {
+                // backup of deployment
+                price_per_hour = (app.value.app_hosting.disk * _conf.PRICE_OBJ.price_per_gb_backup) / _conf.PRICE_OBJ.avg_hours_in_month;
+              } else {
+                // backup of project
+
+                const info_ret = await db_module.get_couch_app_info(doc.app_id);
+                if (info_ret.code > 0) {
+                  const size = info_ret.data.sizes.active / 1000 / 1000 / 1000; //gb
+                  price_per_hour = (size * _conf.PRICE_OBJ.price_per_gb_backup) / _conf.PRICE_OBJ.avg_hours_in_month;
+                }
+              }
+              break;
+
+            case 'user_group': {
+              const team_ret = await db_module.get_couch_view('xuda_team', 'user_group_shares_count', {
+                key: app.id,
+                reduce: true,
+                group_level: 1,
+              });
+
+              const team_members = team_ret.data.rows?.[0]?.value || 0;
+              const price_per_hour_team = (team_members * _conf.PRICE_OBJ.price_per_user_group_member) / _conf.PRICE_OBJ.avg_hours_in_month;
+              doc.price_user_group += price_per_hour_team;
+              doc.user_group_members = team_members;
+              doc.user_group_members_accumulated += team_members;
+              doc.user_group_members_avg = doc.user_group_members_accumulated / doc.hours;
+            }
+
+            default:
+              // deployments,vps,master,instances and datacenters
+              if (!app.doc.app_hosting) continue;
+
+              doc.app_hosting = app.doc.app_hosting;
+              doc.server_type = app.doc.app_hosting.app_server_type;
+              price_per_hour = app.doc.app_hosting.price / _conf.PRICE_OBJ.avg_hours_in_month;
+
+              break;
+          }
+          doc.price += price_per_hour;
+          if (doc.price < 1) {
+            doc.price = 1;
+          }
+
+          doc.ts = Date.now();
+          await db_module.save_couch_doc('xuda_usage', doc);
+        }
+      }
+    } catch (err) {
+      console.error(err.message);
+    }
+  };
+
+  // iterate on all status account except deleted accounts
+  for await (let val of accounts_ret.rows) {
+    var account_data = val.value;
+
+    const size_ret = await drive_ms.get_drive_size({
+      uid: account_data._id,
+      drive_type: 'user',
+    });
+
+    account_data.user_drive_size = size_ret.data;
+    account_data.studio_drive_size = 0;
+    account_data.workspace_drive_size = 0;
+    account_data.plugins_drive_size = 0;
+    account_data.builds_drive_size = 0;
+    account_data.project_data_size = 0;
+
+    await run_account_apps(account_data);
+    await run_account_drive(account_data);
+
+    account_data.total_drive_size = account_data.user_drive_size + account_data.studio_drive_size + account_data.workspace_drive_size + account_data.plugins_drive_size + account_data.builds_drive_size + account_data.project_data_size;
+    await db_module.save_couch_doc('xuda_accounts', account_data);
+  }
+};
+
+// ──────────────────────────────────────────────────────────────────
+// Per-deployment billing helpers.
+//
+// HISTORY: an earlier iteration of unified billing had an hourly
+// cron (`accrue_deployment_costs`) that walked every active
+// deployment and pushed accrual into a `deployment_usage` doc per
+// VPS, then flushed those docs to Stripe at end-of-cycle. That
+// approach had cron-coupling, off-by-one bugs at hour boundaries,
+// drift, and a parallel state machine to keep in sync.
+//
+// CURRENT: on-demand. Both the dashboard's `accrued_so_far` /
+// `projected_total` numbers AND the Stripe invoice items at cycle
+// close are computed from `app_cost.created_ts` /
+// `app_cost.terminated_ts` directly. No cron, no accumulator
+// docs. See compute_cycle_billable_amount in deploy_module/cost.mjs
+// for the math. Result: per-second accuracy automatically, idempotent
+// flush, zero between-event state.
+//
+// Only the `backfill_app_costs` one-shot remains here — it stamps
+// `app_cost.*` onto legacy deployments that pre-date the per-VPS
+// ledger, anchoring `created_ts = now` so past hours stay unbilled.
+// ──────────────────────────────────────────────────────────────────
+
+// Doc types that own a billable droplet / add-on bundle. Used by the
+// backfill query to scope its selector — and reusable as a constant
+// elsewhere should anything need to filter by "is this a billable
+// app type?".
+const BILLABLE_APP_TYPES = ['vps', 'datacenter', 'instance', 'balancer'];
+
+// `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.
+// -------------------------------------------------------------------
+
+// Admin emails get access to the abuse triage endpoints. Keep this in
+// sync with the dashboard's admin-route gate. Lives here (not in
+// config) so a compromised config_dev.json can't grant admin access.
+const ADMIN_EMAILS = new Set(['info@ioshka.com']);
+
+const is_admin_email = (email) => {
+  if (!email) return false;
+  return ADMIN_EMAILS.has(String(email).toLowerCase());
+};
+
+// Get the active billing cycle bounds for an account, on demand from
+// Stripe. Used by recompute_abuse_signals to scope its "this cycle"
+// counters correctly. Returns { cycle_start_ts, cycle_end_ts } in ms
+// or null if Stripe isn't reachable / customer not found.
+const get_account_cycle_bounds = async (account) => {
+  if (!account?.stripe_customer_id) return null;
+  try {
+    const stripe_ms = await import(`${module_path}/stripe_module/index_ms.mjs`);
+    // get_upcoming_invoice returns the upcoming invoice for the customer.
+    // Its period_start/period_end define the active cycle window. If
+    // that endpoint isn't available, we approximate from docDate.
+    const upcoming = await stripe_ms
+      .get_upcoming_invoice({
+        customer_id: account.stripe_customer_id,
+      })
+      .catch(() => null);
+    if (upcoming?.data?.period_start && upcoming?.data?.period_end) {
+      return {
+        cycle_start_ts: upcoming.data.period_start * 1000,
+        cycle_end_ts: upcoming.data.period_end * 1000,
+      };
+    }
+  } catch (_) {}
+  // Fallback: rolling 30-day window from now. Approximation good enough
+  // for abuse signals — exact cycle bounds only matter for invoicing.
+  const now = Date.now();
+  return { cycle_start_ts: now - 30 * 24 * 60 * 60 * 1000, cycle_end_ts: now };
+};
+
+// Walk an account's deployments and update its abuse_signals object.
+// Idempotent — safe to call on every cycle close, on resize, or on
+// admin demand. Returns the computed signals shape + any flags raised.
+//
+// Rules implemented (from the abuse plan):
+//   Rule 1 (negative_margin)        — margin_ratio < 0 AND provider > $5
+//   Rule 2 (resize_churn)           — >3 short segments OR >10 resizes this cycle
+//   Rule 3 (new_account_high_spec)  — account age < 7d AND any deploy > $150/mo
+//
+// Rules 4/5/6 need additional data sources (project history view, Stripe
+// payment_failed webhook, fingerprint capture) and ship in later phases.
+export const recompute_abuse_signals = async function (req) {
+  const { uid } = 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 cost_mod = await import(`${module_path}/deploy_module/cost.mjs`);
+    const { compute_cycle_billable_amount, is_billable } = cost_mod;
+
+    const bounds = await get_account_cycle_bounds(account);
+    const cycle_start_ts = bounds?.cycle_start_ts || Date.now() - 30 * 24 * 60 * 60 * 1000;
+    const cycle_end_ts = bounds?.cycle_end_ts || Date.now();
+
+    // Walk apps via the user_apps view.
+    const apps_ret = await db_module.get_couch_view('xuda_master', 'user_apps', {
+      startkey: [uid, ''],
+      endkey: [uid, 'ZZZZZ'],
+      include_docs: true,
+    });
+
+    let resizes_this_cycle = 0;
+    let short_segments_this_cycle = 0;
+    let total_billed = 0;
+    let total_provider = 0;
+    let max_monthly_spec = 0;
+
+    for (const row of apps_ret?.data?.rows || []) {
+      const doc = row.doc;
+      if (!is_billable(doc)) continue;
+
+      // Count cycle-relevant resizes by examining history[] entries
+      // whose closing timestamp falls inside the cycle window.
+      for (const seg of doc.app_cost.history || []) {
+        if (seg.to_ts > cycle_start_ts && seg.to_ts <= cycle_end_ts) {
+          resizes_this_cycle++;
+          if (seg.to_ts - seg.from_ts < 60 * 60 * 1000) short_segments_this_cycle++;
+        }
+      }
+
+      const billed = compute_cycle_billable_amount(doc, cycle_start_ts, cycle_end_ts);
+      total_billed += billed;
+
+      // Provider cost: use provider_cost_monthly if populated (Phase B
+      // will fill this from DO billing API). Until then approximate as
+      // monthly_hosting (assume 0% markup baseline — conservative for
+      // detecting negative margin).
+      const provider_monthly = doc.app_cost.provider_cost_monthly ?? doc.app_cost.monthly_hosting ?? 0;
+      const cycle_ms = cycle_end_ts - cycle_start_ts;
+      const window_start = Math.max(doc.app_cost.created_ts || cycle_start_ts, cycle_start_ts);
+      const window_end = Math.min(doc.app_cost.terminated_ts || cycle_end_ts, cycle_end_ts);
+      if (window_end > window_start && cycle_ms > 0) {
+        total_provider += provider_monthly * ((window_end - window_start) / cycle_ms);
+      }
+
+      if (doc.app_cost.monthly_total > max_monthly_spec) {
+        max_monthly_spec = doc.app_cost.monthly_total;
+      }
+    }
+
+    const account_age_ms = Date.now() - (account.docDate || account.created_ts || Date.now());
+    const account_age_days = account_age_ms / (24 * 60 * 60 * 1000);
+    const margin_ratio = total_provider > 0 ? (total_billed - total_provider) / total_provider : 0;
+
+    // Apply rules — first flag wins.
+    let flag = null;
+    let flag_detail = null;
+    if (total_provider > 5 && margin_ratio < 0) {
+      flag = 'negative_margin';
+      flag_detail = `provider $${total_provider.toFixed(2)} > billed $${total_billed.toFixed(2)} (margin ${(margin_ratio * 100).toFixed(0)}%)`;
+    } else if (short_segments_this_cycle > 3 || resizes_this_cycle > 10) {
+      flag = 'resize_churn';
+      flag_detail = `${resizes_this_cycle} resizes, ${short_segments_this_cycle} sub-1h segments`;
+    } else if (account_age_days < 7 && max_monthly_spec > 150) {
+      flag = 'new_account_high_spec';
+      flag_detail = `${account_age_days.toFixed(1)}d old, biggest VPS $${max_monthly_spec}/mo`;
+    }
+
+    const prev = account.abuse_signals || {};
+    const signals = {
+      resizes_this_cycle,
+      short_segments_this_cycle,
+      destroy_recreate_pairs: prev.destroy_recreate_pairs || 0, // populated by Rule 4 (later)
+      account_age_days,
+      total_provider_cost: Number(total_provider.toFixed(2)),
+      total_billed_amount: Number(total_billed.toFixed(2)),
+      margin_ratio: Number(margin_ratio.toFixed(4)),
+      max_monthly_spec,
+      cycle_start_ts,
+      cycle_end_ts,
+      computed_at: Date.now(),
+      flagged: !!flag,
+      flag_reason: flag,
+      flag_detail,
+      flag_ts: flag ? prev.flag_ts || Date.now() : null, // sticky until reviewed
+      reviewed_by: flag ? prev.reviewed_by || null : null,
+      reviewed_at: flag ? prev.reviewed_at || null : null,
+    };
+
+    account.abuse_signals = signals;
+    await db_module.save_couch_doc('xuda_accounts', account);
+
+    return { code: 1, data: signals };
+  } catch (err) {
+    console.error('[recompute_abuse_signals]', err.message);
+    return { code: -1, data: err.message };
+  }
+};
+
+// Admin-only: list every account currently flagged. The dashboard's
+// /admin/abuse page reads from here.
+export const get_flagged_accounts = async function (req) {
+  const { uid: caller_uid } = req || {};
+  if (!caller_uid) return { code: -1, data: 'unauthorized' };
+  try {
+    const caller_ret = await db_module.get_couch_doc('xuda_accounts', caller_uid);
+    if (caller_ret.code < 0 || !is_admin_email(caller_ret.data.email)) {
+      return { code: -1, data: 'unauthorized' };
+    }
+
+    // No view yet — scan via find_couch_query on abuse_signals.flagged.
+    // Acceptable at small scale; index this if the flagged list grows.
+    const find_ret = await db_module.find_couch_query('xuda_accounts', {
+      selector: { 'abuse_signals.flagged': true },
+      limit: 500,
+    });
+
+    const rows = (find_ret?.docs || []).map((a) => ({
+      uid: a._id,
+      email: a.email,
+      first_name: a.first_name,
+      last_name: a.last_name,
+      username: a.username,
+      stripe_customer_id: a.stripe_customer_id,
+      abuse_signals: a.abuse_signals,
+      stat: a.stat,
+      docDate: a.docDate,
+    }));
+
+    // Sort: unreviewed first, then most recent flag.
+    rows.sort((a, b) => {
+      const ar = a.abuse_signals?.reviewed_by ? 1 : 0;
+      const br = b.abuse_signals?.reviewed_by ? 1 : 0;
+      if (ar !== br) return ar - br;
+      return (b.abuse_signals?.flag_ts || 0) - (a.abuse_signals?.flag_ts || 0);
+    });
+
+    return { code: 1, data: rows };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+// Admin-only: sweep every account that has a stripe_customer_id and
+// recompute its abuse_signals. Used by the admin page's "Run sweep"
+// button so signals get refreshed without waiting for the next
+// invoice.upcoming webhook. Returns counts (flagged / clean / errors).
+export const sweep_abuse_signals = async function (req) {
+  const { uid: caller_uid } = req || {};
+  if (!caller_uid) return { code: -1, data: 'unauthorized' };
+  try {
+    const caller_ret = await db_module.get_couch_doc('xuda_accounts', caller_uid);
+    if (caller_ret.code < 0 || !is_admin_email(caller_ret.data.email)) {
+      return { code: -1, data: 'unauthorized' };
+    }
+
+    const accounts_ret = await db_module.find_couch_query('xuda_accounts', {
+      selector: { stripe_customer_id: { $exists: true } },
+      limit: 1000,
+    });
+    const accounts = accounts_ret?.docs || [];
+
+    const summary = { scanned: 0, flagged: 0, clean: 0, errors: [] };
+    for (const acct of accounts) {
+      summary.scanned++;
+      try {
+        const r = await recompute_abuse_signals({ uid: acct._id });
+        if (r?.code < 0) {
+          summary.errors.push({ uid: acct._id, message: r.data });
+        } else if (r?.data?.flagged) {
+          summary.flagged++;
+        } else {
+          summary.clean++;
+        }
+      } catch (err) {
+        summary.errors.push({ uid: acct._id, message: err.message });
+      }
+    }
+    return { code: 1, data: summary };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+// Admin-only: mark an account's current flag as reviewed (cleared until
+// next recompute raises it again). Records who reviewed + when.
+export const mark_account_reviewed = async function (req) {
+  const { uid: caller_uid, target_uid, note } = req || {};
+  if (!caller_uid || !target_uid) return { code: -1, data: 'uid + target_uid required' };
+  try {
+    const caller_ret = await db_module.get_couch_doc('xuda_accounts', caller_uid);
+    if (caller_ret.code < 0 || !is_admin_email(caller_ret.data.email)) {
+      return { code: -1, data: 'unauthorized' };
+    }
+
+    const target_ret = await db_module.get_couch_doc('xuda_accounts', target_uid);
+    if (target_ret.code < 0) return { code: -1, data: 'target account not found' };
+    const target = target_ret.data;
+
+    if (!target.abuse_signals) target.abuse_signals = {};
+    target.abuse_signals.reviewed_by = caller_ret.data.email;
+    target.abuse_signals.reviewed_at = Date.now();
+    target.abuse_signals.review_note = note || null;
+    target.abuse_signals.flagged = false; // cleared
+
+    await db_module.save_couch_doc('xuda_accounts', target);
+    return { code: 1, data: target.abuse_signals };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+// One-shot backfill: stamp `app_cost.*` onto legacy deployments,
+// anchored at `last_billed_ts = now` so the cron starts forward-only.
+// Idempotent — re-running on a doc that already has app_cost.last_billed_ts
+// is a no-op.
+//
+// opts:
+//   dry_run: boolean — compute, don't save.
+//   limit: number — cap on docs processed (canary backfill).
+//   app_id: string — backfill only this specific app.
+export const backfill_app_costs = async function (opts = {}) {
+  const { dry_run = false, limit = null, app_id = null } = opts || {};
+
+  // compute_app_cost lives in deploy_module/cost.mjs. Imported via
+  // the same cross-module path convention used elsewhere in this
+  // file (see fs_module / db_module imports at the top). Falls back
+  // to inline noop if the import fails so the backfill can at least
+  // log what it WOULD have done.
+  let compute_app_cost;
+  try {
+    const cost_mod = await import(`${module_path}/deploy_module/cost.mjs`);
+    compute_app_cost = cost_mod.compute_app_cost;
+  } catch (err) {
+    return { code: -1, data: `cost.mjs not importable from account_module: ${err.message}` };
+  }
+
+  const start = Date.now();
+  const summary = {
+    started_at: new Date().toISOString(),
+    dry_run,
+    scanned: 0,
+    stamped: 0,
+    terminated: 0,
+    skipped: 0,
+    nothing_to_bill: 0,
+    errors: [],
+  };
+
+  const APP_STATUS_DELETED = 4;
+
+  let selector;
+  if (app_id) {
+    selector = { _id: app_id };
+  } else {
+    selector = {
+      docType: 'app',
+      $or: [{ app_type: { $in: BILLABLE_APP_TYPES } }, { is_deployment: true }],
+    };
+  }
+
+  const find_ret = await db_module.find_couch_query('xuda_master', { selector, limit: limit || 99999 });
+  const docs = find_ret?.docs || [];
+
+  for (const doc of docs) {
+    summary.scanned++;
+    try {
+      let action = 'skipped';
+      let reason = '';
+
+      if (doc.app_cost?.last_billed_ts) {
+        reason = 'already has app_cost.last_billed_ts';
+      } else if (!doc.deploy_data) {
+        reason = 'no deploy_data';
+      } else if (!BILLABLE_APP_TYPES.includes(doc.app_type) && !doc.is_deployment) {
+        reason = `app_type ${doc.app_type} not billable`;
+      } else {
+        const has_addons = doc.deploy_data?.enable_backups || doc.deploy_data?.enable_ai_maintenance || doc.deploy_data?.enable_ai_instructions || doc.deploy_data?.enable_offline || doc.deploy_data?.enable_utility_screen || doc.deploy_data?.enable_user_assist;
+        if (doc.is_deployment && !has_addons && !doc.deploy_data?.app_server_type) {
+          reason = 'deployment without addons → datacenter bears cost';
+        } else {
+          const cost = compute_app_cost(doc.deploy_data);
+          if (!cost) {
+            action = 'nothing-to-bill';
+            reason = 'monthly_total = 0';
+          } else {
+            if (doc.app_status_code === APP_STATUS_DELETED) {
+              cost.terminated_ts = doc.app_status_data ? new Date(doc.app_status_data).getTime() : Date.now();
+              action = 'terminated';
+            } else {
+              action = 'stamped';
+            }
+            reason = `monthly=$${cost.monthly_total}`;
+            doc.app_cost = cost;
+            if (!dry_run) {
+              await db_module.save_couch_doc('xuda_master', doc);
+            }
+          }
+        }
+      }
+
+      if (action === 'stamped') summary.stamped++;
+      else if (action === 'terminated') summary.terminated++;
+      else if (action === 'nothing-to-bill') summary.nothing_to_bill++;
+      else summary.skipped++;
+
+      if (!summary.per_doc) summary.per_doc = [];
+      summary.per_doc.push({ _id: doc._id, app_type: doc.app_type, app_name: doc.app_name, action, reason });
+    } catch (err) {
+      summary.errors.push({ _id: doc._id, message: err.message });
+    }
+  }
+
+  summary.duration_ms = Date.now() - start;
+  return summary;
+};
+
+export const get_account_data = async function (req) {
+  var { uid, enforce_usage } = req;
+
+  try {
+    const { data: acc_obj } = await db_module.get_couch_doc('xuda_accounts', uid);
+
+    // let _design;
+    // if (acc_obj.account_project_id) {
+    //   _design = await db_module.get_app_couch_doc_native(acc_obj.account_project_id, '_design/xuda');
+    // }
+
+    var ret = { code: 1 };
+    ret.data = {
+      _id: acc_obj._id,
+      account_info: acc_obj.account_info,
+      usage: acc_obj.activity_usage,
+      membership_plan: acc_obj.membership_plan,
+      plan_changed: acc_obj.plan_changed,
+      plan_info: acc_obj.plan_info,
+      support_plan: acc_obj.support_plan,
+      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,
+      // 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,
+      uid: acc_obj._id,
+      stat: acc_obj.stat,
+      preferences: acc_obj.preferences || {},
+      billing_status: {
+        account_suspension_status: acc_obj.account_suspension_status,
+        account_suspension_data: acc_obj.account_suspension_data,
+        account_billing_hold_status: acc_obj.account_billing_hold_status,
+        account_billing_hold_data: acc_obj.account_billing_hold_date,
+        account_termination_status: acc_obj.account_termination_status,
+        account_termination_data: acc_obj.account_termination_data,
+      },
+      drive_usage: {
+        user_drive_size: acc_obj.user_drive_size || 0,
+        studio_drive_size: acc_obj.studio_drive_size || 0,
+        workspace_drive_size: acc_obj.workspace_drive_size || 0,
+        plugins_drive_size: acc_obj.plugins_drive_size || 0,
+        builds_drive_size: acc_obj.builds_drive_size || 0,
+        project_data_size: acc_obj.project_data_size || 0,
+        total_drive_size: acc_obj.total_drive_size || 0,
+      },
+
+      stripe_connect_account_id: acc_obj?.stripe_connect_account_obj?.id,
+      stripe_connect_account_status: acc_obj?.stripe_connect_account_status,
+    };
+
+    return ret;
+  } catch (err) {
+    console.error(err);
+    return { code: -1, data: err.message };
+  }
+  // };
+
+  // return get_info();
+};
+
+export const get_account_projects = async function (req) {
+  const { uid } = req;
+  var opt = {
+    key: uid,
+  };
+
+  if (_conf.superuser_account_ids.includes(uid) || _conf.support.support_team_account_ids.includes(uid)) {
+    opt = {};
+  }
+
+  var ret = await db_module.get_couch_view('xuda_master', 'user_projects', opt);
+
+  return ret;
+};
+
+export const get_account_datacenters = async function (req) {
+  return await db_module.get_couch_view('xuda_master', 'user_datacenters', {
+    key: req.uid,
+  });
+};
+export const get_account_deployments = async function (req) {
+  return await db_module.get_couch_view('xuda_master', 'user_deployments', {
+    key: req.uid,
+  });
+};
+export const get_account_instances = async function (req) {
+  return await db_module.get_couch_view('xuda_master', 'user_all_instances', {
+    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({
+    uid: req.uid,
+    enforce_usage: req.enforce_usage,
+  });
+};
+
+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;
+
+const load_did_you_know_tips = function () {
+  try {
+    const stat = fs.statSync(TIPS_FILE_PATH);
+    if (_did_you_know_tips_cache && stat.mtimeMs === _did_you_know_tips_cache_mtime) {
+      return _did_you_know_tips_cache;
+    }
+    const raw = fs.readFileSync(TIPS_FILE_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    _did_you_know_tips_cache = Array.isArray(parsed) ? parsed : parsed.tips || [];
+    _did_you_know_tips_cache_mtime = stat.mtimeMs;
+    return _did_you_know_tips_cache;
+  } catch (err) {
+    console.error('load_did_you_know_tips failed:', err.message);
+    return [];
+  }
+};
+
+const tip_requirement_passes = function (tip, account_doc) {
+  const r = tip?.requires;
+  if (!r) return true;
+  const account_info = account_doc?.account_info || {};
+  switch (r) {
+    case 'profile_incomplete': {
+      const required = ['first_name', 'last_name', 'bio', 'country', 'profile_picture'];
+      return required.some((k) => !account_info[k]);
+    }
+    case 'free_plan':
+      return account_doc?.membership_plan === 'free';
+    case 'no_support_plan':
+      return !account_doc?.support_plan || account_doc.support_plan === 'none' || account_doc.support_plan === 'free';
+    case 'email_not_connected':
+      return !account_doc?.connected_emails?.length && !account_doc?.email_oauth?.connected;
+    default:
+      return true;
+  }
+};
+
+export const did_you_know_tips = async function (req, job_id, headers) {
+  const { uid, action = 'next', tip_id } = req || {};
+  try {
+    if (!uid) throw new Error('uid required');
+
+    const account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+    if (!account_doc) throw new Error('account not found');
+
+    account_doc.did_you_know_tips = account_doc.did_you_know_tips || { offered: [], accepted: [], dismissed: [], current_offer: null };
+    const tips_state = account_doc.did_you_know_tips;
+
+    if (action === 'accept' || action === 'dismiss') {
+      const target_id = tip_id || tips_state.current_offer?.id;
+      if (!target_id) throw new Error('tip_id required');
+
+      const bucket = action === 'accept' ? tips_state.accepted : tips_state.dismissed;
+      if (!bucket.includes(target_id)) bucket.push(target_id);
+
+      if (tips_state.current_offer?.id === target_id) {
+        tips_state.current_offer = null;
+      }
+
+      account_doc.ts = Date.now();
+      const save_ret = await db_module.save_couch_doc('xuda_accounts', account_doc);
+      if (save_ret.code < 0) throw new Error(save_ret.data);
+      return { code: 1, data: { action, tip_id: target_id, tips_state } };
+    }
+
+    // Hold "Did you know" tips for the account's first week — brand-new
+    // users get a clean onboarding run before we start surfacing tips. The
+    // banner renders nothing when offer === null, so no frontend change is
+    // needed. Fails OPEN for legacy accounts with no creation timestamp
+    // (they're established users, not new ones).
+    const DYK_MIN_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+    const created_ts = Number(account_doc.date_created_ts) || (account_doc.date_created ? new Date(account_doc.date_created).getTime() : 0);
+    if (created_ts && Date.now() - created_ts < DYK_MIN_AGE_MS) {
+      return { code: 1, data: { offer: null, message: 'account in first-week grace period' } };
+    }
+
+    const all_tips = load_did_you_know_tips();
+    if (!all_tips.length) {
+      return { code: 1, data: { offer: null, message: 'no tips available' } };
+    }
+
+    const seen = new Set([...(tips_state.accepted || []), ...(tips_state.dismissed || [])]);
+    let candidates = all_tips.filter((t) => !seen.has(t.id) && tip_requirement_passes(t, account_doc));
+
+    if (!candidates.length) {
+      candidates = all_tips.filter((t) => !tips_state.accepted?.includes(t.id) && tip_requirement_passes(t, account_doc));
+    }
+    if (!candidates.length) {
+      return { code: 1, data: { offer: null, message: 'no more tips available' } };
+    }
+
+    const not_yet_offered = candidates.filter((t) => !tips_state.offered?.includes(t.id));
+    const pool = not_yet_offered.length ? not_yet_offered : candidates;
+    const picked = pool[Math.floor(Math.random() * pool.length)];
+
+    const offer = {
+      id: picked.id,
+      title: picked.title,
+      text: picked.text,
+      image: picked.image,
+      url: picked.url,
+      ts: Date.now(),
+    };
+
+    if (!tips_state.offered.includes(picked.id)) tips_state.offered.push(picked.id);
+    tips_state.current_offer = offer;
+
+    account_doc.ts = Date.now();
+    const save_ret = await db_module.save_couch_doc('xuda_accounts', account_doc);
+    if (save_ret.code < 0) throw new Error(save_ret.data);
+
+    return { code: 1, data: { offer } };
+  } catch (err) {
+    return { code: -45, data: err.message };
+  }
+};
+
+const _warned_no_account_project_id = new Set();
+
+export const get_active_account_profile_info = async function (uid, profile_id) {
+  try {
+    const acc_obj = await db_module.get_couch_doc_native('xuda_accounts', uid);
+
+    if (!acc_obj.account_project_id) {
+      if (!_warned_no_account_project_id.has(acc_obj._id)) {
+        _warned_no_account_project_id.add(acc_obj._id);
+        console.warn(`[get_active_account_profile_info] acc ${acc_obj._id} has no account_project_id; returning null`);
+      }
+      return { uid, account_profile_id: null, app_id: null, is_main: false, account_profile_obj: null };
+    }
+
+    // Fallback chain: explicit profile_id > active_account_profile_id > top-level account_profile_id.
+    // Recovers gracefully from accounts where active_account_profile_id was never set during boarding
+    // (e.g. interrupted Google signup flow), instead of throwing on every chat-widget poll.
+    let active_account_profile_id = profile_id || acc_obj.account_info?.active_account_profile_id || acc_obj.account_profile_id;
+
+    if (!active_account_profile_id) {
+      // Soft-fail: log once and return a degraded response. Callers that need a real profile
+      // should null-check `account_profile_obj`. The chat widget treats this as anonymous visitor.
+      console.warn(`[get_active_account_profile_info] acc ${acc_obj._id} has neither active_account_profile_id nor account_profile_id; returning null`);
+      return { uid, account_profile_id: null, app_id: acc_obj.account_project_id, is_main: false, account_profile_obj: null };
+    }
+
+    const account_profile_obj = await db_module.get_app_couch_doc_native(acc_obj.account_project_id, active_account_profile_id);
+    if (account_profile_obj.share_item_id) {
+      // set the original profile id if shared
+      active_account_profile_id = account_profile_obj.share_item_id;
+    }
+    const app_id = await get_account_default_project_id(account_profile_obj.shared_from_uid || account_profile_obj.uid);
+
+    return { uid: account_profile_obj.shared_from_uid || uid, account_profile_id: active_account_profile_id, app_id, is_main: active_account_profile_id === acc_obj.account_profile_id, account_profile_obj };
+  } catch (err) {
+    console.warn('**** get_active_account_profile_info', err);
+    // console.error(err.message);
+    // debugger;
+    throw err;
+  }
+};
+
+export const get_account_profile_group_member_uids = async function (owner_uid, share_item_id) {
+  const selector = { docType: 'team_request', team_req_stat: 3, share_item_id, access_type: 'account_profile', team_req_from_uid: owner_uid };
+  const ret = await db_module.find_couch_query('xuda_team', { selector });
+  return (ret?.docs || []).map((d) => d.team_req_to_uid).filter(Boolean);
+};
+
+export const get_account_name = async function (req) {
+  const data = await db_module.get_couch_doc('xuda_accounts', req.uid_query || req.uid);
+  if (data.code < 0) {
+    return data;
+  }
+  const { membership_plan = '', support_plan = '', ai_workspace_plan = '', date_created_ts = '', stat = '' } = data.data;
+  var obj = {
+    first_name: '',
+    last_name: '',
+    email: '',
+    phone_number: '',
+    profile_picture: '',
+    username: '',
+    membership_plan,
+    support_plan,
+    ai_workspace_plan,
+    date_created_ts,
+    stat,
+  };
+  if (data.data.account_info) {
+    const {
+      first_name,
+      last_name,
+      email,
+      phone_number,
+      profile_picture,
+      profile_avatar,
+      username,
+      website,
+      country,
+      bio,
+      industry,
+      account_type,
+      address,
+      city,
+      state,
+      zip,
+      business_name,
+      auto_respond,
+      auto_respond_mode,
+      auto_respond_agents,
+      avatar_source,
+      active_account_profile_id,
+      network_country_code,
+      public_profile_disabled,
+    } = data.data.account_info;
+
+    obj = {
+      _id: data.data._id,
+      stat,
+      network_country_code,
+      public_profile_disabled,
+      first_name,
+      last_name,
+      email,
+      phone_number,
+      profile_picture,
+      profile_avatar,
+      username,
+      website,
+      country,
+      bio,
+      industry,
+      membership_plan,
+      support_plan,
+      ai_workspace_plan,
+      date_created_ts,
+      account_type,
+      address,
+      city,
+      state,
+      zip,
+      business_name,
+      online: data?.data?.socket_id ? true : false,
+      auto_respond,
+      auto_respond_mode,
+      auto_respond_agents,
+      // email,// email?.[0] || '',
+      avatar_source,
+      active_account_profile_id,
+    };
+  }
+  return { code: 1, data: obj }; //is_online: data?.data?.socket_id ? true : false
+};
+
+export const account_validate_username = async function (req) {
+  const opt = {
+    selector: { 'account_info.username': req.username },
+    fields: ['_id'],
+    limit: 1,
+  };
+
+  var ret = await db_module.find_couch_query('xuda_accounts', opt);
+
+  if (ret.docs.length) {
+    return { code: -400, data: 'User exist' };
+  } else {
+    return { code: 1, data: 'ok' };
+  }
+};
+
+// export const get_account_activity = async function (req) {
+//   return await db_module.get_couch_view(
+//     "xuda_activity",
+//     "activity_per_account",
+//     {
+//       key: req.uid,
+//     }
+//   );
+// };
+
+export const verify_account = async function (req) {
+  const { account_id } = req;
+  if (!account_id) {
+    return { code: -10, data: 'Missing id' };
+  }
+
+  const ret = await db_module.get_couch_doc('xuda_accounts', account_id);
+
+  if (ret.code < 0) {
+    return { code: -1, data: 'account not found' };
+  }
+  var obj = ret.data;
+  obj.stat = 3;
+  const ret_acc = await db_module.save_couch_doc('xuda_accounts', obj);
+  if (ret.code < 0) {
+    return ret_acc;
+  }
+  return { code: 1, data: ret_acc.data };
+};
+
+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'],
+    reduce: true,
+    group_level: 2,
+  });
+
+  var ret_obj = _.reduce(
+    apps_ret.data.rows,
+    (ret, value) => {
+      ret[value.key[1]] = value.value;
+      return ret;
+    },
+    {},
+  );
+
+  const ret = await db_module.get_couch_doc('xuda_accounts', account_id);
+  if (ret.code < 0) {
+    return ret;
+  }
+  var plan = _conf.PLAN_OBJ[ret.data.membership_plan];
+  // get plan from user
+
+  if (!plan) {
+    return { code: -7, data: 'error - no plan defined' };
+  }
+
+  // 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`,
+    };
+  }
+
+  // validate number of team members
+
+  const user_active_app_requests_count_ret = await db_module.get_couch_view('xuda_team', 'user_active_app_requests_count', {
+    key: account_id,
+    reduce: true,
+    // group_level: 2,
+  });
+
+  if (app_obj.app_type === 'master' && user_active_app_requests_count_ret.data?.rows?.[0]?.value >= plan.features.team) {
+    return {
+      code: -9,
+      data: `Number of team shares (${user_active_app_requests_count_ret.data.rows[0].value}) exceeds to the ${plan.features.team} plan limits`,
+    };
+  }
+
+  return { code: 1, data: ret.data };
+};
+
+export const get_hosting_plan = function (req) {
+  const { app_obj } = req;
+  if (app_obj.app_hosting) {
+    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 };
+  }
+};
+
+export const get_cpu = async function (req) {
+  const { app_obj } = req;
+  var cpu = 1;
+  if (app_obj.app_hosting) {
+    const hosting_plan = get_hosting_plan({
+      app_obj,
+    });
+
+    if (hosting_plan.cpu) {
+      cpu = hosting_plan.cpu;
+    }
+  }
+  return cpu;
+};
+
+const get_account_log_object = function (body, status, service, source, response_data, ip, headers, security) {
+  return {
+    uid: body.uid,
+    ip,
+    method: service,
+    req_body: body,
+    client_headers: headers,
+    security: _conf.cpi_methods?.[service]?.log,
+    api_pk: body.api_pk,
+    api_sk: body.api_sk,
+    dashboard: !body.api_pk && !body.api_sk,
+    response_status_code: status,
+    response_data,
+    source,
+    security,
+  };
+};
+
+export const add_account_log_util = async function (body, status, service, source, response_data, ip, headers) {
+  // non error log
+  // if (status < 400) {
+  // console.log("error", "add_account_log_util", service);
+
+  if (!_conf.cpi_methods?.[service]) return;
+  if (_conf.cpi_methods?.[service]?.private) return;
+  const security = _conf.cpi_methods?.[service].security;
+  if (!security) {
+    if (service.substr(0, 4) === 'get_' && !body.api_pk && !body.api_sk) return;
+  }
+
+  logs_msa.add_account_log(get_account_log_object(body, status, service, source, response_data, ip, headers, security));
+};
+
+export const save_ssh_key = async function (req) {
+  const { uid, _id, ssh_key_name, ssh_key_content } = req;
+
+  function isValidSSHPublicKey(sshPublicKey) {
+    // Regular expression to match SSH public keys
+    const sshKeyRegex = /^ssh-(rsa|ed25519|ecdsa-sha2-nistp[0-9]+) [A-Za-z0-9+/]+[=]{0,3}( [^@]+@[^@]+)?$/;
+
+    return sshKeyRegex.test(sshPublicKey);
+  }
+
+  if (!isValidSSHPublicKey(ssh_key_content)) {
+    return { code: -1, data: 'invalid ssh key' };
+  }
+
+  var doc = {
+    uid,
+    docType: 'ssh_key',
+    date_created_ts: Date.now(),
+    date_created: Date.now(),
+    stat: 3,
+  };
+
+  if (_id) {
+    const ret = await db_module.get_couch_doc('xuda_ssh_keys', _id);
+    if (ret.code < 0) {
+      return ret;
+    }
+    doc = ret.data;
+    doc.date_updated_ts = Date.now();
+  } else {
+    doc._id = await _common.xuda_get_uuid('ssh_key');
+  }
+
+  doc.ssh_key_name = ssh_key_name;
+  doc.ssh_key_content = ssh_key_content;
+
+  const save_ret = await db_module.save_couch_doc('xuda_ssh_keys', doc);
+
+  return save_ret;
+};
+export const delete_ssh_key = async function (req) {
+  const { ssh_key_id } = req;
+
+  const ret = await db_module.get_couch_doc('xuda_ssh_keys', ssh_key_id);
+  if (ret.code < 0) {
+    return ret;
+  }
+  var doc = ret.data;
+  doc.date_updated_ts = Date.now();
+  doc.stat = 4;
+
+  const save_ret = await db_module.save_couch_doc('xuda_ssh_keys', doc);
+
+  return save_ret;
+};
+
+export const get_ssh_keys = async function (req) {
+  const { uid, _id } = req;
+
+  let opt = {
+    selector: { docType: 'ssh_key', uid, stat: { $lt: 4 } },
+  };
+
+  if (_id) {
+    opt.selector._id = _id;
+  }
+
+  var ret = await db_module.find_couch_query('xuda_ssh_keys', opt);
+  return ret;
+};
+
+export const search_users = async function (req) {
+  const { _id, search, limit, skip, bookmark, uid } = req;
+
+  // search
+  // skip
+  // limit
+  // bookmark
+  try {
+    // if (!_conf.superuser_account_ids.includes(req.uid)) {
+    //   throw new Error('user is not authorized for this method');
+    // }
+
+    let selector = {
+      docType: 'account',
+      stat: 3,
+    };
+
+    if (_id) {
+      selector._id = _id;
+    }
+
+    if (search) {
+      selector = {
+        ...selector,
+        $or: [
+          {
+            'account_info.full_name': {
+              $regex: `(?i)${search}`,
+            },
+          },
+          // {
+          //   'account_info.last_name': {
+          //     $regex: `(?i)${search}`,
+          //   },
+          // },
+          {
+            'account_info.business_name': {
+              $regex: `(?i)${search}`,
+            },
+          },
+          {
+            'account_info.phone_number': {
+              $regex: `(?i)${search}`,
+            },
+          },
+          {
+            'account_info.email': {
+              $regex: `(?i)${search}`,
+            },
+          },
+          {
+            'account_info.address': {
+              $regex: `(?i)${search}`,
+            },
+          },
+          {
+            _id: {
+              $regex: `(?i)${search}`,
+            },
+          },
+        ],
+      };
+    }
+
+    const opt = {
+      selector,
+      fields: ['_id', 'account_info.first_name', 'account_info.last_name', 'account_info.username', 'account_info.profile_avatar', 'account_info.profile_picture', 'socket_id', 'account_info.country', 'account_info.bio', 'account_info.business_name'],
+      limit: limit ? limit : 99999,
+    };
+
+    if (skip) {
+      opt.skip = skip;
+    }
+
+    if (req?.bookmark && req?.bookmark !== 'nil') {
+      opt.bookmark = bookmark;
+    }
+
+    try {
+      var ret = await db_module.find_couch_query('xuda_accounts', opt);
+
+      let docs = [];
+      for await (let e of ret.docs) {
+        let doc = await get_user_card({ uid, uid_query: e._id }); //await get_contact_info(uid, e);
+        docs.push(doc);
+      }
+
+      return {
+        code: 1,
+        data: docs,
+      };
+    } catch (e) {
+      return {
+        code: -400,
+        data: e,
+      };
+    }
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+export const find_contact_duplicates = async function (req) {
+  const { uid, name } = req;
+  var opt = {
+    selector: {
+      docType: 'contact',
+      stat: { $lt: 4 },
+      // uid,
+    },
+    limit: 999999,
+  };
+
+  if (typeof name !== 'undefined') {
+    opt.selector.name = name;
+  }
+  const contact_ret = await find_contact_query(uid, opt);
+  var duplicates = {};
+  for (contact of contact_ret.docs) {
+    if (!duplicates[contact.name]) {
+      duplicates[contact.name] = [];
+    }
+    if (contact.stat === 3) {
+      contact.primary = true;
+    }
+    duplicates[contact.name].push(contact);
+  }
+
+  // filter results
+  for await (let [name, val] of Object.entries(duplicates)) {
+    if (val.length < 2) {
+      delete duplicates[name];
+    }
+  }
+
+  return { code: 1, data: duplicates };
+};
+
+export const merge_contact = async function (req) {
+  const { uid, name } = req;
+  var duplicate_ret = await find_contact_duplicates({
+    uid,
+    name,
+  });
+  if (duplicate_ret.code < 0) {
+    return duplicate_ret;
+  }
+
+  var duplicate_arr = duplicate_ret?.data?.[name] || [];
+  if (!duplicate_arr.length) {
+    return { code: 1, data: 'no merge performed' };
+  }
+  var contact_to_merge;
+  var contact_to_delete = [];
+  for (contact of duplicate_arr) {
+    if (contact.primary) {
+      contact_to_merge = contact._id;
+      continue;
+    }
+    contact_to_delete.push(contact._id);
+  }
+
+  if (!contact_to_merge) {
+    // find best match for primary
+    for (let [i, contact_id] of Object.entries(contact_to_delete)) {
+      var contact_obj = duplicate_arr.find((e) => e._id === contact_id);
+
+      if (contact_obj.name && !['spam', 'newsletter', 'noreply', 'no-reply'].includes(contact_obj.email?.[0]?.toLowerCase())) {
+        contact_to_merge = contact_id;
+        contact_to_delete = contact_to_delete.splice(i, 1);
+        break;
+      }
+    }
+
+    if (!contact_to_merge) {
+      contact_to_merge = contact_to_delete[0];
+      contact_to_delete = contact_to_delete.slice(1);
+    }
+  }
+
+  // get the primary account
+
+  var primary_contact_doc = await get_contact(uid, contact_to_merge);
+
+  primary_contact_doc.stat_ts = Date.now();
+  primary_contact_doc.stat_reason = 'merge';
+
+  for (let contact_id of contact_to_delete) {
+    var email_address = duplicate_arr.find((e) => e._id === contact_id).email[0];
+
+    primary_contact_doc.email.push(email_address);
+  }
+
+  const primary_contact_save_ret = await save_contact(uid, primary_contact_doc);
+
+  for (let contact_id of contact_to_delete) {
+    try {
+      var contact_doc = await get_contact(uid, contact_id);
+      contact_doc.stat = 4;
+      contact_doc.stat_ts = Date.now();
+      contact_doc.stat_reason = 'merge';
+      await save_contact(uid, contact_doc);
+    } catch (error) {}
+  }
+
+  return primary_contact_save_ret; //{ code: 1, data: duplicate_arr };
+};
+
+const get_contact_background = function (doc) {
+  let ret = `linear-gradient(145deg,#60496e8c 0%,#71C4FF44 100%)`;
+
+  if (doc.pending) {
+    ret = `linear-gradient(145deg, #009ec2 0%, #002c74 100%)`;
+  } else {
+    switch (doc.contact_mood_level) {
+      case -2: {
+        ret = `linear-gradient(145deg, #f6040494 0%, #f6040476 100%)`;
+        break;
+      }
+      case -1: {
+        ret = `linear-gradient(145deg, #f604048b 0%, #7f98e344 100%)`;
+        break;
+      }
+      case 1: {
+        ret = `linear-gradient(145deg, #04f61447 0%, #7f98e344 100%)`;
+        break;
+      }
+      case 2: {
+        ret = `linear-gradient(145deg, #30f60468 0%, #04f61447 100%)`;
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return ret;
+};
+
+const get_contact_pattern = async function (doc) {
+  let ret = `default-pattern.png`;
+
+  if (doc?.shared_from_uid) {
+    const shared_from_uid_ret = await get_account_name({ uid_query: doc.shared_from_uid });
+    ret = shared_from_uid_ret.data.profile_avatar;
+  } else if (doc.profile_avatar_stat === 1) {
+    if (!doc.profile_avatar_stat_ts || Date.now() - doc.profile_avatar_stat_ts > 1000 * 60 * 5) {
+      ret = `error-pattern.png`;
+    } else {
+      ret = `pending-pattern.png`;
+    }
+  } else if (doc.profile_avatar_stat === 2) {
+    if (!doc.profile_avatar_stat_ts || Date.now() - doc.profile_avatar_stat_ts > 1000 * 60 * 5) {
+      ret = `error-pattern.png`;
+    } else {
+      ret = `processing-pattern.png`;
+    }
+  } else if (doc.is_spam) {
+    ret = `spam-pattern.png`;
+  } else {
+    // if (doc.account_type === 'business') {
+    //   // if (doc?.is_real_person) {
+    //   ret = doc.profile_picture;
+    //   // }
+    // } else {
+    // if (doc.my_contact) {
+    //   if (doc.account_type === 'business') {
+    //     ret = doc.profile_picture;
+    //   } else {
+    //     switch (doc.avatar_source) {
+    //       case 'fictional':
+    //         ret = `fictional-avatar-pattern.png`;
+    //         break;
+
+    //       case 'ai profile':
+    //         ret = `fictional-avatar-pattern.png`;
+    //         break;
+
+    //       case 'authentic profile':
+    //         ret = `authentic-avatar-pattern.png`;
+    //         break;
+
+    //       default:
+    //         ret = `xu-pattern.png`;
+    //         break;
+    //     }
+    //   }
+    // } else
+
+    // if (doc?.shared_from_uid) {
+    //   //&& (doc.pending || (doc.team_req_id && doc.contact_share_copy))) {
+    //   // pending or active share request
+    //   const shared_from_uid_ret = await get_account_name({ uid_query: doc.shared_from_uid });
+    //   ret = shared_from_uid_ret.data.profile_avatar;
+    // }
+
+    // else if (doc?.reference_doc?.shared_from_uid) {
+    //   //active share
+    //   const shared_from_uid_ret = await get_account_name({ uid_query: doc.reference_doc.shared_from_uid });
+    //   ret = shared_from_uid_ret.data.profile_avatar;
+    // }
+    // else
+    if (doc.contact_uid) {
+      switch (doc.avatar_source) {
+        case 'fictional':
+          ret = `fictional-avatar-pattern.png`;
+          break;
+
+        case 'ai profile':
+          ret = `fictional-avatar-pattern.png`;
+          break;
+
+        case 'authentic profile':
+          ret = `authentic-avatar-pattern.png`;
+          break;
+
+        default:
+          ret = `xu-pattern.png`;
+          break;
+      }
+    } else {
+      switch (doc.source) {
+        case 'read emails': {
+          ret = `email-pattern.png`;
+          break;
+        }
+        case 'web': {
+          ret = `web-pattern.png`;
+          break;
+        }
+
+        default:
+          break;
+      }
+    }
+    // }
+  }
+  return ret;
+};
+
+const get_contact_border = function (doc) {
+  const disable_color = `#1a3557`;
+  let ret;
+
+  if (doc.pending) {
+    ret = `#6f6c67`; // gray
+  } else if (doc.my_contact) {
+    ret = `transparent`; // gray
+  } else {
+    switch (doc.connection_stat) {
+      case 0: {
+        ret = disable_color;
+        break;
+      }
+      case 1: {
+        ret = `red`;
+        break;
+      }
+
+      case 2: {
+        ret = `red`;
+        break;
+      }
+
+      case 3: {
+        ret = `#164a28`; //`#0070ff`;
+        break;
+      }
+
+      case 4: {
+        ret = `red`;
+        break;
+      }
+
+      default:
+        ret = disable_color;
+        break;
+    }
+  }
+  return ret;
+};
+
+function formatPhoneWithFlag(phoneString, country = 'US') {
+  // try {
+
+  const phoneNumber = parsePhoneNumber(phoneString, country);
+  if (phoneNumber && phoneNumber.country) {
+    const flag = countryCodeEmoji(phoneNumber.country);
+    const formatted = phoneNumber.formatInternational(); // e.g., +1 213 373 4253
+    return `${flag} ${formatted}`;
+  }
+  // } catch (error) {
+  //   return 'Invalid phone number';
+  // }
+}
+
+export const get_contact_info = async function (uid, contact_doc, _id) {
+  try {
+    let doc = contact_doc;
+    if (_id) {
+      doc = await get_contact(uid, _id);
+    }
+
+    delete doc.metadata;
+    delete doc.profile_avatar_obj;
+    delete doc.profile_picture_obj;
+    delete doc.bio;
+
+    const account_profile_info = await get_active_account_profile_info(uid);
+
+    const chat_conversation_count = async function () {
+      let value = 0;
+
+      const key = `chat_conversation_count_${doc._id}`;
+      try {
+        value = await db_module.get_memcached_doc(key);
+      } catch (e) {
+        const counts_ret = await db_module.get_app_couch_view(account_profile_info.app_id, 'chat_conversation_item_counts', {
+          reduce: true,
+          group_level: 1,
+
+          startkey: [doc._id, ''],
+          endkey: [doc._id, 'zzzzzz'],
+        });
+
+        value = counts_ret?.rows?.[0]?.value || 0;
+        db_module.set_memcached_doc(key, value);
+      }
+
+      return value;
+    };
+    const chat_conversation_read = async function () {
+      let value = 0;
+
+      const key = `chat_conversation_read_${uid}_${doc._id}`;
+      try {
+        value = await db_module.get_memcached_doc(key);
+      } catch (e) {
+        const counts_ret = await db_module.get_app_couch_view(account_profile_info.app_id, 'chat_conversation_item_read', {
+          reduce: true,
+          group_level: 2,
+
+          startkey: [uid, doc._id, ''],
+          endkey: [uid, doc._id, 'zzzzzz'],
+        });
+
+        value = counts_ret?.rows?.[0]?.value || 0;
+        db_module.set_memcached_doc(key, value);
+      }
+      return value;
+    };
+
+    doc.notifications = 0;
+    if (doc.contact_uid) {
+      const account_info_ret = await get_account_name({ uid_query: doc.contact_uid });
+      if (account_info_ret.code < 0) {
+        return; // throw new Error(`account ${contact_uid} not found`);
+      }
+
+      doc.profile_avatar = account_info_ret.data.profile_avatar;
+
+      //membership_plan
+      // doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
+      doc.name = account_info_ret.data?.account_type === 'business' ? account_info_ret.data.business_name : `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
+
+      if (account_info_ret.data.phone_number) {
+        try {
+          doc.phone_number = formatPhoneWithFlag(account_info_ret.data.phone_number, account_info_ret.data.country);
+        } catch (err) {
+          // console.error(err);
+          doc.phone_number = account_info_ret.data.phone_number;
+        }
+      }
+
+      if (doc.team_req_id) {
+        try {
+          const req_doc = await db_module.get_couch_doc_native('xuda_team', doc.team_req_id);
+          doc.connection_stat = req_doc.team_req_stat;
+          doc.connection_type = req_doc.access_type;
+          doc.connection_uid = req_doc.team_req_from_uid === uid ? req_doc.team_req_to_uid : req_doc.team_req_from_uid;
+          doc.connection_contact_id = req_doc.team_req_from_contact_id === doc._id ? req_doc.team_req_to_contact_id : req_doc.team_req_from_contact_id;
+          if (doc.connection_type === 'contact_connection') {
+            doc.friend_since = req_doc.team_req_date;
+          }
+          if (doc.connection_type === 'account_profile') {
+            try {
+              const app_id = await get_account_default_project_id(uid);
+              const account_profile_doc = await db_module.get_app_couch_doc_native(app_id, req_doc.share_item_id);
+              doc.account_profile = account_profile_doc;
+            } catch (error) {}
+          }
+        } catch (err) {
+          if (err.message === 'deleted') {
+            try {
+              let contact_doc = await get_contact(uid, doc._id);
+              contact_doc.team_req_id = '';
+              await save_contact(uid, contact_doc);
+            } catch (error) {}
+          }
+          doc.connection_stat = 0;
+        }
+      }
+
+      doc.avatar_source = account_info_ret.data.avatar_source;
+      // doc.icon_pattern = await get_contact_pattern(doc);
+      doc.username = account_info_ret.data.username;
+      doc.business_name = account_info_ret.data.business_name;
+      doc.address = account_info_ret.data.address;
+      doc.city = account_info_ret.data.city;
+      doc.state = account_info_ret.data.state;
+      doc.zip = account_info_ret.data.zip;
+      doc.account_type = account_info_ret.data.account_type;
+      doc.email = doc.email;
+      if (doc.connection_stat === 3) {
+        doc.online = account_info_ret.data.online;
+      }
+    } else {
+      doc.email = doc.email;
+    }
+
+    doc.business_has_person = doc?.business_has_person && doc?.person_info?.person_full_name !== 'Not available';
+    doc.icon_pattern = await get_contact_pattern(doc);
+
+    delete doc.account_type_info;
+    delete doc.person_info;
+    delete doc.business_info;
+
+    const contact_chat_conversation_count_ret = await chat_conversation_count();
+    const contact_chat_conversation_read_ret = await chat_conversation_read();
+
+    doc.interactions = contact_chat_conversation_count_ret;
+    doc.notifications = contact_chat_conversation_count_ret - contact_chat_conversation_read_ret;
+    doc.chats = doc.interactions;
+
+    doc.card_background = get_contact_background(doc);
+
+    doc.border = get_contact_border(doc);
+
+    return doc;
+  } catch (err) {
+    console.error(err);
+    return {};
+  }
+};
+
+export const get_pending_contact_out = async function (uid, _id) {
+  let docs = [];
+  const to_opt = {
+    selector: { docType: 'team_request', access_type: 'contact_connection', team_req_stat: 2, team_req_from_uid: uid },
+    fields: ['_id', 'team_req_date', 'team_req_to_uid', 'team_req_to_email', 'sender_account_info.email', 'sender_account_info.first_name', 'sender_account_info.last_name', 'sender_account_info.profile_avatar', 'team_req_from_uid'],
+  };
+
+  if (_id) {
+    to_opt.selector._id = _id;
+  }
+  const requests_to_res = await db_module.find_couch_query('xuda_team', to_opt);
+
+  for await (let e of requests_to_res.docs) {
+    let doc = { docType: 'contact', date_created: e.team_req_date, email: [e.team_req_to_email], name: '', pending: true, contact_uid: e.team_req_to_uid, team_req_id: e._id, team_req_from_uid: uid };
+
+    if (e.team_req_to_uid) {
+      const account_info_ret = await get_account_name({ uid_query: e.team_req_to_uid });
+      if (account_info_ret.code < 0) {
+        continue; // throw new Error(`account ${contact_uid} not found`);
+      }
+      doc.account_type = account_info_ret.data.account_type;
+      doc.avatar_source = account_info_ret.data.avatar_source;
+      doc.profile_avatar = account_info_ret.data.profile_avatar;
+      doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
+    }
+    doc.icon_pattern = await get_contact_pattern(doc);
+    doc.card_background = get_contact_background({ pending: true });
+    docs.push(doc);
+  }
+
+  return docs;
+};
+
+export const get_pending_contact_in = async function (uid, _id) {
+  let docs = [];
+  const from_opt = { selector: { docType: 'team_request', access_type: 'contact_connection', team_req_stat: 2, team_req_to_uid: uid }, fields: ['_id', 'team_req_date', 'sender_account_info.email', 'team_req_from_uid'] };
+
+  if (_id) {
+    to_opt.selector._id = _id;
+  }
+
+  const requests_from_res = await db_module.find_couch_query('xuda_team', from_opt);
+
+  for await (let e of requests_from_res.docs) {
+    let doc = { docType: 'contact', date_created: e.team_req_date, email: [e.sender_account_info.email], name: '', pending: true, contact_uid: e.team_req_from_uid, team_req_id: e._id };
+
+    if (e.team_req_from_uid) {
+      const account_info_ret = await get_account_name({ uid_query: e.team_req_from_uid });
+      if (account_info_ret.code < 0) {
+        continue; // throw new Error(`account ${contact_uid} not found`);
+      }
+      doc.account_type = account_info_ret.data.account_type;
+      doc.avatar_source = account_info_ret.data.avatar_source;
+      doc.profile_avatar = account_info_ret.data.profile_avatar;
+      doc.name = `${account_info_ret.data.first_name} ${account_info_ret.data.last_name}`;
+    }
+    doc.card_background = get_contact_background({ pending: true });
+    doc.icon_pattern = await get_contact_pattern(doc);
+    docs.push(doc);
+  }
+  return docs;
+};
+export const get_pending_share_contact_in = async function (uid, _id) {
+  let docs = [];
+  const from_opt = { selector: { docType: 'team_request', access_type: 'contact', team_req_stat: 2, team_req_to_uid: uid }, fields: ['_id', 'team_req_date', 'sender_account_info.email', 'team_req_from_uid', 'share_item_id'] };
+
+  if (_id) {
+    to_opt.selector._id = _id;
+  }
+
+  const requests_from_res = await db_module.find_couch_query('xuda_team', from_opt);
+
+  for await (let e of requests_from_res.docs) {
+    let doc = await get_contact(uid, e.share_item_id);
+    delete doc.contact_mood_level;
+    doc.shared_from_uid = e.team_req_from_uid;
+    doc.pending = true;
+    doc = await get_contact_info(uid, doc);
+    doc.team_req_id = e._id;
+
+    docs.push(doc);
+  }
+  return docs;
+};
+
+const get_user_contact = async function (uid, uid_query) {
+  const account_info = (await get_account_name({ uid_query })).data;
+  let doc = { docType: 'contact', account_type: account_info.account_type, date_created: Date.now(), email: account_info.email, contact_uid: uid_query, username: account_info.username };
+
+  doc.name = account_info?.account_type === 'business' ? account_info.business_name : `${account_info.first_name} ${account_info.last_name}`;
+  doc.profile_avatar = account_info.profile_avatar;
+  doc.profile_picture = account_info.profile_picture;
+  doc.avatar_source = account_info.avatar_source;
+  doc.card_background = get_contact_background(doc);
+  doc.icon_pattern = await get_contact_pattern(doc);
+  doc.border = get_contact_border(doc);
+  doc.auto_respond = account_info.auto_respond;
+  doc.auto_respond_mode = account_info.auto_respond_mode;
+  doc.auto_respond_agents = account_info.auto_respond_agents;
+
+  return doc;
+};
+
+export const update_contact = async function (req) {
+  const { uid, email, contact_uid, stat, team_req_id } = req;
+
+  const account_profile_info = await get_active_account_profile_info(uid);
+
+  var contact_ret;
+
+  let opt = {
+    selector: {
+      docType: 'contact',
+      stat: 3,
+    },
+    limit: 1,
+    fields: ['_id'],
+  };
+
+  if (email) {
+    opt.selector.email = email;
+  } else if (contact_uid) {
+    opt.selector.contact_uid = contact_uid;
+  }
+
+  contact_ret = await find_contact_query(account_profile_info.uid, opt);
+
+  if (contact_ret.docs.length) {
+    var doc = contact_ret.docs[0];
+    if (stat) {
+      doc.stat = stat;
+      doc.stat_ts = Date.now();
+    }
+    if (team_req_id) {
+      doc.team_req_id = team_req_id;
+    }
+
+    if (contact_uid) {
+      const ret = await db_module.get_couch_doc('xuda_accounts', contact_uid);
+      const account_obj = ret.data;
+      doc.profile_picture = account_obj.account_info.profile_picture;
+      doc.profile_avatar = account_obj.account_info.profile_avatar;
+    }
+
+    return await save_contact(uid, doc);
+  }
+  return { code: -1, data: 'contact not found' };
+};
+
+export const get_account_rt_info = async function (uid) {
+  const doc_ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  if (doc_ret.code < 0) {
+    console.error('get_account_rt_info', doc_ret);
+    return {};
+  }
+  var account_info = doc_ret.data.account_info;
+
+  delete account_info.user_id;
+
+  account_info.uid = doc_ret.data._id;
+  return account_info;
+};
+
+export const validate_account_topup = async function (uid, items = []) {
+  const { code, data } = await stripe_ms.get_billing_metrics({ uid });
+  if (code < 0) {
+    throw new Error(data);
+  }
+  // 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;
+  }
+
+  // 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 = data.balance.past_due;
+    err.open_invoices = data?.open_invoices;
+    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);
+
+  return true;
+};
+
+const release_account_billing_hold_if_current = async function (uid) {
+  const account_ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  if (account_ret.code < 0 || !account_ret.data?.account_billing_hold_status) {
+    return;
+  }
+
+  const account_obj = account_ret.data;
+  account_obj.account_billing_hold_status = 0;
+  account_obj.account_billing_hold_date = Date.now();
+  await db_module.save_couch_doc('xuda_accounts', account_obj);
+
+  ws_dashboard_msa.emit_message_to_dashboard({
+    service: 'account_billing_hold_released',
+    to: [uid],
+    data: {
+      account_billing_hold_status: 0,
+      account_billing_hold_date: account_obj.account_billing_hold_date,
+    },
+  });
+};
+
+const get_prices = function (uid, item) {
+  let price;
+
+  switch (item) {
+    case 'user_group':
+    case 'pwa':
+    case 'preview':
+    case 'android':
+    case 'ios':
+    case 'macos':
+    case 'emitter':
+      price = _conf.PRICE_OBJ.deployments[item];
+      break;
+
+    case 'drive_ocr':
+      price = _conf.PRICE_OBJ.drive_addons.ocr.price;
+      break;
+
+    case 'drive_edit_image':
+      price = _conf.PRICE_OBJ.drive_addons.edit_image.price;
+      break;
+
+    case 'auto_backup':
+      price = _conf.PRICE_OBJ.auto_backup_per_month;
+      break;
+
+    case 'deployment_offline':
+      price = _conf.PRICE_OBJ.deployment_offline_per_month;
+      break;
+
+    case 'xuda_subdomain':
+      price = _conf.PRICE_OBJ.xuda_subdomain_per_month;
+      break;
+
+    case 'custom_domain':
+      price = _conf.PRICE_OBJ.custom_domain_per_month;
+      break;
+
+    case 'user_monitor':
+      price = _conf.PRICE_OBJ.user_assist_per_month;
+      break;
+
+    case 'branding':
+      price = _conf.PRICE_OBJ.branding_per_month;
+      break;
+
+    case 'utility_screen':
+      price = _conf.PRICE_OBJ.utility_screen_per_month;
+      break;
+
+    default:
+      price = 0;
+      break;
+  }
+
+  if (_conf.PRICE_OBJ.server_slugs[item]) {
+    price = _conf.PRICE_OBJ.server_slugs[item].price;
+  }
+
+  return price;
+};
+
+export const create_account_oauth_link = async function (req, job_id) {
+  const link = `https://accounts.google.com/o/oauth2/v2/auth?scope=https://mail.google.com/&access_type=offline&include_granted_scopes=true&response_type=code&state=${req.uid}&redirect_uri=https://${_conf.is_debug ? 'dev.' : ''}xuda.ai/oauth&client_id=${
+    _conf.gmail.clientId
+  }&prompt=select_account consent`;
+  // await jobs_module.update_job(
+  //   {
+  //     job_id,
+  //     current_step_name: 'creating link',
+  //     response: link,
+  //   },
+  //   global[`_account_module_ch`],
+  // );
+  // await _utils.delay(20000);
+  // debugger;
+  return {
+    code: 1,
+    data: link,
+  };
+};
+
+export const get_default_project_account_doc = async function (uid) {
+  const ret = await db_module.get_couch_doc('xuda_accounts', uid);
+  return ret.data;
+};
+export const get_account_default_project_id = async function (uid) {
+  const account_obj = await get_default_project_account_doc(uid);
+  return account_obj.account_project_id;
+};
+
+export const get_user_name = async function (uid) {
+  try {
+    const { data: account_info } = await get_account_name({ uid });
+    let username = 'unknown';
+    if (account_info) {
+      username = account_info.first_name + ' ' + account_info.last_name;
+
+      if (!username) {
+        username = +account_info.email;
+      }
+    }
+
+    return username;
+  } catch (err) {
+    return 'unknown';
+  }
+};
+
+export const get_user_card = async function (req) {
+  const { uid, uid_query } = req;
+  if (uid === uid_query) return await get_user_contact(uid, uid_query);
+
+  let user_contact_obj;
+
+  const opt = {
+    selector: {
+      docType: 'contact',
+      stat: 3,
+      contact_uid: uid_query,
+    },
+    limit: 1,
+    fields: ['_id'],
+  };
+  // const account_profile_info = await get_active_account_profile_info(uid);
+  const user_contacts = await find_contact_query(uid, opt);
+
+  const contact_id = user_contacts?.docs?.[0]?._id;
+  if (contact_id) {
+    user_contact_obj = await get_contact_info(uid, null, contact_id);
+  } else {
+    user_contact_obj = await get_user_contact(uid, uid_query);
+  }
+  return user_contact_obj;
+};
+
+export const onboarding_completed = async function (req, job_id, headers) {
+  const { uid } = req;
+  try {
+    await update_account_info(req, job_id, headers);
+
+    let account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+
+    // NOTE: neither profile_picture nor profile_avatar are required
+    // to complete onboarding. The client UI labels step 4 "(optional)"
+    // and lets the user skip — matching that here means a successful
+    // client flow always succeeds server-side too. Anything they skip
+    // can be added later from Settings → Profile. The avatar service
+    // can also time out or fail transiently, and we don't want a
+    // generation hiccup to block someone from finishing signup.
+
+    account_doc.account_info.full_name = `${account_doc.account_info.first_name} ${account_doc.account_info.last_name}`;
+
+    account_doc.boarded_info = { headers, date_ts: Date.now() };
+    account_doc.isBoarded = true;
+    const save_ret = await db_module.save_couch_doc('xuda_accounts', account_doc);
+
+    // 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) {
+    return { code: -44, data: 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
+// 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);
+    contact_doc.ts = Date.now();
+    const save_ret = await save_contact(uid, contact_doc);
+    return save_ret;
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const set_account_profile_picture = async function (uid, account_uid, metadata, job_id, headers, account_profile_info) {
+  await update_account_profile_picture_status(account_uid, 1);
+  try {
+    let profile_picture;
+
+    let { code: account_code, data: account_obj } = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    let account_info = account_obj.account_info;
+
+    if (account_code < 0) {
+      throw new Error(`account ${account_uid} not found`);
+    }
+
+    const name = account_info.account_type === 'business' ? account_info.business_name : account_info.full_name;
+
+    await update_account_profile_picture_status(account_uid, 2);
+    if (!account_info.profile_picture) {
+      const file_ret = await ai_ms.get_profile_picture(uid, account_info.account_type, name, { email: account_info.email, metadata, account_info }, account_profile_info, job_id, headers);
+
+      let { code: account_code, data: account_obj2 } = await db_module.get_couch_doc('xuda_accounts', account_uid);
+      account_obj = account_obj2;
+      account_info = account_obj.account_info;
+
+      if (!_.isObject(file_ret.data)) throw new Error('file_ret not an object');
+      account_info.profile_picture_obj = file_ret.data;
+
+      account_info.profile_picture = account_info.profile_picture_obj.file_url;
+      account_info.profile_picture_source = file_ret.profile_picture_source;
+      const account_save_ret = await db_module.save_couch_doc('xuda_accounts', account_obj);
+      profile_picture = account_info.profile_picture;
+    }
+
+    if (!account_info.profile_avatar) {
+      let business_size;
+
+      switch (account_obj.membership_plan) {
+        case 'free': {
+          business_size = 'unknown';
+          break;
+        }
+
+        case 'pro': {
+          business_size = 'small';
+          break;
+        }
+
+        case 'team': {
+          business_size = 'medium';
+          break;
+        }
+
+        case 'agency': {
+          business_size = 'large';
+          break;
+        }
+        case 'enterprise_t1':
+        case 'enterprise_t2':
+        case 'enterprise_t3': {
+          business_size = 'enterprise';
+          break;
+        }
+
+        default:
+          business_size = 'unknown';
+          break;
+      }
+
+      const { bio, country, mainCategory, subCategory } = account_info;
+
+      const file_ret = await ai_ms.get_profile_avatar(account_info.profile_picture, uid, '', account_profile_info, account_info.account_type, 'account', account_uid, { bio, country, mainCategory, subCategory, is_user: true }, business_size, name, account_info.email, job_id, headers);
+      if (file_ret.code < 0) {
+        throw new Error(file_ret.data);
+      }
+      let { code: account_code, data: account_obj3 } = await db_module.get_couch_doc('xuda_accounts', account_uid);
+      account_obj = account_obj3;
+      account_info = account_obj.account_info;
+
+      if (!_.isObject(file_ret.data)) throw new Error('file_ret not an object');
+      account_info.profile_avatar_obj = file_ret.data;
+      account_info.profile_avatar = account_info.profile_avatar_obj.file_url;
+
+      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);
+  }
+};
+
+// Internal trigger used by the widget Google-signup flow: when a freshly-created
+// visitor account already has a profile_picture (their Google photo) but no
+// generated avatar yet, kick off avatar generation. set_account_profile_picture
+// maintains profile_avatar_stat (1 → 2 → 3); the caller polls that. Mirrors the
+// opportunistic trigger in update_account_info (profile_avatar_stat !== 2 guards
+// against re-triggering while a generation is mid-flight).
+export const ensure_profile_avatar = async function (req, job_id, headers) {
+  try {
+    const { uid } = req || {};
+    if (!uid) return { code: -1, data: 'missing uid' };
+    const { code, data: account_obj } = await db_module.get_couch_doc('xuda_accounts', uid);
+    if (code < 0 || !account_obj) return { code: -1, data: 'account not found' };
+    const info = account_obj.account_info || {};
+    if (info.profile_picture && !info.profile_avatar && info.profile_avatar_stat !== 2) {
+      // Best-effort profile context for AI-usage attribution. A freshly-created
+      // widget visitor may have no profile/project yet — tolerate that.
+      let account_profile_info;
+      try {
+        account_profile_info = await get_active_account_profile_info(uid);
+      } catch (e) {}
+      // fire-and-forget inside this worker; generation is heavy (vision + image ops)
+      set_account_profile_picture(uid, uid, info, job_id, headers, account_profile_info);
+    }
+    return { code: 1, data: { profile_avatar_stat: info.profile_avatar_stat || 0 } };
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+setTimeout(async () => {
+  const app_id = 'prj712ffdf5aa8adce6cedef988f9c12392'; //'prj3937cb6f9a31c8c7dea25055bba845b1'; //
+  const uid = 'd39126e0e2c51ffbd1aad10709fc8335';
+
+  let ret;
+  // read_accounts_emails();
+  // ret = await get_account_ai_usage({ uid }, 111);
+  // ret = await set_deep_research_contact({ uid, contact_id: 'cnt_c07049718613a11d164e90450d5f9902' });
+  // ret = await generate_contact_avatar({ uid, contact_id: 'cnt_c07049718613a11d164e90450d5f2742' });
+  // ret = await not_spam_contact({ uid, contact_id: 'cnt_c07049718613a11d164e90450d5f2742' });
+  // ret = await get_account_ai_usage({ uid });
+  // ret = await create_account_profile({ uid });
+  // ret = await get_account_profiles({ uid });
+
+  // let _design = await db_module.get_app_couch_doc_native(app_id, '_design/xuda');
+  // ret = _design.views.ai_chat_usage;
+  // console.log(_design.views.ai_chat_usage);
+  // ret = await set_contact_profile_picture(uid, 'cnt_2d21d55f8f0cdaf65a7a69f69617f532', {}, null, {});
+  // ret = await get_xuda_cache(uid, 'chat_thumbnail', 'word five title');
+  // add_ai_credits_to_active_accounts();
+
+  console.log(ret);
+}, 1000);
+
+//////// CONTACTS  //////////////
+
+function identifyPersonalProvider(domain) {
+  const providers = {
+    'gmail.com': 'Google Gmail',
+    'googlemail.com': 'Google Gmail',
+    'outlook.com': 'Microsoft Outlook',
+    'hotmail.com': 'Microsoft Hotmail',
+    'live.com': 'Microsoft Live',
+    'yahoo.com': 'Yahoo Mail',
+    'ymail.com': 'Yahoo Mail',
+    'aol.com': 'AOL Mail',
+    'icloud.com': 'Apple iCloud',
+    'me.com': 'Apple iCloud',
+    'mac.com': 'Apple iCloud',
+    'protonmail.com': 'ProtonMail',
+    'proton.me': 'ProtonMail',
+    'zoho.com': 'Zoho Mail',
+    'yandex.com': 'Yandex Mail',
+    'mail.com': 'Mail.com',
+    'gmx.com': 'GMX Mail',
+  };
+
+  return providers[domain.toLowerCase()];
+}
+
+export const add_contact = async function (req, job_id, headers) {
+  try {
+    const { profile_id, uid, email, name, stat, contact_uid, context, source, team_req_id, metadata = {} } = req;
+    const account_profile_info = await get_active_account_profile_info(uid, profile_id);
+    const { account_profile_obj } = account_profile_info;
+
+    //////////////////
+    const opt = {
+      selector: {
+        docType: 'contact',
+        stat: { $ne: 4 },
+        email: email.toLowerCase(),
+      },
+      limit: 1,
+      fields: ['_id'],
+    };
+
+    const user_contacts = await find_contact_query(uid, opt);
+    if (user_contacts.docs.length) {
+      // throw new Error('contact already exist');
+      return { code: -1, data: 'contact already exist', contact_id: user_contacts.docs[0]._id };
+    }
+
+    /////////////////
+
+    let is_spam = false;
+    // let email_type_info;
+    // let account_type_info;
+    let business_info;
+    let account_type;
+    let cached_contact;
+    let business_has_person;
+    if (contact_uid) {
+      let { code: account_code, data: account_obj } = await db_module.get_couch_doc('xuda_accounts', contact_uid);
+      // account_info = account_obj.account_info;
+      // account_info_ret = await get_account_name({ uid_query: contact_uid });
+      if (account_code < 0) {
+        throw new Error(`account ${contact_uid} not found`);
+      }
+
+      set_account_profile_picture(uid, contact_uid, metadata, job_id, headers, account_profile_info);
+    } else {
+      is_spam = await isLikelySpamEmail(email);
+
+      // contact without use account
+      cached_contact = await get_xuda_cache(uid, 'contact', email, 'metadata');
+
+      if (_.isEmpty(cached_contact)) {
+        if (!is_spam && metadata.subject && !metadata.is_sent && !metadata.is_answered && !metadata.not_junk) {
+          // deep search for spam
+          is_spam = await ai_ms.is_spam_email(uid, email, metadata.subject, account_profile_info);
+        }
+        if (!is_spam) {
+          const is_business = await ai_ms.is_business_contact(uid, email, name, metadata.subject, metadata.summarized_body, account_profile_info);
+          account_type = is_business ? 'business' : 'personal';
+          if (is_business) {
+            business_info = await ai_ms.get_business_info(uid, '', email, account_profile_info, { light: true });
+            if (business_info.business_name !== 'Not available') {
+              business_has_person = await ai_ms.is_business_contact_has_person(uid, email, name, metadata.subject, metadata.summarized_body, account_profile_info);
+            } else {
+              account_type = 'personal';
+              business_info = undefined;
+            }
+          }
+          if (_.isEmpty(cached_contact) && account_type === 'business' && !business_has_person) {
+            if (!identifyPersonalProvider(business_info.business_domain)) {
+              cached_contact = await get_xuda_cache(uid, 'contact', business_info.business_domain, 'metadata');
+            } else {
+              cached_contact = await get_xuda_cache(uid, 'contact', business_info.business_name, 'metadata');
+            }
+          }
+        }
+      }
+    }
+
+    const d = Date.now();
+    const contact_obj = {
+      _id: await _common.xuda_get_uuid('contact'),
+      email: email.toLowerCase(),
+      name: cached_contact?.name || name,
+      stat: stat || 3,
+      date_created: metadata.email_data ? new Date(metadata.email_data).getTime() : d,
+      ts: d,
+      docType: 'contact',
+      contact_uid,
+      uid: account_profile_info.uid,
+      uid_created: uid,
+      context,
+      headers,
+      source,
+      team_req_id,
+      metadata,
+      is_spam: cached_contact?.is_spam || is_spam,
+      business_has_person: cached_contact?.business_has_person || business_has_person,
+      business_info: cached_contact?.business_info || business_info,
+
+      account_profiles: [account_profile_obj._id],
+      account_type: cached_contact?.account_type || account_type,
+      profile_avatar_stat: 0,
+    };
+
+    if (!is_spam) {
+      if (account_type === 'personal' || contact_obj?.business_has_person) {
+        contact_obj.person_info = await ai_ms.get_person_info(uid, contact_obj.name, contact_obj.email, account_profile_info, metadata?.summarized_body, { light: true });
+        if (!contact_obj.name) {
+          contact_obj.name = await ai_ms.get_name_from_email_addr(uid, contact_obj.email, account_profile_info);
+        }
+      }
+
+      const conversation_obj = await ai_ms.create_openai_conversation();
+      contact_obj.contact_reference_conversation_id = conversation_obj.id;
+    } else {
+      if (!contact_obj.name) {
+        contact_obj.name = '';
+      }
+    }
+
+    const save_ret = await save_contact(uid, contact_obj);
+    save_xuda_cache(uid, 'contact', contact_obj.email, null, contact_obj);
+
+    if (!contact_obj.is_spam && contact_obj.name) {
+      set_contact_profile_picture(uid, contact_obj._id, metadata, job_id, headers, account_profile_info, false);
+    }
+
+    return save_ret;
+  } catch (err) {
+    return { code: -1, data: err.message };
+  }
+};
+
+const set_contact_profile_picture = async function (uid, contact_id, metadata, job_id, headers, account_profile_info, create_avatar) {
+  let contact_obj;
+  await update_contact_profile_picture_status(uid, contact_id, 1);
+  try {
+    // let profile_picture;
+
+    const contact_ret = await db_module.get_app_couch_doc(account_profile_info.app_id, contact_id);
+
+    if (contact_ret.code < 0) {
+      throw new Error(`contact ${contact_id} not found`);
+    }
+    contact_obj = contact_ret.data;
+    await update_contact_profile_picture_status(uid, contact_id, 2);
+    ////// PROFILE PICTURE
+    if (!contact_obj.profile_picture) {
+      let cache = await get_xuda_cache(uid, 'profile_picture', contact_obj.email, 'file');
+      if (!cache && contact_obj?.business_info?.business_domain) {
+        if (!identifyPersonalProvider(contact_obj.business_info.business_domain)) {
+          cache = await get_xuda_cache(uid, 'profile_picture', contact_obj.business_info.business_domain, 'file');
+        } else {
+          cache = await get_xuda_cache(uid, 'profile_picture', contact_obj.business_info.business_name, 'file');
+        }
+      }
+      let file_ret = { code: 1, data: cache };
+
+      if (!cache) {
+        // if personal, return profile pic, if business return logo
+        file_ret = await ai_ms.get_profile_picture(uid, contact_obj.account_type, contact_obj?.business_info?.business_domain || contact_obj.name, { email: contact_obj.email, metadata: contact_obj, create_avatar }, account_profile_info, job_id, headers);
+
+        if (file_ret.code < 0) {
+          throw new Error(file_ret.data);
+        }
+
+        if (!_.isObject(file_ret.data)) throw new Error('file_ret not an object');
+        if (file_ret?.data?.file_url) {
+          if (contact_obj?.business_info?.business_domain) {
+            if (!identifyPersonalProvider(contact_obj.business_info.business_domain)) {
+              save_xuda_cache(uid, 'profile_picture', contact_obj.business_info.business_domain, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+            } else {
+              save_xuda_cache(uid, 'profile_picture', contact_obj.business_info.business_name, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+            }
+          }
+          save_xuda_cache(uid, 'profile_picture', contact_obj.email, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+        }
+      }
+      if (file_ret?.data?.file_url) {
+        let { code: contact_code, data: contact_obj2 } = await db_module.get_app_couch_doc(account_profile_info.app_id, contact_id);
+        contact_obj = contact_obj2;
+        contact_obj.profile_picture_obj = file_ret.data;
+        contact_obj.profile_picture = contact_obj.profile_picture_obj.file_url;
+        contact_obj.profile_picture_source = file_ret.profile_picture_source;
+
+        const contact_save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, contact_obj);
+        // profile_picture = contact_obj.profile_picture;
+      }
+    }
+    ////// PROFILE AVATAR
+    if (!contact_obj.profile_avatar && contact_obj.profile_picture) {
+      let cache;
+      if (contact_obj?.account_type === 'business') {
+        if (contact_obj?.business_has_person && contact_obj?.person_info?.person_full_name !== 'Not available') {
+          cache = await get_xuda_cache(uid, 'profile_avatar', contact_obj.email, 'file');
+        } else {
+          cache = await get_xuda_cache(uid, 'profile_avatar', `${contact_obj?.business_info?.business_category || ''} ${contact_obj?.business_info?.business_sub_category || ''}`, 'file');
+        }
+      } else {
+        cache = await get_xuda_cache(uid, 'profile_avatar', contact_obj.email, 'file');
+      }
+
+      let file_ret = { code: 1, data: cache };
+
+      if (!cache && create_avatar) {
+        file_ret = await ai_ms.get_profile_avatar(
+          contact_obj.profile_picture,
+          uid,
+          '',
+          account_profile_info,
+          contact_obj.account_type,
+          'contact',
+          contact_id,
+          {
+            business_name: contact_obj?.business_info?.business_name,
+            name: contact_obj.name,
+            bio: contact_obj?.business_info?.bio || contact_obj?.personal_info?.bio,
+            country: contact_obj?.business_info?.business_country || contact_obj?.person_info?.person_nationality,
+            mainCategory: contact_obj?.business_info?.business_category,
+            subCategory: contact_obj?.business_info?.business_sub_category,
+            business_has_person: contact_obj?.business_has_person && contact_obj?.person_info?.person_full_name !== 'Not available',
+            person_nationality: contact_obj?.person_info?.person_nationality,
+          },
+          // { business_info: contact_obj.business_info, personal_info: contact_obj.personal_info, account_type_info: contact_obj.account_type_info },
+          contact_obj?.business_info?.business_size,
+          contact_obj?.business_info?.business_domain || contact_obj.name,
+          contact_obj.email,
+          job_id,
+          headers,
+        );
+
+        if (file_ret.code < 0) {
+          if (file_ret.data === 'Input file contains unsupported image format') {
+            contact_obj.profile_picture = null;
+            contact_obj.profile_picture_obj = null;
+            const contact_save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, contact_obj);
+          }
+          throw new Error(file_ret.data);
+        }
+
+        if (!_.isObject(file_ret.data)) throw new Error('file_ret not an object');
+
+        if (contact_obj?.account_type === 'business') {
+          if (contact_obj?.business_has_person && contact_obj?.person_info?.person_full_name !== 'Not available') {
+            cache = await save_xuda_cache(uid, 'profile_avatar', contact_obj.email, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+          } else {
+            cache = await save_xuda_cache(uid, 'profile_avatar', `${contact_obj?.business_info?.business_category || ''} ${contact_obj?.business_info?.business_sub_category || ''}`, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+          }
+        } else {
+          cache = await save_xuda_cache(uid, 'profile_avatar', contact_obj.email, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+        }
+
+        // if (contact_obj?.account_type === 'business' && !contact_obj?.account_type_info?.is_real_person) {
+        //   cache = await save_xuda_cache(uid, 'profile_avatar', `${contact_obj?.business_info?.mainCategory || ''}_${contact_obj?.business_info?.subCategory || ''}`, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+        // } else {
+        //   cache = await save_xuda_cache(uid, 'profile_avatar', contact_obj.email, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+        // }
+
+        // if (contact_obj.business_name) {
+        //   save_xuda_cache(uid, 'profile_avatar', contact_obj.business_name, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+        // }
+        // save_xuda_cache(uid, 'profile_avatar', contact_obj.email, file_ret.data, { account_type: contact_obj.account_type, type: 'contact' });
+      }
+
+      let { code: contact_code, data: contact_obj3 } = await db_module.get_app_couch_doc(account_profile_info.app_id, contact_id);
+      contact_obj = contact_obj3;
+      contact_obj.profile_avatar_obj = file_ret.data;
+      contact_obj.profile_avatar = contact_obj?.profile_avatar_obj?.file_url;
+      contact_obj.avatar_source = file_ret?.data?.avatar_source;
+      const contact_save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, contact_obj);
+    }
+    await update_contact_profile_picture_status(uid, contact_id, 3);
+  } catch (err) {
+    await update_contact_profile_picture_status(uid, contact_id, 1, err.message);
+    delete_xuda_cache(contact_obj);
+  }
+};
+
+const update_account_profile_picture_status = async function (uid, stat, error) {
+  try {
+    let doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+    doc.account_info.profile_avatar_stat = stat;
+    doc.account_info.profile_avatar_error = error;
+    doc.account_info.profile_avatar_stat_ts = Date.now();
+    const save_ret = await db_module.save_couch_doc_native('xuda_accounts', doc);
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+const update_contact_profile_picture_status = async function (uid, contact_id, stat, error) {
+  const account_profile_info = await get_active_account_profile_info(uid);
+  try {
+    let doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, contact_id);
+    doc.profile_avatar_stat = stat;
+    doc.profile_avatar_error = error;
+    doc.profile_avatar_stat_ts = Date.now();
+
+    const save_ret = await db_module.save_app_couch_doc_native(account_profile_info.app_id, doc);
+  } catch (err) {
+    console.error(err);
+  }
+};
+
+export const get_contacts = async function (req, job_id, headers) {
+  const { _id, uid, name, limit, skip, bookmark, search, filter_type = 'all', contact_id, profile_id } = req;
+  try {
+    const account_profile_info = await get_active_account_profile_info(uid, profile_id);
+    if (_id) {
+      let data = { code: 34, data: await get_contact(uid, _id) };
+      return data;
+    }
+
+    let { with_requests } = req;
+    var opt = {
+      selector: {
+        docType: 'contact',
+
+        stat: { $lt: 4 },
+      },
+      limit: limit || 9999,
+      skip: skip || 0,
+      sort: [{ ts: 'desc' }],
+    };
+
+    if (!account_profile_info.is_main) {
+      opt.selector.account_profiles = { $in: [account_profile_info.account_profile_id] };
+    } else {
+      const active_profiles = await db_module.find_app_couch_query(account_profile_info.app_id, {
+        selector: {
+          docType: 'account_profile',
+          uid: account_profile_info.uid,
+          stat: { $lt: 4 },
+        },
+        fields: ['_id'],
+        limit: 9999,
+      });
+
+      const active_profile_ids = active_profiles.docs.map((profile) => profile._id).filter(Boolean);
+      opt.selector.account_profiles = { $in: active_profile_ids.length ? active_profile_ids : [account_profile_info.account_profile_id] };
+    }
+
+    switch (filter_type) {
+      case 'archived': {
+        opt.selector.stat = 5;
+        break;
+      }
+      case 'shared': {
+        opt.selector.shared_from_uid = { $gt: null };
+        break;
+      }
+
+      case 'pinned': {
+        opt.selector.pinned = true;
+        break;
+      }
+
+      case 'online': {
+        opt.limit = 9999;
+        break;
+      }
+
+      default:
+        with_requests = true;
+        break;
+    }
+
+    if (_id) {
+      opt.selector._id = _id;
+    }
+
+    if (contact_id) {
+      opt.selector._id = contact_id;
+    }
+
+    if (typeof name !== 'undefined') {
+      opt.selector.name = { $regex: `(?i)${name}` };
+    }
+
+    if (typeof search !== 'undefined') {
+      opt.selector['$or'] = [
+        {
+          name: {
+            $regex: `(?i)${search}`,
+          },
+        },
+        {
+          email: {
+            $regex: `(?i)${search}`,
+          },
+        },
+        {
+          _id: {
+            $regex: `(?i)${search}`,
+          },
+        },
+      ];
+    }
+
+    if (bookmark && bookmark !== 'nil') {
+      opt.bookmark = bookmark;
+    }
+
+    let contacts = { docs: [], total_docs: 0 };
+
+    if (filter_type !== 'pending') {
+      contacts = await find_contact_query(account_profile_info.uid, opt);
+      if (!limit || contact_id) {
+        contacts.total_docs = contacts.docs.length;
+      } else {
+        delete opt.sort;
+        delete opt.skip;
+        opt.limit = 9999;
+        opt.fields = ['_id'];
+
+        const counter = await find_contact_query(account_profile_info.uid, opt);
+        contacts.total_docs = counter.docs.length;
+      }
+    }
+
+    let requests_to = { docs: [], total_docs: 0 };
+    let requests_from = { docs: [], total_docs: 0 };
+    let shared_from = { docs: [], total_docs: 0 };
+
+    let contact_docs = { docs: [], total_docs: contacts.total_docs };
+
+    for await (let doc of contacts.docs) {
+      const ret_to = requests_to.docs.find((e) => {
+        return e.contact_uid === doc.contact_uid;
+      });
+      if (ret_to) continue;
+
+      const ret_from = requests_from.docs.find((e) => {
+        return e.contact_uid === doc.contact_uid;
+      });
+      if (ret_from) continue;
+
+      doc = await get_contact_info(uid, doc);
+
+      // doc.interactions = contact_chat_conversation_count_ret[doc._id];
+      // doc.notifications = contact_chat_conversation_count_ret[doc._id] - contact_chat_conversation_read_ret[doc._id];
+      // doc.chats = doc.interactions;
+
+      if (filter_type === 'online') {
+        if (!doc.online) continue;
+      }
+
+      contact_docs.docs.push(doc);
+
+      if (contact_id) {
+        if (!doc.profile_avatar && !doc.is_spam && (!doc.profile_avatar_stat || doc.profile_avatar_stat === 1 || (doc.profile_avatar_stat === 2 && (!doc.profile_avatar_stat_ts || Date.now() - doc.profile_avatar_stat_ts > 1000 * 60 * 5)))) {
+          set_contact_profile_picture(uid, doc._id, {}, job_id, headers, account_profile_info, false);
+        }
+      }
+    }
+
+    if (!contact_id && with_requests) {
+      if (filter_type === 'pending' && account_profile_info.is_main) {
+        ////// TO - OUT
+        requests_to.docs = await get_pending_contact_out(uid);
+        requests_to.total_docs = requests_to.docs.length;
+
+        ////// FROM - IN
+        requests_from.docs = await get_pending_contact_in(uid);
+        requests_from.total_docs = requests_from.docs.length;
+        shared_from.docs = await get_pending_share_contact_in(uid);
+        shared_from.total_docs = shared_from.docs.length;
+      }
+    }
+
+    return {
+      code: 1,
+      data: {
+        docs: [...shared_from.docs, ...requests_from.docs, ...requests_to.docs, ...contact_docs.docs],
+        total_docs: shared_from.total_docs + requests_from.total_docs + requests_to.total_docs + contact_docs.total_docs,
+      },
+    };
+  } catch (err) {
+    return { code: -34, data: err.message };
+  }
+};
+
+export const archive_contact = async function (req) {
+  const { uid, contact_id } = req;
+  try {
+    await team_ms.validate_share_exist(uid, 'contact', contact_id);
+
+    var contact_doc = await get_contact(uid, contact_id);
+
+    if (contact_doc.uid !== uid && contact_doc?.account_profile_info?.uid !== uid) {
+      throw new Error('Operation not allowed');
+    }
+
+    contact_doc.stat = 5;
+    contact_doc.stat_ts = Date.now();
+    contact_doc.stat_reason = 'archived by the user';
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const delete_contact = async function (req, job_id, headers) {
+  const { uid, contact_id } = req;
+  try {
+    var contact_doc = await get_contact(uid, contact_id);
+    if (contact_doc.stat !== 5) {
+      throw new Error('A document can only be deleted after it has been archived');
+    }
+    contact_doc.stat = 4;
+    contact_doc.stat_ts = Date.now();
+    contact_doc.stat_reason = 'deleted by the user';
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+
+    ai_msa.delete_depended_chats(uid, contact_id);
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const unarchive_contact = async function (req, job_id, headers) {
+  const { uid, contact_id } = req;
+  try {
+    var contact_doc = await get_contact(uid, contact_id);
+
+    if (contact_doc.stat !== 5) {
+      throw new Error('contact is not archived');
+    }
+
+    contact_doc.stat = 3;
+    contact_doc.stat_ts = Date.now();
+    contact_doc.stat_reason = 'unarchive by the user';
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+
+    if (!contact_doc.is_spam) {
+      not_spam_contact(req, job_id, headers);
+    }
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const unfriend_contact = async function (req) {
+  const { uid, contact_id } = req;
+  try {
+    let contact_doc = await get_contact(uid, contact_id);
+
+    if (!contact_doc.team_req_id) {
+      throw new Error('no friend relationship found');
+    }
+    let req_doc = await db_module.get_couch_doc_native('xuda_team', contact_doc.team_req_id);
+    req_doc.team_req_stat = 4;
+    req_doc.team_req_stat_desc = 'unfriend by the user';
+    await db_module.get_couch_doc_native('xuda_team', contact_doc.team_req_id);
+
+    contact_doc.team_req_id = null;
+    const contact_save_ret = await save_contact(uid, contact_doc);
+
+    const req_save_ret = await db_module.save_couch_doc('xuda_team', req_doc);
+
+    return req_save_ret;
+  } catch (err) {
+    return {
+      code: -21,
+      data: err.message,
+    };
+  }
+};
+
+export const pin_contact = async function (req) {
+  const { uid, contact_id } = req;
+  try {
+    var contact_doc = await get_contact(uid, contact_id);
+    contact_doc.pinned = true;
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+
+    ws_dashboard_msa.emit_message_to_dashboard({
+      service: 'contact_pinned',
+      to: [uid],
+      data: await get_contact_info(uid, null, contact_id),
+    });
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
+export const set_contact_deep_research = async function (req) {
+  const { uid, contact_id } = req;
+  try {
+    var contact_doc = await get_contact(uid, contact_id);
+    contact_doc.deep_research = true;
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+
+    // attachments transcript
+    // business info
+    // personal info
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
+export const unpin_contact = async function (req) {
+  const { contact_id, uid } = req;
+  try {
+    var contact_doc = await get_contact(uid, contact_id);
+    contact_doc.pinned = false;
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+
+    ws_dashboard_msa.emit_message_to_dashboard({
+      service: 'contact_unpinned',
+      to: [uid],
+      data: await get_contact_info(uid, null, contact_id),
+    });
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
+export const not_spam_contact = async function (req, job_id, headers) {
+  const { contact_id, uid } = req;
+  const account_profile_info = await get_active_account_profile_info(uid);
+  try {
+    var contact_doc = await get_contact(uid, contact_id);
+
+    if (contact_doc.is_spam) {
+      await db_module.save_couch_doc_native('xuda_accounts', {
+        _id: await _common.xuda_get_uuid('spam_whitelist'),
+        uid,
+        docType: 'spam_whitelist',
+        email: contact_doc.email,
+        date_created_ts: Date.now(),
+        stat: 3,
+      });
+    }
+    contact_doc.is_spam = false;
+
+    if (!contact_doc.contact_reference_conversation_id) {
+      const conversation_obj = await ai_ms.create_openai_conversation();
+      contact_doc.contact_reference_conversation_id = conversation_obj.id;
+    }
+
+    const is_business = await ai_ms.is_business_contact(uid, contact_doc.email, contact_doc.name, contact_doc?.metadata?.subject, contact_doc?.metadata?.summarized_body, account_profile_info);
+    contact_doc.account_type = is_business ? 'business' : 'personal';
+    if (is_business) {
+      contact_doc.business_info = await ai_ms.get_business_info(uid, '', contact_doc.email, account_profile_info, { light: true });
+      if (contact_doc.business_info.business_name !== 'Not available') {
+        contact_doc.business_has_person = await ai_ms.is_business_contact_has_person(uid, contact_doc.email, contact_doc.name, contact_doc?.metadata?.subject, contact_doc?.metadata?.summarized_body, account_profile_info);
+      } else {
+        contact_doc.account_type = 'personal';
+        contact_doc.business_info = undefined;
+      }
+    }
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+
+    await delete_xuda_cache(contact_doc);
+    set_contact_profile_picture(uid, contact_doc._id, {}, job_id, headers, account_profile_info, false);
+
+    const emails = await db_module.find_app_couch_query(account_profile_info.app_id, {
+      selector: {
+        docType: 'email',
+        contact_id,
+        stat: 3,
+        process_stat: 'partial',
+      },
+    });
+
+    for await (let email of emails.docs) {
+      const app_id = await get_account_default_project_id(uid);
+      if (email.conversation_id) {
+        db_module.delete_app_couch_doc(app_id, email.conversation_id);
+        email.conversation_id = null;
+      }
+      if (email.conversation_item_id) {
+        db_module.delete_app_couch_doc(app_id, email.conversation_item_id);
+        email.conversation_item_id = null;
+      }
+      const save_ret = await db_module.save_app_couch_doc_native(app_id, email);
+
+      // save attachments
+      // summarized_body
+      req.uid = email.uid;
+      req.email_id = email._id;
+      await email_ms.process_pending_email(req, job_id, headers);
+    }
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
+export const generate_contact_avatar = async function (req, job_id, headers) {
+  const { contact_id, uid } = req;
+  const account_profile_info = await get_active_account_profile_info(uid);
+  try {
+    const account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+    if (account_doc.membership_plan == 'free' && account_doc.ai_workspace_plan == 'free_ai_workspace') {
+      throw new Error('cannot read emails for free account');
+    }
+
+    var contact_doc = await get_contact(uid, contact_id);
+
+    contact_doc.profile_picture_obj = null;
+    contact_doc.profile_picture = null;
+    contact_doc.profile_avatar_obj = null;
+    contact_doc.profile_avatar = null;
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+    await delete_xuda_cache(contact_doc);
+    set_contact_profile_picture(uid, contact_doc._id, {}, job_id, headers, account_profile_info, true);
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
+export const set_deep_research_contact = async function (req, job_id, headers) {
+  const { contact_id, uid } = req;
+  const account_profile_info = await get_active_account_profile_info(uid);
+  try {
+    var contact_doc = await get_contact(uid, contact_id);
+    contact_doc.deep_research = true;
+
+    if (contact_doc.account_type === 'business') {
+      contact_doc.business_info = await ai_ms.get_business_info(uid, '', contact_doc.email, account_profile_info);
+      if (contact_doc.business_info.business_name !== 'Not available') {
+        contact_doc.business_has_person = await ai_ms.is_business_contact_has_person(uid, contact_doc.email, contact_doc.name, contact_doc?.metadata?.subject, contact_doc?.metadata?.summarized_body, account_profile_info);
+      } else {
+        contact_doc.account_type = 'personal';
+        contact_doc.business_info = undefined;
+      }
+    }
+
+    if (contact_doc.account_type === 'personal' || contact_doc?.business_has_person) {
+      contact_doc.person_info = await ai_ms.get_person_info(uid, contact_doc.name, contact_doc.email, account_profile_info, contact_doc?.metadata?.summarized_body);
+      if (!contact_doc.name) {
+        contact_doc.name = await ai_ms.get_name_from_email_addr(uid, contact_doc.email, account_profile_info);
+      }
+    }
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+    await delete_xuda_cache(contact_doc);
+
+    const conversation_items = await db_module.find_app_couch_query(account_profile_info.app_id, {
+      selector: {
+        docType: 'chat_conversation_item',
+        reference_id: contact_id,
+        stat: 3,
+        process_stat: 'partial',
+      },
+    });
+
+    for await (let conversation_item of conversation_items.docs) {
+      try {
+        const account_profile_info = await get_active_account_profile_info(conversation_item.uid);
+        let conversation_doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, conversation_item.conversation_id);
+
+        const transcript = await ai_ms.get_transcript(conversation_item.uid, conversation_item.app_id, conversation_item.conversation_id, account_profile_info, conversation_item.file.filename);
+        let items;
+
+        if (transcript) {
+          items = await ai_ms.add_transcript_conversation_item(conversation_doc.reference_conversation_id, conversation_item.file.filename, transcript);
+
+          conversation_item.text = transcript?.data || transcript || '';
+          conversation_item.process_stat = 'full';
+          const conversation_item_save_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, conversation_item);
+        }
+      } catch (err) {
+        throw err;
+      }
+    }
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+
+export const unset_deep_research_contact = async function (req, job_id, headers) {
+  const { contact_id, uid } = req;
+  const account_profile_info = await get_active_account_profile_info(uid);
+  try {
+    var contact_doc = await get_contact(uid, contact_id);
+    contact_doc.deep_research = false;
+
+    const contact_save_ret = await save_contact(uid, contact_doc);
+    await delete_xuda_cache(contact_doc);
+
+    return contact_save_ret;
+  } catch (err) {
+    return {
+      code: -24,
+      data: err.message,
+    };
+  }
+};
+//////// PROFILES  //////////////
+
+export const get_pending_share_profile_in = async function (uid, _id) {
+  let docs = [];
+  const from_opt = { selector: { docType: 'team_request', access_type: 'account_profile', team_req_stat: 2, team_req_to_uid: uid }, fields: ['_id', 'team_req_date', 'sender_account_info.email', 'team_req_from_uid', 'share_item_id'] };
+
+  if (_id) {
+    to_opt.selector._id = _id;
+  }
+
+  const requests_from_res = await db_module.find_couch_query('xuda_team', from_opt);
+
+  for await (let e of requests_from_res.docs) {
+    const account_profile_info = await get_active_account_profile_info(e.team_req_from_uid);
+    let doc = await db_module.get_app_couch_doc_native(account_profile_info.app_id, e.share_item_id);
+
+    doc.shared_from_uid = e.team_req_from_uid;
+    doc.pending = true;
+    doc = await get_account_profile_info(uid, doc);
+    doc.team_req_id = e._id;
+
+    docs.push(doc);
+  }
+  return docs;
+};
+
+export const get_account_profile_info = async function (uid, contact_profile_doc, _id) {
+  const app_id = await get_account_default_project_id(uid);
+  let doc = contact_profile_doc;
+  if (_id) {
+    doc = await db_module.get_couch_doc_native('xuda_accounts', _id);
+  }
+  doc.notifications = 0;
+
+  let uid_query = uid;
+  if (doc.shared_from_uid) uid_query = doc.shared_from_uid;
+  const account_info_ret = await get_account_name({ uid_query });
+  if (account_info_ret.code < 0) {
+    return;
+  }
+  if (!doc.profile_avatar) {
+    doc.profile_avatar = account_info_ret.data.profile_avatar;
+  }
+  if (!doc.profile_picture) {
+    doc.profile_picture = account_info_ret.data.profile_picture;
+  }
+
+  if (!doc.account_type) {
+    doc.account_type = account_info_ret.data.account_type;
+  }
+
+  const get_pattern = async function (doc) {
+    let ret = `default-pattern.png`;
+
+    if (doc.shared_from_uid) {
+      // const account_profile_doc = await db_module.get_couch_doc_native('xuda_accounts', doc.share_item_id);
+      const shared_from_uid_ret = await get_account_name({ uid_query: doc.shared_from_uid });
+      ret = shared_from_uid_ret.data.profile_avatar;
+    } else if (doc.is_spam) {
+      ret = `spam-pattern.png`;
+    } else if (doc.account_type === 'business') {
+      ret = doc.profile_picture;
+    } else {
+      switch (doc.avatar_source) {
+        case 'fictional':
+          ret = `fictional-avatar-pattern.png`;
+          break;
+
+        case 'ai profile':
+          ret = `fictional-avatar-pattern.png`;
+          break;
+
+        case 'authentic profile':
+          ret = `authentic-avatar-pattern.png`;
+          break;
+
+        default:
+          ret = `xu-pattern.png`;
+          break;
+      }
+    }
+
+    return ret;
+  };
+
+  const get_online = async () => {
+    let online = false;
+    let selector = { docType: 'team_request', team_req_stat: 3, share_item_id: doc._id, access_type: 'account_profile', team_req_from_uid: uid };
+    let ret = await db_module.find_couch_query('xuda_team', { selector });
+    for (const req_obj of ret.docs) {
+      const account_info_ret = await get_account_name({ uid_query: req_obj.team_req_to_uid });
+      online = account_info_ret.data.online;
+      if (online) break;
+    }
+    return online;
+  };
+
+  const stringToColour = (str) => {
+    let hash = 0;
+    // Generate a numeric hash from the string
+    for (let i = 0; i < str.length; i++) {
+      hash = str.charCodeAt(i) + ((hash << 5) - hash);
+    }
+    let colour = '#';
+    // Convert the hash into a 6-digit hex color code
+    for (let i = 0; i < 3; i++) {
+      const value = (hash >> (i * 8)) & 0xff;
+      colour += ('00' + value.toString(16)).substr(-2);
+    }
+    return colour;
+  };
+  const get_members = async (uid, share_item_id) => {
+    let members = [];
+    let selector = { docType: 'team_request', team_req_stat: 3, share_item_id, access_type: 'account_profile', team_req_from_uid: uid };
+    let ret = await db_module.find_couch_query('xuda_team', { selector });
+    for (const req_obj of ret.docs) {
+      const account_info_ret = await get_account_name({ uid_query: req_obj.team_req_to_uid });
+      const info = await await get_contact_info(uid, account_info_ret.data);
+      members.push(info);
+    }
+    return members;
+  };
+
+  const get_user_account_profiles = async () => {
+    // const account_profile_info = await get_active_account_profile_info(uid);
+
+    let selector = { docType: 'account_profile', stat: 3 };
+    let ret = await db_module.find_app_couch_query(app_id, { selector });
+
+    return ret.docs;
+  };
+
+  // Usage examples:
+  // console.log(stringToColour('User A')); // -> Consistent color for "User A"
+  // console.log(stringToColour('Project Z')); // -> Consistent color for "Project Z"
+
+  doc.avatar_source = account_info_ret.data.avatar_source;
+  doc.icon_pattern = await get_pattern(doc);
+  doc.name = doc.profile_name;
+  doc.interactions = 0;
+  doc.chats = 0;
+
+  doc.online = await get_online();
+
+  // doc.border = account_info_ret.data.active_account_profile_id === doc._id ? 'yellow' : ''; //'#1a3557';
+  // doc.border = stringToColour(doc.shared_from_uid || doc.uid);
+  // const chats_ret = await ai_ms.get_ai_chats({ uid, reference_id: doc._id });
+
+  doc.card_background = `linear-gradient(145deg, #242480 0%, #060619 100%)`;
+  // doc.border = get_contact_border(doc);
+
+  doc.members = await get_members(doc.shared_from_uid || doc.uid, doc.share_item_id || doc._id);
+  const user_account_profiles = await get_user_account_profiles();
+
+  const usage_ret = await get_account_ai_usage({ uid: doc.shared_from_uid || doc.uid });
+
+  doc.max_credits = usage_ret?.data?.credits.total / user_account_profiles.length;
+  doc.used_credits = 0;
+  for (const [user, amount] of Object.entries(usage_ret?.data?.usage?.profile?.[doc._id] || {})) {
+    doc.used_credits += amount;
+  }
+
+  // doc.used_credits = usage_ret?.data?.usage?.profile?.[doc._id] || 0;
+
+  if (doc.shared_from_uid) {
+    doc.max_credits = doc.max_credits / (doc.members.length + 1 || 1);
+  }
+
+  return doc;
+};
+
+export const get_account_profiles = async function (req) {
+  const { _id, uid, profile_name, limit, skip, bookmark, search, filter_type = 'all', profile_id, active_tab } = req;
+  const app_id = await get_account_default_project_id(uid);
+  if (_id) {
+    let data = await db_module.get_app_couch_doc(app_id, _id);
+    return data;
+  }
+
+  var opt = {
+    selector: {
+      docType: 'account_profile',
+      uid,
+      stat: { $lt: 4 },
+    },
+    limit: limit || 9999,
+    skip: skip || 0,
+    sort: [{ ts: 'desc' }],
+  };
+
+  switch (filter_type) {
+    case 'archived': {
+      opt.selector.stat = 5;
+      break;
+    }
+    case 'shared': {
+      opt.selector.shared_from_uid = { $gt: null };
+      break;
+    }
+
+    default:
+      break;
+  }
+
+  // if (_id) {
+  //   opt.selector._id = _id;
+  // }
+
+  if (profile_id) {
+    opt.selector._id = profile_id;
+  }
+
+  if (typeof profile_name !== 'undefined') {
+    opt.selector.name = { $regex: `(?i)${profile_name}` };
+  }
+
+  if (typeof search !== 'undefined') {
+    opt.selector['$or'] = [
+      {
+        profile_name: {
+          $regex: `(?i)${search}`,
+        },
+      },
+      {
+        profile_email: {
+          $regex: `(?i)${search}`,
+        },
+      },
+      {
+        _id: {
+          $regex: `(?i)${search}`,
+        },
+      },
+    ];
+  }
+
+  if (bookmark && bookmark !== 'nil') {
+    opt.bookmark = bookmark;
+  }
+
+  let profiles = { docs: [], total_docs: 0 };
+
+  if (filter_type !== 'pending') {
+    profiles = await db_module.find_app_couch_query(app_id, opt);
+    if (!limit || profile_id) {
+      profiles.total_docs = profiles.docs.length;
+    } else {
+      delete opt.sort;
+      delete opt.skip;
+      opt.limit = 9999;
+      opt.fields = ['_id'];
+
+      const counter = await db_module.find_app_couch_query(app_id, opt);
+      profiles.total_docs = counter.docs.length;
+    }
+  }
+
+  let shared_from = { docs: [], total_docs: 0 };
+
+  let profile_docs = { docs: [], total_docs: profiles.total_docs };
+  for await (let doc of profiles.docs) {
+    doc = await get_account_profile_info(uid, doc);
+    if (doc.main) {
+      profile_docs.docs.unshift(doc);
+    } else {
+      profile_docs.docs.push(doc);
+    }
+  }
+
+  if (!profile_id) {
+    if (filter_type === 'pending') {
+      ////// FROM - IN
+      shared_from.docs = await get_pending_share_profile_in(uid);
+      shared_from.total_docs = shared_from.docs.length;
+    }
+  }
+
+  // if (filter_type === 'all' && !profile_id && !search && active_tab && profile_docs.docs.length === 1 && profile_docs.docs[0].main) {
+  //   // return empty state if no custom profile defined by user
+  //   return {
+  //     code: 1,
+  //     data: {
+  //       docs: [],
+  //       total_docs: 0,
+  //     },
+  //   };
+  // }
+
+  return {
+    code: 1,
+    data: {
+      docs: [...shared_from.docs, ...profile_docs.docs],
+      total_docs: shared_from.total_docs + profile_docs.total_docs,
+    },
+  };
+};
+
+export const archive_account_profile = async function (req) {
+  const { uid, profile_id } = req;
+  try {
+    const app_id = await get_account_default_project_id(uid);
+    const account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+
+    // await team_ms.validate_share_exist(uid, 'account_profile', profile_id);
+
+    var account_profile_doc = await db_module.get_app_couch_doc_native(app_id, profile_id);
+
+    if (account_profile_doc.main) {
+      throw new Error('reserve');
+    }
+    // if (!account_profile_doc.team_req_id) {
+    account_profile_doc.stat = 5;
+    account_profile_doc.stat_ts = Date.now();
+    account_profile_doc.stat_reason = 'archived by the user';
+
+    const account_profile_save_ret = await db_module.save_app_couch_doc(app_id, account_profile_doc);
+
+    if (account_doc?.account_info?.active_account_profile_id === profile_id) {
+      account_doc.account_info.active_account_profile_id = account_doc.account_profile_id;
+      await db_module.save_couch_doc('xuda_accounts', account_doc);
+    }
+
+    return account_profile_save_ret;
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const delete_account_profile = async function (req, job_id, headers) {
+  const { profile_id, uid } = req;
+  try {
+    const app_id = await get_account_default_project_id(uid);
+    const account_doc = await db_module.get_couch_doc_native('xuda_accounts', uid);
+
+    await team_ms.validate_share_exist(uid, 'account_profile', profile_id);
+
+    var account_profile_doc = await db_module.get_app_couch_doc_native(app_id, profile_id);
+    if (account_profile_doc.stat !== 5) {
+      throw new Error('A document can only be deleted after it has been archived');
+    }
+    account_profile_doc.stat = 4;
+    account_profile_doc.stat_ts = Date.now();
+    account_profile_doc.stat_reason = 'deleted by the user';
+
+    const account_profile_save_ret = await db_module.save_app_couch_doc(app_id, account_profile_doc);
+
+    if (account_doc?.account_info?.active_account_profile_id === profile_id) {
+      account_doc.account_info.active_account_profile_id = account_doc.account_profile_id;
+      await db_module.save_couch_doc('xuda_accounts', account_doc);
+    }
+
+    ai_msa.delete_depended_chats(uid, profile_id);
+    return account_profile_save_ret;
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const unarchive_account_profile = async function (req) {
+  const { profile_id, uid } = req;
+
+  try {
+    const app_id = await get_account_default_project_id(uid);
+
+    var account_profile_doc = await db_module.get_app_couch_doc_native(app_id, profile_id);
+
+    if (account_profile_doc.stat !== 5) {
+      throw new Error('account profile is not archived');
+    }
+    if (!account_profile_doc.team_req_id) {
+      account_profile_doc.stat = 3;
+      account_profile_doc.stat_ts = Date.now();
+      account_profile_doc.stat_reason = 'archived by the user';
+
+      const account_profile_save_ret = await db_module.save_app_couch_doc(app_id, account_profile_doc);
+
+      return account_profile_save_ret;
+    }
+  } catch (err) {
+    return {
+      code: -22,
+      data: err.message,
+    };
+  }
+};
+
+export const create_account_profile = async function (req, job_id, headers) {
+  const { uid, profile_name, profile_signature, email_account_id, profile_picture, profile_avatar, profile_picture_obj, profile_avatar_obj, main, account_type } = req;
+  try {
+    const app_id = await get_account_default_project_id(uid);
+    // const { data: acc_obj } = await db_module.get_couch_doc('xuda_accounts', uid);
+
+    const d = Date.now();
+    const doc = {
+      _id: await _common.xuda_get_uuid('account_profile'),
+      stat: 3,
+      date_created_ts: d,
+      ts: d,
+      docType: 'account_profile',
+      account_type,
+      uid,
+      profile_name, //: profile_name || acc_obj.account_info.business_name || acc_obj.account_info.name,
+      profile_signature,
+      email_account_id,
+      profile_picture,
+      profile_avatar,
+      profile_picture_obj,
+      profile_avatar_obj,
+      main,
+    };
+    const save_ret = await db_module.save_app_couch_doc(app_id, doc);
+    // acc_obj.active_profile_id = save_ret.data.id;
+
+    // return { code: 55, data: save_ret };
+    return save_ret;
+  } catch (err) {
+    return { code: -55, data: err.message };
+  }
+};
+
+export const update_account_profile = async function (req, job_id, headers) {
+  const { uid, _id } = req;
+  const app_id = await get_account_default_project_id(uid);
+  const account_profile_properties = [
+    'profile_name',
+    'profile_signature',
+    'email_account_id',
+    'profile_picture',
+    'profile_avatar',
+    'profile_picture_obj',
+    'profile_avatar_obj',
+    'auto_respond',
+    'auto_respond_mode',
+    'auto_respond_agents',
+    'account_type',
+    'active_ai_model',
+    'ai_models',
+    'active_agents',
+  ];
+  try {
+    let { data: account_profile_doc } = await db_module.get_app_couch_doc(app_id, _id);
+
+    if (account_profile_doc.docType !== 'account_profile') {
+      throw new Error('not account profile doc');
+    }
+
+    let changes_arr = [];
+
+    for (const key of account_profile_properties) {
+      let val = req[key];
+      if (typeof val === 'undefined') continue;
+      if (account_profile_doc[key] !== val) {
+        changes_arr.push(key);
+        account_profile_doc[key] = val;
+      }
+    }
+
+    if (!changes_arr.length) {
+      // throw new Error('no change');
+      return { code: 56, data: 'no change' };
+    }
+
+    account_profile_doc.ts = Date.now();
+
+    const save_ret = await db_module.save_app_couch_doc(app_id, account_profile_doc);
+
+    return { code: 56, data: save_ret };
+  } catch (err) {
+    return { code: -56, data: err.message };
+  }
+};
+
+export const update_entity_account_profiles = async function (req, job_id, headers) {
+  const { uid, _id, account_profiles = [] } = req;
+  const app_id = await get_account_default_project_id(uid);
+
+  try {
+    if (!account_profiles.length) {
+      throw new Error('account_profiles cannot be empty');
+    }
+
+    let doc = await db_module.get_app_couch_doc_native(app_id, _id);
+
+    switch (doc.docType) {
+      case 'chat_conversation':
+      case 'contact': {
+        doc.account_profiles = account_profiles;
+        break;
+      }
+
+      case 'studio': {
+        //mini_app //ai_agent
+        if (doc.studio_meta.miniApp || doc.properties.menuType === 'ai_agent') {
+          doc.studio_meta.account_profiles = account_profiles;
+          break;
+        }
+      }
+
+      default:
+        throw new Error('entity not supported');
+        break;
+    }
+
+    const save_ret = await db_module.save_app_couch_doc(app_id, doc);
+
+    return { code: 57, data: save_ret };
+  } catch (err) {
+    return { code: -57, data: err.message };
+  }
+};
+
+export const get_contact = async function (uid, contact_id) {
+  if (!contact_id) return null;
+  const account_profile_info = await get_active_account_profile_info(uid);
+
+  const contact_ret = await db_module.get_app_couch_doc_native(account_profile_info.app_id, contact_id);
+  return contact_ret;
+};
+
+export const save_contact = async function (uid, contact_doc) {
+  const account_profile_info = await get_active_account_profile_info(uid);
+  const contact_ret = await db_module.save_app_couch_doc(account_profile_info.app_id, contact_doc);
+  return contact_ret;
+};
+
+export const find_contact_query = async function (uid, opt) {
+  // const app_id = await get_account_default_project_id(uid);
+  const account_profile_info = await get_active_account_profile_info(uid);
+  const ret = await db_module.find_app_couch_query(account_profile_info.app_id, opt);
+  return ret;
+};
+
+//////////////////////////////
+
+export const delete_xuda_cache = async function (contact_obj) {
+  const ret = await db_module.find_couch_query('xuda_cache', {
+    selector: {
+      $or: [
+        {
+          key: contact_obj?.business_info?.business_domain?.toLowerCase() || '',
+        },
+        { key: contact_obj?.business_info?.business_name?.toLowerCase() || '' },
+        { key: `${contact_obj?.business_info?.business_category?.toLowerCase() || ''} ${contact_obj?.business_info?.business_sub_category?.toLowerCase() || ''}` },
+        { key: contact_obj?.email?.toLowerCase() || '' },
+      ],
+    },
+  });
+
+  for (let doc of ret.docs) {
+    doc._deleted = true;
+    const save_ret = await db_module.save_couch_doc('xuda_cache', doc);
+  }
+};
+
+export const save_xuda_cache = async function (uid, docType, key, file, metadata = {}) {
+  if (!key || typeof key !== 'string') return null;
+
+  const cache = await get_xuda_cache(uid, docType, key);
+  if (cache) return;
+
+  const keyWords = key
+    .trim()
+    .toLowerCase()
+    .split(/\s+/)
+    .filter((w) => w.length > 1)
+    .filter((w, i, arr) => arr.indexOf(w) === i); // deduplicate
+
+  let doc = {
+    _id: await _common.xuda_get_uuid('cache'),
+    key: key.toLowerCase().trim(),
+    docType,
+    uid,
+    file,
+    date_created_ts: Date.now(),
+    metadata,
+    hits: 0,
+    keyWords,
+  };
+  const save_ret = await db_module.save_couch_doc('xuda_cache', doc);
+  return save_ret;
+};
+
+export const get_xuda_cache = async function (uid, docType, key, return_property) {
+  let ret = await db_module.find_couch_query('xuda_cache', {
+    selector: { docType, key: key.toLowerCase().trim() },
+    limit: 1,
+  });
+  if (ret.docs.length) {
+    save_cache_hit(ret.docs[0]._id);
+    return (return_property ? ret.docs[0]?.[return_property] : ret.docs[0]) ?? null;
+  }
+
+  return null;
+
+  // ret = await db_module.find_couch_query('xuda_cache', {
+  //   selector: { docType, name: name.trim() },
+  //   limit: 1,
+  // });
+  // if (ret.docs.length) {
+  //   save_cache_hit(ret.docs[0]._id);
+  //   return (return_property ? ret.docs[0]?.[return_property] : ret.docs[0]) ?? null;
+  // }
+};
+
+export const save_cache_hit = async function (_id) {
+  let doc_ret = await db_module.get_couch_doc('xuda_cache', _id);
+  if (doc_ret.code > -1) {
+    doc_ret.data.hits++;
+    await db_module.save_couch_doc('xuda_cache', doc_ret.data);
+  }
+};
+
+///////////////////////////////
+
+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;
+  try {
+    const app_id = await get_account_default_project_id(uid);
+
+    // const timestamp_from = new Date(Number(year_from) || year, (Number(month_from) || month) - 1, Number(day_from) || day).getTime();
+    // const timestamp_to = new Date(Number(year_to) || year, (Number(month_to) || month) - 1, Number(day_to) || day).getTime();
+
+    // BEGINNING OF DAY (00:00:00.000)
+    const timestamp_from = new Date(Number(year_from), Number(month_from) - 1, Number(day_from)).setHours(0, 0, 0, 0);
+
+    // END OF DAY (23:59:59.999)
+    const timestamp_to = new Date(Number(year_to), Number(month_to) - 1, Number(day_to)).setHours(23, 59, 59, 999);
+
+    const query = {
+      // include_docs: true,
+      startkey: [uid, timestamp_from],
+      endkey: [uid, timestamp_to],
+      // reduce: true,
+      // group_level: 999,
+    };
+    const response = await db_module.call_list_function('xuda_usage', 'ai_usage2', 'filter_usage', query);
+
+    // console.log('ai_usage', ai_usage.rows);
+
+    let total_usage = response.total_usage;
+    let profile = response.profiles;
+
+    const ai_credits = await db_module.get_couch_view('xuda_billing', 'ai_credits', {
+      startkey: [uid, ''],
+      endkey: [uid, 'zzz'],
+      reduce: true,
+      group_level: 999,
+    });
+
+    let credits_obj = {},
+      total_credits = 0;
+    for (const row of ai_credits.data.rows) {
+      const user = row.key[0];
+      const source = row.key[1];
+
+      const credits = row.value;
+
+      total_credits += credits;
+
+      if (!credits_obj[source]) {
+        credits_obj[source] = 0;
+      }
+      credits_obj[source] += credits;
+    }
+
+    let data = { credits: { ...credits_obj, total: total_credits }, usage: { profile, projects: [], total: total_usage }, packs: _conf.ai_credit_packs || [] };
+
+    if (job_id) {
+      data.profile_info = {};
+      data.user_info = {};
+      for (const [key, val] of Object.entries(data?.usage?.profile || {})) {
+        try {
+          data.profile_info[key] = (await db_module.get_app_couch_doc_native(app_id, key))?.profile_name;
+
+          for (const [user_id, val2] of Object.entries(val || {})) {
+            try {
+              const account_info = (await db_module.get_couch_doc_native('xuda_accounts', user_id)).account_info;
+              data.user_info[user_id] = account_info.account_type === 'business' ? account_info.business_name : `${account_info.first_name} ${account_info.last_name}`;
+            } catch (error) {}
+          }
+        } catch (error) {}
+      }
+    }
+
+    return { code: 55, data };
+  } catch (err) {
+    return { code: -55, data: err.message };
+  }
+};
+
+export const get_account_ai_usage_old = async function (req, job_id, headers) {
+  const { uid, year_from, month_from, day_from, year_to, month_to, day_to } = req;
+  try {
+    const app_id = await get_account_default_project_id(uid);
+
+    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 ai_usage = await db_module.get_couch_view('xuda_usage', 'ai_usage', {
+      startkey: [uid, year_from || curr_year, month_from || curr_month, day_from || 0],
+      endkey: [uid, year_to || curr_year, month_to || curr_month, day_to || 99],
+      reduce: true,
+      group_level: 999,
+    });
+    // console.log('ai_usage', ai_usage.rows);
+    debugger;
+    let total_usage = 0;
+    let profile = {};
+
+    for (const row of ai_usage.data.rows) {
+      const user = row.key[0];
+      const year = row.key[1];
+      const month = row.key[2];
+      const day = row.key[3];
+      const account_profile_id = row.key[4];
+      const uid = row.key[5];
+      const model = row.key[6];
+      const input_tokens = row.value[0];
+      const output_tokens = row.value[1];
+      const input_credits = row.value[2];
+      const output_credits = row.value[3];
+      if (!profile[account_profile_id]) {
+        profile[account_profile_id] = {};
+      }
+      if (!profile[account_profile_id][uid]) {
+        profile[account_profile_id][uid] = 0;
+      }
+
+      profile[account_profile_id][uid] += input_credits + output_credits;
+      total_usage += input_credits + output_credits;
+    }
+
+    // let membership_plan = _conf.PLAN_OBJ?.[acc_obj?.ai_workspace_plan]?.features?.ai_credits || 0;
+    // let ai_workspace_plan = _conf.PLAN_OBJ?.[acc_obj?.membership_plan]?.features?.ai_credits || 0;
+    // let contact_connection = 0;
+    // let total_credits = membership_plan + ai_workspace_plan + contact_connection;
+
+    const ai_credits = await db_module.get_couch_view('xuda_billing', 'ai_credits', {
+      startkey: [uid, ''],
+      endkey: [uid, 'zzz'],
+      reduce: true,
+      group_level: 999,
+    });
+
+    let credits_obj = {},
+      total_credits = 0;
+    for (const row of ai_credits.data.rows) {
+      const user = row.key[0];
+      const source = row.key[1];
+
+      const credits = row.value;
+
+      total_credits += credits;
+
+      if (!credits_obj[source]) {
+        credits_obj[source] = 0;
+      }
+      credits_obj[source] += credits;
+    }
+
+    let data = { credits: { ...credits_obj, total: total_credits }, usage: { profile, projects: [], total: total_usage }, packs: _conf.ai_credit_packs || [] };
+
+    if (job_id) {
+      data.profile_info = {};
+      data.user_info = {};
+      for (const [key, val] of Object.entries(data?.usage?.profile || {})) {
+        try {
+          data.profile_info[key] = (await db_module.get_app_couch_doc_native(app_id, key))?.profile_name;
+
+          for (const [user_id, val2] of Object.entries(val || {})) {
+            try {
+              data.user_info[user_id] = (await db_module.get_couch_doc_native('xuda_accounts', user_id))?.account_info?.full_name;
+            } catch (error) {}
+          }
+        } catch (error) {}
+      }
+    }
+
+    return { code: 55, data };
+  } catch (err) {
+    return { code: -55, data: err.message };
+  }
+};
+
+// 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');
+
+    const cost = _conf?.ai_models?.[model] || {
+      input: 1.0,
+      output: 1.0,
+    };
+
+    const t = Date.now();
+    let usage_doc = {
+      _id: await _common.xuda_get_uuid('ai_usage'),
+      docType: 'ai_usage',
+      prompt: typeof prompt === 'string' ? prompt.substr(0, 40) : '',
+      date_created_ts: t,
+      uid,
+      source,
+      input_tokens,
+      output_tokens,
+      stat: 3,
+      metadata,
+      model,
+      cost,
+      account_profile_info,
+      tools,
+    };
+    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);
+  }
+};
+
+export const record_ai_credit = async function (uid, credits = 0, source, details, credited_uid) {
+  try {
+    var dup = await db_module.find_couch_query('xuda_billing', {
+      selector: {
+        docType: 'ai_credit',
+        credited_uid,
+        details,
+      },
+      fields: ['_id'],
+      limit: 1,
+    });
+
+    if (dup.docs.length) {
+      throw new Error(`${details} - already credited!`);
+    }
+
+    const t = Date.now();
+    let credit_doc = {
+      _id: await _common.xuda_get_uuid('ai_credit'),
+      docType: 'ai_credit',
+      credits,
+      date_created_ts: t,
+      uid,
+      source,
+      stat: 3,
+      credited_uid,
+      details,
+    };
+    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!')) {
+      console.error(err);
+    }
+    return { code: -78, data: err.message };
+  }
+};
+
+export const add_ai_credits_to_active_accounts = async function () {
+  let d = new Date();
+
+  let date_str = d.toLocaleDateString('en-US', {
+    month: 'long',
+    day: 'numeric',
+    year: 'numeric',
+  });
+
+  const _24_hr_ms = 1000 * 60 * 60 * 24;
+  const active_accounts = await db_module.find_couch_query('xuda_accounts', { selector: { stat: 3, docType: 'account', last_free_daily_ai_credit_ts: { $lt: Date.now() - _24_hr_ms }, ai_workspace_plan: 'free_ai_workspace' }, limit: 99999 });
+  for await (let account_doc of active_accounts.docs) {
+    const ret = await record_ai_credit('system', 1, 'daily credit', 'free daily credit ' + date_str, account_doc._id);
+    if (ret.code > -1) {
+      account_doc.last_free_daily_ai_credit_ts = Date.now();
+      account_doc.last_free_daily_ai_credit_id = ret.data.id;
+      const save_ret = await db_module.save_couch_doc('xuda_accounts', account_doc);
+    }
+  }
+};
+
+export const archive_expire_ai_credits = async function () {
+  const _24_hr_ms = 1000 * 60 * 60 * 24;
+  const _mo_ms = _24_hr_ms * 30;
+
+  const active_ai_credits = await db_module.find_couch_query('xuda_billing', { selector: { stat: 3, docType: 'ai_credit', date_created_ts: { $lt: Date.now() - _mo_ms } }, limit: 99999 });
+  for await (let ai_credit_doc of active_ai_credits.docs) {
+    ai_credit_doc.stat = 5;
+    ai_credit_doc.stat_ts = Date.now();
+    ai_credit_doc.stat_reason = 'expired';
+    const save_ret = await db_module.save_couch_doc('xuda_billing', ai_credit_doc);
+  }
+};
+
+export const read_accounts_emails = async function () {
+  const active_accounts = await db_module.find_couch_query('xuda_accounts', { selector: { stat: 3, docType: 'account' }, limit: 99999 });
+  for await (let account_doc of active_accounts.docs) {
+    if (!account_doc?.account_info?.active_account_profile_id) continue;
+    if (account_doc.membership_plan == 'free' && account_doc.ai_workspace_plan == 'free_ai_workspace') continue;
+    email_msa.refresh_mailboxes({ uid: account_doc._id });
+  }
+};
+
+export const process_accounts_emails = async function () {
+  const active_accounts = await db_module.find_couch_query('xuda_accounts', { selector: { stat: 3, docType: 'account' }, limit: 99999 });
+  for await (let account_doc of active_accounts.docs) {
+    if (!account_doc?.account_info?.active_account_profile_id) continue;
+    email_msa.process_emails({ uid: account_doc._id });
+  }
+};
+
+const isLikelySpamEmail = async function (email) {
+  const spam_whitelists = await db_module.find_couch_query('xuda_accounts', {
+    selector: {
+      docType: 'spam_whitelist',
+      email,
+      stat: 3,
+    },
+    limit: 1,
+  });
+  if (spam_whitelists.docs.length) return false;
+
+  if (!email || typeof email !== 'string') return true;
+
+  const lower = email.toLowerCase().trim();
+
+  // Must have exactly one @ and non-empty parts
+  if (!lower.includes('@') || lower.split('@').length !== 2) return true;
+
+  const [localPart, domain] = lower.split('@');
+
+  if (!localPart || !domain) return true;
+
+  // 1. Obvious syntax/format red flags (unchanged — strict is good here)
+  if (localPart.length > 64 || domain.length > 255 || localPart.startsWith('.') || localPart.endsWith('.') || localPart.includes('..') || domain.includes('..') || domain.startsWith('-') || domain.endsWith('-') || /[^\w.!#$%&'*+/=?^`{|}~-]/.test(localPart)) {
+    return true;
+  }
+
+  // 2. Common spam patterns (unchanged — these are strong signals)
+  const spamPatterns = [
+    /\d{8,}/, // long consecutive digits
+    /[a-z]{20,}/, // very long random lowercase
+    /unsubscribe/i,
+    /free|win|bonus|deal|promo/i,
+    /\+\d+$/,
+    /^[\d\W_]+$/,
+  ];
+
+  if (spamPatterns.some((p) => p.test(localPart))) {
+    return true;
+  }
+
+  // 3. Free / major disposable providers — RELAXED
+  const freeOrDisposableDomains = new Set([
+    'gmail.com',
+    'yahoo.com',
+    'hotmail.com',
+    'outlook.com',
+    'aol.com',
+    'icloud.com',
+    'proton.me',
+    'protonmail.com',
+    'mail.com',
+    'yandex.com',
+    'ymail.com',
+    'rocketmail.com',
+    'gmx.com',
+    'gmx.net',
+    'web.de',
+    'live.com',
+    'msn.com',
+    'inbox.com',
+    'zoho.com',
+    'tutanota.com',
+    'tempmail.com',
+    '10minutemail.com',
+    'guerrillamail.com',
+    'trashmail.com',
+    'mailinator.com',
+    'yopmail.com',
+    'sharklasers.com',
+    // Consider dynamic loading for real disposables (see comment above)
+  ]);
+
+  if (freeOrDisposableDomains.has(domain)) {
+    const cleanLocal = localPart.split('+')[0].toLowerCase(); // ignore +tag
+
+    // Expanded serious/role keywords
+    const roleKeywords = ['info', 'support', 'sales', 'contact', 'hello', 'team', 'admin', 'office', 'billing', 'help', 'service', 'orders', 'bookings', 'quotes', 'enquiries', 'noreply', 'no-reply'];
+
+    // New: business/service descriptive keywords (very common for small trades on Gmail)
+    const businessKeywords = [
+      'locksmith',
+      'doors',
+      'garage',
+      'repair',
+      'pro',
+      'expert',
+      '247',
+      '24hr',
+      'emergency',
+      'mobile',
+      'auto',
+      'key',
+      'security',
+      'home',
+      'commercial',
+      'residential',
+      'plumbing',
+      'electric',
+      'hvac',
+      'cleaning',
+      'pest',
+      'movers',
+      'towing',
+      'tutor',
+      // Add more relevant to your audience/use-case
+    ];
+
+    const allKeywords = [...roleKeywords, ...businessKeywords];
+
+    // Check if any segment contains a keyword
+    const parts = cleanLocal.split(/[\.-]/);
+    const looksTrusted = allKeywords.some((kw) => parts.some((part) => part.includes(kw)) || cleanLocal.includes(kw));
+
+    if (looksTrusted) {
+      return false; // early pass for role or descriptive business names
+    }
+
+    // Relaxed extra scrutiny
+    if (cleanLocal.length > 32 || /\d{8,}/.test(cleanLocal)) {
+      // ← raised thresholds
+      return true;
+    }
+
+    return false; // default: allow most personal / semi-descriptive Gmail use
+  }
+
+  // 4. Very short / meaningless / bot-like — SLIGHTLY relaxed
+  if (localPart.length < 2 || /^[a-z\d]{1,6}$/.test(localPart)) {
+    // ← up to 6 chars
+    return true;
+  }
+
+  // 5. Suspicious TLDs (unchanged — still useful)
+  const suspiciousTlds = ['.top', '.xyz', '.club', '.online', '.site', '.fun', '.buzz', '.shop', '.store', '.live', '.digital', '.monster'];
+  if (suspiciousTlds.some((tld) => domain.endsWith(tld))) {
+    return true;
+  }
+
+  // Extra: very long local parts (unchanged)
+  if (localPart.length > 40) {
+    return true;
+  }
+
+  // Passed → likely legitimate
+  return false;
+};
+
+setTimeout(async () => {
+  const uid = 'd39126e0e2c51ffbd1aad10709fc8335';
+  // onboarding_completed({ uid });
+}, 2000);