cyberia 3.2.9 → 3.2.12

package/src/server/process.js

@@ -1,6 +1,22 @@
 /**
  * Module for process and shell command management.
- * Provides utilities for executing shell commands, managing signals, and handling environment details.
+ * Provides utilities for executing shell commands, managing signals, and
+ * handling environment details.
+ *
+ * Execution semantics:
+ *   - `shellExec(cmd)` throws `ShellExecError` on non-zero exit (fail-fast
+ *     is the default). CI/CD chains observe the failure end-to-end.
+ *   - `shellExec(cmd, { silentOnError: true })` opts out — returns the
+ *     `ShellString` result with `.code/.stdout/.stderr` so callers can
+ *     branch on the exit code themselves. Use for existence checks
+ *     (`test -x …`, `command -v …`, `kubectl get` when "missing" is a
+ *     normal answer).
+ *   - `shellExec(cmd, { cwd: "..." })` runs hermetically in `cwd` without
+ *      touching shelljs's global state.
+ *   - All children spawned by `shellExec` register in
+ *     `ProcessController.children` so SIGINT/SIGTERM forwarding can reach
+ *     them before the parent exits.
+ *
  * @module src/server/process.js
  * @namespace Process
  */
@@ -19,6 +35,12 @@ const logger = loggerFactory(import.meta);
 const getRootDirectory = () => process.cwd().replace(/\\/g, '/');
 /**
  * Controls and manages process-level events and signals.
+ *
+ * Subprocess registry: any child process tracked here will receive
+ * SIGTERM (followed by SIGKILL after a short grace period) when the
+ * parent receives SIGINT or SIGTERM. This prevents orphaned children
+ * during Ctrl+C in dev and during pod-termination in K8S.
+ *
  * @namespace ProcessController
  */
 class ProcessController {
@@ -41,9 +63,41 @@ class ProcessController {
     'SIGSEGV',
     'SIGILL',
   ];
+
+  /**
+   * Registry of currently running tracked child processes.
+   * Populated when callers spawn via the streaming Node-native path
+   * (future expansion). The sets are exposed so signal handlers and
+   * test harnesses can introspect / clean up the registry.
+   */
+  static children = new Set();
+
+  /** Internal: forward terminating signals to all tracked children. */
+  static _forwardToChildren(sig) {
+    if (ProcessController.children.size === 0) return;
+    for (const child of [...ProcessController.children]) {
+      try {
+        if (!child.killed) child.kill(sig);
+      } catch (_) {
+        // child may already have exited; ignore.
+      }
+    }
+    // Hard SIGKILL after 5s grace if any child is still alive.
+    setTimeout(() => {
+      for (const child of [...ProcessController.children]) {
+        try {
+          if (!child.killed) child.kill('SIGKILL');
+        } catch (_) {
+          /* noop */
+        }
+      }
+    }, 5000).unref();
+  }
+
   /**
    * Sets up listeners for various process signals defined in {@link ProcessController.SIG}.
-   * Handles graceful exit on 'SIGINT' (Ctrl+C).
+   * Handles graceful exit on 'SIGINT' (Ctrl+C) — but first forwards the
+   * signal to every tracked child so they get a chance to clean up.
    * @memberof ProcessController
    * @returns {Array<process.Process>} An array of process listener handles.
    */
@@ -53,7 +107,14 @@ class ProcessController {
         ProcessController.logger.info(`process on ${sig}`, args);
         switch (sig) {
           case 'SIGINT':
-            return process.exit();
+          case 'SIGTERM':
+          case 'SIGHUP':
+            ProcessController._forwardToChildren('SIGTERM');
+            // Give children a moment to exit cleanly before our own exit.
+            if (sig === 'SIGINT') {
+              setTimeout(() => process.exit(130), 200).unref();
+            }
+            break;
           default:
             break;
         }
@@ -71,33 +132,111 @@ class ProcessController {
     ProcessController.logger = logger;
     process.on('exit', (...args) => {
       ProcessController.logger.info(`process on exit`, args);
+      // Last-chance reap: any tracked child still alive at exit time
+      // gets a hard kill so the parent does not leak orphans into the
+      // pod / shell session.
+      ProcessController._forwardToChildren('SIGKILL');
     });
     ProcessController.onSigListen();
-    Underpost.env.delete('await-deploy');
+  }
+}
+/**
+ * `ShellExecError` — thrown by `shellExec` when the underlying command
+ * exits with a non-zero code (the default fail-fast behaviour). Carries
+ * the exit code, stdout, and stderr for inspection by callers / CI
+ * pipelines that need structured failure data.
+ */
+class ShellExecError extends Error {
+  constructor(cmd, code, stdout, stderr) {
+    super(`shellExec failed (exit=${code}): ${cmd}`);
+    this.name = 'ShellExecError';
+    this.cmd = cmd;
+    this.code = code;
+    this.stdout = stdout;
+    this.stderr = stderr;
   }
 }
 /**
  * Executes a shell command using shelljs.
+ *
+ * **Default behaviour is fail-fast**: a non-zero exit code throws
+ * `ShellExecError`. Callers that need to branch on the exit code
+ * (existence checks, optional commands) must pass `silentOnError: true`
+ * to opt out of throwing.
+ *
+ * The async-callback path is exempt from the throw — shelljs delivers
+ * `(code, stdout, stderr)` to the callback, which owns its own error
+ * handling.
+ *
  * @memberof Process
  * @param {string} cmd - The command string to execute.
  * @param {Object} [options] - Options for execution.
- * @param {boolean} [options.silent=false] - Suppress output from shell commands.
- * @param {boolean} [options.async=false] - Run command asynchronously.
- * @param {boolean} [options.stdout=false] - Return stdout content (string) instead of shelljs result object.
- * @param {boolean} [options.disableLog=false] - Prevent logging of the command.
- * @param {Function} [options.callback=null] - Callback function for asynchronous execution.
- * @returns {string|shelljs.ShellString} The result of the shell command (string if `stdout: true`, otherwise a ShellString object).
+ * @param {boolean} [options.silent=false] - Suppress child stdout/stderr to the parent terminal.
+ * @param {boolean} [options.async=false] - Run the command asynchronously (use with `callback`).
+ * @param {boolean} [options.stdout=false] - Return stdout string instead of the `ShellString` result object.
+ * @param {boolean} [options.disableLog=false] - Skip the `[process] cmd …` info log line.
+ * @param {Function} [options.callback=null] - Async callback `(code, stdout, stderr) => void` when `async: true`.
+ * @param {boolean} [options.silentOnError=false] - When `true`, swallow non-zero exits and return the `ShellString` instead of throwing. Inverse of the previous `throwOnError` flag.
+ * @param {string} [options.cwd] - Hermetic working directory (snapshotted + restored — does NOT leak).
+ * @returns {string|shelljs.ShellString} `ShellString` by default; the stdout string when `stdout: true`.
+ * @throws {ShellExecError} On non-zero exit when `silentOnError` is not set.
  */
-const shellExec = (
-  cmd,
-  options = { silent: false, async: false, stdout: false, disableLog: false, callback: null },
-) => {
+const shellExec = (cmd, options = {}) => {
   if (!options.disableLog) logger.info(`cmd`, cmd);
-  if (options.callback) return shell.exec(cmd, options, options.callback);
-  return options.stdout ? shell.exec(cmd, options).stdout : shell.exec(cmd, options);
+
+  // Whitelist exactly the keys `shelljs.exec` understands. Passing our own
+  // bookkeeping keys through (or a literal `cwd: undefined`) makes shelljs
+  // call `path.resolve(undefined)` and crash with ERR_INVALID_ARG_TYPE.
+  const shellOpts = {};
+  if (options.silent !== undefined) shellOpts.silent = options.silent;
+  if (options.async !== undefined) shellOpts.async = options.async;
+
+  // Hermetic cwd. shelljs.cd mutates a process-wide global; instead we
+  // snapshot the current cwd here, switch for the duration of this call,
+  // and restore in `finally`. We deliberately do NOT forward `cwd` to
+  // shelljs — leaving its `cwd` unset means it inherits our just-changed
+  // `process.cwd()`, and we keep full control of restore semantics.
+  const previousCwd = options.cwd ? process.cwd() : null;
+  if (options.cwd) {
+    try {
+      process.chdir(options.cwd);
+    } catch (err) {
+      if (Underpost.env.isInsideContainer()) Underpost.env.set('container-status', 'error')
+      throw new ShellExecError(cmd, -1, '', `chdir(${options.cwd}) failed: ${err.message}`);
+    }
+  }
+  try {
+    if (options.callback) {
+      // Async path. shelljs invokes the callback with (code, stdout, stderr).
+      // The callback owns its own error handling; the throw default does
+      // not apply here.
+      return shell.exec(cmd, shellOpts, options.callback);
+    }
+    const result = shell.exec(cmd, shellOpts);
+
+    if (!options.silentOnError && result && typeof result.code === 'number' && result.code !== 0) {
+      if (Underpost.env.isInsideContainer()) Underpost.env.set('container-status', 'error')
+      throw new ShellExecError(cmd, result.code, result.stdout || '', result.stderr || '');
+    }
+
+    return options.stdout ? result.stdout : result;
+  } finally {
+    if (previousCwd) {
+      try {
+        process.chdir(previousCwd);
+      } catch (_) {
+        /* best-effort restore */
+      }
+    }
+  }
 };
 /**
  * Changes the current working directory using shelljs.
+ *
+ * Note: `shellCd` mutates global state. Prefer `shellExec(cmd, { cwd })`
+ * for one-shot directory-scoped commands; use `shellCd` only for the
+ * outermost shell where the cwd should persist across many calls.
+ *
  * @memberof Process
  * @param {string} cd - The path to change the directory to.
  * @param {Object} [options] - Options for the CD operation.
@@ -110,6 +249,11 @@ const shellCd = (cd, options = { disableLog: false }) => {
 };
 /**
  * Wraps a command to run it as a daemon process in a shell (keeping the process alive/terminal open).
+ *
+ * NB: callers must ensure `cmd` does not contain unescaped single quotes —
+ * the wrapper uses `bash -c '<cmd>; …'`. For arbitrary user input prefer
+ * a heredoc or a temporary script file.
+ *
  * @memberof Process
  * @param {string} cmd - The command to daemonize.
  * @returns {string} The shell command string for the daemon process.
@@ -119,11 +263,19 @@ const daemonProcess = (cmd) => `exec bash -c '${cmd}; exec tail -f /dev/null'`;
  * Retrieves the process ID (PID) of the most recently created gnome-terminal instance.
  * Note: This function is environment-specific (GNOME/Linux) and uses `pgrep -n`.
  * @memberof Process
- * @returns {number} The PID of the last gnome-terminal process.
+ * @returns {number|null} The PID of the last gnome-terminal process, or null if none running.
  */
 // list all terminals: pgrep gnome-terminal
 // list last terminal: pgrep -n gnome-terminal
-const getTerminalPid = () => JSON.parse(shellExec(`pgrep -n gnome-terminal`, { stdout: true, silent: true }));
+const getTerminalPid = () => {
+  const raw = shellExec(`pgrep -n gnome-terminal`, { stdout: true, silent: true, silentOnError: true });
+  if (!raw || !raw.trim()) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
 /**
  * Copies text content to the system clipboard using clipboardy.
  * Logs the copied content for confirmation.
@@ -135,4 +287,13 @@ function pbcopy(data) {
   clipboard.writeSync(data || '🦄');
   logger.info(`copied to clipboard`, clipboard.readSync());
 }
-export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy, getTerminalPid, daemonProcess };
+export {
+  ProcessController,
+  ShellExecError,
+  getRootDirectory,
+  shellExec,
+  shellCd,
+  pbcopy,
+  getTerminalPid,
+  daemonProcess,
+};

package/src/server/proxy.js

@@ -9,7 +9,14 @@
 import express from 'express';
 import { createProxyMiddleware } from 'http-proxy-middleware';
 import { loggerFactory, loggerMiddleware } from './logger.js';
-import { buildPortProxyRouter, buildProxyRouter, getTlsHosts, isDevProxyContext, isTlsDevProxy } from './conf.js';
+import {
+  buildPortProxyRouter,
+  buildProxyRouter,
+  etcHostFactory,
+  getTlsHosts,
+  isDevProxyContext,
+  isTlsDevProxy,
+} from './conf.js';
 
 import { shellExec } from './process.js';
 import fs from 'fs-extra';
@@ -114,7 +121,7 @@ class ProxyService {
       logger.info('Proxy running', { port, router: options.router });
       if (process.env.NODE_ENV === 'development')
         logger.info(
-          Underpost.deploy.etcHostFactory(Object.keys(options.router), {
+          etcHostFactory(Object.keys(options.router), {
             append: true,
           }).renderHosts,
         );

package/src/server/runtime.js

@@ -176,7 +176,7 @@ const buildRuntime = async () => {
   }
 
   if (Lampp.enabled() && Lampp.router) Lampp.initService();
-
+  Underpost.env.delete('await-deploy');
   Underpost.start.logRuntimeRouter();
 };
 

package/src/server/start.js

@@ -198,20 +198,32 @@ class UnderpostStartUp {
      */
     async run(deployId = 'dd-default', env = 'development', options = {}) {
       const runCmd = env === 'production' ? 'run prod:container' : 'run dev:container';
+      const makeDeployCallback = (cmd) => (code, out, msg) => {
+        if (code !== 0) {
+          logger.error(`Deployment process exited with code ${code}`, { cmd, msg });
+          Underpost.env.set('container-status', 'error');
+        }
+      };
       if (fs.existsSync(`./engine-private/replica`)) {
         const replicas = await fs.readdir(`./engine-private/replica`);
         for (const replica of replicas) {
           if (!replica.match(deployId)) continue;
           shellExec(`node bin env ${replica} ${env}`);
-          shellExec(`npm ${runCmd} ${replica}`, { async: true });
-          await awaitDeployMonitor(true);
+          const replicaCmd = `npm ${runCmd} ${replica}`;
+          shellExec(replicaCmd, { async: true, callback: makeDeployCallback(replicaCmd) });
+          await awaitDeployMonitor();
         }
       }
       shellExec(`node bin env ${deployId} ${env}`);
-      shellExec(`npm ${runCmd} ${deployId}`, { async: true });
+      const deployCmd = `npm ${runCmd} ${deployId}`;
+      shellExec(deployCmd, { async: true, callback: makeDeployCallback(deployCmd) });
       await awaitDeployMonitor(true);
-      if (env === 'production' && Underpost.env.isInsideContainer()) Underpost.secret.globalSecretClean();
-      Underpost.env.set('container-status', `${deployId}-${env}-running-deployment`);
+      if (Underpost.env.get('container-status') !== 'error') {
+        if (env === 'production' && Underpost.env.isInsideContainer()) Underpost.secret.globalSecretClean();
+        Underpost.env.set('container-status', `${deployId}-${env}-running-deployment`);
+      } else {
+        Underpost.env.set('container-status', 'error');
+      }
     },
   };
 }

package/src/server/valkey.js

@@ -14,6 +14,7 @@
  */
 import Valkey from 'iovalkey';
 import { loggerFactory } from './logger.js';
+import Underpost from '../index.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -70,6 +71,7 @@ const createValkeyConnection = async (instance = {}, connectionOptions = {}) =>
   client.on('error', (err) => {
     ValkeyStatus[key] = 'error';
     logger.error('Valkey error', { err: err?.message, instance });
+    if (Underpost.env.isInsideContainer()) Underpost.env.set('container-status', 'error');
   });
   client.on('reconnecting', () => {
     ValkeyStatus[key] = 'reconnecting';

package/src/ws/IoInterface.js

@@ -46,9 +46,9 @@ class IoChannel {
   constructor(IoInterface) {
     this.#IoInterface = {
       channel: '',
-      connection: async (socket = {}, client = {}, wsManagementId = '') => {},
-      controller: async (socket = {}, client = {}, payload = {}, wsManagementId = '', args = []) => {},
-      disconnect: async (socket = {}, client = {}, reason = '', wsManagementId = '') => {},
+      connection: async (socket = {}, client = {}, hostKeyContext = '') => { },
+      controller: async (socket = {}, client = {}, payload = {}, hostKeyContext = '', args = []) => { },
+      disconnect: async (socket = {}, client = {}, reason = '', hostKeyContext = '') => { },
       stream: false,
       ...IoInterface,
     };
@@ -68,18 +68,18 @@ class IoChannel {
    * Sets up the listener for the channel message.
    *
    * @param {Socket} socket - The Socket.IO socket object.
-   * @param {string} wsManagementId - Unique identifier for the WebSocket management context.
+   * @param {string} hostKeyContext - Unique identifier for the WebSocket management context.
    * @returns {Promise<void>}
    */
-  async connection(socket, wsManagementId) {
+  async connection(socket, hostKeyContext) {
     try {
       this.client[socket.id] = socket;
       // Use bind/arrow function to maintain 'this' context for the controller
-      socket.on(this.channel, (...args) => this.controller(socket, args, wsManagementId));
-      await this.#IoInterface.connection(socket, this.client, wsManagementId);
+      socket.on(this.channel, (...args) => this.controller(socket, args, hostKeyContext));
+      await this.#IoInterface.connection(socket, this.client, hostKeyContext);
       logger.debug(`Socket ${socket.id} connected to channel ${this.channel}`);
     } catch (error) {
-      logger.error(error, { channel: this.channel, wsManagementId, stack: error.stack });
+      logger.error(error, { channel: this.channel, hostKeyContext, stack: error.stack });
     }
   }
 
@@ -89,10 +89,10 @@ class IoChannel {
    * @method
    * @param {Socket} socket - The Socket.IO socket object.
    * @param {any[]} args - The raw arguments received from the socket event.
-   * @param {string} wsManagementId - Unique identifier for the WebSocket management context.
+   * @param {string} hostKeyContext - Unique identifier for the WebSocket management context.
    * @returns {Promise<void>}
    */
-  async controller(socket, args, wsManagementId) {
+  async controller(socket, args, hostKeyContext) {
     try {
       if (!args || args.length === 0) {
         logger.warn(`No arguments received for channel: ${this.channel}`, { socketId: socket.id });
@@ -101,9 +101,9 @@ class IoChannel {
       // Determine if JSON parsing is needed based on the stream flag
       const payload = this.#IoInterface.stream ? args[0] : JSON.parse(args[0]);
 
-      await this.#IoInterface.controller(socket, this.client, payload, wsManagementId, args);
+      await this.#IoInterface.controller(socket, this.client, payload, hostKeyContext, args);
     } catch (error) {
-      logger.error(error, { channel: this.channel, wsManagementId, socketId: socket.id, args, stack: error.stack });
+      logger.error(error, { channel: this.channel, hostKeyContext, socketId: socket.id, args, stack: error.stack });
     }
   }
 
@@ -112,16 +112,16 @@ class IoChannel {
    *
    * @param {Socket} socket - The Socket.IO socket object.
    * @param {string} reason - The reason for disconnection (e.g., 'client namespace disconnect').
-   * @param {string} wsManagementId - Unique identifier for the WebSocket management context.
+   * @param {string} hostKeyContext - Unique identifier for the WebSocket management context.
    * @returns {Promise<void>}
    */
-  async disconnect(socket, reason, wsManagementId) {
+  async disconnect(socket, reason, hostKeyContext) {
     try {
-      await this.#IoInterface.disconnect(socket, this.client, reason, wsManagementId);
+      await this.#IoInterface.disconnect(socket, this.client, reason, hostKeyContext);
       delete this.client[socket.id];
       logger.debug(`Socket ${socket.id} disconnected from channel ${this.channel}. Reason: ${reason}`);
     } catch (error) {
-      logger.error(error, { channel: this.channel, wsManagementId, reason, socketId: socket.id, stack: error.stack });
+      logger.error(error, { channel: this.channel, hostKeyContext, reason, socketId: socket.id, stack: error.stack });
     }
   }
 }

package/src/ws/core/channels/core.ws.chat.js

@@ -12,13 +12,13 @@ import { CoreWsEmitter } from '../core.ws.emit.js';
  * Broadcasts incoming messages to all other connected sockets.
  */
 class CoreWsChatChannel {
-  /** @type {Object.<string, Object>} Per-instance state keyed by wsManagementId. */
+  /** @type {Object.<string, Object>} Per-instance state keyed by hostKeyContext. */
   static #state = {};
 
   /** @type {IoChannel} */
   static #io = new IoChannel({
     channel: 'chat',
-    controller(socket, client, payload, wsManagementId) {
+    controller(socket, client, payload, hostKeyContext) {
       for (const socketId of Object.keys(client)) {
         if (socketId !== socket.id) {
           CoreWsEmitter.emit('chat', client[socketId], { id: socket.id, ...payload });
@@ -39,29 +39,29 @@ class CoreWsChatChannel {
 
   /**
    * Initializes state for a server instance.
-   * @param {string} wsManagementId - Unique server context ID.
+   * @param {string} hostKeyContext - Unique server context ID.
    */
-  static init(wsManagementId) {
-    this.#state[wsManagementId] = {};
+  static init(hostKeyContext) {
+    this.#state[hostKeyContext] = {};
   }
 
   /**
    * Registers a socket connection.
    * @param {import('socket.io').Socket} socket
-   * @param {string} wsManagementId
+   * @param {string} hostKeyContext
    */
-  static connection(socket, wsManagementId) {
-    return this.#io.connection(socket, wsManagementId);
+  static connection(socket, hostKeyContext) {
+    return this.#io.connection(socket, hostKeyContext);
   }
 
   /**
    * Handles socket disconnection.
    * @param {import('socket.io').Socket} socket
    * @param {string} reason
-   * @param {string} wsManagementId
+   * @param {string} hostKeyContext
    */
-  static disconnect(socket, reason, wsManagementId) {
-    return this.#io.disconnect(socket, reason, wsManagementId);
+  static disconnect(socket, reason, hostKeyContext) {
+    return this.#io.disconnect(socket, reason, hostKeyContext);
   }
 }
 

package/src/ws/core/channels/core.ws.mailer.js

@@ -12,29 +12,29 @@ import { IoChannel } from '../../IoInterface.js';
  * Handles register/unregister messages and cleanup on disconnect.
  */
 class CoreWsMailerChannel {
-  /** @type {Object.<string, Object.<string, { model: { user: Object } }>>} Socket data keyed by `[wsManagementId][socketId]`. */
+  /** @type {Object.<string, Object.<string, { model: { user: Object } }>>} Socket data keyed by `[hostKeyContext][socketId]`. */
   static #data = {};
 
-  /** @type {Object.<string, Object.<string, string>>} Reverse index: `[wsManagementId][userId]` → socketId. */
+  /** @type {Object.<string, Object.<string, string>>} Reverse index: `[hostKeyContext][userId]` → socketId. */
   static #userIndex = {};
 
   /** @type {IoChannel} */
   static #io = new IoChannel({
     channel: 'mailer',
-    controller(socket, client, payload, wsManagementId) {
+    controller(socket, client, payload, hostKeyContext) {
       switch (payload.status) {
         case 'register-user':
-          CoreWsMailerChannel.setUser(wsManagementId, socket.id, payload.user);
+          CoreWsMailerChannel.setUser(hostKeyContext, socket.id, payload.user);
           break;
         case 'unregister-user':
-          CoreWsMailerChannel.removeSocket(wsManagementId, socket.id);
+          CoreWsMailerChannel.removeSocket(hostKeyContext, socket.id);
           break;
         default:
           break;
       }
     },
-    disconnect(socket, client, reason, wsManagementId) {
-      CoreWsMailerChannel.removeSocket(wsManagementId, socket.id);
+    disconnect(socket, client, reason, hostKeyContext) {
+      CoreWsMailerChannel.removeSocket(hostKeyContext, socket.id);
     },
   });
 
@@ -50,66 +50,66 @@ class CoreWsMailerChannel {
 
   /**
    * Initializes state for a server instance.
-   * @param {string} wsManagementId - Unique server context ID (`${host}${path}`).
+   * @param {string} hostKeyContext - Unique server context ID (`${host}${path}`).
    */
-  static init(wsManagementId) {
-    this.#data[wsManagementId] = {};
-    this.#userIndex[wsManagementId] = {};
+  static init(hostKeyContext) {
+    this.#data[hostKeyContext] = {};
+    this.#userIndex[hostKeyContext] = {};
   }
 
   /**
    * Registers a socket connection.
    * @param {import('socket.io').Socket} socket
-   * @param {string} wsManagementId
+   * @param {string} hostKeyContext
    */
-  static connection(socket, wsManagementId) {
-    return this.#io.connection(socket, wsManagementId);
+  static connection(socket, hostKeyContext) {
+    return this.#io.connection(socket, hostKeyContext);
   }
 
   /**
    * Handles socket disconnection.
    * @param {import('socket.io').Socket} socket
    * @param {string} reason
-   * @param {string} wsManagementId
+   * @param {string} hostKeyContext
    */
-  static disconnect(socket, reason, wsManagementId) {
-    return this.#io.disconnect(socket, reason, wsManagementId);
+  static disconnect(socket, reason, hostKeyContext) {
+    return this.#io.disconnect(socket, reason, hostKeyContext);
   }
 
   /**
    * Registers a user↔socket mapping.
-   * @param {string} wsManagementId
+   * @param {string} hostKeyContext
    * @param {string} socketId
    * @param {Object} user - User data with `_id` property.
    */
-  static setUser(wsManagementId, socketId, user) {
-    this.#data[wsManagementId][socketId] = { model: { user } };
+  static setUser(hostKeyContext, socketId, user) {
+    this.#data[hostKeyContext][socketId] = { model: { user } };
     if (user?._id) {
-      this.#userIndex[wsManagementId][user._id.toString()] = socketId;
+      this.#userIndex[hostKeyContext][user._id.toString()] = socketId;
     }
   }
 
   /**
    * Removes a socket entry and its reverse user index.
-   * @param {string} wsManagementId
+   * @param {string} hostKeyContext
    * @param {string} socketId
    */
-  static removeSocket(wsManagementId, socketId) {
-    const entry = this.#data[wsManagementId]?.[socketId];
+  static removeSocket(hostKeyContext, socketId) {
+    const entry = this.#data[hostKeyContext]?.[socketId];
     if (entry?.model?.user?._id) {
-      delete this.#userIndex[wsManagementId][entry.model.user._id.toString()];
+      delete this.#userIndex[hostKeyContext][entry.model.user._id.toString()];
     }
-    delete this.#data[wsManagementId]?.[socketId];
+    delete this.#data[hostKeyContext]?.[socketId];
   }
 
   /**
    * Finds the socket ID for a user (O(1) reverse index lookup).
-   * @param {string} wsManagementId
+   * @param {string} hostKeyContext
    * @param {string} userId - The user `_id`.
    * @returns {string|undefined} Socket ID, or `undefined` if not connected.
    */
-  static getUserWsId(wsManagementId, userId) {
-    return this.#userIndex[wsManagementId]?.[userId];
+  static getUserWsId(hostKeyContext, userId) {
+    return this.#userIndex[hostKeyContext]?.[userId];
   }
 }