@xuda.io/account_module 1.2.2276 → 1.2.2277

package/index.mjs

@@ -54,6 +54,8 @@ 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`);
+// Awaitable app handle for the ops termination flow (power off / destroy).
+const app_ms = await import(`${module_path}/app_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`);
@@ -1118,6 +1120,192 @@ export const get_account_info = async function (req) {
   });
 };
 
+// ===================================================================
+// OPS ACCOUNT TERMINATION FLOW (manual, superuser-only)
+// -------------------------------------------------------------------
+// Escalation ladder for non-payment, driven manually from the ops
+// dashboard (never automatic): suspend (services OFF) -> terminate
+// (services OFF + 14-day appeal window) -> finalize (permanent delete)
+// -> or reinstate. Every step notifies ops. `req.uid` is ALWAYS the
+// authenticated ops caller (the HTTP layer overwrites it from the
+// session), so the TARGET account is passed as `account_uid`.
+// ===================================================================
+const _OPS_SERVER_TYPES = ['datacenter', 'deployment', 'vps', 'managed_vps', 'instance', 'master'];
+const _ops_is_super = (req) => !!(req && req.uid && Array.isArray(_conf.superuser_account_ids) && _conf.superuser_account_ids.includes(req.uid));
+const _ops_host = () => (_conf.is_debug ? process.env.XUDA_HOSTNAME || _conf.domain : _conf.domain) || 'xuda.ai';
+const _ops_appeal_days = () => Number(_conf.termination?.appeal_days) || 14;
+
+const _ops_enum_apps = async (uid) => {
+  const ret = await db_module.find_couch_query('xuda_master', { selector: { app_uId: uid, docType: 'app' }, limit: 99999 }, true);
+  return ret.docs || [];
+};
+
+// Turn every server-type service for an account OFF (or back ON). Read the
+// power state via the canonical app_ms wrappers so DO/proxmox teardown is
+// handled correctly. Returns a small tally.
+const _ops_services_power = async (uid, on) => {
+  const servers = (await _ops_enum_apps(uid)).filter((a) => _OPS_SERVER_TYPES.includes(a.app_type));
+  let ok = 0, err = 0;
+  for (const a of servers) {
+    try {
+      const r = on ? await app_ms.turn_app_on({ app_id: a._id }) : await app_ms.turn_app_off({ app_id: a._id });
+      if (!r || r.code < 0) err++; else ok++;
+    } catch (e) { err++; console.error('[ops power]', a._id, e.message); }
+  }
+  return { total: servers.length, ok, err };
+};
+
+// OPS = the superuser accounts + info@xuda.ai. Sends both an email to info@ and
+// a system notification to every superuser. `ref` is shown in a small footer.
+const _ops_notify_ops = (subject, rows, ref) => {
+  try {
+    const esc = (v) => String(v == null ? '' : v).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    const footer = ref ? `<p style="margin:16px 0 0 0;font-size:11px;color:#999">Ref: ${esc(ref)}</p>` : '';
+    const body = `<h2>${esc(subject)}</h2><table cellpadding="6" style="border-collapse:collapse;font-size:14px">${rows.map(([k, v]) => `<tr><td><strong>${esc(k)}</strong></td><td>${esc(v)}</td></tr>`).join('')}</table>${footer}`;
+    email_msa.send_email({ email: 'info@xuda.ai', subject: `[OPS] ${subject}`, body });
+    const supers = _conf.superuser_account_ids || [];
+    if (supers.length) notification_msa.submit_notification({ type: 'system', uid_arr: supers, system: true, subject: `[OPS] ${subject}`, body, delivery_method: ['banner', 'email'], display_type: 'warning' });
+  } catch (e) { console.error('[ops notify]', e.message); }
+};
+
+// Step 1a — SUSPEND: services off, no data loss.
+export const ops_suspend_account = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const account_uid = req.account_uid;
+    if (!account_uid) return { code: -1, data: 'account_uid is required' };
+    const ar = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    if (ar.code < 0 || !ar.data) return { code: -1, data: 'account not found' };
+    const account = ar.data;
+    account.account_suspension_status = 1;
+    account.account_suspension_date = Date.now();
+    account.suspension_reason = req.reason || '';
+    account.suspension_by_uid = req.uid;
+    const sr = await db_module.save_couch_doc('xuda_accounts', account);
+    if (sr.code < 0) return { code: -1, data: sr.data };
+    const power = await _ops_services_power(account_uid, false);
+    const host = _ops_host();
+    notification_msa.submit_notification({ type: 'account', uid_arr: [account_uid], topic: 'health_account_suspended', params: { billing_url: `https://${host}/dashboard/settings/billing` } });
+    _ops_notify_ops(`Account suspended: ${account.account_info?.email || account_uid}`, [['Account', account_uid], ['Email', account.account_info?.email], ['By', req.uid], ['Reason', req.reason || ''], ['Services off', `${power.ok}/${power.total}`]], 'A2');
+    logs_msa.add_account_log({ uid: account_uid, method: 'ops_suspend_account', source: 'ops dashboard', response_status_code: 200, response_data: `suspended by ${req.uid}; services off ${power.ok}/${power.total}` });
+    return { code: 1, data: { suspended: account_uid, services: power } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Step 1b — TERMINATE: services off + start the appeal window. No deletion.
+export const ops_terminate_account = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const account_uid = req.account_uid;
+    if (!account_uid) return { code: -1, data: 'account_uid is required' };
+    const ar = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    if (ar.code < 0 || !ar.data) return { code: -1, data: 'account not found' };
+    const account = ar.data;
+    const appeal_days = _ops_appeal_days();
+    account.account_termination_status = 1;
+    account.account_termination_date = Date.now();
+    account.termination_reason = req.reason || '';
+    account.termination_by_uid = req.uid;
+    account.termination_appeal_deadline = Date.now() + appeal_days * 86400000;
+    account.appeal_status = 'none';
+    account.termination_finalized_ts = null;
+    const sr = await db_module.save_couch_doc('xuda_accounts', account);
+    if (sr.code < 0) return { code: -1, data: sr.data };
+    const power = await _ops_services_power(account_uid, false);
+    const host = _ops_host();
+    notification_msa.submit_notification({ type: 'account', uid_arr: [account_uid], topic: 'health_account_terminated', params: { appeal_days, appeal_url: `https://${host}/dashboard/support` } });
+    _ops_notify_ops(`Account terminated (${appeal_days}d appeal): ${account.account_info?.email || account_uid}`, [['Account', account_uid], ['Email', account.account_info?.email], ['By', req.uid], ['Reason', req.reason || ''], ['Services off', `${power.ok}/${power.total}`], ['Appeal deadline', new Date(account.termination_appeal_deadline).toISOString()]], 'A3');
+    logs_msa.add_account_log({ uid: account_uid, method: 'ops_terminate_account', source: 'ops dashboard', response_status_code: 200, response_data: `terminated by ${req.uid}; appeal until ${new Date(account.termination_appeal_deadline).toISOString()}; services off ${power.ok}/${power.total}` });
+    return { code: 1, data: { terminated: account_uid, appeal_deadline: account.termination_appeal_deadline, services: power } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Step 3 — FINALIZE: NEVER destroys anything. It compiles the list of resources
+// that should be deleted for a terminated account and REPORTS it to ops, who
+// then delete manually. Superuser + terminated required.
+export const ops_finalize_termination = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const account_uid = req.account_uid;
+    if (!account_uid) return { code: -1, data: 'account_uid is required' };
+    const ar = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    if (ar.code < 0 || !ar.data) return { code: -1, data: 'account not found' };
+    const account = ar.data;
+    if (account.account_termination_status !== 1) return { code: -1, data: 'account is not in a terminated state' };
+
+    const apps = await _ops_enum_apps(account_uid);
+    const resources = apps.map((a) => ({
+      app_id: a._id,
+      app_type: a.app_type,
+      app_name: a.app_name || a._id,
+      ip: a.app_hosting_server?.ip || '',
+      region: a.app_hosting_server?.region_name || a.app_hosting_server?.provider || '',
+    }));
+    const appeal_window_elapsed = !!(account.termination_appeal_deadline && Date.now() >= account.termination_appeal_deadline);
+    account.termination_reported_ts = Date.now();
+    account.termination_reported_by_uid = req.uid;
+    await db_module.save_couch_doc('xuda_accounts', account);
+
+    const rows = [
+      ['Account', account_uid], ['Email', account.account_info?.email], ['Requested by', req.uid],
+      ['Appeal window elapsed', appeal_window_elapsed ? 'yes' : 'NO — still within appeal period'],
+      ['Resources to delete', resources.length],
+      ...resources.map((r, i) => [`#${i + 1} ${r.app_type}`, `${r.app_name} ${r.ip}`.trim()]),
+    ];
+    _ops_notify_ops(`Resources to delete (manual) for terminated account: ${account.account_info?.email || account_uid}`, rows, 'OPS-DELETE-LIST');
+    logs_msa.add_account_log({ uid: account_uid, method: 'ops_finalize_termination', security: true, source: 'ops dashboard', response_status_code: 200, response_data: `reported ${resources.length} resource(s) for manual deletion by ${req.uid}; appeal_elapsed=${appeal_window_elapsed}` });
+    return { code: 1, data: { account_uid, appeal_window_elapsed, resources } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Reinstate (appeal accepted): clear suspension/termination, services back on.
+export const ops_reinstate_account = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const account_uid = req.account_uid;
+    if (!account_uid) return { code: -1, data: 'account_uid is required' };
+    const ar = await db_module.get_couch_doc('xuda_accounts', account_uid);
+    if (ar.code < 0 || !ar.data) return { code: -1, data: 'account not found' };
+    const account = ar.data;
+    if (account.termination_finalized_ts) return { code: -1, data: 'resources already deleted; cannot reinstate' };
+    account.account_suspension_status = 0;
+    account.account_termination_status = 0;
+    account.appeal_status = 'accepted';
+    account.reinstated_ts = Date.now();
+    account.reinstated_by_uid = req.uid;
+    const sr = await db_module.save_couch_doc('xuda_accounts', account);
+    if (sr.code < 0) return { code: -1, data: sr.data };
+    const power = await _ops_services_power(account_uid, true);
+    notification_msa.submit_notification({ type: 'account', uid_arr: [account_uid], subject: 'Your account has been reinstated', body: '<h2>Your account has been reinstated</h2><p>Your account is active again and your services are being restored. Thank you.</p><p style="margin:16px 0 0 0;font-size:11px;color:#999">Ref: OPS-REINST</p>', delivery_method: ['banner', 'email'], display_type: 'info' });
+    _ops_notify_ops(`Account reinstated: ${account.account_info?.email || account_uid}`, [['Account', account_uid], ['Email', account.account_info?.email], ['By', req.uid], ['Services on', `${power.ok}/${power.total}`]], 'OPS-REINST');
+    logs_msa.add_account_log({ uid: account_uid, method: 'ops_reinstate_account', source: 'ops dashboard', response_status_code: 200, response_data: `reinstated by ${req.uid}; services on ${power.ok}/${power.total}` });
+    return { code: 1, data: { reinstated: account_uid, services: power } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Ops dashboard queue: accounts currently suspended or terminated.
+export const ops_list_terminations = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const ret = await db_module.find_couch_query('xuda_accounts', { selector: { docType: 'account', $or: [{ account_suspension_status: 1 }, { account_termination_status: 1 }] }, limit: 9999 }, true);
+    const rows = (ret.docs || []).map((a) => ({
+      account_uid: a._id,
+      email: a.account_info?.email,
+      name: `${a.account_info?.first_name || ''} ${a.account_info?.last_name || ''}`.trim(),
+      suspended: a.account_suspension_status === 1,
+      suspension_date: a.account_suspension_date,
+      terminated: a.account_termination_status === 1,
+      termination_date: a.account_termination_date,
+      reason: a.termination_reason || a.suspension_reason || '',
+      by_uid: a.termination_by_uid || a.suspension_by_uid || '',
+      appeal_deadline: a.termination_appeal_deadline || null,
+      appeal_status: a.appeal_status || 'none',
+      finalized: !!a.termination_finalized_ts,
+    }));
+    return { code: 1, data: { rows } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
 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;

package/index_ms.mjs

@@ -89,6 +89,26 @@ export const get_account_info = async function (...args) {
   return await broker.send_to_queue("get_account_info", ...args);
 };
 
+export const ops_suspend_account = async function (...args) {
+  return await broker.send_to_queue("ops_suspend_account", ...args);
+};
+
+export const ops_terminate_account = async function (...args) {
+  return await broker.send_to_queue("ops_terminate_account", ...args);
+};
+
+export const ops_finalize_termination = async function (...args) {
+  return await broker.send_to_queue("ops_finalize_termination", ...args);
+};
+
+export const ops_reinstate_account = async function (...args) {
+  return await broker.send_to_queue("ops_reinstate_account", ...args);
+};
+
+export const ops_list_terminations = async function (...args) {
+  return await broker.send_to_queue("ops_list_terminations", ...args);
+};
+
 export const did_you_know_tips = async function (...args) {
   return await broker.send_to_queue("did_you_know_tips", ...args);
 };

package/index_msa.mjs

@@ -89,6 +89,26 @@ export const get_account_info =  function (...args) {
    broker.send_to_queue_async("get_account_info", ...args);
 };
 
+export const ops_suspend_account =  function (...args) {
+   broker.send_to_queue_async("ops_suspend_account", ...args);
+};
+
+export const ops_terminate_account =  function (...args) {
+   broker.send_to_queue_async("ops_terminate_account", ...args);
+};
+
+export const ops_finalize_termination =  function (...args) {
+   broker.send_to_queue_async("ops_finalize_termination", ...args);
+};
+
+export const ops_reinstate_account =  function (...args) {
+   broker.send_to_queue_async("ops_reinstate_account", ...args);
+};
+
+export const ops_list_terminations =  function (...args) {
+   broker.send_to_queue_async("ops_list_terminations", ...args);
+};
+
 export const did_you_know_tips =  function (...args) {
    broker.send_to_queue_async("did_you_know_tips", ...args);
 };

package/package.json

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