source: Klonkt/src/routes/ward.js@ 5b6f93b

/**
 * De Ward PWA (FEP-633c): de tegenhanger van /guardian, maar dan vanuit het
 * kind gezien. Shaer doet dit als native app; dit is dezelfde ward-kant in de
 * browser, voor wie geen app kan of wil installeren.
 *
 * Plak 1 is bewust HET VANGNET en niet de sociale kant: wie over mij waakt,
 * of dat vangnet ook echt heel is, wat er bij mijn guardians ligt te wachten,
 * en de knop om hulp te vragen. De feed en de composer heeft Klonkt al op de
 * gewone site; die dubbelen we hier niet zomaar.
 *
 * Alles is gescoped op een site die de ingelogde gebruiker BEZIT, precies als
 * bij /guardian (?site=slug kiest er een als je er meerdere hebt). Views
 * dragen geen inline scripts (CSP): de logica staat in /assets/js/ward.js.
 */
import express from 'express';
import multer from 'multer';
import fs from 'fs';
import { randomUUID } from 'crypto';
import path from 'path';
import { fileURLToPath } from 'url';
import { mediaDir } from '../config/paths.js';
import db from '../config/database.js';
import { requireAuth } from '../middleware/auth.js';
import AP from '../services/ActivityPubService.js';
import * as Guardianship from '../services/guardianship/index.js';
// offers en carriesGuardians komen NIET als naamruimte uit index.js (die
// exporteert er losse namen van), dus rechtstreeks uit hun eigen module.
import * as Offers from '../services/guardianship/offers.js';
import { carriesGuardians } from '../services/guardianship/context.js';
import { t as i18nT, resolveLang } from '../services/i18n.js';
import { injectCspNonce, renderNoteBody, formatDateTime } from '../middleware/render.js';

const router = express.Router();
const __dir = path.dirname(fileURLToPath(import.meta.url));

/** De handelende site: ?site=slug als je hem bezit, anders je eerste. */
function siteForUser(req) {
  const userId = req.session.user.id;
  const want = String(req.query.site || req.body?.site || '').trim();
  if (want) {
    const s = db.prepare('SELECT * FROM sites WHERE slug = ? AND owner_id = ?').get(want, userId);
    if (s) return s;
  }
  return db.prepare('SELECT * FROM sites WHERE owner_id = ? ORDER BY id LIMIT 1').get(userId);
}

/**
 * Alles wat het scherm in één keer nodig heeft.
 *
 * Bewust ZONDER netwerk: dit draait bij elke paginaweergave, en een trage
 * guardian-server mag de eigen pagina van een kind niet ophouden. Wat een
 * remote fetch vraagt (de §4-controle) zit in een eigen endpoint dat de app
 * ná het tekenen ophaalt.
 */
