feat(relay): rendezvous-relay service — 7 packages + plans (contracts/transport/agent/control-plane/e2e/auth/web)

Multi-tenant reverse-tunnel service ("ngrok for Claude Code" with E2E): a
host-agent dials OUT to an operator-run relay; external devices reach the host
THROUGH the relay, routed by per-tenant subdomain, forwarding ciphertext only
(the relay never sees plaintext). Lets a customer reach their own self-hosted
web-terminal from anywhere with zero networking setup.

Packages — all tsc-strict + vitest green (656 tests), cross-package integration verified:
- relay-contracts: frozen shared contracts (mux frame codec, data model,
  capability token, E2E envelope, pairing) — the src/types.ts analog
- term-relay:   native WS mux + stateless data plane (subdomain routing, ciphertext forward)
- agent:        host-agent (pairing, per-host Ed25519 + mTLS dial-out, forwards to 127.0.0.1:3000)
- control-plane: accounts/hosts registry, pairing-code flow, routing table, provisioning
- relay-e2e:    browser<->agent E2E (X25519 ECDH through relay, AEAD, anti-replay, recoverable replay key)
- relay-auth:   Passkey/WebAuthn, capability tokens, per-host certs, deny-by-default tenant isolation
- relay-web:    browser login + Web Crypto E2E + client-side preview rendering

Security invariants INV1-15 enforced; cross-tenant isolation CI tripwire live
(.github/workflows/relay-tripwire.yml). Design + implementation-level plans in
docs/PLAN_RELAY_*.md and docs/EXPLORE_RELAY_SERVICE.md.

NOTE: generated autonomously per the reviewed plans. The security-critical
packages (relay-e2e, relay-auth) REQUIRE expert security audit before any real
deployment — passing tests prove self-consistency, not resistance to attackers.
Base app (src/, public/) unchanged; concurrent desktop work left uncommitted.

control-plane/src/ca/csr.ts

@@ -0,0 +1,53 @@
+/**
+ * CSR proof-of-possession (INV14). Models a PKCS#10 CSR as `embeddedPub(32) || sig(64)` where
+ * `sig = Ed25519(privateKey, CSR_CHALLENGE || embeddedPub)`. Verifying the signature against the
+ * embedded pubkey proves the requester holds the matching private key (the exact property a real
+ * PKCS#10 self-signature provides) — using builtin crypto only.
+ *
+ * INTEGRATION SEAM: production parses a real PKCS#10 DER (`@peculiar/x509`) and checks the
+ * self-signature. Swapping it in does not change `signHostLeaf`'s check ORDER or reject path.
+ */
+import { ed25519Sign, ed25519Verify, type KeyObject } from '../util/crypto.js'
+
+const CSR_CHALLENGE = new TextEncoder().encode('relay-cp/csr-pop/v1|')
+
+/** Test/agent helper: build a CSR proving possession of `privateKey` for `embeddedPub`. */
+export function buildCsr(privateKey: KeyObject, embeddedPub: Uint8Array): Uint8Array {
+  const message = concat(CSR_CHALLENGE, embeddedPub)
+  const sig = ed25519Sign(privateKey, message)
+  return concat(embeddedPub, sig)
+}
+
+export interface CsrParts {
+  readonly embeddedPub: Uint8Array
+  readonly sig: Uint8Array
+}
+
+/** Parse the modelled CSR bytes. Throws on wrong length. */
+export function parseCsr(csr: Uint8Array): CsrParts {
+  if (csr.length !== 96) throw new Error('malformed csr')
+  return { embeddedPub: csr.subarray(0, 32), sig: csr.subarray(32, 96) }
+}
+
+/**
+ * Verify CSR proof-of-possession: the embedded pubkey's private key signed the challenge.
+ * Independent of any registry state (a forged signature is refused even for a registered key).
+ */
+export function verifyCsrPoP(csr: Uint8Array): { ok: boolean; embeddedPub: Uint8Array } {
+  let parts: CsrParts
+  try {
+    parts = parseCsr(csr)
+  } catch {
+    return { ok: false, embeddedPub: new Uint8Array(0) }
+  }
+  const message = concat(CSR_CHALLENGE, parts.embeddedPub)
+  const ok = ed25519Verify(parts.embeddedPub, message, parts.sig)
+  return { ok, embeddedPub: parts.embeddedPub }
+}
+
+function concat(a: Uint8Array, b: Uint8Array): Uint8Array {
+  const out = new Uint8Array(a.length + b.length)
+  out.set(a, 0)
+  out.set(b, a.length)
+  return out
+}

