@mh-gg/cli 0.1.1-alpha.20260613T085325975Z

package/runtime/host/host.cjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+const path = require("node:path");
+const WebSocket = require("ws");
+const { ensureRoomSecurity } = require("@mh-gg/room-security");
+const { parseArgs } = require("@mh-gg/host-config");
+const { loadStore, saveStore } = require("@mh-gg/host-store");
+const { normalizeAppUrl } = require("@mh-gg/room-link");
+const { applymatterhornrcDefaults } = require("./matterhornrc.cjs");
+const { ensureLocalRelay, relayIpcUrl } = require("./localRelayClient.cjs");
+const { createHostSession } = require("./hostSession.cjs");
+
+function roomAppFromEnv(env = process.env) {
+  if (!env.MATTERHORN_ROOM_APP) return undefined;
+  try {
+    const value = JSON.parse(env.MATTERHORN_ROOM_APP);
+    if (!value || typeof value !== "object") return undefined;
+    return value;
+  } catch {
+    return undefined;
+  }
+}
+
+function frontendBundleFromEnv(env = process.env) {
+  if (!env.MATTERHORN_FRONTEND_BUNDLE_FILE) return undefined;
+  let rebuild;
+  if (env.MATTERHORN_FRONTEND_BUNDLE_REBUILD) {
+    try {
+      const parsed = JSON.parse(env.MATTERHORN_FRONTEND_BUNDLE_REBUILD);
+      if (parsed && typeof parsed === "object" && typeof parsed.command === "string") rebuild = parsed;
+    } catch {
+      rebuild = undefined;
+    }
+  }
+  const sourceRoots = env.MATTERHORN_FRONTEND_BUNDLE_SOURCE_ROOTS
+    ? env.MATTERHORN_FRONTEND_BUNDLE_SOURCE_ROOTS.split(path.delimiter).filter(Boolean).map((item) => path.resolve(item))
+    : undefined;
+  return {
+    file: path.resolve(env.MATTERHORN_FRONTEND_BUNDLE_FILE),
+    id: env.MATTERHORN_FRONTEND_BUNDLE_ID || undefined,
+    integrity: env.MATTERHORN_FRONTEND_BUNDLE_INTEGRITY || undefined,
+    dynamic: env.MATTERHORN_FRONTEND_BUNDLE_DYNAMIC === "1",
+    sourceRoot: env.MATTERHORN_FRONTEND_BUNDLE_SOURCE_ROOT ? path.resolve(env.MATTERHORN_FRONTEND_BUNDLE_SOURCE_ROOT) : undefined,
+    ...(sourceRoots ? { sourceRoots } : {}),
+    rebuild
+  };
+}
+
+function appRefFromEnv(env = process.env) {
+  if (!env.MATTERHORN_APP_REF) return undefined;
+  return {
+    appRef: env.MATTERHORN_APP_REF,
+    appCwd: env.MATTERHORN_APP_CWD || process.cwd()
+  };
+}
+
+async function main() {
+  applymatterhornrcDefaults();
+  const args = parseArgs(process.argv.slice(2), {
+    defaultDataDir: path.join(__dirname, "data")
+  });
+  const store = loadStore(args);
+  const appUrl = normalizeAppUrl(args.appUrl);
+  const localRelay = await ensureLocalRelay({
+    relayPeers: args.relayPeers,
+    iceServers: args.iceServers,
+    localPeerjs: args.localPeerjs
+  });
+  const roomPeerId = localRelay.info.relayPeerId || localRelay.config.relayPeerId;
+  store.roomPeerId = roomPeerId;
+  store.relayAddress = localRelay.info.relayAddress || localRelay.config.relayAddress;
+  const roomApp = roomAppFromEnv();
+  if (roomApp) store.roomApp = roomApp;
+  ensureRoomSecurity(store);
+  saveStore(store);
+
+  const hostSession = createHostSession({
+    store,
+    args,
+    appUrl,
+    ...appRefFromEnv(),
+    frontendBundle: frontendBundleFromEnv(),
+    localRelay,
+    roomPeerId,
+    reconnectRelay: true
+  });
+  const relaySocket = new WebSocket(relayIpcUrl(localRelay.config));
+  hostSession.attachRelaySocket(relaySocket);
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  frontendBundleFromEnv,
+  appRefFromEnv,
+  main,
+  roomAppFromEnv
+};

