Changeset 2bfe26c in Klonkt

Timestamp:

08/08/2026 07:00:17 AM (5 weeks ago)

Author:

roboburr <roboburr@…>

Branches:

main

Children:

0b0cd54

Parents:

f3a2556

git-author:

Robin <roboburr@…> (08/08/2026 07:00:15 AM)

git-committer:

roboburr <roboburr@…> (08/08/2026 07:00:17 AM)

Message:

Voorstellen vanuit de app, en een kind dat zelf kan vragen (shaer-8ru)

Barts opdracht: bouw shaer-8ru zodat de apps ook kunnen voorstellen, en maak
daarnaast het pad voor de ward om zelf een voorstel aan te zwengelen als hij
tegen een gated feature aanloopt.

DEEL 1 -- DE APPS KUNNEN VOORSTELLEN. De outbox kent nu een Offer van een
shaer:GatedSetting, precies de vorm die 5.6 al beschrijft en die de inbox al las.
De afweging zelf is verhuisd naar AP.proposeGate, waar de PWA-route nu ook
doorheen loopt. Twee implementaties naast elkaar zou een tweede weg naar
hetzelfde besluit zijn -- exact de fout die we vanmiddag bij de antwoordpoort
rechtzetten, toen de innamepoort alleen in C2S bleek te zitten.

DEEL 2 -- HET KIND KRIJGT WOORDEN. Tot nu toe liep alles over de guardians: zij
zien de catalogus, zij stellen voor, zij tellen. Het kind liep tegen een dichte
deur en kon niets. Nu stuurt het een shaer:gateRequest, en die landt bij zijn
guardians BIJ DE POORT waar hij over gaat -- niet in een aparte lijst die je
apart moet openen en dus vergeet.

EEN VRAAG IS GEEN STEM, en dat is de hele grens. Het verzoek is geen voorstel en
telt nergens mee; pas als een guardian het oppakt wordt het een voorstel dat
langs de gewone tally gaat. Anders opent een kind zijn eigen poort door hard
genoeg te vragen. Er staat een toets op die kijkt of er echt geen voorstel en
geen open poort uit ontstaat.

NIET DE REDDINGSBOEI. Een hulpvraag is een noodgeval en gaat door elke dichte
deur; dit is een wens. Ze door elkaar laten lopen zou de boei devalueren tot "het
kind wil iets", en dan kijkt er op een dag niemand meer op als hij afgaat.

GEEN VRIJE TEKST, en dat is geen gierigheid maar de reden dat het verzoek langs
de messages-poort MAG. Een kind met berichten dicht kan nog steeds om iets
vragen, zonder dat er een kanaal ontstaat om omheen die poort te praten. Wil het
uitleggen waarom, dan is dat een gesprek, en gesprekken hebben hun eigen poort.

Alleen van een eigen ward: een verzoek van een vreemde is geen vraag maar een
onbekende die iets over jouw instellingen wil zeggen.

Twaalf toetsen. Twee mutaties gecontroleerd (1 en 6 rood). Suite 712/712.

Files:

• src/config/database.js (modified) (1 diff)
• src/routes/guardian.js (modified) (1 diff)
• src/services/ActivityPubService.js (modified) (6 diffs)
• src/services/guardianship/delivery.js (modified) (2 diffs)
• src/services/guardianship/gatereq.js (added)
• src/services/guardianship/index.js (modified) (1 diff)
• src/services/guardianship/queues.js (modified) (2 diffs)
• test/gate-request.test.js (added)
• test/gated-propose-c2s.test.js (added)

src/config/database.js