control-plane/src/ca/fingerprint.ts

@@ -0,0 +1,6 @@
+/** Enrollment fingerprint of an agent public key: SHA-256 hex (pinned by the browser for E2E TOFU, §4.4). */
+import { createHash } from 'node:crypto'
+
+export function fingerprint(agentPubkey: Uint8Array): string {
+  return createHash('sha256').update(agentPubkey).digest('hex')
+}

control-plane/src/ca/rotate.ts

@@ -0,0 +1,55 @@
+/**
+ * T15 — CA leaf RENEWAL (INV14). Re-signs a short-TTL leaf for an already-bound, non-revoked host
+ * under the current intermediate. SAME guards as T8 `signHostLeaf`: (1) CSR proof-of-possession
+ * against the embedded pubkey; (2) embedded pubkey == the host's registered `agent_pubkey`;
+ * (3) host active/non-revoked. Any failure → same reject path. A drained/revoked host cannot renew
+ * (closes the INV12+INV14 loop). Signing = `CaSigner.sign()` (KMS, §3.1), never a raw key.
+ * Distinct file from T8 (`ca/sign.ts`) — shares only the KMS-signer primitive.
+ */
+import type { HostStore } from '../store/ports.js'
+import type { CaSigner } from '../boot/ca-wiring.js'
+import { verifyCsrPoP } from './csr.js'
+import { LeafSignError } from './sign.js'
+import { timingSafeEqualBytes, bytesToBase64 } from '../util/bytes.js'
+
+export interface LeafRenewerDeps {
+  readonly hosts: HostStore
+  readonly signer: CaSigner
+  readonly caChainDer: readonly Uint8Array[]
+  readonly leafTtlSec?: number
+}
+
+export interface LeafRenewer {
+  renewHostLeaf(
+    hostId: string,
+    csr: Uint8Array,
+  ): Promise<{ cert: Uint8Array; caChain: readonly Uint8Array[] }>
+}
+
+const DEFAULT_LEAF_TTL_SEC = 24 * 60 * 60
+
+export function createLeafRenewer(deps: LeafRenewerDeps): LeafRenewer {
+  const ttl = deps.leafTtlSec ?? DEFAULT_LEAF_TTL_SEC
+  return {
+    async renewHostLeaf(hostId, csr) {
+      const host = await deps.hosts.get(hostId)
+      // A revoked/absent host cannot renew (INV12 + INV14).
+      if (host === null || host.status === 'revoked') throw new LeafSignError('not_registered')
+
+      const pop = verifyCsrPoP(csr)
+      if (!pop.ok) throw new LeafSignError('csr_rejected')
+      // embedded pubkey must equal the host's REGISTERED pubkey (no key substitution on renewal).
+      if (!timingSafeEqualBytes(pop.embeddedPub, host.agentPubkey)) throw new LeafSignError('csr_rejected')
+
+      const notAfter = Math.floor(Date.now() / 1000) + ttl
+      const tbs = new TextEncoder().encode(
+        JSON.stringify({ v: 1, hostId, subjectSpki: bytesToBase64(host.agentPubkey), notAfter, renewed: true }),
+      )
+      const sig = await deps.signer.sign(tbs) // KMS sign(); no raw key
+      const cert = new TextEncoder().encode(
+        JSON.stringify({ tbs: bytesToBase64(tbs), sig: bytesToBase64(sig) }),
+      )
+      return { cert, caChain: deps.caChainDer }
+    },
+  }
+}

