@xuda.io/account_module 1.2.2285 → 1.2.2286

package/index.mjs

@@ -1957,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

@@ -189,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

@@ -189,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.2285",
+  "version": "1.2.2286",
   "description": "Xuda Account Server Module",
   "main": "index.mjs",
   "dependencies": {