Changeset e311202 in Klonkt

Timestamp:

08/21/2026 08:44:47 AM (3 weeks ago)

Author:

Robin <roboburr@…>

Branches:

main

Children:

4e5fe29

Parents:

bb9e54c

Message:

A block now leaves the house: Block out, Undo(Block) back

Blocking was purely local — row in ap_blocks, purge the cached content,
drop the follower — and the other side never heard about it. The hub
kept the channel and every post, because nothing told it and its
unsigned crawl kept reading the public outbox (seen on dev.klonkt.com,
21-8).

Now blocking delivers a Block to the blocked actor's inbox and
unblocking an Undo(Block), so the way back stays open. Delivery can
never hold up the block itself: the row is written first and a
failed delivery is swallowed. Domain blocks send nothing — no inbox to
address.

Second door: a signed reader we block gets the same 404 on /ap/notes/:id
that a stranger gets, matching what the outbox already did. Unsigned
callers stay anonymous to us and keep the public view; that is what the
Block delivery is for.

Co-Authored-By: Claude Fable 5 <noreply@…>

Files:

• src/routes/activitypub.js (modified) (1 diff)
• src/routes/posts.js (modified) (1 diff)
• src/services/ActivityPubService.js (modified) (2 diffs)
• src/services/BlocklistService.js (modified) (2 diffs)
• test/block-federeert.test.js (added)

src/routes/activitypub.js

@@ -1258 +1258 @@
   // cannot_resolve_inReplyTo. Strangers still get the exact same 404, so a
   // note's existence stays as private as before.
+  // EEN GEBLOKKEERDE KRIJGT DE DEUR DICHT (Robin, 21-8), net als bij de outbox:
+  // wie ondertekend aanklopt, klopt met zijn naam erop, en een blokkade is een
+  // gesloten deur. Dezelfde 404 als een vreemde, zodat het bestaan van een note
+  // niets extra's verraadt. Onbetekende verzoeken kunnen we niet thuisbrengen
+  // en houden de publieke weergave -- daarvoor is de Block-bezorging.
+  if (req.headers['signature']) {
+    const wie = await AP.verifyRequest(req).catch(() => null);
+    if (wie && wie.id && AP.isBlockedAny(wie.id)) return res.status(404).end();
+  }
   const post = db.prepare(
     "SELECT * FROM posts WHERE id = ? AND status = 'published'"

src/routes/posts.js

@@ -1534 +1534 @@
 router.post('/blocking/remove', requireSiteManager, (req, res) => {
   const site = res.locals.site;
-  if (site) { try { ActivityPubService.unblock(site, (req.body.target || '').toString()); } catch (e) { /* ignore */ } }
+  if (site) { try { ActivityPubService.unblock(site, (req.body.target || '').toString()).catch(() => {}); } catch (e) { /* ignore */ } }
   res.redirect('/blocking?success=' + encodeURIComponent('Deblokkeerd'));
 });

src/services/ActivityPubService.js

@@ -3600 +3600 @@
         if (innerType === 'Block') {
           if (!innerTarget) return { status: 400, error: 'missing_object' };
-          unblock(site, innerTarget);   // release from Orbit
+          unblock(site, innerTarget).catch(() => {});   // release from Orbit
           return { status: 202, url: innerTarget };
         }
@@ -6666 +6666 @@
 // Block an actor (@handle or actor URL) or a whole domain; purges their content.
 // The handle resolver is ours; the storage/purge lives in BlocklistService.
-export async function blockTarget(site, input) { return Blocklist.blockTarget(site, input, webfingerResolve); }
-
-export function unblock(site, target) { return Blocklist.unblock(site, target); }
+//
+// De BEZORGING hoort ook hier: BlocklistService kent de database, niet het
+// afleveren. Een Block gaat naar de inbox van wie je blokkeert, een
+// Undo(Block) bij het opheffen -- zonder retry-wachtrij, want een blokkade
+// wacht niet op een server die even plat ligt (en bij opheffen komt de ander
+// vanzelf weer langs).
+async function bezorgBlokkade(site, target, undo) {
+  const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
+  const me = actorId(base, site.slug);
+  const blok = { id: `${me}#block-${Date.now()}-${rid()}`, type: 'Block', actor: me, object: target, to: [target] };
+  const activiteit = undo
+    ? { '@context': AP_CONTEXT, id: `${me}#unblock-${Date.now()}-${rid()}`, type: 'Undo', actor: me, object: blok, to: [target] }
+    : { '@context': AP_CONTEXT, ...blok };
+  const r = await deliverToActor(site, target, activiteit);
+  console.log('[AP]', undo ? 'Undo(Block)' : 'Block', site.slug, '→', target, r && r.delivered ? 'bezorgd' : 'niet bezorgd');
+}
+
+export async function blockTarget(site, input) { return Blocklist.blockTarget(site, input, webfingerResolve, bezorgBlokkade); }
+
+export function unblock(site, target) { return Blocklist.unblock(site, target, bezorgBlokkade); }
 
 // ── Guardianship module wiring (src/services/guardianship/) ────────

src/services/BlocklistService.js

@@ -56 +56 @@
 // `resolveHandle` (async handle → actor URL) is injected by the caller so this
 // service needs nothing from ActivityPubService (no circular import).
-export async function blockTarget(site, input, resolveHandle) {
+/**
+ * Een blokkade is pas een blokkade als de ander het merkt (Robin, 21-8).
+ *
+ * Tot vandaag bleef hij binnenshuis: rij in ap_blocks, inhoud opruimen, volger
+ * eruit -- en verder niets. De andere kant volgde je dan nog steeds in zijn
+ * eigen boeken en bleef je publieke outbox lezen. Precies wat de hub deed:
+ * kanaal en berichten stonden er gewoon nog. Vandaar dat we het nu ook
+ * VERSTUREN, zoals Mastodon dat doet: een Block naar de inbox van wie je
+ * blokkeert, en bij opheffen een Undo(Block) zodat de weg terug openligt.
+ *
+ * Alleen voor een actor-blokkade: een heel domein heeft geen inbox om aan te
+ * schrijven. En bezorgen mag nooit de blokkade zelf tegenhouden -- die staat
+ * al vast in de database voordat we ook maar iets proberen te versturen.
+ */
+async function meldBlokkade(site, target, kind, bezorg, undo = false) {
+  if (kind !== 'actor' || typeof bezorg !== 'function') return;
+  try { await bezorg(site, target, undo); } catch { /* de blokkade staat, de melding is een gunst */ }
+}
+
+export async function blockTarget(site, input, resolveHandle, bezorg) {
   const raw = String(input || '').trim();
   if (!site || !site.slug || !raw) return { error: 'empty' };
@@ -69 +88 @@
   purgeBlocked(kind, target);
   console.log('[AP] block', site.slug, kind, target);
+  await meldBlokkade(site, target, kind, bezorg);
   return { ok: true, label };
 }
 
-export function unblock(site, target) { blStmts().del.run(site.slug, target); return { ok: true }; }
+export async function unblock(site, target, bezorg) {
+  const rij = blStmts().list.all(site.slug).find((b) => b.target === target);
+  blStmts().del.run(site.slug, target);
+  // Undo(Block) zodat de ander weet dat de deur weer open is; zonder dit blijft
+  // hij bij zichzelf geblokkeerd staan en komt hij nooit terug.
+  await meldBlokkade(site, target, (rij && rij.kind) || 'actor', bezorg, true);
+  return { ok: true };
+}
 
 export default { listBlocks, isBlockedAny, blockTarget, unblock };