function wardState(site, L) {
  const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
  const me = AP.actorId(base, site.slug);
  const guardianRows = Guardianship.listGuardians(site.slug);
  const uris = guardianRows.map((g) => g.other_uri).filter(Boolean);
  const statuses = Guardianship.availability.statusesFor(site.slug, uris, Date.now());
  const byUri = new Map(statuses.map((s) => [s.id || s.uri, s]));

  return {
    me,
    slug: site.slug,
    // Wie over mij waakt. De beschikbaarheid staat erbij omdat een guardian
    // die weg is de echte maat van je vangnet verandert (§3.6).
    guardians: guardianRows.map((g) => {
      const st = byUri.get(g.other_uri) || {};
      return {
        uri: g.other_uri,
        handle: g.other_handle || AP.deriveHandleFor?.(g.other_uri) || g.other_uri,
        availability: st['shaer:availability'] || st.availability || 'active',
        awayUntil: st['shaer:awayUntil'] || st.awayUntil || null,
      };
    }),
    // Aanbiedingen waar IK een partij in ben: iemand wil mijn guardian worden,
    // of er loopt een verzoek om er een te laten gaan.
    offers: Offers.listForParty(site.slug, me).map((o) => Offers.queueItem(o, me)),
    // Wat ik wilde volgen en wat bij mijn guardians ligt (§5.3 uitgaand).
    // Dit is de derde uitkomst die Shaer ook toont: niet verstuurd, niet
    // mislukt, maar wachtend op iemand die je kent.
    waitingFollows: Guardianship.outgoing.listForWard(site.slug).map((o) => ({
      id: o.id,
      target: o.target_uri,
      handle: o.target_handle || o.target_uri,
      status: o.status,
      createdAt: o.created_at,
    })),
    strings: {
      title: i18nT(L, 'ward.app_name'),
      guardians: i18nT(L, 'ward.guardians'),
      noGuardians: i18nT(L, 'ward.no_guardians'),
      offers: i18nT(L, 'ward.offers'),
      waiting: i18nT(L, 'ward.waiting'),
      help: i18nT(L, 'ward.help'),
      feed: i18nT(L, 'ward.feed'),
      feedEmpty: i18nT(L, 'ward.feed_empty'),
      buoyHint: i18nT(L, 'ward.buoy_hint'),
      helpWords: i18nT(L, 'ward.help_words'),
      helpSend: i18nT(L, 'ward.help_send'),
      helpSent: i18nT(L, 'ward.help_sent'),
      cancel: i18nT(L, 'ward.cancel'),
      toSky: i18nT(L, 'ward.to_sky'),
      toCards: i18nT(L, 'ward.to_cards'),
      skyEmpty: i18nT(L, 'ward.sky_empty'),
      handHint: i18nT(L, 'ward.hand_hint'),
      close: i18nT(L, 'ward.close'),
      writeHere: i18nT(L, 'ward.write_here'),
      send: i18nT(L, 'ward.send'),
      wave: i18nT(L, 'ward.wave'),
      waveCall: i18nT(L, 'ward.wave_call'),
      waveThanks: i18nT(L, 'ward.wave_thanks'),
      notNow: i18nT(L, 'ward.not_now'),
      waveTo: i18nT(L, 'ward.wave_to'),
      newTitle: i18nT(L, 'ward.new_title'),
      noFriends: i18nT(L, 'ward.no_friends'),
      write: i18nT(L, 'ward.write'),
      post: i18nT(L, 'ward.post'),
      visibility: i18nT(L, 'ward.visibility'),
      visFriends: i18nT(L, 'ward.vis_friends'),
      visPublic: i18nT(L, 'ward.vis_public'),
      addPhoto: i18nT(L, 'ward.add_photo'),
      addAudio: i18nT(L, 'ward.add_audio'),
      addVideo: i18nT(L, 'ward.add_video'),
      posted: i18nT(L, 'ward.posted'),
      uploading: i18nT(L, 'ward.uploading'),
      tooBig: i18nT(L, 'ward.too_big'),
      theme: i18nT(L, 'ward.theme'),
      playPause: i18nT(L, 'ward.play_pause'),
    },
  };
}

// ── De PWA-pagina ────────────────────────────────────────────────────────
router.get('/', requireAuth, (req, res) => {
  const site = siteForUser(req);
  const L = resolveLang(req);
  if (!site) return res.status(404).send('No site for this account.');
  // Losse PWA-pagina, dus NIET via renderPage: de CSP-nonce moet hier zelf
  // geïnjecteerd worden, anders blokkeert strict-dynamic ward.js en doet geen
  // enkele knop iets (zelfde valkuil als bij /guardian).
  res.render('pages/ward', {
    state: wardState(site, L),
    lang: L,
    t: (k, v) => i18nT(L, k, v),
    cspNonce: res.locals.cspNonce,
  }, (err, html) => {
    if (err) { console.error('[ward] render error', err); return res.status(500).send('Internal Server Error'); }
    res.send(injectCspNonce(html, res.locals.cspNonce));
  });
});

// ── JSON voor verversen ──────────────────────────────────────────────────
router.get('/api/state', requireAuth, (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  res.json(wardState(site, resolveLang(req)));
});

