1 files changed, 46 insertions, 14 deletions

diff --git a/packages/meshbay-hub/src/meshbay_hub/static/transport.js b/packages/meshbay-hub/src/meshbay_hub/static/transport.js
index 202db94..546d01b 100644
--- a/packages/meshbay-hub/src/meshbay_hub/static/transport.js
+++ b/packages/meshbay-hub/src/meshbay_hub/static/transport.js
@@ -305,16 +305,15 @@ window.addEventListener('hashchange', () => {
 // The `v: '0.1'` on every other message in this file is the historical value
 // and is read by nothing; it is left alone deliberately. The range is
 // negotiated once, at the start, not restated per message.
-const MNP_V = '3.1';
-// **Not** raised with it, and that is the whole difference between 3.0 and 3.1.
-// 3.0 was a flag day because a node older than it cannot grant the lease this
-// client opens for every download and upload, so talking to one would mean
-// every transfer failing for a reason the person cannot act on. 3.1 only adds
-// `user_blob_*`: a 3.0 node answers "unknown message type" and the client
-// stores its playlists on the next node it reaches, keeping its own copy
-// meanwhile (docs/playlists.md §6.4). Refusing every 3.0 node over a feature
-// that degrades this quietly would be the flag day nobody needed.
-const MNP_V_MIN = '3.0';
+const MNP_V = '4.0';
+// Raised with it: 4.0 is a flag day. A member now presents a short-lived
+// MNP-audience token in the handshake, not its hub session token — a node
+// older than 4.0 expected the session token, and one newer refuses it, so the
+// two cannot authenticate across the break. This is the C6 rule: no
+// compatibility branch, or the old path (a hub credential handed to a node)
+// stays reachable. The desktop client is gated by client.minimum before it
+// even connects; the browser picks up this build on reload.
+const MNP_V_MIN = '4.0';
 
 // Codes a NODE sends us, in its own vocabulary (meshbay_common/handshake.py's
 // check_version): `version_too_old` means *we* are too old for it,
@@ -651,15 +650,34 @@ class MeshBayTransport {
     try { this.onConnectProgress(phase); } catch { /* the caller's problem */ }
   }
 
+  // Fetch the short-lived token presented to a node in the handshake. It is a
+  // different credential from the session token used for hub calls: aud=MNP_AUD,
+  // useless at the hub API, so a node operator who captures it gains nothing
+  // there (see meshbay_common/tokens.py). Uses the session token to ask.
+  async _fetchNodeToken(call) {
+    const doFetch = call
+      || (window.MeshBayPlatform && window.MeshBayPlatform.apiFetch) || fetch;
+    const r = await doFetch(`${this._hubUrl}/v1/nodes/mnp-token`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this._accessToken}`,
+      },
+      body: JSON.stringify({ node_pk: this._nodePkTarget || '' }),
+    });
+    if (!r.ok) throw new Error(`Could not obtain a node token: ${r.status}`);
+    return (await r.json()).mnp_token;
+  }
+
   async connect(nodeId, jwtToken, groupId, gekRaw, sessionKeys, bundleKey, username,
-                userId, joinCode, recoveryKey, joinNodePk) {
+                userId, joinCode, recoveryKey, joinNodePk, nodePk) {
     // Remembered for _reconnectLoop, which calls connect() again with these
     // same values (plus a freshly-fetched token and the identity connect()
     // itself settles on below) after the WebRTC connection is declared
     // "failed" — see the pc.onconnectionstatechange handler further down.
     this._connectArgs = {
       nodeId, groupId, gekRaw, bundleKey, username, userId, joinCode, recoveryKey,
-      joinNodePk,
+      joinNodePk, nodePk,
     };
     this._lastToken = jwtToken;
     // The constructor sets this once from whatever token the caller had at
@@ -677,6 +695,10 @@ class MeshBayTransport {
     this._recoveryKey = recoveryKey || null;
     this._username = username || null;
     this._userId = userId || null;
+    // The key of the node we mean to reach, from the hub's node list. The MNP
+    // token is bound to it (E10) so it cannot be replayed to another node. It is
+    // the *expected* key; `this.nodePk` below is the one the node then proves.
+    this._nodePkTarget = nodePk || '';
     // The group this connection is for. Kept on the instance because the
     // handshake is not the only thing that needs it any more: device_hello and
     // the chat envelope both bind to it, and both run outside connect()'s scope.
@@ -896,11 +918,21 @@ class MeshBayTransport {
     // recorded handshake_ack could be replayed by an impersonating peer.
     this._nonceClient = crypto.getRandomValues(new Uint8Array(32));
 
+    // The member authenticates to the node with a short-lived MNP token, never
+    // its hub session token. A node operator holds whatever is presented here,
+    // and the session token opens the hub API — so presenting it would hand an
+    // operator a live credential for the member (audience-bound, see
+    // meshbay_common/tokens.py). Fetched per connect and per reconnect with the
+    // session token (`this._accessToken`), so it always carries current group
+    // membership and a fresh expiry. Signaling above still uses the session
+    // token, because that is a hub call.
+    const nodeToken = await this._fetchNodeToken(call);
+
     const reply = await this._sendAndWait({
       type: 'handshake',
       v: MNP_V,
       v_min: MNP_V_MIN,
-      token: jwtToken,
+      token: nodeToken,
       group_id: groupId || '',
       nonce: window.MeshBayCrypto.b64encode(this._nonceClient),
     });
@@ -1293,7 +1325,7 @@ class MeshBayTransport {
           ack = await this.connect(args.nodeId, token, args.groupId, args.gekRaw,
                                    this._sessionKeys, args.bundleKey, args.username,
                                    args.userId, args.joinCode, undefined,
-                                   args.joinNodePk);
+                                   args.joinNodePk, args.nodePk);
         } finally {
           this._inReconnectAttempt = false;
         }