1 files changed, 53 insertions, 0 deletions

diff --git a/packages/meshbay-hub/src/meshbay_hub/static/transport.js b/packages/meshbay-hub/src/meshbay_hub/static/transport.js
index 9b86921..f9e1370 100644
--- a/packages/meshbay-hub/src/meshbay_hub/static/transport.js
+++ b/packages/meshbay-hub/src/meshbay_hub/static/transport.js
@@ -684,6 +684,8 @@ class MeshBayTransport {
 
   /** Set on a first join: the identity created for this node, still to be left with it. */
   get newNodeBundle() { return this._newNodeBundle || null; }
+  /** TRANSITIONAL — the identity was read from an MBK2 bundle, not created. */
+  get upgradedLegacy() { return Boolean(this._upgradedLegacy); }
   set newNodeBundle(v) { this._newNodeBundle = v; }
 
   /** The recovery-wrapped copy of that same first-join identity, when a recovery key was in hand. */
@@ -765,6 +767,7 @@ class MeshBayTransport {
     this._groupId = groupId || '';
     this._newNodeBundle = null;
     this._newNodeBundleRecovery = null;
+    this._upgradedLegacy = false;
     this._joinError = null;
     // Per connection, for the same reason the chat keys and the roster are
     // dropped further down: the device the *previous* connection identified
@@ -1048,6 +1051,8 @@ class MeshBayTransport {
           fresh = await this._settleNativeIdentity(kpResp);
         } else if (this._nodeHasBundle && K.bundleFormat(kpResp.bundle_enc) === 'retired') {
           throw _retiredBundleError();
+        } else if (this._nodeHasBundle && K.bundleFormat(kpResp.bundle_enc) === 'legacy') {
+          keys = await this._openLegacyBundle(kpResp, sealedFor);
         } else if (this._nodeHasBundle) {
           try {
             keys = await K.decryptBundle(kpResp.bundle_enc,
@@ -1298,6 +1303,46 @@ class MeshBayTransport {
    * hangs, the textbox is dead" report. Every exit below names itself.
    */
   /**
+   * TRANSITIONAL — an MBK2 bundle, opened with the session's legacy key (or
+   * the recovery copy with the recovery key) and sealed again as MBK3, left
+   * for `settleNodeBundle` to store in its place once the connection is made.
+   *
+   * A session restored from before the legacy key was kept has none: the
+   * passphrase is asked for again (`no_keys`) rather than the identity being
+   * declared lost. A legacy key that does not open it — a bundle sealed under
+   * an older passphrase — is what a current bundle that does not open is: the
+   * caller goes on to a first join.
+   */
+  async _openLegacyBundle(kpResp, sealedFor) {
+    const K = window.MeshBayKeys;
+    let keys = null;
+    if (this._bundleKey.legacy) {
+      try { keys = await K.decryptLegacyBundle(kpResp.bundle_enc, this._bundleKey.legacy); }
+      catch { /* sealed under another passphrase */ }
+    }
+    if (!keys && this._recoveryKey && kpResp.bundle_enc_recovery
+        && K.bundleFormat(kpResp.bundle_enc_recovery) === 'legacy') {
+      try {
+        keys = await K.decryptLegacyBundle(kpResp.bundle_enc_recovery, this._recoveryKey);
+        this._recoveredFromRecovery = true;
+      } catch { /* not this recovery key */ }
+    }
+    if (!keys) {
+      if (!this._bundleKey.legacy && !this._recoveryKey) {
+        const err = new Error('Your passphrase is needed once to update how this node keeps your identity');
+        err.reason = 'no_keys';
+        throw err;
+      }
+      return null;
+    }
+    const sealed = await K.resealLegacyIdentity(keys, this._bundleKey, this._recoveryKey, sealedFor);
+    this._newNodeBundle = sealed.bundleEnc;
+    this._newNodeBundleRecovery = sealed.bundleEncRecovery || null;
+    this._upgradedLegacy = true;
+    return keys;
+  }
+
+  /**
    * This node's identity when the desktop application holds the keys.
    *
    * Kept by the application once it has it, so a bundle left on the node —
@@ -1316,8 +1361,16 @@ class MeshBayTransport {
         throw _retiredBundleError();
       }
       try {
+        // An MBK2 bundle too (TRANSITIONAL): the application opens it with
+        // the legacy key it kept from the passphrase, and `settleNodeBundle`
+        // then replaces or withdraws it as browser access says.
         pub = await P.openBundle(uid, pk, { bundleEnc: kpResp.bundle_enc });
       } catch (e) {
+        if (String(e && e.message).includes('no_legacy_key')) {
+          const err = new Error('Your passphrase is needed once to update how this node keeps your identity');
+          err.reason = 'no_keys';
+          throw err;
+        }
         // Sealed under a passphrase no longer in use: as in a browser, a
         // passphrase change must report it, and a first join replaces it.
         if (this._rewrapOnly) throw new Error('could not open the stored identity');