/**
 * De §4-controle: is mijn vangnet wel heel?
 *
 * Een "guardian" met eigen guardians is er geen (§1), en een escalatie
 * daarheen komt nergens aan. Dat is precies wat een ward moet kunnen zien.
 * Apart endpoint omdat het per guardian een remote fetch kost; de pagina
 * tekent eerst en vult dit daarna aan.
 *
 * Drie uitkomsten, net als in de apps: in orde, misvormd, of onbereikbaar.
 * Onbereikbaar is géén goedkeuring, dus het krijgt een eigen waarde in plaats
 * van te ontbreken.
 */
router.get('/api/guardian-checks', requireAuth, async (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  const uris = Guardianship.listGuardians(site.slug).map((g) => g.other_uri).filter(Boolean);
  const out = {};
  await Promise.all(uris.map(async (uri) => {
    const doc = await AP.fetchActor(uri).catch(() => null);
    if (!doc) { out[uri] = 'unreachable'; return; }
    out[uri] = carriesGuardians(doc) ? 'malformed' : 'sound';
  }));
  res.json({ checks: out });
});

/**
 * De feed: wat er binnenkomt van de mensen die je volgt.
 *
 * Zelfde bron en dezelfde partial als de Krant, Berichten en het
 * guardian-dashboard (renderNoteBody), zodat een post er overal hetzelfde
 * uitziet: opmaak, media, quote-kaart en embed. Kale content sturen zou hier
 * een lege regel opleveren waar een foto hoort.
 */
router.get('/api/feed', requireAuth, (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  const L = resolveLang(req);
  const items = AP.getTimeline(site.slug, 60, 0).map((p) => ({
    id: p.id,
    uri: p.object_uri || p.url,
    author: p.author_handle || p.author_name || p.author_uri,
    authorName: p.author_name,
    authorIcon: p.author_icon,
    url: p.url,
    published: p.published || p.created_at,
    whenText: formatDateTime(p.published || p.created_at),
    cw: p.cw || null,
    bodyHtml: renderNoteBody(p, L),
  }));
  res.json({ items });
});

/**
 * De reddingsboei (§5.2.1): sleep hem op een post en je guardians krijgen hem.
 *
 * Shaer maakt hier een SCHERMAFDRUK van de kaart, met al het gedoe van buiten
 * beeld renderen. Op de server is dat onnodig: wij weten wélke note het is, dus
 * de hulpvraag draagt de note zelf mee. Dat is niet alleen minder werk maar ook
 * eerlijker: een guardian ziet de echte post en niet een plaatje dat er ooit op
 * leek.
 *
 * Gaat naar ALLE guardians tegelijk, als direct bericht. Geen post, nooit
 * boostbaar. Zonder guardians is er niets om te vragen en zegt dat het ook.
 */
router.post('/api/help', requireAuth, express.json({ limit: '4kb' }), async (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  const guardians = Guardianship.listGuardians(site.slug).map((g) => g.other_uri).filter(Boolean);
  if (!guardians.length) return res.status(409).json({ error: 'no_guardians' });

  const noteId = String(req.body?.note || '').trim();
  const words = String(req.body?.words || '').trim().slice(0, 500);
  // De post waar het om gaat, als die van deze tijdlijn komt. Niet verplicht:
  // een kind mag ook om hulp vragen zonder dat er een post bij hoort.
  const row = noteId ? AP.getTimeline(site.slug, 200, 0).find((p) => String(p.id) === noteId) : null;
  const link = row && (row.url || row.object_uri);

  const text = [words || 'Ik heb hulp nodig.', link ? `\n\n${link}` : ''].join('');
  const sent = await Guardianship.deliverDirectNote(site, {
    recipients: guardians,
    text,
    language: site.language || 'nl',
    helpRequest: true,
  }).catch(() => null);

  if (!sent) return res.status(502).json({ error: 'not_delivered' });
  res.json({ ok: true, guardians: guardians.length, note: link || null });
});

/**
 * De gesprekken voor de hemel: iedereen met wie dit kind persoonlijk berichten
 * heeft gewisseld, met hoe lang geleden dat voor het laatst was.
 *
 * De hemel toont GESPREKKEN, geen posts. Directe berichten leven in
 * ap_mentions en niet in de tijdlijn, precies omdat een bericht aan genoemde
 * mensen geen post is. Per tegenpartij houden we het jongste bericht: dat is
 * wat de afstand tot het midden bepaalt.
 */
