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

package/runtime/host/wireValidation/presenceEvent.cjs

@@ -0,0 +1,49 @@
+const { validateRelayEvent } = require("@mh-gg/relay-core");
+const { MATTERHORN_PRESENCE_NOSTR_KIND } = require("@mh-gg/event");
+const { invalid, isObject, ok } = require("./shared.cjs");
+
+function tagValue(tags, name) {
+  const tag = Array.isArray(tags) ? tags.find((item) => Array.isArray(item) && item[0] === name) : undefined;
+  return tag?.[1];
+}
+
+function parseEventContent(event) {
+  try {
+    return JSON.parse(event.content || "{}");
+  } catch {
+    return undefined;
+  }
+}
+
+function isEncryptedRoomPayload(value) {
+  return value
+    && typeof value === "object"
+    && value.encrypted === true
+    && value.alg === "A256GCM"
+    && value.kind === "presence.update"
+    && typeof value.iv === "string"
+    && typeof value.data === "string";
+}
+
+function validatePresenceEvent(message) {
+  const event = message.presenceEvent;
+  if (!isObject(event)) return invalid("client/presence", "presenceEvent is required");
+  if (event.kind !== MATTERHORN_PRESENCE_NOSTR_KIND) return invalid("client/presence", "presenceEvent kind is invalid");
+  const eventValidation = validateRelayEvent(event);
+  if (!eventValidation.ok) return invalid("client/presence", `presenceEvent is invalid: ${eventValidation.message}`);
+  if (tagValue(event.tags, "protocol") !== "matterhorn-sdk") return invalid("client/presence", "presenceEvent protocol tag is invalid");
+  if (tagValue(event.tags, "d") !== message.roomName) return invalid("client/presence", "presenceEvent room tag is invalid");
+  if (tagValue(event.tags, "t") !== "matterhorn:presence") return invalid("client/presence", "presenceEvent topic tag is invalid");
+  if (tagValue(event.tags, "client") !== message.clientId) return invalid("client/presence", "presenceEvent client tag is invalid");
+  if (tagValue(event.tags, "status") !== undefined) return invalid("client/presence", "presenceEvent status tag must be encrypted");
+
+  const content = parseEventContent(event);
+  if (!isEncryptedRoomPayload(content)) {
+    return invalid("client/presence", "presenceEvent content is invalid");
+  }
+  return ok();
+}
+
+module.exports = {
+  validatePresenceEvent
+};

package/runtime/host/wireValidation/push.cjs

@@ -0,0 +1,49 @@
+const { safeValidate, validateClientPushRegister, validateClientPushGrant } = require("@mh-gg/protocol");
+const { hasText, invalid, isObject, ok, protocolOne, protocolResult } = require("./shared.cjs");
+
+const MAX_PUSH_SEND_TARGETS = 256;
+const MAX_PUSH_SEND_PAYLOAD_BYTES = 3 * 1024;
+const PUSH_URGENCY_VALUES = new Set(["very-low", "low", "normal", "high"]);
+
+function hasValidTtlSeconds(value) {
+  if (value === undefined) return true;
+  return Number.isInteger(value) && value > 0 && value <= 24 * 60 * 60;
+}
+
+// Client-originated request asking the relay to deliver a push to other users.
+// The relay never decrypts: payload is forwarded opaquely to registered
+// subscriptions, so we only validate shape, target count, and payload size.
+function validateClientPushSendMessage(message) {
+  if (!isObject(message)) return invalid("client/push-send", "message must be an object");
+  if (!protocolOne(message)) return invalid("client/push-send", "protocol is invalid");
+  if (!hasText(message.roomName)) return invalid("client/push-send", "roomName is required");
+  if (!Array.isArray(message.userIds) || message.userIds.length === 0) return invalid("client/push-send", "userIds is required");
+  if (message.userIds.length > MAX_PUSH_SEND_TARGETS) return invalid("client/push-send", "too many userIds");
+  if (message.userIds.some((id) => !hasText(id))) return invalid("client/push-send", "userIds must be non-empty strings");
+  if (!hasText(message.payload)) return invalid("client/push-send", "payload is required");
+  if (Buffer.byteLength(message.payload, "utf8") > MAX_PUSH_SEND_PAYLOAD_BYTES) return invalid("client/push-send", "payload is too large");
+  if (message.pushId !== undefined && !hasText(message.pushId)) return invalid("client/push-send", "pushId is invalid");
+  if (!hasValidTtlSeconds(message.ttlSeconds)) return invalid("client/push-send", "ttlSeconds is invalid");
+  if (message.urgency !== undefined && !PUSH_URGENCY_VALUES.has(message.urgency)) return invalid("client/push-send", "urgency is invalid");
+  return ok();
+}
+
+function validateClientPushRegisterMessage(message) {
+  const result = safeValidate(validateClientPushRegister, message);
+  if (!result.ok) return protocolResult("client/push-register", result);
+  if (!protocolOne(message)) return invalid("client/push-register", "protocol is invalid");
+  return ok();
+}
+
+function validateClientPushGrantMessage(message) {
+  const result = safeValidate(validateClientPushGrant, message);
+  if (!result.ok) return protocolResult("client/push-grant", result);
+  if (!protocolOne(message)) return invalid("client/push-grant", "protocol is invalid");
+  return ok();
+}
+
+module.exports = {
+  validateClientPushRegisterMessage,
+  validateClientPushGrantMessage,
+  validateClientPushSendMessage
+};