package/runtime/host/hostAnnouncement.cjs

@@ -0,0 +1,70 @@
+const qrcode = require("qrcode-terminal");
+const { activePublicInvite } = require("@mh-gg/room-security");
+const { stateFile } = require("@mh-gg/host-store");
+const { buildInviteUrl } = require("@mh-gg/room-link");
+const { peerJsSignalingUrl } = require("./peerJsConfig.cjs");
+
+function buildInvite(store, appUrl, roomPeerId, invite, adminToken) {
+  return buildInviteUrl(appUrl, store.roomName, roomPeerId, invite.secret, store.relayAddress, invite.id, adminToken);
+}
+
+function announceGuestInvite(options) {
+  const {
+    store,
+    appUrl,
+    roomPeerId,
+    logger = console,
+    qr = qrcode
+  } = options;
+  const invite = activePublicInvite(store);
+  if (!invite) {
+    logger.log("Guest Invite: no active public invite\n");
+    return false;
+  }
+
+  const shareUrl = buildInvite(store, appUrl, roomPeerId, invite);
+  logger.log(`Guest Invite: ${shareUrl}\n`);
+  qr.generate(shareUrl, { small: true });
+  return true;
+}
+
+function announceHost(options) {
+  const {
+    store,
+    appUrl,
+    localRelay,
+    roomPeerId,
+    logger = console,
+    qr = qrcode
+  } = options;
+
+  logger.log("\nMatterhorn host is live through the local relay.");
+  logger.log(`Room:        ${store.roomName}`);
+  logger.log(`Room peer:   ${roomPeerId}`);
+  logger.log(`Relay mesh:  ${store.relayAddress}`);
+  logger.log(`Relay IPC:   ws://${localRelay.config.ipcHost}:${localRelay.config.ipcPort}/room${localRelay.spawned ? " (started)" : " (existing)"}`);
+  logger.log(`Signaling:   ${peerJsSignalingUrl()}`);
+  logger.log(`Launcher:    ${appUrl}`);
+  if (store.roomApp?.appPack?.id) logger.log(`Room app:    ${store.roomApp.appPack.id}@${store.roomApp.appPack.version || "unknown"}`);
+  const frontend = Array.isArray(store.roomApp?.frontends) ? store.roomApp.frontends[0] : undefined;
+  if (frontend?.id) logger.log(`Frontend:    ${frontend.id}@${frontend.version || "unknown"} via ${frontend.delivery || "unknown"}`);
+  logger.log(`Data file:   ${stateFile(store.dataDir, store.roomName)}`);
+  const invite = activePublicInvite(store);
+  let guestInviteAnnounced = false;
+  if (invite) {
+    if (store.adminBootstrapToken) {
+      const adminUrl = buildInvite(store, appUrl, roomPeerId, invite, store.adminBootstrapToken);
+      logger.log(`JOIN AS ADMIN: ${adminUrl}\n`);
+    }
+    guestInviteAnnounced = announceGuestInvite(options);
+  } else {
+    logger.log("Guest Invite: no active public invite\n");
+  }
+  logger.log("\nKeep this process running while guests are connected. Press Ctrl+C to stop.\n");
+  return { guestInviteAnnounced };
+}
+
+module.exports = {
+  announceGuestInvite,
+  announceHost
+};

package/runtime/host/hostClients/constants.cjs

@@ -0,0 +1,7 @@
+const OPERATION_SNAPSHOT_INTERVAL = 50;
+const DEFAULT_FRONTEND_CHUNK_BYTES = 11 * 1024;
+
+module.exports = {
+  DEFAULT_FRONTEND_CHUNK_BYTES,
+  OPERATION_SNAPSHOT_INTERVAL
+};

package/runtime/host/hostClients/frontendBundleRefresh.cjs