router.get('/api/conversations', requireAuth, (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  const now = Date.now();
  const byUri = new Map();
  for (const m of AP.getDirectMessages(site.slug, 200)) {
    if (!m.actor_uri) continue;
    const when = Date.parse(m.published || m.created_at || '') || now;
    const seen = byUri.get(m.actor_uri);
    if (!seen || when > seen.when) {
      byUri.set(m.actor_uri, {
        uri: m.actor_uri,
        name: m.actor_name || m.actor_handle || m.actor_uri,
        handle: m.actor_handle || m.actor_uri,
        icon: m.actor_icon || null,
        when,
      });
    }
  }
  const items = [...byUri.values()]
    .sort((a, b) => b.when - a.when)
    .map((c) => ({ ...c, ageMs: Math.max(0, now - c.when) }));
  res.json({ items });
});

/**
 * Eén gesprek, beide kanten, nieuwste eerst, met een cursor voor "meer".
 *
 * Dezelfde bron als de C2S-lezing die Shaer gebruikt (conversationHistory):
 * inkomend zijn de ap_mentions, uitgaand de eigen directe notes. De body komt
 * af van de server, net als in de feed; de client hoeft alleen bubbels te
 * tekenen en te weten welke kant elk bericht op wijst.
 */
router.get('/api/thread', requireAuth, (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  const other = String(req.query.with || '');
  if (!/^https?:\/\//i.test(other)) return res.status(400).json({ error: 'with_must_be_actor_uri' });
  const L = resolveLang(req);
  const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');

  const page = AP.conversationHistory(site.slug, other, {
    before: req.query.before ? String(req.query.before) : null,
    limit: req.query.limit,
  });
  const inRefs = page.rows.filter((r) => r.direction === 'in').map((r) => r.ref);
  const inMap = new Map(AP.messageRowsByUri(site.slug, inRefs).map((m) => [m.object_uri, m]));

  const items = page.rows.map((r) => {
    if (r.direction === 'in') {
      const m = inMap.get(r.ref);
      if (!m) return null;
      return {
        dir: 'in', id: m.object_uri,
        whenText: formatDateTime(m.published || m.created_at),
        bodyHtml: renderNoteBody(m, L),
        wave: !!m.wave, help: !!m.help_request,
      };
    }
    const n = AP.getOutboxNote(base, r.ref);
    if (!n) return null;
    return {
      dir: 'out', id: n.id,
      whenText: formatDateTime(n.published),
      // Eigen notes zijn door onszelf gebouwd en gesaniteerd bij het maken.
      bodyHtml: n.content || '',
      wave: n['shaer:wave'] === true,
    };
  }).filter(Boolean);

  // Openen is lezen. De markering is optellend (maximum), dus een oud toestel
  // kan nooit iets weer ongelezen maken.
  const nieuwsteIn = items.find((i) => i.dir === 'in');
  if (nieuwsteIn) { try { AP.markRead(site.slug, nieuwsteIn.id); } catch { /* lezen faalt stil */ } }

  res.json({ items, more: page.more, oldest: page.oldest });
});

/**
 * Een bericht in een gesprek, of een zwaai (§5, shaer:wave).
 *
 * Dezelfde draad als de boei (deliverDirectNote): een direct bericht aan één
 * persoon, nooit een post, nooit boostbaar. De wave-vlag reist mee zodat de
 * andere kant hem als zwaai toont en niet als kale tekst.
 */
router.post('/api/message', requireAuth, express.json({ limit: '8kb' }), async (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  const to = String(req.body?.to || '').trim();
  const text = String(req.body?.text || '').trim().slice(0, 2000);
  if (!/^https?:\/\//i.test(to)) return res.status(400).json({ error: 'to_must_be_actor_uri' });
  if (!text) return res.status(400).json({ error: 'empty' });

  const sent = await Guardianship.deliverDirectNote(site, {
    recipients: [to],
    text,
    language: site.language || 'nl',
    wave: req.body?.wave === true,
  }).catch(() => null);
  if (!sent) return res.status(502).json({ error: 'not_delivered' });
  res.json({ ok: true });
});

/**
 * De vrienden, voor de (+): iedereen met een volgrelatie, welke kant op dan
 * ook. Dezelfde bron als de Connect-pagina (listConnections), want de vraag
 * is dezelfde: wie ken je. De hemel toont alleen met wie je al SPRAK; dit is
 * de deur naar de rest.
 */
router.get('/api/friends', requireAuth, (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  const items = AP.listConnections(site.slug).map((c) => ({
    uri: c.actor_uri,
    name: c.name || c.handle || c.actor_uri,
    handle: c.handle || c.actor_uri,
    icon: c.icon || null,
  }));
  res.json({ items });
});

// Dezelfde media-map en dezelfde filters als de AP C2S-upload (/uploadMedia):
// een ward die via de app post en een ward die via de browser post moeten in
// dezelfde bak landen, anders federeren hun foto's van twee plekken.
const WARD_MEDIA_DIR = mediaDir('REPLY_MEDIA_PATH', 'reply-media');
fs.mkdirSync(WARD_MEDIA_DIR, { recursive: true });
const WARD_MEDIA_EXT = new Set(['.jpg', '.jpeg', '.png', '.webp', '.gif', '.mp3', '.m4a', '.ogg', '.opus', '.flac', '.wav', '.mp4', '.webm', '.mov']);
const wardUpload = multer({
  storage: multer.diskStorage({
    destination: (req, file, cb) => cb(null, WARD_MEDIA_DIR),
    filename: (req, file, cb) => cb(null, `${randomUUID()}${path.extname(file.originalname || '').toLowerCase()}`),
  }),
  limits: { fileSize: 32 * 1024 * 1024 },
  fileFilter: (req, file, cb) => {
    const ext = path.extname(file.originalname || '').toLowerCase();
    if (!WARD_MEDIA_EXT.has(ext)) return cb(new Error('media_type'));
    cb(null, true);
  },
});

/**
 * Media uploaden voor de composer. Sessie-geauthenticeerd, want /ward draait
 * op je eigen ingelogde Klonkt; de AP-upload eromheen eist een bearer die de
 * browser niet heeft. Geeft { url, mediaType, name } terug, precies de vorm
 * die een note als attachment draagt.
 */
router.post('/api/upload', requireAuth, (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  wardUpload.single('file')(req, res, (err) => {
    if (err) return res.status(400).json({ error: err.message === 'media_type' ? 'media_type' : 'upload_failed' });
    if (!req.file) return res.status(400).json({ error: 'no_file' });
    const mime = String(req.file.mimetype || '');
    if (!/^(image|audio|video)\//.test(mime)) {
      try { fs.unlinkSync(req.file.path); } catch { /* best effort */ }
      return res.status(400).json({ error: 'media_type' });
    }
    res.status(201).json({
      url: '/media/reply-media/' + req.file.filename,
      mediaType: mime,
      name: String(req.file.originalname || '').slice(0, 120),
    });
  });
});

/**
 * Een post maken. Bouwt precies de AS2 Create die Shaer over C2S stuurt en
 * geeft hem aan ingestOutboxActivity: die doet de compose-poort (§5), de
 * attachment-validatie en de zichtbaarheid. GEEN eigen posting-pad, want dan
 * zou de web-ward langs een gate kunnen die de app-ward tegenhoudt.
 *
 * De zichtbaarheid volgt Shaers eigen keuzes: 'public' luidop, 'friends'
 * alleen naar volgers, 'direct' naar genoemde mensen. Standaard 'friends',
 * want een besloten post is de veiligere default voor een kind.
 */
router.post('/api/post', requireAuth, express.json({ limit: '16kb' }), async (req, res) => {
  const site = siteForUser(req);
  if (!site) return res.status(404).json({ error: 'no_site' });
  const base = (process.env.PUBLIC_BASE_URL || '').replace(/\/+$/, '');
  const me = AP.actorId(base, site.slug);

  const text = String(req.body?.text || '').trim().slice(0, 5000);
  const media = Array.isArray(req.body?.media) ? req.body.media.slice(0, 4) : [];
  if (!text && !media.length) return res.status(400).json({ error: 'empty' });

  const vis = ['public', 'friends'].includes(req.body?.visibility) ? req.body.visibility : 'friends';
  const followers = `${me}/followers`;
  // Publiek luidop = Public in to; vrienden = alleen volgers, geen Public.
  const to = vis === 'public' ? ['https://www.w3.org/ns/activitystreams#Public'] : [followers];

  const attachment = media
    .filter((m) => m && typeof m.url === 'string' && /^\/media\//.test(m.url) && /^(image|audio|video)\//.test(String(m.mediaType || '')))
    .map((m) => ({
      type: m.mediaType.startsWith('image/') ? 'Image' : m.mediaType.startsWith('audio/') ? 'Audio' : 'Video',
      mediaType: m.mediaType,
      url: m.url,
      name: String(m.name || '').slice(0, 120),
    }));

  const escaped = text.replace(/[<>&]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;' }[c]));
  const content = escaped ? `<p>${escaped.replace(/\n/g, '<br>')}</p>` : '';

  const r = await AP.ingestOutboxActivity(site, req.session.user, {
    type: 'Create',
    object: {
      type: 'Note',
      content,
      source: { content: text, mediaType: 'text/plain' },
      to, cc: [],
      attachment: attachment.length ? attachment : undefined,
    },
  }).catch((e) => ({ status: 500, error: String(e && e.message || e) }));

  if (!r || r.status >= 400) return res.status(r?.status || 502).json({ error: r?.error || 'post_failed' });
  res.status(201).json({ ok: true, url: r.url || null });
});

function pwaAsset(rel, type) {
  return (req, res) => {
    res.set('Cache-Control', 'no-cache');
    res.type(type);
    res.sendFile(path.join(__dir, '..', 'assets', rel));
  };
}
router.get('/app.js', pwaAsset('js/ward.js', 'application/javascript'));
// De hemel is een eigen module, zodat model en renderer los staan van de rest.
router.get('/sky.js', pwaAsset('js/ward-sky.js', 'application/javascript'));
// De themamodule (SkyPalette): app.js importeert hem, dus zonder deze route
// valt de hele module om op een 404.
router.get('/theme.js', pwaAsset('js/ward-theme.js', 'application/javascript'));
router.get('/app.css', pwaAsset('css/ward.css', 'text/css'));

router.get('/manifest.webmanifest', (req, res) => {
  const site = res.locals.site;
  res.set('Cache-Control', 'no-cache');
  res.json({
    id: `klonkt-ward-${site?.slug || 'ward'}`,
    name: 'Klonkt Ward',
    short_name: 'Ward',
    description: 'Wie over je waakt, en wat er op hen wacht.',
    scope: '/ward/',
    start_url: '/ward?source=pwa',
    display: 'standalone',
    display_override: ['standalone', 'minimal-ui'],
    orientation: 'any',
    background_color: '#141a24',
    theme_color: '#5a32e6',
    lang: site?.language || 'nl',
    icons: [
      { src: '/ward/icon.svg', sizes: 'any', type: 'image/svg+xml' },
    ],
  });
});

// Het schild uit de guardianship-taal, in het ward-accent.
router.get('/icon.svg', (req, res) => {
  const svg = `<?xml version="1.0" encoding="UTF-8"?>
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
  <rect width="64" height="64" rx="14" fill="#141a24"/>
  <path d="M32 12l16 6v14c0 10-6.6 16.6-16 20-9.4-3.4-16-10-16-20V18z" fill="#5a32e6"/>
  <path d="M24 32l6 6 12-12" stroke="#fff" stroke-width="4" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
</svg>`;
  res.set('Cache-Control', 'public, max-age=86400');
  res.type('image/svg+xml').send(svg);
});

export default router;