drupal-mcp-connector 2.10.1 → 2.12.0

package/src/lib/relay/edge.js

@@ -1,8 +1,10 @@
 /**
- * Relay northbound edge (#232) — the DEV-294 AC4 slice.
+ * Relay northbound edge (#232, #242, #244, #247, #250, #253) — DEV-294 AC4,
+ * DEV-122 isolation, DEV-124 tenant routing, DEV-123 actor mapping, DEV-125
+ * policy digest and W&L-operated bundle promotion.
  *
  * Terminates northbound MCP over the OAuth resource server and fans requests
- * down an outbound tenant-agent channel. The edge proposes; the tenant-side
+ * down outbound tenant-agent channels. The edge proposes; the tenant-side
  * connector disposes. Policy at this seam, fail-closed from birth:
  *
  *   - `createInboundHttpsAuth` is the ONLY authentication arm. There is no
@@ -16,6 +18,11 @@
  *     before framing. The frame carries the validated identity object only.
  *   - The edge holds no site credentials: a catalog entry carrying credential
  *     material refuses startup. It cannot leak what it does not hold.
+ *   - Tunnel identity is the tenant boundary. Agent sessions are keyed by
+ *     `agentId`; channel records may bind `sites`. A second unscoped agent
+ *     or overlapping site claim is denied at hello. Fan-down selects the
+ *     unique bound agent from server-owned grants. Single unscoped agent
+ *     remains the DEV-294 compatibility path.
  *   - Stateless MCP 2026-07-28 northbound: sessionful traffic is refused and
  *     no `Mcp-Session-Id` crosses in either direction.
  *   - Revocation is per-request with no grace window, for both credential
@@ -31,7 +38,14 @@ import { createServer as createTlsServer } from "node:tls";
 import { createLocalRelay } from "../contracts/relay.js";
 import { createInboundHttpsAuth, SPOOFABLE_IDENTITY_HEADERS } from "../http-auth.js";
 import { createLegacySessionHandler, createMcpRequestHandler } from "../http-handler.js";
-import { resolveGrantedSites } from "../principal.js";
+import { isWriteLikeCall } from "../operations.js";
+import {
+  eligiblePromotions,
+  POLICY_DIGEST,
+  promotionsRequired,
+  resolveEligiblePromotion,
+} from "../policy-promotion.js";
+import { DIAGNOSTIC_TOOLS, resolveActor, resolveGrantedSites, resolvePolicy } from "../principal.js";
 import {
   attachFramer,
   createRequestBroker,
@@ -79,6 +93,230 @@ const SITE_CREDENTIAL_KEYS = Object.freeze([
 
 const DEFAULT_FAN_DOWN_TIMEOUT_MS = 10_000;
 
+/**
+ * Normalize a channel-record `sites` list. Empty / missing means unscoped
+ * (legal only as the sole connected agent — the DEV-294 compatibility path).
+ *
+ * @param {unknown} sites
+ * @returns {string[]}
+ */
+export function boundSiteNames(sites) {
+  if (!Array.isArray(sites)) return [];
+  return sites.map(String).filter((name) => name && !name.startsWith("_"));
+}
+
+/**
+ * Decide whether a hello may join the agent-channel session table.
+ *
+ * @param {object} params
+ * @param {{agentId: string, revoked?: boolean, sites?: string[]|null}|null} params.record
+ * @param {Array<{agentId: string, sites: string[]|null}>} [params.sessions]
+ *   Currently connected agents, excluding a reconnect of the same agentId.
+ * @param {Iterable<string>} [params.catalogNames]
+ * @returns {{ok: true, sites: string[]|null}|{ok: false, reason: string}}
+ */
+export function acceptAgentHello({ record, sessions = [], catalogNames = [] } = {}) {
+  if (!record || typeof record.agentId !== "string" || !record.agentId) {
+    return { ok: false, reason: "unauthenticated" };
+  }
+  if (record.revoked) return { ok: false, reason: "revoked" };
+
+  const known = new Set([...catalogNames].map(String));
+  let incoming = boundSiteNames(record.sites);
+  if (incoming.length && known.size) {
+    incoming = incoming.filter((name) => known.has(name));
+    if (!incoming.length) return { ok: false, reason: "unbound_tenant" };
+  }
+  const incomingScoped = incoming.length > 0;
+  const others = sessions.filter((session) => session.agentId !== record.agentId);
+
+  if (others.length === 0) {
+    return { ok: true, sites: incomingScoped ? incoming : null };
+  }
+  if (!incomingScoped) return { ok: false, reason: "unbound_tenant" };
+  if (others.some((session) => !boundSiteNames(session.sites).length)) {
+    return { ok: false, reason: "unbound_tenant" };
+  }
+  const claimed = new Set(others.flatMap((session) => boundSiteNames(session.sites)));
+  if (incoming.some((name) => claimed.has(name))) {
+    return { ok: false, reason: "overlapping_tenant" };
+  }
+  return { ok: true, sites: incoming };
+}
+
+/**
+ * Pick the unique tenant agent this principal may use.
+ *
+ * @param {object} params
+ * @param {string[]} params.grantedSiteNames
+ * @param {string|null} [params.targetName]
+ * @param {Array<{agentId: string, sites: string[]|null}>} params.sessions
+ * @returns {{session: object|null, reason: "not_entitled"|"no_agent"|null}}
+ */
+export function selectTenantSession({
+  grantedSiteNames = [],
+  targetName = null,
+  sessions = [],
+} = {}) {
+  if (!grantedSiteNames.length) return { session: null, reason: "not_entitled" };
+  if (targetName && !grantedSiteNames.includes(targetName)) {
+    return { session: null, reason: "not_entitled" };
+  }
+  const needed = targetName ? [targetName] : [...grantedSiteNames];
+  if (!sessions.length) return { session: null, reason: "no_agent" };
+
+  const scoped = [];
+  const unscoped = [];
+  for (const session of sessions) {
+    if (boundSiteNames(session.sites).length) scoped.push(session);
+    else unscoped.push(session);
+  }
+
+  if (unscoped.length && scoped.length) {
+    return { session: null, reason: "no_agent" };
+  }
+  if (unscoped.length === 1 && sessions.length === 1) {
+    return { session: unscoped[0], reason: null };
+  }
+  if (unscoped.length > 1) return { session: null, reason: "no_agent" };
+
+  const matches = scoped.filter((session) => {
+    const names = new Set(boundSiteNames(session.sites));
+    return needed.every((name) => names.has(name));
+  });
+  if (matches.length === 1) return { session: matches[0], reason: null };
+  if (matches.length > 1) return { session: null, reason: "not_entitled" };
+
+  const partial = scoped.filter((session) => {
+    const names = new Set(boundSiteNames(session.sites));
+    return needed.some((name) => names.has(name));
+  });
+  if (partial.length > 0 && needed.length > 1) {
+    return { session: null, reason: "not_entitled" };
+  }
+  return { session: null, reason: "no_agent" };
+}
+
+/**
+ * Resolve tenant and target from server-owned grants. Caller `tenant` is a
+ * confirming hint inside the grant, never authority. When `tenantGrants` is
+ * omitted, tenant is derived from the unique agent covering the site grant
+ * (DEV-122 / DEV-294 compatibility).
+ *
+ * @param {object} params
+ * @param {object|null} params.identity
+ * @param {string|null} [params.callerTenant]
+ * @param {object|null} [params.tenantGrants]
+ * @param {string[]} params.grantedSiteNames
+ * @param {string|null} [params.targetName]
+ * @param {Array<{agentId: string, sites: string[]|null}>} params.sessions
+ * @returns {{session: object|null, tenant: string|null, target: string|null, source: string, reason: "not_entitled"|"no_agent"|null}}
+ */
+export function resolveTenantRoute({
+  identity,
+  callerTenant = null,
+  tenantGrants = null,
+  grantedSiteNames = [],
+  targetName = null,
+  sessions = [],
+} = {}) {
+  if (tenantGrants) {
+    const listed = identity?.clientId
+      ? new Map(Object.entries(tenantGrants)).get(identity.clientId)
+      : undefined;
+    const grantedTenants = grantIds(listed);
+    if (!grantedTenants.length) {
+      return {
+        session: null, tenant: null, target: targetName, source: "grant", reason: "not_entitled",
+      };
+    }
+    if (callerTenant && !grantedTenants.includes(callerTenant)) {
+      return {
+        session: null, tenant: null, target: targetName, source: "grant", reason: "not_entitled",
+      };
+    }
+    if (!callerTenant && grantedTenants.length > 1) {
+      return {
+        session: null, tenant: null, target: targetName, source: "grant", reason: "not_entitled",
+      };
+    }
+    const tenant = callerTenant || grantedTenants[0];
+    const session = sessions.find((entry) => entry.agentId === tenant) ?? null;
+    if (!session) {
+      return {
+        session: null, tenant, target: targetName, source: "grant", reason: "no_agent",
+      };
+    }
+    const tenantSites = boundSiteNames(session.sites);
+    const allowed = tenantSites.length
+      ? grantedSiteNames.filter((name) => tenantSites.includes(name))
+      : grantedSiteNames;
+    if (targetName && !allowed.includes(targetName)) {
+      return {
+        session: null, tenant, target: targetName, source: "grant", reason: "not_entitled",
+      };
+    }
+    if (!targetName && grantedSiteNames.length && allowed.length === 0) {
+      return {
+        session: null, tenant, target: targetName, source: "grant", reason: "not_entitled",
+      };
+    }
+    return { session, tenant, target: targetName, source: "grant", reason: null };
+  }
+
+  const selected = selectTenantSession({ grantedSiteNames, targetName, sessions });
+  return {
+    session: selected.session,
+    tenant: selected.session?.agentId ?? null,
+    target: targetName,
+    source: "grant",
+    reason: selected.reason,
+  };
+}
+
+function callerTenantHint(args = {}) {
+  const value = new Map(Object.entries(args ?? {})).get("tenant");
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+const CALLER_HINT_KEYS = Object.freeze(["tenant", "actor", "delegator", "policy", "digest"]);
+
+function stripCallerHints(body) {
+  const args = body?.params?.arguments;
+  if (!args || typeof args !== "object" || Array.isArray(args)) return body;
+  const bag = new Map(Object.entries(args));
+  let changed = false;
+  for (const key of CALLER_HINT_KEYS) {
+    if (bag.has(key)) {
+      bag.delete(key);
+      changed = true;
+    }
+  }
+  if (!changed) return body;
+  return { ...body, params: { ...body.params, arguments: Object.fromEntries(bag) } };
+}
+
+function identityWithGrant(identity, { tenant, actor = null, delegator = null, policy = null }) {
+  const bag = new Map(Object.entries(identity ?? {}));
+  for (const key of ["actor", "delegator", "policy", "digest"]) bag.delete(key);
+  bag.set("tenant", tenant);
+  if (actor) bag.set("actor", actor);
+  if (delegator) bag.set("delegator", delegator);
+  if (policy) bag.set("policy", policy);
+  return Object.freeze(Object.fromEntries(bag));
+}
+
+/**
+ * Canonical form of a tenant site bind. Null and empty both mean unscoped.
+ *
+ * @param {unknown} sites
+ * @returns {string}
+ */
+export function siteBindingKey(sites) {
+  const names = boundSiteNames(sites);
+  return names.length ? names.slice().sort().join("\0") : "";
+}
+
 /** Startup refusals: configuration that must not become a listener. */
 export class EdgeStartupError extends Error {
   constructor(message) {
@@ -110,14 +348,17 @@ export function fanDownHeaders(headers = {}) {
  * Hot-reloaded agent channel credential store.
  *
  * File shape: `{ "agents": { "<agentId>": { "tokenSha256": "<hex>",
- * "revoked": false } } }`. The edge stores only SHA-256 digests — never a raw
- * channel token. A missing or unreadable file denies every lookup (a
- * credential table that cannot be read authorizes nobody), and the file is
- * re-read when its mtime changes so a revoke needs no restart.
+ * "sites": ["site-name"], "revoked": false } } }`. The edge stores only
+ * SHA-256 digests — never a raw channel token. `sites` binds the tunnel to
+ * catalog names (the tenant boundary). Omitted `sites` is unscoped and is
+ * only accepted as the sole connected agent. A missing or unreadable file
+ * denies every lookup (a credential table that cannot be read authorizes
+ * nobody), and the file is re-read when its mtime changes so a revoke needs
+ * no restart.
  *
  * @param {object} options
  * @param {string} options.filePath
- * @returns {{lookup: (token: string) => {agentId: string, revoked: boolean}|null}}
+ * @returns {{lookup: (token: string) => {agentId: string, revoked: boolean, sites: string[]|null}|null}}
  */
 export function createChannelCredentialStore({
   filePath,
@@ -146,6 +387,7 @@ export function createChannelCredentialStore({
           agentId,
           tokenSha256: entry.tokenSha256.toLowerCase(),
           revoked: entry.revoked === true,
+          sites: Array.isArray(entry.sites) ? boundSiteNames(entry.sites) : null,
         }));
       cache = { mtimeMs: info.mtimeMs, agents, denyAll: false };
     } catch {
@@ -166,7 +408,7 @@ export function createChannelCredentialStore({
       for (const agent of agents) {
         const expected = Buffer.from(agent.tokenSha256, "utf8");
         if (digest.length === expected.length && timingSafeEqual(digest, expected)) {
-          return { agentId: agent.agentId, revoked: agent.revoked };
+          return { agentId: agent.agentId, revoked: agent.revoked, sites: agent.sites };
         }
       }
       return null;
@@ -178,11 +420,18 @@ function isLoopback(host) {
   return host === "127.0.0.1" || host === "::1" || host === "localhost";
 }
 
+function grantIds(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(
+    values.map((value) => String(value).trim()).filter((value) => value && !value.startsWith("_")),
+  )];
+}
+
 function normalizeGrants(grants) {
   if (!grants || typeof grants !== "object" || Array.isArray(grants)) return null;
   const entries = Object.entries(grants)
     .filter(([clientId, sites]) => !clientId.startsWith("_") && Array.isArray(sites))
-    .map(([clientId, sites]) => [clientId, sites.map(String)]);
+    .map(([clientId, sites]) => [clientId, grantIds(sites)]);
   return entries.length ? Object.fromEntries(entries) : null;
 }
 
@@ -222,6 +471,15 @@ function jsonResponse(res, status, body) {
  * @param {{issuer: string, audience: string}} options.auth Inbound
  *   resource-server config (`resolveInboundAuthConfig` shape). Mandatory.
  * @param {object} options.grants Non-empty client-id → site-name grant table.
+ * @param {object|null} [options.tenantGrants] Optional client-id → tenant
+ *   agent-id table. When present, tenant routing is grant-authoritative.
+ * @param {object|null} [options.actors] Optional principal → Drupal actor
+ *   table (`sub` / `azp` → `{ uuid, delegators? }`). When present, write-like
+ *   tools/call require a mapping.
+ * @param {object|null} [options.policies] Optional principal → SHA-256 digest.
+ * @param {object|null} [options.promotions] Optional W&L-operated dual-control
+ *   ledger (digest → sealed document + two operator ids). When present,
+ *   non-diagnostic tools/call require a matching agent attestation.
  * @param {Array<{_name: string}>} options.sites Credential-free catalog.
  * @param {string} [options.defaultSite]
  * @param {{lookup: Function}} options.channelCredentials Agent channel store.
@@ -240,6 +498,10 @@ function jsonResponse(res, status, body) {
 export async function startEdge({
   auth,
   grants,
+  tenantGrants = null,
+  actors = null,
+  policies = null,
+  promotions = null,
   sites,
   defaultSite,
   channelCredentials,
@@ -268,6 +530,17 @@ export async function startEdge({
       + "The library's all-sites fallback does not apply to this entry point.",
     );
   }
+  const tenantGrantTable = normalizeGrants(tenantGrants);
+  const actorTable = actors && typeof actors === "object" && !Array.isArray(actors)
+    ? actors
+    : null;
+  const policyTable = policies && typeof policies === "object" && !Array.isArray(policies)
+    ? policies
+    : null;
+  const promotionTable = promotions && typeof promotions === "object" && !Array.isArray(promotions)
+    ? promotions
+    : null;
+  const promoRequired = promotionsRequired(promotionTable);
   if (typeof channelCredentials?.lookup !== "function") {
     throw new EdgeStartupError(
       "Relay edge requires an agent channel credential store; without one no "
@@ -293,7 +566,9 @@ export async function startEdge({
   const targetRelay = createLocalRelay({ sites: catalog, grants: grantTable, defaultSite });
   const broker = createRequestBroker({ timeoutMs: fanDownTimeoutMs });
 
-  let session = null;
+  /** @type {Map<string, {socket: object, token: string, agentId: string, sites: string[]|null, attestedDigests: Set<string>, offeredDigests: Set<string>}>} */
+  const sessions = new Map();
+  const catalogNames = catalog.map((site) => site._name);
 
   const channelServer = (hasTls ? createTlsServer(tls) : createNetServer())
     .on("connection", handleChannelSocket)
@@ -303,35 +578,76 @@ export async function startEdge({
     // Plain server emits "connection"; the TLS server emits both "connection"
     // (raw) and "secureConnection" (cleartext). Attach once, post-handshake.
     if (hasTls && !socket.encrypted) return;
+    let agentId = null;
     attachFramer(socket, (frame) => {
       if (frame.type === "hello") {
         const record = channelCredentials.lookup(frame.token);
-        if (!record) {
-          writeFrame(socket, { type: "denied", reason: "unauthenticated" });
+        const others = [...sessions.values()].filter((entry) => entry.socket !== socket);
+        const decision = acceptAgentHello({
+          record,
+          sessions: others,
+          catalogNames,
+        });
+        if (!decision.ok) {
+          writeFrame(socket, { type: "denied", reason: decision.reason });
           socket.end();
           return;
         }
-        if (record.revoked) {
-          writeFrame(socket, { type: "denied", reason: "revoked" });
-          socket.end();
-          return;
+        const existing = sessions.get(record.agentId);
+        if (existing && existing.socket !== socket) existing.socket.destroy();
+        agentId = record.agentId;
+        const offeredDigests = new Set();
+        sessions.set(agentId, {
+          socket,
+          token: frame.token,
+          agentId,
+          sites: decision.sites,
+          attestedDigests: new Set(),
+          offeredDigests,
+        });
+        try {
+          for (const row of eligiblePromotions(promotionTable)) {
+            const wrote = writeFrame(socket, { type: "policy-bundle", document: row.document });
+            if (!wrote) throw new Error("policy-bundle write failed");
+            offeredDigests.add(row.digest);
+          }
+          writeFrame(socket, { type: "hello-ok", agent: { agentId } });
+        } catch {
+          sessions.delete(agentId);
+          agentId = null;
+          socket.destroy();
+        }
+        return;
+      }
+      if (!agentId) {
+        socket.destroy();
+        return;
+      }
+      if (frame.type === "policy-bundle-ack") {
+        const session = sessions.get(agentId);
+        const digest = typeof frame.digest === "string"
+          ? frame.digest.trim().toLowerCase()
+          : "";
+        if (
+          session && frame.ok === true && POLICY_DIGEST.test(digest)
+          && session.offeredDigests.has(digest)
+        ) {
+          session.attestedDigests.add(digest);
         }
-        if (session && session.socket !== socket) session.socket.destroy();
-        session = { socket, token: frame.token, agentId: record.agentId };
-        writeFrame(socket, { type: "hello-ok", agent: { agentId: record.agentId } });
         return;
       }
       if (frame.type === "mcp-response") {
-        broker.settle(frame);
+        broker.settle(frame, { owner: agentId });
         return;
       }
       // Any other frame type on the agent channel is a protocol violation.
       socket.destroy();
     });
     socket.on("close", () => {
-      if (session?.socket === socket) {
-        session = null;
-        broker.rejectAll(new Error("Relay agent channel closed."));
+      const current = agentId ? sessions.get(agentId) : null;
+      if (current?.socket === socket) {
+        sessions.delete(agentId);
+        broker.rejectByOwner(agentId, new Error("Relay agent channel closed."));
       }
     });
   }
@@ -352,38 +668,107 @@ export async function startEdge({
       jsonResponse(res, 403, { error: "not_entitled" });
       return;
     }
+    const args = body?.params?.arguments ?? {};
+    const callerTenant = callerTenantHint(args);
+    const siteArgs = { ...args };
+    delete siteArgs.tenant;
+    let targetName = null;
     if (body?.method === "tools/call") {
       try {
-        targetRelay.resolve(identity, body?.params?.arguments ?? {});
+        targetName = targetRelay.resolve(identity, siteArgs).name;
       } catch {
         jsonResponse(res, 403, { error: "not_entitled" });
         return;
       }
     }
 
-    if (!session) {
-      jsonResponse(res, 503, { error: "no_agent" });
+    const mapped = resolveActor({ identity, actors: actorTable });
+    const boundPolicy = resolvePolicy({ identity, policies: policyTable });
+    const isCall = body?.method === "tools/call";
+    const toolName = isCall && typeof body?.params?.name === "string" && body.params.name.trim()
+      ? body.params.name.trim()
+      : null;
+    if (mapped.required && mapped.reason && isCall && (!toolName || isWriteLikeCall(toolName, args))) {
+      jsonResponse(res, 403, { error: "not_entitled" });
+      return;
+    }
+    const policyCall = isCall && (!toolName || !DIAGNOSTIC_TOOLS.has(toolName));
+    if (
+      boundPolicy.required && boundPolicy.reason && policyCall
+    ) {
+      jsonResponse(res, 403, { error: "not_entitled" });
+      return;
+    }
+    if (promoRequired && policyCall && !boundPolicy.policy) {
+      jsonResponse(res, 403, { error: "not_entitled" });
       return;
     }
-    const record = channelCredentials.lookup(session.token);
+
+    const selected = resolveTenantRoute({
+      identity,
+      callerTenant,
+      tenantGrants: tenantGrantTable,
+      grantedSiteNames: granted.map((site) => site._name),
+      targetName,
+      sessions: [...sessions.values()],
+    });
+    if (promoRequired && policyCall) {
+      const promo = resolveEligiblePromotion({
+        digest: boundPolicy.policy,
+        promotions: promotionTable,
+      });
+      const attested = selected.session?.attestedDigests;
+      if (!promo.eligible || !attested || !attested.has(boundPolicy.policy)) {
+        jsonResponse(res, 403, { error: "not_entitled" });
+        return;
+      }
+    }
+    if (!selected.session) {
+      const entitled = selected.reason === "not_entitled";
+      jsonResponse(res, entitled ? 403 : 503, {
+        error: entitled ? "not_entitled" : "no_agent",
+      });
+      return;
+    }
+    const record = channelCredentials.lookup(selected.session.token);
     if (!record || record.revoked) {
       jsonResponse(res, 403, { error: "revoked", bound: EDGE_REVOCATION_BOUND.name });
       return;
     }
+    if (siteBindingKey(record.sites) !== siteBindingKey(selected.session.sites)) {
+      selected.session.socket.destroy();
+      jsonResponse(res, 503, { error: "no_agent" });
+      return;
+    }
 
     const id = randomUUID();
-    const waited = broker.track(id);
-    const wrote = writeFrame(session.socket, {
+    const waited = broker.track(id, { owner: selected.session.agentId });
+    const routedIdentity = identityWithGrant(identity, {
+      tenant: selected.tenant,
+      actor: mapped.actor,
+      delegator: mapped.delegator,
+      policy: boundPolicy.policy,
+    });
+    const wrote = writeFrame(selected.session.socket, {
       type: "mcp-request",
       id,
       method: req.method,
       url: "/mcp",
       headers: fanDownHeaders(req.headers),
-      identity,
-      body,
+      identity: routedIdentity,
+      body: stripCallerHints(body),
+      correlation: {
+        requestId: id,
+        tenant: selected.tenant,
+        target: selected.target,
+        source: selected.source,
+        ...(mapped.actor ? { actor: mapped.actor } : {}),
+        ...(mapped.delegator ? { delegator: mapped.delegator } : {}),
+        ...(boundPolicy.policy ? { policyDigest: boundPolicy.policy } : {}),
+      },
     });
     if (!wrote) {
-      broker.settle({ id, status: 503 });
+      broker.settle({ id, status: 503 }, { owner: selected.session.agentId });
       jsonResponse(res, 503, { error: "no_agent" });
       return;
     }
@@ -446,16 +831,20 @@ export async function startEdge({
     agentPort: channelAddr.port,
     resourceMetadataUrl: inbound.resourceMetadataUrl,
     get hasAgent() {
-      return Boolean(session);
+      return sessions.size > 0;
     },
     get agentId() {
-      return session?.agentId ?? null;
+      if (sessions.size !== 1) return null;
+      return sessions.keys().next().value;
+    },
+    get agentIds() {
+      return [...sessions.keys()];
     },
     async close() {
       if (closed) return;
       closed = true;
-      session?.socket.destroy();
-      session = null;
+      for (const entry of sessions.values()) entry.socket.destroy();
+      sessions.clear();
       broker.rejectAll(new Error("Relay edge closed."));
       await closeServer(channelServer);
       await closeServer(northServer);