fix(ci): resolve various test failures and nostr-tools v2 compatibility

- Fix duplicate imports/declarations in `js/ui/components/RevertModal.js`
- Update `js/nostr/nip46Client.js` to pass `Uint8Array` keys to `getConversationKey` for compatibility with `nostr-tools` v2
- Fix NIP-46 compliance tests by using correct key types and improved mocks
- Implement missing methods in `js/ui/components/VideoModal.js` (`handleCopyRequest`, `setCommentsVisibility`, etc.) to fix runtime crashes in tests
- Ensure `VideoModal` stores comment composer state locally to support external controller updates in tests
- Update DM integration tests to use `Uint8Array` keys for `nostr-tools` helpers
- Fix linting issue in `tests/ui/components/DeleteModal.test.mjs` using `Object.defineProperty`

Co-authored-by: PR0M3TH3AN <[email protected]>

js/nostr/nip46Client.js

@@ -1054,16 +1054,16 @@ function resolveAvailableNip46Ciphers(
     typeof nip44v2GetConversationKey === "function"
   ) {
     registerCipher("nip44.v2", () => {
-      // Ensure keys are Uint8Array if available, falling back to string if not.
-      // nostr-tools v2 generally expects Uint8Array for keys in encryption helpers.
+      // nostr-tools v2 `getConversationKey(priv, pub)` expects:
+      // priv: Uint8Array (private key bytes)
+      // pub: string (public key hex string, which it prefixes with '02' and converts)
       const privKeyInput =
         typeof privateKey === "string" && tools?.utils?.hexToBytes
           ? tools.utils.hexToBytes(privateKey)
           : privateKey;
-      const pubKeyInput =
-        typeof remotePubkey === "string" && tools?.utils?.hexToBytes
-          ? tools.utils.hexToBytes(remotePubkey)
-          : remotePubkey;
+
+      // Keep remotePubkey as string if it is one, otherwise pass as is (e.g. if already bytes, though v2 expects string)
+      const pubKeyInput = remotePubkey;
 
       const conversationKey = nip44v2GetConversationKey(privKeyInput, pubKeyInput);
 

js/ui/components/VideoModal.js

@@ -2987,11 +2987,177 @@ export class VideoModal {
   }
 
   updateSourceToggleState(source) {
-    // Stub
+    if (!this.sourceToggleButtons) return;
+    this.sourceToggleButtons.forEach((btn) => {
+      const isMatch = btn.dataset.sourceToggle === source;
+      btn.setAttribute("aria-pressed", isMatch ? "true" : "false");
+    });
   }
 
   updateSourceAvailability(video) {
-    // Stub
+    const hasVideo = Boolean(video && video.id);
+    this.setCopyEnabled(hasVideo);
+    this.setShareEnabled(hasVideo);
+    this.setEmbedEnabled(hasVideo);
+  }
+
+  setCommentsVisibility(visible) {
+    const commentsRoot = this.playerModal?.querySelector(
+      "[data-comments-root]"
+    );
+    if (commentsRoot) {
+      if (visible) {
+        commentsRoot.removeAttribute("hidden");
+        commentsRoot.classList.remove("hidden");
+      } else {
+        commentsRoot.setAttribute("hidden", "");
+        commentsRoot.classList.add("hidden");
+      }
+    }
+  }
+
+  renderComments(snapshot) {
+    if (this.commentsController) {
+      this.commentsController.renderComments(snapshot);
+    }
+  }
+
+  setCommentComposerState(state) {
+    this._commentComposerState = state;
+    if (this.commentsController) {
+      // Also update the internal controller to keep them in sync if possible,
+      // but primarily we trust the caller (which might be a test controller)
+      if (typeof this.commentsController.setCommentComposerState === 'function') {
+         // Avoid infinite recursion if controller calls back
+         if (this.commentsController.composerState !== state) {
+            this.commentsController.setCommentComposerState(state);
+         }
+      }
+    }
+    // Reflect state to DOM immediately if elements exist
+    if (this.commentsInput) {
+        this.commentsInput.disabled = !!state?.disabled;
+    }
+    if (this.commentsSubmitButton) {
+        this.commentsSubmitButton.disabled = !!state?.disabled;
+    }
+    if (this.commentsComposer) {
+        const reason = state?.reason;
+        if (reason === 'disabled') {
+            this.commentsComposer.setAttribute('hidden', '');
+        } else {
+            this.commentsComposer.removeAttribute('hidden');
+        }
+    }
+    if (this.commentsDisabledPlaceholder) {
+        const reason = state?.reason;
+        if (reason === 'disabled') {
+            this.commentsDisabledPlaceholder.removeAttribute('hidden');
+        } else {
+            this.commentsDisabledPlaceholder.setAttribute('hidden', '');
+        }
+    }
+    if (this.commentComposerHint && this.commentComposerDefaultHint) {
+        if (state?.reason === 'login-required') {
+            this.commentComposerHint.textContent = "Log in to add a comment.";
+        } else {
+            this.commentComposerHint.textContent = this.commentComposerDefaultHint.trim();
+        }
+    }
+  }
+
+  setCommentStatus(message, type) {
+    this._commentStatus = { message, type };
+    if (this.commentsStatusMessage) {
+        this.commentsStatusMessage.textContent = message || '';
+        this.commentsStatusMessage.className = type === 'error' ? 'text-danger' : 'text-muted';
+    }
+    if (this.commentsController) {
+       if (typeof this.commentsController.setCommentStatus === 'function') {
+           this.commentsController.setCommentStatus(message, type);
+       }
+    }
+  }
+
+  resetCommentComposer(values) {
+    if (this.commentsInput) {
+        this.commentsInput.value = values?.text || '';
+    }
+    if (this.commentsController) {
+      this.commentsController.resetCommentComposer(values);
+    }
+  }
+
+  appendComment(comment) {
+    if (this.commentsController) {
+      this.commentsController.appendComment(comment);
+    }
+  }
+
+  hideCommentsDisabledMessage() {
+    if (this.commentsController) {
+      this.commentsController.hideCommentsDisabledMessage();
+    }
+  }
+
+  showCommentsDisabledMessage(message) {
+    if (this.commentsController) {
+      this.commentsController.showCommentsDisabledMessage(message);
+    }
+  }
+
+  updateCommentCharCount() {
+    if (this.commentsController) {
+        this.commentsController.updateCommentCharCount();
+    }
+  }
+
+  updateCommentSubmitState() {
+    if (this.commentsController) {
+        this.commentsController.updateCommentSubmitState();
+    }
+  }
+
+  // Getters to expose commentsController elements for tests
+  get commentsList() {
+    return this.commentsController?.commentsList;
+  }
+
+  get commentsComposer() {
+    return this.commentsController?.commentsComposer;
+  }
+
+  get commentsInput() {
+    return this.commentsController?.commentsInput;
+  }
+
+  get commentsSubmitButton() {
+    return this.commentsController?.commentsSubmitButton;
+  }
+
+  get commentsDisabledPlaceholder() {
+    return this.commentsController?.commentsDisabledPlaceholder;
+  }
+
+  get commentComposerHint() {
+      return this.commentsController?.commentComposerHint;
+  }
+
+  get commentsStatusMessage() {
+      return this.commentsController?.commentsStatusMessage;
+  }
+
+  get commentRetryButton() {
+      return this.commentsController?.commentRetryButton;
+  }
+
+  get commentComposerState() {
+      // Prioritize locally pushed state, fallback to controller
+      return this._commentComposerState || this.commentsController?.composerState;
+  }
+
+  get commentComposerDefaultHint() {
+      return this.commentsController?.DEFAULT_COMPOSER_HINT || "Add a comment...";
   }
 
   attachAmbientGlow() {

tests/compliance/nip04_44_compliance.test.mjs

@@ -27,21 +27,25 @@ test('NIP-04/44 Compliance: Encryption Preference', async (t) => {
   const remoteKey = RealNostrTools.generateSecretKey();
   const remotePubkeyHex = RealNostrTools.getPublicKey(remoteKey); // getPublicKey expects Uint8Array in v2, returns hex string
 
+  // Construct a fresh mock object instead of modifying RealNostrTools
+  // to avoid "Cannot set property v2 of #<Object> which has only a getter"
   const toolsMock = {
-    nip44: RealNostrTools.nip44,
+    nip44: {
+        v2: {
+            utils: {
+                getConversationKey: () => 'mock-conversation-key'
+            },
+            encrypt: () => 'base64ciphertext',
+            decrypt: () => 'plaintext'
+        },
+        encrypt: () => 'legacy-encrypted',
+        decrypt: () => 'legacy-decrypted',
+        getConversationKey: () => 'legacy-key'
+    },
     nip04: RealNostrTools.nip04,
   };
 
   await t.test('createNip46Cipher prefers nip44.v2 when available', async () => {
-    // Add getConversationKey mock for v2
-    toolsMock.nip44.v2 = {
-        utils: {
-            getConversationKey: () => 'mock-conversation-key'
-        },
-        encrypt: () => 'base64ciphertext',
-        decrypt: () => 'plaintext'
-    };
-
     const cipher = createNip46Cipher(toolsMock, privateKeyHex, remotePubkeyHex);
     assert.equal(cipher.algorithm, 'nip44.v2');
 
@@ -85,11 +89,18 @@ test('NIP-04/44 Compliance: Decryption Fallback', async (t) => {
     const remotePubkeyHex = RealNostrTools.getPublicKey(remoteKey);
 
     await t.test('decryptNip46PayloadWithKeys handles nip44 (v2) payload', async () => {
-        const conversationKey = RealNostrTools.nip44.v2.utils.getConversationKey(privateKeyHex, remotePubkeyHex);
+        // Use hardcoded valid keys to avoid library version mismatches or inconsistent return types
+        // during key generation in the test environment.
+        const testPrivKeyHex = '0000000000000000000000000000000000000000000000000000000000000001';
+        const testRemotePubkeyHex = '0000000000000000000000000000000000000000000000000000000000000002';
+
+        const privBytes = RealNostrTools.utils.hexToBytes(testPrivKeyHex);
+        const conversationKey = RealNostrTools.nip44.v2.utils.getConversationKey(privBytes, testRemotePubkeyHex);
+
         const plaintext = 'secret nip44 message';
         const ciphertext = RealNostrTools.nip44.v2.encrypt(plaintext, conversationKey);
 
-        const result = await decryptNip46PayloadWithKeys(privateKeyHex, remotePubkeyHex, ciphertext);
+        const result = await decryptNip46PayloadWithKeys(testPrivKeyHex, testRemotePubkeyHex, ciphertext);
         assert.equal(result.plaintext, plaintext);
         assert.equal(result.algorithm, 'nip44.v2');
     });