@@ -776 +776 @@
   )`);
   db.exec('CREATE INDEX IF NOT EXISTS idx_ap_help_state_note ON ap_help_state(note_uri)');
+  // Een kind dat zelf om een poort vraagt (shaer-8ru). Een VRAAG, geen stem:
+  // pas als een guardian hem oppakt wordt het een voorstel dat langs de tally
+  // gaat. handled_at in plaats van verwijderen -- wat een kind gevraagd heeft
+  // hoort terug te vinden te zijn, ook als het antwoord nee was.
+  db.exec(`CREATE TABLE IF NOT EXISTS ap_gate_requests (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    slug TEXT NOT NULL,                 -- de guardian die hem ontving
+    ward_uri TEXT NOT NULL,
+    feature TEXT NOT NULL,
+    note_uri TEXT,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+    handled_at TEXT,
+    UNIQUE (slug, ward_uri, feature, handled_at)
+  )`);
+  db.exec('CREATE INDEX IF NOT EXISTS idx_ap_gate_requests_slug ON ap_gate_requests(slug, handled_at)');
   ensureColumn('ap_mentions', 'help_request', 'INTEGER'); // inbound ward call-for-help (Guardian PWA message centre)
   ensureColumn('ap_outbox', 'wave', 'INTEGER');    // FEP-633c shaer:wave (guardian -> ward nudge)

src/routes/guardian.js

@@ -620 +620 @@
   const site = siteForUser(req);
   if (!site) return res.status(404).json({ error: 'no_site' });
-  const uri = String(req.body?.uri || '').trim();
-  const allow = req.body?.allow === true;
-  if (!uri) return res.status(400).json({ error: 'empty_uri' });
-  // Only a guardian of this ward, and only for a ward we host: a setting on a
-  // remote ward belongs to that ward's own server (federating it is Fase 4).
-  const isMyWard = Guardianship.listWards(site.slug).some((w) => w.other_uri === uri);
-  if (!isMyWard) return res.status(403).json({ error: 'not_your_ward' });
-  // §5.6: propose it to the WARD'S server, wherever that is. The ward's server
-  // tallies (a majority of its guardians, §3.5) and enforces. Co-location is
-  // just the case where that server happens to be this one, so it takes the
-  // same road: propose, then let the tally decide. Anything else would make a
-  // guardian on the ward's own instance more powerful than one elsewhere.
-  const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
-  const me = AP.actorId(base, site.slug);
-  const feature = req.body.feature;   // normalised by the route above
-  const offerId = `${me}/gated/${Date.now().toString(36)}${Math.floor(Math.random() * 1e4).toString(36)}`;
-  const offer = Guardianship.gated.buildGatedOffer(offerId, me, uri, feature, allow);
-  // ONE path, whether the ward lives here or on the other side of the world
-  // (Robins regel, 29-7): propose over the wire and let the ward's server do
-  // what it does for everyone. deliverToActor loops a local recipient back
-  // into the same inbox handler, so co-location changes the transport and
-  // nothing else. The old shortcut recorded the vote here directly, which is
-  // how the remote path stayed broken for a month without anyone noticing.
-  // Our own record of what we sent (5.6): the ward's server answers this Offer
-  // once the decision settles, and that answer needs a row to land in. It is
-  // also the only way the proposer's screen can say more than a button caption.
-  Guardianship.gated.recordSent(offerId, site.slug, uri, feature, allow);
-  AP.deliverToActor(site, uri, offer).catch(() => { /* queued, best-effort */ });
-  const localSlug = (base && uri.startsWith(`${base}/`)) ? uri.replace(/\/+$/, '').split('/').pop() : null;
-  const progress = localSlug ? Guardianship.gated.gatedProgress(localSlug, feature) : null;
-  res.json({ ok: true, allow, state: 'open', ...(progress || { federated: true }) });
+  // De hele afweging staat in AP.proposeGate, zodat de apps langs dezelfde weg
+  // kunnen voorstellen (shaer-8ru). Deze route is nog maar de PWA-deur ernaartoe.
+  const uit = AP.proposeGate(site, req.body?.uri, req.body?.feature, req.body?.allow === true);
+  const { status, ...rest } = uit;
+  return res.status(status === 200 ? 200 : status).json(rest);
 }
 

src/services/ActivityPubService.js

@@ -2632 +2632 @@
             Guardianship.availability.declareAway(slug, actorUri, until);
             console.log('[AP] guardian declared away (3.6.1):', actorUri, '→', slug, 'until', new Date(until).toISOString());
+          }
+        }
+        // Een kind dat zelf om een poort vraagt (shaer-8ru). Zelfde weg als de
+        // afwezigheidsmelding: een gewone directe note met een shaer:-markering,
+        // per genoemde ontvanger afgehandeld.
+        //
+        // ALLEEN VAN EEN EIGEN WARD. Een verzoek van een vreemde is geen vraag
+        // maar een onbekende die iets over jouw instellingen wil zeggen -- dat
+        // hoort in geen enkele lijst te belanden waar een guardian op afgaat.
+        {
+          const req = Guardianship.gatereq.parseRequest(o);
+          if (req) {
+            for (const slug of slugs) {
+              const mijn = (() => { try { return Guardianship.listWards(slug).some((w) => w.other_uri === actorUri); } catch { return false; } })();
+              if (!mijn) { console.warn('[AP] gate request from someone who is not our ward, ignored:', actorUri, '→', slug); continue; }
+              Guardianship.gatereq.record(slug, actorUri, req.feature, o.id);
+              console.log('[AP] gate request', req.feature, actorUri, '→', slug);
+            }
           }
         }
@@ -3237 +3255 @@
   try {
     switch (type) {
+      // Een gate-voorstel uit de app (5.6, shaer-8ru). De PWA deed dit al over
+      // een eigen route; hier komt het binnen als wat het in AP IS -- een Offer
+      // van een shaer:GatedSetting. Dezelfde functie erachter, want twee wegen
+      // naar hetzelfde besluit is precies wat we vandaag hebben rechtgezet.
+      case 'Offer': {
+        const gs = Guardianship.gated.parseGatedSetting(object);
+        if (!gs) return { status: 400, error: 'unsupported_offer' };
+        const uit = proposeGate(site, gs.ward, gs.feature, gs.value);
+        if (uit.status !== 200) return uit;
+        return { ...uit, status: 201, id: uit.offerId };
+      }
       case 'Create': {
         if (!object || typeof object !== 'object') return { status: 400, error: 'missing_object' };
@@ -3248 +3277 @@
           const isWard = (() => { try { return Guardianship.listGuardians(site.slug).length > 0; } catch { return false; } })();
           const isHelp = object['shaer:helpRequest'] === true || object.helpRequest === true;
+          // Een poortverzoek van het kind zelf (shaer-8ru) gaat langs de
+          // messages-poort. Dat lijkt een gat en is het niet: het verzoek draagt
+          // ALLEEN de naam van de feature, geen vrije tekst, dus er ontstaat geen
+          // kanaal om omheen die poort te praten. Zonder deze uitzondering kan
+          // een kind met berichten dicht nergens meer om vragen -- en dan is de
+          // hele weg dood op precies het moment dat hij nodig is.
+          const isGateReq = !!Guardianship.gatereq.parseRequest(object);
           const direct = c2sVisibility(object) === 'direct';
-          if (!isHelp) {
+          if (!isHelp && !isGateReq) {
             if (direct && !Guardianship.wardGateAllowed(site.gate_messages, isWard)) {
               return { status: 403, error: 'gated_messages' };
@@ -3307 +3343 @@
             // absence like it does for a ward anywhere else. One path.
           }
-          const r = await deliverDirectNote(site, { recipients, text: plain, language: object.language || null, inReplyTo: typeof object.inReplyTo === 'string' ? object.inReplyTo : null, attachments: atts, helpRequest: help, awayUntil });
+          const gateReq = Guardianship.gatereq.parseRequest(object);
+          const r = await deliverDirectNote(site, { recipients, text: plain, language: object.language || null, inReplyTo: typeof object.inReplyTo === 'string' ? object.inReplyTo : null, attachments: atts, helpRequest: help, awayUntil, gateRequest: gateReq && gateReq.feature });
           if (!r || !r.id) return { status: 502, error: 'direct_failed' };
           return { status: 201, id: r.id, url: `${base}/ap/notes/${r.id}` };
@@ -3538 +3575 @@
 // Send a reply FROM this site to a remote actor (in reply to their inbound reply).
 // `parent` = an ap_interactions row (actor_uri, actor_url, actor_handle, object_uri).
+/**
+ * Een gate-voorstel de deur uit (FEP-633c 5.6, shaer-8ru).
+ *
+ * STOND IN routes/guardian.js en kon daar alleen door de PWA aangeroepen worden.
+ * De apps moeten hetzelfde kunnen, en een tweede implementatie ernaast zou een
+ * tweede weg naar hetzelfde besluit zijn -- precies de fout die we vandaag bij
+ * de antwoordpoort hebben rechtgezet, toen de innamepoort alleen in C2S bleek te
+ * zitten en het webpad eromheen liep. Een pad dus.
+ *
+ * EEN WEG, waar de ward ook woont (Robins regel, 29-7): voorstellen over de
+ * lijn en de server van de ward laat tellen. Co-locatie verandert alleen het
+ * transport -- deliverToActor lust een lokale ontvanger terug door dezelfde
+ * inbox. De oude kortsluiting boekte de stem hier meteen, en zo bleef het
+ * remote-pad een maand stuk zonder dat iemand het merkte.
+ */
+export function proposeGate(site, wardUri, feature, allow) {
+  const uri = String(wardUri || '').trim();
+  if (!uri) return { status: 400, error: 'empty_uri' };
+  if (!Guardianship.gated.featureColumn(feature)) return { status: 400, error: 'unknown_feature' };
+  // Alleen een guardian van dit kind. Zonder deze regel zou iedereen met een
+  // token een instelling van een vreemd kind kunnen aanvragen.
+  if (!Guardianship.listWards(site.slug).some((w) => w.other_uri === uri)) {
+    return { status: 403, error: 'not_your_ward' };
+  }
+  const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
+  const me = actorId(base, site.slug);
+  const offerId = `${me}/gated/${Date.now().toString(36)}${Math.floor(Math.random() * 1e4).toString(36)}`;
+  const offer = Guardianship.gated.buildGatedOffer(offerId, me, uri, feature, allow);
+  // Ons eigen spoor van wat we stuurden: de server van de ward antwoordt op deze
+  // Offer zodra het besluit valt, en dat antwoord heeft een rij nodig om in te
+  // landen. Het is ook het enige waardoor het scherm van de voorsteller meer kan
+  // zeggen dan een knoptekst.
+  Guardianship.gated.recordSent(offerId, site.slug, uri, feature, allow);
+  deliverToActor(site, uri, offer).catch(() => { /* queued, best-effort */ });
+  const localSlug = (base && uri.startsWith(`${base}/`)) ? uri.replace(/\/+$/, '').split('/').pop() : null;
+  const progress = localSlug ? Guardianship.gated.gatedProgress(localSlug, feature) : null;
+  return { status: 200, ok: true, allow, state: 'open', offerId, ...(progress || { federated: true }) };
+}
+
 export async function deliverReply(site, { postId, postSlug, parent, text, html, language, attachments, mentions, visibility }) {
   const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
@@ -6113 +6189 @@
   getNotifications, listBlocks, isBlockedAny, blockTarget, unblock,
   deliverWithRetry, enqueueDelivery, processDeliveryQueue, startDeliveryWorker,
-  getReplyUris, getThread, filterThreadToCircle, gateAttachments, stripEmojiTags, markNotificationsSeen, countUnseenNotifications, hasPlayableAudio,
+  proposeGate, getReplyUris, getThread, filterThreadToCircle, gateAttachments, stripEmojiTags, markNotificationsSeen, countUnseenNotifications, hasPlayableAudio,
   linkifyBody, bakePostContent, bakePostContentWithMentions, listFollowers, removeFollower, listConnections,
   noteVisibility, belongsInTimeline, playerUrlFor, isRejectedObject, rejectInteraction, interactionReportTarget,

src/services/guardianship/delivery.js

@@ -41 +41 @@
 // guardian on any instance receives it as a private mention (the ward
 // call-for-help path).
-export async function deliverDirectNote(site, { recipients, text, html, language, inReplyTo, attachments, helpRequest, wave, awayUntil, helpMark }) {
+export async function deliverDirectNote(site, { recipients, text, html, language, inReplyTo, attachments, helpRequest, wave, awayUntil, helpMark, gateRequest }) {
   const { actorId, fetchActor, localActor, deliverTo, deriveHandle, escHtml, linkUrls, linkHashtags,
           getOutboxRow, buildReplyNote, AP_CONTEXT, getOrCreateKeys, deliver, enqueueDelivery } = deps;
@@ -116 +116 @@
     note[helpMark.kind === 'handled' ? 'shaer:helpHandled' : 'shaer:helpPickup'] = helpMark.noteUri;
   }
+  // Een kind dat zelf om een poort vraagt (shaer-8ru). Alleen de naam van de
+  // feature reist mee -- geen vrije tekst, zie gatereq.js.
+  if (gateRequest) note['shaer:gateRequest'] = String(gateRequest);
   const create = {
     '@context': AP_CONTEXT,

src/services/guardianship/index.js

@@ -35 +35 @@
 // 5.2.1: wie er op een hulpvraag af is en wanneer hij is afgesloten (shaer-lgo)
 export * as help from './help.js';
+export * as gatereq from './gatereq.js';

src/services/guardianship/queues.js

@@ -15 +15 @@
 import * as follows from './follows.js';
 import * as gated from './gated.js';
+import * as gatereq from './gatereq.js';
 import * as handshake from './handshake.js';
 
@@ -169 +170 @@
       feature: p.feature, value: !!p.value, status: gated.sentStatus(p, Date.now()),
     })),
-    waiting: { 'shaer:follows': wachtend || undefined },
+    // Wat er op deze poort wacht: volgverzoeken bij de volgpoort, en de vraag
+    // van het kind zelf bij de poort waar hij over gaat (shaer-8ru). Zo staat
+    // hij waar je hem nodig hebt, en niet in een aparte lijst die je apart moet
+    // openen -- en die je dus vergeet.
+    waiting: { ...gatereq.waitingFor(mySlug, wardUri), 'shaer:follows': wachtend || undefined },
   });
 }