From d109a41158c1528788e9b833b9f443ae94a881dd Mon Sep 17 00:00:00 2001
From: DreamLab-AI Mega-Sprint <anthropic@xrsystems.uk>
Date: Tue, 12 May 2026 14:20:12 +0000
Subject: [PATCH 01/24] fix: remove duplicate fetch/XHR interception from
 content script
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Both src/injected.js (content script context) and
src/nip98-interceptor.js (page context) were independently overriding
window.fetch and XMLHttpRequest.prototype.send. This caused double
interception of every request, double auth header injection, and double
401 retry loops.

The content script's interception was also coupled to a
window.__podkey_setAuthFn callback that was never properly wired —
getAuthHeaderFn started as null and relied on an async setup race.

This commit removes all fetch/XHR interception code from injected.js
and leaves NIP-98 request interception solely to nip98-interceptor.js,
which already has its own clean implementation using CustomEvent-based
message passing to the content script. The content script now only
handles what it should: relaying podkey-request/podkey-response events
for NIP-07 and podkey-nip98-request/response events for NIP-98.

Co-Authored-By: claude-flow <ruv@ruv.net>
---
 src/injected.js | 321 ++----------------------------------------------
 1 file changed, 11 insertions(+), 310 deletions(-)

diff --git a/src/injected.js b/src/injected.js
index b77f08b..06c7a75 100644
--- a/src/injected.js
+++ b/src/injected.js
@@ -1,266 +1,13 @@
 /**
  * Podkey - Content Script
- * Bridges between injected window.nostr and background script
+ * Bridges between injected window.nostr and background script.
+ *
+ * Fetch/XHR interception for NIP-98 auth headers is handled exclusively
+ * by src/nip98-interceptor.js (injected into the page context below).
+ * This content script only relays messages between the page and the
+ * extension background via CustomEvents.
  */
 
-// CRITICAL: Set up fetch/XHR interception IMMEDIATELY, synchronously
-// This must run before ANY other code, including page scripts
-(function setupInterceptionImmediately () {
-  'use strict';
-
-  // Store original functions
-  const originalFetch = window.fetch;
-  const originalXHROpen = XMLHttpRequest.prototype.open;
-  const originalXHRSend = XMLHttpRequest.prototype.send;
-  const originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
-
-  // Duplicate of src/auth-header-utils.js — keep in sync. The canonical
-  // module is imported by unit tests; this copy runs in content-script
-  // context where classic scripts can't use ESM imports. Build-time
-  // bundling to drop the duplication is tracked in #7.
-  function hasAuthorizationHeader (headers) {
-    if (!headers) return false;
-    if (typeof Headers !== 'undefined' && headers instanceof Headers) {
-      return headers.has('authorization');
-    }
-    if (Array.isArray(headers)) {
-      return headers.some((entry) =>
-        Array.isArray(entry) && typeof entry[0] === 'string' &&
-        entry[0].toLowerCase() === 'authorization'
-      );
-    }
-    if (typeof headers === 'object') {
-      for (const key of Object.keys(headers)) {
-        if (key.toLowerCase() === 'authorization') return true;
-      }
-    }
-    return false;
-  }
-
-  // Per fetch spec, init.headers overrides Request.headers entirely — so
-  // init.headers is authoritative when present. Only consult input.headers
-  // when init omits the headers key.
-  function fetchCallHasAuthorization (input, init) {
-    if (init && Object.prototype.hasOwnProperty.call(init, 'headers')) {
-      return hasAuthorizationHeader(init.headers);
-    }
-    if (typeof Request !== 'undefined' && input instanceof Request) {
-      return hasAuthorizationHeader(input.headers);
-    }
-    return false;
-  }
-
-  function setAuthorizationOnOptions (options, value) {
-    options.headers = options.headers || {};
-    if (typeof Headers !== 'undefined' && options.headers instanceof Headers) {
-      options.headers.set('Authorization', value);
-    } else if (Array.isArray(options.headers)) {
-      const normalized = new Headers(options.headers);
-      normalized.set('Authorization', value);
-      options.headers = normalized;
-    } else {
-      for (const key of Object.keys(options.headers)) {
-        if (key.toLowerCase() === 'authorization') delete options.headers[key];
-      }
-      options.headers['Authorization'] = value;
-    }
-    return options.headers;
-  }
-
-  function normalizeFetchCall (input, init) {
-    if (typeof Request !== 'undefined' && input instanceof Request) {
-      return {
-        url: input.url,
-        method: init?.method || input.method || 'GET',
-        body: init?.body
-      };
-    }
-    return {
-      url: typeof input === 'string' ? input : String(input),
-      method: init?.method || 'GET',
-      body: init?.body
-    };
-  }
-
-  // Helper to get auth header (will be async, but we'll handle that)
-  let getAuthHeaderFn = null;
-
-  // Set up the async auth header function (will be defined below)
-  function setAuthHeaderFn (fn) {
-    getAuthHeaderFn = fn;
-  }
-
-  // Intercept fetch - MUST replace immediately to catch all calls
-  // This runs synchronously, so it catches fetch even if called immediately
-  window.fetch = function (url, options = {}) {
-    // Default-param `= {}` only applies for `undefined`; `fetch(url, null)`
-    // passes null through. Coerce once so the rest of the wrapper can
-    // assume an object.
-    options = options || {};
-    // Normalize once — handles fetch(url, init) and fetch(new Request(...))
-    // so downstream signing sees the real URL/method, not "[object Request]".
-    const { url: urlString, method, body } = normalizeFetchCall(url, options);
-    console.log('[Podkey] 🔍 fetch() intercepted:', urlString, method);
-
-    // Respect an Authorization header the page already set — on either
-    // options.headers or a Request input (e.g. Solid-OIDC DPoP). Overwriting
-    // would re-identify the request as Podkey's NIP-98 and break the page's
-    // own auth. If it fails with 401, the retry path below still injects
-    // NIP-98. See issue #5.
-    const pageSetAuth = fetchCallHasAuthorization(url, options);
-
-    // If we have the auth function, use it
-    if (getAuthHeaderFn && !pageSetAuth) {
-      console.log('[Podkey] ✅ Auth function ready, adding header...');
-      const promise = (async () => {
-        try {
-          const authHeader = await getAuthHeaderFn(urlString, method, body);
-          if (authHeader) {
-            setAuthorizationOnOptions(options, authHeader);
-            console.log('[Podkey] ✅ Added NIP-98 auth header');
-          } else {
-            console.log('[Podkey] ⚠️ No auth header returned (will retry on 401)');
-          }
-        } catch (e) {
-          console.error('[Podkey] Error in fetch interceptor:', e);
-        }
-        return originalFetch.call(this, url, options);
-      })();
-
-      // Handle 401 retry
-      return promise.then(response => {
-        if (response.status === 401 && getAuthHeaderFn) {
-          console.log('[Podkey] 🔄 401 detected, retrying with auth...');
-          return (async () => {
-            try {
-              const authHeader = await getAuthHeaderFn(urlString, method, body);
-              if (authHeader) {
-                const retryOptions = { ...options };
-                setAuthorizationOnOptions(retryOptions, authHeader);
-                console.log('[Podkey] 🔄 Retrying with NIP-98 auth...');
-                const retryResponse = await originalFetch.call(this, url, retryOptions);
-                if (retryResponse.status === 200 || retryResponse.status === 201) {
-                  console.log('[Podkey] ✅✅ NIP-98 auth retry successful!');
-                } else {
-                  console.log('[Podkey] ⚠️ Retry still failed:', retryResponse.status);
-                }
-                return retryResponse;
-              }
-            } catch (e) {
-              console.error('[Podkey] Error in 401 retry:', e);
-            }
-            return response;
-          })();
-        }
-        return response;
-      });
-    }
-
-    // Fall-through branch: we're here because either the page set its own
-    // Authorization (and we deliberately skipped initial injection) or the
-    // auth function isn't wired up yet. Send the request as-is; on 401,
-    // retry with NIP-98 — either immediately if ready, or after waiting
-    // for setup (with a hard deadline so we don't hang forever).
-    if (pageSetAuth) {
-      console.log('[Podkey] ⏭️ Page already set Authorization — skipping initial injection');
-    } else {
-      console.log('[Podkey] ⚠️ Auth function not ready yet, making request...');
-    }
-
-    const requestPromise = originalFetch.call(this, url, options);
-
-    const AUTH_READY_DEADLINE_MS = 5000;
-
-    // If we get a 401 and auth becomes available, retry
-    return requestPromise.then(response => {
-      if (response.status === 401) {
-        console.log('[Podkey] 🔄 Got 401, checking if auth function is ready now...');
-        // Wait for auth function to be ready, bounded by deadline. Every
-        // async step below has an error handler so the outer promise is
-        // guaranteed to settle (otherwise the caller would hang).
-        return new Promise((resolve) => {
-          const deadline = Date.now() + AUTH_READY_DEADLINE_MS;
-          const checkAuth = () => {
-            if (getAuthHeaderFn) {
-              console.log('[Podkey] 🔄 Auth function now ready, retrying with NIP-98...');
-              getAuthHeaderFn(urlString, method, body)
-                .then(authHeader => {
-                  if (authHeader) {
-                    const retryOptions = { ...options };
-                    setAuthorizationOnOptions(retryOptions, authHeader);
-                    originalFetch.call(this, url, retryOptions)
-                      .then(resolve)
-                      .catch(err => {
-                        console.error('[Podkey] Retry fetch failed:', err);
-                        resolve(response);
-                      });
-                  } else {
-                    resolve(response);
-                  }
-                })
-                .catch(err => {
-                  console.error('[Podkey] Error getting auth header for retry:', err);
-                  resolve(response);
-                });
-            } else if (Date.now() >= deadline) {
-              console.log('[Podkey] ⚠️ Auth function still not ready after deadline, giving up');
-              resolve(response);
-            } else {
-              // Check again in 100ms
-              setTimeout(checkAuth, 100);
-            }
-          };
-          checkAuth();
-        });
-      }
-      return response;
-    });
-  };
-
-  // Intercept XMLHttpRequest
-  XMLHttpRequest.prototype.open = function (method, url, ...args) {
-    this._podkeyMethod = method;
-    this._podkeyUrl = url;
-    this._podkeyHasPageAuth = false;
-    return originalXHROpen.apply(this, [method, url, ...args]);
-  };
-
-  // Track a page-set Authorization on XHR so send() can respect it.
-  XMLHttpRequest.prototype.setRequestHeader = function (name, value) {
-    if (typeof name === 'string' && name.toLowerCase() === 'authorization') {
-      this._podkeyHasPageAuth = true;
-    }
-    return originalXHRSetRequestHeader.apply(this, arguments);
-  };
-
-  XMLHttpRequest.prototype.send = function (body) {
-    // setRequestHeader must run before send(); defer originalXHRSend until
-    // the header is applied (or skipped), else the async setRequestHeader
-    // would fire after the request is already in-flight and throw
-    // InvalidStateError.
-    const runSend = () => originalXHRSend.apply(this, [body]);
-    if (getAuthHeaderFn && this._podkeyUrl && !this._podkeyHasPageAuth) {
-      getAuthHeaderFn(this._podkeyUrl, this._podkeyMethod, body)
-        .then(authHeader => {
-          if (authHeader) {
-            originalXHRSetRequestHeader.call(this, 'Authorization', authHeader);
-          }
-        })
-        .catch(e => {
-          console.error('[Podkey] Error in XHR interceptor:', e);
-        })
-        .finally(runSend);
-    } else {
-      runSend();
-    }
-  };
-
-  // Expose setter for the auth function
-  window.__podkey_setAuthFn = setAuthHeaderFn;
-
-  console.log('[Podkey] ✅ Synchronous interception setup complete');
-})();
-
 // Inject NIP-98 interceptor FIRST (must run before any page code)
 const interceptorScript = document.createElement('script');
 interceptorScript.src = chrome.runtime.getURL('src/nip98-interceptor.js');
@@ -312,9 +59,12 @@ script.src = chrome.runtime.getURL('src/nostr-provider.js');
 script.onload = function () {
   this.remove();
 };
+script.onerror = function () {
+  console.error('[Podkey] Failed to load nostr-provider.js');
+};
 (document.head || document.documentElement).appendChild(script);
 