package/runtime/host/wireValidation/relay.cjs

@@ -0,0 +1,131 @@
+const { validateClientMessage, validatePeerSignalFields } = require("./client.cjs");
+const { validateHostMessage } = require("./host.cjs");
+const { safeValidate, validateRoomOperation } = require("@mh-gg/protocol");
+const { hasText, invalid, isObject, ok } = require("./shared.cjs");
+
+const PUSH_URGENCY_VALUES = new Set(["very-low", "low", "normal", "high"]);
+
+function hasValidTtlSeconds(value) {
+  if (value === undefined) return true;
+  return Number.isInteger(value) && value > 0 && value <= 24 * 60 * 60;
+}
+
+function validateRelayClientEnvelope(message) {
+  if (!hasText(message.id)) return invalid("relay.client", "id is required");
+  if (!hasText(message.roomName)) return invalid("relay.client", "roomName is required");
+  if (!hasText(message.peerId)) return invalid("relay.client", "peerId is required");
+  if (!isObject(message.message)) return invalid("relay.client", "message is required");
+  const nested = validateClientMessage(message.message);
+  if (!nested.ok) {
+    if (nested.message.startsWith("Invalid client: unknown client message type")) return invalid("relay.client", nested.message.replace(/^Invalid client: /, ""));
+    return invalid("relay.client", nested.message.replace(/^Invalid client\/?[^:]*: /, ""));
+  }
+  if (message.message.roomName !== message.roomName) return invalid("relay.client", "roomName is required");
+  return ok();
+}
+
+function validateRelayHostEnvelope(message) {
+  if (!hasText(message.id)) return invalid("relay.host", "id is required");
+  if (!hasText(message.peerId)) return invalid("relay.host", "peerId is required");
+  if (message.roomName !== undefined && !hasText(message.roomName)) return invalid("relay.host", "roomName is invalid");
+  if (!isObject(message.message)) return invalid("relay.host", "message is required");
+  return validateHostMessage(message.message, "relay.host.message");
+}
+
+function validateRelayBroadcastEnvelope(message) {
+  if (!hasText(message.id)) return invalid("relay.broadcast", "id is required");
+  if (!hasText(message.roomName)) return invalid("relay.broadcast", "roomName is required");
+  if (!isObject(message.message)) return invalid("relay.broadcast", "message is required");
+  return validateHostMessage(message.message, "relay.broadcast.message");
+}
+
+function validateRelayClientCloseEnvelope(message) {
+  if (!hasText(message.id) && message.id !== undefined) return invalid("relay.client.close", "id is invalid");
+  if (message.roomName !== undefined && !hasText(message.roomName)) return invalid("relay.client.close", "roomName is invalid");
+  if (!hasText(message.peerId)) return invalid("relay.client.close", "peerId is required");
+  return ok();
+}
+
+function validateRelayPeerSignalEnvelope(message) {
+  if (!hasText(message.id) && message.id !== undefined) return invalid("relay.peer-signal", "id is invalid");
+  if (message.type !== "relay.peer-signal") return invalid("relay.peer-signal", "type is invalid");
+  return validatePeerSignalFields(message, "relay.peer-signal", { relay: true });
+}
+
+function validateRelayHeartbeatEnvelope(message) {
+  if (!hasText(message.id)) return invalid(message.type, "id is required");
+  if (message.relayAddress !== undefined && !hasText(message.relayAddress)) return invalid(message.type, "relayAddress is invalid");
+  if (message.targetRelayAddress !== undefined && !hasText(message.targetRelayAddress)) return invalid(message.type, "targetRelayAddress is invalid");
+  if (message.requestId !== undefined && !hasText(message.requestId)) return invalid(message.type, "requestId is invalid");
+  if (message.sentAt !== undefined && (!Number.isFinite(message.sentAt) || message.sentAt < 0)) return invalid(message.type, "sentAt is invalid");
+  return ok();
+}
+
+function validateRelayMatterhornOperationEnvelope(message) {
+  if (!hasText(message.id)) return invalid("relay.matterhorn-operation", "id is required");
+  if (!hasText(message.roomName)) return invalid("relay.matterhorn-operation", "roomName is required");
+  if (!isObject(message.operation)) return invalid("relay.matterhorn-operation", "operation is required");
+  const operationValidation = safeValidate(validateRoomOperation, message.operation);
+  if (!operationValidation.ok) return invalid("relay.matterhorn-operation", "operation is invalid");
+  if (message.operation.roomId !== message.roomName) return invalid("relay.matterhorn-operation", "operation room does not match roomName");
+  if (message.operations !== undefined) {
+    if (!Array.isArray(message.operations)) return invalid("relay.matterhorn-operation", "operations must be an array");
+    for (const [index, operation] of message.operations.entries()) {
+      const proofValidation = safeValidate(validateRoomOperation, operation);
+      if (!proofValidation.ok) return invalid("relay.matterhorn-operation", `operations[${index}] is invalid`);
+      if (operation.roomId !== message.roomName) return invalid("relay.matterhorn-operation", `operations[${index}] room does not match roomName`);
+    }
+  }
+  if (message.state !== undefined && !isObject(message.state)) return invalid("relay.matterhorn-operation", "state must be an object");
+  if (isObject(message.state) && message.state.roomId !== undefined && message.state.roomId !== message.roomName) return invalid("relay.matterhorn-operation", "state room does not match roomName");
+  return ok();
+}
+
+function validateRelayPushEnvelope(message) {
+  if (!hasText(message.id)) return invalid("relay.push", "id is required");
+  if (message.pushId !== undefined && !hasText(message.pushId)) return invalid("relay.push", "pushId is invalid");
+  if (!isObject(message.target)) return invalid("relay.push", "target is required");
+  if (!hasText(message.target.userId)) return invalid("relay.push", "target.userId is required");
+  if (message.payload === undefined) return invalid("relay.push", "payload is required");
+  let serialized;
+  try {
+    serialized = JSON.stringify(message.payload);
+  } catch {
+    return invalid("relay.push", "payload must be JSON serializable");
+  }
+  const maxBytes = 3 * 1024;
+  if (Buffer.byteLength(serialized, "utf8") > maxBytes) {
+    return invalid("relay.push", "payload is too large");
+  }
+  if (!hasValidTtlSeconds(message.ttlSeconds)) return invalid("relay.push", "ttlSeconds is invalid");
+  if (message.urgency !== undefined && !PUSH_URGENCY_VALUES.has(message.urgency)) return invalid("relay.push", "urgency is invalid");
+  return ok();
+}
+
+function validateRelayPushAckEnvelope(message) {
+  if (!hasText(message.id)) return invalid("relay.push.ack", "id is required");
+  if (!hasText(message.pushId)) return invalid("relay.push.ack", "pushId is required");
+  if (message.status !== undefined && !["accepted", "delivered"].includes(message.status)) return invalid("relay.push.ack", "status is invalid");
+  return ok();
+}
+
+function validateRelayEnvelope(message) {
+  if (!isObject(message)) return invalid("relay", "message must be an object");
+  switch (message.type) {
+    case "relay.client": return validateRelayClientEnvelope(message);
+    case "relay.host": return validateRelayHostEnvelope(message);
+    case "relay.broadcast": return validateRelayBroadcastEnvelope(message);
+    case "relay.client.close": return validateRelayClientCloseEnvelope(message);
+    case "relay.ping": return validateRelayHeartbeatEnvelope(message);
+    case "relay.pong": return validateRelayHeartbeatEnvelope(message);
+    case "relay.matterhorn-operation": return validateRelayMatterhornOperationEnvelope(message);
+    case "relay.peer-signal": return validateRelayPeerSignalEnvelope(message);
+    case "relay.push": return validateRelayPushEnvelope(message);
+    case "relay.push.ack": return validateRelayPushAckEnvelope(message);
+    default: return invalid("relay", "unknown relay message type");
+  }
+}
+
+module.exports = {
+  validateRelayEnvelope
+};

