@xuda.io/account_module 1.2.2284 → 1.2.2286

package/index.mjs

@@ -67,6 +67,59 @@ 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`);
 
+// ── Account main-project auto-naming ─────────────────────────────────────────
+// The account's main project (is_account_project) is named after its owner:
+// "John's Project" (personal) / "Acme Inc's Project" (business). It's set at
+// creation (misc_module) and re-synced here whenever the account name changes.
+// The name is display-only — everything functional references the project by id,
+// and it's hidden from listings via is_account_project — so renaming is safe.
+const ACCOUNT_PROJECT_LEGACY_RX = /^Account\s+\S+\s+main project$/i;
+
+// Owner-derived project name, or null when the account has no name yet.
+export const account_project_name = function (account_info) {
+  const ai = account_info || {};
+  let base = String((ai.account_type === 'business' ? ai.business_name : ai.first_name) || '').trim();
+  if (!base) return null;
+  base = base.charAt(0).toUpperCase() + base.slice(1); // capitalize the first letter for display ("john" → "John")
+  return `${base}'s Project`; // possessive: "John's", "James's" — always append 's
+};
+
+// True when the project's current name is one WE generated (legacy sentinel, the
+// pre-name fallback, or the name derived from ref_info) — so a sync/backfill may
+// replace it. A name the user set themselves is NOT auto → never clobbered.
+export const is_auto_account_project_name = function (name, ref_info) {
+  const n = String(name || '').trim();
+  if (!n) return true;
+  if (ACCOUNT_PROJECT_LEGACY_RX.test(n)) return true;
+  if (n === 'My Project') return true; // creation fallback before the name is known
+  const derived = account_project_name(ref_info);
+  return !!derived && n === derived;
+};
+
+// Re-sync the account main project's name to the owner's CURRENT name. Only renames
+// when the project still carries an auto-generated name (relative to ref_info = the
+// name info BEFORE this change); a user-customized name is left untouched. Best-effort.
+export const _sync_account_project_name = async function (account_obj, ref_info) {
+  try {
+    const proj_id = account_obj?.account_project_id;
+    if (!proj_id) return;
+    const new_name = account_project_name(account_obj.account_info);
+    if (!new_name) return;
+    const ret = await db_module.get_couch_doc('xuda_master', proj_id);
+    const proj = ret?.data;
+    if (!proj?._id || proj.app_name === new_name) return;
+    if (!is_auto_account_project_name(proj.app_name, ref_info)) return; // user-customized → keep
+    proj.app_name = new_name;
+    if (!proj.app_general_prop) proj.app_general_prop = {};
+    proj.app_general_prop.app_name = new_name;
+    proj.last_updated_ts = Date.now();
+    await db_module.save_app_obj(proj, proj_id);
+    console.log(`[account_project_name] ${account_obj._id}: renamed account project → "${new_name}"`);
+  } catch (err) {
+    console.warn(`[account_project_name] sync failed for ${account_obj?._id}:`, err?.message || err);
+  }
+};
+
 export const update_account_info = async function (req, job_id, headers) {
   const { uid } = req;
   const data = req;
@@ -92,6 +145,13 @@ export const update_account_info = async function (req, job_id, headers) {
   const ret = await db_module.get_couch_doc('xuda_accounts', uid);
   var account_obj = ret.data;
   account_obj.ts = Date.now();
+  // Owner's name BEFORE this update — lets the project-name sync (after save) tell an
+  // auto-generated project name (safe to rename) from a user-customized one (keep).
+  const _old_name_info = {
+    first_name: account_obj.account_info?.first_name,
+    business_name: account_obj.account_info?.business_name,
+    account_type: account_obj.account_info?.account_type,
+  };
   var change = '';
   var account_info_changes_arr = [];
   var error = {};
@@ -231,6 +291,13 @@ export const update_account_info = async function (req, job_id, headers) {
 
   const save_ret = await db_module.save_couch_doc('xuda_accounts', account_obj);
 
+  // Keep the account main project's name in sync with the owner's name
+  // ("John's Project"). Only when a name field actually changed, and only if the
+  // project still has an auto-generated name (a user-customized one is left alone).
+  if (['first_name', 'business_name', 'account_type'].some((k) => account_info_changes_arr.includes(k))) {
+    await _sync_account_project_name(account_obj, _old_name_info);
+  }
+
   if (account_obj.account_info?.profile_picture) {
     if (!account_obj.account_info?.profile_avatar && account_obj.account_info.profile_avatar_stat !== 2) {
       debugger;
@@ -1890,6 +1957,177 @@ export const ops_send_notification = async function (req = {}) {
   } catch (err) { return { code: -1, data: err.message }; }
 };
 
+// ---------------------------------------------------------------------------
+// Fleet server admin (superuser) — list the platform's own servers, queue a
+// soft/hard code deploy, and poll deploy status/progress. These are thin, SAFE
+// wrappers over the existing, battle-tested publish engine in misc_module
+// (_publish_rollout / _reinstall_server_detached): a deploy here only sets
+// stat:1 + publish_mode on the target's xuda_servers doc — the dev
+// orchestrator's 1-min tick (controller_module -> misc.publish_to_servers)
+// picks it up and runs the drain -> reinstall -> undrain rollout, writing
+// progress back onto the SAME doc (stat 1->2->3/4, stat_ts, publish_error). So
+// the blast radius of THIS module is a single CouchDB field write; the vetted
+// engine does the actual work. Deploy targets are region app-servers only
+// (docType 'regional_server' + application_server); farm/proxmox nodes and the
+// dev orchestrator itself are never deployable here.
+// ---------------------------------------------------------------------------
+
+// stat state-machine on an xuda_servers doc -> friendly deploy state.
+const _SRV_DEPLOY_STATE = { 1: 'queued', 2: 'deploying', 3: 'idle', 4: 'failed' };
+const _srv_deploy_state = (doc) => _SRV_DEPLOY_STATE[doc && doc.stat] || 'unknown';
+const _srv_busy = (doc) => !!doc && (doc.stat === 1 || doc.stat === 2);
+// A deploy target is a region control-plane app-server (runs the /var/xuda
+// stack). NOT farm/proxmox nodes (no stack) and NOT dev (the orchestrator
+// itself — it deploys via rsync, and can't reinstall itself mid-rollout).
+const _srv_is_deployable = (doc) => !!(doc && doc.docType === 'regional_server' && doc.application_server === true && doc._id !== 'dev');
+const _srv_role = (doc) => {
+  if (!doc) return 'other';
+  if (doc.docType === 'regional_server' && doc.application_server) return 'region';
+  if (doc.provider === 'proxmox' && doc.vmid) return 'farm_vm';
+  if (doc.provider === 'proxmox' && (doc.node || doc.api_url)) return 'farm_node';
+  return 'other';
+};
+
+// Load every xuda_servers doc via _all_docs (nano .list) rather than a
+// match-all Mango selector — avoids the "no matching index" warning that would
+// otherwise spam the log on every (frequently-polled) status call.
+const _load_all_server_docs = async () => {
+  const couch = await db_module.get_con('xuda_servers');
+  const res = await couch.list({ include_docs: true });
+  return (res.rows || []).map((r) => r.doc).filter((d) => d && !String(d._id).startsWith('_design'));
+};
+
+// Normalize one xuda_servers doc into the admin list view.
+const _srv_view = (doc) => {
+  const info = doc.server_info && typeof doc.server_info === 'object' ? doc.server_info : {};
+  return {
+    id: doc._id,
+    role: _srv_role(doc),
+    deployable: _srv_is_deployable(doc),
+    provider: doc.provider || (doc.droplet_id ? 'digitalocean' : doc.node || doc.api_url ? 'proxmox' : 'unknown'),
+    hostname: doc.hostname || info.public_hostname || null,
+    public_ip: doc.public || info.public_ip || null,
+    private_ip: doc.private || info.private_ip || null, // WireGuard mesh IP (10.8.0.x)
+    server_status: doc.server_status || info.status || 'unknown', // active | off
+    server_is_full: !!doc.server_is_full,
+    capacity: doc.server_capacity || null,
+    countries: doc.countries || null,
+    deploy: {
+      state: _srv_deploy_state(doc),
+      busy: _srv_busy(doc),
+      publish_mode: doc.publish_mode || null,
+      stat: typeof doc.stat === 'number' ? doc.stat : null,
+      stat_ts: doc.stat_ts || null,
+      error: doc.publish_error || null,
+      requested_by: doc.deploy_requested_by || null,
+      requested_ts: doc.deploy_requested_ts || null,
+    },
+  };
+};
+
+// List every fleet server (regions + farm nodes) with live status + deploy
+// state. Read-only. Live status is maintained by controller_module.check_live_servers.
+export const ops_list_servers = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const docs = await _load_all_server_docs();
+    const rank = { region: 0, farm_node: 1, farm_vm: 2, other: 3 };
+    const servers = docs
+      .map(_srv_view)
+      .sort((a, b) => rank[a.role] - rank[b.role] || (a.id === 'master' ? -1 : b.id === 'master' ? 1 : String(a.id).localeCompare(String(b.id))));
+    return {
+      code: 1,
+      data: {
+        servers,
+        deploy_targets: servers.filter((s) => s.deployable).map((s) => s.id),
+        orchestrator: 'dev.xuda.ai',
+        note: 'Deploy runs from the dev orchestrator; region app-servers only. Soft = zero-downtime drain + reload; hard = teardown + clean install.',
+      },
+    };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Queue a code deploy to ONE region app-server. Enqueue-only + superuser-gated:
+// sets stat:1 + publish_mode on the target doc; the dev orchestrator rolls it
+// out. mode: 'soft' (default, zero-downtime) | 'hard' (teardown + clean
+// install). Guards: deployable target only; not the dev orchestrator; not
+// already busy; confirm required (hard requires the server id typed back).
+// dry_run returns the plan WITHOUT writing (safe preview).
+export const ops_deploy_server = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const server_id = String(req.server_id || '').trim();
+    const mode = req.mode === 'hard' ? 'hard' : 'soft';
+    if (!server_id) return { code: -1, data: 'server_id is required' };
+    if (server_id === 'dev') return { code: -1, data: 'the dev orchestrator deploys via rsync, not this rollout; pick a region (master/us/eu)' };
+
+    // FULL doc (no field projection) so it is safe to save back.
+    const sr = await db_module.get_couch_doc('xuda_servers', server_id);
+    if (sr.code < 0 || !sr.data) return { code: -1, data: `server "${server_id}" not found` };
+    const doc = sr.data;
+    if (!_srv_is_deployable(doc)) return { code: -1, data: `server "${server_id}" is not a deployable region app-server (needs docType 'regional_server' + application_server)` };
+
+    // Confirmation gate — proportional to blast radius.
+    if (mode === 'hard') {
+      if (req.confirm !== server_id) return { code: -1, data: `hard deploy tears down and reinstalls "${server_id}" (brief downtime). Re-send with confirm:"${server_id}" to proceed.` };
+    } else {
+      const ok = req.confirm === true || req.confirm === 'true' || req.confirm === server_id;
+      if (!ok) return { code: -1, data: `confirm required: re-send with confirm:true to deploy "${server_id}" (soft, zero-downtime).` };
+    }
+
+    // Already-in-flight guard.
+    if (_srv_busy(doc)) return { code: -1, data: `a deploy is already ${_srv_deploy_state(doc)} for "${server_id}"; wait for it to finish (poll ops_server_deploy_status).` };
+
+    const plan = { server_id, mode, current_state: _srv_deploy_state(doc), private_ip: doc.private || null };
+    if (req.dry_run) return { code: 1, data: { dry_run: true, would_deploy: plan } };
+
+    // Enqueue: the dev orchestrator's 1-min publish tick picks stat:1 up.
+    doc.stat = 1;
+    doc.stat_ts = Date.now();
+    doc.publish_mode = mode;
+    doc.deploy_requested_by = req.uid;
+    doc.deploy_requested_ts = Date.now();
+    delete doc.publish_error;
+    const wr = await db_module.save_couch_doc('xuda_servers', doc);
+    if (wr.code < 0) return { code: -1, data: wr.data };
+
+    _ops_notify_ops(`Server deploy queued (${mode}): ${server_id}`, [['Server', server_id], ['Mode', mode], ['By', req.uid], ['State', 'queued'], ['Orchestrator', 'dev.xuda.ai']], 'OPS-DEPLOY-' + server_id);
+    logs_msa.add_account_log({ uid: req.uid, method: 'ops_deploy_server', source: 'ops dashboard', response_status_code: 200, response_data: `queued ${mode} deploy for ${server_id} by ${req.uid}` });
+
+    return { code: 1, data: { enqueued: true, server_id, mode, state: 'queued', orchestrator: 'dev.xuda.ai', poll: 'ops_server_deploy_status' } };
+  } catch (err) { return { code: -1, data: err.message }; }
+};
+
+// Poll deploy status/progress for one server (or all region app-servers). Reads
+// the stat state-machine the rollout writes onto each xuda_servers doc.
+export const ops_server_deploy_status = async function (req = {}) {
+  try {
+    if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    const now = Date.now();
+    const to_status = (doc) => ({
+      id: doc._id,
+      state: _srv_deploy_state(doc),
+      busy: _srv_busy(doc),
+      publish_mode: doc.publish_mode || null,
+      stat: typeof doc.stat === 'number' ? doc.stat : null,
+      stat_ts: doc.stat_ts || null,
+      elapsed_ms: doc.stat_ts && _srv_busy(doc) ? now - doc.stat_ts : null,
+      error: doc.publish_error || null,
+      requested_by: doc.deploy_requested_by || null,
+      requested_ts: doc.deploy_requested_ts || null,
+    });
+
+    if (req.server_id) {
+      const sr = await db_module.get_couch_doc('xuda_servers', String(req.server_id).trim());
+      if (sr.code < 0 || !sr.data) return { code: -1, data: `server "${req.server_id}" not found` };
+      return { code: 1, data: to_status(sr.data) };
+    }
+    const docs = await _load_all_server_docs();
+    const rows = docs.filter(_srv_is_deployable).map(to_status);
+    return { code: 1, data: { servers: rows, any_busy: rows.some((r) => r.busy) } };
+  } 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

@@ -17,6 +17,18 @@
 
  
 
+export const account_project_name = async function (...args) {
+  return await broker.send_to_queue("account_project_name", ...args);
+};
+
+export const is_auto_account_project_name = async function (...args) {
+  return await broker.send_to_queue("is_auto_account_project_name", ...args);
+};
+
+export const _sync_account_project_name = async function (...args) {
+  return await broker.send_to_queue("_sync_account_project_name", ...args);
+};
+
 export const update_account_info = async function (...args) {
   return await broker.send_to_queue("update_account_info", ...args);
 };
@@ -177,6 +189,18 @@ export const ops_send_notification = async function (...args) {
   return await broker.send_to_queue("ops_send_notification", ...args);
 };
 
+export const ops_list_servers = async function (...args) {
+  return await broker.send_to_queue("ops_list_servers", ...args);
+};
+
+export const ops_deploy_server = async function (...args) {
+  return await broker.send_to_queue("ops_deploy_server", ...args);
+};
+
+export const ops_server_deploy_status = async function (...args) {
+  return await broker.send_to_queue("ops_server_deploy_status", ...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

@@ -17,6 +17,18 @@
 
  
 
+export const account_project_name =  function (...args) {
+   broker.send_to_queue_async("account_project_name", ...args);
+};
+
+export const is_auto_account_project_name =  function (...args) {
+   broker.send_to_queue_async("is_auto_account_project_name", ...args);
+};
+
+export const _sync_account_project_name =  function (...args) {
+   broker.send_to_queue_async("_sync_account_project_name", ...args);
+};
+
 export const update_account_info =  function (...args) {
    broker.send_to_queue_async("update_account_info", ...args);
 };
@@ -177,6 +189,18 @@ export const ops_send_notification =  function (...args) {
    broker.send_to_queue_async("ops_send_notification", ...args);
 };
 
+export const ops_list_servers =  function (...args) {
+   broker.send_to_queue_async("ops_list_servers", ...args);
+};
+
+export const ops_deploy_server =  function (...args) {
+   broker.send_to_queue_async("ops_deploy_server", ...args);
+};
+
+export const ops_server_deploy_status =  function (...args) {
+   broker.send_to_queue_async("ops_server_deploy_status", ...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.2284",
+  "version": "1.2.2286",
   "description": "Xuda Account Server Module",
   "main": "index.mjs",
   "dependencies": {