@xuda.io/account_module 1.2.2285 → 1.2.2287

package/index.mjs

@@ -57,6 +57,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`);
+// Revoking an SSH key from the servers it is installed on (disable/delete/expiry).
+const deploy_ms = await import(`${module_path}/deploy_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`);
 
@@ -1957,6 +1959,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;
@@ -2492,8 +2665,40 @@ export const add_app_log_util = async function (body, status, service, source, r
   }
 };
 
+// Append one entry to the SSH access log (xuda_ssh_keys, docType ssh_key_event).
+// stat:3 is stamped so the existing idx_ssh_keys_uid [docType, uid, stat] index
+// serves the log reads. deploy_module carries the same writer on purpose: cpi
+// modules do not import each other.
+const _ssh_key_event = async function (uid, action, extra = {}) {
+  try {
+    if (!uid) return;
+    await db_module.save_couch_doc('xuda_ssh_keys', {
+      _id: await _common.xuda_get_uuid('ssh_key_event'),
+      docType: 'ssh_key_event',
+      uid, action, stat: 3, at: Date.now(), ...extra,
+    });
+  } catch (e) {}
+};
+
+// Pull a key off every server it is installed on (assigned_apps is the reverse
+// index deploy_module maintains at assign time). Best-effort per app: one
+// unreachable server must not leave the key half-revoked on the others.
+const _ssh_key_revoke_everywhere = async function (doc) {
+  const apps = Array.isArray(doc.assigned_apps) ? doc.assigned_apps : [];
+  const failed = [];
+  for (const app_id of apps) {
+    try {
+      const r = await deploy_ms.revoke_ssh_keys({ app_id, ssh_keys: [doc._id] });
+      if (!(r && r.code > 0)) failed.push(app_id);
+    } catch (e) {
+      failed.push(app_id);
+    }
+  }
+  return { apps, failed };
+};
+
 export const save_ssh_key = async function (req) {
-  const { uid, _id, ssh_key_name, ssh_key_content } = req;
+  const { uid, _id, ssh_key_name, ssh_key_content, expires_at, enabled } = req;
 
   function isValidSSHPublicKey(sshPublicKey) {
     // Regular expression to match SSH public keys
@@ -2506,6 +2711,16 @@ export const save_ssh_key = async function (req) {
     return { code: -1, data: 'invalid ssh key' };
   }
 
+  // Optional expiry (epoch ms). null/0 clears it; a date in the past is a
+  // mistake the UI should hear about, not silently store.
+  let _exp = null;
+  if (expires_at !== undefined && expires_at !== null && expires_at !== 0 && expires_at !== '') {
+    _exp = Number(expires_at);
+    if (!Number.isFinite(_exp) || _exp <= Date.now()) {
+      return { code: -1, data: 'expires_at must be a future date (epoch milliseconds)' };
+    }
+  }
+
   var doc = {
     uid,
     docType: 'ssh_key',
@@ -2514,36 +2729,92 @@ export const save_ssh_key = async function (req) {
     stat: 3,
   };
 
+  var is_new = true;
   if (_id) {
     const ret = await db_module.get_couch_doc('xuda_ssh_keys', _id);
     if (ret.code < 0) {
       return ret;
     }
+    if (ret.data.uid !== uid) {
+      return { code: -403, data: 'not your key' };
+    }
     doc = ret.data;
     doc.date_updated_ts = Date.now();
+    is_new = false;
   } else {
     doc._id = await _common.xuda_get_uuid('ssh_key');
   }
 
   doc.ssh_key_name = ssh_key_name;
   doc.ssh_key_content = ssh_key_content;
+  if (expires_at !== undefined) doc.expires_at = _exp;
+  if (enabled !== undefined) doc.enabled = enabled !== false;
+  if (doc.enabled === undefined) doc.enabled = true;
 
   const save_ret = await db_module.save_couch_doc('xuda_ssh_keys', doc);
+  if (save_ret.code > -1) {
+    await _ssh_key_event(uid, is_new ? 'create' : 'update', { ssh_key_id: doc._id, key_name: ssh_key_name, expires_at: doc.expires_at || null });
+  }
 
   return save_ret;
 };
+
+// On/off switch for one key. Switching OFF also pulls the key from every server
+// it is installed on, so "off" means the developer is locked out now, not on the
+// next reassign. Switching ON does not auto-reinstall: the user re-assigns
+// per server (deliberate: re-granting access is an explicit act).
+export const set_ssh_key_enabled = async function (req) {
+  const { uid, ssh_key_id, enabled } = req;
+  const ret = await db_module.get_couch_doc('xuda_ssh_keys', ssh_key_id);
+  if (ret.code < 0) return ret;
+  const doc = ret.data;
+  if (doc.uid !== uid) return { code: -403, data: 'not your key' };
+
+  const on = enabled !== false;
+  let revoked = null;
+  if (!on) {
+    revoked = await _ssh_key_revoke_everywhere(doc);
+    if (revoked.failed.length) {
+      return { code: -1, data: `could not remove the key from ${revoked.failed.length} server(s) (${revoked.failed.join(', ')}). The key stays ON so the state on your servers is never ambiguous. Try again.` };
+    }
+  }
+  // revoke_ssh_keys rewrote the key doc (assigned_apps); refetch before saving.
+  const fresh = await db_module.get_couch_doc('xuda_ssh_keys', ssh_key_id);
+  const fdoc = fresh.code > -1 ? fresh.data : doc;
+  fdoc.enabled = on;
+  fdoc.date_updated_ts = Date.now();
+  const save_ret = await db_module.save_couch_doc('xuda_ssh_keys', fdoc);
+  if (save_ret.code > -1) {
+    await _ssh_key_event(uid, on ? 'enable' : 'disable', { ssh_key_id, key_name: fdoc.ssh_key_name, ...(revoked ? { removed_from: revoked.apps } : {}) });
+  }
+  return save_ret.code > -1 ? { code: 1, data: { enabled: on, removed_from: revoked ? revoked.apps : [] } } : save_ret;
+};
+
 export const delete_ssh_key = async function (req) {
-  const { ssh_key_id } = req;
+  const { uid, ssh_key_id } = req;
 
   const ret = await db_module.get_couch_doc('xuda_ssh_keys', ssh_key_id);
   if (ret.code < 0) {
     return ret;
   }
   var doc = ret.data;
+  if (doc.uid !== uid) {
+    return { code: -403, data: 'not your key' };
+  }
+  // A deleted key must stop opening doors: pull it off every server first.
+  const revoked = await _ssh_key_revoke_everywhere(doc);
+  if (revoked.failed.length) {
+    return { code: -1, data: `could not remove the key from ${revoked.failed.length} server(s) (${revoked.failed.join(', ')}). The key was NOT deleted. Try again.` };
+  }
+  const fresh = await db_module.get_couch_doc('xuda_ssh_keys', ssh_key_id);
+  doc = fresh.code > -1 ? fresh.data : doc;
   doc.date_updated_ts = Date.now();
   doc.stat = 4;
 
   const save_ret = await db_module.save_couch_doc('xuda_ssh_keys', doc);
+  if (save_ret.code > -1) {
+    await _ssh_key_event(uid, 'delete', { ssh_key_id, key_name: doc.ssh_key_name, ...(revoked.apps.length ? { removed_from: revoked.apps } : {}) });
+  }
 
   return save_ret;
 };
@@ -2563,6 +2834,22 @@ export const get_ssh_keys = async function (req) {
   return ret;
 };
 
+// The account's SSH access log: every grant, revoke, on/off flip, expiry and
+// delete, newest first. Selector rides idx_ssh_keys_uid ([docType, uid, stat]).
+export const get_ssh_key_events = async function (req) {
+  const { uid, ssh_key_id, app_id, limit } = req;
+  const opt = {
+    selector: { docType: 'ssh_key_event', uid, stat: { $gte: 0 } },
+    limit: 2000,
+  };
+  if (ssh_key_id) opt.selector.ssh_key_id = ssh_key_id;
+  if (app_id) opt.selector.app_id = app_id;
+  const ret = await db_module.find_couch_query('xuda_ssh_keys', opt);
+  if (ret.code < 0) return ret;
+  const rows = (ret.docs || ret.data?.docs || []).sort((a, b) => (b.at || 0) - (a.at || 0)).slice(0, Math.min(Number(limit) || 200, 1000));
+  return { code: 1, data: rows };
+};
+
 export const search_users = async function (req) {
   const { _id, search, limit, skip, bookmark, uid } = req;
 
@@ -5363,6 +5650,8 @@ export const update_account_profile = async function (req, job_id, headers) {
     'active_ai_model',
     'ai_models',
     'active_agents',
+    // Email Template tab: { style: 'plain' | 'card' | 'accent' | 'minimal' }
+    'email_template',
   ];
   try {
     let { data: account_profile_doc } = await db_module.get_app_couch_doc(app_id, _id);
@@ -5746,10 +6035,21 @@ export const record_ai_usage = async function (uid, input_tokens, output_tokens,
   try {
     if (!account_profile_info) throw new Error('missing account_profile_info');
 
-    const cost = _conf?.ai_models?.[model] || {
+    // `model` arrives as the stable ai_models code (the key profiles/agents store,
+    // e.g. 'gpt-5.4'). Price by that code, but store the real OpenAI model name in
+    // the usage record (e.g. 'gpt-5.6-terra') so usage/billing reflects the actual
+    // model used. Also match by .model so a caller that already passed a real id
+    // still prices correctly.
+    const models = _conf?.ai_models || {};
+    // Canonicalize a legacy key (still stored on old profiles/agents, e.g. 'gpt-5.4')
+    // to its current catalog code before pricing.
+    const code = _conf?.ai_model_aliases?.[model] || model;
+    const entry = models[code] || Object.values(models).find((e) => e && e.model === model) || null;
+    const cost = entry || {
       input: 1.0,
       output: 1.0,
     };
+    const model_name = entry?.model || model;
 
     const t = Date.now();
     let usage_doc = {
@@ -5763,7 +6063,7 @@ export const record_ai_usage = async function (uid, input_tokens, output_tokens,
       output_tokens,
       stat: 3,
       metadata,
-      model,
+      model: model_name,
       cost,
       account_profile_info,
       tools,
@@ -6055,6 +6355,33 @@ const _nl_gif_url = (g) => (g ? `https://xuda.ai/dist/images/email/${g}.gif` : '
 const _nl_esc = (v) =>
   String(v == null ? '' : v).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 