package/runtime/host/wireValidation/shared.cjs

@@ -0,0 +1,49 @@
+const { PROTOCOL } = require("@mh-gg/host-config");
+
+const INVALID_MESSAGE_CODE = "invalid-message";
+
+function ok() {
+  return { ok: true };
+}
+
+function invalid(scope, reason) {
+  return {
+    ok: false,
+    code: INVALID_MESSAGE_CODE,
+    message: `Invalid ${scope}: ${reason}`
+  };
+}
+
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function hasText(value) {
+  return typeof value === "string" && value.length > 0;
+}
+
+function protocolOne(value) {
+  return value.protocol === PROTOCOL;
+}
+
+function protocolResult(scope, result) {
+  if (result.ok) return ok();
+  let reason = result.message || "message is invalid";
+  const prefix = `${scope}.`;
+  if (typeof result.path === "string" && result.path.startsWith(prefix)) {
+    reason = `${result.path.slice(prefix.length)} ${reason.includes(":") ? reason.split(":").slice(1).join(":").trim() : "is invalid"}`;
+  } else if (reason.includes(":")) {
+    reason = reason.split(":").slice(1).join(":").trim();
+  }
+  return invalid(scope, reason || "message is invalid");
+}
+
+module.exports = {
+  INVALID_MESSAGE_CODE,
+  hasText,
+  invalid,
+  isObject,
+  ok,
+  protocolOne,
+  protocolResult
+};

