@xuda.io/account_module 1.2.2288 → 1.2.2289

package/index.mjs

@@ -1990,11 +1990,29 @@ const _srv_role = (doc) => {
   return 'other';
 };
 
+// xuda_servers is authoritative on the dev orchestrator and replicates dev->master
+// ONE-WAY (db_module.get_live_servers_couch): nothing replicates back INTO dev, so
+// a stat:1 enqueue written on any other node's local couch strands and the dev
+// rollout tick never sees it. So the ops server methods (list / status / deploy)
+// must read+write the ORCHESTRATOR's couch, not the local region replica. On dev
+// itself this is the local connection (unchanged); from any other node we reach
+// dev's couch over the WG mesh, reusing THIS node's couch admin credential (shared
+// fleet-wide). Endpoint comes from _conf.deploy_orchestrator; absent -> fall back
+// to local (no worse than before, and never throws on nodes not yet reconfigured).
+const _orchestrator_servers_couch = () => {
+  const orch = _conf.deploy_orchestrator || {};
+  const host = process.env.XUDA_HOSTNAME;
+  if (!orch.couch_location || host === orch.hostname) return db_module.get_con('xuda_servers');
+  const local = (_conf.couchdb_control_database && _conf.couchdb_control_database[host]) || {};
+  const url = `${local.db_server_http || 'http'}://${local.db_server_username || 'admin'}:${local.db_server_password || ''}@${orch.couch_location}/`;
+  return db_module.get_con('xuda_servers', url);
+};
+
 // 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 couch = _orchestrator_servers_couch();
   const res = await couch.list({ include_docs: true });
   return (res.rows || []).map((r) => r.doc).filter((d) => d && !String(d._id).startsWith('_design'));
 };
@@ -2063,12 +2081,26 @@ export const ops_deploy_server = async function (req = {}) {
     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;
+    // Read + write the ORCHESTRATOR's authoritative couch (dev), NOT the local
+    // region replica: a stat:1 written to a region's copy never reaches the dev
+    // rollout tick (nothing replicates back into dev), so it would strand and the
+    // deploy would silently no-op. Raw nano .get/.insert (full doc, safe to save
+    // back) mirrors _publish_rollout's own access pattern.
+    const couch = _orchestrator_servers_couch();
+    let doc;
+    try {
+      doc = await couch.get(server_id);
+    } catch (e) {
+      return { code: -1, data: e.statusCode === 404 ? `server "${server_id}" not found` : `orchestrator couch read failed: ${e.message}` };
+    }
     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)` };
 
+    // Preview (dry_run) writes nothing and needs no confirmation, so it must run
+    // BEFORE the confirmation and busy gates: "Preview plan" sends dry_run:true
+    // with no confirm, and should also work while a deploy is already in flight.
+    const plan = { server_id, mode, current_state: _srv_deploy_state(doc), busy: _srv_busy(doc), private_ip: doc.private || null };
+    if (req.dry_run) return { code: 1, data: { dry_run: true, would_deploy: plan } };
+
     // 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.` };
@@ -2080,18 +2112,18 @@ export const ops_deploy_server = async function (req = {}) {
     // 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.
+    // Enqueue on the orchestrator's couch: the dev 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 };
+    try {
+      await couch.insert(doc);
+    } catch (e) {
+      return { code: -1, data: `enqueue write to orchestrator couch failed: ${e.message}` };
+    }
 
     _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}` });
@@ -2120,9 +2152,14 @@ export const ops_server_deploy_status = async function (req = {}) {
     });
 
     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) };
+      // Read the orchestrator's authoritative copy so progress reflects the dev
+      // rollout's stat writes (the region replica can lag / never see enqueues).
+      try {
+        const doc = await _orchestrator_servers_couch().get(String(req.server_id).trim());
+        return { code: 1, data: to_status(doc) };
+      } catch (e) {
+        return { code: -1, data: e.statusCode === 404 ? `server "${req.server_id}" not found` : `orchestrator couch read failed: ${e.message}` };
+      }
     }
     const docs = await _load_all_server_docs();
     const rows = docs.filter(_srv_is_deployable).map(to_status);

package/package.json

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