+// Self-healing storage: xuda_newsletter lives on master ONLY and replicates to
+// master2 ONLY (never regions — the fleet control-DB hub must not pick it up).
+// Creates the DB if missing (fresh master build / DR restore / master2 promote)
+// and upserts the continuous master->master2 replicator doc, modeled on the
+// fw_repl_* docs. Idempotent; called from newsletter_generate which is already
+// gated to master + dev, so this can never materialize the DB on a region.
+const _nl_ensure_storage = async () => {
+  const cc = _conf.couchdb_control_database?.[process.env.XUDA_HOSTNAME] || _conf.couchdb_control_database;
+  if (!cc?.db_server_location) return;
+  await db_module.create_couch_database(NEWSLETTER_DB, `${cc.db_server_http}://${cc.db_server_username}:${cc.db_server_password}@${cc.db_server_location}`);
+  if (process.env.XUDA_HOSTNAME !== 'master.xuda.ai') return;
+  const m2 = _conf.couchdb_control_database?.['master2.xuda.ai'];
+  if (!m2?.db_server_location) return;
+  const rep_id = 'nl_repl_master_to_master2';
+  const existing = await db_module.get_couch_doc('_replicator', rep_id);
+  if (existing.code > 0 && existing.data) return;
+  const b64 = (u, p) => 'Basic ' + Buffer.from(`${u}:${p}`).toString('base64');
+  const save = await db_module.save_couch_doc('_replicator', {
+    _id: rep_id,
+    source: { url: `${cc.db_server_http}://${cc.db_server_location}/${NEWSLETTER_DB}`, headers: { Authorization: b64(cc.db_server_username, cc.db_server_password) } },
+    target: { url: `${m2.db_server_http}://${m2.db_server_location}/${NEWSLETTER_DB}`, headers: { Authorization: b64(m2.db_server_username || cc.db_server_username, m2.db_server_password || cc.db_server_password) } },
+    continuous: true,
+    create_target: true,
+  });
+  if (save.code < 0) console.error('[newsletter] replicator ensure failed:', save.data);
+};
+
 // Next issue number = max(existing) + 1. Read-only projection (never PUT these).
 const _nl_next_number = async () => {
   try {
@@ -6412,6 +6739,10 @@ const _newsletter_send_sample_internal = async (issue, to_email, theme) => {
 export const newsletter_generate = async function (req = {}) {
   try {
     if (!req.system && !_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    // Master-only (dev exempt for testing): the issue DB must never be created
+    // on a regional couch, and the weekly coupon/sample flow belongs to master.
+    if (!_conf.is_debug && process.env.XUDA_HOSTNAME !== 'master.xuda.ai') return { code: -1, data: 'newsletter_generate runs on master only' };
+    await _nl_ensure_storage();
 
     // Two DISTINCT tips: one for "Did you know?", one for "Tip of the week".
     const _two_tips = async () => {
@@ -6569,6 +6900,9 @@ const _newsletter_blast = async (issue, by_uid) => {
 export const newsletter_publish = async function (req = {}) {
   try {
     if (!_ops_is_super(req)) return { code: -403, data: 'superuser only' };
+    // Same master-only gate as generate: the blast must run where xuda_newsletter
+    // and the authoritative xuda_accounts live (dev exempt for testing).
+    if (!_conf.is_debug && process.env.XUDA_HOSTNAME !== 'master.xuda.ai') return { code: -1, data: 'newsletter_publish runs on master only' };
     const id = req.id || `nl_issue_${req.issue_number}`;
     const gret = await db_module.get_couch_doc(NEWSLETTER_DB, id);
     if (gret.code < 0 || !gret.data) return { code: -1, data: 'issue not found' };

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);
 };
@@ -237,6 +249,10 @@ export const save_ssh_key = async function (...args) {
   return await broker.send_to_queue("save_ssh_key", ...args);
 };
 
+export const set_ssh_key_enabled = async function (...args) {
+  return await broker.send_to_queue("set_ssh_key_enabled", ...args);
+};
+
 export const delete_ssh_key = async function (...args) {
   return await broker.send_to_queue("delete_ssh_key", ...args);
 };
@@ -245,6 +261,10 @@ export const get_ssh_keys = async function (...args) {
   return await broker.send_to_queue("get_ssh_keys", ...args);
 };
 
+export const get_ssh_key_events = async function (...args) {
+  return await broker.send_to_queue("get_ssh_key_events", ...args);
+};
+
 export const search_users = async function (...args) {
   return await broker.send_to_queue("search_users", ...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);
 };
@@ -237,6 +249,10 @@ export const save_ssh_key =  function (...args) {
    broker.send_to_queue_async("save_ssh_key", ...args);
 };
 
+export const set_ssh_key_enabled =  function (...args) {
+   broker.send_to_queue_async("set_ssh_key_enabled", ...args);
+};
+
 export const delete_ssh_key =  function (...args) {
    broker.send_to_queue_async("delete_ssh_key", ...args);
 };
@@ -245,6 +261,10 @@ export const get_ssh_keys =  function (...args) {
    broker.send_to_queue_async("get_ssh_keys", ...args);
 };
 
+export const get_ssh_key_events =  function (...args) {
+   broker.send_to_queue_async("get_ssh_key_events", ...args);
+};
+
 export const search_users =  function (...args) {
    broker.send_to_queue_async("search_users", ...args);
 };

package/package.json

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