-// Listen for requests from the injected script
+// Listen for requests from the injected script (NIP-07 relay)
 window.addEventListener('podkey-request', async (event) => {
   const { id, type, ...data } = event.detail;
 
@@ -370,53 +120,4 @@ window.addEventListener('podkey-request', async (event) => {
   }
 });
 
-// NIP-98 auto-auth: Set up the async auth header function
-// This connects to the synchronous interceptor above
-(function setupAuthFunction () {
-  console.log('[Podkey] Setting up NIP-98 auth function...');
-
-  async function getNip98AuthHeader (url, method, body) {
-    try {
-      const urlString = typeof url === 'string' ? url : url.toString();
-      console.log('[Podkey] Requesting NIP-98 auth header for:', urlString, method);
-
-      const response = await chrome.runtime.sendMessage({
-        type: 'CREATE_NIP98_AUTH_HEADER',
-        url: urlString,
-        method: method || 'GET',
-        body: body
-      });
-
-      if (chrome.runtime.lastError) {
-        console.error('[Podkey] Error from background script:', chrome.runtime.lastError.message);
-        return null;
-      }
-
-      if (response) {
-        console.log('[Podkey] ✅ Got NIP-98 auth header');
-      } else {
-        console.log('[Podkey] ❌ No NIP-98 auth header (origin not trusted, auto-sign disabled, or no keypair)');
-      }
-
-      return response || null;
-    } catch (error) {
-      console.error('[Podkey] Error getting NIP-98 auth header:', error);
-      return null;
-    }
-  }
-
-  // Connect the auth function to the synchronous interceptor
-  if (window.__podkey_setAuthFn) {
-    window.__podkey_setAuthFn(getNip98AuthHeader);
-    console.log('[Podkey] ✅ Auth function connected');
-  } else {
-    console.error('[Podkey] ❌ Could not connect auth function - interceptor not ready');
-  }
-})();
-
-console.log('[Podkey] Content script loaded with NIP-98 auto-auth interception');
-
-// Error handling for script injection
-script.onerror = function () {
-  console.error('[Podkey] Failed to load nostr-provider.js');
-};
+console.log('[Podkey] Content script loaded');

From f7f3ff3ded3f46a38aed685535f308bb65d26271 Mon Sep 17 00:00:00 2001
From: DreamLab-AI Mega-Sprint <anthropic@xrsystems.uk>
Date: Tue, 12 May 2026 14:20:14 +0000
Subject: [PATCH 02/24] security: move private key from chrome.storage.local to
 chrome.storage.session

chrome.storage.local persists data to disk as unencrypted JSON at a
well-known path (~/.config/google-chrome/.../Local Extension Settings/<id>/).
Any process with filesystem access -- malware, other extensions with
nativeMessaging, backup tools -- can read the raw private key hex.

chrome.storage.session is MV3-only, in-memory storage that is:
- Never written to disk
- Cleared when the service worker terminates
- Scoped to the extension's origin

Changes:
- storeKeypair() now writes private key to session storage, public key
  to local storage (public key is not secret and is needed by the popup
  to display identity without unlocking)
- getKeypair() reads private key from session, public key from local
- deleteKeypair() clears from both storages (including legacy local copy)
- Added getStoredPublicKey() for popup identity display
- popup/popup.js handleExport() now reads from session storage first,
  with a fallback to local for legacy installs
- Added legacy private key cleanup: storeKeypair removes any old
  chrome.storage.local copy of the private key

Trade-off: Users must re-import their key after browser restart (session
storage is cleared). This is an acceptable UX cost for the security gain
of never persisting the private key to disk.

Co-Authored-By: claude-flow <ruv@ruv.net>
---
 popup/popup.js | 13 ++++++----
 src/storage.js | 65 ++++++++++++++++++++++++++++++++++++--------------
 2 files changed, 56 insertions(+), 22 deletions(-)

diff --git a/popup/popup.js b/popup/popup.js
index 80af088..4819b80 100644
--- a/popup/popup.js
+++ b/popup/popup.js
@@ -219,10 +219,15 @@ async function handleExport() {
   if (!confirmed) return;
 
   try {
-    const { podkey_private_key: privateKey } = await chrome.storage.local.get(['podkey_private_key']);
+    // Private key is now stored in session storage (in-memory only).
+    // Try session storage first, fall back to local for legacy installs.
+    let { podkey_private_key: privateKey } = await chrome.storage.session.get(['podkey_private_key']);
+    if (!privateKey) {
+      ({ podkey_private_key: privateKey } = await chrome.storage.local.get(['podkey_private_key']));
+    }
 
     if (!privateKey) {
-      alert('No private key found');
+      alert('No private key found. The key may have been cleared when the browser restarted. Please re-import your key.');
       return;
     }
 
@@ -282,9 +287,9 @@ async function removeTrustedSite(origin) {
   console.log('[Podkey] Removed trusted site:', origin);
 }
 
-// Listen for storage changes
+// Listen for storage changes (local for trusted sites / pubkey, session for private key)
 chrome.storage.onChanged.addListener((changes, areaName) => {
-  if (areaName === 'local' && currentScreen === 'main') {
+  if ((areaName === 'local' || areaName === 'session') && currentScreen === 'main') {
     loadTrustedSites();
   }
 });
diff --git a/src/storage.js b/src/storage.js
index 0996eb7..057b3c3 100644
--- a/src/storage.js
+++ b/src/storage.js
@@ -1,6 +1,11 @@
 /**
  * Podkey - Secure storage for Nostr keys
- * Uses Chrome storage API with encryption
+ *
+ * Private keys are stored in chrome.storage.session (in-memory only, never
+ * persisted to disk, cleared when the service worker terminates).
+ *
+ * Public keys remain in chrome.storage.local so the popup can display the
+ * user's pubkey/DID without requiring the private key to be unlocked.
  */
 
 const STORAGE_KEYS = {
@@ -13,7 +18,9 @@ const STORAGE_KEYS = {
 };
 
 /**
- * Store private key securely
+ * Store keypair securely.
+ * Private key goes to session storage (in-memory only).
+ * Public key goes to local storage (persisted, but not secret).
  * @param {string} privateKey - 64-char hex private key
  * @param {string} publicKey - 64-char hex public key
  */
@@ -23,36 +30,46 @@ export async function storeKeypair(privateKey, publicKey) {
     throw new Error('Keys must be 64-char hex');
   }
 
+  // Private key: session storage only (in-memory, never written to disk)
+  await chrome.storage.session.set({
+    [STORAGE_KEYS.PRIVATE_KEY]: privateKey
+  });
+
+  // Public key: local storage (needs to survive service worker restarts
+  // so the popup can show the user's identity without the private key)
   await chrome.storage.local.set({
-    [STORAGE_KEYS.PRIVATE_KEY]: privateKey,
     [STORAGE_KEYS.PUBLIC_KEY]: publicKey
   });
 
-  console.log('[Podkey] Keypair stored securely');
+  // Remove any legacy private key from local storage left by older versions
+  await chrome.storage.local.remove([STORAGE_KEYS.PRIVATE_KEY]);
+
+  console.log('[Podkey] Keypair stored (private key in session storage only)');
 }
 
 /**
- * Get stored keypair
+ * Get stored keypair.
+ * Private key comes from session storage, public key from local storage.
+ * Returns null if either key is missing (e.g. service worker restarted and
+ * session storage was cleared -- user will need to re-import).
  * @returns {Promise<{privateKey: string, publicKey: string} | null>}
  */
 export async function getKeypair() {
-  const result = await chrome.storage.local.get([
-    STORAGE_KEYS.PRIVATE_KEY,
-    STORAGE_KEYS.PUBLIC_KEY
-  ]);
+  const { [STORAGE_KEYS.PRIVATE_KEY]: privateKey } =
+    await chrome.storage.session.get([STORAGE_KEYS.PRIVATE_KEY]);
+
+  const { [STORAGE_KEYS.PUBLIC_KEY]: publicKey } =
+    await chrome.storage.local.get([STORAGE_KEYS.PUBLIC_KEY]);
 
-  if (!result[STORAGE_KEYS.PRIVATE_KEY] || !result[STORAGE_KEYS.PUBLIC_KEY]) {
+  if (!privateKey || !publicKey) {
     return null;
   }
 
-  return {
-    privateKey: result[STORAGE_KEYS.PRIVATE_KEY],
-    publicKey: result[STORAGE_KEYS.PUBLIC_KEY]
-  };
+  return { privateKey, publicKey };
 }
 
 /**
- * Check if keypair exists
+ * Check if a usable keypair exists (private key in session + public key on disk).
  * @returns {Promise<boolean>}
  */
 export async function hasKeypair() {
@@ -61,16 +78,28 @@ export async function hasKeypair() {
 }
 
 /**
- * Delete stored keypair (use with caution!)
+ * Check if a public key exists on disk (may not have a private key in session).
+ * Useful for the popup to show identity even when the session has expired.
+ * @returns {Promise<string|null>} The public key hex, or null
+ */
+export async function getStoredPublicKey() {
+  const { [STORAGE_KEYS.PUBLIC_KEY]: publicKey } =
+    await chrome.storage.local.get([STORAGE_KEYS.PUBLIC_KEY]);
+  return publicKey || null;
+}
+
+/**
+ * Delete stored keypair from both session and local storage.
  * @returns {Promise<void>}
  */
 export async function deleteKeypair() {
+  await chrome.storage.session.remove([STORAGE_KEYS.PRIVATE_KEY]);
   await chrome.storage.local.remove([
-    STORAGE_KEYS.PRIVATE_KEY,
+    STORAGE_KEYS.PRIVATE_KEY, // clean up any legacy local copy
     STORAGE_KEYS.PUBLIC_KEY
   ]);
 
-  console.log('[Podkey] Keypair deleted');
+  console.log('[Podkey] Keypair deleted from all storage');
 }
 
 /**

From d9667dabd53eef415cbc6a91d1c8131db326a75b Mon Sep 17 00:00:00 2001
From: DreamLab-AI Mega-Sprint <anthropic@xrsystems.uk>
Date: Tue, 12 May 2026 14:20:29 +0000
Subject: [PATCH 03/24] security: fix Solid server auto-trust hostname matching

Replace String.includes() with exact hostname matching via URL parsing.
The previous substring check allowed malicious domains containing the
trusted substring to pass (e.g. evil-solid.social.attacker.com matched
solid.social). Now uses new URL().hostname with exact match or subdomain
check (hostname.endsWith('.' + trusted)). Also removes the never-matching
'/.well-known/solid' entry since origins don't contain paths.

Co-Authored-By: claude-flow <ruv@ruv.net>
---
 src/background.js | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/background.js b/src/background.js
index 84481e2..3e55567 100644
--- a/src/background.js
+++ b/src/background.js
@@ -330,16 +330,23 @@ function encodeNip98Header (signedEvent) {
  * @returns {boolean}
  */
 function isLikelySolidServer (origin) {
-  // Common Solid server indicators
-  const solidIndicators = [
+  let hostname;
+  try {
+    hostname = new URL(origin).hostname;
+  } catch {
+    return false;
+  }
+
+  const trustedHosts = [
     'solid.social',
     'solidcommunity.net',
     'inrupt.net',
-    'solidweb.org',
-    '/.well-known/solid'
+    'solidweb.org'
   ];
 
-  return solidIndicators.some(indicator => origin.includes(indicator));
+  return trustedHosts.some(trusted =>
+    hostname === trusted || hostname.endsWith('.' + trusted)
+  );
 }
 
 async function createNip98AuthHeader (url, method, body = null) {

From 69eaaca78d847afdbdcf1250a8919d15271b1f68 Mon Sep 17 00:00:00 2001
From: DreamLab-AI Mega-Sprint <anthropic@xrsystems.uk>
Date: Tue, 12 May 2026 14:20:32 +0000
Subject: [PATCH 04/24] security: remove NIP-98 signed event cache to prevent
 replay attacks

Remove the nip98Cache Map and all caching logic. The cache reused signed
events for identical URL+method+bodyHash within 60 seconds, causing the
same event ID to be sent multiple times. Servers with replay protection
reject duplicate event IDs, and the predictable cache keys create an
additional attack surface. NIP-98 event creation is computationally cheap
(~1ms with noble/secp256k1), so caching provides no meaningful benefit.

Co-Authored-By: claude-flow <ruv@ruv.net>
---
 src/background.js | 57 +++++++++++++++++------------------------------
 1 file changed, 20 insertions(+), 37 deletions(-)

diff --git a/src/background.js b/src/background.js
index 84481e2..638a5e5 100644
--- a/src/background.js
+++ b/src/background.js
@@ -17,9 +17,7 @@ import { bytesToHex } from '@noble/hashes/utils';
 
 console.log('[Podkey] Background service worker started');
 
-// NIP-98 auth event cache: key = `${url}:${method}:${bodyHash}`, value = { event, expires }
-const nip98Cache = new Map();
-const CACHE_TTL = 60000; // 60 seconds
+// NIP-98 events are always created fresh to avoid replay issues
 
 // Track retry state to prevent infinite loops: key = requestId, value = true
 const retryState = new Map();
@@ -392,43 +390,28 @@ async function createNip98AuthHeader (url, method, body = null) {
       }
     }
 
-    // Check cache
-    const cacheKey = `${url}:${method}:${bodyHash}`;
-    const cached = nip98Cache.get(cacheKey);
-
-    let signedEvent;
-    if (cached && cached.expires > Date.now()) {
-      signedEvent = cached.event;
-      console.log('[Podkey] Using cached NIP-98 auth event');
-    } else {
-      // Create and sign event
-      const event = {
-        kind: 27235,
-        content: '',
-        created_at: Math.floor(Date.now() / 1000),
-        tags: [
-          ['u', url],
-          ['method', method]
-        ]
-      };
-
-      if (bodyHash) {
-        event.tags.push(['payload', bodyHash]);
-      }
+    // Always create a fresh signed event (no caching -- reusing signed events
+    // causes replay issues and servers with replay protection reject duplicates)
+    const event = {
+      kind: 27235,
+      content: '',
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [
+        ['u', url],
+        ['method', method]
+      ]
+    };
 
-      const keypair = await getKeypair();
-      signedEvent = await signEvent(event, keypair.privateKey);
+    if (bodyHash) {
+      event.tags.push(['payload', bodyHash]);
+    }
 
-      // Cache
-      nip98Cache.set(cacheKey, {
-        event: signedEvent,
-        expires: Date.now() + CACHE_TTL
-      });
+    const keypair = await getKeypair();
+    const signedEvent = await signEvent(event, keypair.privateKey);
 
-      console.log('[Podkey] Created and signed NIP-98 auth event for', url);
-      console.log('[Podkey] NIP-98 event:', JSON.stringify(signedEvent, null, 2));
-      console.log('[Podkey] Public key (did:nostr):', `did:nostr:${keypair.publicKey}`);
-    }
+    console.log('[Podkey] Created and signed NIP-98 auth event for', url);
+    console.log('[Podkey] NIP-98 event:', JSON.stringify(signedEvent, null, 2));
+    console.log('[Podkey] Public key (did:nostr):', `did:nostr:${keypair.publicKey}`);
 
     const authHeader = `Nostr ${encodeNip98Header(signedEvent)}`;
     console.log('[Podkey] Authorization header (first 100 chars):', authHeader.substring(0, 100) + '...');

From af55262fc95bb2809b03565cddf711c5b7c4bef4 Mon Sep 17 00:00:00 2001
From: DreamLab-AI Mega-Sprint <anthropic@xrsystems.uk>
Date: Tue, 12 May 2026 14:20:34 +0000
Subject: [PATCH 05/24] security: whitelist message types in content script
 relay

Add an ALLOWED_TYPES whitelist to validate the type field from page
events before forwarding to the background script. Previously, the
type field came directly from the page with no validation, and the
spread operator forwarded arbitrary fields, allowing a malicious page
to invoke internal extension message handlers or inject unexpected
data. Now only known NIP message types are forwarded, and only safe
fields per message type are included in the forwarded message.

Co-Authored-By: claude-flow <ruv@ruv.net>
---
 src/injected.js | 34 ++++++++++++++++++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

diff --git a/src/injected.js b/src/injected.js
index b77f08b..5711a67 100644
--- a/src/injected.js
+++ b/src/injected.js
@@ -314,17 +314,47 @@ script.onload = function () {
 };
 (document.head || document.documentElement).appendChild(script);
 
+// Allowed message types that can be forwarded to the background script
+const ALLOWED_TYPES = new Set([
+  'GET_PUBLIC_KEY',
+  'SIGN_EVENT',
+  'GET_RELAYS',
+  'NIP04_ENCRYPT',
+  'NIP04_DECRYPT',
+  'NIP44_ENCRYPT',
+  'NIP44_DECRYPT'
+]);
+
 // Listen for requests from the injected script
 window.addEventListener('podkey-request', async (event) => {
   const { id, type, ...data } = event.detail;
 
   console.log('[Podkey] Received request:', type, 'from page');
 
+  if (!ALLOWED_TYPES.has(type)) {
+    console.warn('[Podkey] Rejected unknown request type:', type);
+    window.dispatchEvent(new CustomEvent('podkey-response', {
+      detail: { id, error: 'Unknown request type' }
+    }));
+    return;
+  }
+
+  // Only forward known safe fields per message type
+  const safeData = {};
+  if (type === 'SIGN_EVENT' && data.event) {
+    safeData.event = data.event;
+  } else if ((type === 'NIP04_ENCRYPT' || type === 'NIP04_DECRYPT' ||
+              type === 'NIP44_ENCRYPT' || type === 'NIP44_DECRYPT')) {
+    if (data.peer) safeData.peer = String(data.peer);
+    if (data.plaintext !== undefined) safeData.plaintext = String(data.plaintext || '');
+    if (data.ciphertext !== undefined) safeData.ciphertext = String(data.ciphertext);
+  }
+
   try {
-    // Forward to background script
+    // Forward to background script with only validated fields
     const response = await chrome.runtime.sendMessage({
       type,
-      ...data,
+      ...safeData,
       origin: window.location.origin
     });
 

From 5534b20ff3d86a9dc005dce69bf846ed10ddb2b5 Mon Sep 17 00:00:00 2001
From: DreamLab-AI Mega-Sprint <anthropic@xrsystems.uk>
Date: Tue, 12 May 2026 14:22:10 +0000
Subject: [PATCH 06/24] security: implement signing approval popup to replace
 auto-approve

The previous showPermissionPrompt() unconditionally returned true,
meaning ANY website could silently sign Nostr events as the user
without any confirmation. This is a complete bypass of the extension's
security model -- equivalent to giving every website full access to the
user's private key.

This commit replaces the auto-approve stub with a proper popup-based
approval flow:

- New popup/approve.html: Approval dialog showing the requesting
  origin, action description, and event preview data
- New popup/approve.js: Handles approve/deny button clicks and sends
  the decision back to the background service worker via
  chrome.runtime.sendMessage
- Modified src/background.js:
  - showPermissionPrompt() now opens a chrome.windows.create() popup
    and returns a Promise that resolves when the user clicks
    approve or deny
  - Pending approvals tracked via Map<requestId, resolve>
  - 60-second auto-deny timeout prevents abandoned prompts from
    blocking indefinitely
  - APPROVE_SIGNING message type handled before the main message
    router to avoid deadlock
  - Event preview data (kind, truncated content, tag count) passed
    to the approval popup for informed consent

This follows the same pattern used by established NIP-07 extensions
(nos2x, Alby) where every signing request requires explicit user
approval unless the origin has been previously trusted.

Co-Authored-By: claude-flow <ruv@ruv.net>
---
 popup/approve.html | 114 +++++++++++++++++++++++++++++++++++++++++++++
 popup/approve.js   |  55 ++++++++++++++++++++++
 src/background.js  |  96 ++++++++++++++++++++++++++------------
 3 files changed, 235 insertions(+), 30 deletions(-)
 create mode 100644 popup/approve.html
 create mode 100644 popup/approve.js

diff --git a/popup/approve.html b/popup/approve.html
new file mode 100644
index 0000000..f5db261
--- /dev/null
+++ b/popup/approve.html
@@ -0,0 +1,114 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>PodKey - Signing Request</title>
+  <link rel="stylesheet" href="popup.css">
+  <style>
+    body { width: 380px; min-height: 200px; }
+    .approve-container { padding: 16px; }
+    .approve-header {
+      margin: 0 0 12px;
+      font-size: 18px;
+      font-weight: 700;
+      background: linear-gradient(135deg, #ef4444 0%, #f97316 100%);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+      background-clip: text;
+    }
+    .origin-badge {
+      background: #1a1a2e;
+      color: #e94560;
+      padding: 6px 10px;
+      border-radius: 6px;
+      font-family: 'Monaco', 'Menlo', 'Courier New', monospace;
+      font-size: 13px;
+      word-break: break-all;
+    }
+    .action-text {
+      margin: 12px 0;
+      color: #475569;
+      font-size: 14px;
+      font-weight: 500;
+    }
+    .event-preview {
+      background: #f8fafc;
+      border: 1px solid #e2e8f0;
+      padding: 10px;
+      border-radius: 6px;
+      font-family: 'Monaco', 'Menlo', 'Courier New', monospace;
+      font-size: 11px;
+      max-height: 120px;
+      overflow-y: auto;
+      color: #64748b;
+      margin: 8px 0;
+      white-space: pre-wrap;
+      word-break: break-all;
+    }
+    .btn-row {
+      display: flex;
+      gap: 10px;
+      margin-top: 16px;
+    }
+    .btn-row button {
+      flex: 1;
+      padding: 12px;
+      border: none;
+      border-radius: 10px;
+      font-size: 14px;
+      font-weight: 600;
+      cursor: pointer;
+      transition: all 0.2s ease;
+    }
+    .btn-approve {
+      background: linear-gradient(135deg, #4ade80 0%, #22c55e 100%);
+      color: #052e16;
+      box-shadow: 0 4px 12px rgba(34, 197, 94, 0.25);
+    }
+    .btn-deny {
+      background: linear-gradient(135deg, #fca5a5 0%, #ef4444 100%);
+      color: #450a0a;
+      box-shadow: 0 4px 12px rgba(239, 68, 68, 0.25);
+    }
+    .btn-approve:hover {
+      transform: translateY(-1px);
+      box-shadow: 0 6px 16px rgba(34, 197, 94, 0.35);
+    }
+    .btn-deny:hover {
+      transform: translateY(-1px);
+      box-shadow: 0 6px 16px rgba(239, 68, 68, 0.35);
+    }
+    .timeout-bar {
+      margin-top: 12px;
+      height: 3px;
+      background: #e2e8f0;
+      border-radius: 2px;
+      overflow: hidden;
+    }
+    .timeout-bar-inner {
+      height: 100%;
+      background: linear-gradient(90deg, #ef4444 0%, #f97316 100%);
+      width: 100%;
+      animation: shrink 60s linear forwards;
+    }
+    @keyframes shrink {
+      from { width: 100%; }
+      to { width: 0%; }
+    }
+  </style>
+</head>
+<body>
+  <div class="approve-container">
+    <h3 class="approve-header">Signing Request</h3>
+    <div class="origin-badge" id="origin"></div>
+    <div class="action-text" id="action"></div>
+    <div class="event-preview" id="preview"></div>
+    <div class="btn-row">
+      <button class="btn-deny" id="deny">Deny</button>
+      <button class="btn-approve" id="approve">Approve</button>
+    </div>
+    <div class="timeout-bar"><div class="timeout-bar-inner"></div></div>
+  </div>
+  <script src="approve.js"></script>
+</body>
+</html>
diff --git a/popup/approve.js b/popup/approve.js
new file mode 100644
index 0000000..b17db5b
--- /dev/null
+++ b/popup/approve.js
@@ -0,0 +1,55 @@
+/**
+ * Podkey - Signing Approval Popup
+ * Presents signing requests to the user for explicit approval/denial.
+ */
+
+const params = new URLSearchParams(window.location.search);
+const requestId = params.get('id');
+const origin = params.get('origin') || 'Unknown';
+const action = params.get('action') || 'sign';
+const preview = params.get('preview') || '';
+
+// Populate UI
+document.getElementById('origin').textContent = origin;
+document.getElementById('action').textContent = `wants to: ${action}`;
+
+if (preview) {
+  try {
+    // Try to pretty-print JSON previews
+    const parsed = JSON.parse(preview);
+    document.getElementById('preview').textContent = JSON.stringify(parsed, null, 2);
+  } catch {
+    document.getElementById('preview').textContent = preview;
+  }
+} else {
+  document.getElementById('preview').style.display = 'none';
+}
+
+// Approve button
+document.getElementById('approve').addEventListener('click', () => {
+  chrome.runtime.sendMessage({
+    type: 'APPROVE_SIGNING',
+    requestId,
+    approved: true
+  });
+  window.close();
+});
+
+// Deny button
+document.getElementById('deny').addEventListener('click', () => {
+  chrome.runtime.sendMessage({
+    type: 'APPROVE_SIGNING',
+    requestId,
+    approved: false
+  });
+  window.close();
+});
+
+// Also deny on window close (user closes the popup without clicking)
+window.addEventListener('beforeunload', () => {
+  chrome.runtime.sendMessage({
+    type: 'APPROVE_SIGNING',
+    requestId,
+    approved: false
+  });
+});
diff --git a/src/background.js b/src/background.js
index 84481e2..5ba0621 100644
--- a/src/background.js
+++ b/src/background.js
@@ -36,8 +36,21 @@ chrome.runtime.onInstalled.addListener(async () => {
   }
 });
 
+// Pending signing approval promises: requestId -> resolve function
+const pendingApprovals = new Map();
+
 // Handle messages from content scripts and popup
 chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  // Handle signing approval responses from the approve popup
+  if (message.type === 'APPROVE_SIGNING') {
+    const resolve = pendingApprovals.get(message.requestId);
+    if (resolve) {
+      pendingApprovals.delete(message.requestId);
+      resolve(message.approved === true);
+    }
+    return; // synchronous, no sendResponse needed
+  }
+
   handleMessage(message, sender)
     .then(result => {
       console.log('[Podkey] Message handled successfully:', message.type, result);
@@ -110,7 +123,7 @@ async function handleGetPublicKey (origin, sender) {
 
   if (!trusted) {
     // Show permission prompt
-    const allowed = await showPermissionPrompt(origin, 'share your public key');
+    const allowed = await showPermissionPrompt(origin, 'read your public key');
 
     if (!allowed) {
       throw new Error('User denied permission');
@@ -148,12 +161,14 @@ async function handleSignEvent (event, origin, sender) {
   let shouldSign = trusted && autoSign && isSolidAuth;
 
   if (!shouldSign) {
-    // Show signing prompt
-    const eventPreview = formatEventForPrompt(event);
-    const allowed = await showPermissionPrompt(
-      origin,
-      `sign this ${isSolidAuth ? 'Solid authentication' : 'event'}:\n\n${eventPreview}`
-    );
+    // Show signing prompt with event preview
+    const actionLabel = isSolidAuth ? 'sign a Solid authentication event' : `sign an event (kind ${event.kind})`;
+    const previewData = JSON.stringify({
+      kind: event.kind,
+      content: (event.content || '').substring(0, 200),
+      tags: (event.tags || []).length
+    });
+    const allowed = await showPermissionPrompt(origin, actionLabel, previewData);
 
     if (!allowed) {
       throw new Error('User denied signing');
@@ -256,30 +271,51 @@ async function handleGetKeypairStatus () {
 }
 
 /**
- * Show permission prompt to user
- * Note: Service workers can't use confirm(), so we auto-approve for now
- * TODO: Implement proper UI using chrome.notifications or action badge
+ * Show permission prompt to user via a popup window.
+ * Opens popup/approve.html and waits for the user to approve or deny.
+ * Auto-denies after 60 seconds if no response.
+ * @param {string} origin - The requesting origin
+ * @param {string} action - Human-readable description of the action
+ * @param {string} [eventPreview] - Optional preview of the event data
+ * @returns {Promise<boolean>} True if user approved
  */
-async function showPermissionPrompt (origin, action) {
-  // For now, auto-approve requests (service workers can't use confirm())
-  // In production, this should show a notification or update the badge
-  console.log(`[Podkey] Auto-approving: ${origin} wants to ${action}`);
-
-  // TODO: Show notification using chrome.notifications API
-  // For now, return true to auto-approve
-  return true;
-
-  // Future implementation:
-  // return new Promise((resolve) => {
-  //   chrome.notifications.create({
-  //     type: 'basic',
-  //     iconUrl: 'icons/128x128.png',
-  //     title: 'Podkey Permission Request',
-  //     message: `${origin} wants to ${action}`
-  //   }, (notificationId) => {
-  //     // Handle user response via notification buttons
-  //   });
-  // });
+async function showPermissionPrompt (origin, action, eventPreview) {
+  const requestId = crypto.randomUUID();
+
+  return new Promise((resolve) => {
+    pendingApprovals.set(requestId, resolve);
+
+    // Auto-deny after 60 seconds if no response
+    const timeout = setTimeout(() => {
+      if (pendingApprovals.has(requestId)) {
+        pendingApprovals.delete(requestId);
+        console.log(`[Podkey] Signing request ${requestId} timed out, auto-denying`);
+        resolve(false);
+      }
+    }, 60000);
+
+    // Clean up timeout when resolved normally
+    const originalResolve = resolve;
+    pendingApprovals.set(requestId, (approved) => {
+      clearTimeout(timeout);
+      originalResolve(approved);
+    });
+
+    const params = new URLSearchParams({
+      id: requestId,
+      origin: origin || 'Unknown',
+      action: action || 'sign',
+      preview: eventPreview || ''
+    });
+
+    chrome.windows.create({
+      url: `popup/approve.html?${params.toString()}`,
+      type: 'popup',
+      width: 420,
+      height: 380,
+      focused: true
+    });
+  });
 }
 
 /**

From 84829ec85c8c19bf48a765e0f255e15c58ae98a2 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 19:33:56 +0000
Subject: [PATCH 07/24] feat: NIP-44 (v2) encrypt/decrypt for window.nostr

Add window.nostr.nip44.{encrypt,decrypt} to the injected NIP-07 provider so
apps that use NIP-17 / NIP-59 gift-wrapped direct messages (e.g. the DreamLab
nostr-rust-forum) can encrypt/decrypt DMs through the Podkey extension.

Implementation mirrors the existing signing/nip04 message path exactly:
page provider (nostr-provider.js) posts a podkey-request CustomEvent ->
content script (injected.js) relays via chrome.runtime.sendMessage ->
background service worker (background.js) routes NIP44_ENCRYPT/NIP44_DECRYPT/
NIP44_GET_CONVERSATION_KEY to handlers that resolve the keypair the same way
GET_PUBLIC_KEY/SIGN_EVENT do. The raw private key never leaves the background;
only the base64 payload / plaintext / conversation key crosses to the page.

NIP-44 v2 (src/nip44.js) uses the vetted @noble stack the extension already
depends on for nip04-era crypto:
  - @noble/secp256k1  : ECDH shared secret (x-coordinate)
  - @noble/hashes     : hkdf (extract/expand), hmac, sha256
  - @noble/ciphers    : chacha20 (added dependency)
conversation key = hkdf_extract(salt="nip44-v2", ikm=ECDH.x);
per-message keys = hkdf_expand(conv_key, info=nonce, 76) ->
chacha_key|chacha_nonce|hmac_key; payload = base64(0x02|nonce|ct|mac),
mac = hmac_sha256(hmac_key, nonce|ct). Padding and unpadding per spec.

Tests (test/nip44.test.js, node --test) cover symmetric conversation keys,
round-trips (unicode/long/random-nonce), background-path helpers, HMAC tamper
detection, and the official NIP-44 spec vectors (deterministic conversation
key + encrypt/decrypt). All 34 tests pass; npm run build bundles cleanly.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 CHANGELOG.md          |  12 ++
 README.md             |  14 +++
 package-lock.json     |  19 ++-
 package.json          |   3 +-
 src/background.js     |  99 +++++++++++++++
 src/nip44.js          | 273 ++++++++++++++++++++++++++++++++++++++++++
 src/nostr-provider.js |  34 ++++++
 test/nip44.test.js    | 166 +++++++++++++++++++++++++
 8 files changed, 616 insertions(+), 4 deletions(-)
 create mode 100644 src/nip44.js
 create mode 100644 test/nip44.test.js

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1f273f7..42d26f9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,18 @@ All notable changes to Podkey will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- **NIP-44 (v2) encryption** — `window.nostr.nip44.encrypt(pubkey, plaintext)`
+  and `window.nostr.nip44.decrypt(pubkey, ciphertext)`, enabling NIP-17 / NIP-59
+  gift-wrapped direct messages. Crypto runs in the background service worker
+  (the private key never reaches the page), reusing the existing message-passing
+  path. Implemented with `@noble/ciphers` (chacha20) + `@noble/hashes`
+  (hkdf/hmac/sha256) + `@noble/secp256k1` (ECDH). Verified against the official
+  NIP-44 spec test vectors.
+
 ## [0.0.7] - 2024-12-XX
 
 ### Changed
diff --git a/README.md b/README.md
index b12cc78..eb19d56 100644
--- a/README.md
+++ b/README.md
@@ -68,6 +68,7 @@
 - ✅ **Key Generation** - Secure cryptographic key generation using `@noble/secp256k1`
 - ✅ **Key Import** - Import existing 64-char hex private keys
 - ✅ **Event Signing** - Sign Nostr events with Schnorr signatures
+- ✅ **NIP-44 Encryption** - v2 `encrypt`/`decrypt` for NIP-17/NIP-59 gift-wrapped DMs (key never leaves the background)
 - ✅ **Trust Management** - Per-origin permissions with auto-approval
 - ✅ **Beautiful UI** - Soft gradients, smooth animations
 - ✅ **64-char Hex Keys** - Proper did:nostr format compatibility
@@ -261,6 +262,19 @@ const signed = await window.nostr.signEvent({
 })
 ```
 
+### `window.nostr.nip44.encrypt(pubkey, plaintext)` / `window.nostr.nip44.decrypt(pubkey, ciphertext)`
+
+NIP-44 (v2) encryption, used by NIP-17 / NIP-59 gift-wrapped direct messages.
+The private key never leaves the background service worker — encryption is
+performed there and only the resulting base64 payload (or decrypted plaintext)
+crosses to the page, mirroring the existing signing message path.
+
+```javascript
+const peer = '<64-char hex pubkey>'
+const payload = await window.nostr.nip44.encrypt(peer, 'hello')
+const plaintext = await window.nostr.nip44.decrypt(peer, payload)
+```
+
 ### `window.nostr.getRelays()`
 
 Returns relay configuration (coming soon).
diff --git a/package-lock.json b/package-lock.json
index 8fe28a2..c9ffaeb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,14 +1,15 @@
 {
   "name": "podkey",
-  "version": "0.0.2",
+  "version": "0.0.7",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "podkey",
-      "version": "0.0.2",
-      "license": "MIT",
+      "version": "0.0.7",
+      "license": "AGPL-3.0",
       "dependencies": {
+        "@noble/ciphers": "^2.2.0",
         "@noble/hashes": "^1.3.3",
         "@noble/secp256k1": "^3.0.0"
       },
@@ -563,6 +564,18 @@
       "dev": true,
       "license": "BSD-3-Clause"
     },
+    "node_modules/@noble/ciphers": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/@noble/ciphers/-/ciphers-2.2.0.tgz",
+      "integrity": "sha512-Z6pjIZ/8IJcCGzb2S/0Px5J81yij85xASuk1teLNeg75bfT07MV3a/O2Mtn1I2se43k3lkVEcFaR10N4cgQcZA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 20.19.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/@noble/hashes": {
       "version": "1.8.0",
       "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
diff --git a/package.json b/package.json
index 3e04ce5..39ffcd3 100644
--- a/package.json
+++ b/package.json
@@ -34,6 +34,7 @@
   },
   "homepage": "https://github.com/JavaScriptSolidServer/podkey#readme",
   "dependencies": {
+    "@noble/ciphers": "^2.2.0",
     "@noble/hashes": "^1.3.3",
     "@noble/secp256k1": "^3.0.0"
   },
@@ -44,4 +45,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
\ No newline at end of file
+}
diff --git a/src/background.js b/src/background.js
index 84481e2..a1f01d0 100644
--- a/src/background.js
+++ b/src/background.js
@@ -4,6 +4,12 @@
  */
 
 import { generateKeypair, signEvent, getPublicKey } from './crypto.js';
+import {
+  getConversationKey,
+  encrypt as nip44Encrypt,
+  decrypt as nip44Decrypt,
+  bytesToHex as nip44BytesToHex
+} from './nip44.js';
 import {
   storeKeypair,
   getKeypair,
@@ -83,6 +89,15 @@ async function handleMessage (message, sender) {
     case 'NIP04_DECRYPT':
       throw new Error('NIP-04 encryption not yet implemented');
 
+    case 'NIP44_ENCRYPT':
+      return await handleNip44Encrypt(message.pubkey, message.plaintext, origin);
+
+    case 'NIP44_DECRYPT':
+      return await handleNip44Decrypt(message.pubkey, message.ciphertext, origin);
+
+    case 'NIP44_GET_CONVERSATION_KEY':
+      return await handleNip44GetConversationKey(message.pubkey, origin);
+
     case 'CREATE_NIP98_AUTH_HEADER':
       return await createNip98AuthHeader(
         message.url,
@@ -181,6 +196,90 @@ async function handleSignEvent (event, origin, sender) {
   };
 }
 
+/**
+ * Resolve the user's keypair for an encryption request, gating on origin
+ * trust exactly the way GET_PUBLIC_KEY / SIGN_EVENT do. The raw private key
+ * never leaves the background service worker — only ciphertext/plaintext or a
+ * conversation key is returned to the page.
+ *
+ * @param {string} origin - requesting page origin
+ * @param {string} action - human-readable action for the permission prompt
+ * @returns {Promise<{privateKey: string, publicKey: string}>}
+ */
+async function resolveKeypairForEncryption (origin, action) {
+  const keyExists = await hasKeypair();
+  if (!keyExists) {
+    throw new Error('No keypair found. Please generate or import a key first.');
+  }
+
+  const trusted = await isTrustedOrigin(origin);
+  if (!trusted) {
+    const allowed = await showPermissionPrompt(origin, action);
+    if (!allowed) {
+      throw new Error('User denied permission');
+    }
+    await addTrustedOrigin(origin);
+  }
+
+  const keypair = await getKeypair();
+  if (!keypair || typeof keypair.privateKey !== 'string') {
+    throw new Error('Invalid keypair format');
+  }
+  return keypair;
+}
+
+/**
+ * NIP-44 (v2) encrypt: encrypt plaintext for a peer pubkey.
+ * @param {string} peerPubkey - 64-char hex peer public key
+ * @param {string} plaintext - message to encrypt
+ * @param {string} origin - requesting page origin
+ * @returns {Promise<string>} base64 NIP-44 payload
+ */
+async function handleNip44Encrypt (peerPubkey, plaintext, origin) {
+  if (typeof peerPubkey !== 'string' || typeof plaintext !== 'string') {
+    throw new Error('nip44.encrypt requires (pubkey, plaintext) strings');
+  }
+
+  const keypair = await resolveKeypairForEncryption(origin, 'encrypt a message (NIP-44)');
+  const conversationKey = getConversationKey(keypair.privateKey, peerPubkey);
+  return nip44Encrypt(plaintext, conversationKey);
+}
+
+/**
+ * NIP-44 (v2) decrypt: decrypt a base64 payload from a peer pubkey.
+ * @param {string} peerPubkey - 64-char hex peer public key
+ * @param {string} ciphertext - base64 NIP-44 payload
+ * @param {string} origin - requesting page origin
+ * @returns {Promise<string>} decrypted plaintext
+ */
+async function handleNip44Decrypt (peerPubkey, ciphertext, origin) {
+  if (typeof peerPubkey !== 'string' || typeof ciphertext !== 'string') {
+    throw new Error('nip44.decrypt requires (pubkey, ciphertext) strings');
+  }
+
+  const keypair = await resolveKeypairForEncryption(origin, 'decrypt a message (NIP-44)');
+  const conversationKey = getConversationKey(keypair.privateKey, peerPubkey);
+  return nip44Decrypt(ciphertext, conversationKey);
+}
+
+/**
+ * NIP-44 (v2) conversation key derivation (hex). Some apps call this sub-API to
+ * cache the key client-side; we still derive it in the background so the raw
+ * private key stays here.
+ * @param {string} peerPubkey - 64-char hex peer public key
+ * @param {string} origin - requesting page origin
+ * @returns {Promise<string>} 64-char hex conversation key
+ */
+async function handleNip44GetConversationKey (peerPubkey, origin) {
+  if (typeof peerPubkey !== 'string') {
+    throw new Error('nip44.getConversationKey requires a pubkey string');
+  }
+
+  const keypair = await resolveKeypairForEncryption(origin, 'derive a NIP-44 conversation key');
+  const conversationKey = getConversationKey(keypair.privateKey, peerPubkey);
+  return nip44BytesToHex(conversationKey);
+}
+
 /**
  * Generate new keypair
  */
diff --git a/src/nip44.js b/src/nip44.js
new file mode 100644
index 0000000..7bb3c15
--- /dev/null
+++ b/src/nip44.js
@@ -0,0 +1,273 @@
+/**
+ * Podkey - NIP-44 (v2) encryption / decryption
+ *
+ * Implements the current NIP-44 versioned encryption scheme (version 0x02):
+ *   conversation key = hkdf_extract(IKM = ECDH(priv, pub).x, salt = "nip44-v2")
+ *   per-message keys = hkdf_expand(conversation_key, info = nonce, L = 76)
+ *                        -> chacha_key (32) ‖ chacha_nonce (12) ‖ hmac_key (32)
+ *   ciphertext       = chacha20(chacha_key, chacha_nonce, pad(plaintext))
+ *   mac              = hmac_sha256(hmac_key, aad = nonce ‖ ciphertext)
+ *   payload          = base64( version(0x02) ‖ nonce(32) ‖ ciphertext ‖ mac(32) )
+ *
+ * Uses the same vetted @noble primitives the rest of the extension depends on:
+ *   - @noble/secp256k1     : ECDH shared secret
+ *   - @noble/hashes        : hkdf, hmac, sha256
+ *   - @noble/ciphers       : chacha20 (raw, unauthenticated, IETF nonce)
+ *
+ * Spec: https://github.com/nostr-protocol/nips/blob/master/44.md
+ */
+
+import { getSharedSecret } from '@noble/secp256k1';
+import { hkdf, extract as hkdfExtract, expand as hkdfExpand } from '@noble/hashes/hkdf';
+import { hmac } from '@noble/hashes/hmac';
+import { sha256 } from '@noble/hashes/sha256';
+import { bytesToHex, hexToBytes, concatBytes, utf8ToBytes } from '@noble/hashes/utils';
+import { chacha20 } from '@noble/ciphers/chacha.js';
+
+const VERSION = 2;
+const SALT = utf8ToBytes('nip44-v2');
+const MIN_PLAINTEXT_SIZE = 1; // 1 byte (NIP-44 forbids empty plaintext)
+const MAX_PLAINTEXT_SIZE = 65535; // 64KB - 1
+
+/**
+ * Compute the NIP-44 conversation key for a (private, public) pair.
+ * conversation_key = hkdf_extract(IKM = sharedX, salt = "nip44-v2")
+ *
+ * @param {string} privateKeyHex - 64-char hex private key (the user's)
+ * @param {string} peerPublicKeyHex - 64-char hex x-only public key (the peer's)
+ * @returns {Uint8Array} 32-byte conversation key
+ */
+export function getConversationKey (privateKeyHex, peerPublicKeyHex) {
+  validateHexKey(privateKeyHex, 'private');
+  validateHexKey(peerPublicKeyHex, 'public');
+
+  // ECDH: prefix the x-only Nostr pubkey with 0x02 to get a compressed point.
+  // getSharedSecret returns a 33-byte compressed point; bytes [1..33] are the
+  // shared X coordinate used as the HKDF input keying material.
+  const shared = getSharedSecret(hexToBytes(privateKeyHex), hexToBytes('02' + peerPublicKeyHex));
+  const sharedX = shared.subarray(1, 33);
+
+  return hkdfExtract(sha256, sharedX, SALT);
+}
+
+/**
+ * Derive the per-message keys from the conversation key and nonce.
+ * @param {Uint8Array} conversationKey - 32-byte conversation key
+ * @param {Uint8Array} nonce - 32-byte random nonce
+ * @returns {{ chachaKey: Uint8Array, chachaNonce: Uint8Array, hmacKey: Uint8Array }}
+ */
+function getMessageKeys (conversationKey, nonce) {
+  if (conversationKey.length !== 32) {
+    throw new Error('Invalid conversation key length');
+  }
+  if (nonce.length !== 32) {
+    throw new Error('Invalid nonce length');
+  }
+
+  const keys = hkdfExpand(sha256, conversationKey, nonce, 76);
+  return {
+    chachaKey: keys.subarray(0, 32),
+    chachaNonce: keys.subarray(32, 44),
+    hmacKey: keys.subarray(44, 76)
+  };
+}
+
+/**
+ * Calculate the padded length for a given plaintext length (power-of-two
+ * bucketing, minimum 32 bytes) per the NIP-44 padding scheme.
+ * @param {number} len - unpadded plaintext length in bytes
+ * @returns {number} padded length
+ */
+function calcPaddedLen (len) {
+  if (!Number.isInteger(len) || len < 1) {
+    throw new Error('Expected positive integer length');
+  }
+  if (len <= 32) return 32;
+  const nextPower = 1 << (Math.floor(Math.log2(len - 1)) + 1);
+  const chunk = nextPower <= 256 ? 32 : nextPower / 8;
+  return chunk * (Math.floor((len - 1) / chunk) + 1);
+}
+
+/**
+ * Pad plaintext: u16 big-endian length prefix ‖ utf8(plaintext) ‖ zero padding.
+ * @param {string} plaintext
+ * @returns {Uint8Array}
+ */
+function pad (plaintext) {
+  const unpadded = utf8ToBytes(plaintext);
+  const unpaddedLen = unpadded.length;
+  if (unpaddedLen < MIN_PLAINTEXT_SIZE || unpaddedLen > MAX_PLAINTEXT_SIZE) {
+    throw new Error('Invalid plaintext length');
+  }
+
+  const prefix = new Uint8Array(2);
+  new DataView(prefix.buffer).setUint16(0, unpaddedLen, false); // big-endian
+
+  const padded = new Uint8Array(calcPaddedLen(unpaddedLen));
+  padded.set(unpadded);
+
+  return concatBytes(prefix, padded);
+}
+
+/**
+ * Unpad a decrypted buffer back to the original plaintext string.
+ * @param {Uint8Array} padded - prefix ‖ plaintext ‖ zero padding
+ * @returns {string}
+ */
+function unpad (padded) {
+  const unpaddedLen = new DataView(padded.buffer, padded.byteOffset, 2).getUint16(0, false);
+  const unpadded = padded.subarray(2, 2 + unpaddedLen);
+
+  if (
+    unpaddedLen < MIN_PLAINTEXT_SIZE ||
+    unpaddedLen > MAX_PLAINTEXT_SIZE ||
+    unpadded.length !== unpaddedLen ||
+    padded.length !== 2 + calcPaddedLen(unpaddedLen)
+  ) {
+    throw new Error('Invalid padding');
+  }
+
+  return new TextDecoder().decode(unpadded);
+}
+
+/**
+ * HMAC-SHA256 with the nonce as associated data, per NIP-44:
+ *   mac = hmac_sha256(key, aad ‖ message) where aad = nonce
+ * @param {Uint8Array} key - 32-byte hmac key
+ * @param {Uint8Array} ciphertext
+ * @param {Uint8Array} aad - 32-byte nonce
+ * @returns {Uint8Array} 32-byte mac
+ */
+function hmacAad (key, ciphertext, aad) {
+  if (aad.length !== 32) {
+    throw new Error('AAD (nonce) must be 32 bytes');
+  }
+  return hmac(sha256, key, concatBytes(aad, ciphertext));
+}
+
+/**
+ * Constant-time comparison of two byte arrays.
+ * @param {Uint8Array} a
+ * @param {Uint8Array} b
+ * @returns {boolean}
+ */
+function equalBytes (a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+
+/**
+ * Encrypt plaintext with NIP-44 v2.
+ * @param {string} plaintext - message to encrypt
+ * @param {Uint8Array} conversationKey - 32-byte conversation key
+ * @param {Uint8Array} [nonce] - optional 32-byte nonce (random if omitted)
+ * @returns {string} base64 NIP-44 payload
+ */
+export function encrypt (plaintext, conversationKey, nonce = randomBytes(32)) {
+  const { chachaKey, chachaNonce, hmacKey } = getMessageKeys(conversationKey, nonce);
+  const padded = pad(plaintext);
+  const ciphertext = chacha20(chachaKey, chachaNonce, padded);
+  const mac = hmacAad(hmacKey, ciphertext, nonce);
+
+  const payload = concatBytes(new Uint8Array([VERSION]), nonce, ciphertext, mac);
+  return base64Encode(payload);
+}
+
+/**
+ * Decrypt a NIP-44 v2 base64 payload.
+ * @param {string} payload - base64 NIP-44 payload
+ * @param {Uint8Array} conversationKey - 32-byte conversation key
+ * @returns {string} decrypted plaintext
+ */
+export function decrypt (payload, conversationKey) {
+  if (typeof payload !== 'string' || payload.length === 0) {
+    throw new Error('Invalid payload');
+  }
+  // Reject NIP-44 "encoded as #..." marker payloads explicitly.
+  if (payload[0] === '#') {
+    throw new Error('Unsupported encryption version');
+  }
+
+  const data = base64Decode(payload);
+  const version = data[0];
+  if (version !== VERSION) {
+    throw new Error(`Unknown encryption version: ${version}`);
+  }
+
+  // version(1) ‖ nonce(32) ‖ ciphertext(>=32) ‖ mac(32)
+  if (data.length < 1 + 32 + 32 + 32) {
+    throw new Error('Invalid payload length');
+  }
+
+  const nonce = data.subarray(1, 33);
+  const ciphertext = data.subarray(33, data.length - 32);
+  const mac = data.subarray(data.length - 32);
+
+  const { chachaKey, chachaNonce, hmacKey } = getMessageKeys(conversationKey, nonce);
+  const calculatedMac = hmacAad(hmacKey, ciphertext, nonce);
+  if (!equalBytes(calculatedMac, mac)) {
+    throw new Error('Invalid MAC');
+  }
+
+  const padded = chacha20(chachaKey, chachaNonce, ciphertext);
+  return unpad(padded);
+}
+
+/**
+ * Encrypt using raw key material (convenience for the background handler):
+ * derives the conversation key from (privateKeyHex, peerPublicKeyHex) first.
+ * @param {string} privateKeyHex
+ * @param {string} peerPublicKeyHex
+ * @param {string} plaintext
+ * @returns {string} base64 NIP-44 payload
+ */
+export function encryptWithKeys (privateKeyHex, peerPublicKeyHex, plaintext) {
+  const conversationKey = getConversationKey(privateKeyHex, peerPublicKeyHex);
+  return encrypt(plaintext, conversationKey);
+}
+
+/**
+ * Decrypt using raw key material (convenience for the background handler).
+ * @param {string} privateKeyHex
+ * @param {string} peerPublicKeyHex
+ * @param {string} payload - base64 NIP-44 payload
+ * @returns {string} decrypted plaintext
+ */
+export function decryptWithKeys (privateKeyHex, peerPublicKeyHex, payload) {
+  const conversationKey = getConversationKey(privateKeyHex, peerPublicKeyHex);
+  return decrypt(payload, conversationKey);
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function randomBytes (n) {
+  const bytes = new Uint8Array(n);
+  crypto.getRandomValues(bytes);
+  return bytes;
+}
+
+function validateHexKey (key, kind) {
+  if (typeof key !== 'string' || !/^[0-9a-fA-F]{64}$/.test(key)) {
+    throw new Error(`Invalid ${kind} key: must be 64-char hex`);
+  }
+}
+
+function base64Encode (bytes) {
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  return btoa(binary);
+}
+
+function base64Decode (str) {
+  const binary = atob(str);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+// Re-export hashing helpers used by callers/tests for convenience.
+export { bytesToHex, hexToBytes, hkdf };
diff --git a/src/nostr-provider.js b/src/nostr-provider.js
index 98125c4..7a7f593 100644
--- a/src/nostr-provider.js
+++ b/src/nostr-provider.js
@@ -87,6 +87,40 @@
           ciphertext
         });
       }
+    },
+
+    /**
+     * Encrypt / decrypt (NIP-44 v2)
+     * Used by NIP-17 / NIP-59 (gift-wrapped) direct messages. The private key
+     * never leaves the background service worker — encryption is performed
+     * there and only the resulting payload/plaintext crosses to the page.
+     */
+    nip44: {
+      /**
+       * @param {string} pubkey - 64-char hex peer public key
+       * @param {string} plaintext - message to encrypt
+       * @returns {Promise<string>} base64 NIP-44 v2 payload
+       */
+      encrypt: async (pubkey, plaintext) => {
+        return sendMessageToExtension({
+          type: 'NIP44_ENCRYPT',
+          pubkey,
+          plaintext
+        });
+      },
+
+      /**
+       * @param {string} pubkey - 64-char hex peer public key
+       * @param {string} ciphertext - base64 NIP-44 v2 payload
+       * @returns {Promise<string>} decrypted plaintext
+       */
+      decrypt: async (pubkey, ciphertext) => {
+        return sendMessageToExtension({
+          type: 'NIP44_DECRYPT',
+          pubkey,
+          ciphertext
+        });
+      }
     }
   };
 
diff --git a/test/nip44.test.js b/test/nip44.test.js
new file mode 100644
index 0000000..fdb3ba0
--- /dev/null
+++ b/test/nip44.test.js
@@ -0,0 +1,166 @@
+/**
+ * Tests for Podkey NIP-44 (v2) encryption.
+ *
+ * Mirrors the structure of crypto.test.js and adds official NIP-44 spec
+ * test vectors to prove the implementation matches the standard.
+ * Vectors: https://github.com/paulmillr/nip44/blob/main/nip44.vectors.json
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import {
+  getConversationKey,
+  encrypt,
+  decrypt,
+  encryptWithKeys,
+  decryptWithKeys,
+  bytesToHex,
+  hexToBytes
+} from '../src/nip44.js';
+import { generateKeypair, getPublicKey } from '../src/crypto.js';
+
+describe('NIP-44 (v2)', () => {
+  describe('getConversationKey', () => {
+    it('is symmetric: convKey(a, B) === convKey(b, A)', async () => {
+      const alice = await generateKeypair();
+      const bob = await generateKeypair();
+
+      const fromAlice = getConversationKey(alice.privateKey, bob.publicKey);
+      const fromBob = getConversationKey(bob.privateKey, alice.publicKey);
+
+      assert.strictEqual(bytesToHex(fromAlice), bytesToHex(fromBob),
+        'Conversation key must be identical from both sides');
+      assert.strictEqual(fromAlice.length, 32, 'Conversation key must be 32 bytes');
+    });
+
+    it('matches the official NIP-44 spec test vector', () => {
+      // From nip44.vectors.json -> v2.valid.get_conversation_key[0]
+      const sec1 = '315e59ff51cb9209768cf7da80791ddcaae56ac9775eb25b6dee1234bc5d2268';
+      const pub2 = 'c2f9d9948dc8c7c38321e4b85c8558872eafa0641cd269db76848a6073e69133';
+      const expected = '3dfef0ce2a4d80a25e7a328accf73448ef67096f65f79588e358d9a0eb9013f1';
+
+      const convKey = getConversationKey(sec1, pub2);
+      assert.strictEqual(bytesToHex(convKey), expected,
+        'Conversation key must match the NIP-44 spec vector');
+    });
+
+    it('rejects malformed keys', () => {
+      assert.throws(() => getConversationKey('zz', 'a'.repeat(64)), /Invalid private key/);
+      assert.throws(() => getConversationKey('a'.repeat(64), 'short'), /Invalid public key/);
+    });
+  });
+
+  describe('official NIP-44 spec encrypt/decrypt vector', () => {
+    // From nip44.vectors.json -> v2.valid.encrypt_decrypt[0]
+    const conversationKey = hexToBytes('c41c775356fd92eadc63ff5a0dc1da211b268cbea22316767095b2871ea1412d');
+    const nonce = hexToBytes('0000000000000000000000000000000000000000000000000000000000000001');
+    const plaintext = 'a';
+    const payload = 'AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABee0G5VSK0/9YypIObAtDKfYEAjD35uVkHyB0F4DwrcNaCXlCWZKaArsGrY6M9wnuTMxWfp1RTN9Xga8no+kF5Vsb';
+
+    it('encrypt with the spec nonce produces the spec payload', () => {
+      assert.strictEqual(encrypt(plaintext, conversationKey, nonce), payload);
+    });
+
+    it('decrypt of the spec payload yields the spec plaintext', () => {
+      assert.strictEqual(decrypt(payload, conversationKey), plaintext);
+    });
+  });
+
+  describe('encrypt/decrypt round-trip', () => {
+    it('round-trips a simple message', async () => {
+      const alice = await generateKeypair();
+      const bob = await generateKeypair();
+      const plaintext = 'Hello from the DreamLab forum 👋';
+
+      const convKeyAlice = getConversationKey(alice.privateKey, bob.publicKey);
+      const convKeyBob = getConversationKey(bob.privateKey, alice.publicKey);
+
+      const payload = encrypt(plaintext, convKeyAlice);
+      assert.match(payload, /^[A-Za-z0-9+/]+=*$/, 'Payload should be base64');
+
+      const decrypted = decrypt(payload, convKeyBob);
+      assert.strictEqual(decrypted, plaintext, 'Decrypted text must match original');
+    });
+
+    it('produces a v2 payload (first byte 0x02)', async () => {
+      const alice = await generateKeypair();
+      const bob = await generateKeypair();
+      const convKey = getConversationKey(alice.privateKey, bob.publicKey);
+
+      const payload = encrypt('version check', convKey);
+      const raw = Uint8Array.from(atob(payload), c => c.charCodeAt(0));
+      assert.strictEqual(raw[0], 2, 'First byte of the payload must be version 0x02');
+    });
+
+    it('produces different payloads for the same plaintext (random nonce)', async () => {
+      const alice = await generateKeypair();
+      const bob = await generateKeypair();
+      const convKey = getConversationKey(alice.privateKey, bob.publicKey);
+
+      const a = encrypt('same message', convKey);
+      const b = encrypt('same message', convKey);
+      assert.notStrictEqual(a, b, 'Nonce randomization must yield distinct payloads');
+      assert.strictEqual(decrypt(a, convKey), decrypt(b, convKey));
+    });
+
+    it('round-trips unicode and emoji', async () => {
+      const alice = await generateKeypair();
+      const bob = await generateKeypair();
+      const convKey = getConversationKey(alice.privateKey, bob.publicKey);
+      const plaintext = 'ünîcödé 测试 🔐 — NIP-44';
+
+      assert.strictEqual(decrypt(encrypt(plaintext, convKey), convKey), plaintext);
+    });
+
+    it('round-trips a long message (padding buckets)', async () => {
+      const alice = await generateKeypair();
+      const bob = await generateKeypair();
+      const convKey = getConversationKey(alice.privateKey, bob.publicKey);
+      const plaintext = 'x'.repeat(5000);
+
+      assert.strictEqual(decrypt(encrypt(plaintext, convKey), convKey), plaintext);
+    });
+  });
+
+  describe('encryptWithKeys/decryptWithKeys (background path helpers)', () => {
+    it('round-trips using raw key material', async () => {
+      const alice = await generateKeypair();
+      const bob = await generateKeypair();
+      const plaintext = 'gift-wrapped DM payload';
+
+      const payload = encryptWithKeys(alice.privateKey, bob.publicKey, plaintext);
+      const decrypted = decryptWithKeys(bob.privateKey, alice.publicKey, payload);
+
+      assert.strictEqual(decrypted, plaintext);
+    });
+
+    it('derived pubkeys match generated pubkeys', async () => {
+      const alice = await generateKeypair();
+      assert.strictEqual(getPublicKey(alice.privateKey), alice.publicKey);
+    });
+  });
+
+  describe('tamper detection (HMAC)', () => {
+    it('rejects a payload with a flipped ciphertext byte', async () => {
+      const alice = await generateKeypair();
+      const bob = await generateKeypair();
+      const convKey = getConversationKey(alice.privateKey, bob.publicKey);
+
+      const payload = encrypt('authentic message', convKey);
+      const raw = Uint8Array.from(atob(payload), c => c.charCodeAt(0));
+      raw[40] ^= 0xff; // flip a byte inside the ciphertext region
+      let binary = '';
+      for (const b of raw) binary += String.fromCharCode(b);
+      const tampered = btoa(binary);
+
+      assert.throws(() => decrypt(tampered, convKey), /Invalid MAC/);
+    });
+
+    it('rejects an unknown version byte', () => {
+      const convKey = hexToBytes('00'.repeat(32));
+      // version 0x01 (NIP-04-style marker is unsupported by NIP-44 v2)
+      const bogus = btoa(String.fromCharCode(1) + 'x'.repeat(96));
+      assert.throws(() => decrypt(bogus, convKey), /Unknown encryption version/);
+    });
+  });
+});

From 11c018cbe2533e6eee1b914c18e239aec16ddfd7 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 19:50:56 +0000
Subject: [PATCH 08/24] test: update storage mock for session/local split

The encrypted-key-storage change (#12) moved the private key to
chrome.storage.session; the test mock only stubbed chrome.storage.local,
so storeKeypair/getKeypair/hasKeypair/deleteKeypair threw on the missing
session area. Back each area with its own store, matching production.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 test/storage.test.js | 35 +++++++++++++++++++++++------------
 1 file changed, 23 insertions(+), 12 deletions(-)

diff --git a/test/storage.test.js b/test/storage.test.js
index 5483eff..b40dc28 100644
--- a/test/storage.test.js
+++ b/test/storage.test.js
@@ -6,37 +6,45 @@
 import { describe, it, before, after } from 'node:test';
 import assert from 'node:assert';
 
-// Mock chrome.storage for testing
-const mockStorage = {
-  data: {},
-  local: {
+// Mock chrome.storage for testing. The extension uses two areas: session
+// (in-memory private key) and local (persisted public key + settings), so the
+// mock backs each area with its own store.
+function makeArea (store) {
+  return {
     get: async (keys) => {
       const result = {};
       if (Array.isArray(keys)) {
         keys.forEach(key => {
-          result[key] = mockStorage.data[key];
+          result[key] = store[key];
         });
       } else if (keys) {
         Object.keys(keys).forEach(key => {
-          result[key] = mockStorage.data[key] || keys[key];
+          result[key] = store[key] || keys[key];
         });
       } else {
-        return { ...mockStorage.data };
+        return { ...store };
       }
       return result;
     },
     set: async (items) => {
-      Object.assign(mockStorage.data, items);
+      Object.assign(store, items);
     },
     remove: async (keys) => {
       if (Array.isArray(keys)) {
-        keys.forEach(key => delete mockStorage.data[key]);
+        keys.forEach(key => delete store[key]);
       } else {
-        delete mockStorage.data[keys];
+        delete store[keys];
       }
     }
-  }
+  };
+}
+
+const mockStorage = {
+  localData: {},
+  sessionData: {}
 };
+mockStorage.local = makeArea(mockStorage.localData);
+mockStorage.session = makeArea(mockStorage.sessionData);
 
 // Set up global chrome mock
 global.chrome = { storage: mockStorage };
@@ -56,7 +64,10 @@ const {
 describe('Storage Functions', () => {
   // Clear storage before each test
   const clearStorage = () => {
-    mockStorage.data = {};
+    mockStorage.localData = {};
+    mockStorage.sessionData = {};
+    mockStorage.local = makeArea(mockStorage.localData);
+    mockStorage.session = makeArea(mockStorage.sessionData);
   };
 
   describe('storeKeypair / getKeypair', () => {

From adf19127fad85c543a9aa44fe6ada22a515f07ed Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 19:57:51 +0000
Subject: [PATCH 09/24] fix(crypto): self-verify schnorr signature in signEvent
 before returning

A key-holder must never emit a signature it has not verified. signEvent now
checks schnorr.verify(sig, eventId, pubkey) and throws on mismatch, catching a
faulty signing path (bad RNG, library regression) before the bad signature
leaves the service worker. This also exercises the previously unused verify
primitive on the hot signing path.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 src/crypto.js | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/crypto.js b/src/crypto.js
index 181f4ce..297fe24 100644
--- a/src/crypto.js
+++ b/src/crypto.js
@@ -80,6 +80,13 @@ export async function signEvent (event, privateKeyHex) {
     throw new Error('Invalid signature length');
   }
 
+  // Self-verify before returning: a signature that does not verify against
+  // the event id and pubkey indicates a faulty signing path (bad RNG, library
+  // regression) and must never be emitted from a key-holder.
+  if (!schnorr.verify(signatureBytes, eventIdBytes, hexToBytes(pubkey))) {
+    throw new Error('Signature self-verification failed');
+  }
+
   // Ensure all fields are strings (Nostr spec requires this)
   return {
     ...event,

From 19b545ded6b5ba843a048434890ef878e7e7455d Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 19:58:17 +0000
Subject: [PATCH 10/24] fix(provider): stop advertising unimplemented nip04 and
 getRelays

window.nostr.nip04 delegated to a background handler that throws "not
implemented", and getRelays returned {}. Feature-detection
(window.nostr.nip04 / .getRelays) was therefore lying to callers. NIP-04 is a
distinct, deprecated scheme we do not implement (Podkey ships NIP-44 v2 only),
and Podkey holds no relay list, so the honest signal is the absence of both
methods. The dead background cases are removed alongside the NIP-98 work.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 src/nostr-provider.js | 35 ++++-------------------------------
 1 file changed, 4 insertions(+), 31 deletions(-)

diff --git a/src/nostr-provider.js b/src/nostr-provider.js
index 7a7f593..6cab005 100644
--- a/src/nostr-provider.js
+++ b/src/nostr-provider.js
@@ -57,37 +57,10 @@
       });
     },
 
-    /**
-     * Get relays (optional NIP-07 extension)
-     * @returns {Promise<object>} Relay configuration
-     */
-    async getRelays () {
-      return sendMessageToExtension({ type: 'GET_RELAYS' });
-    },
-
-    /**
-     * Encrypt (NIP-04)
-     * @param {string} pubkey - Recipient public key
-     * @param {string} plaintext - Message to encrypt
-     * @returns {Promise<string>} Encrypted message
-     */
-    nip04: {
-      encrypt: async (pubkey, plaintext) => {
-        return sendMessageToExtension({
-          type: 'NIP04_ENCRYPT',
-          pubkey,
-          plaintext
-        });
-      },
-
-      decrypt: async (pubkey, ciphertext) => {
-        return sendMessageToExtension({
-          type: 'NIP04_DECRYPT',
-          pubkey,
-          ciphertext
-        });
-      }
-    },
+    // NIP-04 is intentionally not provided: it is a deprecated, unauthenticated
+    // scheme and Podkey only ships NIP-44 (v2). Advertising window.nostr.nip04
+    // would make feature-detection lie. NIP-07 getRelays is also omitted because
+    // Podkey holds no relay list — a missing method is the honest signal.
 
     /**
      * Encrypt / decrypt (NIP-44 v2)

From ae8a1f337839f9143041e313d7155d88a3dfdb54 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 19:58:48 +0000
Subject: [PATCH 11/24] fix(nip98): fresh-token nonce, page-side body hash,
 redirect-aware retry; drop dead code; gate secret logs

NIP-98 hardening:
- Add a random 'nonce' tag to every kind-27235 event. created_at has 1s
  resolution, so two identical requests in the same second previously produced
  a byte-identical event id (a replayable token even after the cache removal).
- Compute the 'payload' body hash in the page context (nip98-interceptor.js),
  where FormData / URLSearchParams / Blob / typed-array bodies are still intact,
  and send only the hex digest. The raw body no longer crosses the message
  channel (it could not be structured-cloned faithfully), which also fixes the
  missing payload hash for URLSearchParams/binary bodies. background.js consumes
  the precomputed hash, falling back to hashing string/ArrayBuffer/Blob locally.
- On the 401 retry, re-sign against response.url when the original request was
  redirected, so the 'u' tag matches the endpoint that issued the challenge.

Dead code:
- Remove unused retryState map and formatEventForPrompt (the approval popup
  inlines its own preview).
- Remove the NIP04_ENCRYPT/DECRYPT and GET_RELAYS message cases now that the
  provider no longer advertises them.

Secret-log hygiene:
- Introduce a DEBUG flag (default off) in background.js, popup.js and
  nip98-interceptor.js and gate every console statement that prints a public
  key, DID, signed event, Authorization header, or message result behind it.
  Error logs and benign lifecycle logs are kept.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 popup/popup.js           |  10 +++-
 src/background.js        | 124 +++++++++++++--------------------------
 src/injected.js          |   9 ++-
 src/nip98-interceptor.js |  71 +++++++++++++++-------
 4 files changed, 104 insertions(+), 110 deletions(-)

diff --git a/popup/popup.js b/popup/popup.js
index cae5a79..10d6d90 100644
--- a/popup/popup.js
+++ b/popup/popup.js
@@ -2,6 +2,10 @@
  * Podkey - Popup UI Logic
  */
 
+// Set DEBUG=true to log identity material (public key / DID) for local
+// debugging. Off by default so the popup never prints the user's pubkey.
+const DEBUG = false;
+
 // UI State
 let currentScreen = 'setup';
 
@@ -20,7 +24,7 @@ async function checkKeypairStatus() {
   console.log('[Podkey Popup] Checking keypair status...');
   try {
     const response = await chrome.runtime.sendMessage({ type: 'GET_KEYPAIR_STATUS' });
-    console.log('[Podkey Popup] Keypair status response:', response);
+    if (DEBUG) console.log('[Podkey Popup] Keypair status response:', response);
 
     if (response.exists) {
       console.log('[Podkey Popup] Keypair exists, showing main screen');
@@ -116,7 +120,7 @@ async function handleGenerate() {
 
     const response = await chrome.runtime.sendMessage({ type: 'GENERATE_KEYPAIR' });
 
-    console.log('[Podkey] Keypair generated:', response.publicKey);
+    if (DEBUG) console.log('[Podkey] Keypair generated:', response.publicKey);
 
     // Show main screen
     await showMainScreen({
@@ -152,7 +156,7 @@ async function handleImport() {
       privateKey
     });
 
-    console.log('[Podkey] Keypair imported:', response.publicKey);
+    if (DEBUG) console.log('[Podkey] Keypair imported:', response.publicKey);
 
     // Clear input
     document.getElementById('privateKeyInput').value = '';
diff --git a/src/background.js b/src/background.js
index 86f0a85..1060353 100644
--- a/src/background.js
+++ b/src/background.js
@@ -21,12 +21,11 @@ import {
 import { sha256 } from '@noble/hashes/sha256';
 import { bytesToHex } from '@noble/hashes/utils';
 
-console.log('[Podkey] Background service worker started');
+// Set DEBUG=true to emit verbose diagnostics. Off by default so the extension
+// never logs public keys, DIDs, NIP-98 events, or Authorization headers.
+const DEBUG = false;
 
-// NIP-98 events are always created fresh to avoid replay issues
-
-// Track retry state to prevent infinite loops: key = requestId, value = true
-const retryState = new Map();
+if (DEBUG) console.log('[Podkey] Background service worker started');
 
 // Initialize extension
 chrome.runtime.onInstalled.addListener(async () => {
@@ -57,7 +56,9 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
 
   handleMessage(message, sender)
     .then(result => {
-      console.log('[Podkey] Message handled successfully:', message.type, result);
+      // Never log `result`: it may be a public key, signed event, or
+      // Authorization header (token). Log only the message type under DEBUG.
+      if (DEBUG) console.log('[Podkey] Message handled:', message.type);
       sendResponse(result);
     })
     .catch(error => {
@@ -74,7 +75,7 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
 async function handleMessage (message, sender) {
   const { type, origin } = message;
 
-  console.log('[Podkey] Message received:', type, 'from', origin || 'popup');
+  if (DEBUG) console.log('[Podkey] Message received:', type, 'from', origin || 'popup');
 
   switch (type) {
     case 'GET_PUBLIC_KEY':
@@ -92,14 +93,6 @@ async function handleMessage (message, sender) {
     case 'GET_KEYPAIR_STATUS':
       return await handleGetKeypairStatus();
 
-    case 'GET_RELAYS':
-      // TODO: Implement relay management
-      return {};
-
-    case 'NIP04_ENCRYPT':
-    case 'NIP04_DECRYPT':
-      throw new Error('NIP-04 encryption not yet implemented');
-
     case 'NIP44_ENCRYPT':
       return await handleNip44Encrypt(message.pubkey, message.plaintext, origin);
 
@@ -113,7 +106,8 @@ async function handleMessage (message, sender) {
       return await createNip98AuthHeader(
         message.url,
         message.method,
-        message.body
+        message.body,
+        message.bodyHash
       );
 
     default:
@@ -196,7 +190,7 @@ async function handleSignEvent (event, origin, sender) {
   // Sign the event
   const signedEvent = await signEvent(event, keypair.privateKey);
 
-  console.log('[Podkey] Event signed:', signedEvent.id.substring(0, 16) + '...');
+  if (DEBUG) console.log('[Podkey] Event signed:', signedEvent.id.substring(0, 16) + '...');
 
   // Ensure event structure is correct (tags should be array, content should be string)
   // Preserve original event structure but ensure required fields are correct types
@@ -298,23 +292,14 @@ async function handleNip44GetConversationKey (peerPubkey, origin) {
  */
 async function handleGenerateKeypair () {
   try {
-    console.log('[Podkey] Starting keypair generation...');
     const keypair = await generateKeypair();
-    console.log('[Podkey] Keypair generated:', {
-      privateKeyLength: keypair.privateKey.length,
-      publicKeyLength: keypair.publicKey.length
-    });
-
     await storeKeypair(keypair.privateKey, keypair.publicKey);
-    console.log('[Podkey] Keypair stored');
+    if (DEBUG) console.log('[Podkey] Keypair generated and stored');
 
-    const result = {
+    return {
       publicKey: keypair.publicKey,
       did: `did:nostr:${keypair.publicKey}`
     };
-
-    console.log('[Podkey] Returning result:', result);
-    return result;
   } catch (error) {
     console.error('[Podkey] Error generating keypair:', error);
     throw error;
@@ -340,7 +325,7 @@ async function handleImportKeypair (privateKey) {
   // Store keypair
   await storeKeypair(privateKey, publicKey);
 
-  console.log('[Podkey] Keypair imported');
+  if (DEBUG) console.log('[Podkey] Keypair imported');
 
   return {
     publicKey,
@@ -415,29 +400,6 @@ async function showPermissionPrompt (origin, action, eventPreview) {
   });
 }
 
-/**
- * Format event for display in prompt
- */
-function formatEventForPrompt (event) {
-  const lines = [];
-  lines.push(`Kind: ${event.kind}`);
-
-  if (event.tags && event.tags.length > 0) {
-    lines.push(`Tags: ${event.tags.length}`);
-    event.tags.slice(0, 3).forEach(tag => {
-      lines.push(`  [${tag.join(', ')}]`);
-    });
-  }
-
-  if (event.content) {
-    const preview = event.content.substring(0, 100);
-    lines.push(`Content: ${preview}${event.content.length > 100 ? '...' : ''}`);
-  }
-
-  return lines.join('\n');
-}
-
-
 /**
  * Encode signed event to Authorization header value
  * @param {object} signedEvent - Signed Nostr event
@@ -482,7 +444,7 @@ function isLikelySolidServer (origin) {
   );
 }
 
-async function createNip98AuthHeader (url, method, body = null) {
+async function createNip98AuthHeader (url, method, body = null, bodyHash = null) {
   try {
     // Check if we should add auth
     const origin = new URL(url).origin;
@@ -491,73 +453,69 @@ async function createNip98AuthHeader (url, method, body = null) {
     const keyExists = await hasKeypair();
     const isSolid = isLikelySolidServer(origin);
 
-    console.log('[Podkey] NIP-98 auth check:', {
-      url,
-      origin,
-      keyExists,
-      trusted,
-      autoSign,
-      isSolid
-    });
+    if (DEBUG) console.log('[Podkey] NIP-98 auth check:', { url, origin, keyExists, trusted, autoSign, isSolid });
 
     if (!keyExists) {
-      console.log('[Podkey] No keypair found, skipping NIP-98 auth');
+      if (DEBUG) console.log('[Podkey] No keypair found, skipping NIP-98 auth');
       return null;
     }
 
     // For Solid servers, auto-trust on first use if auto-sign is enabled
     if (!trusted && isSolid && autoSign) {
-      console.log('[Podkey] Auto-trusting Solid server:', origin);
+      if (DEBUG) console.log('[Podkey] Auto-trusting Solid server:', origin);
       await addTrustedOrigin(origin);
     } else if (!trusted) {
-      console.log('[Podkey] Origin not trusted, skipping NIP-98 auth');
+      if (DEBUG) console.log('[Podkey] Origin not trusted, skipping NIP-98 auth');
       return null;
     }
 
     if (!autoSign) {
-      console.log('[Podkey] Auto-sign disabled, skipping NIP-98 auth');
+      if (DEBUG) console.log('[Podkey] Auto-sign disabled, skipping NIP-98 auth');
       return null;
     }
 
-    // Hash body if present
-    let bodyHash = '';
-    if (body) {
+    // Prefer a body hash computed in the page context (the only place where
+    // FormData / URLSearchParams / streamed bodies survive intact). Fall back
+    // to hashing here for body types that cross the message channel losslessly.
+    let resolvedBodyHash = typeof bodyHash === 'string' ? bodyHash : '';
+    if (!resolvedBodyHash && body) {
       if (typeof body === 'string') {
-        bodyHash = bytesToHex(sha256(new TextEncoder().encode(body)));
+        resolvedBodyHash = bytesToHex(sha256(new TextEncoder().encode(body)));
       } else if (body instanceof ArrayBuffer) {
-        bodyHash = bytesToHex(sha256(new Uint8Array(body)));
+        resolvedBodyHash = bytesToHex(sha256(new Uint8Array(body)));
       } else if (body instanceof Blob) {
-        const arrayBuffer = await body.arrayBuffer();
-        bodyHash = bytesToHex(sha256(new Uint8Array(arrayBuffer)));
+        resolvedBodyHash = bytesToHex(sha256(new Uint8Array(await body.arrayBuffer())));
       }
     }
 
     // Always create a fresh signed event (no caching -- reusing signed events
-    // causes replay issues and servers with replay protection reject duplicates)
+    // causes replay issues and servers with replay protection reject them).
+    // created_at has 1-second resolution, so a random nonce tag guarantees a
+    // distinct event id for repeated identical requests within the same second.
     const event = {
       kind: 27235,
       content: '',
       created_at: Math.floor(Date.now() / 1000),
       tags: [
         ['u', url],
-        ['method', method]
+        ['method', method],
+        ['nonce', bytesToHex(crypto.getRandomValues(new Uint8Array(16)))]
       ]
     };
 
-    if (bodyHash) {
-      event.tags.push(['payload', bodyHash]);
+    if (resolvedBodyHash) {
+      event.tags.push(['payload', resolvedBodyHash]);
     }
 
     const keypair = await getKeypair();
     const signedEvent = await signEvent(event, keypair.privateKey);
 
-    console.log('[Podkey] Created and signed NIP-98 auth event for', url);
-    console.log('[Podkey] NIP-98 event:', JSON.stringify(signedEvent, null, 2));
-    console.log('[Podkey] Public key (did:nostr):', `did:nostr:${keypair.publicKey}`);
+    if (DEBUG) {
+      console.log('[Podkey] NIP-98 event:', JSON.stringify(signedEvent));
+      console.log('[Podkey] Public key (did:nostr):', `did:nostr:${keypair.publicKey}`);
+    }
 
-    const authHeader = `Nostr ${encodeNip98Header(signedEvent)}`;
-    console.log('[Podkey] Authorization header (first 100 chars):', authHeader.substring(0, 100) + '...');
-    return authHeader;
+    return `Nostr ${encodeNip98Header(signedEvent)}`;
   } catch (error) {
     console.error('[Podkey] Error creating NIP-98 auth header:', error);
     return null;
@@ -569,4 +527,4 @@ async function createNip98AuthHeader (url, method, body = null) {
 // Instead, we use JavaScript-level interception via content scripts.
 // See src/injected.js for fetch/XMLHttpRequest interception.
 
-console.log('[Podkey] NIP-98 auto-auth: Using JavaScript-level interception (see injected.js)');
+if (DEBUG) console.log('[Podkey] NIP-98 auto-auth: Using JavaScript-level interception (see injected.js)');
diff --git a/src/injected.js b/src/injected.js
index 25b8485..3eba392 100644
--- a/src/injected.js
+++ b/src/injected.js
@@ -19,16 +19,19 @@ interceptorScript.onerror = function () {
 };
 (document.head || document.documentElement).appendChild(interceptorScript);
 
-// Listen for NIP-98 auth requests from page context
+// Listen for NIP-98 auth requests from page context. The request body never
+// crosses this boundary -- the page context computes its SHA-256 (the only
+// place FormData / URLSearchParams / streamed bodies survive intact) and sends
+// only the hex digest for the NIP-98 `payload` tag.
 window.addEventListener('podkey-nip98-request', async (event) => {
-  const { id, url, method, body } = event.detail;
+  const { id, url, method, bodyHash } = event.detail;
 
   try {
     const response = await chrome.runtime.sendMessage({
       type: 'CREATE_NIP98_AUTH_HEADER',
       url,
       method,
-      body
+      bodyHash
     });
 
     if (chrome.runtime.lastError) {
diff --git a/src/nip98-interceptor.js b/src/nip98-interceptor.js
index 029a1cc..e0ffdb1 100644
--- a/src/nip98-interceptor.js
+++ b/src/nip98-interceptor.js
@@ -6,6 +6,10 @@
 (function () {
   'use strict';
 
+  // Set to true for verbose request-flow logging. Off by default; this script
+  // never logs the Authorization header value or any token.
+  const DEBUG = false;
+
   // Only inject once
   if (window.__podkey_nip98_intercepted) {
     return;
@@ -86,10 +90,36 @@
     };
   }
 
+  // Compute the NIP-98 `payload` body hash here in the page context, where the
+  // body object is still intact (FormData / URLSearchParams / Blob cannot be
+  // structured-cloned to the background service worker faithfully). Returns the
+  // hex SHA-256, or '' when there is no hashable body. FormData is intentionally
+  // unsupported: NIP-98 does not define a canonical hash for multipart bodies.
+  async function bodyToHashHex (body) {
+    if (body === undefined || body === null || body === '') return '';
+    let bytes;
+    if (typeof body === 'string') {
+      bytes = new TextEncoder().encode(body);
+    } else if (body instanceof URLSearchParams) {
+      bytes = new TextEncoder().encode(body.toString());
+    } else if (body instanceof Blob) {
+      bytes = new Uint8Array(await body.arrayBuffer());
+    } else if (body instanceof ArrayBuffer) {
+      bytes = new Uint8Array(body);
+    } else if (ArrayBuffer.isView(body)) {
+      bytes = new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+    } else {
+      return '';
+    }
+    const digest = await crypto.subtle.digest('SHA-256', bytes);
+    return Array.from(new Uint8Array(digest), b => b.toString(16).padStart(2, '0')).join('');
+  }
+
   // Helper to get auth header from extension
   async function getNip98AuthHeader (url, method, body) {
     try {
       const urlString = typeof url === 'string' ? url : url.toString();
+      const bodyHash = await bodyToHashHex(body);
 
       // Send message to extension via custom event (content script will forward it)
       return new Promise((resolve) => {
@@ -104,13 +134,13 @@
 
         window.addEventListener('podkey-nip98-response', handler);
 
-        // Request auth header
+        // Request auth header (body hash only -- the raw body stays in the page)
         window.dispatchEvent(new CustomEvent('podkey-nip98-request', {
           detail: {
             id: eventId,
             url: urlString,
             method: method || 'GET',
-            body: body
+            bodyHash
           }
         }));
 
@@ -135,7 +165,7 @@
     // Normalize once — handles fetch(url, init) and fetch(new Request(...))
     // so downstream signing sees the real URL/method, not "[object Request]".
     const { url: urlString, method, body } = normalizeFetchCall(url, options);
-    console.log('[Podkey] 🔍 fetch() intercepted:', urlString, method);
+    if (DEBUG) console.log('[Podkey] fetch() intercepted:', urlString, method);
 
     // Respect an Authorization header the page already set — on either
     // options.headers or a Request input (e.g. Solid-OIDC DPoP). Overwriting
@@ -149,34 +179,33 @@
         const authHeader = await getNip98AuthHeader(urlString, method, body);
         if (authHeader) {
           setAuthorizationOnOptions(options, authHeader);
-          console.log('[Podkey] ✅ Added NIP-98 auth header');
-        } else {
-          console.log('[Podkey] ⚠️ No auth header (will retry on 401)');
+          if (DEBUG) console.log('[Podkey] Added NIP-98 auth header');
+        } else if (DEBUG) {
+          console.log('[Podkey] No auth header (will retry on 401)');
         }
       } catch (error) {
         console.error('[Podkey] Error adding NIP-98 auth:', error);
       }
-    } else {
-      console.log('[Podkey] ⏭️ Page already set Authorization — skipping injection');
+    } else if (DEBUG) {
+      console.log('[Podkey] Page already set Authorization — skipping injection');
     }
 
     const response = await originalFetch.call(this, url, options);
 
     // Handle 401 retry
     if (response.status === 401) {
-      console.log('[Podkey] 🔄 401 detected, retrying with NIP-98 auth...');
+      if (DEBUG) console.log('[Podkey] 401 detected, retrying with NIP-98 auth...');
       try {
-        const authHeader = await getNip98AuthHeader(urlString, method, body);
+        // If the original request followed a redirect, the endpoint that
+        // returned 401 is response.url, not the requested url. NIP-98 binds the
+        // signature to the `u` tag, so re-sign against the actual final URL.
+        const retryUrl = response.redirected && response.url ? response.url : urlString;
+        const authHeader = await getNip98AuthHeader(retryUrl, method, body);
         if (authHeader) {
           const retryOptions = { ...options };
           setAuthorizationOnOptions(retryOptions, authHeader);
-          console.log('[Podkey] 🔄 Retrying with NIP-98 auth...');
-          const retryResponse = await originalFetch.call(this, url, retryOptions);
-          if (retryResponse.status === 200 || retryResponse.status === 201) {
-            console.log('[Podkey] ✅✅ NIP-98 auth retry successful!');
-          } else {
-            console.log('[Podkey] ⚠️ Retry still failed:', retryResponse.status);
-          }
+          const retryResponse = await originalFetch.call(this, retryUrl, retryOptions);
+          if (DEBUG) console.log('[Podkey] NIP-98 retry status:', retryResponse.status);
           return retryResponse;
         }
       } catch (error) {
@@ -211,16 +240,16 @@
         const authHeader = await getNip98AuthHeader(this._podkeyUrl, this._podkeyMethod, body);
         if (authHeader) {
           originalXHRSetRequestHeader.call(this, 'Authorization', authHeader);
-          console.log('[Podkey] ✅ Added NIP-98 auth to XHR');
+          if (DEBUG) console.log('[Podkey] Added NIP-98 auth to XHR');
         }
       } catch (error) {
         console.error('[Podkey] Error adding NIP-98 auth to XHR:', error);
       }
-    } else if (this._podkeyHasPageAuth) {
-      console.log('[Podkey] ⏭️ Page set XHR Authorization — skipping injection');
+    } else if (this._podkeyHasPageAuth && DEBUG) {
+      console.log('[Podkey] Page set XHR Authorization — skipping injection');
     }
     return originalXHRSend.apply(this, [body]);
   };
 
-  console.log('[Podkey] ✅ NIP-98 interceptor injected into page context');
+  if (DEBUG) console.log('[Podkey] NIP-98 interceptor injected into page context');
 })();

From 2f740cb1a4fdf5d9c97972093b2d5ba8cb2480f6 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:08:16 +0000
Subject: [PATCH 12/24] chore(lint): add minimal ESLint config for
 browser-extension ESM

eslint 8.57.1 is pinned in package-lock, so this uses the .eslintrc.json
(eslintrc) format. Extends eslint:recommended with browser, webextensions
(chrome.*), serviceworker (self), and es2022 environments; test/ and
scripts/ get the node environment via overrides.

Security/correctness rules are errors: no-eval, no-implied-eval, no-undef.
no-unused-vars is a warning (argsIgnorePattern ^_) so pre-existing unused
args/imports in src and test surface in CI logs without blocking the gate,
keeping defaults sensible rather than a pedantic wall. Ignores node_modules,
dist, and the gitignored **/*.bundle.js build output.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 .eslintrc.json | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 .eslintrc.json

diff --git a/.eslintrc.json b/.eslintrc.json
new file mode 100644
index 0000000..3e45219
--- /dev/null
+++ b/.eslintrc.json
@@ -0,0 +1,41 @@
+{
+  "root": true,
+  "env": {
+    "browser": true,
+    "webextensions": true,
+    "serviceworker": true,
+    "es2022": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2022,
+    "sourceType": "module"
+  },
+  "extends": "eslint:recommended",
+  "rules": {
+    "no-eval": "error",
+    "no-implied-eval": "error",
+    "no-undef": "error",
+    "no-unused-vars": [
+      "warn",
+      {
+        "argsIgnorePattern": "^_",
+        "varsIgnorePattern": "^_",
+        "caughtErrorsIgnorePattern": "^_"
+      }
+    ]
+  },
+  "ignorePatterns": [
+    "node_modules/",
+    "dist/",
+    "**/*.bundle.js"
+  ],
+  "overrides": [
+    {
+      "files": ["test/**/*.js", "scripts/**/*.js"],
+      "env": {
+        "node": true,
+        "browser": false
+      }
+    }
+  ]
+}

From 5b6056eaed686a7f342e2cf1bc094ecec85cba47 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:08:20 +0000
Subject: [PATCH 13/24] ci: add build/test/lint gate for PRs and pushes to main

New CI workflow runs on pull_request and push to main: a single
ubuntu-latest job on Node 20 with npm cache, running npm ci -> build ->
test -> lint. Minimal contents:read permissions; gh-pages.yml is left
untouched.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 .github/workflows/ci.yml | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 .github/workflows/ci.yml

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..f74ecc1
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,35 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read
+
+jobs:
+  build-test-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build
+        run: npm run build
+
+      - name: Test
+        run: npm test
+
+      - name: Lint
+        run: npm run lint

From 4bc9514d07b2e680a56776b9895f571a17b9194f Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:19:25 +0000
Subject: [PATCH 14/24] feat(popup): calm, trustworthy redesign of the main
 popup
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the purple/blue gradient theme with a calm slate palette and a single
trust-blue accent (semantic green/red reserved for safe/destructive actions).
Add a token-based light/dark theme via prefers-color-scheme, generous spacing,
rounded cards, subtle shadows, accessible focus rings, and inline SVG icons in
place of emoji.

- popup.css: full rewrite as a shared design system (CSS custom properties for
  surfaces, text, borders, accent, semantic colours, shape) consumed by both
  popup.html and approve.html.
- popup.html: restructured identity view — npub/DID in monospace inset cards, a
  "Session" lock pill making the session-only key legible at a glance, a
  settings toggle with a description, and a tidy trusted-sites list.
- popup.js: copy/generate now update a label span instead of overwriting button
  contents (preserves icons); loadTrustedSites rebuilds via the DOM API
  (replaceChildren/createElement) so no innerHTML is used on a surface that
  renders web-origin strings. All message protocols and DEBUG gating unchanged.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 popup/popup.css  | 640 ++++++++++++++++++++++++++++++++---------------
 popup/popup.html | 130 +++++++---
 popup/popup.js   |  29 ++-
 3 files changed, 560 insertions(+), 239 deletions(-)

diff --git a/popup/popup.css b/popup/popup.css
index 6db5dfe..3408f7d 100644
--- a/popup/popup.css
+++ b/popup/popup.css
@@ -1,8 +1,100 @@
 /**
  * Podkey - Popup Styles
- * Beautiful soft light theme with gradients
+ * Calm, modern, trustworthy. Slate neutrals with a single trust-blue accent;
+ * semantic green/red reserved for safe/destructive actions only.
+ * Dark mode via prefers-color-scheme. No frameworks, no dependencies.
  */
 
+:root {
+  /* Surfaces */
+  --bg: #f6f7f9;
+  --surface: #ffffff;
+  --surface-2: #f1f3f6;
+  --surface-inset: #f8fafc;
+
+  /* Text */
+  --text: #1e293b;
+  --text-muted: #64748b;
+  --text-faint: #94a3b8;
+
+  /* Borders */
+  --border: #e2e8f0;
+  --border-strong: #cbd5e1;
+
+  /* Accent (trust blue) */
+  --accent: #2563eb;
+  --accent-hover: #1d4ed8;
+  --accent-soft: #eff6ff;
+  --accent-ring: rgba(37, 99, 235, 0.25);
+
+  /* Semantic */
+  --safe: #16a34a;
+  --safe-hover: #15803d;
+  --safe-soft: #f0fdf4;
+  --safe-border: #bbf7d0;
+
+  --danger: #dc2626;
+  --danger-hover: #b91c1c;
+  --danger-soft: #fef2f2;
+  --danger-border: #fecaca;
+
+  --warn: #b45309;
+  --warn-soft: #fffbeb;
+  --warn-border: #fde68a;
+
+  /* Shape */
+  --radius: 12px;
+  --radius-sm: 8px;
+  --radius-lg: 16px;
+  --shadow-sm: 0 1px 2px rgba(15, 23, 42, 0.06);
+  --shadow: 0 4px 16px rgba(15, 23, 42, 0.08);
+  --shadow-lg: 0 10px 30px rgba(15, 23, 42, 0.12);
+
+  --mono: 'SFMono-Regular', 'Menlo', 'Monaco', 'Consolas', 'Liberation Mono',
+    monospace;
+  --sans: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Helvetica Neue',
+    Arial, sans-serif;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #0e131b;
+    --surface: #161c26;
+    --surface-2: #1c232f;
+    --surface-inset: #0f151d;
+
+    --text: #e6eaf0;
+    --text-muted: #9aa6b6;
+    --text-faint: #6b7888;
+
+    --border: #2a3340;
+    --border-strong: #3a4452;
+
+    --accent: #5b8def;
+    --accent-hover: #74a0f4;
+    --accent-soft: #16223a;
+    --accent-ring: rgba(91, 141, 239, 0.35);
+
+    --safe: #4ade80;
+    --safe-hover: #6ee79a;
+    --safe-soft: #122418;
+    --safe-border: #1f4d30;
+
+    --danger: #f87171;
+    --danger-hover: #fca5a5;
+    --danger-soft: #2a1414;
+    --danger-border: #5a2626;
+
+    --warn: #fbbf24;
+    --warn-soft: #2a2310;
+    --warn-border: #5a4a1a;
+
+    --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.4);
+    --shadow: 0 4px 16px rgba(0, 0, 0, 0.45);
+    --shadow-lg: 0 10px 30px rgba(0, 0, 0, 0.55);
+  }
+}
+
 * {
   box-sizing: border-box;
   margin: 0;
@@ -10,205 +102,321 @@
 }
 
 body {
-  width: 420px;
-  min-height: 500px;
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', sans-serif;
-  background: linear-gradient(135deg, #fef5ff 0%, #f0f9ff 50%, #fef3c7 100%);
-  color: #334155;
-  padding: 0;
+  width: 380px;
+  min-height: 480px;
+  font-family: var(--sans);
+  background: var(--bg);
+  color: var(--text);
+  font-size: 14px;
+  line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
 }
 
 .screen {
-  padding: 20px;
+  padding: 18px 18px 14px;
 }
 
-/* Header */
+/* ---- Header ---- */
 .header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 18px;
+}
+
+.header.center {
+  flex-direction: column;
   text-align: center;
-  margin-bottom: 24px;
-  padding-bottom: 20px;
-  border-bottom: 2px solid rgba(168, 85, 247, 0.2);
+  gap: 8px;
+  margin-bottom: 20px;
 }
 
-.logo {
-  font-size: 64px;
-  margin-bottom: 12px;
-  filter: drop-shadow(0 4px 8px rgba(168, 85, 247, 0.15));
+.brand-mark {
+  width: 36px;
+  height: 36px;
+  flex: none;
+  display: grid;
+  place-items: center;
+  border-radius: 10px;
+  background: var(--accent-soft);
+  color: var(--accent);
+  border: 1px solid var(--border);
 }
 
-.logo-small {
-  font-size: 32px;
-  display: inline-block;
-  margin-right: 8px;
+.brand-mark svg {
+  width: 20px;
+  height: 20px;
+}
+
+.brand-mark.lg {
+  width: 56px;
+  height: 56px;
+  border-radius: 16px;
+  margin-bottom: 2px;
+}
+
+.brand-mark.lg svg {
+  width: 30px;
+  height: 30px;
 }
 
 h1 {
-  font-size: 24px;
+  font-size: 18px;
   font-weight: 700;
-  background: linear-gradient(135deg, #7c3aed 0%, #3b82f6 100%);
-  -webkit-background-clip: text;
-  -webkit-text-fill-color: transparent;
-  background-clip: text;
-  margin-bottom: 6px;
+  letter-spacing: -0.01em;
+  color: var(--text);
 }
 
 h2 {
-  font-size: 20px;
-  color: #6b21a8;
-  margin-bottom: 8px;
+  font-size: 17px;
+  font-weight: 700;
+  letter-spacing: -0.01em;
+  color: var(--text);
 }
 
 .subtitle {
-  font-size: 13px;
-  color: #9333ea;
-  font-weight: 500;
+  font-size: 12.5px;
+  color: var(--text-muted);
+  line-height: 1.45;
+  max-width: 30ch;
+}
+
+.header.center .subtitle {
+  margin: 0 auto;
 }
 
-/* Sections */
+/* ---- Sections / cards ---- */
 .section {
-  background: rgba(255, 255, 255, 0.7);
-  backdrop-filter: blur(10px);
-  border: 1px solid rgba(168, 85, 247, 0.15);
-  border-radius: 16px;
-  padding: 16px;
-  margin-bottom: 16px;
-  box-shadow: 0 4px 12px rgba(168, 85, 247, 0.08);
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 14px;
+  margin-bottom: 12px;
+  box-shadow: var(--shadow-sm);
 }
 
 .section-title {
-  font-size: 14px;
-  font-weight: 600;
-  color: #7c3aed;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  font-size: 11px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-muted);
   margin-bottom: 12px;
 }
 
-/* Buttons */
+/* ---- Buttons ---- */
 .btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 7px;
   width: 100%;
-  padding: 14px;
-  border: none;
-  border-radius: 12px;
-  font-size: 15px;
+  padding: 11px 14px;
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  font-family: inherit;
+  font-size: 14px;
   font-weight: 600;
   cursor: pointer;
-  transition: all 0.2s ease;
+  transition: background 0.15s ease, border-color 0.15s ease,
+    transform 0.05s ease, box-shadow 0.15s ease;
   margin-bottom: 10px;
 }
 
+.btn:last-child {
+  margin-bottom: 0;
+}
+
+.btn svg {
+  width: 16px;
+  height: 16px;
+  flex: none;
+}
+
+.btn:active {
+  transform: translateY(1px);
+}
+
+.btn:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 3px var(--accent-ring);
+}
+
 .btn-primary {
-  background: linear-gradient(135deg, #a78bfa 0%, #7c3aed 100%);
-  color: white;
-  box-shadow: 0 4px 12px rgba(124, 58, 237, 0.25);
+  background: var(--accent);
+  color: #fff;
+  box-shadow: var(--shadow-sm);
 }
 
 .btn-primary:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 6px 20px rgba(124, 58, 237, 0.35);
+  background: var(--accent-hover);
 }
 
 .btn-secondary {
-  background: linear-gradient(135deg, #e0e7ff 0%, #dbeafe 100%);
-  color: #6b21a8;
-  border: 1px solid #c7d2fe;
+  background: var(--surface);
+  color: var(--text);
+  border-color: var(--border-strong);
 }
 
 .btn-secondary:hover {
-  background: linear-gradient(135deg, #c7d2fe 0%, #bfdbfe 100%);
-  transform: translateY(-1px);
+  background: var(--surface-2);
+}
+
+.btn[disabled] {
+  opacity: 0.55;
+  cursor: not-allowed;
+}
+
+.btn[disabled]:active {
+  transform: none;
+}
+
+/* ---- Identity ---- */
+.identity-section .section-title {
+  margin-bottom: 10px;
+}
+
+.identity-field {
+  margin-bottom: 12px;
+}
+
+.identity-field:last-of-type {
+  margin-bottom: 14px;
+}
+
+.identity-label {
+  font-size: 10.5px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-faint);
+  margin-bottom: 5px;
+}
+
+.identity-value {
+  font-family: var(--mono);
+  font-size: 11.5px;
+  line-height: 1.55;
+  color: var(--text);
+  background: var(--surface-inset);
+  border: 1px solid var(--border);
+  padding: 9px 11px;
+  border-radius: var(--radius-sm);
+  word-break: break-all;
 }
 
 .btn-copy {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
   width: 100%;
-  padding: 10px;
-  margin-top: 12px;
-  background: linear-gradient(135deg, #fef3c7 0%, #fed7aa 100%);
-  border: 1px solid #fbbf24;
-  border-radius: 8px;
-  color: #92400e;
-  font-size: 13px;
+  padding: 9px;
+  background: var(--surface);
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius-sm);
+  color: var(--text);
+  font-family: inherit;
+  font-size: 12.5px;
   font-weight: 600;
   cursor: pointer;
-  transition: all 0.2s;
+  transition: background 0.15s ease, color 0.15s ease;
 }
 
-.btn-copy:hover {
-  background: linear-gradient(135deg, #fde68a 0%, #fbbf24 100%);
-  transform: translateY(-1px);
+.btn-copy svg {
+  width: 14px;
+  height: 14px;
 }
 
-/* Identity Card */
-.identity-card {
-  background: linear-gradient(135deg, #fef3c7 0%, #dbeafe 100%);
-  border: 1px solid #bfdbfe;
-  border-radius: 12px;
-  padding: 16px;
+.btn-copy:hover {
+  background: var(--surface-2);
 }
 
-.identity-label {
-  font-size: 11px;
-  font-weight: 700;
-  color: #7c2d12;
-  text-transform: uppercase;
-  letter-spacing: 0.5px;
-  margin-top: 12px;
-  margin-bottom: 6px;
+.btn-copy.copied {
+  color: var(--safe);
+  border-color: var(--safe-border);
+  background: var(--safe-soft);
 }
 
-.identity-label:first-child {
-  margin-top: 0;
+/* ---- Session/lock pill ---- */
+.lock-pill {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 3px 9px;
+  border-radius: 999px;
+  font-size: 10.5px;
+  font-weight: 700;
+  text-transform: none;
+  letter-spacing: 0;
+  background: var(--safe-soft);
+  color: var(--safe);
+  border: 1px solid var(--safe-border);
 }
 
-.identity-value {
-  font-family: 'Monaco', 'Menlo', 'Courier New', monospace;
-  font-size: 11px;
-  color: #475569;
-  background: rgba(255, 255, 255, 0.8);
-  padding: 8px 10px;
-  border-radius: 6px;
-  word-break: break-all;
-  line-height: 1.5;
+.lock-pill svg {
+  width: 11px;
+  height: 11px;
 }
 
-/* Input Fields */
+/* ---- Inputs ---- */
 label {
   display: block;
-  font-size: 13px;
+  font-size: 12.5px;
   font-weight: 600;
-  color: #6b21a8;
-  margin-bottom: 8px;
+  color: var(--text);
+  margin-bottom: 7px;
 }
 
 textarea {
   width: 100%;
-  padding: 12px;
-  border: 2px solid #e9d5ff;
-  border-radius: 8px;
-  font-family: 'Monaco', 'Menlo', monospace;
+  padding: 11px;
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius-sm);
+  font-family: var(--mono);
   font-size: 12px;
+  line-height: 1.5;
   resize: vertical;
-  background: rgba(255, 255, 255, 0.9);
-  color: #334155;
-  transition: border-color 0.2s;
+  background: var(--surface-inset);
+  color: var(--text);
+  transition: border-color 0.15s ease, box-shadow 0.15s ease;
+}
+
+textarea::placeholder {
+  color: var(--text-faint);
 }
 
 textarea:focus {
   outline: none;
-  border-color: #a78bfa;
-  box-shadow: 0 0 0 3px rgba(167, 139, 250, 0.1);
+  border-color: var(--accent);
+  box-shadow: 0 0 0 3px var(--accent-ring);
 }
 
 .hint {
-  font-size: 11px;
-  color: #dc2626;
-  margin-top: 8px;
-  margin-bottom: 16px;
-  padding: 8px 12px;
-  background: linear-gradient(135deg, #fee2e2 0%, #fecaca 100%);
-  border: 1px solid #fca5a5;
-  border-radius: 6px;
-}
-
-/* Actions */
+  display: flex;
+  align-items: flex-start;
+  gap: 7px;
+  font-size: 11.5px;
+  line-height: 1.45;
+  color: var(--warn);
+  margin: 10px 0 0;
+  padding: 9px 11px;
+  background: var(--warn-soft);
+  border: 1px solid var(--warn-border);
+  border-radius: var(--radius-sm);
+}
+
+.hint svg {
+  width: 14px;
+  height: 14px;
+  flex: none;
+  margin-top: 1px;
+}
+
+/* ---- Actions row ---- */
 .actions {
   display: flex;
   gap: 10px;
@@ -219,23 +427,38 @@ textarea:focus {
   margin-bottom: 0;
 }
 
-/* Settings */
+/* ---- Settings ---- */
 .settings-item {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  padding: 12px 0;
-  color: #6b21a8;
-  font-weight: 500;
-  font-size: 14px;
+  gap: 12px;
 }
 
-/* Toggle Switch */
+.settings-text {
+  min-width: 0;
+}
+
+.settings-label {
+  font-size: 13.5px;
+  font-weight: 600;
+  color: var(--text);
+}
+
+.settings-desc {
+  font-size: 11.5px;
+  color: var(--text-muted);
+  line-height: 1.4;
+  margin-top: 2px;
+}
+
+/* Toggle */
 .toggle {
   position: relative;
   display: inline-block;
-  width: 50px;
-  height: 26px;
+  width: 42px;
+  height: 24px;
+  flex: none;
 }
 
 .toggle input {
@@ -246,147 +469,174 @@ textarea:focus {
 
 .slider {
   position: absolute;
+  inset: 0;
   cursor: pointer;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  background: #cbd5e1;
-  transition: 0.3s;
-  border-radius: 26px;
+  background: var(--border-strong);
+  transition: background 0.2s ease;
+  border-radius: 999px;
 }
 
 .slider:before {
   position: absolute;
-  content: "";
-  height: 20px;
-  width: 20px;
+  content: '';
+  height: 18px;
+  width: 18px;
   left: 3px;
   bottom: 3px;
-  background: white;
-  transition: 0.3s;
+  background: #fff;
+  transition: transform 0.2s ease;
   border-radius: 50%;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+  box-shadow: var(--shadow-sm);
 }
 
 input:checked + .slider {
-  background: linear-gradient(135deg, #a78bfa 0%, #7c3aed 100%);
+  background: var(--accent);
 }
 
 input:checked + .slider:before {
-  transform: translateX(24px);
+  transform: translateX(18px);
+}
+
+input:focus-visible + .slider {
+  box-shadow: 0 0 0 3px var(--accent-ring);
 }
 
-/* Trusted Sites */
+/* ---- Trusted sites ---- */
 .trusted-list {
-  max-height: 180px;
+  max-height: 168px;
   overflow-y: auto;
+  margin: -2px;
+  padding: 2px;
 }
 
 .trusted-item {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  padding: 10px 12px;
-  margin: 6px 0;
-  background: linear-gradient(135deg, #fef3c7 0%, #e0f2fe 100%);
-  border: 1px solid #bfdbfe;
-  border-radius: 8px;
-  font-size: 12px;
+  gap: 10px;
+  padding: 9px 11px;
+  margin-bottom: 7px;
+  background: var(--surface-inset);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+}
+
+.trusted-item:last-child {
+  margin-bottom: 0;
 }
 
 .trusted-origin {
-  font-family: monospace;
-  color: #475569;
+  font-family: var(--mono);
+  font-size: 11.5px;
+  color: var(--text);
   flex: 1;
-  margin-right: 8px;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
 }
 
 .btn-remove {
+  flex: none;
   padding: 4px 10px;
-  background: linear-gradient(135deg, #fecaca 0%, #fca5a5 100%);
-  border: 1px solid #f87171;
-  border-radius: 6px;
-  color: #991b1b;
+  background: transparent;
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius-sm);
+  color: var(--text-muted);
+  font-family: inherit;
   font-size: 11px;
   font-weight: 600;
   cursor: pointer;
-  transition: all 0.2s;
+  transition: background 0.15s ease, color 0.15s ease, border-color 0.15s ease;
 }
 
 .btn-remove:hover {
-  background: linear-gradient(135deg, #fca5a5 0%, #f87171 100%);
-  transform: translateY(-1px);
+  background: var(--danger-soft);
+  color: var(--danger);
+  border-color: var(--danger-border);
+}
+
+.btn-remove:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 3px var(--accent-ring);
 }
 
 .empty-state {
   text-align: center;
-  padding: 32px 16px;
-  color: #a78bfa;
-  font-size: 13px;
-  font-style: italic;
+  padding: 22px 16px;
+  color: var(--text-faint);
+  font-size: 12.5px;
 }
 
-/* Info Box */
+/* ---- Info box ---- */
 .info-box {
-  background: linear-gradient(135deg, #f0fdf4 0%, #dbeafe 100%);
-  border: 1px solid #86efac;
-  border-radius: 12px;
-  padding: 16px;
-  margin-top: 16px;
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 14px;
+  margin-top: 4px;
+  box-shadow: var(--shadow-sm);
 }
 
-.info-box p {
-  font-size: 12px;
-  line-height: 1.6;
-  color: #166534;
-  margin-bottom: 8px;
+.info-box-title {
+  font-size: 12.5px;
+  font-weight: 700;
+  color: var(--text);
+  margin-bottom: 6px;
 }
 
-.info-box p:last-child {
-  margin-bottom: 0;
+.info-box p {
+  font-size: 12px;
+  line-height: 1.55;
+  color: var(--text-muted);
 }
 
 .info-box strong {
-  color: #15803d;
+  color: var(--text);
   font-weight: 600;
 }
 
-/* Footer */
+/* ---- Footer ---- */
 .footer {
   text-align: center;
-  padding: 16px;
+  padding: 12px 0 2px;
   font-size: 12px;
-  color: #9333ea;
+  color: var(--text-muted);
 }
 
 .footer a {
-  color: #7c3aed;
+  color: var(--accent);
   text-decoration: none;
   font-weight: 600;
-  transition: color 0.2s;
 }
 
 .footer a:hover {
-  color: #6b21a8;
   text-decoration: underline;
 }
 
-/* Scrollbar Styling */
-.trusted-list::-webkit-scrollbar {
-  width: 6px;
+.footer .sep {
+  margin: 0 6px;
+  color: var(--text-faint);
+}
+
+/* ---- Scrollbars ---- */
+.trusted-list::-webkit-scrollbar,
+.event-preview::-webkit-scrollbar {
+  width: 8px;
 }
 
-.trusted-list::-webkit-scrollbar-track {
-  background: rgba(168, 85, 247, 0.05);
-  border-radius: 3px;
+.trusted-list::-webkit-scrollbar-track,
+.event-preview::-webkit-scrollbar-track {
+  background: transparent;
 }
 
-.trusted-list::-webkit-scrollbar-thumb {
-  background: linear-gradient(135deg, #a78bfa 0%, #7c3aed 100%);
-  border-radius: 3px;
+.trusted-list::-webkit-scrollbar-thumb,
+.event-preview::-webkit-scrollbar-thumb {
+  background: var(--border-strong);
+  border-radius: 999px;
 }
 
-.trusted-list::-webkit-scrollbar-thumb:hover {
-  background: linear-gradient(135deg, #7c3aed 0%, #6b21a8 100%);
+.trusted-list::-webkit-scrollbar-thumb:hover,
+.event-preview::-webkit-scrollbar-thumb:hover {
+  background: var(--text-faint);
 }
diff --git a/popup/popup.html b/popup/popup.html
index 5ae2fed..0ff22d5 100644
--- a/popup/popup.html
+++ b/popup/popup.html
@@ -3,14 +3,21 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Podkey - Your Nostr Identity</title>
+    <title>Podkey — Your Nostr Identity</title>
     <link rel="stylesheet" href="popup.css" />
   </head>
   <body>
     <!-- Setup Screen (shown when no key exists) -->
     <div id="setupScreen" class="screen" style="display: none">
-      <div class="header">
-        <div class="logo">🔑</div>
+      <div class="header center">
+        <div class="brand-mark lg" aria-hidden="true">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <circle cx="8" cy="15" r="4" />
+            <path d="M10.85 12.15 19 4" />
+            <path d="m18 5 2 2" />
+            <path d="m15 8 2 2" />
+          </svg>
+        </div>
         <h1>Welcome to Podkey</h1>
         <p class="subtitle">
           did:nostr and Solid authentication for the decentralized web
@@ -18,21 +25,31 @@ <h1>Welcome to Podkey</h1>
       </div>
 
       <div class="section">
-        <button id="generateBtn" class="btn btn-primary">
-          ✨ Generate New Key
+        <button id="generateBtn" class="btn btn-primary" type="button">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M5 3v4" /><path d="M3 5h4" />
+            <path d="M19 17v4" /><path d="M17 19h4" />
+            <path d="m12 3 1.9 5.8a2 2 0 0 0 1.3 1.3L21 12l-5.8 1.9a2 2 0 0 0-1.3 1.3L12 21l-1.9-5.8a2 2 0 0 0-1.3-1.3L3 12l5.8-1.9a2 2 0 0 0 1.3-1.3z" />
+          </svg>
+          <span class="btn-label">Generate new key</span>
         </button>
-        <button id="importBtn" class="btn btn-secondary">
-          📥 Import Existing Key
+        <button id="importBtn" class="btn btn-secondary" type="button">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+            <polyline points="7 10 12 15 17 10" />
+            <line x1="12" y1="15" x2="12" y2="3" />
+          </svg>
+          Import existing key
         </button>
       </div>
 
       <div class="info-box">
-        <p><strong>What is Podkey?</strong></p>
+        <div class="info-box-title">What is Podkey?</div>
         <p>
           A browser extension for <strong>did:nostr</strong> and
-          <strong>Solid</strong> authentication. Store your cryptographic
-          identity and authenticate seamlessly to Solid pods using did:nostr
-          identities.
+          <strong>Solid</strong> authentication. It holds your cryptographic
+          identity and signs in to Solid pods using your did:nostr identity —
+          your keys never leave this device.
         </p>
       </div>
     </div>
@@ -40,22 +57,40 @@ <h1>Welcome to Podkey</h1>
     <!-- Import Screen -->
     <div id="importScreen" class="screen" style="display: none">
       <div class="header">
-        <h2>Import Private Key</h2>
-        <p class="subtitle">Enter your 64-character hex private key</p>
+        <div class="brand-mark" aria-hidden="true">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+            <polyline points="7 10 12 15 17 10" />
+            <line x1="12" y1="15" x2="12" y2="3" />
+          </svg>
+        </div>
+        <div>
+          <h2>Import private key</h2>
+          <p class="subtitle">Enter your 64-character hex private key</p>
+        </div>
       </div>
 
       <div class="section">
-        <label for="privateKeyInput">Private Key (hex)</label>
+        <label for="privateKeyInput">Private key (hex)</label>
         <textarea
           id="privateKeyInput"
-          placeholder="Enter 64-character hexadecimal private key..."
+          placeholder="64-character hexadecimal private key…"
           rows="3"
+          spellcheck="false"
+          autocomplete="off"
         ></textarea>
-        <div class="hint">⚠️ Never share your private key with anyone!</div>
+        <div class="hint">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M10.29 3.86 1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" />
+            <line x1="12" y1="9" x2="12" y2="13" />
+            <line x1="12" y1="17" x2="12.01" y2="17" />
+          </svg>
+          <span>Never share your private key with anyone.</span>
+        </div>
 
         <div class="actions">
-          <button id="importConfirmBtn" class="btn btn-primary">Import</button>
-          <button id="importCancelBtn" class="btn btn-secondary">Cancel</button>
+          <button id="importCancelBtn" class="btn btn-secondary" type="button">Cancel</button>
+          <button id="importConfirmBtn" class="btn btn-primary" type="button">Import</button>
         </div>
       </div>
     </div>
@@ -63,27 +98,55 @@ <h2>Import Private Key</h2>
     <!-- Main Screen (shown when key exists) -->
     <div id="mainScreen" class="screen" style="display: none">
       <div class="header">
-        <div class="logo-small">🔑</div>
+        <div class="brand-mark" aria-hidden="true">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <circle cx="8" cy="15" r="4" />
+            <path d="M10.85 12.15 19 4" />
+            <path d="m18 5 2 2" />
+            <path d="m15 8 2 2" />
+          </svg>
+        </div>
         <h1>Podkey</h1>
       </div>
 
       <div class="section identity-section">
-        <div class="section-title">Your Identity</div>
-        <div class="identity-card">
-          <div class="identity-label">Public Key</div>
-          <div class="identity-value" id="publicKey">Loading...</div>
+        <div class="section-title">
+          <span>Your identity</span>
+          <span class="lock-pill" title="Your key is held in memory for this browser session only.">
+            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+              <rect x="3" y="11" width="18" height="11" rx="2" ry="2" />
+              <path d="M7 11V7a5 5 0 0 1 10 0v4" />
+            </svg>
+            Session
+          </span>
+        </div>
 
-          <div class="identity-label">DID</div>
-          <div class="identity-value" id="did">Loading...</div>
+        <div class="identity-field">
+          <div class="identity-label">Public key (npub hex)</div>
+          <div class="identity-value" id="publicKey">Loading…</div>
+        </div>
 
-          <button id="copyBtn" class="btn-copy">📋 Copy Public Key</button>
+        <div class="identity-field">
+          <div class="identity-label">DID</div>
+          <div class="identity-value" id="did">Loading…</div>
         </div>
+
+        <button id="copyBtn" class="btn-copy" type="button">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <rect x="9" y="9" width="13" height="13" rx="2" ry="2" />
+            <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
+          </svg>
+          <span class="btn-copy-label">Copy public key</span>
+        </button>
       </div>
 
       <div class="section">
-        <div class="section-title">Settings</div>
+        <div class="section-title"><span>Settings</span></div>
         <div class="settings-item">
-          <span>Auto-sign for Solid</span>
+          <div class="settings-text">
+            <div class="settings-label">Auto-sign for Solid</div>
+            <div class="settings-desc">Silently authenticate to trusted Solid servers.</div>
+          </div>
           <label class="toggle">
             <input type="checkbox" id="autoSignToggle" checked />
             <span class="slider"></span>
@@ -92,19 +155,16 @@ <h1>Podkey</h1>
       </div>
 
       <div class="section">
-        <div class="section-title">Trusted Sites</div>
+        <div class="section-title"><span>Trusted sites</span></div>
         <div id="trustedList" class="trusted-list">
           <div class="empty-state">No trusted sites yet</div>
         </div>
       </div>
 
       <div class="footer">
-        <a href="#" id="exportBtn">Export Key</a> •
-        <a
-          href="https://github.com/JavaScriptSolidServer/podkey"
-          target="_blank"
-          >GitHub</a
-        >
+        <a href="#" id="exportBtn">Export key</a>
+        <span class="sep">•</span>
+        <a href="https://github.com/JavaScriptSolidServer/podkey" target="_blank" rel="noopener">GitHub</a>
       </div>
     </div>
 
diff --git a/popup/popup.js b/popup/popup.js
index 10d6d90..4c1d906 100644
--- a/popup/popup.js
+++ b/popup/popup.js
@@ -113,9 +113,11 @@ function setupEventListeners() {
  * Handle generate new keypair
  */
 async function handleGenerate() {
+  const btn = document.getElementById('generateBtn');
+  const labelEl = btn.querySelector('.btn-label');
+  const original = labelEl ? labelEl.textContent : btn.textContent;
   try {
-    const btn = document.getElementById('generateBtn');
-    btn.textContent = 'Generating...';
+    if (labelEl) labelEl.textContent = 'Generating…';
     btn.disabled = true;
 
     const response = await chrome.runtime.sendMessage({ type: 'GENERATE_KEYPAIR' });
@@ -130,8 +132,8 @@ async function handleGenerate() {
     });
   } catch (error) {
     alert('Error generating keypair: ' + error.message);
-    document.getElementById('generateBtn').textContent = '✨ Generate New Key';
-    document.getElementById('generateBtn').disabled = false;
+    if (labelEl) labelEl.textContent = original;
+    btn.disabled = false;
   }
 }
 
@@ -184,11 +186,14 @@ async function handleCopy() {
     await navigator.clipboard.writeText(publicKey);
 
     const btn = document.getElementById('copyBtn');
-    const originalText = btn.textContent;
-    btn.textContent = '✅ Copied!';
+    const labelEl = btn.querySelector('.btn-copy-label');
+    const originalText = labelEl.textContent;
+    labelEl.textContent = 'Copied';
+    btn.classList.add('copied');
 
     setTimeout(() => {
-      btn.textContent = originalText;
+      labelEl.textContent = originalText;
+      btn.classList.remove('copied');
     }, 2000);
   } catch (error) {
     alert('Failed to copy: ' + error.message);
@@ -251,12 +256,18 @@ async function loadTrustedSites() {
   const listEl = document.getElementById('trustedList');
   const origins = Object.keys(trusted);
 
+  // Rebuild the list with the DOM API only — no innerHTML on this surface,
+  // since origin strings originate from web pages.
+  listEl.replaceChildren();
+
   if (origins.length === 0) {
-    listEl.innerHTML = '<div class="empty-state">No trusted sites yet</div>';
+    const empty = document.createElement('div');
+    empty.className = 'empty-state';
+    empty.textContent = 'No trusted sites yet';
+    listEl.appendChild(empty);
     return;
   }
 
-  listEl.innerHTML = '';
   origins.sort().forEach(origin => {
     const div = document.createElement('div');
     div.className = 'trusted-item';

From b4f674ec64363445c74b5f291c9aac3194368782 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:19:36 +0000
Subject: [PATCH 15/24] feat(approve): trustworthy redesign of the
 signing-consent prompt
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The consent prompt is the surface a user sees when a site asks to sign with
their key, so it now reads as a clear, calm security decision.

- approve.css: dedicated stylesheet (inherits the popup design tokens). The
  requesting origin is the focal point — large monospace in a bordered inset
  that wraps/scrolls long or hostile origins without overflowing the layout or
  hiding the buttons. Deny is the safe default (solid, autofocused); Approve is
  deliberate (outlined danger-tone, not pre-focused, so a blind Enter denies).
  An amber note states that approving lets the site act as the user.
- approve.html: restructured DOM (shield header, origin block, action row,
  scrollable payload, trust note, button row, live countdown). No inline styles
  with untrusted data; all dynamic fields are empty containers populated by JS.
- approve.js: drives a visible, accurate 60s auto-deny countdown (rAF, with an
  "urgent" state under 10s). Security contract preserved byte-for-byte: reads
  id/origin/action/preview from the query string, sends
  {type:'APPROVE_SIGNING', requestId, approved} on choice, denies on
  beforeunload (close = deny), and auto-denies at 60s. A one-shot guard ensures
  the decision is sent exactly once. Origin and payload are written via
  textContent only — never innerHTML.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 popup/approve.css  | 252 +++++++++++++++++++++++++++++++++++++++++++++
 popup/approve.html | 178 ++++++++++++--------------------
 popup/approve.js   |  95 ++++++++++++-----
 3 files changed, 389 insertions(+), 136 deletions(-)
 create mode 100644 popup/approve.css

diff --git a/popup/approve.css b/popup/approve.css
new file mode 100644
index 0000000..3f042c9
--- /dev/null
+++ b/popup/approve.css
@@ -0,0 +1,252 @@
+/**
+ * Podkey - Signing-approval consent prompt
+ * The most security-critical surface: a site is asking to act as the user.
+ * Goal: unambiguous, calm, hard to mis-click. Deny is the safe default.
+ * Inherits design tokens from popup.css (loaded first).
+ */
+
+body {
+  width: 380px;
+  min-height: 0;
+}
+
+.approve {
+  display: flex;
+  flex-direction: column;
+  padding: 16px 16px 14px;
+}
+
+/* ---- Header ---- */
+.approve-head {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 14px;
+}
+
+.approve-shield {
+  width: 36px;
+  height: 36px;
+  flex: none;
+  display: grid;
+  place-items: center;
+  border-radius: 10px;
+  background: var(--accent-soft);
+  color: var(--accent);
+  border: 1px solid var(--border);
+}
+
+.approve-shield svg {
+  width: 20px;
+  height: 20px;
+}
+
+.approve-title {
+  font-size: 16px;
+  font-weight: 700;
+  letter-spacing: -0.01em;
+  color: var(--text);
+}
+
+.approve-sub {
+  font-size: 11.5px;
+  color: var(--text-muted);
+  margin-top: 1px;
+}
+
+/* ---- Origin block (the spoof-resistant focal point) ---- */
+.origin-block {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 12px 14px;
+  margin-bottom: 12px;
+  box-shadow: var(--shadow-sm);
+}
+
+.origin-eyebrow {
+  font-size: 10.5px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-faint);
+  margin-bottom: 6px;
+}
+
+.origin-badge {
+  display: block;
+  font-family: var(--mono);
+  font-size: 14px;
+  font-weight: 600;
+  line-height: 1.4;
+  color: var(--text);
+  background: var(--surface-inset);
+  border: 1px solid var(--border-strong);
+  border-radius: var(--radius-sm);
+  padding: 9px 11px;
+  /* Long/hostile origins wrap and stay contained; cannot push layout. */
+  word-break: break-all;
+  overflow-wrap: anywhere;
+  max-height: 84px;
+  overflow-y: auto;
+}
+
+/* ---- Action ---- */
+.action-row {
+  display: flex;
+  align-items: flex-start;
+  gap: 9px;
+  margin-bottom: 12px;
+  font-size: 13.5px;
+  color: var(--text);
+}
+
+.action-row .action-icon {
+  width: 18px;
+  height: 18px;
+  flex: none;
+  margin-top: 1px;
+  color: var(--text-muted);
+}
+
+.action-row .action-text {
+  font-weight: 600;
+}
+
+/* ---- Preview ---- */
+.preview-wrap {
+  margin-bottom: 12px;
+}
+
+.preview-label {
+  font-size: 10.5px;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--text-faint);
+  margin-bottom: 6px;
+}
+
+.event-preview {
+  background: var(--surface-inset);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  padding: 11px 12px;
+  font-family: var(--mono);
+  font-size: 11.5px;
+  line-height: 1.5;
+  color: var(--text-muted);
+  max-height: 150px;
+  overflow: auto;
+  white-space: pre;
+  word-break: normal;
+  tab-size: 2;
+}
+
+/* ---- Trust warning ---- */
+.trust-note {
+  display: flex;
+  align-items: flex-start;
+  gap: 8px;
+  font-size: 11.5px;
+  line-height: 1.45;
+  color: var(--warn);
+  margin-bottom: 14px;
+  padding: 9px 11px;
+  background: var(--warn-soft);
+  border: 1px solid var(--warn-border);
+  border-radius: var(--radius-sm);
+}
+
+.trust-note svg {
+  width: 15px;
+  height: 15px;
+  flex: none;
+  margin-top: 1px;
+}
+
+/* ---- Buttons ---- */
+.btn-row {
+  display: flex;
+  gap: 10px;
+}
+
+.btn-row .btn {
+  flex: 1;
+  margin-bottom: 0;
+}
+
+/* Deny = safe default: solid, visually settled, autofocused. */
+.btn-deny {
+  background: var(--surface);
+  color: var(--text);
+  border: 1px solid var(--border-strong);
+}
+
+.btn-deny:hover {
+  background: var(--surface-2);
+}
+
+.btn-deny:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 3px var(--accent-ring);
+}
+
+/* Approve = deliberate: outlined danger-tone, not pre-focused. */
+.btn-approve {
+  background: transparent;
+  color: var(--danger);
+  border: 1.5px solid var(--danger-border);
+}
+
+.btn-approve:hover {
+  background: var(--danger-soft);
+  border-color: var(--danger);
+}
+
+.btn-approve:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 3px rgba(220, 38, 38, 0.3);
+}
+
+/* ---- Countdown ---- */
+.countdown {
+  margin-top: 12px;
+}
+
+.countdown-text {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 6px;
+  font-size: 11px;
+  color: var(--text-faint);
+  margin-bottom: 7px;
+}
+
+.countdown-text strong {
+  color: var(--text-muted);
+  font-variant-numeric: tabular-nums;
+  font-weight: 700;
+}
+
+.timeout-bar {
+  height: 4px;
+  background: var(--border);
+  border-radius: 999px;
+  overflow: hidden;
+}
+
+.timeout-bar-inner {
+  height: 100%;
+  width: 100%;
+  background: var(--text-faint);
+  border-radius: 999px;
+  transform-origin: left center;
+  /* Width is driven from JS for an accurate, synced countdown. */
+  transition: background 0.4s ease;
+}
+
+.timeout-bar-inner.urgent {
+  background: var(--danger);
+}
diff --git a/popup/approve.html b/popup/approve.html
index f5db261..29b0099 100644
--- a/popup/approve.html
+++ b/popup/approve.html
@@ -1,114 +1,68 @@
 <!DOCTYPE html>
-<html>
-<head>
-  <meta charset="utf-8">
-  <title>PodKey - Signing Request</title>
-  <link rel="stylesheet" href="popup.css">
-  <style>
-    body { width: 380px; min-height: 200px; }
-    .approve-container { padding: 16px; }
-    .approve-header {
-      margin: 0 0 12px;
-      font-size: 18px;
-      font-weight: 700;
-      background: linear-gradient(135deg, #ef4444 0%, #f97316 100%);
-      -webkit-background-clip: text;
-      -webkit-text-fill-color: transparent;
-      background-clip: text;
-    }
-    .origin-badge {
-      background: #1a1a2e;
-      color: #e94560;
-      padding: 6px 10px;
-      border-radius: 6px;
-      font-family: 'Monaco', 'Menlo', 'Courier New', monospace;
-      font-size: 13px;
-      word-break: break-all;
-    }
-    .action-text {
-      margin: 12px 0;
-      color: #475569;
-      font-size: 14px;
-      font-weight: 500;
-    }
-    .event-preview {
-      background: #f8fafc;
-      border: 1px solid #e2e8f0;
-      padding: 10px;
-      border-radius: 6px;
-      font-family: 'Monaco', 'Menlo', 'Courier New', monospace;
-      font-size: 11px;
-      max-height: 120px;
-      overflow-y: auto;
-      color: #64748b;
-      margin: 8px 0;
-      white-space: pre-wrap;
-      word-break: break-all;
-    }
-    .btn-row {
-      display: flex;
-      gap: 10px;
-      margin-top: 16px;
-    }
-    .btn-row button {
-      flex: 1;
-      padding: 12px;
-      border: none;
-      border-radius: 10px;
-      font-size: 14px;
-      font-weight: 600;
-      cursor: pointer;
-      transition: all 0.2s ease;
-    }
-    .btn-approve {
-      background: linear-gradient(135deg, #4ade80 0%, #22c55e 100%);
-      color: #052e16;
-      box-shadow: 0 4px 12px rgba(34, 197, 94, 0.25);
-    }
-    .btn-deny {
-      background: linear-gradient(135deg, #fca5a5 0%, #ef4444 100%);
-      color: #450a0a;
-      box-shadow: 0 4px 12px rgba(239, 68, 68, 0.25);
-    }
-    .btn-approve:hover {
-      transform: translateY(-1px);
-      box-shadow: 0 6px 16px rgba(34, 197, 94, 0.35);
-    }
-    .btn-deny:hover {
-      transform: translateY(-1px);
-      box-shadow: 0 6px 16px rgba(239, 68, 68, 0.35);
-    }
-    .timeout-bar {
-      margin-top: 12px;
-      height: 3px;
-      background: #e2e8f0;
-      border-radius: 2px;
-      overflow: hidden;
-    }
-    .timeout-bar-inner {
-      height: 100%;
-      background: linear-gradient(90deg, #ef4444 0%, #f97316 100%);
-      width: 100%;
-      animation: shrink 60s linear forwards;
-    }
-    @keyframes shrink {
-      from { width: 100%; }
-      to { width: 0%; }
-    }
-  </style>
-</head>
-<body>
-  <div class="approve-container">
-    <h3 class="approve-header">Signing Request</h3>
-    <div class="origin-badge" id="origin"></div>
-    <div class="action-text" id="action"></div>
-    <div class="event-preview" id="preview"></div>
-    <div class="btn-row">
-      <button class="btn-deny" id="deny">Deny</button>
-      <button class="btn-approve" id="approve">Approve</button>
-    </div>
-    <div class="timeout-bar"><div class="timeout-bar-inner"></div></div>
-  </div>
-  <script src="approve.js"></script>
-</body>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Podkey — Signing Request</title>
+    <link rel="stylesheet" href="popup.css" />
+    <link rel="stylesheet" href="approve.css" />
+  </head>
+  <body>
+    <main class="approve">
+      <div class="approve-head">
+        <div class="approve-shield" aria-hidden="true">
+          <!-- shield -->
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+            <path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z" />
+          </svg>
+        </div>
+        <div>
+          <div class="approve-title">Signing request</div>
+          <div class="approve-sub">Review carefully before approving</div>
+        </div>
+      </div>
+
+      <section class="origin-block">
+        <div class="origin-eyebrow">Requested by</div>
+        <code class="origin-badge" id="origin"></code>
+      </section>
+
+      <div class="action-row">
+        <svg class="action-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+          <path d="M12 20h9" />
+          <path d="M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4 12.5-12.5z" />
+        </svg>
+        <span class="action-text" id="action"></span>
+      </div>
+
+      <div class="preview-wrap" id="previewWrap">
+        <div class="preview-label">Payload</div>
+        <pre class="event-preview" id="preview"></pre>
+      </div>
+
+      <div class="trust-note">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+          <circle cx="12" cy="12" r="10" />
+          <line x1="12" y1="8" x2="12" y2="12" />
+          <line x1="12" y1="16" x2="12.01" y2="16" />
+        </svg>
+        <span>Approving lets this site act with your key as if it were you.</span>
+      </div>
+
+      <div class="btn-row">
+        <button class="btn btn-deny" id="deny" type="button" autofocus>Deny</button>
+        <button class="btn btn-approve" id="approve" type="button">Approve</button>
+      </div>
+
+      <div class="countdown">
+        <div class="countdown-text">
+          Auto-denies in <strong id="countdown">60</strong>s
+        </div>
+        <div class="timeout-bar">
+          <div class="timeout-bar-inner" id="timeoutBar"></div>
+        </div>
+      </div>
+    </main>
+    <script src="approve.js"></script>
+  </body>
 </html>
diff --git a/popup/approve.js b/popup/approve.js
index b17db5b..2c8f5ab 100644
--- a/popup/approve.js
+++ b/popup/approve.js
@@ -1,55 +1,102 @@
 /**
  * Podkey - Signing Approval Popup
  * Presents signing requests to the user for explicit approval/denial.
+ *
+ * Security contract (must stay byte-equivalent in effect):
+ *   - Read requestId/origin/action/preview from the query string.
+ *   - On a choice: chrome.runtime.sendMessage(
+ *       { type: 'APPROVE_SIGNING', requestId, approved: <bool> }).
+ *   - Closing the popup (beforeunload) sends approved:false (closing = deny).
+ *   - A 60-second auto-deny countdown denies if the user does nothing.
+ *
+ * The displayed origin and payload come from web pages and are treated as
+ * hostile strings: only ever written via textContent, never innerHTML.
  */
 
+const APPROVAL_TIMEOUT_MS = 60_000;
+
 const params = new URLSearchParams(window.location.search);
 const requestId = params.get('id');
 const origin = params.get('origin') || 'Unknown';
 const action = params.get('action') || 'sign';
 const preview = params.get('preview') || '';
 
-// Populate UI
+// One-shot guard: the decision is sent exactly once, whichever path fires
+// first (button click, auto-deny timeout, or window close).
+let decisionSent = false;
+
+function sendDecision(approved) {
+  if (decisionSent) return;
+  decisionSent = true;
+  chrome.runtime.sendMessage({
+    type: 'APPROVE_SIGNING',
+    requestId,
+    approved
+  });
+}
+
+// ---- Populate UI (textContent only — never innerHTML for untrusted data) ----
+
 document.getElementById('origin').textContent = origin;
-document.getElementById('action').textContent = `wants to: ${action}`;
+document.getElementById('action').textContent = action;
 
+const previewEl = document.getElementById('preview');
+const previewWrap = document.getElementById('previewWrap');
 if (preview) {
   try {
-    // Try to pretty-print JSON previews
+    // Pretty-print JSON payloads for readability; fall back to raw text.
     const parsed = JSON.parse(preview);
-    document.getElementById('preview').textContent = JSON.stringify(parsed, null, 2);
+    previewEl.textContent = JSON.stringify(parsed, null, 2);
   } catch {
-    document.getElementById('preview').textContent = preview;
+    previewEl.textContent = preview;
   }
 } else {
-  document.getElementById('preview').style.display = 'none';
+  previewWrap.style.display = 'none';
 }
 
-// Approve button
+// ---- Buttons ----
+
 document.getElementById('approve').addEventListener('click', () => {
-  chrome.runtime.sendMessage({
-    type: 'APPROVE_SIGNING',
-    requestId,
-    approved: true
-  });
+  sendDecision(true);
   window.close();
 });
 
-// Deny button
 document.getElementById('deny').addEventListener('click', () => {
-  chrome.runtime.sendMessage({
-    type: 'APPROVE_SIGNING',
-    requestId,
-    approved: false
-  });
+  sendDecision(false);
   window.close();
 });
 
-// Also deny on window close (user closes the popup without clicking)
+// Closing the popup without choosing is a denial.
 window.addEventListener('beforeunload', () => {
-  chrome.runtime.sendMessage({
-    type: 'APPROVE_SIGNING',
-    requestId,
-    approved: false
-  });
+  sendDecision(false);
 });
+
+// ---- 60-second auto-deny countdown ----
+
+const countdownEl = document.getElementById('countdown');
+const barEl = document.getElementById('timeoutBar');
+const startedAt = Date.now();
+
+function tickCountdown() {
+  if (decisionSent) return;
+
+  const elapsed = Date.now() - startedAt;
+  const remainingMs = Math.max(0, APPROVAL_TIMEOUT_MS - elapsed);
+  const remainingSec = Math.ceil(remainingMs / 1000);
+  const fraction = remainingMs / APPROVAL_TIMEOUT_MS;
+
+  countdownEl.textContent = String(remainingSec);
+  barEl.style.width = `${(fraction * 100).toFixed(2)}%`;
+  barEl.classList.toggle('urgent', remainingSec <= 10);
+
+  if (remainingMs <= 0) {
+    // Time is up: deny and close.
+    sendDecision(false);
+    window.close();
+    return;
+  }
+
+  requestAnimationFrame(tickCountdown);
+}
+
+requestAnimationFrame(tickCountdown);

From 3f83e90a1fd0ae44af406463783e98b7d1080b2b Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:19:45 +0000
Subject: [PATCH 16/24] feat(test-page): polished install/test landing,
 CSP-clean
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rework the public test/install page to match the extension's calm design and
to drop inline scripts/handlers.

- app.css: new stylesheet matching the popup design tokens, with light/dark via
  prefers-color-scheme.
- app.js: extracted from the inline <script>; buttons are wired with
  addEventListener keyed by data-action (no onclick=). Result panels and the
  event log are built with createElement/textContent — no innerHTML with
  interpolated signed-event fields or error messages.
- index.html: cleaner brand header, status card, a numbered install flow with
  code blocks, colour-coded notices, and key-management/signing test sections.
  Links external app.css/app.js; no inline <style> or <script> remain.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 test-page/app.css    |  583 +++++++++++++++++++++++
 test-page/app.js     |  317 +++++++++++++
 test-page/index.html | 1047 ++++++++----------------------------------
 3 files changed, 1085 insertions(+), 862 deletions(-)
 create mode 100644 test-page/app.css
 create mode 100644 test-page/app.js

diff --git a/test-page/app.css b/test-page/app.css
new file mode 100644
index 0000000..3373e55
--- /dev/null
+++ b/test-page/app.css
@@ -0,0 +1,583 @@
+/**
+ * Podkey — Test / install page styles
+ * Calm, modern, trustworthy; matches the extension popup language.
+ * Dark mode via prefers-color-scheme. No frameworks, no dependencies.
+ */
+
+:root {
+  --bg: #f6f7f9;
+  --surface: #ffffff;
+  --surface-2: #f1f3f6;
+  --surface-inset: #f8fafc;
+
+  --text: #1e293b;
+  --text-muted: #64748b;
+  --text-faint: #94a3b8;
+
+  --border: #e2e8f0;
+  --border-strong: #cbd5e1;
+
+  --accent: #2563eb;
+  --accent-hover: #1d4ed8;
+  --accent-soft: #eff6ff;
+  --accent-ring: rgba(37, 99, 235, 0.25);
+
+  --safe: #16a34a;
+  --safe-soft: #f0fdf4;
+  --safe-border: #bbf7d0;
+
+  --danger: #dc2626;
+  --danger-soft: #fef2f2;
+  --danger-border: #fecaca;
+
+  --warn: #b45309;
+  --warn-soft: #fffbeb;
+  --warn-border: #fde68a;
+
+  --code-bg: #0f172a;
+  --code-text: #e2e8f0;
+  --code-muted: #94a3b8;
+
+  --radius: 14px;
+  --radius-sm: 9px;
+  --shadow-sm: 0 1px 2px rgba(15, 23, 42, 0.06);
+  --shadow: 0 6px 24px rgba(15, 23, 42, 0.08);
+
+  --mono: 'SFMono-Regular', 'Menlo', 'Monaco', 'Consolas', 'Liberation Mono',
+    monospace;
+  --sans: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto',
+    'Helvetica Neue', Arial, sans-serif;
+}
+
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #0b0f16;
+    --surface: #141a24;
+    --surface-2: #1b222e;
+    --surface-inset: #0f151d;
+
+    --text: #e6eaf0;
+    --text-muted: #9aa6b6;
+    --text-faint: #6b7888;
+
+    --border: #2a3340;
+    --border-strong: #3a4452;
+
+    --accent: #5b8def;
+    --accent-hover: #74a0f4;
+    --accent-soft: #16223a;
+    --accent-ring: rgba(91, 141, 239, 0.35);
+
+    --safe: #4ade80;
+    --safe-soft: #122418;
+    --safe-border: #1f4d30;
+
+    --danger: #f87171;
+    --danger-soft: #2a1414;
+    --danger-border: #5a2626;
+
+    --warn: #fbbf24;
+    --warn-soft: #2a2310;
+    --warn-border: #5a4a1a;
+
+    --code-bg: #060a11;
+    --code-text: #d7deea;
+    --code-muted: #7a8696;
+
+    --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.4);
+    --shadow: 0 6px 24px rgba(0, 0, 0, 0.5);
+  }
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: var(--sans);
+  background: var(--bg);
+  color: var(--text);
+  padding: 28px 20px 48px;
+  min-height: 100vh;
+  line-height: 1.5;
+  -webkit-font-smoothing: antialiased;
+}
+
+.container {
+  max-width: 820px;
+  margin: 0 auto;
+}
+
+a {
+  color: var(--accent);
+}
+
+/* ---- Header ---- */
+.header {
+  text-align: center;
+  margin-bottom: 28px;
+}
+
+.header .brand {
+  display: inline-flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 12px;
+}
+
+.header .brand-mark {
+  width: 48px;
+  height: 48px;
+  display: grid;
+  place-items: center;
+  border-radius: 14px;
+  background: var(--accent-soft);
+  color: var(--accent);
+  border: 1px solid var(--border);
+}
+
+.header .brand-mark svg {
+  width: 26px;
+  height: 26px;
+}
+
+.header h1 {
+  font-size: 28px;
+  font-weight: 800;
+  letter-spacing: -0.02em;
+}
+
+.header .tagline {
+  color: var(--text-muted);
+  font-size: 15px;
+  max-width: 52ch;
+  margin: 0 auto;
+}
+
+.header .tagline strong {
+  color: var(--text);
+}
+
+/* ---- Cards ---- */
+.card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 22px;
+  margin-bottom: 18px;
+  box-shadow: var(--shadow-sm);
+}
+
+.card h2 {
+  font-size: 18px;
+  font-weight: 700;
+  letter-spacing: -0.01em;
+  margin-bottom: 16px;
+  display: flex;
+  align-items: center;
+  gap: 9px;
+}
+
+.card h2 svg {
+  width: 18px;
+  height: 18px;
+  color: var(--text-muted);
+}
+
+.card h3 {
+  font-size: 15px;
+  font-weight: 700;
+  margin-bottom: 12px;
+}
+
+.card p {
+  color: var(--text-muted);
+  margin-bottom: 10px;
+}
+
+.card p:last-child {
+  margin-bottom: 0;
+}
+
+.card p strong {
+  color: var(--text);
+}
+
+/* ---- Status indicator ---- */
+.status-dot {
+  display: inline-block;
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  background: var(--text-faint);
+  flex: none;
+}
+
+.status-dot.active {
+  background: var(--safe);
+  box-shadow: 0 0 0 4px var(--safe-soft);
+}
+
+.status-dot.error {
+  background: var(--danger);
+  box-shadow: 0 0 0 4px var(--danger-soft);
+}
+
+.status-line {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  font-size: 15px;
+  font-weight: 600;
+}
+
+.status-meta {
+  margin-top: 8px;
+  font-size: 13px;
+  color: var(--text-muted);
+}
+
+.status-meta strong {
+  color: var(--text);
+}
+
+.badge {
+  display: inline-block;
+  padding: 3px 9px;
+  border-radius: 999px;
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+}
+
+.badge-success {
+  background: var(--safe-soft);
+  color: var(--safe);
+  border: 1px solid var(--safe-border);
+}
+
+.badge-error {
+  background: var(--danger-soft);
+  color: var(--danger);
+  border: 1px solid var(--danger-border);
+}
+
+/* ---- Buttons ---- */
+.btn {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  background: var(--accent);
+  color: #fff;
+  border: 1px solid transparent;
+  padding: 10px 16px;
+  border-radius: var(--radius-sm);
+  font-family: inherit;
+  font-size: 13.5px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: background 0.15s ease, transform 0.05s ease, box-shadow 0.15s ease;
+  margin: 0 8px 8px 0;
+}
+
+.btn:hover {
+  background: var(--accent-hover);
+}
+
+.btn:active {
+  transform: translateY(1px);
+}
+
+.btn:focus-visible {
+  outline: none;
+  box-shadow: 0 0 0 3px var(--accent-ring);
+}
+
+.btn.secondary {
+  background: var(--surface);
+  color: var(--text);
+  border-color: var(--border-strong);
+}
+
+.btn.secondary:hover {
+  background: var(--surface-2);
+}
+
+.btn:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.btn:disabled:active {
+  transform: none;
+}
+
+.btn-link {
+  display: inline-flex;
+  align-items: center;
+  gap: 7px;
+  background: var(--accent);
+  color: #fff;
+  text-decoration: none;
+  padding: 10px 18px;
+  border-radius: var(--radius-sm);
+  font-weight: 600;
+  font-size: 14px;
+}
+
+.btn-link:hover {
+  background: var(--accent-hover);
+}
+
+/* ---- Test grid ---- */
+.test-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
+  gap: 16px;
+}
+
+.test-cell .value-display {
+  margin-top: 0;
+}
+
+/* ---- Value display ---- */
+.value-display {
+  background: var(--surface-inset);
+  border: 1px solid var(--border);
+  border-radius: var(--radius-sm);
+  padding: 12px;
+  font-family: var(--mono);
+  font-size: 11.5px;
+  line-height: 1.55;
+  word-break: break-all;
+  margin-top: 10px;
+  color: var(--text-muted);
+}
+
+.value-display .vd-label {
+  display: block;
+  font-weight: 700;
+  color: var(--text);
+  margin: 8px 0 2px;
+}
+
+.value-display .vd-label:first-child {
+  margin-top: 0;
+}
+
+.value-display.is-error {
+  background: var(--danger-soft);
+  border-color: var(--danger-border);
+  color: var(--danger);
+}
+
+.value-display pre {
+  white-space: pre-wrap;
+  word-break: break-all;
+  font-size: 11px;
+}
+
+/* ---- Log ---- */
+.log {
+  background: var(--code-bg);
+  color: var(--code-text);
+  padding: 14px 16px;
+  border-radius: var(--radius-sm);
+  font-family: var(--mono);
+  font-size: 12px;
+  max-height: 360px;
+  overflow-y: auto;
+  margin-top: 8px;
+}
+
+.log-entry {
+  padding: 3px 0;
+}
+
+.log-time {
+  color: var(--code-muted);
+  margin-right: 8px;
+}
+
+.log-success {
+  color: #4ade80;
+}
+.log-error {
+  color: #f87171;
+}
+.log-info {
+  color: #93c5fd;
+}
+.log-warn {
+  color: #fbbf24;
+}
+
+/* ---- Install steps ---- */
+.steps {
+  counter-reset: step;
+  list-style: none;
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+}
+
+.steps > li {
+  position: relative;
+  padding-left: 42px;
+  counter-increment: step;
+}
+
+.steps > li::before {
+  content: counter(step);
+  position: absolute;
+  left: 0;
+  top: 0;
+  width: 28px;
+  height: 28px;
+  display: grid;
+  place-items: center;
+  border-radius: 50%;
+  background: var(--accent-soft);
+  color: var(--accent);
+  border: 1px solid var(--border);
+  font-size: 13px;
+  font-weight: 700;
+}
+
+.steps .step-title {
+  font-weight: 700;
+  color: var(--text);
+  margin-bottom: 6px;
+}
+
+.steps .step-body {
+  color: var(--text-muted);
+  font-size: 14px;
+}
+
+.steps .step-body strong {
+  color: var(--text);
+}
+
+.steps ul {
+  margin: 8px 0 0;
+  padding-left: 18px;
+  color: var(--text-muted);
+  font-size: 13.5px;
+  line-height: 1.7;
+}
+
+code.inline {
+  font-family: var(--mono);
+  font-size: 12px;
+  background: var(--surface-2);
+  border: 1px solid var(--border);
+  padding: 1px 6px;
+  border-radius: 5px;
+  color: var(--text);
+}
+
+pre.code-block {
+  background: var(--code-bg);
+  color: var(--code-text);
+  padding: 14px 16px;
+  border-radius: var(--radius-sm);
+  font-family: var(--mono);
+  font-size: 12.5px;
+  line-height: 1.7;
+  overflow-x: auto;
+  margin-top: 10px;
+}
+
+/* ---- Notices ---- */
+.notice {
+  display: flex;
+  gap: 10px;
+  align-items: flex-start;
+  border-radius: var(--radius-sm);
+  padding: 13px 15px;
+  margin-top: 16px;
+  font-size: 13.5px;
+  line-height: 1.5;
+}
+
+.notice svg {
+  width: 17px;
+  height: 17px;
+  flex: none;
+  margin-top: 1px;
+}
+
+.notice.info {
+  background: var(--accent-soft);
+  border: 1px solid var(--border);
+  color: var(--text);
+}
+.notice.info svg {
+  color: var(--accent);
+}
+
+.notice.good {
+  background: var(--safe-soft);
+  border: 1px solid var(--safe-border);
+  color: var(--text);
+}
+.notice.good svg {
+  color: var(--safe);
+}
+
+.notice.warn {
+  background: var(--warn-soft);
+  border: 1px solid var(--warn-border);
+  color: var(--text);
+}
+.notice.warn svg {
+  color: var(--warn);
+}
+
+.notice strong {
+  color: var(--text);
+}
+
+.notice ul {
+  margin: 6px 0 0;
+  padding-left: 18px;
+  line-height: 1.7;
+}
+
+.divider {
+  height: 1px;
+  background: var(--border);
+  margin: 20px 0;
+}
+
+/* ---- Footer ---- */
+.page-footer {
+  text-align: center;
+  color: var(--text-faint);
+  font-size: 13px;
+  margin-top: 28px;
+}
+
+.page-footer a {
+  font-weight: 600;
+  text-decoration: none;
+}
+
+.page-footer a:hover {
+  text-decoration: underline;
+}
+
+/* ---- Scrollbars ---- */
+.log::-webkit-scrollbar {
+  width: 9px;
+}
+.log::-webkit-scrollbar-track {
+  background: transparent;
+}
+.log::-webkit-scrollbar-thumb {
+  background: rgba(148, 163, 184, 0.4);
+  border-radius: 999px;
+}
diff --git a/test-page/app.js b/test-page/app.js
new file mode 100644
index 0000000..4e44709
--- /dev/null
+++ b/test-page/app.js
@@ -0,0 +1,317 @@
+/**
+ * Podkey — Test / install page logic.
+ *
+ * Runs in a normal web page (window.nostr is provided by the extension's
+ * injected provider). All DOM updates use textContent / createElement — never
+ * innerHTML with interpolated values — since signed-event fields and error
+ * messages may contain arbitrary strings.
+ */
+
+let logCount = 0;
+
+const els = {};
+function $(id) {
+  return (els[id] ||= document.getElementById(id));
+}
+
+/* ---------- Logging ---------- */
+
+function log(message, type = 'info') {
+  const logEl = $('eventLog');
+  const time = new Date().toLocaleTimeString();
+
+  const entry = document.createElement('div');
+  entry.className = 'log-entry';
+
+  const timeSpan = document.createElement('span');
+  timeSpan.className = 'log-time';
+  timeSpan.textContent = `[${time}]`;
+
+  const messageSpan = document.createElement('span');
+  messageSpan.className = `log-${type}`;
+  messageSpan.textContent = message;
+
+  entry.appendChild(timeSpan);
+  entry.appendChild(messageSpan);
+  logEl.insertBefore(entry, logEl.firstChild);
+
+  logCount++;
+  while (logEl.children.length > 100) {
+    logEl.removeChild(logEl.lastChild);
+  }
+}
+
+function clearLog() {
+  $('eventLog').replaceChildren();
+  logCount = 0;
+  log('Log cleared', 'info');
+}
+
+/* ---------- Result rendering helpers (DOM-only, no innerHTML) ---------- */
+
+/**
+ * Render labelled key/value lines into a value-display element.
+ * fields: array of [label, value] pairs.
+ */
+function showResult(id, fields) {
+  const el = $(id);
+  el.classList.remove('is-error');
+  el.replaceChildren();
+  el.style.display = 'block';
+
+  for (const [label, value] of fields) {
+    const labelEl = document.createElement('span');
+    labelEl.className = 'vd-label';
+    labelEl.textContent = label;
+    el.appendChild(labelEl);
+
+    const valueEl = document.createElement('span');
+    valueEl.textContent = value;
+    el.appendChild(valueEl);
+  }
+}
+
+function showPreformatted(id, label, text) {
+  const el = $(id);
+  el.classList.remove('is-error');
+  el.replaceChildren();
+  el.style.display = 'block';
+
+  const labelEl = document.createElement('span');
+  labelEl.className = 'vd-label';
+  labelEl.textContent = label;
+  el.appendChild(labelEl);
+
+  const pre = document.createElement('pre');
+  pre.textContent = text;
+  el.appendChild(pre);
+}
+
+function showError(id, message) {
+  const el = $(id);
+  el.classList.add('is-error');
+  el.replaceChildren();
+  el.style.display = 'block';
+
+  const labelEl = document.createElement('span');
+  labelEl.className = 'vd-label';
+  labelEl.textContent = 'Error';
+  el.appendChild(labelEl);
+
+  const msg = document.createElement('span');
+  msg.textContent = message;
+  el.appendChild(msg);
+}
+
+/* ---------- Extension status ---------- */
+
+function updateExtensionStatus() {
+  const statusEl = $('extensionStatus');
+  const infoEl = $('extensionInfo');
+  const installCard = $('installationCard');
+
+  infoEl.replaceChildren();
+
+  if (typeof window.nostr !== 'undefined') {
+    statusEl.className = 'status-dot active';
+    installCard.style.display = 'none';
+
+    const line = document.createElement('div');
+    line.className = 'status-line';
+
+    const title = document.createElement('span');
+    title.textContent = 'Podkey detected';
+    line.appendChild(title);
+
+    const badge = document.createElement('span');
+    badge.className = 'badge badge-success';
+    badge.textContent = 'Active';
+    line.appendChild(badge);
+
+    const meta = document.createElement('div');
+    meta.className = 'status-meta';
+    meta.textContent =
+      'window.nostr is available for did:nostr and Solid authentication.';
+
+    infoEl.appendChild(line);
+    infoEl.appendChild(meta);
+
+    log('Podkey extension detected — window.nostr is available', 'success');
+  } else {
+    statusEl.className = 'status-dot error';
+    installCard.style.display = 'block';
+
+    const line = document.createElement('div');
+    line.className = 'status-line';
+
+    const title = document.createElement('span');
+    title.textContent = 'Podkey not found';
+    line.appendChild(title);
+
+    const badge = document.createElement('span');
+    badge.className = 'badge badge-error';
+    badge.textContent = 'Not installed';
+    line.appendChild(badge);
+
+    const meta = document.createElement('div');
+    meta.className = 'status-meta';
+    meta.textContent =
+      'window.nostr is undefined. Install the extension to enable did:nostr and Solid support.';
+
+    infoEl.appendChild(line);
+    infoEl.appendChild(meta);
+
+    log('Podkey extension not found — window.nostr is undefined', 'error');
+  }
+}
+
+/* ---------- Tests ---------- */
+
+function requireNostr() {
+  if (!window.nostr) {
+    throw new Error('window.nostr is not available');
+  }
+  return window.nostr;
+}
+
+async function testGetPublicKey() {
+  log('Testing getPublicKey()…', 'info');
+  try {
+    const nostr = requireNostr();
+    const pubkey = await nostr.getPublicKey();
+    showResult('publicKeyResult', [
+      ['Public key', pubkey],
+      ['DID', `did:nostr:${pubkey}`]
+    ]);
+    log(`getPublicKey() succeeded: ${pubkey.substring(0, 16)}…`, 'success');
+  } catch (error) {
+    log(`getPublicKey() failed: ${error.message}`, 'error');
+    showError('publicKeyResult', error.message);
+  }
+}
+
+async function testKeypairStatus() {
+  log('Testing keypair status…', 'info');
+  try {
+    const nostr = requireNostr();
+    const pubkey = await nostr.getPublicKey();
+    showResult('keypairStatusResult', [
+      ['Status', 'Keypair exists'],
+      ['Public key', `${pubkey.substring(0, 32)}…`],
+      ['Length', `${pubkey.length} characters`]
+    ]);
+    log(`Keypair exists: ${pubkey.length}-char hex key`, 'success');
+  } catch (error) {
+    log(`Keypair check failed: ${error.message}`, 'error');
+    showError('keypairStatusResult', error.message);
+  }
+}
+
+async function testSignSimpleEvent() {
+  log('Testing signEvent() with a simple event…', 'info');
+  try {
+    const nostr = requireNostr();
+    const event = {
+      kind: 1,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [],
+      content: 'Hello from the Podkey test page!'
+    };
+    const signed = await nostr.signEvent(event);
+    showPreformatted(
+      'signEventResult',
+      'Signed event',
+      JSON.stringify(signed, null, 2)
+    );
+    log(`signEvent() succeeded — event id ${signed.id.substring(0, 16)}…`, 'success');
+  } catch (error) {
+    log(`signEvent() failed: ${error.message}`, 'error');
+    showError('signEventResult', error.message);
+  }
+}
+
+async function testSignTextNote() {
+  log('Testing signEvent() with a text note…', 'info');
+  try {
+    const nostr = requireNostr();
+    const event = {
+      kind: 1,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [],
+      content:
+        'This is a test note from the Podkey test page. Testing NIP-07 compatibility.'
+    };
+    const signed = await nostr.signEvent(event);
+    log(`Text note signed — id ${signed.id.substring(0, 16)}…`, 'success');
+    log(`Content: "${signed.content.substring(0, 50)}…"`, 'info');
+  } catch (error) {
+    log(`Text note signing failed: ${error.message}`, 'error');
+  }
+}
+
+async function testSignWithTags() {
+  log('Testing signEvent() with tags…', 'info');
+  try {
+    const nostr = requireNostr();
+    const event = {
+      kind: 1,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [
+        ['t', 'podkey'],
+        ['t', 'test'],
+        ['p', '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d']
+      ],
+      content: 'Testing event with tags #podkey #test'
+    };
+    const signed = await nostr.signEvent(event);
+    log(`Event with tags signed — id ${signed.id.substring(0, 16)}…`, 'success');
+    log(`Tags: ${signed.tags.length} included`, 'info');
+  } catch (error) {
+    log(`Tagged event signing failed: ${error.message}`, 'error');
+  }
+}
+
+/* ---------- Wiring ---------- */
+
+const ACTIONS = {
+  getPublicKey: testGetPublicKey,
+  keypairStatus: testKeypairStatus,
+  signSimple: testSignSimpleEvent,
+  signTextNote: testSignTextNote,
+  signWithTags: testSignWithTags,
+  clearLog
+};
+
+function wireActions() {
+  document.querySelectorAll('[data-action]').forEach(btn => {
+    const handler = ACTIONS[btn.dataset.action];
+    if (handler) btn.addEventListener('click', handler);
+  });
+}
+
+function init() {
+  wireActions();
+  log('Initialising test page…', 'info');
+  setTimeout(updateExtensionStatus, 100);
+}
+
+window.addEventListener('nostr-ready', () => {
+  log('nostr-ready event fired', 'success');
+  updateExtensionStatus();
+});
+
+if (document.readyState === 'loading') {
+  document.addEventListener('DOMContentLoaded', init);
+} else {
+  init();
+}
+
+// Re-check periodically in case the provider injects late.
+setInterval(() => {
+  if (typeof window.nostr === 'undefined') {
+    const statusEl = $('extensionStatus');
+    if (statusEl && statusEl.className.includes('active')) {
+      updateExtensionStatus();
+    }
+  }
+}, 2000);
diff --git a/test-page/index.html b/test-page/index.html
index 34f33b1..399bd21 100644
--- a/test-page/index.html
+++ b/test-page/index.html
@@ -3,896 +3,219 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Podkey Test Page - NIP-07 Diagnostics</title>
-    <style>
-      * {
-        box-sizing: border-box;
-        margin: 0;
-        padding: 0;
-      }
-
-      body {
-        font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto',
-          'Oxygen', 'Ubuntu', 'Cantarell', sans-serif;
-        background: linear-gradient(
-          135deg,
-          #fef5ff 0%,
-          #f0f9ff 50%,
-          #fef3c7 100%
-        );
-        color: #334155;
-        padding: 20px;
-        min-height: 100vh;
-      }
-
-      .container {
-        max-width: 900px;
-        margin: 0 auto;
-      }
-
-      .header {
-        text-align: center;
-        margin-bottom: 32px;
-        padding: 24px;
-        background: rgba(255, 255, 255, 0.8);
-        backdrop-filter: blur(10px);
-        border-radius: 16px;
-        box-shadow: 0 4px 12px rgba(168, 85, 247, 0.1);
-      }
-
-      .header h1 {
-        font-size: 32px;
-        background: linear-gradient(135deg, #7c3aed 0%, #3b82f6 100%);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        background-clip: text;
-        margin-bottom: 8px;
-      }
-
-      .header p {
-        color: #64748b;
-        font-size: 14px;
-      }
-
-      .status-card {
-        background: rgba(255, 255, 255, 0.9);
-        backdrop-filter: blur(10px);
-        border: 1px solid rgba(168, 85, 247, 0.2);
-        border-radius: 12px;
-        padding: 20px;
-        margin-bottom: 20px;
-        box-shadow: 0 4px 12px rgba(168, 85, 247, 0.08);
-      }
-
-      .status-card h2 {
-        font-size: 18px;
-        color: #7c3aed;
-        margin-bottom: 16px;
-        display: flex;
-        align-items: center;
-        gap: 8px;
-      }
-
-      .status-indicator {
-        display: inline-block;
-        width: 12px;
-        height: 12px;
-        border-radius: 50%;
-        background: #cbd5e1;
-        animation: pulse 2s infinite;
-      }
-
-      .status-indicator.active {
-        background: #10b981;
-        box-shadow: 0 0 8px rgba(16, 185, 129, 0.5);
-      }
-
-      .status-indicator.error {
-        background: #ef4444;
-        box-shadow: 0 0 8px rgba(239, 68, 68, 0.5);
-      }
-
-      @keyframes pulse {
-        0%,
-        100% {
-          opacity: 1;
-        }
-        50% {
-          opacity: 0.5;
-        }
-      }
-
-      .test-button {
-        background: linear-gradient(135deg, #a78bfa 0%, #7c3aed 100%);
-        color: white;
-        border: none;
-        padding: 12px 24px;
-        border-radius: 8px;
-        font-size: 14px;
-        font-weight: 600;
-        cursor: pointer;
-        transition: all 0.2s;
-        margin-right: 8px;
-        margin-bottom: 8px;
-      }
-
-      .test-button:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 6px 20px rgba(124, 58, 237, 0.35);
-      }
-
-      .test-button:disabled {
-        opacity: 0.5;
-        cursor: not-allowed;
-        transform: none;
-      }
-
-      .log {
-        background: #1e293b;
-        color: #e2e8f0;
-        padding: 16px;
-        border-radius: 8px;
-        font-family: 'Monaco', 'Menlo', 'Courier New', monospace;
-        font-size: 12px;
-        max-height: 400px;
-        overflow-y: auto;
-        margin-top: 12px;
-      }
-
-      .log-entry {
-        margin-bottom: 8px;
-        padding: 4px 0;
-        border-bottom: 1px solid rgba(255, 255, 255, 0.1);
-      }
-
-      .log-entry:last-child {
-        border-bottom: none;
-      }
-
-      .log-time {
-        color: #64748b;
-        margin-right: 8px;
-      }
-
-      .log-success {
-        color: #10b981;
-      }
-
-      .log-error {
-        color: #ef4444;
-      }
-
-      .log-info {
-        color: #3b82f6;
-      }
-
-      .log-warn {
-        color: #f59e0b;
-      }
-
-      .value-display {
-        background: #f8fafc;
-        border: 1px solid #e2e8f0;
-        border-radius: 6px;
-        padding: 12px;
-        font-family: 'Monaco', 'Menlo', 'Courier New', monospace;
-        font-size: 11px;
-        word-break: break-all;
-        margin-top: 8px;
-        color: #475569;
-      }
-
-      .grid {
-        display: grid;
-        grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-        gap: 16px;
-        margin-bottom: 20px;
-      }
-
-      .badge {
-        display: inline-block;
-        padding: 4px 8px;
-        border-radius: 4px;
-        font-size: 11px;
-        font-weight: 600;
-        margin-left: 8px;
-      }
-
-      .badge-success {
-        background: #d1fae5;
-        color: #065f46;
-      }
-
-      .badge-error {
-        background: #fee2e2;
-        color: #991b1b;
-      }
-
-      .badge-info {
-        background: #dbeafe;
-        color: #1e40af;
-      }
-    </style>
+    <meta
+      name="description"
+      content="Podkey — a browser extension for did:nostr and Solid authentication. Detect, install, and test NIP-07 signing."
+    />
+    <title>Podkey — Install &amp; Test</title>
+    <link rel="stylesheet" href="app.css" />
   </head>
   <body>
     <div class="container">
-      <div class="header">
-        <h1>🔑 Podkey Test Page</h1>
-        <p>Real-time diagnostics for NIP-07 extension testing</p>
-        <p style="margin-top: 12px; font-size: 13px; color: #64748b">
-          Extension for <strong>did:nostr</strong> and
-          <strong>Solid</strong> authentication
+      <header class="header">
+        <div class="brand">
+          <div class="brand-mark" aria-hidden="true">
+            <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+              <circle cx="8" cy="15" r="4" />
+              <path d="M10.85 12.15 19 4" />
+              <path d="m18 5 2 2" />
+              <path d="m15 8 2 2" />
+            </svg>
+          </div>
+          <h1>Podkey</h1>
+        </div>
+        <p class="tagline">
+          A browser extension for <strong>did:nostr</strong> and
+          <strong>Solid</strong> authentication. Your keys stay on your device;
+          every signature needs your explicit approval.
         </p>
-      </div>
+      </header>
 
-      <div class="status-card" id="installationCard" style="display: none">
-        <div style="text-align: center; margin-bottom: 24px">
-          <h2 style="margin-bottom: 8px">📦 Install Podkey Extension</h2>
-          <p style="color: #64748b; font-size: 14px">
-            Get started with <strong>did:nostr</strong> and
-            <strong>Solid</strong> authentication
-          </p>
-        </div>
+      <!-- Extension status -->
+      <section class="card">
+        <h2>
+          <span class="status-dot" id="extensionStatus" aria-hidden="true"></span>
+          Extension status
+        </h2>
+        <div id="extensionInfo">Checking…</div>
+      </section>
 
-        <div
-          style="
-            background: #f8fafc;
-            padding: 16px;
-            border-radius: 12px;
-            margin-bottom: 20px;
-            border-left: 4px solid #7c3aed;
-          "
-        >
-          <p style="margin-bottom: 8px; font-size: 15px">
-            <strong>What is Podkey?</strong>
-          </p>
-          <p style="font-size: 14px; color: #475569; line-height: 1.6">
-            Podkey is a browser extension that provides
-            <strong>NIP-07</strong> wallet functionality for the Nostr protocol.
-            It enables seamless authentication to
-            <strong>Solid pods</strong> using
-            <strong>did:nostr</strong> decentralized identifiers. Your
-            cryptographic keys stay secure in your browser, giving you full
-            control over your identity and data.
-          </p>
-        </div>
+      <!-- Install (shown only when not detected) -->
+      <section class="card" id="installationCard" style="display: none">
+        <h2>
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+            <polyline points="7 10 12 15 17 10" />
+            <line x1="12" y1="15" x2="12" y2="3" />
+          </svg>
+          Install Podkey
+        </h2>
+        <p>
+          Podkey provides <strong>NIP-07</strong> signing for Nostr and
+          authenticates to <strong>Solid pods</strong> using
+          <strong>did:nostr</strong> identifiers. Your cryptographic keys stay
+          in your browser — you stay in control of your identity and data.
+        </p>
 
-        <h3 style="margin-bottom: 16px; font-size: 18px; color: #1e293b">
-          Quick Installation (Recommended)
-        </h3>
-        <div style="line-height: 1.8; font-size: 14px">
-          <ol
-            style="
-              margin-left: 20px;
-              margin-top: 12px;
-              counter-reset: step-counter;
-            "
-          >
-            <li style="margin-bottom: 20px; padding-left: 8px">
-              <strong style="color: #7c3aed"
-                >Step 1: Download the Extension</strong
-              ><br />
-              <div style="margin-top: 8px; margin-bottom: 4px">
-                Download the latest release from GitHub:
-              </div>
-              <div style="margin-top: 8px; margin-bottom: 8px">
+        <div class="divider"></div>
+
+        <h3>Quick install</h3>
+        <ol class="steps">
+          <li>
+            <div class="step-title">Download the extension</div>
+            <div class="step-body">
+              Grab the latest packaged release, or the source ZIP from the
+              repository.
+              <div style="margin-top: 10px">
                 <a
+                  class="btn-link"
                   href="https://github.com/JavaScriptSolidServer/podkey/releases/latest"
                   target="_blank"
-                  style="
-                    display: inline-block;
-                    background: #7c3aed;
-                    color: white;
-                    padding: 10px 20px;
-                    border-radius: 6px;
-                    text-decoration: none;
-                    font-weight: 600;
-                    font-size: 14px;
-                  "
-                  >📦 Download Latest Release</a
+                  rel="noopener"
                 >
+                  Download latest release
+                </a>
               </div>
-              <div style="margin-top: 6px; font-size: 12px; color: #64748b">
-                Or download the source code as a ZIP file from the
-                <a
-                  href="https://github.com/JavaScriptSolidServer/podkey"
-                  target="_blank"
-                  style="color: #7c3aed; font-weight: 600"
-                  >GitHub repository</a
-                >
-                (click the green "Code" button → "Download ZIP")
-              </div>
-            </li>
-            <li style="margin-bottom: 20px; padding-left: 8px">
-              <strong style="color: #7c3aed"
-                >Step 2: Extract and Build (if needed)</strong
-              ><br />
-              <div style="margin-top: 8px; margin-bottom: 4px">
-                If you downloaded a release ZIP, extract it. If you downloaded
-                the source code, you'll need to build it:
-              </div>
-              <div
-                style="
-                  background: #fef3c7;
-                  padding: 12px;
-                  border-radius: 8px;
-                  margin-top: 8px;
-                  border: 1px solid #fbbf24;
-                "
-              >
-                <p style="margin: 0 0 8px 0; font-size: 13px">
-                  <strong>📋 Building from source requires:</strong>
-                  <a
-                    href="https://nodejs.org/"
-                    target="_blank"
-                    style="color: #7c3aed; font-weight: 600"
-                    >Node.js v18+</a
-                  >
-                </p>
-                <code
-                  style="
-                    display: block;
-                    background: #1e293b;
-                    color: #e2e8f0;
-                    padding: 10px;
-                    border-radius: 6px;
-                    font-size: 12px;
-                    font-family: 'Courier New', monospace;
-                    margin-top: 6px;
-                    overflow-x: auto;
-                  "
-                >
-                  cd podkey<br />
-                  npm install<br />
-                  npm run build
-                </code>
-              </div>
-            </li>
-            <li style="margin-bottom: 20px; padding-left: 8px">
-              <strong style="color: #7c3aed"
-                >Step 3: Load Extension in Chrome/Edge</strong
-              ><br />
-              <div style="margin-top: 8px; margin-bottom: 8px">
-                Follow these steps in your browser:
-              </div>
-              <ul
-                style="
-                  margin-left: 20px;
-                  margin-top: 4px;
-                  list-style-type: disc;
-                "
-              >
-                <li style="margin-bottom: 6px">
-                  Open <strong>chrome://extensions/</strong> (or
-                  <strong>edge://extensions/</strong> for Edge) in a new tab
-                </li>
-                <li style="margin-bottom: 6px">
-                  Enable <strong>"Developer mode"</strong> using the toggle in
-                  the top-right corner
-                </li>
-                <li style="margin-bottom: 6px">
-                  Click the <strong>"Load unpacked"</strong> button that appears
-                </li>
-                <li style="margin-bottom: 6px">
-                  Navigate to and select the
-                  <code
-                    style="
-                      background: #f1f5f9;
-                      padding: 2px 6px;
-                      border-radius: 4px;
-                      font-size: 11px;
-                    "
-                    >podkey</code
-                  >
-                  directory (the one containing
-                  <code
-                    style="
-                      background: #f1f5f9;
-                      padding: 2px 6px;
-                      border-radius: 4px;
-                      font-size: 11px;
-                    "
-                    >manifest.json</code
-                  >)
-                </li>
+            </div>
+          </li>
+
+          <li>
+            <div class="step-title">Build, if you downloaded source</div>
+            <div class="step-body">
+              Requires
+              <a href="https://nodejs.org/" target="_blank" rel="noopener">Node.js 18+</a>.
+              <pre class="code-block">cd podkey
+npm install
+npm run build</pre>
+            </div>
+          </li>
+
+          <li>
+            <div class="step-title">Load it in Chrome or Edge</div>
+            <div class="step-body">
+              <ul>
+                <li>Open <code class="inline">chrome://extensions</code> (or <code class="inline">edge://extensions</code>).</li>
+                <li>Enable <strong>Developer mode</strong> (top-right).</li>
+                <li>Click <strong>Load unpacked</strong>.</li>
+                <li>Select the <code class="inline">podkey</code> folder containing <code class="inline">manifest.json</code>.</li>
               </ul>
-            </li>
-            <li style="margin-bottom: 20px; padding-left: 8px">
-              <strong style="color: #7c3aed">Step 4: Verify Installation</strong
-              ><br />
-              <div style="margin-top: 8px">
-                <strong>Reload this page</strong> (F5 or Ctrl+R) and the
-                extension should be detected! You'll see a green checkmark above
-                and can start testing Podkey's features.
-              </div>
-            </li>
-          </ol>
-
-          <div
-            style="
-              background: #f1f5f9;
-              padding: 16px;
-              border-radius: 8px;
-              margin-top: 24px;
-              border: 1px solid #cbd5e1;
-            "
-          >
-            <p style="margin: 0 0 12px 0; font-size: 14px">
-              <strong>🔧 For Developers: Build from Source</strong>
-            </p>
-            <p style="margin: 0 0 8px 0; font-size: 13px; color: #475569">
-              If you want the latest code or plan to contribute, you can clone
-              and build from the repository:
-            </p>
-            <code
-              style="
-                display: block;
-                background: #1e293b;
-                color: #e2e8f0;
-                padding: 10px;
-                border-radius: 6px;
-                font-size: 12px;
-                font-family: 'Courier New', monospace;
-                margin-top: 6px;
-                overflow-x: auto;
-              "
-            >
-              git clone https://github.com/JavaScriptSolidServer/podkey.git<br />
-              cd podkey<br />
-              npm install<br />
-              npm run build
-            </code>
-            <p style="margin: 8px 0 0 0; font-size: 12px; color: #64748b">
-              Then follow Step 3 above to load the extension.
-            </p>
-          </div>
-
-          <div
-            style="
-              background: #ecfdf5;
-              padding: 16px;
-              border-radius: 8px;
-              margin-top: 16px;
-              border: 1px solid #10b981;
-            "
-          >
-            <p style="margin: 0 0 8px 0; font-size: 14px">
-              <strong>✅ First Time Setup:</strong> After installation, click
-              the Podkey extension icon in your browser toolbar to generate or
-              import your first keypair. This creates your
-              <strong>did:nostr</strong> identity!
-            </p>
-          </div>
+            </div>
+          </li>
+
+          <li>
+            <div class="step-title">Verify</div>
+            <div class="step-body">
+              <strong>Reload this page.</strong> The status above turns green
+              when the extension is detected, and these tests become live.
+            </div>
+          </li>
+        </ol>
+
+        <div class="notice good">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M22 11.08V12a10 10 0 1 1-5.93-9.14" />
+            <polyline points="22 4 12 14.01 9 11.01" />
+          </svg>
+          <span>
+            <strong>First run:</strong> open the Podkey icon in your toolbar to
+            generate or import your first key — that creates your
+            <strong>did:nostr</strong> identity.
+          </span>
+        </div>
 
-          <div
-            style="
-              background: #fef3c7;
-              padding: 16px;
-              border-radius: 8px;
-              margin-top: 16px;
-              border: 1px solid #fbbf24;
-            "
-          >
-            <p style="margin: 0 0 12px 0; font-size: 14px">
-              <strong>💡 Learn More:</strong>
-            </p>
-            <ul
-              style="
-                margin: 0;
-                padding-left: 20px;
-                font-size: 13px;
-                line-height: 1.8;
-              "
-            >
-              <li>
-                <a
-                  href="https://github.com/JavaScriptSolidServer/podkey"
-                  target="_blank"
-                  style="color: #7c3aed; font-weight: 600"
-                  >📚 GitHub Repository</a
-                >
-                - Source code and documentation
-              </li>
-              <li>
-                <a
-                  href="https://nostrcg.github.io/did-nostr/"
-                  target="_blank"
-                  style="color: #7c3aed; font-weight: 600"
-                  >🔗 did:nostr Specification</a
-                >
-                - Learn about Nostr DIDs
-              </li>
-              <li>
-                <a
-                  href="https://solidproject.org/"
-                  target="_blank"
-                  style="color: #7c3aed; font-weight: 600"
-                  >🌐 Solid Project</a
-                >
-                - Decentralized web platform
-              </li>
-              <li>
-                <a
-                  href="https://github.com/nostr-protocol/nips/blob/master/07.md"
-                  target="_blank"
-                  style="color: #7c3aed; font-weight: 600"
-                  >📖 NIP-07 Specification</a
-                >
-                - Nostr wallet standard
-              </li>
-            </ul>
-          </div>
+        <div class="notice info">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <circle cx="12" cy="12" r="10" />
+            <line x1="12" y1="16" x2="12" y2="12" />
+            <line x1="12" y1="8" x2="12.01" y2="8" />
+          </svg>
+          <span>
+            <strong>Learn more:</strong>
+            <a href="https://github.com/JavaScriptSolidServer/podkey" target="_blank" rel="noopener">repository</a>,
+            <a href="https://nostrcg.github.io/did-nostr/" target="_blank" rel="noopener">did:nostr spec</a>,
+            <a href="https://solidproject.org/" target="_blank" rel="noopener">Solid Project</a>,
+            <a href="https://github.com/nostr-protocol/nips/blob/master/07.md" target="_blank" rel="noopener">NIP-07</a>.
+          </span>
+        </div>
 
-          <div
-            style="
-              background: #fee2e2;
-              padding: 16px;
-              border-radius: 8px;
-              margin-top: 16px;
-              border: 1px solid #ef4444;
-            "
-          >
-            <p style="margin: 0 0 8px 0; font-size: 14px">
-              <strong>🔧 Troubleshooting:</strong>
-            </p>
-            <ul
-              style="
-                margin: 0;
-                padding-left: 20px;
-                font-size: 13px;
-                line-height: 1.8;
-              "
-            >
-              <li>
-                <strong>Extension not detected?</strong> Make sure you reloaded
-                this page after installation
-              </li>
-              <li>
-                <strong>Build errors?</strong> Ensure Node.js v18+ is installed:
-                <code
-                  style="
-                    background: #f1f5f9;
-                    padding: 2px 4px;
-                    border-radius: 3px;
-                    font-size: 11px;
-                  "
-                  >node --version</code
-                >
-              </li>
-              <li>
-                <strong>Can't find "Load unpacked"?</strong> Developer mode must
-                be enabled first
-              </li>
-              <li>
-                <strong>Extension icon not showing?</strong> Check
-                chrome://extensions/ to ensure it's enabled
-              </li>
+        <div class="notice warn">
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M10.29 3.86 1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z" />
+            <line x1="12" y1="9" x2="12" y2="13" />
+            <line x1="12" y1="17" x2="12.01" y2="17" />
+          </svg>
+          <span>
+            <strong>Troubleshooting:</strong>
+            <ul>
+              <li>Not detected? Reload this page after loading the extension.</li>
+              <li>Build errors? Check <code class="inline">node --version</code> is 18+.</li>
+              <li>No “Load unpacked”? Enable Developer mode first.</li>
             </ul>
-          </div>
+          </span>
         </div>
-      </div>
+      </section>
 
-      <div class="status-card">
+      <!-- Key management -->
+      <section class="card">
         <h2>
-          <span class="status-indicator" id="extensionStatus"></span>
-          Extension Status
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <rect x="3" y="11" width="18" height="11" rx="2" ry="2" />
+            <path d="M7 11V7a5 5 0 0 1 10 0v4" />
+          </svg>
+          Key management
         </h2>
-        <div id="extensionInfo">Checking...</div>
-      </div>
-
-      <div class="status-card">
-        <h2>🔐 Key Management</h2>
-        <div class="grid">
-          <div>
-            <button class="test-button" onclick="testGetPublicKey()">
-              Get Public Key
-            </button>
-            <div
-              id="publicKeyResult"
-              class="value-display"
-              style="display: none"
-            ></div>
+        <div class="test-grid">
+          <div class="test-cell">
+            <button class="btn" type="button" data-action="getPublicKey">Get public key</button>
+            <div id="publicKeyResult" class="value-display" style="display: none"></div>
           </div>
-          <div>
-            <button class="test-button" onclick="testKeypairStatus()">
-              Check Keypair Status
-            </button>
-            <div
-              id="keypairStatusResult"
-              class="value-display"
-              style="display: none"
-            ></div>
+          <div class="test-cell">
+            <button class="btn" type="button" data-action="keypairStatus">Check keypair status</button>
+            <div id="keypairStatusResult" class="value-display" style="display: none"></div>
           </div>
         </div>
-      </div>
+      </section>
 
-      <div class="status-card">
-        <h2>✍️ Event Signing</h2>
-        <div class="grid">
-          <div>
-            <button class="test-button" onclick="testSignSimpleEvent()">
-              Sign Simple Event
-            </button>
-          </div>
-          <div>
-            <button class="test-button" onclick="testSignTextNote()">
-              Sign Text Note
-            </button>
-          </div>
-          <div>
-            <button class="test-button" onclick="testSignWithTags()">
-              Sign with Tags
-            </button>
-          </div>
+      <!-- Event signing -->
+      <section class="card">
+        <h2>
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M12 20h9" />
+            <path d="M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4 12.5-12.5z" />
+          </svg>
+          Event signing
+        </h2>
+        <div>
+          <button class="btn" type="button" data-action="signSimple">Sign simple event</button>
+          <button class="btn" type="button" data-action="signTextNote">Sign text note</button>
+          <button class="btn" type="button" data-action="signWithTags">Sign with tags</button>
         </div>
-        <div
-          id="signEventResult"
-          class="value-display"
-          style="display: none"
-        ></div>
-      </div>
+        <div id="signEventResult" class="value-display" style="display: none"></div>
+      </section>
 
-      <div class="status-card">
-        <h2>📊 Event Log</h2>
-        <div class="log" id="eventLog">
-          <div class="log-entry">
-            <span class="log-time">[00:00:00]</span>
-            <span class="log-info">Initializing test page...</span>
-          </div>
-        </div>
-        <button
-          class="test-button"
-          onclick="clearLog()"
-          style="margin-top: 12px"
-        >
-          Clear Log
+      <!-- Log -->
+      <section class="card">
+        <h2>
+          <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" />
+            <polyline points="14 2 14 8 20 8" />
+            <line x1="16" y1="13" x2="8" y2="13" />
+            <line x1="16" y1="17" x2="8" y2="17" />
+          </svg>
+          Event log
+        </h2>
+        <div class="log" id="eventLog"></div>
+        <button class="btn secondary" type="button" data-action="clearLog" style="margin-top: 12px">
+          Clear log
         </button>
-      </div>
-    </div>
+      </section>
 
-    <script>
-      let logCount = 0
-
-      function log(message, type = 'info') {
-        const logEl = document.getElementById('eventLog')
-        const time = new Date().toLocaleTimeString()
-        const entry = document.createElement('div')
-        entry.className = 'log-entry'
-
-        const timeSpan = document.createElement('span')
-        timeSpan.className = 'log-time'
-        timeSpan.textContent = `[${time}]`
-
-        const messageSpan = document.createElement('span')
-        messageSpan.className = `log-${type}`
-        messageSpan.textContent = message
-
-        entry.appendChild(timeSpan)
-        entry.appendChild(messageSpan)
-        logEl.insertBefore(entry, logEl.firstChild)
-
-        logCount++
-        if (logCount > 100) {
-          // Keep only last 100 entries
-          while (logEl.children.length > 100) {
-            logEl.removeChild(logEl.lastChild)
-          }
-        }
-      }
-
-      function clearLog() {
-        document.getElementById('eventLog').innerHTML = ''
-        logCount = 0
-        log('Log cleared', 'info')
-      }
-
-      function updateExtensionStatus() {
-        const statusEl = document.getElementById('extensionStatus')
-        const infoEl = document.getElementById('extensionInfo')
-        const installCard = document.getElementById('installationCard')
-
-        if (typeof window.nostr !== 'undefined') {
-          statusEl.className = 'status-indicator active'
-          installCard.style.display = 'none'
-          infoEl.innerHTML = `
-          <strong>✅ Podkey Extension Detected</strong>
-          <span class="badge badge-success">Active</span>
-          <div style="margin-top: 8px; font-size: 12px; color: #64748b;">
-            window.nostr is available for <strong>did:nostr</strong> and <strong>Solid</strong> authentication
-          </div>
-        `
-          log(
-            'Podkey extension detected - window.nostr is available',
-            'success'
-          )
-        } else {
-          statusEl.className = 'status-indicator error'
-          installCard.style.display = 'block'
-          infoEl.innerHTML = `
-          <strong>❌ Podkey Extension Not Found</strong>
-          <span class="badge badge-error">Not Installed</span>
-          <div style="margin-top: 8px; font-size: 12px; color: #64748b;">
-            window.nostr is undefined. Install the extension for <strong>did:nostr</strong> and <strong>Solid</strong> support.
-          </div>
-        `
-          log('Podkey extension not found - window.nostr is undefined', 'error')
-        }
-      }
-
-      async function testGetPublicKey() {
-        log('Testing getPublicKey()...', 'info')
-        try {
-          if (!window.nostr) {
-            throw new Error('window.nostr is not available')
-          }
-
-          const pubkey = await window.nostr.getPublicKey()
-          const resultEl = document.getElementById('publicKeyResult')
-          resultEl.style.display = 'block'
-          resultEl.innerHTML = `
-          <strong>Public Key:</strong><br>
-          ${pubkey}<br><br>
-          <strong>DID:</strong><br>
-          did:nostr:${pubkey}
-        `
-          log(
-            `✅ getPublicKey() succeeded: ${pubkey.substring(0, 16)}...`,
-            'success'
-          )
-        } catch (error) {
-          log(`❌ getPublicKey() failed: ${error.message}`, 'error')
-          const resultEl = document.getElementById('publicKeyResult')
-          resultEl.style.display = 'block'
-          resultEl.innerHTML = `<strong style="color: #ef4444;">Error:</strong> ${error.message}`
-        }
-      }
-
-      async function testKeypairStatus() {
-        log('Testing keypair status...', 'info')
-        try {
-          if (!window.nostr) {
-            throw new Error('window.nostr is not available')
-          }
-
-          const pubkey = await window.nostr.getPublicKey()
-          const resultEl = document.getElementById('keypairStatusResult')
-          resultEl.style.display = 'block'
-          resultEl.innerHTML = `
-          <strong>Status:</strong> Keypair exists<br>
-          <strong>Public Key:</strong> ${pubkey.substring(0, 32)}...<br>
-          <strong>Length:</strong> ${pubkey.length} characters
-        `
-          log(`✅ Keypair exists: ${pubkey.length}-char hex key`, 'success')
-        } catch (error) {
-          log(`❌ Keypair check failed: ${error.message}`, 'error')
-          const resultEl = document.getElementById('keypairStatusResult')
-          resultEl.style.display = 'block'
-          resultEl.innerHTML = `<strong style="color: #ef4444;">Error:</strong> ${error.message}`
-        }
-      }
-
-      async function testSignSimpleEvent() {
-        log('Testing signEvent() with simple event...', 'info')
-        try {
-          if (!window.nostr) {
-            throw new Error('window.nostr is not available')
-          }
-
-          const event = {
-            kind: 1,
-            created_at: Math.floor(Date.now() / 1000),
-            tags: [],
-            content: 'Hello from Podkey test page!'
-          }
-
-          const signed = await window.nostr.signEvent(event)
-          const resultEl = document.getElementById('signEventResult')
-          resultEl.style.display = 'block'
-          resultEl.innerHTML = `
-          <strong>Signed Event:</strong><br>
-          <pre style="white-space: pre-wrap; font-size: 10px;">${JSON.stringify(
-            signed,
-            null,
-            2
-          )}</pre>
-        `
-          log(
-            `✅ signEvent() succeeded - Event ID: ${signed.id.substring(
-              0,
-              16
-            )}...`,
-            'success'
-          )
-        } catch (error) {
-          log(`❌ signEvent() failed: ${error.message}`, 'error')
-          const resultEl = document.getElementById('signEventResult')
-          resultEl.style.display = 'block'
-          resultEl.innerHTML = `<strong style="color: #ef4444;">Error:</strong> ${error.message}`
-        }
-      }
-
-      async function testSignTextNote() {
-        log('Testing signEvent() with text note...', 'info')
-        try {
-          if (!window.nostr) {
-            throw new Error('window.nostr is not available')
-          }
-
-          const event = {
-            kind: 1,
-            created_at: Math.floor(Date.now() / 1000),
-            tags: [],
-            content:
-              'This is a test note from the Podkey test page. Testing NIP-07 compatibility! 🔑'
-          }
-
-          const signed = await window.nostr.signEvent(event)
-          log(
-            `✅ Text note signed - ID: ${signed.id.substring(0, 16)}...`,
-            'success'
-          )
-          log(`   Content: "${signed.content.substring(0, 50)}..."`, 'info')
-        } catch (error) {
-          log(`❌ Text note signing failed: ${error.message}`, 'error')
-        }
-      }
-
-      async function testSignWithTags() {
-        log('Testing signEvent() with tags...', 'info')
-        try {
-          if (!window.nostr) {
-            throw new Error('window.nostr is not available')
-          }
-
-          const event = {
-            kind: 1,
-            created_at: Math.floor(Date.now() / 1000),
-            tags: [
-              ['t', 'podkey'],
-              ['t', 'test'],
-              [
-                'p',
-                '3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d'
-              ]
-            ],
-            content: 'Testing event with tags #podkey #test'
-          }
-
-          const signed = await window.nostr.signEvent(event)
-          log(
-            `✅ Event with tags signed - ID: ${signed.id.substring(0, 16)}...`,
-            'success'
-          )
-          log(`   Tags: ${signed.tags.length} tags included`, 'info')
-        } catch (error) {
-          log(`❌ Tagged event signing failed: ${error.message}`, 'error')
-        }
-      }
-
-      // Listen for nostr-ready event
-      window.addEventListener('nostr-ready', () => {
-        log('nostr-ready event fired', 'success')
-        updateExtensionStatus()
-      })
-
-      // Initial check
-      if (document.readyState === 'loading') {
-        document.addEventListener('DOMContentLoaded', () => {
-          setTimeout(updateExtensionStatus, 100)
-        })
-      } else {
-        setTimeout(updateExtensionStatus, 100)
-      }
+      <footer class="page-footer">
+        Podkey ·
+        <a href="https://github.com/JavaScriptSolidServer/podkey" target="_blank" rel="noopener">GitHub</a>
+      </footer>
+    </div>
 
-      // Periodic check for extension
-      setInterval(() => {
-        if (typeof window.nostr === 'undefined') {
-          const statusEl = document.getElementById('extensionStatus')
-          if (statusEl.className.includes('active')) {
-            updateExtensionStatus()
-          }
-        }
-      }, 2000)
-    </script>
+    <script src="app.js"></script>
   </body>
 </html>

From 6e03bbccbb68dd6103a47ba9f55644b0726ba364 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:25:20 +0000
Subject: [PATCH 17/24] test: consent gate + NIP-98 token
 freshness/exact-origin coverage

Drive background.js through its captured chrome.runtime.onMessage listener
(it exports nothing and wires handlers at import time), mirroring the real
content-script / approve-popup message contract.

consent-approval.test.js (11): approve resolves the pending request; deny and
APPROVE_SIGNING{approved:false} (popup beforeunload) reject; the 60s timeout
auto-denies (and does not fire early); a late response after timeout is a
no-op; trusted+autoSign auto-signs kind-27235 Solid auth with no prompt while
other kinds and autoSign-off still prompt; approving an untrusted origin trusts
it for next time.

nip98-token.test.js (16): per-token random 16-byte nonce yields distinct event
ids/sigs for the same (url,method) within one second (no replayable duplicate);
payload tag carries the sha-256 of a string body and prefers a page-computed
bodyHash; exact-origin Solid auto-trust accepts inrupt.net and real subdomains
but rejects inrupt.net.evil.com / evilinrupt.net / non-Solid hosts; autoSign-off
and no-keypair return null instead of a header.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 test/consent-approval.test.js | 245 ++++++++++++++++++++++++++++++++++
 test/nip98-token.test.js      | 206 ++++++++++++++++++++++++++++
 2 files changed, 451 insertions(+)
 create mode 100644 test/consent-approval.test.js
 create mode 100644 test/nip98-token.test.js

diff --git a/test/consent-approval.test.js b/test/consent-approval.test.js
new file mode 100644
index 0000000..05775e0
--- /dev/null
+++ b/test/consent-approval.test.js
@@ -0,0 +1,245 @@
+/**
+ * Tests for the per-origin consent gate / signing-approval flow.
+ *
+ * background.js exports nothing and wires its handlers onto chrome.runtime at
+ * import time, so these tests drive it exactly the way the real extension does:
+ * mock `chrome`, import the module to capture the onMessage listener, then send
+ * the same messages the content script and approve popup would send.
+ *
+ * Covered (consent contract, security/signing-approval-ui #20):
+ *   - approve resolves the pending request with the result
+ *   - deny rejects the request ("User denied ...")
+ *   - the 60s timeout auto-denies
+ *   - APPROVE_SIGNING with approved:false (popup beforeunload = deny) rejects
+ *   - trusted-origin + autoSign auto-path: kind 27235 Solid auth signs with NO
+ *     prompt; any other kind still prompts even when trusted+autoSign
+ */
+
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert/strict';
+
+// --- chrome mock (session + local areas, like storage.test.js) ----------------
+function makeArea (store) {
+  return {
+    get: async (keys) => {
+      const result = {};
+      if (Array.isArray(keys)) {
+        keys.forEach((k) => { result[k] = store[k]; });
+      } else if (keys) {
+        Object.keys(keys).forEach((k) => { result[k] = store[k] ?? keys[k]; });
+      } else {
+        return { ...store };
+      }
+      return result;
+    },
+    set: async (items) => { Object.assign(store, items); },
+    remove: async (keys) => {
+      (Array.isArray(keys) ? keys : [keys]).forEach((k) => delete store[k]);
+    }
+  };
+}
+
+const stores = { local: {}, session: {} };
+const windowsCreated = [];
+const captured = { onMessage: null };
+
+global.chrome = {
+  runtime: {
+    onInstalled: { addListener: () => {} },
+    onMessage: { addListener: (fn) => { captured.onMessage = fn; } },
+    lastError: null
+  },
+  windows: {
+    create: (opts) => { windowsCreated.push(opts); return Promise.resolve({ id: windowsCreated.length }); }
+  },
+  storage: {
+    local: makeArea(stores.local),
+    session: makeArea(stores.session)
+  }
+};
+
+// Import background once (captures the onMessage listener). Storage helpers are
+// imported separately for seeding; they share the same chrome mock instance.
+await import('../src/background.js');
+const { generateKeypair } = await import('../src/crypto.js');
+const { storeKeypair, addTrustedOrigin, setAutoSign } = await import('../src/storage.js');
+
+const onMessage = captured.onMessage;
+
+/**
+ * Drain the microtask queue. handleMessage awaits several storage reads before
+ * it reaches showPermissionPrompt / chrome.windows.create; one setImmediate
+ * turn flushes that chain deterministically (and is not affected by the faked
+ * setTimeout used in the timeout tests).
+ */
+const flush = () => new Promise((resolve) => setImmediate(resolve));
+
+/** Send a message to the background and return a promise of sendResponse(). */
+function send (message) {
+  return new Promise((resolve) => { onMessage(message, {}, resolve); });
+}
+
+/** Read the requestId out of the most recently opened approval popup URL. */
+function lastRequestId () {
+  const last = windowsCreated[windowsCreated.length - 1];
+  // url is `popup/approve.html?id=...&origin=...` — parse against a dummy base
+  return new URL('https://x/' + last.url).searchParams.get('id');
+}
+
+/** Resolve a pending prompt by sending the popup's APPROVE_SIGNING message. */
+function respond (requestId, approved) {
+  onMessage({ type: 'APPROVE_SIGNING', requestId, approved }, {}, () => {});
+}
+
+const SOLID_EVENT = { kind: 27235, created_at: 1700000000, tags: [['u', 'https://pod.test/']], content: '' };
+const NOTE_EVENT = { kind: 1, created_at: 1700000000, tags: [], content: 'gm' };
+
+describe('consent gate / approval flow', () => {
+  let keypair;
+
+  beforeEach(async () => {
+    // Reset storage and the record of opened windows before every test.
+    for (const k of Object.keys(stores.local)) delete stores.local[k];
+    for (const k of Object.keys(stores.session)) delete stores.session[k];
+    windowsCreated.length = 0;
+    keypair = await generateKeypair();
+    await storeKeypair(keypair.privateKey, keypair.publicKey);
+  });
+
+  afterEach(() => { mock.timers.reset(); });
+
+  it('opens an approval popup for an untrusted origin (does not auto-resolve)', async () => {
+    const pending = send({ type: 'GET_PUBLIC_KEY', origin: 'https://untrusted.test' });
+    // Let the handler reach showPermissionPrompt / chrome.windows.create.
+    await flush();
+    assert.equal(windowsCreated.length, 1, 'exactly one approval popup should open');
+    const url = windowsCreated[0].url;
+    assert.match(url, /^popup\/approve\.html\?/);
+    const params = new URL('https://x/' + url).searchParams;
+    assert.equal(params.get('origin'), 'https://untrusted.test');
+    assert.equal(params.get('action'), 'read your public key');
+    assert.ok(params.get('id'), 'a requestId must be present');
+    // Clean up the dangling promise so the test runner doesn't hang.
+    respond(params.get('id'), true);
+    await pending;
+  });
+
+  it('approve resolves the pending request with the public key', async () => {
+    const pending = send({ type: 'GET_PUBLIC_KEY', origin: 'https://app.test' });
+    await flush();
+    respond(lastRequestId(), true);
+    const result = await pending;
+    assert.equal(result, keypair.publicKey);
+  });
+
+  it('deny rejects the request with "User denied permission"', async () => {
+    const pending = send({ type: 'GET_PUBLIC_KEY', origin: 'https://app.test' });
+    await flush();
+    respond(lastRequestId(), false);
+    const result = await pending;
+    assert.deepEqual(result, { error: 'User denied permission' });
+  });
+
+  it('APPROVE_SIGNING approved:false (popup beforeunload = deny) rejects signing', async () => {
+    const pending = send({ type: 'SIGN_EVENT', event: NOTE_EVENT, origin: 'https://app.test' });
+    await flush();
+    // The approve popup sends {approved:false} on window beforeunload (closing
+    // the window without choosing = deny). Same wire message, approved:false.
+    respond(lastRequestId(), false);
+    const result = await pending;
+    assert.deepEqual(result, { error: 'User denied signing' });
+  });
+
+  it('the 60s timeout auto-denies when the popup never responds', async () => {
+    mock.timers.enable({ apis: ['setTimeout'] });
+    const pending = send({ type: 'GET_PUBLIC_KEY', origin: 'https://slow.test' });
+    await flush();
+    assert.equal(windowsCreated.length, 1, 'popup opened, awaiting a decision');
+    // No APPROVE_SIGNING arrives. Advance just past the 60s auto-deny.
+    mock.timers.tick(60001);
+    const result = await pending;
+    assert.deepEqual(result, { error: 'User denied permission' });
+  });
+
+  it('does NOT auto-deny before 60s elapse', async () => {
+    mock.timers.enable({ apis: ['setTimeout'] });
+    const pending = send({ type: 'GET_PUBLIC_KEY', origin: 'https://app.test' });
+    await flush();
+    mock.timers.tick(59999); // one ms short of the deadline
+    // Still pending — a late approval must win the race.
+    respond(lastRequestId(), true);
+    const result = await pending;
+    assert.equal(result, keypair.publicKey);
+  });
+
+  it('a late APPROVE_SIGNING after timeout is ignored (entry already deleted)', async () => {
+    mock.timers.enable({ apis: ['setTimeout'] });
+    const pending = send({ type: 'GET_PUBLIC_KEY', origin: 'https://app.test' });
+    await flush();
+    const id = lastRequestId();
+    mock.timers.tick(60001);
+    const result = await pending;
+    assert.deepEqual(result, { error: 'User denied permission' });
+    // Late response for the same id must be a harmless no-op (no throw, no
+    // second resolution). pendingApprovals no longer holds the id.
+    assert.doesNotThrow(() => respond(id, true));
+  });
+});
+
+describe('trusted-origin auto-path (autoSign)', () => {
+  let keypair;
+
+  beforeEach(async () => {
+    for (const k of Object.keys(stores.local)) delete stores.local[k];
+    for (const k of Object.keys(stores.session)) delete stores.session[k];
+    windowsCreated.length = 0;
+    keypair = await generateKeypair();
+    await storeKeypair(keypair.privateKey, keypair.publicKey);
+  });
+
+  it('signs a kind-27235 Solid event with NO prompt when trusted + autoSign', async () => {
+    await addTrustedOrigin('https://pod.test');
+    await setAutoSign(true);
+    const result = await send({ type: 'SIGN_EVENT', event: SOLID_EVENT, origin: 'https://pod.test' });
+    assert.equal(windowsCreated.length, 0, 'auto-sign path must not open a popup');
+    assert.equal(result.kind, 27235);
+    assert.equal(result.pubkey, keypair.publicKey);
+    assert.equal(result.sig.length, 128);
+  });
+
+  it('still PROMPTS for a non-Solid kind even when trusted + autoSign', async () => {
+    await addTrustedOrigin('https://pod.test');
+    await setAutoSign(true);
+    const pending = send({ type: 'SIGN_EVENT', event: NOTE_EVENT, origin: 'https://pod.test' });
+    await flush();
+    assert.equal(windowsCreated.length, 1, 'non-Solid kind must still require approval');
+    respond(lastRequestId(), true);
+    const result = await pending;
+    assert.equal(result.kind, 1);
+  });
+
+  it('PROMPTS for a Solid event when autoSign is OFF (even if trusted)', async () => {
+    await addTrustedOrigin('https://pod.test');
+    await setAutoSign(false);
+    const pending = send({ type: 'SIGN_EVENT', event: SOLID_EVENT, origin: 'https://pod.test' });
+    await flush();
+    assert.equal(windowsCreated.length, 1, 'autoSign off must require explicit approval');
+    respond(lastRequestId(), true);
+    const result = await pending;
+    assert.equal(result.kind, 27235);
+  });
+
+  it('approving an untrusted signing request trusts the origin (no re-prompt)', async () => {
+    await setAutoSign(true);
+    // First request: untrusted -> prompt -> approve.
+    const first = send({ type: 'SIGN_EVENT', event: SOLID_EVENT, origin: 'https://new.test' });
+    await flush();
+    assert.equal(windowsCreated.length, 1);
+    respond(lastRequestId(), true);
+    await first;
+    // Second Solid request from the now-trusted origin: auto-signs, no popup.
+    const second = await send({ type: 'SIGN_EVENT', event: SOLID_EVENT, origin: 'https://new.test' });
+    assert.equal(windowsCreated.length, 1, 'origin became trusted; no second popup');
+    assert.equal(second.kind, 27235);
+  });
+});
diff --git a/test/nip98-token.test.js b/test/nip98-token.test.js
new file mode 100644
index 0000000..6f0dfd1
--- /dev/null
+++ b/test/nip98-token.test.js
@@ -0,0 +1,206 @@
+/**
+ * Tests for NIP-98 auth-header minting in the background service worker:
+ *   - token freshness: per-token random nonce -> distinct event id even for the
+ *     same (url, method) within the same second (no replayable duplicate)
+ *   - exact-origin Solid auto-trust matching (the fix for substring trust)
+ *   - body-hash `payload` tag inclusion for losslessly-crossing body types
+ *
+ * createNip98AuthHeader is module-private, so it is exercised the way the
+ * content script reaches it: via the CREATE_NIP98_AUTH_HEADER message. The
+ * returned `Nostr <base64>` header is decoded back into the signed event.
+ */
+
+import { describe, it, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+
+function makeArea (store) {
+  return {
+    get: async (keys) => {
+      const result = {};
+      if (Array.isArray(keys)) keys.forEach((k) => { result[k] = store[k]; });
+      else if (keys) Object.keys(keys).forEach((k) => { result[k] = store[k] ?? keys[k]; });
+      else return { ...store };
+      return result;
+    },
+    set: async (items) => { Object.assign(store, items); },
+    remove: async (keys) => { (Array.isArray(keys) ? keys : [keys]).forEach((k) => delete store[k]); }
+  };
+}
+
+const stores = { local: {}, session: {} };
+const captured = { onMessage: null };
+
+global.chrome = {
+  runtime: {
+    onInstalled: { addListener: () => {} },
+    onMessage: { addListener: (fn) => { captured.onMessage = fn; } },
+    lastError: null
+  },
+  windows: { create: () => Promise.resolve({ id: 1 }) },
+  storage: { local: makeArea(stores.local), session: makeArea(stores.session) }
+};
+
+await import('../src/background.js');
+const { generateKeypair } = await import('../src/crypto.js');
+const { storeKeypair, setAutoSign, addTrustedOrigin, isTrustedOrigin } = await import('../src/storage.js');
+
+const onMessage = captured.onMessage;
+const send = (message) => new Promise((resolve) => { onMessage(message, {}, resolve); });
+
+/** Decode a `Nostr <base64>` header back into the signed event object. */
+function decodeHeader (header) {
+  assert.equal(typeof header, 'string', 'expected a header string');
+  assert.match(header, /^Nostr /, 'NIP-98 header must use the "Nostr " scheme');
+  return JSON.parse(Buffer.from(header.slice('Nostr '.length), 'base64').toString('utf8'));
+}
+
+const tagValue = (event, name) => {
+  const t = event.tags.find((tag) => tag[0] === name);
+  return t ? t[1] : undefined;
+};
+
+let keypair;
+beforeEach(async () => {
+  for (const k of Object.keys(stores.local)) delete stores.local[k];
+  for (const k of Object.keys(stores.session)) delete stores.session[k];
+  keypair = await generateKeypair();
+  await storeKeypair(keypair.privateKey, keypair.publicKey);
+  await setAutoSign(true);
+});
+
+describe('NIP-98 token freshness (per-token nonce)', () => {
+  it('mints a kind-27235 event with u, method and a 16-byte nonce tag', async () => {
+    await addTrustedOrigin('https://pod.test');
+    const event = decodeHeader(await send({
+      type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://pod.test/resource', method: 'PUT'
+    }));
+    assert.equal(event.kind, 27235);
+    assert.equal(event.content, '');
+    assert.equal(tagValue(event, 'u'), 'https://pod.test/resource');
+    assert.equal(tagValue(event, 'method'), 'PUT');
+    const nonce = tagValue(event, 'nonce');
+    assert.ok(nonce, 'a nonce tag is required for freshness');
+    assert.match(nonce, /^[0-9a-f]{32}$/, 'nonce must be 16 random bytes (32 hex chars)');
+  });
+
+  it('two tokens for the same (url, method) have distinct ids and nonces', async () => {
+    await addTrustedOrigin('https://pod.test');
+    const a = decodeHeader(await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://pod.test/x', method: 'GET' }));
+    const b = decodeHeader(await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://pod.test/x', method: 'GET' }));
+
+    // created_at has 1s resolution; back-to-back calls usually share it. The
+    // nonce is what must differ so the event id (and thus the token) cannot be
+    // replayed.
+    assert.notEqual(tagValue(a, 'nonce'), tagValue(b, 'nonce'), 'nonces must differ');
+    assert.notEqual(a.id, b.id, 'event ids must differ -> no replayable duplicate');
+    assert.notEqual(a.sig, b.sig, 'signatures must differ');
+  });
+
+  it('each minted event is self-consistent (id binds u/method/nonce)', async () => {
+    await addTrustedOrigin('https://pod.test');
+    const { verifySignature, getEventHash } = await import('../src/crypto.js');
+    const event = decodeHeader(await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://pod.test/y', method: 'POST' }));
+    assert.equal(event.id, getEventHash(event), 'id must be the NIP-01 hash of the event');
+    assert.equal(await verifySignature(event), true, 'signature must verify against the pubkey');
+    assert.equal(event.pubkey, keypair.publicKey);
+  });
+});
+
+describe('NIP-98 payload body-hash tag', () => {
+  it('adds a payload tag with the sha-256 of a string body', async () => {
+    await addTrustedOrigin('https://pod.test');
+    const body = '{"hello":"world"}';
+    const event = decodeHeader(await send({
+      type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://pod.test/r', method: 'POST', body
+    }));
+    const expected = createHash('sha256').update(body, 'utf8').digest('hex');
+    assert.equal(tagValue(event, 'payload'), expected);
+  });
+
+  it('prefers a page-computed bodyHash over re-hashing the body', async () => {
+    await addTrustedOrigin('https://pod.test');
+    // The page context (nip98-interceptor) sends only the hash; background must
+    // use it verbatim and not require the raw body.
+    const bodyHash = createHash('sha256').update('precomputed', 'utf8').digest('hex');
+    const event = decodeHeader(await send({
+      type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://pod.test/r', method: 'POST', bodyHash
+    }));
+    assert.equal(tagValue(event, 'payload'), bodyHash);
+  });
+
+  it('omits the payload tag when there is no body', async () => {
+    await addTrustedOrigin('https://pod.test');
+    const event = decodeHeader(await send({
+      type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://pod.test/r', method: 'GET'
+    }));
+    assert.equal(tagValue(event, 'payload'), undefined);
+  });
+});
+
+describe('Solid auto-trust: exact-origin matching (substring-trust fix)', () => {
+  it('auto-trusts an exact trusted Solid host and mints a header', async () => {
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://inrupt.net/profile/card', method: 'GET' });
+    assert.equal(typeof header, 'string', 'inrupt.net should be auto-trusted');
+    assert.equal(decodeHeader(header).kind, 27235);
+    assert.equal(await isTrustedOrigin('https://inrupt.net'), true, 'origin should be persisted as trusted');
+  });
+
+  it('does NOT trust a lookalike suffix host (inrupt.net.evil.com)', async () => {
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://inrupt.net.evil.com/steal', method: 'GET' });
+    assert.equal(header, null, 'a substring-only match must not be auto-trusted');
+    assert.equal(await isTrustedOrigin('https://inrupt.net.evil.com'), false);
+  });
+
+  it('does NOT trust an attacker prefix host (evil-inrupt.net)', async () => {
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://evilinrupt.net/x', method: 'GET' });
+    assert.equal(header, null);
+  });
+
+  it('trusts a legitimate subdomain of a trusted Solid host', async () => {
+    // isLikelySolidServer accepts host === trusted || host.endsWith('.'+trusted)
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://alice.solidcommunity.net/profile', method: 'GET' });
+    assert.equal(typeof header, 'string', 'a real subdomain should auto-trust');
+    assert.equal(decodeHeader(header).kind, 27235);
+  });
+
+  it('does NOT auto-trust a non-Solid origin', async () => {
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://example.com/api', method: 'GET' });
+    assert.equal(header, null, 'unknown origins require an explicit prompt, not silent NIP-98');
+    assert.equal(await isTrustedOrigin('https://example.com'), false);
+  });
+
+  it('host matching is case-insensitive on the registrable host (URL-normalized)', async () => {
+    // The URL parser lowercases the host, so INRUPT.NET resolves to inrupt.net.
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://INRUPT.NET/x', method: 'GET' });
+    assert.equal(typeof header, 'string');
+  });
+
+  it('binds the u tag to the exact requested URL', async () => {
+    const event = decodeHeader(await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://inrupt.net/a/b?q=1', method: 'GET' }));
+    assert.equal(tagValue(event, 'u'), 'https://inrupt.net/a/b?q=1');
+  });
+});
+
+describe('NIP-98 auto-trust gating', () => {
+  it('returns null for a trusted origin when autoSign is OFF', async () => {
+    await addTrustedOrigin('https://pod.test');
+    await setAutoSign(false);
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://pod.test/r', method: 'GET' });
+    assert.equal(header, null, 'autoSign off must suppress silent NIP-98');
+  });
+
+  it('does NOT auto-trust a Solid host when autoSign is OFF', async () => {
+    await setAutoSign(false);
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://inrupt.net/r', method: 'GET' });
+    assert.equal(header, null);
+    assert.equal(await isTrustedOrigin('https://inrupt.net'), false, 'no auto-trust without autoSign');
+  });
+
+  it('returns null when no keypair exists', async () => {
+    for (const k of Object.keys(stores.session)) delete stores.session[k];
+    for (const k of Object.keys(stores.local)) delete stores.local[k];
+    const header = await send({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://inrupt.net/r', method: 'GET' });
+    assert.equal(header, null, 'no key -> no header (never throws to the page)');
+  });
+});

From 677b9df3bf3493262d79eb6035502a67349f09bf Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:25:28 +0000
Subject: [PATCH 18/24] test: signEvent self-verify guard + honest provider
 surface

sign-event-verify.test.js (7): a correctly-signed event passes and round-trips
through verifySignature; the self-verify guard throws (never returns a bad
signature) when the shared @noble/secp256k1 schnorr.sign singleton is patched
to emit a flipped-byte or wrong-message signature; verifySignature rejects
mutated content/sig/pubkey. Patches and restores the module singleton without
touching src.

provider-surface.test.js (15): window.nostr exposes exactly getPublicKey,
signEvent and nip44.{encrypt,decrypt} and does NOT expose nip04 or getRelays
(truthful feature-detection); signEvent input validation rejects bad shapes
before any wire dispatch; the podkey-request CustomEvent wiring forwards the
right type/fields (nip44 field is "pubkey", not "peer") and propagates a
background error back as a rejection. Runs the page-context IIFE against a
minimal EventTarget-backed window.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 test/provider-surface.test.js  | 158 +++++++++++++++++++++++++++++++++
 test/sign-event-verify.test.js | 103 +++++++++++++++++++++
 2 files changed, 261 insertions(+)
 create mode 100644 test/provider-surface.test.js
 create mode 100644 test/sign-event-verify.test.js

diff --git a/test/provider-surface.test.js b/test/provider-surface.test.js
new file mode 100644
index 0000000..dd307b6
--- /dev/null
+++ b/test/provider-surface.test.js
@@ -0,0 +1,158 @@
+/**
+ * Tests for the NIP-07 provider surface (nostr-provider.js).
+ *
+ * The provider must advertise ONLY what it implements, so that page-side
+ * feature-detection is truthful:
+ *   - exposes getPublicKey, signEvent, nip44.{encrypt,decrypt}
+ *   - does NOT expose nip04 (deprecated, unauthenticated; not shipped)
+ *   - does NOT expose getRelays (Podkey holds no relay list)
+ *
+ * nostr-provider.js is a page-context IIFE that assigns window.nostr, so the
+ * test mounts a minimal window (EventTarget-backed) and imports the module to
+ * run it, then inspects the installed surface and its request wiring.
+ */
+
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert/strict';
+
+let nostr;
+const events = new EventTarget();
+
+before(async () => {
+  global.window = {
+    addEventListener: (...a) => events.addEventListener(...a),
+    removeEventListener: (...a) => events.removeEventListener(...a),
+    dispatchEvent: (e) => events.dispatchEvent(e)
+  };
+  // Running the IIFE installs window.nostr.
+  await import('../src/nostr-provider.js');
+  nostr = global.window.nostr;
+});
+
+describe('provider surface (honest feature-detection)', () => {
+  it('exposes exactly getPublicKey, signEvent and nip44', () => {
+    assert.deepEqual(Object.keys(nostr).sort(), ['getPublicKey', 'nip44', 'signEvent']);
+  });
+
+  it('exposes nip44.encrypt and nip44.decrypt as functions', () => {
+    assert.equal(typeof nostr.nip44.encrypt, 'function');
+    assert.equal(typeof nostr.nip44.decrypt, 'function');
+  });
+
+  it('does NOT expose nip04 (deprecated scheme is not shipped)', () => {
+    assert.equal('nip04' in nostr, false);
+    assert.equal(nostr.nip04, undefined);
+  });
+
+  it('does NOT expose getRelays (no relay list is held)', () => {
+    assert.equal('getRelays' in nostr, false);
+    assert.equal(nostr.getRelays, undefined);
+  });
+
+  it('getPublicKey and signEvent are async functions', () => {
+    assert.equal(typeof nostr.getPublicKey, 'function');
+    assert.equal(typeof nostr.signEvent, 'function');
+  });
+});
+
+describe('signEvent input validation (before any signing)', () => {
+  // These reject synchronously inside the provider, never reaching the wire,
+  // so no response listener is needed.
+  it('rejects a non-object event', async () => {
+    await assert.rejects(() => nostr.signEvent(null), /Event must be an object/);
+    await assert.rejects(() => nostr.signEvent('nope'), /Event must be an object/);
+  });
+
+  it('rejects a missing/typed kind', async () => {
+    await assert.rejects(() => nostr.signEvent({ created_at: 1, tags: [], content: '' }), /kind must be a number/);
+  });
+
+  it('rejects a missing created_at', async () => {
+    await assert.rejects(() => nostr.signEvent({ kind: 1, tags: [], content: '' }), /created_at must be a number/);
+  });
+
+  it('rejects non-array tags', async () => {
+    await assert.rejects(() => nostr.signEvent({ kind: 1, created_at: 1, tags: 'x', content: '' }), /tags must be an array/);
+  });
+
+  it('rejects non-string content', async () => {
+    await assert.rejects(() => nostr.signEvent({ kind: 1, created_at: 1, tags: [], content: 5 }), /content must be a string/);
+  });
+});
+
+describe('provider request wiring (podkey-request CustomEvent)', () => {
+  /**
+   * Capture the next podkey-request the provider emits, reply to it with the
+   * matching id, and return the request detail for assertions.
+   */
+  function captureRequest (reply) {
+    return new Promise((resolve) => {
+      const handler = (e) => {
+        global.window.removeEventListener('podkey-request', handler);
+        const detail = e.detail;
+        // Respond on the next tick so the provider's listener is registered.
+        queueMicrotask(() => {
+          global.window.dispatchEvent(new CustomEvent('podkey-response', {
+            detail: { id: detail.id, result: reply(detail) }
+          }));
+        });
+        resolve(detail);
+      };
+      global.window.addEventListener('podkey-request', handler);
+    });
+  }
+
+  it('getPublicKey dispatches a GET_PUBLIC_KEY request and resolves the response', async () => {
+    const reqP = captureRequest(() => 'deadbeef'.repeat(8));
+    const resP = nostr.getPublicKey();
+    const req = await reqP;
+    assert.equal(req.type, 'GET_PUBLIC_KEY');
+    assert.ok(req.id, 'request must carry a correlation id');
+    assert.equal(await resP, 'deadbeef'.repeat(8));
+  });
+
+  it('signEvent forwards the validated event under SIGN_EVENT', async () => {
+    const event = { kind: 1, created_at: 1700000000, tags: [['t', 'x']], content: 'gm' };
+    const reqP = captureRequest((d) => ({ ...d.event, id: 'a'.repeat(64), pubkey: 'b'.repeat(64), sig: 'c'.repeat(128) }));
+    const resP = nostr.signEvent(event);
+    const req = await reqP;
+    assert.equal(req.type, 'SIGN_EVENT');
+    assert.deepEqual(req.event, event);
+    const signed = await resP;
+    assert.equal(signed.sig.length, 128);
+  });
+
+  it('nip44.encrypt dispatches NIP44_ENCRYPT with pubkey + plaintext (field is "pubkey")', async () => {
+    const reqP = captureRequest(() => 'BASE64PAYLOAD');
+    const resP = nostr.nip44.encrypt('f'.repeat(64), 'secret');
+    const req = await reqP;
+    assert.equal(req.type, 'NIP44_ENCRYPT');
+    assert.equal(req.pubkey, 'f'.repeat(64));
+    assert.equal(req.plaintext, 'secret');
+    assert.equal('peer' in req, false, 'the reconciled field name is "pubkey", not "peer"');
+    assert.equal(await resP, 'BASE64PAYLOAD');
+  });
+
+  it('nip44.decrypt dispatches NIP44_DECRYPT with pubkey + ciphertext', async () => {
+    const reqP = captureRequest(() => 'plaintext-out');
+    const resP = nostr.nip44.decrypt('f'.repeat(64), 'BASE64PAYLOAD');
+    const req = await reqP;
+    assert.equal(req.type, 'NIP44_DECRYPT');
+    assert.equal(req.pubkey, 'f'.repeat(64));
+    assert.equal(req.ciphertext, 'BASE64PAYLOAD');
+    assert.equal(await resP, 'plaintext-out');
+  });
+
+  it('propagates a background error back to the caller as a rejection', async () => {
+    const handler = (e) => {
+      global.window.removeEventListener('podkey-request', handler);
+      queueMicrotask(() => {
+        global.window.dispatchEvent(new CustomEvent('podkey-response', {
+          detail: { id: e.detail.id, error: 'User denied permission' }
+        }));
+      });
+    };
+    global.window.addEventListener('podkey-request', handler);
+    await assert.rejects(() => nostr.getPublicKey(), /User denied permission/);
+  });
+});
diff --git a/test/sign-event-verify.test.js b/test/sign-event-verify.test.js
new file mode 100644
index 0000000..e6bbce9
--- /dev/null
+++ b/test/sign-event-verify.test.js
@@ -0,0 +1,103 @@
+/**
+ * Tests for the schnorr self-verification guard in signEvent (crypto.js).
+ *
+ * A key-holder must never emit a signature it cannot itself verify: a faulty
+ * signing path (bad RNG, a library regression) producing a structurally-valid
+ * but cryptographically-wrong signature has to throw, not return a bad token.
+ *
+ * The positive path is tested directly. The throw path is forced by patching
+ * the shared @noble/secp256k1 schnorr.sign singleton (the same module instance
+ * crypto.js imports) so it returns a corrupted signature — without touching src.
+ */
+
+import { describe, it, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { schnorr } from '@noble/secp256k1';
+import { generateKeypair, signEvent, verifySignature, getEventHash } from '../src/crypto.js';
+
+const baseEvent = () => ({ kind: 1, created_at: 1700000000, tags: [], content: 'self-verify' });
+
+describe('signEvent self-verification', () => {
+  const realSign = schnorr.sign;
+  afterEach(() => { schnorr.sign = realSign; }); // always restore the singleton
+
+  it('a correctly-signed event passes and round-trips through verifySignature', async () => {
+    const kp = await generateKeypair();
+    const signed = await signEvent(baseEvent(), kp.privateKey);
+
+    assert.equal(signed.sig.length, 128);
+    assert.equal(signed.pubkey, kp.publicKey);
+    assert.equal(signed.id, getEventHash(signed), 'id must be the NIP-01 event hash');
+    assert.equal(await verifySignature(signed), true);
+  });
+
+  it('throws when signing yields a signature that does not verify (flipped byte)', async () => {
+    const kp = await generateKeypair();
+    // Emit a 64-byte signature that is structurally valid but wrong: passes the
+    // length check, fails schnorr.verify. The guard must catch it.
+    schnorr.sign = (msg, sk) => {
+      const sig = realSign(msg, sk);
+      sig[0] ^= 0xff;
+      return sig;
+    };
+    await assert.rejects(
+      () => signEvent(baseEvent(), kp.privateKey),
+      /Signature self-verification failed/
+    );
+  });
+
+  it('throws when the signature is over the wrong message id', async () => {
+    const kp = await generateKeypair();
+    // Produce a real schnorr signature, but over a different 32-byte message
+    // than the event id. It is a valid signature for *something* — just not for
+    // this event — so length passes and self-verify against the true id fails.
+    const wrongMsg = new Uint8Array(32).fill(7);
+    schnorr.sign = (_msg, sk) => realSign(wrongMsg, sk);
+    await assert.rejects(
+      () => signEvent(baseEvent(), kp.privateKey),
+      /Signature self-verification failed/
+    );
+  });
+
+  it('does NOT leak the bad signature when it throws', async () => {
+    const kp = await generateKeypair();
+    let emitted;
+    schnorr.sign = (msg, sk) => {
+      const sig = realSign(msg, sk);
+      sig[10] ^= 0x01;
+      emitted = sig;
+      return sig;
+    };
+    await assert.rejects(() => signEvent(baseEvent(), kp.privateKey));
+    assert.ok(emitted, 'the patched signer ran');
+    // The point of the guard: a bad signature is produced internally but never
+    // returned to a caller. (The rejection above already proves no value is
+    // returned; this asserts the failure happened *after* signing, at verify.)
+  });
+});
+
+describe('verifySignature (guard primitive) rejects mutations', () => {
+  it('rejects a mutated content (id no longer matches)', async () => {
+    const kp = await generateKeypair();
+    const signed = await signEvent(baseEvent(), kp.privateKey);
+    const tampered = { ...signed, content: 'tampered' };
+    // The signature is over the original id; verifying against the original id
+    // still passes, but a consumer recomputing the id would reject it.
+    assert.notEqual(getEventHash(tampered), signed.id, 'mutated content changes the id');
+    assert.equal(await verifySignature({ ...tampered, id: getEventHash(tampered) }), false);
+  });
+
+  it('rejects a flipped signature byte', async () => {
+    const kp = await generateKeypair();
+    const signed = await signEvent(baseEvent(), kp.privateKey);
+    const badSig = (parseInt(signed.sig[0], 16) ^ 0x8).toString(16) + signed.sig.slice(1);
+    assert.equal(await verifySignature({ ...signed, sig: badSig }), false);
+  });
+
+  it('rejects a signature verified against a different pubkey', async () => {
+    const kp = await generateKeypair();
+    const other = await generateKeypair();
+    const signed = await signEvent(baseEvent(), kp.privateKey);
+    assert.equal(await verifySignature({ ...signed, pubkey: other.publicKey }), false);
+  });
+});

From 56fc537c5d4b10a28bfe5f77932081355b9e3adb Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:25:36 +0000
Subject: [PATCH 19/24] test: page-side body-hash + content-script message
 whitelist

body-hash.test.js (11): exercise the real bodyToHashHex inside the
nip98-interceptor IIFE by running it in a vm sandbox with a minimal page
(window/fetch/XHR) and capturing the bodyHash it emits on podkey-nip98-request.
Correct sha-256 hex for string, URLSearchParams, Blob, ArrayBuffer and
typed-array bodies (respecting view offset); "" for no/empty body; "" for
FormData (no canonical NIP-98 multipart hash). A page-set Authorization
suppresses NIP-98 injection; absent auth emits a request.

content-whitelist.test.js (9): injected.js forwards only the four NIP-07 types,
rejects anything else (incl. CREATE_NIP98_AUTH_HEADER, which has its own
channel) with "Unknown request type" and never calls sendMessage for it;
forwards only safe fields per type, always overriding origin with the real page
origin (drops attacker-supplied privateKey/peer/extra) and coerces nip44 fields
to strings.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 test/body-hash.test.js         | 152 +++++++++++++++++++++++++++++++++
 test/content-whitelist.test.js | 142 ++++++++++++++++++++++++++++++
 2 files changed, 294 insertions(+)
 create mode 100644 test/body-hash.test.js
 create mode 100644 test/content-whitelist.test.js

diff --git a/test/body-hash.test.js b/test/body-hash.test.js
new file mode 100644
index 0000000..81f0de9
--- /dev/null
+++ b/test/body-hash.test.js
@@ -0,0 +1,152 @@
+/**
+ * Tests for bodyToHashHex — the page-side NIP-98 `payload` body hashing in
+ * nip98-interceptor.js. The raw request body never crosses to the background
+ * service worker; the page computes its SHA-256 here (the only context where
+ * FormData / URLSearchParams / Blob survive intact) and ships only the digest.
+ *
+ * bodyToHashHex is a private function inside the interceptor's page-context
+ * IIFE (no ESM export — classic scripts can't import). To exercise the real
+ * source it is loaded and run inside a vm sandbox with a minimal page (window,
+ * fetch, XHR), and the bodyHash the interceptor emits on the
+ * podkey-nip98-request event is captured. This drives the genuine code path
+ * (window.fetch wrapper -> getNip98AuthHeader -> bodyToHashHex) rather than a
+ * reimplementation.
+ */
+
+import { describe, it, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { createHash, webcrypto } from 'node:crypto';
+import vm from 'node:vm';
+
+const sha256hex = (input) => createHash('sha256').update(input).digest('hex');
+
+/** Build a fresh sandboxed page with the interceptor installed. */
+function makeInterceptedPage () {
+  const src = readFileSync(new URL('../src/nip98-interceptor.js', import.meta.url), 'utf8');
+  const bus = new EventTarget();
+  const win = {
+    __podkey_nip98_intercepted: false,
+    addEventListener: (...a) => bus.addEventListener(...a),
+    removeEventListener: (...a) => bus.removeEventListener(...a),
+    dispatchEvent: (e) => bus.dispatchEvent(e),
+    // originalFetch: a stub the wrapper calls after deciding on auth.
+    fetch: async () => ({ status: 200, redirected: false, url: '' })
+  };
+
+  // Echo every nip98 request back immediately so the fetch wrapper resolves,
+  // recording the detail (which carries bodyHash) for assertions.
+  const requests = [];
+  bus.addEventListener('podkey-nip98-request', (e) => {
+    requests.push(e.detail);
+    bus.dispatchEvent(new CustomEvent('podkey-nip98-response', { detail: { id: e.detail.id, result: null } }));
+  });
+
+  // Minimal XHR so the interceptor can patch its prototype without throwing.
+  function XHR () {}
+  XHR.prototype = { open () {}, send () {}, setRequestHeader () {} };
+
+  const sandbox = {
+    window: win,
+    XMLHttpRequest: XHR,
+    crypto: webcrypto,
+    CustomEvent, Headers, Request, TextEncoder,
+    Blob, URLSearchParams, ArrayBuffer, Uint8Array, Uint16Array, Array, Object,
+    console, setTimeout, clearTimeout
+  };
+  vm.createContext(sandbox);
+  vm.runInContext(src, sandbox);
+
+  return {
+    /** Issue a fetch through the wrapped fetch and return the captured bodyHash. */
+    async fetchAndGetHash (init) {
+      requests.length = 0;
+      await win.fetch('https://pod.test/r', init);
+      assert.equal(requests.length, 1, 'interceptor should emit exactly one nip98 request');
+      return requests[0].bodyHash;
+    },
+    /** Issue a fetch and return whether any nip98 request was emitted. */
+    async fetchEmitsRequest (input, init) {
+      requests.length = 0;
+      await win.fetch(input, init);
+      return requests.length > 0;
+    }
+  };
+}
+
+describe('bodyToHashHex (NIP-98 page-side body hashing)', () => {
+  let page;
+  before(() => { page = makeInterceptedPage(); });
+
+  it('hashes a string body to its sha-256 hex', async () => {
+    const body = '{"hello":"world"}';
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body }), sha256hex(body));
+  });
+
+  it('hashes a URLSearchParams body via its serialized form', async () => {
+    const params = new URLSearchParams({ a: '1', b: 'two' });
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: params }), sha256hex(params.toString()));
+  });
+
+  it('hashes a Blob body by its bytes', async () => {
+    const text = 'blob-bytes-😀';
+    const blob = new Blob([text]);
+    const expected = sha256hex(Buffer.from(text, 'utf8'));
+    assert.equal(await page.fetchAndGetHash({ method: 'PUT', body: blob }), expected);
+  });
+
+  it('hashes an ArrayBuffer body', async () => {
+    const bytes = new Uint8Array([1, 2, 3, 4, 250, 255]);
+    const expected = sha256hex(Buffer.from(bytes));
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: bytes.buffer }), expected);
+  });
+
+  it('hashes a typed-array (Uint8Array) body', async () => {
+    const bytes = new Uint8Array([10, 20, 30]);
+    const expected = sha256hex(Buffer.from(bytes));
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: bytes }), expected);
+  });
+
+  it('respects a typed-array view offset (does not hash the whole buffer)', async () => {
+    const full = new Uint8Array([0, 0, 1, 2, 3, 0]);
+    const view = full.subarray(2, 5); // [1,2,3]
+    const expected = sha256hex(Buffer.from([1, 2, 3]));
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: view }), expected);
+  });
+
+  it('returns "" for no body (GET)', async () => {
+    assert.equal(await page.fetchAndGetHash({ method: 'GET' }), '');
+  });
+
+  it('returns "" for an empty-string body', async () => {
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: '' }), '');
+  });
+
+  it('returns "" for a FormData body (no canonical NIP-98 multipart hash)', async () => {
+    // Documented decision: NIP-98 defines no canonical hash for multipart bodies,
+    // so FormData is intentionally not hashed (no payload tag is added). A
+    // FormData instance matches none of bodyToHashHex's recognised body types
+    // (string / URLSearchParams / Blob / ArrayBuffer / typed-array) and hits the
+    // `return ''` fallthrough.
+    const fd = new FormData();
+    fd.append('field', 'value');
+    assert.equal(await page.fetchAndGetHash({ method: 'POST', body: fd }), '');
+  });
+});
+
+describe('interceptor honors a page-set Authorization (no NIP-98 injection)', () => {
+  let page;
+  before(() => { page = makeInterceptedPage(); });
+
+  it('does not emit a nip98 request when init.headers already has Authorization', async () => {
+    const emitted = await page.fetchEmitsRequest('https://pod.test/r', {
+      method: 'GET', headers: { Authorization: 'DPoP page-token' }
+    });
+    assert.equal(emitted, false, 'page-set DPoP must not be overwritten by NIP-98');
+  });
+
+  it('emits a nip98 request when no Authorization is present', async () => {
+    const emitted = await page.fetchEmitsRequest('https://pod.test/r', { method: 'GET' });
+    assert.equal(emitted, true);
+  });
+});
diff --git a/test/content-whitelist.test.js b/test/content-whitelist.test.js
new file mode 100644
index 0000000..229b680
--- /dev/null
+++ b/test/content-whitelist.test.js
@@ -0,0 +1,142 @@
+/**
+ * Tests for the content-script message-type whitelist (injected.js,
+ * security/whitelist-message-types #19).
+ *
+ * The content script bridges page CustomEvents to chrome.runtime. It must:
+ *   - forward ONLY the four NIP-07 message types, rejecting anything else with
+ *     "Unknown request type" and never calling sendMessage for it
+ *   - forward ONLY known-safe fields per type (no arbitrary page-supplied props
+ *     reach the background), always appending the real page origin
+ *
+ * injected.js runs at import time against the DOM and chrome.runtime, so the
+ * test mounts minimal window/document/chrome and then drives it via the
+ * podkey-request / podkey-response CustomEvents the provider uses.
+ */
+
+import { describe, it, before, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+
+const ORIGIN = 'https://app.test';
+const bus = new EventTarget();
+const forwarded = [];
+
+before(async () => {
+  global.window = {
+    addEventListener: (...a) => bus.addEventListener(...a),
+    removeEventListener: (...a) => bus.removeEventListener(...a),
+    dispatchEvent: (e) => bus.dispatchEvent(e),
+    location: { origin: ORIGIN }
+  };
+  global.document = {
+    createElement: () => ({ set src (_v) {}, set onload (_v) {}, set onerror (_v) {}, remove () {} }),
+    head: { appendChild () {} },
+    documentElement: { appendChild () {} }
+  };
+  global.chrome = {
+    runtime: {
+      getURL: (p) => 'chrome-extension://test/' + p,
+      sendMessage: async (message) => {
+        forwarded.push(message);
+        if (message.type === 'GET_PUBLIC_KEY') return 'a'.repeat(64);
+        if (message.type === 'SIGN_EVENT') return { ...message.event, id: 'i'.repeat(64), sig: 's'.repeat(128) };
+        return 'OK';
+      },
+      lastError: null
+    }
+  };
+  await import('../src/injected.js');
+});
+
+beforeEach(() => { forwarded.length = 0; });
+
+let seq = 0;
+/** Dispatch a podkey-request and resolve with the matching podkey-response. */
+function request (detail) {
+  const id = `req-${++seq}`;
+  return new Promise((resolve) => {
+    const handler = (e) => {
+      if (e.detail.id !== id) return;
+      bus.removeEventListener('podkey-response', handler);
+      resolve(e.detail);
+    };
+    bus.addEventListener('podkey-response', handler);
+    bus.dispatchEvent(new CustomEvent('podkey-request', { detail: { id, ...detail } }));
+  });
+}
+
+describe('content-script whitelist', () => {
+  it('forwards GET_PUBLIC_KEY and returns the result', async () => {
+    const res = await request({ type: 'GET_PUBLIC_KEY' });
+    assert.equal(res.result, 'a'.repeat(64));
+    assert.equal(forwarded.length, 1);
+    assert.equal(forwarded[0].type, 'GET_PUBLIC_KEY');
+  });
+
+  it('forwards SIGN_EVENT, NIP44_ENCRYPT and NIP44_DECRYPT', async () => {
+    await request({ type: 'SIGN_EVENT', event: { kind: 1, created_at: 1, tags: [], content: 'x' } });
+    await request({ type: 'NIP44_ENCRYPT', pubkey: 'f'.repeat(64), plaintext: 'hi' });
+    await request({ type: 'NIP44_DECRYPT', pubkey: 'f'.repeat(64), ciphertext: 'BASE64' });
+    assert.deepEqual(forwarded.map((m) => m.type), ['SIGN_EVENT', 'NIP44_ENCRYPT', 'NIP44_DECRYPT']);
+  });
+
+  it('rejects an unknown type and never forwards it', async () => {
+    const res = await request({ type: 'EXPORT_PRIVATE_KEY' });
+    assert.deepEqual(res, { id: res.id, error: 'Unknown request type' });
+    assert.equal(forwarded.length, 0, 'an unknown type must not reach the background');
+  });
+
+  it('rejects NIP-98 header type on the NIP-07 channel (separate channel only)', async () => {
+    // CREATE_NIP98_AUTH_HEADER is intentionally not in the NIP-07 whitelist;
+    // it has its own podkey-nip98-request channel.
+    const res = await request({ type: 'CREATE_NIP98_AUTH_HEADER', url: 'https://x/', method: 'GET' });
+    assert.equal(res.error, 'Unknown request type');
+    assert.equal(forwarded.length, 0);
+  });
+
+  it('always appends the page origin to forwarded messages', async () => {
+    await request({ type: 'GET_PUBLIC_KEY' });
+    assert.equal(forwarded[0].origin, ORIGIN);
+  });
+});
+
+describe('content-script field stripping (only safe fields forwarded)', () => {
+  it('SIGN_EVENT forwards only { event, type, origin } — drops injected extras', async () => {
+    await request({
+      type: 'SIGN_EVENT',
+      event: { kind: 1, created_at: 1, tags: [], content: 'x' },
+      privateKey: 'attacker-supplied', // must NOT be forwarded
+      origin: 'https://spoofed.evil' // page-supplied origin must be overridden
+    });
+    const msg = forwarded[0];
+    assert.deepEqual(Object.keys(msg).sort(), ['event', 'origin', 'type']);
+    assert.equal(msg.origin, ORIGIN, 'origin must be the real page origin, not a spoofed one');
+    assert.equal('privateKey' in msg, false);
+  });
+
+  it('NIP44_ENCRYPT forwards only pubkey + plaintext (field is "pubkey", not "peer")', async () => {
+    await request({
+      type: 'NIP44_ENCRYPT', pubkey: 'f'.repeat(64), plaintext: 'secret',
+      peer: 'should-be-dropped', extra: 'nope'
+    });
+    const msg = forwarded[0];
+    assert.deepEqual(Object.keys(msg).sort(), ['origin', 'plaintext', 'pubkey', 'type']);
+    assert.equal(msg.pubkey, 'f'.repeat(64));
+    assert.equal(msg.plaintext, 'secret');
+    assert.equal('peer' in msg, false);
+    assert.equal('extra' in msg, false);
+  });
+
+  it('NIP44_DECRYPT forwards only pubkey + ciphertext', async () => {
+    await request({ type: 'NIP44_DECRYPT', pubkey: 'f'.repeat(64), ciphertext: 'BASE64', junk: 1 });
+    const msg = forwarded[0];
+    assert.deepEqual(Object.keys(msg).sort(), ['ciphertext', 'origin', 'pubkey', 'type']);
+    assert.equal('junk' in msg, false);
+  });
+
+  it('coerces NIP44 fields to strings', async () => {
+    await request({ type: 'NIP44_ENCRYPT', pubkey: 123, plaintext: 456 });
+    const msg = forwarded[0];
+    assert.equal(typeof msg.pubkey, 'string');
+    assert.equal(typeof msg.plaintext, 'string');
+  });
+});

From 11562f11eb9f1931850bef76294aa2d87c4bed4a Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:25:42 +0000
Subject: [PATCH 20/24] test: NIP-44 length-bound and key-isolation edges
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

nip44-edges.test.js (8): plaintext bounds (1..65535) — empty and oversized are
rejected, the single-byte minimum and exact 65535-byte maximum round-trip; key
isolation — a payload encrypted under convKey(alice,bob) fails the MAC under
convKey(alice,eve) rather than silently decrypting; malformed/too-short and
non-base64 payloads are rejected. Complements (does not duplicate) the spec
vectors and basic round-trip already in nip44.test.js.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 test/nip44-edges.test.js | 86 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 test/nip44-edges.test.js

diff --git a/test/nip44-edges.test.js b/test/nip44-edges.test.js
new file mode 100644
index 0000000..0cc0539
--- /dev/null
+++ b/test/nip44-edges.test.js
@@ -0,0 +1,86 @@
+/**
+ * NIP-44 (v2) edge cases and security boundaries NOT already covered by
+ * nip44.test.js (which owns the spec vectors and the basic round-trip).
+ *
+ * Focus here:
+ *   - plaintext length bounds (1..65535): empty is rejected, max is allowed
+ *   - key isolation: a payload does not decrypt under the wrong conversation key
+ *   - malformed-payload rejection (too short to contain version+nonce+mac)
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import {
+  getConversationKey, encrypt, decrypt, hexToBytes
+} from '../src/nip44.js';
+import { generateKeypair } from '../src/crypto.js';
+
+describe('NIP-44 plaintext length bounds', () => {
+  it('rejects empty plaintext (NIP-44 forbids 0-length)', async () => {
+    const a = await generateKeypair();
+    const b = await generateKeypair();
+    const ck = getConversationKey(a.privateKey, b.publicKey);
+    assert.throws(() => encrypt('', ck), /Invalid plaintext length/);
+  });
+
+  it('encrypts/decrypts a single-byte plaintext (min boundary)', async () => {
+    const a = await generateKeypair();
+    const b = await generateKeypair();
+    const ck = getConversationKey(a.privateKey, b.publicKey);
+    assert.equal(decrypt(encrypt('x', ck), ck), 'x');
+  });
+
+  it('encrypts/decrypts the maximum-length plaintext (65535 bytes)', async () => {
+    const a = await generateKeypair();
+    const b = await generateKeypair();
+    const ck = getConversationKey(a.privateKey, b.publicKey);
+    const max = 'a'.repeat(65535);
+    assert.equal(decrypt(encrypt(max, ck), ck), max);
+  });
+
+  it('rejects plaintext above the maximum length', async () => {
+    const a = await generateKeypair();
+    const b = await generateKeypair();
+    const ck = getConversationKey(a.privateKey, b.publicKey);
+    assert.throws(() => encrypt('a'.repeat(65536), ck), /Invalid plaintext length/);
+  });
+});
+
+describe('NIP-44 key isolation', () => {
+  it('a third party with a different conversation key cannot decrypt', async () => {
+    const alice = await generateKeypair();
+    const bob = await generateKeypair();
+    const eve = await generateKeypair();
+
+    const ckAB = getConversationKey(alice.privateKey, bob.publicKey);
+    const payload = encrypt('for bob only', ckAB);
+
+    // Eve derives a conversation key with alice — different shared secret.
+    const ckAE = getConversationKey(alice.privateKey, eve.publicKey);
+    assert.throws(() => decrypt(payload, ckAE), /Invalid MAC/,
+      'wrong conversation key must fail the MAC check, not silently decrypt');
+  });
+
+  it('the same conversation key from both peers decrypts (sanity, no key reuse leak)', async () => {
+    const alice = await generateKeypair();
+    const bob = await generateKeypair();
+    const ckA = getConversationKey(alice.privateKey, bob.publicKey);
+    const ckB = getConversationKey(bob.privateKey, alice.publicKey);
+    const payload = encrypt('round', ckA);
+    assert.equal(decrypt(payload, ckB), 'round');
+  });
+});
+
+describe('NIP-44 malformed payload rejection', () => {
+  it('rejects a payload too short to hold version+nonce+ciphertext+mac', () => {
+    const ck = hexToBytes('11'.repeat(32));
+    // base64 of a single version byte 0x02 — far below the minimum frame size.
+    const tooShort = btoa(String.fromCharCode(2));
+    assert.throws(() => decrypt(tooShort, ck));
+  });
+
+  it('rejects non-base64 garbage', () => {
+    const ck = hexToBytes('22'.repeat(32));
+    assert.throws(() => decrypt('!!!not base64!!!', ck));
+  });
+});

From 7192a72e74ce6960c41ee3b2c5a0347965cd67e0 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:35:58 +0000
Subject: [PATCH 21/24] chore(lint): prefix unused args with _ and promote
 no-unused-vars to error

Cleanup flagged by the CI review, then harden the gate so unused
identifiers fail lint instead of merely warning:

- background.js: the two consent handlers (handleGetPublicKey,
  handleSignEvent) receive `sender` but never use it -> `_sender`.
- nip98-interceptor.js: the XHR setRequestHeader override only inspects
  the header `name` (and forwards `arguments`); the `value` arg is
  unused -> `_value`.
- test/storage.test.js: drop the unused `before`/`after` imports (the
  suite uses inline clearStorage() calls).
- .eslintrc.json: no-unused-vars "warn" -> "error", keeping the
  ^_ ignore patterns for args/vars/caught-errors.

Lint is 0 errors / 0 warnings; build and the 133-test suite stay green.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 .eslintrc.json           | 2 +-
 src/background.js        | 4 ++--
 src/nip98-interceptor.js | 2 +-
 test/storage.test.js     | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.eslintrc.json b/.eslintrc.json
index 3e45219..56178ef 100644
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -16,7 +16,7 @@
     "no-implied-eval": "error",
     "no-undef": "error",
     "no-unused-vars": [
-      "warn",
+      "error",
       {
         "argsIgnorePattern": "^_",
         "varsIgnorePattern": "^_",
diff --git a/src/background.js b/src/background.js
index 1060353..4cb7216 100644
--- a/src/background.js
+++ b/src/background.js
@@ -118,7 +118,7 @@ async function handleMessage (message, sender) {
 /**
  * Get public key with user permission
  */
-async function handleGetPublicKey (origin, sender) {
+async function handleGetPublicKey (origin, _sender) {
   // Check if keypair exists
   const keyExists = await hasKeypair();
   if (!keyExists) {
@@ -151,7 +151,7 @@ async function handleGetPublicKey (origin, sender) {
 /**
  * Sign event with user permission
  */
-async function handleSignEvent (event, origin, sender) {
+async function handleSignEvent (event, origin, _sender) {
   // Check if keypair exists
   const keyExists = await hasKeypair();
   if (!keyExists) {
diff --git a/src/nip98-interceptor.js b/src/nip98-interceptor.js
index e0ffdb1..52bd5b8 100644
--- a/src/nip98-interceptor.js
+++ b/src/nip98-interceptor.js
@@ -227,7 +227,7 @@
   // Track page-set Authorization on XHR so we don't overwrite it in send().
   // setRequestHeader auto-merges values per the XHR spec, but a merged
   // "DPoP xxx, Nostr yyy" still confuses servers that branch on scheme.
-  XMLHttpRequest.prototype.setRequestHeader = function (name, value) {
+  XMLHttpRequest.prototype.setRequestHeader = function (name, _value) {
     if (typeof name === 'string' && name.toLowerCase() === 'authorization') {
       this._podkeyHasPageAuth = true;
     }
diff --git a/test/storage.test.js b/test/storage.test.js
index b40dc28..bb92170 100644
--- a/test/storage.test.js
+++ b/test/storage.test.js
@@ -3,7 +3,7 @@
  * Note: These tests require Chrome extension APIs, so they may need mocking
  */
 
-import { describe, it, before, after } from 'node:test';
+import { describe, it } from 'node:test';
 import assert from 'node:assert';
 
 // Mock chrome.storage for testing. The extension uses two areas: session

From 7002f30afdfec82bc568984f07b20b2e09111d39 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:36:10 +0000
Subject: [PATCH 22/24] fix(consent): default auto-sign OFF so first-run
 installs never silently trust

getAutoSign() defaulted to `true`, which made the silent NIP-98 path in
createNip98AuthHeader (background.js: `!trusted && isSolid && autoSign`)
active out of the box: a freshly installed extension visiting any of the
hardcoded Solid hosts (solid.social, solidcommunity.net, inrupt.net,
solidweb.org) would mint a NIP-98 Authorization header AND persist the
origin to trusted-origins with zero user interaction -- a silent
auto-approve / auto-trust on install.

Flip the default to OFF in storage.getAutoSign so the trusted-origin
Solid (kind 27235) auto-sign and the Solid NIP-98 auto-trust are strictly
opt-in: the user enables "Auto-sign for Solid" from the popup
deliberately. Untrusted-origin signing was already prompt-gated and is
unaffected.

Align the popup default-display accordingly: popup.js reads the same OFF
default, and the popup.html toggle drops its hardcoded `checked` so the
markup matches the real (off) state instead of flashing on at load.

No test pins the autoSign default (storage.test only asserts it is a
boolean; the consent/NIP-98 suites set it explicitly), so the full
133-test suite, build and lint remain green.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 popup/popup.html | 2 +-
 popup/popup.js   | 5 +++--
 src/storage.js   | 8 ++++++--
 3 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/popup/popup.html b/popup/popup.html
index 0ff22d5..ecfc185 100644
--- a/popup/popup.html
+++ b/popup/popup.html
@@ -148,7 +148,7 @@ <h1>Podkey</h1>
             <div class="settings-desc">Silently authenticate to trusted Solid servers.</div>
           </div>
           <label class="toggle">
-            <input type="checkbox" id="autoSignToggle" checked />
+            <input type="checkbox" id="autoSignToggle" />
             <span class="slider"></span>
           </label>
         </div>
diff --git a/popup/popup.js b/popup/popup.js
index 4c1d906..8bdf0db 100644
--- a/popup/popup.js
+++ b/popup/popup.js
@@ -76,8 +76,9 @@ async function showMainScreen(status) {
   // Load trusted sites
   await loadTrustedSites();
 
-  // Load auto-sign setting
-  const { podkey_auto_sign: autoSign = true } = await chrome.storage.local.get(['podkey_auto_sign']);
+  // Load auto-sign setting (defaults OFF — must match storage.getAutoSign,
+  // which keeps silent trusted-origin Solid / NIP-98 signing strictly opt-in).
+  const { podkey_auto_sign: autoSign = false } = await chrome.storage.local.get(['podkey_auto_sign']);
   document.getElementById('autoSignToggle').checked = autoSign;
 }
 
diff --git a/src/storage.js b/src/storage.js
index 057b3c3..d820c53 100644
--- a/src/storage.js
+++ b/src/storage.js
@@ -159,11 +159,15 @@ export async function getTrustedOrigins() {
 }
 
 /**
- * Get auto-sign setting
+ * Get auto-sign setting.
+ * Defaults to OFF: a freshly installed extension must not silently sign or
+ * auto-trust any origin (including recognised Solid hosts) until the user
+ * deliberately enables auto-sign from the popup. This keeps the silent
+ * trusted-origin Solid / NIP-98 path strictly opt-in.
  * @returns {Promise<boolean>}
  */
 export async function getAutoSign() {
-  const { [STORAGE_KEYS.AUTO_SIGN]: autoSign = true } =
+  const { [STORAGE_KEYS.AUTO_SIGN]: autoSign = false } =
     await chrome.storage.local.get([STORAGE_KEYS.AUTO_SIGN]);
 
   return autoSign;

From fdab878a745267229bb6fa674c32558a8d23165d Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 20:59:34 +0000
Subject: [PATCH 23/24] ci: package built extension as a downloadable artifact
 for sideloading

Adds Package + upload-artifact steps so every CI run produces
podkey-extension.zip (manifest + src + popup + icons), loadable via
chrome://extensions -> Load unpacked. Answers 'does CI produce a
sideloadable extension'.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 .github/workflows/ci.yml | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f74ecc1..19d4dd9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -33,3 +33,15 @@ jobs:
 
       - name: Lint
         run: npm run lint
+
+      - name: Package extension (sideloadable unpacked zip)
+        run: |
+          mkdir -p dist
+          zip -r dist/podkey-extension.zip manifest.json src popup $([ -d icons ] && echo icons) -x '*.test.js'
+
+      - name: Upload extension artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: podkey-extension
+          path: dist/podkey-extension.zip
+          if-no-files-found: error

From 66e8eb7804b5cb2ccce6a755518e600bd35da577 Mon Sep 17 00:00:00 2001
From: Claude Code <github@thedreamlab.uk>
Date: Sun, 14 Jun 2026 21:24:58 +0000
Subject: [PATCH 24/24] fix(ci): use portable test glob (test/*.test.js)

node --test on the runner's non-globstar sh never expanded
test/**/*.test.js, so CI reported 'Could not find'. All test files are
flat in test/, so a single * is correct and portable. Pre-existing
fragility surfaced by adding CI.

Co-Authored-By: jjohare <github@thedreamlab.uk>
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 39ffcd3..fafbc50 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
     "dev": "echo 'Load extension from chrome://extensions in developer mode'",
     "build": "npm run bundle",
     "bundle": "node scripts/bundle.js",
-    "test": "node --test test/**/*.test.js",
+    "test": "node --test test/*.test.js",
     "lint": "eslint src/"
   },
   "keywords": [