Testclient: gedeelde afhankelijkheden, en zicht op de WebSocket

Een fout van ons, gevonden door de gebruiker bij de tweede eigenaar: "Expected
tab leader port.". createEvoluDeps vraagt via navigator.locks het slot "tab" aan
en kondigt de houder aan als tab leader, en dat slot kan er maar een hebben.
openStore maakte per eigenaar een eigen stel afhankelijkheden, dus de tweede
werd nooit leider. Nu een stel per proces met een teller, zodat het pas
opgeruimd wordt als de laatste store sluit. Dit stond al als valstrik 2 in
PLAN.md 4e en was er alsnog in geslopen; de toets met twee eigenaars tegelijk
brengt hem terug zodra iemand dit ongedaan maakt.

Twee dingen erbij om te kunnen zien wat er met de relay gebeurt:

- spiegel <naam> opent dezelfde eigenaar in een lege database naast de
  bestaande. Alles wat daar binnenkomt heeft de heen- en terugreis over de relay
  gemaakt, en dat is de enige manier waarop de clientkant kan bewijzen dat er
  werkelijk iets op de relay staat; lees toont je altijd je eigen rijen.
- onWebSocket meldt welke URL geopend wordt en wat ermee gebeurt. Zonder dat
  ziet een relay die de socket dichtgooit er hetzelfde uit als een trage relay.

Dat luikje gaf meteen het antwoord: de socket komt nooit open, 1006, in een
herhaallus, en met het ws-pakket ernaast staat er wat de globale WebSocket
verzwijgt: 401. Twee eigenaars die eerder allebei 101 gaven zijn dus uit de
allowlist van de relay verdwenen. Dat is een vraag over de server-app en staat
als open punt 9, met vier verklaringen en wat ze uit elkaar houdt.

Suite: 478 goed, 0 fout.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

tools/relay-client/src/cli.js

@@ -11,6 +11,8 @@
 //  scherm komt.
 // ═══════════════════════════════════════════════════════════════════════════════
 
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 
 import { gebruiksaanwijzing, leesArgumenten } from './argumenten.js';
@@ -48,6 +50,11 @@ const openVoor = (regel, { metRelay }) =>
       console.error(defect);
       process.exit(1);
     },
+    // Wat Evolu wérkelijk opent, en niet wat wij hem meegaven. De `OwnerId` in
+    // die URL is wat de relay ziet en dus wie er toegelaten of geweigerd wordt.
+    onWebSocket: (m) => {
+      console.log(`  socket ${m.wat}: ${m.url}${m.detail ? ` (${m.detail})` : ""}`);
+    },
   });
 
 const eisRelay = () => {
@@ -154,6 +161,76 @@ const opdrachten = {
     process.exit(uitkomst.geaccepteerd ? 0 : 1);
   },
 
+  spiegel: async ({ naam }, vlaggen) => {
+    // De enige proef die van de cliëntkant kan bewijzen dat er werkelijk iets op
+    // de relay staat. Dezelfde eigenaar, een lege database ernaast: alles wat
+    // hier binnenkomt heeft de heenreis en de terugreis gemaakt.
+    //
+    // Waarom dit nodig is: de cliënt is local-first, dus `lees` toont je altijd
+    // je eigen rijen, ook als de relay ze nooit gezien heeft. Wat de relay
+    // bewaart is van hier niet te zien; dit is de omweg eromheen.
+    eisRelay();
+    const { regel } = haalEigenaarOp(naam);
+    const seconden = Number.parseInt(vlaggen.wacht ?? '15', 10);
+
+    const tijdelijk = mkdtempSync(join(tmpdir(), 'relay-client-spiegel-'));
+    console.log(`"${naam}" opnieuw opgehaald in een lege database.`);
+    console.log(`  ${tijdelijk}`);
+    console.log(`  ${config.relayUrl}`);
+    console.log('');
+
+    const store = await openStore({
+      directory: tijdelijk,
+      owner: eigenaarUitMnemonic(regel.mnemonic),
+      relayUrl: config.relayUrl,
+      onWebSocket: (m) => { console.log(`  socket ${m.wat}: ${m.url}${m.detail ? ` (${m.detail})` : ""}`); },
+      onDefect: (defect) => {
+        console.error('Defect uit een worker, de opdracht wordt afgebroken:');
+        console.error(defect);
+        process.exit(1);
+      },
+    });
+
+    try {
+      // Peilen tot het aantal een paar rondes stil blijft. Er is geen signaal
+      // "hier ben ik klaar": Evolu synchroniseert en blijft synchroniseren.
+      let vorige = -1;
+      let stil = 0;
+      for (let ronde = 0; ronde < seconden * 2; ronde += 1) {
+        await new Promise((klaar) => {
+          setTimeout(klaar, 500);
+        });
+        const nu = (await store.lees()).length;
+        if (nu === vorige && nu > 0) {
+          stil += 1;
+          if (stil >= 6) break;
+        } else {
+          stil = 0;
+        }
+        vorige = nu;
+      }
+
+      const rijen = await store.lees();
+      if (rijen.length === 0) {
+        console.log('Er kwam niets terug.');
+        console.log('');
+        console.log('Dat kan twee dingen betekenen en de cliënt kan ze niet uit elkaar houden:');
+        console.log('de relay heeft niets van deze eigenaar, of hij was er nog niet klaar mee.');
+        console.log('Probeer `--wacht 60` en kijk anders op de statuspagina van de app.');
+        return;
+      }
+      console.log(`${rijen.length} blob(s) terug van de relay:`);
+      for (const rij of rijen) {
+        console.log(`  ${rij.id}  ${String(rij.body?.length ?? 0).padStart(8)} bytes  ${rij.label}`);
+      }
+    } finally {
+      await store.sluit();
+      // Eigen tijdelijke map, dus die ruimt deze opdracht zelf op. Er zit een
+      // database van een echte eigenaar in.
+      rmSync(tijdelijk, { recursive: true, force: true });
+    }
+  },
+
   sync: async ({ naam }) => {
     eisRelay();
     const { regel } = haalEigenaarOp(naam);