@@ -0,0 +1,158 @@
+const fs = require("node:fs");
+const { createHash } = require("node:crypto");
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+const { commandInvocation, replaceTokens } = require("../../bin/appFrontend/processes.cjs");
+const { buildMatterhornCommandEnv } = require("../../bin/appFrontend/commandEnv.cjs");
+const { assertAppCommandAllowed, commandEnvTrustForPolicy } = require("../../bin/appFrontend/commandPolicy.cjs");
+
+function fileIntegrity(file) {
+  return `sha256-${createHash("sha256").update(fs.readFileSync(file)).digest("hex")}`;
+}
+
+function isIgnoredSourcePath(candidate, ignoredRoots) {
+  const base = path.basename(candidate);
+  if (base === "node_modules" || base === ".git") return true;
+  const resolved = path.resolve(candidate);
+  return ignoredRoots.some((ignoredRoot) => {
+    const relative = path.relative(ignoredRoot, resolved);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+  });
+}
+
+function latestSourceMtime(root, ignoredRoots) {
+  const stat = fs.existsSync(root) ? fs.statSync(root) : undefined;
+  if (stat?.isFile()) return isIgnoredSourcePath(root, ignoredRoots) ? 0 : stat.mtimeMs;
+  let latest = 0;
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current || isIgnoredSourcePath(current, ignoredRoots)) continue;
+    let entries;
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const entryPath = path.join(current, entry.name);
+      if (isIgnoredSourcePath(entryPath, ignoredRoots)) continue;
+      if (entry.isDirectory()) {
+        pending.push(entryPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      try {
+        latest = Math.max(latest, fs.statSync(entryPath).mtimeMs);
+      } catch {
+        continue;
+      }
+    }
+  }
+  return latest;
+}
+
+function latestSourceRootsMtime(roots, ignoredRoots) {
+  return roots.reduce((latest, root) => Math.max(latest, latestSourceMtime(root, ignoredRoots)), 0);
+}
+
+function rebuildEnv(rebuild, options, policy) {
+  const env = Object.fromEntries(
+    Object.entries(rebuild.env || {}).map(([key, value]) => [key, replaceTokens(value, options)])
+  );
+  return buildMatterhornCommandEnv({
+    trust: commandEnvTrustForPolicy(policy || rebuild.trust || "trusted-local-dev"),
+    commandEnv: env,
+    port: options.port,
+    bundlePort: options.bundlePort,
+    mountPath: options.mountPath,
+    unsafeInheritEnv: rebuild.unsafeInheritEnv,
+    allowSensitiveCommandEnv: rebuild.allowSensitiveCommandEnv
+  });
+}
+
+function runRebuildCommand(command, options, policy) {
+  if (!command?.command) return true;
+  const args = Array.isArray(command.args) ? command.args.map((arg) => replaceTokens(arg, options)) : [];
+  const invocation = commandInvocation(command.command, args);
+  const result = spawnSync(invocation.command, invocation.args, {
+    cwd: command.cwd || process.cwd(),
+    env: rebuildEnv(command, options, policy),
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  return result.status === 0;
+}
+
+function runDynamicBundleRebuild(frontendBundle) {
+  const rebuild = frontendBundle?.rebuild;
+  if (!rebuild?.command) return false;
+  const policy = assertAppCommandAllowed({ commandExecution: rebuild.trust || "trusted-local-dev" }, "matterhorn dynamic bundle rebuild");
+  const options = {
+    port: rebuild.port || 0,
+    bundlePort: rebuild.bundlePort || rebuild.port || 0,
+    mountPath: rebuild.mountPath || "/"
+  };
+  for (const command of rebuild.before || []) {
+    if (!runRebuildCommand(command, options, policy)) return false;
+  }
+  return runRebuildCommand(rebuild, options, policy);
+}
+
+function rebuildDynamicBundleIfSourceChanged(frontendBundle) {
+  if (!frontendBundle?.dynamic || !frontendBundle.sourceRoot || !frontendBundle.file) return;
+  const roots = (frontendBundle.sourceRoots || [frontendBundle.sourceRoot]).filter(Boolean).map((root) => path.resolve(root));
+  if (roots.length === 0 || roots.every((root) => !fs.existsSync(root))) return;
+  const bundleFile = path.resolve(frontendBundle.file);
+  const bundleDir = path.dirname(bundleFile);
+  const bundleMtime = fs.existsSync(bundleFile) ? fs.statSync(bundleFile).mtimeMs : 0;
+  if (latestSourceRootsMtime(roots, [bundleDir]) <= bundleMtime) return;
+  runDynamicBundleRebuild(frontendBundle);
+}
+
+function createDynamicFrontendRefresher({ store, frontendBundle, onRoomAppChange = () => {} }) {
+  function refreshDynamicFrontend(frontend) {
+    if (!frontendBundle?.dynamic || !frontendBundle.file || !frontend) return frontend;
+    if (frontendBundle.id && frontendBundle.id !== frontend.id) return frontend;
+    rebuildDynamicBundleIfSourceChanged(frontendBundle);
+    if (!fs.existsSync(frontendBundle.file)) return frontend;
+    let stat;
+    let integrity;
+    try {
+      stat = fs.statSync(frontendBundle.file);
+      if (!stat.isFile()) return frontend;
+      integrity = fileIntegrity(frontendBundle.file);
+    } catch {
+      return frontend;
+    }
+    if (frontend.integrity === integrity && frontend.byteLength === stat.size) return frontend;
+
+    const frontends = Array.isArray(store.roomApp?.frontends) ? store.roomApp.frontends : [];
+    const index = frontends.findIndex((candidate) => candidate.id === frontend.id);
+    if (index < 0) return frontend;
+    const nextFrontend = { ...frontend, integrity, byteLength: stat.size };
+    store.roomApp = {
+      ...store.roomApp,
+      frontends: frontends.map((candidate, candidateIndex) => candidateIndex === index ? nextFrontend : candidate)
+    };
+    onRoomAppChange(store.roomApp);
+    return nextFrontend;
+  }
+
+  function refreshDynamicFrontends() {
+    const frontends = Array.isArray(store.roomApp?.frontends) ? store.roomApp.frontends : [];
+    for (const frontend of frontends) refreshDynamicFrontend(frontend);
+  }
+
+  return {
+    refreshDynamicFrontend,
+    refreshDynamicFrontends
+  };
+}
+
+module.exports = {
+  createDynamicFrontendRefresher,
+  rebuildEnv,
+  runDynamicBundleRebuild
+};

package/runtime/host/hostClients/frontendRequests.cjs

@@ -0,0 +1,166 @@
+const fs = require("node:fs");
+const { PROTOCOL } = require("@mh-gg/host-config");
+const { sendToClient } = require("@mh-gg/host-ipc");
+const { DEFAULT_FRONTEND_CHUNK_BYTES } = require("./constants.cjs");
+const { createDynamicFrontendRefresher } = require("./frontendBundleRefresh.cjs");
+const { createInlineProgressLoader } = require("../inlineProgressBar.cjs");
+
+function createFrontendRequestHandlers({ store, frontendBundle, rejectRoomMismatch, onRoomAppChange = () => {}, frontendProgress, progressStream }) {
+  const dynamicFrontend = createDynamicFrontendRefresher({ store, frontendBundle, onRoomAppChange });
+  const chunkProgress = frontendProgress || createInlineProgressLoader("Loading frontend chunks...", {
+    stream: progressStream,
+    width: 32
+  });
+
+  function cachedFrontendProof(message) {
+    const proof = message?.cachedFrontend;
+    if (!proof || typeof proof !== "object" || Array.isArray(proof)) return undefined;
+    if (typeof proof.id !== "string" || !proof.id) return undefined;
+    if (typeof proof.integrity !== "string" || !proof.integrity) return undefined;
+    const result = { id: proof.id, integrity: proof.integrity };
+    if (Number.isInteger(proof.byteLength) && proof.byteLength >= 0) result.byteLength = proof.byteLength;
+    return result;
+  }
+
+  function frontendCacheStatus(frontend, message) {
+    const proof = cachedFrontendProof(message);
+    const sameFrontend = proof?.id === frontend.id && proof.integrity === frontend.integrity;
+    const sameLength = proof?.byteLength === undefined || frontend.byteLength === undefined || proof.byteLength === frontend.byteLength;
+    return {
+      frontendId: frontend.id,
+      integrity: frontend.integrity,
+      byteLength: frontend.byteLength,
+      clientHasCurrentBundle: Boolean(sameFrontend && sameLength)
+    };
+  }
+
+  function frontendForRequest(message) {
+    dynamicFrontend.refreshDynamicFrontends();
+    const frontends = Array.isArray(store.roomApp?.frontends) ? store.roomApp.frontends : [];
+    if (message.frontendId) return frontends.find((frontend) => frontend.id === message.frontendId);
+    if (message.integrity) return frontends.find((frontend) => frontend.integrity === message.integrity);
+    return frontends[0];
+  }
+
+  function frontendBundleFile(frontend) {
+    if (!frontendBundle?.file) return undefined;
+    if (frontendBundle.id && frontendBundle.id !== frontend.id) return undefined;
+    if (!frontendBundle.dynamic && frontendBundle.integrity && frontendBundle.integrity !== frontend.integrity) return undefined;
+    return frontendBundle.file;
+  }
+
+  function sendFrontendUnavailable(socket, peerId, message = "The room frontend bundle is not available from this host.") {
+    sendToClient(socket, peerId, {
+      type: "host/error",
+      protocol: PROTOCOL,
+      code: "frontend-unavailable",
+      message
+    });
+  }
+
+  function handleFrontendManifestRequest(socket, peerId, message) {
+    if (message.protocol !== PROTOCOL || message.roomName !== store.roomName) {
+      rejectRoomMismatch(socket, peerId, false);
+      return;
+    }
+    const frontend = frontendForRequest(message);
+    if (!frontend) {
+      sendFrontendUnavailable(socket, peerId);
+      return;
+    }
+    sendToClient(socket, peerId, {
+      type: "host/frontend-manifest",
+      protocol: PROTOCOL,
+      roomName: store.roomName,
+      frontend,
+      frontendCache: frontendCacheStatus(frontend, message),
+      frontends: store.roomApp?.frontends || []
+    });
+  }
+
+  function handleRoomInfoRequest(socket, peerId, message) {
+    if (message.protocol !== PROTOCOL || message.roomName !== store.roomName) {
+      rejectRoomMismatch(socket, peerId, false);
+      return;
+    }
+    dynamicFrontend.refreshDynamicFrontends();
+    if (!store.roomApp) {
+      sendFrontendUnavailable(socket, peerId, "Room app information is not available from this host.");
+      return;
+    }
+    const frontend = Array.isArray(store.roomApp.frontends) ? store.roomApp.frontends[0] : undefined;
+    const cache = frontend ? frontendCacheStatus(frontend, message) : undefined;
+    const response = {
+      type: "room.info",
+      protocol: PROTOCOL,
+      roomName: store.roomName,
+      roomApp: store.roomApp
+    };
+    if (message.clientId) response.clientId = message.clientId;
+    if (cache) response.frontendCache = cache;
+    sendToClient(socket, peerId, response);
+  }
+
+  function handleFrontendChunkRequest(socket, peerId, message) {
+    if (message.protocol !== PROTOCOL || message.roomName !== store.roomName) {
+      rejectRoomMismatch(socket, peerId, false);
+      return;
+    }
+    const frontend = frontendForRequest(message);
+    if (!frontend) {
+      sendFrontendUnavailable(socket, peerId);
+      return;
+    }
+    const file = frontendBundleFile(frontend);
+    if (!file || !fs.existsSync(file)) {
+      sendFrontendUnavailable(socket, peerId);
+      return;
+    }
+    const stat = fs.statSync(file);
+    const offset = message.offset || 0;
+    const requestedLength = message.length || frontend.chunkSize || DEFAULT_FRONTEND_CHUNK_BYTES;
+    const maxLength = Math.max(1, Math.min(requestedLength, frontend.chunkSize || DEFAULT_FRONTEND_CHUNK_BYTES, DEFAULT_FRONTEND_CHUNK_BYTES));
+    const byteLength = Math.max(0, Math.min(maxLength, stat.size - offset));
+    const buffer = byteLength > 0 ? Buffer.allocUnsafe(byteLength) : Buffer.alloc(0);
+    if (byteLength > 0) {
+      const fd = fs.openSync(file, "r");
+      try {
+        fs.readSync(fd, buffer, 0, byteLength, offset);
+      } finally {
+        fs.closeSync(fd);
+      }
+    }
+    sendToClient(socket, peerId, {
+      type: "host/frontend-chunk",
+      protocol: PROTOCOL,
+      roomName: store.roomName,
+      frontendId: frontend.id,
+      integrity: frontend.integrity,
+      offset,
+      byteLength,
+      totalBytes: stat.size,
+      encoding: "base64",
+      data: buffer.toString("base64"),
+      done: offset + byteLength >= stat.size
+    });
+    chunkProgress.update({
+      completed: offset + byteLength,
+      total: stat.size,
+      currentItem: frontend.name || frontend.id
+    });
+    if (offset + byteLength >= stat.size) chunkProgress.stop();
+  }
+
+  return {
+    frontendBundleFile,
+    frontendForRequest,
+    handleFrontendChunkRequest,
+    handleFrontendManifestRequest,
+    handleRoomInfoRequest,
+    sendFrontendUnavailable
+  };
+}
+
+module.exports = {
+  createFrontendRequestHandlers
+};

package/runtime/host/hostClients/index.cjs

@@ -0,0 +1,68 @@
+const { validateClientMessage } = require("../wireValidation/index.cjs");
+const { createFrontendRequestHandlers } = require("./frontendRequests.cjs");
+const { rejectInvalidMessage, rejectRoomMismatch } = require("./rejections.cjs");
+
+function createHostClients(options) {
+  const {
+    store,
+    logger = console,
+    frontendBundle,
+    frontendProgress,
+    onStoreChange = () => {}
+  } = options;
+  const connectionRoles = new Map();
+  const pendingJoinConnections = new Map();
+  const frontend = createFrontendRequestHandlers({ store, frontendBundle, frontendProgress, rejectRoomMismatch, onRoomAppChange: onStoreChange });
+
+  function debug(message, ...args) {
+    if (process.env.MATTERHORN_DEBUG === "1") logger.log(message, ...args);
+  }
+
+  function messageDebugSummary(peerId, message) {
+    const keys = message && typeof message === "object" && !Array.isArray(message) ? Object.keys(message).sort() : [];
+    return {
+      peerId,
+      type: message?.type,
+      roomName: message?.roomName,
+      clientId: message?.clientId,
+      keys
+    };
+  }
+
+  function handleClientMessage(socket, peerId, message) {
+    const validation = validateClientMessage(message);
+    if (!validation.ok) {
+      debug("Invalid client message", validation.message, messageDebugSummary(peerId, message));
+      rejectInvalidMessage(socket, peerId, validation);
+      return;
+    }
+    if (message.type === "client/frontend-manifest") {
+      frontend.handleFrontendManifestRequest(socket, peerId, message);
+      return;
+    }
+    if (message.type === "client/frontend-chunk") {
+      frontend.handleFrontendChunkRequest(socket, peerId, message);
+      return;
+    }
+    if (message.type === "client/room-info") {
+      frontend.handleRoomInfoRequest(socket, peerId, message);
+      return;
+    }
+    debug("Unsupported host client message", messageDebugSummary(peerId, message));
+  }
+
+  function removeConnection(peerId) {
+    connectionRoles.delete(peerId);
+  }
+
+  return {
+    connectionRoles,
+    handleClientMessage,
+    pendingJoinConnections,
+    removeConnection
+  };
+}
+
+module.exports = {
+  createHostClients
+};

package/runtime/host/hostClients/rejections.cjs

@@ -0,0 +1,37 @@
+const { PROTOCOL } = require("@mh-gg/host-config");
+const { closeClient, sendToClient } = require("@mh-gg/host-ipc");
+
+function rejectRoomMismatch(socket, peerId, closeConnection) {
+  sendToClient(socket, peerId, {
+    type: "host/error",
+    protocol: PROTOCOL,
+    code: "room-mismatch",
+    message: "Wrong room or protocol."
+  });
+  if (closeConnection) closeClient(socket, peerId);
+}
+
+function rejectInvalidMessage(socket, peerId, validation) {
+  sendToClient(socket, peerId, {
+    type: "host/error",
+    protocol: PROTOCOL,
+    code: validation.code,
+    message: validation.message
+  });
+}
+
+function sendHostError(socket, peerId, code, message, extra = {}) {
+  sendToClient(socket, peerId, {
+    type: "host/error",
+    protocol: PROTOCOL,
+    code,
+    message,
+    ...extra
+  });
+}
+
+module.exports = {
+  rejectInvalidMessage,
+  rejectRoomMismatch,
+  sendHostError
+};