package/runtime/scripts/ensureWorkspaceSdkBuild.cjs

@@ -0,0 +1,148 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { spawn } = require("node:child_process");
+
+const REQUIRED_OUTPUTS = [
+  "dist/app.js",
+  "dist/app.d.ts",
+  "dist/browser/hashRoute.js",
+  "dist/browser/hashRoute.d.ts",
+  "dist/browser/roomLink.js",
+  "dist/browser/roomLink.d.ts",
+  "dist/browser/sfuCalls.js",
+  "dist/browser/sfuCalls.d.ts",
+  "dist/browser/emojiPicker.js",
+  "dist/browser/emojiPicker.d.ts"
+];
+
+function defaultRepoRoot() {
+  return path.resolve(__dirname, "..");
+}
+
+function quoteCommandArg(value) {
+  const text = String(value);
+  if (/^[A-Za-z0-9_./:@=${}\\-]+$/.test(text)) return text;
+  return `"${text.replaceAll("\"", "\\\"")}"`;
+}
+
+function pnpmCommand(args) {
+  if (process.platform !== "win32") return { command: "pnpm", args };
+  return {
+    command: process.env.ComSpec || "cmd.exe",
+    args: ["/d", "/s", "/c", ["pnpm.cmd", ...args].map(quoteCommandArg).join(" ")]
+  };
+}
+
+
+function resolveFromRoots(request, roots) {
+  for (const root of roots) {
+    try {
+      return require.resolve(request, { paths: [root] });
+    } catch {}
+  }
+  throw new Error(`Unable to resolve ${request}. Run pnpm install once at the Matterhorn workspace root.`);
+}
+
+async function runDefaultSdkBuild(root, sdkRoot, options) {
+  fs.rmSync(path.join(sdkRoot, "dist"), { recursive: true, force: true });
+  const tsc = resolveFromRoots("typescript/bin/tsc", [sdkRoot, root]);
+  await run(process.execPath, [tsc, "-p", "tsconfig.build.json"], {
+    cwd: sdkRoot,
+    label: options.label || "matterhorn sdk build",
+    logger: options.logger,
+    timeoutMs: options.timeoutMs || 120000
+  });
+  await run(process.execPath, [path.join(sdkRoot, "scripts", "fix-dist-imports.cjs")], {
+    cwd: sdkRoot,
+    label: options.label || "matterhorn sdk build",
+    logger: options.logger,
+    timeoutMs: options.timeoutMs || 120000
+  });
+}
+
+function latestMtimeMs(target) {
+  if (!fs.existsSync(target)) return 0;
+  const stat = fs.statSync(target);
+  if (!stat.isDirectory()) return stat.mtimeMs;
+  let latest = stat.mtimeMs;
+  for (const entry of fs.readdirSync(target, { withFileTypes: true })) {
+    latest = Math.max(latest, latestMtimeMs(path.join(target, entry.name)));
+  }
+  return latest;
+}
+
+function oldestOutputMtimeMs(sdkRoot) {
+  let oldest = Infinity;
+  for (const relative of REQUIRED_OUTPUTS) {
+    const file = path.join(sdkRoot, relative);
+    if (!fs.existsSync(file)) return 0;
+    oldest = Math.min(oldest, fs.statSync(file).mtimeMs);
+  }
+  return oldest;
+}
+
+function newestInputMtimeMs(sdkRoot) {
+  return Math.max(
+    latestMtimeMs(path.join(sdkRoot, "src")),
+    latestMtimeMs(path.join(sdkRoot, "package.json")),
+    latestMtimeMs(path.join(sdkRoot, "tsconfig.build.json")),
+    latestMtimeMs(path.join(sdkRoot, "scripts"))
+  );
+}
+
+function sdkBuildRequired(sdkRoot) {
+  const oldestOutput = oldestOutputMtimeMs(sdkRoot);
+  if (oldestOutput === 0) return true;
+  return newestInputMtimeMs(sdkRoot) > oldestOutput;
+}
+
+function run(command, args, options) {
+  const child = spawn(command, args, {
+    cwd: options.cwd,
+    env: { ...process.env },
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
+  });
+  child.stdout.on("data", (chunk) => options.logger?.log?.(`${options.label} stdout: ${chunk.toString("utf8").trimEnd()}`));
+  child.stderr.on("data", (chunk) => options.logger?.error?.(`${options.label} stderr: ${chunk.toString("utf8").trimEnd()}`));
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error(`${options.label} timed out after ${options.timeoutMs}ms`));
+    }, options.timeoutMs);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (code === 0) resolve();
+      else reject(new Error(`${options.label} exited ${code}`));
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+  });
+}
+
+async function ensureWorkspaceSdkBuild(options = {}) {
+  const root = options.repoRoot || defaultRepoRoot();
+  const sdkRoot = options.sdkRoot || path.join(root, "packages", "matterhorn-sdk");
+  if (!fs.existsSync(path.join(sdkRoot, "package.json"))) return false;
+  if (!options.force && !sdkBuildRequired(sdkRoot)) return false;
+  if (options.command) {
+    const spec = options.command;
+    await run(spec.command, spec.args, {
+      cwd: sdkRoot,
+      label: options.label || "matterhorn sdk build",
+      logger: options.logger,
+      timeoutMs: options.timeoutMs || 120000
+    });
+  } else {
+    await runDefaultSdkBuild(root, sdkRoot, options);
+  }
+  return true;
+}
+
+module.exports = {
+  ensureWorkspaceSdkBuild,
+  REQUIRED_OUTPUTS,
+  sdkBuildRequired
+};

package/runtime/scripts/killChildTree.cjs

@@ -0,0 +1,18 @@
+const { spawn } = require("node:child_process");
+
+function killChildTree(child) {
+  if (!child?.pid) return;
+  if (process.platform === "win32") {
+    child.kill();
+    const killer = spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    killer.unref();
+    return;
+  }
+  child.kill("SIGTERM");
+  setTimeout(() => child.kill("SIGKILL"), 1000).unref();
+}
+
+module.exports = { killChildTree };