Address copilot review on #2

- Multikey docstring: "e70102" → "e701" (constant was already correct;
  comment was stale from earlier fix).
- nostrPubkeyToMultikey: validate that input is actually hex, not just
  64 chars long.
- doctor.js: only reveal add-key section when the profile fetched
  successfully; runAll now returns { checks, profileFetched, docUrl }
  so callers can distinguish "diagnostics ran" from "diagnostics found
  a real profile to root a snippet against."
- doctor.js: clear stale signer output on connection error so users
  can't accidentally copy an outdated snippet after a failed reconnect.

Also corrected the verificationMethod controller while in the file:
the spec / JSS Phase A profile shape uses the WebID-with-fragment as
controller (matching the profile's outer `controller` predicate), not
the bare document URL. Updated lws-cid.js's VM-controller check to
compare against the profile's @id with fragment so the validator and
generator agree.

Author: melvincarvalho

doctor.js

@@ -53,16 +53,21 @@ form.addEventListener('submit', async (e) => {
   results.hidden = false;
 
   try {
-    const checks = await runAll(url);
+    const { checks, profileFetched, docUrl } = await runAll(url);
     renderChecks(checks);
-    lastWebId = url;
-    revealAddKeySection();
+    if (profileFetched && docUrl) {
+      lastWebId = docUrl;
+      revealAddKeySection();
+    } else {
+      hideAddKeySection();
+    }
   } catch (err) {
     renderChecks([{
       status: 'fail',
       label: 'Diagnostics crashed',
       detail: String(err?.message || err),
     }]);
+    hideAddKeySection();
   } finally {
     button.disabled = false;
     button.textContent = 'Run diagnostics';
@@ -71,6 +76,7 @@ form.addEventListener('submit', async (e) => {
 
 async function runAll(webIdUrl) {
   const checks = [];
+  const result = { checks, profileFetched: false, docUrl: null };
 
   // 1. Resolve the document URL — strip the fragment.
   let docUrl;
@@ -79,22 +85,22 @@ async function runAll(webIdUrl) {
     docUrl.hash = '';
   } catch (err) {
     checks.push({ status: 'fail', label: 'WebID is a valid URL', detail: err.message });
-    return checks;
+    return result;
   }
   checks.push({ status: 'pass', label: 'WebID is a valid URL', detail: docUrl.toString() });
 
   // 2. Fetch as JSON-LD. We avoid Accept: text/turtle so the conneg layer
   //    doesn't transform the document — we want to validate the JSON-LD
   //    representation directly.
-  let res, body, contentType;
+  let res, contentType;
   try {
     res = await fetch(docUrl.toString(), {
       headers: { 'Accept': 'application/ld+json' },
     });
     contentType = (res.headers.get('content-type') || '').toLowerCase();
   } catch (err) {
     checks.push({ status: 'fail', label: 'Profile is reachable', detail: err.message });
-    return checks;
+    return result;
   }
 
   if (!res.ok) {
@@ -103,7 +109,7 @@ async function runAll(webIdUrl) {
       label: 'Profile is reachable',
       detail: `HTTP ${res.status} from ${docUrl}`,
     });
-    return checks;
+    return result;
   }
   checks.push({
     status: 'pass',
@@ -137,16 +143,20 @@ async function runAll(webIdUrl) {
       label: 'Profile parses as JSON',
       detail: err.message,
     });
-    return checks;
+    return result;
   }
   checks.push({ status: 'pass', label: 'Profile parses as JSON' });
 
+  // Profile was fetched and parsed — safe to root a snippet against this URL.
+  result.profileFetched = true;
+  result.docUrl = docUrl.toString();
+
   // 4. Run LWS-CID structural checks.
   for (const c of runLwsCidChecks(profile, { webIdUrl, docUrl: docUrl.toString() })) {
     checks.push(c);
   }
 
-  return checks;
+  return result;
 }
 
 // --- B.2: connect Nostr signer & compute Multikey VM -----------------
@@ -156,6 +166,24 @@ function revealAddKeySection() {
   detectSigner();
 }
 
+function hideAddKeySection() {
+  addKeySection.hidden = true;
+  signerOutput.hidden = true;
+  pubkeyHexEl.textContent = '';
+  pubkeyMbEl.textContent = '';
+  snippetEl.textContent = '';
+  snippetTarget.textContent = '';
+  lastWebId = null;
+}
+
+function clearSignerOutput() {
+  signerOutput.hidden = true;
+  pubkeyHexEl.textContent = '';
+  pubkeyMbEl.textContent = '';
+  snippetEl.textContent = '';
+  snippetTarget.textContent = '';
+}
+
 function detectSigner() {
   if (typeof window.nostr?.getPublicKey === 'function') {
     setSignerStatus('ready', 'NIP-07 signer detected (window.nostr).');
@@ -185,6 +213,7 @@ connectButton.addEventListener('click', async () => {
     signerOutput.hidden = false;
     setSignerStatus('ready', 'Connected. The snippet below is ready to paste into your profile.');
   } catch (err) {
+    clearSignerOutput();
     setSignerStatus('error', `Could not read pubkey: ${err.message || err}`);
   } finally {
     connectButton.textContent = 'Reconnect signer';

lib/lws-cid.js

@@ -127,11 +127,15 @@ export function runLwsCidChecks(profile, { webIdUrl }) {
       label: `verificationMethod has ${vms.length} entr${vms.length === 1 ? 'y' : 'ies'}`,
     });
 
-    // Entry-level checks.
+    // Entry-level checks. VM controllers are compared against the
+    // profile's @id (with fragment if present) — that matches the CID
+    // v1 self-control pattern where the outer profile.controller is
+    // also the WebID itself, not the bare document URL.
+    const profileIdAbs = absolutize(id, requestedNoHash);
     const seenIds = new Set();
     let allOk = true;
     for (const [i, vm] of vms.entries()) {
-      const probs = validateVerificationMethod(vm, requestedNoHash, idAbs(profile, requestedNoHash));
+      const probs = validateVerificationMethod(vm, requestedNoHash, profileIdAbs);
       if (probs.length === 0) continue;
       allOk = false;
       out.push({
@@ -352,12 +356,3 @@ function absolutize(u, base) {
     return u;
   }
 }
-
-// Helper to compute the absolute, fragmentless form of the profile's
-// own @id — used to check that verificationMethod controllers point at
-// the WebID's document URL.
-function idAbs(profile, base) {
-  const id = profile['@id'] || profile.id;
-  if (!id) return null;
-  return stripHash(absolutize(id, base));
-}

lib/multikey.js

@@ -9,7 +9,7 @@
  *   3. Prepend the multicodec varint for secp256k1-pub: 0xe7, 0x01
  *   4. Multibase-encode with base16-lower — prefix "f"
  *
- * Result: "f" + "e70102" + <parity-hex> + <pubkey-hex>
+ * Result: "f" + "e701" + <parity-hex> + <pubkey-hex>
  */
 
 // Multicodec varint for secp256k1-pub: code 0xe7 → varint bytes 0xe7, 0x01
@@ -28,6 +28,9 @@ export function nostrPubkeyToMultikey(xOnlyHex, opts = {}) {
   if (hex.length !== 64) {
     throw new Error(`Nostr pubkey must be 32 bytes (64 hex chars); got ${hex.length}`);
   }
+  if (!/^[0-9a-f]{64}$/.test(hex)) {
+    throw new Error('Nostr pubkey must be lowercase hex (0-9, a-f)');
+  }
 
   let parity = opts.parity ?? 0x02;
   if (typeof parity === 'string') parity = parseInt(parity, 16);
@@ -79,11 +82,14 @@ export function buildNostrVerificationMethod({ webId, xOnlyHex, fragment = 'nost
   // The VM id is a fragment URI rooted at the WebID's document. We strip
   // any existing fragment so paths like ".../card.jsonld#me" yield
   // ".../card.jsonld#nostr-key-1".
+  // The controller is the WebID itself (with its fragment) — this matches
+  // CID v1 self-control where the profile's outer controller is also the
+  // WebID, so all controller predicates inside the document agree.
   const docUrl = stripHash(webId);
   return {
     id: `${docUrl}#${fragment}`,
     type: 'Multikey',
-    controller: docUrl,
+    controller: webId,
     publicKeyMultibase: mb,
   };
 }