control-plane/src/ca/sign.ts

@@ -0,0 +1,70 @@
+/**
+ * T8 — bind-time mTLS leaf signer, registry-gated (INV14 registry half). ORDER OF CHECKS (all
+ * must pass, SAME reject path):
+ *   1. CSR proof-of-possession — verify the CSR self-signature against its embedded pubkey.
+ *   2. embedded pubkey == caller-supplied `agentPubkey` (no substitution).
+ *   3. (hostId, agentPubkey) is an ACTIVE, non-revoked row in the host registry.
+ * A failure at ANY step rejects identically; the KMS `sign()` is NEVER invoked when any check
+ * fails. Signing itself is `CaSigner.sign()` (KMS, §3.1) — never a raw private key in memory.
+ */
+import type { HostStore } from '../store/ports.js'
+import type { CaSigner } from '../boot/ca-wiring.js'
+import { verifyCsrPoP } from './csr.js'
+import { timingSafeEqualBytes, bytesToBase64 } from '../util/bytes.js'
+
+export class LeafSignError extends Error {
+  constructor(public readonly code: 'csr_rejected' | 'not_registered') {
+    super('leaf signing refused') // uniform message — do not leak which check failed
+  }
+}
+
+export interface LeafSignerDeps {
+  readonly hosts: HostStore
+  readonly signer: CaSigner
+  readonly caChainDer: readonly Uint8Array[]
+  /** Leaf validity in seconds (short-lived, INV14). Default 24h. */
+  readonly leafTtlSec?: number
+}
+
+export interface LeafSigner {
+  signHostLeaf(
+    hostId: string,
+    agentPubkey: Uint8Array,
+    csr: Uint8Array,
+  ): Promise<{ cert: Uint8Array; caChain: readonly Uint8Array[] }>
+}
+
+const DEFAULT_LEAF_TTL_SEC = 24 * 60 * 60
+
+export function createLeafSigner(deps: LeafSignerDeps): LeafSigner {
+  const ttl = deps.leafTtlSec ?? DEFAULT_LEAF_TTL_SEC
+  return {
+    async signHostLeaf(hostId, agentPubkey, csr) {
+      // 1. proof-of-possession (independent of registry state)
+      const pop = verifyCsrPoP(csr)
+      if (!pop.ok) throw new LeafSignError('csr_rejected')
+      // 2. no substitution: CSR pubkey must equal the presented agentPubkey
+      if (!timingSafeEqualBytes(pop.embeddedPub, agentPubkey)) throw new LeafSignError('csr_rejected')
+      // 3. registry gate: host bound, active, non-revoked, pubkey matches (INV14)
+      const host = await deps.hosts.get(hostId)
+      if (host === null || host.status === 'revoked') throw new LeafSignError('not_registered')
+      if (!timingSafeEqualBytes(host.agentPubkey, agentPubkey)) throw new LeafSignError('not_registered')
+
+      // Only now do we invoke KMS sign() over the to-be-signed leaf.
+      const notAfter = Math.floor(Date.now() / 1000) + ttl
+      const tbs = new TextEncoder().encode(
+        JSON.stringify({
+          v: 1,
+          hostId,
+          subjectSpki: bytesToBase64(agentPubkey), // subject pubkey == agentPubkey (assertable in tests)
+          notAfter,
+        }),
+      )
+      const sig = await deps.signer.sign(tbs)
+      const cert = new TextEncoder().encode(
+        JSON.stringify({ tbs: bytesToBase64(tbs), sig: bytesToBase64(sig) }),
+      )
+      return { cert, caChain: deps.caChainDer }
+    },
+  }
+}