@xuda.io/account_module 1.2.2313 → 1.2.2315

package/index.mjs

@@ -670,10 +670,33 @@ export const get_effective_entitlements = function (account_doc) {
 //                    to where it is set.
 // scope 'metered'  → no plan ladder at all, usage is metered per call. Listed
 //                    so the customer can see it costs no subscription.
+//
+// `is_active`   → the module is being PAID for. Defaults to price > 0.
+// `is_activated`→ the customer switched it ON, Free included. Defaults to
+//                 `is_active` or a `<field>_changed` stamp, and a module that
+//                 keeps its own answer to that question says so here rather
+//                 than leaving the UI to guess from a price of zero.
 const _MODULE_SUBSCRIPTIONS = [
-  { key: 'commerce', scope: 'account', field: 'commerce_plan', default_plan: 'commerce_free' },
+  // UI-192: `commerce_plan` being SET at all is Commerce's own on/off switch
+  // (`chosen` in commerce_module _cm_plan), which is why activation is read off
+  // the field rather than off the stamp: commerce_set_plan wrote the plan and
+  // stamped nothing until this same change, so every account that switched
+  // Commerce on at its free tier reported "not switched on" here while its own
+  // screen showed the stores.
+  { key: 'commerce', scope: 'account', field: 'commerce_plan', default_plan: 'commerce_free', is_activated: (a) => !!a.commerce_plan },
   { key: 'shipping', scope: 'account', field: 'shipping_plan', default_plan: 'shipping_free' },
-  { key: 'finance', scope: 'account', field: 'finance_plan', default_plan: 'finance_free' },
+  // UI-192: an account can be USING Finance without ever having been through the picker —
+  // finance accounts predate the ladder, and info@xuda.ai holds two of them with no
+  // `finance_plan` at all. Reporting that as "not switched on" put the module behind a
+  // pitch for the customer already invoicing through it. Both markers sit on the account
+  // document, so this costs no extra read.
+  {
+    key: 'finance',
+    scope: 'account',
+    field: 'finance_plan',
+    default_plan: 'finance_free',
+    is_activated: (a) => !!(a.finance_plan || a.finance_plan_changed || a.finance_active || a.finance_account_id),
+  },
   // The desk screen has its own copy of this ladder (UI-82), because Tickets is
   // switched on there as well as here. Both call tickets_set_plan, so the plan
   // is one line item on the consolidated subscription either way.
@@ -681,12 +704,17 @@ const _MODULE_SUBSCRIPTIONS = [
   // UI-104: email is its own product, billed per mailbox tier. Its plan lives on the
   // account as an OBJECT (`email_plan.tier`), which is why it resolves rather than
   // reading a field, and `set_email_plan` is what moves it.
+  // UI-192: and its "the customer chose this" marker is `email_plan.activated_ts`, not
+  // an `email_plan_changed` field, which is email_policy's own `chosen`. The generic
+  // stamp lookup never found anything, so an account on a deliberately free mailbox
+  // tier read as switched off.
   {
     key: 'email',
     scope: 'account',
     field: 'email_plan',
     default_plan: 'email_free',
     resolve: (a) => (a && a.email_plan && a.email_plan.tier ? `email_${a.email_plan.tier}` : ''),
+    changed_of: (a) => (a && a.email_plan && a.email_plan.activated_ts) || null,
   },
   // Auto response is the single gate for whether the AI answers, on every channel
   // (chat, the public chat widget, email and the phone). It is account scoped and
@@ -930,13 +958,14 @@ export const get_module_subscriptions = async function (req = {}) {
     if (ar.code < 0 || !ar.data) return { code: -404, data: 'account not found' };
     const account = ar.data;
     const plans = _conf.PLAN_OBJ || {};
-    // A category is only offerable once its paid tiers carry a real Stripe
-    // price, otherwise "activate" would set a plan nobody is billed for. A module
-    // whose money is NOT a plan line item says so itself (phone), because for those
-    // an absent price_id is the design, not a gap.
-    const billable = (m) =>
-      m.billable === true ||
-      Object.values(plans).some((p) => p.category === m.key && Number(p.price) > 0 && p.price_id && !/TODO/.test(p.price_id));
+    // A category is offerable once it has a paid tier with a real amount on it. It used to
+    // also demand a hand-made Stripe price behind that tier, which is what left Commerce,
+    // Shipping and Finance reading "Coming soon" on the create screen while their products
+    // were finished and shipped: stripe_module now mints the price from the catalog the
+    // first time a tier is bought (_resolve_plan_price), so a placeholder price id is no
+    // longer a reason to take a module off the shelf. A module whose money is not a plan
+    // line item at all still says so itself (phone charges the number).
+    const billable = (m) => m.billable === true || Object.values(plans).some((p) => p.category === m.key && Number(p.price) > 0);
 
     const resource_items = await _module_resource_items(uid);
 
@@ -952,9 +981,14 @@ export const get_module_subscriptions = async function (req = {}) {
         // `plan_of` keeps reporting no plan, exactly as before.
         const plan_id = m.plan_of ? m.plan_of(account) : '';
         const plan = plans[plan_id] || {};
+        const active = m.is_active ? !!m.is_active(account, base.items) : m.scope === 'metered' || base.items.length > 0;
         return {
           ...base,
-          active: m.is_active ? !!m.is_active(account, base.items) : m.scope === 'metered' || base.items.length > 0,
+          active,
+          // UI-192: a per-resource module has no free tier to be switched on at, so
+          // paying for one of the things IS being switched on. Sent all the same, so
+          // every surface can ask the one question rather than two.
+          activated: m.is_activated ? !!m.is_activated(account, base.items) : active,
           included: m.scope === 'metered',
           plan_id,
           plan_name: plan.name || '',
@@ -977,6 +1011,11 @@ export const get_module_subscriptions = async function (req = {}) {
         ? { to_plan: pc.to_plan, to_name: plans[pc.to_plan]?.name || pc.to_plan, effective: pc.effective || null }
         : null;
       const price = Number(plan.price) || 0;
+      // Every *_set_plan method stamps `<field>_changed` when the customer picks a
+      // tier, Free included, so this is the general answer to "have they been through
+      // the picker". A module whose marker is somewhere else brings its own resolver.
+      const changed_ts = (m.changed_of ? m.changed_of(account) : account[`${m.field}_changed`]) || null;
+      const active = m.is_active ? !!m.is_active(account, base.items) : price > 0;
       return {
         ...base,
         plan_id,
@@ -985,10 +1024,16 @@ export const get_module_subscriptions = async function (req = {}) {
         // UI-110: paying is the default proof that a module is on, but a module that
         // records the customer CHOOSING a tier says so itself, because a deliberate
         // free tier is switched on and a price of zero cannot tell the two apart.
-        active: m.is_active ? !!m.is_active(account, base.items) : price > 0,
+        active,
+        // UI-192 (Boaz, on the create sheet's switches): "switched on" as its own
+        // answer, so no surface has to reassemble it out of `active` and `changed_ts`
+        // and get it differently from the next one. Picking a FREE tier is switching
+        // the module on: it is a real tier, it opens the module's screen and it puts
+        // the module in the menu, and the switch that did it has to stay flipped.
+        activated: m.is_activated ? !!m.is_activated(account, base.items) : !!(active || changed_ts),
         included: false,
         pending,
-        changed_ts: account[`${m.field}_changed`] || null,
+        changed_ts,
       };
     });
     return { code: 1, data: { modules, membership_plan: account.membership_plan || 'free' } };
@@ -7124,6 +7169,9 @@ export const archive_account_profile = async function (req) {
       await db_module.save_couch_doc('xuda_accounts', account_doc);
     }
 
+    // UI-202
+    log_profile_activity(uid, profile_id, 'archived', { by: 'user', reason: account_profile_doc.stat_reason }, app_id);
+
     return account_profile_save_ret;
   } catch (err) {
     return {
@@ -7157,6 +7205,10 @@ export const delete_account_profile = async function (req, job_id, headers) {
     }
 
     ai_msa.delete_depended_chats(uid, profile_id);
+
+    // UI-202: the last row this profile gets.
+    log_profile_activity(uid, profile_id, 'deleted', { by: 'user', reason: account_profile_doc.stat_reason, note: 'the chats that hung off this profile were deleted with it' }, app_id);
+
     return account_profile_save_ret;
   } catch (err) {
     return {
@@ -7184,6 +7236,9 @@ export const unarchive_account_profile = async function (req) {
 
       const account_profile_save_ret = await db_module.save_app_couch_doc(app_id, account_profile_doc);
 
+      // UI-202
+      log_profile_activity(uid, profile_id, 'unarchived', { by: 'user' }, app_id);
+
       return account_profile_save_ret;
     }
   } catch (err) {
@@ -7221,6 +7276,9 @@ export const create_account_profile = async function (req, job_id, headers) {
     const save_ret = await db_module.save_app_couch_doc(app_id, doc);
     // acc_obj.active_profile_id = save_ret.data.id;
 
+    // UI-202: the first row of this profile's trail.
+    log_profile_activity(uid, doc._id, 'created', { by: 'user', name: profile_name, type: account_type, main: !!main, mailbox: !!email_account_id }, app_id);
+
     // return { code: 55, data: save_ret };
     return save_ret;
   } catch (err) {
@@ -7257,12 +7315,17 @@ export const update_account_profile = async function (req, job_id, headers) {
     }
 
     let changes_arr = [];
+    // UI-202: the previous values of the fields this edit touches, so the trail can say what
+    // it changed FROM as well as to. Taken inside the same loop that detects the change, so
+    // it costs nothing and cannot drift from changes_arr.
+    const previous_values = {};
 
     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);
+        previous_values[key] = account_profile_doc[key];
         account_profile_doc[key] = val;
       }
     }
@@ -7276,6 +7339,27 @@ export const update_account_profile = async function (req, job_id, headers) {
 
     const save_ret = await db_module.save_app_couch_doc(app_id, account_profile_doc);
 
+    // UI-202: one row naming the fields that moved, with the values of the ones that read
+    // as values (a signature and an avatar url do not). Auto response gets its OWN row on
+    // top: it is the switch that decides whether this profile answers mail by itself, so
+    // "auto response" buried in a list of six field names is not good enough.
+    const changed = changes_arr.map((key) => PROFILE_FIELD_LABELS[key] || key.replace(/_/g, ' '));
+    const values = {};
+    for (const key of changes_arr) {
+      if (PROFILE_FIELDS_WITH_VALUES.has(key)) values[PROFILE_FIELD_LABELS[key] || key] = String(account_profile_doc[key] ?? '').slice(0, 120);
+    }
+    log_profile_activity(uid, _id, 'updated', { by: 'user', changed: [...new Set(changed)], values, previous_name: changes_arr.includes('profile_name') ? previous_values.profile_name : undefined }, app_id);
+
+    if (changes_arr.includes('auto_respond')) {
+      log_profile_activity(
+        uid,
+        _id,
+        account_profile_doc.auto_respond ? 'auto_respond_on' : 'auto_respond_off',
+        { by: 'user', mode: account_profile_doc.auto_respond_mode, agents: (account_profile_doc.auto_respond_agents || []).length },
+        app_id
+      );
+    }
+
     return { code: 56, data: save_ret };
   } catch (err) {
     return { code: -56, data: err.message };
@@ -7371,6 +7455,135 @@ const log_contact_activity = async function (uid, contact_id, event, detail = {}
   }
 };
 
+// ─── UI-202: the account profile activity trail ───────────────────────────────────────
+// The fourth of the same family (contacts UI-134, agents and chats UI-194/195), same shape
+// because one panel renders all of them. A profile doc keeps the current answer to every
+// question and nothing about when it changed, and a profile is the thing that answers mail
+// on its own: "when was auto respond switched on", "which agents were attached", "who
+// changed the signature" had no trace at all.
+//
+// Append-only, never awaited, and a failure to write it can never fail the action it
+// records. Lives in the same app db as the profile.
+const log_profile_activity = async function (uid, profile_id, event, detail = {}, app_id) {
+  try {
+    if (!uid || !profile_id || !event) return null;
+    const app = app_id || (await get_account_default_project_id(uid));
+    if (!app) return null;
+
+    return await db_module.save_app_couch_doc_native(app, {
+      _id: await _common.xuda_get_uuid('profile_activity'),
+      docType: 'profile_activity',
+      profile_id,
+      uid,
+      event,
+      detail,
+      ts: Date.now(),
+      stat: 3,
+    });
+  } catch (err) {
+    console.error('[account_module] profile activity not recorded:', event, profile_id, err?.message || err);
+    return null;
+  }
+};
+
+// The cross-module door: ai_module regenerates a profile's avatar, team_module shares one.
+export const log_account_profile_activity = async function (req) {
+  const { uid, profile_id, event, detail, app_id } = req || {};
+  const ret = await log_profile_activity(uid, profile_id, event, detail || {}, app_id);
+  return { code: ret ? 1 : 0, data: ret ? { profile_id, event } : 'not recorded' };
+};
+
+// Field names the edit row prints, and the ones whose VALUE is safe and useful to print
+// with them. A signature is free text and an avatar is a url, so those travel as the fact
+// that they changed; a name, a mode or a model is the whole point of the row.
+const PROFILE_FIELD_LABELS = {
+  profile_name: 'name',
+  profile_signature: 'signature',
+  email_account_id: 'mailbox',
+  profile_picture: 'picture',
+  profile_avatar: 'avatar',
+  profile_picture_obj: 'picture',
+  profile_avatar_obj: 'avatar',
+  auto_respond: 'auto response',
+  auto_respond_mode: 'auto response mode',
+  auto_respond_agents: 'auto response agents',
+  account_type: 'type',
+  active_ai_model: 'model',
+  ai_models: 'models',
+  active_agents: 'agents',
+  email_template: 'email template',
+};
+const PROFILE_FIELDS_WITH_VALUES = new Set(['profile_name', 'auto_respond_mode', 'account_type', 'active_ai_model']);
+
+export const get_account_profile_activity = async function (req) {
+  const { uid, profile_id } = req;
+  try {
+    if (!profile_id) throw new Error('profile_id is missing');
+    const app_id = await get_account_default_project_id(uid);
+
+    let profile_doc;
+    try {
+      profile_doc = await db_module.get_app_couch_doc_native(app_id, profile_id);
+    } catch (_) {
+      profile_doc = null;
+    }
+    if (!profile_doc || profile_doc.docType !== 'account_profile') throw new Error(`profile ${profile_id} not found`);
+    if (profile_doc.uid !== uid) throw new Error('Operation not allowed');
+
+    const recorded_ret = await db_module.find_app_couch_query(app_id, {
+      selector: { docType: 'profile_activity', profile_id },
+      limit: 500,
+    });
+    const recorded = (recorded_ret?.docs || []).map((d) => ({ event: d.event, detail: d.detail || {}, ts: d.ts, derived: false }));
+
+    const derived = [];
+    const add = (event, ts, detail) => {
+      if (!ts) return;
+      if (recorded.some((r) => r.event === event)) return;
+      derived.push({ event, detail, ts, derived: true });
+    };
+
+    const created_ts = profile_doc.date_created_ts || profile_doc.ts;
+    add('created', created_ts, { name: profile_doc.profile_name, type: profile_doc.account_type, main: !!profile_doc.main });
+    if (profile_doc.email_account_id) add('mailbox_bound', profile_doc.ts || created_ts, {});
+    if (profile_doc.auto_respond) add('auto_respond_on', profile_doc.ts || created_ts, { mode: profile_doc.auto_respond_mode, agents: (profile_doc.auto_respond_agents || []).length });
+    if (profile_doc.profile_avatar) add('avatar_ready', profile_doc.profile_avatar_stat_ts || profile_doc.ts || created_ts, {});
+    // UI-204: the two public surfaces, reconstructed from the flags they are stored as, so a
+    // profile that has been taking messages from strangers for months says so today rather
+    // than only from the next time somebody toggles it.
+    if (profile_doc.widget_enabled) add('widget_on', profile_doc.ts || created_ts, {});
+    if (profile_doc.contact_form_enabled) add('contact_form_on', profile_doc.ts || created_ts, {});
+    if (profile_doc.shared_from_uid) add('shared_with_you', profile_doc.shared_ts || created_ts, { from_uid: profile_doc.shared_from_uid });
+    if (profile_doc.stat === 5) add('archived', profile_doc.stat_ts, { reason: profile_doc.stat_reason });
+    if (profile_doc.stat === 4) add('deleted', profile_doc.stat_ts, { reason: profile_doc.stat_reason });
+
+    const rows = [...recorded, ...derived].sort((a, b) => (b.ts || 0) - (a.ts || 0));
+
+    return {
+      code: 1,
+      data: {
+        profile_id,
+        current: {
+          name: profile_doc.profile_name || null,
+          stat: profile_doc.stat,
+          main: !!profile_doc.main,
+          type: profile_doc.account_type || null,
+          auto_respond: !!profile_doc.auto_respond,
+          auto_respond_mode: profile_doc.auto_respond_mode || null,
+          mailbox: !!profile_doc.email_account_id,
+          model: profile_doc.active_ai_model || null,
+          agents: (profile_doc.active_agents || []).length,
+          widget: !!profile_doc.widget_enabled,
+          contact_form: !!profile_doc.contact_form_enabled,
+        },
+        rows,
+      },
+    };
+  } catch (err) {
+    return { code: -25, data: err.message };
+  }
+};
+
 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);

package/index_ms.mjs

@@ -493,6 +493,14 @@ export const get_contact = async function (...args) {
   return await broker.send_to_queue("get_contact", ...args);
 };
 
+export const log_account_profile_activity = async function (...args) {
+  return await broker.send_to_queue("log_account_profile_activity", ...args);
+};
+
+export const get_account_profile_activity = async function (...args) {
+  return await broker.send_to_queue("get_account_profile_activity", ...args);
+};
+
 export const save_contact = async function (...args) {
   return await broker.send_to_queue("save_contact", ...args);
 };

package/index_msa.mjs

@@ -493,6 +493,14 @@ export const get_contact =  function (...args) {
    broker.send_to_queue_async("get_contact", ...args);
 };
 
+export const log_account_profile_activity =  function (...args) {
+   broker.send_to_queue_async("log_account_profile_activity", ...args);
+};
+
+export const get_account_profile_activity =  function (...args) {
+   broker.send_to_queue_async("get_account_profile_activity", ...args);
+};
+
 export const save_contact =  function (...args) {
    broker.send_to_queue_async("save_contact", ...args);
 };

package/package.json

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