discovery-media-player 0.1.78 → 0.1.80

package/docs/HOST-CONTRACT.md

@@ -35,6 +35,7 @@ need.
   "frameAncestors": ["'self'", "https://*.vercel.app", "https://app.example.com"],
   "separateIssuer": true,
   "internalStrict": true,
+  "retentionSweep": false,
   "hostShare": true,
   "hostMail": true,
   "plugins": { "bot": false, "visitors": false, "brandIntro": false, "botBrowser": false, "providerQuotas": false },
@@ -95,6 +96,12 @@ exactly the monitoring case where "no data" would otherwise read as "all clear".
 ⚠️ **`incomplet` wins over `partiel`**: a missing column is a positive fact and settles the verdict
 on its own, even when the rest has not been checked.
 
+⚠️ **`retentionSweep`** says whether the automatic retention purge is *armed*
+(`config.retention.balayage === true`). The `retention` capability only says the instance *can*
+purge; this boolean says whether it *does*, on its own, once a day. Default `false` — nothing is
+deleted unless an operator wrote the policy. A cockpit can read this to know if an instance is
+subject to automatic deletion, instead of inferring it from a log.
+
 ⚠️ **`internalStrict: false` means internal identity comes from the browser.** In transitional
 mode the internal-analytics route accepts `docId`, `email` and `name` as the client declares them —
 a caller can fabricate "this colleague read this document". Strict mode (`PLAYER_INTERNAL_STRICT=1`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.78",
+  "version": "0.1.80",
   "description": "Self-hosted document viewer: per-recipient tracked links, reading analytics, live presentation. The core knows nothing about the application hosting it — everything it borrows arrives through an injected context.",
   "keywords": [
     "pdf-viewer",

package/server/handler.js

@@ -595,6 +595,12 @@ async function handler(req, res) {
         // MESURABLE : un cockpit peut refuser une instance non stricte, au lieu de le découvrir en
         // lisant un journal. Demandé par le second hôte (cinquième audit, P1-4).
         internalStrict: !!(PLAYER.config && PLAYER.config.internalStrict),
+        // ⚠️ LE BALAYAGE DE RÉTENTION EST-IL ARMÉ ? La capacité `retention` dit que l'instance PEUT
+        // purger ; ce booléen dit si le balayage automatique TOURNE (`config.retention.balayage`).
+        // Sans lui, une instance armée est indiscernable d'une instance éteinte — et une purge qui
+        // supprime se compose mal avec l'ignorance de savoir si l'on est concerné (signalé par le
+        // second hôte). Défaut false, comme la décision par défaut : rien ne s'efface tout seul.
+        retentionSweep: !!(PLAYER.config && PLAYER.config.retention && PLAYER.config.retention.balayage === true),
         // ⚠️ L'ÉTAT DU SCHÉMA, LÀ OÙ ON REGARDE. Une colonne absente était signalée par un
         // `console.warn`, une fois par processus : sur une fonction serverless, une ligne perdue
         // dans une sortie que personne n'ouvre tant que tout a l'air de marcher — et « tout a

package/server/retention.js

@@ -57,52 +57,134 @@ function borne(now, mois) {
 // Bornes d'exécution par défaut — un lot raisonnable, un plafond qui tient dans une fenêtre
 // serverless. L'appelant peut resserrer (dryRun, taille, plafond) ; jamais dépasser sans le dire.
 const LOT = 200, PLAFOND = 5000, PLAFOND_PRESENTATIONS = 500;
+const MAX_TAILLE = 500, MAX_PLAFOND = 5000;
+
+// ⚠️ LES OPTIONS D'EXÉCUTION SONT VALIDÉES AVANT TOUT DELETE (P1 neuvième audit). La route les
+// reçoit d'un appelant ; un `dryRun` non booléen strict, une taille/plafond hors bornes ou une
+// clé inconnue font ÉCHOUER la purge — jamais un `Number()` ni un `!!` qui transformerait
+// `"false"` en purge réelle. `dryRun` est ce qu'un exploitant lance EN PREMIER : il ne doit pas
+// pouvoir supprimer par une faute de type.
+const CLES_OPTS = new Set(["dryRun", "taille", "plafond"]);
+function optionsValidees(opts) {
+  const o = opts || {};
+  for (const cle of Object.keys(o)) {
+    if (!CLES_OPTS.has(cle)) { const e = new Error(`option de rétention inconnue : ${cle}`); e.retentionInvalide = true; throw e; }
+  }
+  if ("dryRun" in o && typeof o.dryRun !== "boolean") { const e = new Error("dryRun doit être un booléen strict"); e.retentionInvalide = true; throw e; }
+  const entierDans = (v, min, max, nom) => {
+    if (v === undefined) return undefined;
+    if (typeof v !== "number" || !Number.isInteger(v) || v < min || v > max) {
+      const e = new Error(`${nom} doit être un entier dans [${min},${max}] — reçu ${JSON.stringify(v)}`); e.retentionInvalide = true; throw e;
+    }
+    return v;
+  };
+  return {
+    dryRun: o.dryRun === true,
+    taille: entierDans(o.taille, 1, MAX_TAILLE, "taille") ?? LOT,
+    plafond: entierDans(o.plafond, 1, MAX_PLAFOND, "plafond") ?? PLAFOND,
+  };
+}
 
 // Une valeur pour `id=in.(…)` : double-guillemets, guillemet et antislash internes échappés —
 // PostgREST exige le guillemetage dès qu'une valeur porte un caractère réservé (`:` d'une clé de
 // débit, par exemple). Guillemeter TOUJOURS est correct et évite d'avoir à deviner.
 const guill = (v) => '"' + String(v).replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
 
+// ⚠️ LES DEUX SEULES PORTES DE DESTRUCTION DU MODULE — dryRun court-circuité en PREMIÈRE ligne.
+// « Honoré » ne se prouve pas en lisant chaque DELETE (une fenêtre de lecture décide de la réponse
+// — le piège du périmètre), mais en n'ayant QU'UNE porte, gardée ici, et une garde de forme qui
+// exige qu'il n'y en ait qu'une (server/__tests__/retentionUnePorte.test.js). Un troisième chemin
+// d'écriture DEVRA passer par ces portes, ou il rougira le compte. C'est « retirer la seconde
+// source de vérité » appliqué à la suppression : un seul endroit peut détruire.
+async function effacerParIds(table, colId, ids, opts) {
+  if (opts.dryRun || !ids || !ids.length) return 0;
+  const del = await PLAYER.db.request(`${table}?${colId}=in.(${ids.map(guill).join(",")})&select=${colId}`, { method: "DELETE", headers: { Prefer: "return=representation" } });
+  return Array.isArray(del) ? del.length : 0;   // lignes RENDUES, pas ids présélectionnés
+}
+async function retirerFichier(chemin, opts) {
+  if (opts.dryRun || !chemin) return null;   // null = rien tenté ; true = retiré ; false = échec
+  const retirer = PLAYER.storage && typeof PLAYER.storage.remove === "function" ? PLAYER.storage.remove.bind(PLAYER.storage) : null;
+  if (!retirer) return null;
+  try { return !!(await retirer("present-attachments", chemin)); } catch { return false; }
+}
+
 // ⚠️ PURGE PAR LOTS BORNÉS (P2 huitième audit). On SÉLECTIONNE un lot d'identifiants (borné,
 // ordonné par la colonne de date), on les supprime par `id=in.(…)`, on recommence — jamais un
 // DELETE non borné qui ramènerait tout l'historique d'un coup (mémoire, WAL, verrous, timeout).
 // `dryRun` sélectionne sans supprimer. Le rapport remplace la liste d'identifiants : examinées,
 // supprimées, tronqué (il reste à faire au prochain passage).
+// ⚠️ Pagination par CURSEUR KEYSET (`colId=gt.<dernier>`), pas par `offset` — la garde de
+// portabilité de la forge interdit `offset=`, et un curseur est de toute façon stable sous
+// suppression concurrente. En dry-run le pool ne rétrécit pas : sans curseur, on relisait le
+// même premier lot à chaque tour (P2 neuvième audit : 120 lignes comptées 300). Le lot est rogné
+// au RESTE du plafond (`min(taille, plafond - examinees)`) pour ne jamais le dépasser. Et on
+// compte les lignes RENDUES par le DELETE (`return=representation&select=id`), pas les ids
+// présélectionnés : deux exécutions concurrentes n'annoncent pas deux fois la même suppression.
 async function purgerParLots(table, filtre, colId, { dryRun = false, taille = LOT, plafond = PLAFOND } = {}) {
-  let examinees = 0, supprimees = 0;
-  const maxTours = Math.max(1, Math.ceil(plafond / taille));
-  let tours = 0, tronque = false;
+  let examinees = 0, supprimees = 0, tronque = false, curseur = null;
   for (;;) {
-    if (tours >= maxTours) { tronque = true; break; }
-    tours += 1;
-    const lot = await PLAYER.db.request(`${table}?${filtre}&select=${colId}&order=${colId}.asc&limit=${taille}`);
+    const reste = plafond - examinees;
+    if (reste <= 0) { tronque = await resteEncore(table, filtre, colId, curseur, dryRun); break; }
+    const limite = Math.min(taille, reste);
+    const borneCur = curseur != null ? `&${colId}=gt.${enc(String(curseur))}` : "";
+    const lot = await PLAYER.db.request(`${table}?${filtre}${borneCur}&select=${colId}&order=${colId}.asc&limit=${limite}`);
     if (!Array.isArray(lot) || !lot.length) break;
     examinees += lot.length;
-    if (!dryRun) {
-      const ids = lot.map((r) => r[colId]).filter((v) => v != null).map(guill);
-      if (ids.length) {
-        await PLAYER.db.request(`${table}?${colId}=in.(${ids.join(",")})`, { method: "DELETE", headers: { Prefer: "return=minimal" } });
-        supprimees += ids.length;
-      }
-    }
-    if (lot.length < taille) break;   // dernier lot
-    if (dryRun) { tronque = tours >= maxTours; if (tours >= maxTours) break; }
+    curseur = lot[lot.length - 1][colId];
+    supprimees += await effacerParIds(table, colId, lot.map((r) => r[colId]).filter((v) => v != null), { dryRun });
+    if (lot.length < limite) break;   // dernier lot (moins que demandé → plus rien après)
   }
   return { examinees, supprimees, tronque };
 }
 
+// « Reste-t-il une ligne au-delà du curseur ? » — sonde d'UNE ligne. Départage « on s'est arrêté
+// pile au plafond mais tout est parti » de « il reste à faire ». En run réel les lignes lues ont
+// été supprimées : la fenêtre a avancé, on relit depuis le début du filtre (curseur non requis).
+async function resteEncore(table, filtre, colId, curseur, dryRun) {
+  const borneCur = dryRun && curseur != null ? `&${colId}=gt.${enc(String(curseur))}` : "";
+  const sonde = await PLAYER.db.request(`${table}?${filtre}${borneCur}&select=${colId}&order=${colId}.asc&limit=1`);
+  return Array.isArray(sonde) && sonde.length > 0;
+}
+
 // ⚠️ REVALIDATION À LA SUPPRESSION — le MÊME validateur que l'écriture (server/presentations.js),
 // avec le slug de la présentation purgée. Une validation d'écriture n'est jamais la seule barrière
 // d'un delete : les lignes déjà en base d'avant le correctif peuvent porter une URL piégée.
 const { cheminPieceJointe: cheminSurSlug } = require("./presentations");
 
-async function purgerRetention(now, opts = {}) {
-  let f;
-  try { f = fenetresValidees(); }
+// Purge des messages d'une présentation morte, par lots bornés qui lisent id+attachment ENSEMBLE :
+// on retire les fichiers du bucket du lot (si l'hôte sait), puis on supprime le lot. Rend `tronque`
+// pour que l'appelant décide de garder ou non la présentation. Compte les lignes RENDUES.
+async function purgerMessagesPresentation(slug, opts, base) {
+  const { dryRun, taille, plafond } = opts;
+  let supprimees = 0, fichiers = 0, fichiersErreur = 0, examinees = 0, tronque = false, curseur = null;
+  for (;;) {
+    const reste = plafond - examinees;
+    if (reste <= 0) { tronque = await resteEncore("doc_presentation_messages", `slug=eq.${enc(slug)}`, "id", curseur, dryRun); break; }
+    const limite = Math.min(taille, reste);
+    const borneCur = curseur != null ? `&id=gt.${enc(String(curseur))}` : "";
+    const lot = await PLAYER.db.request(`doc_presentation_messages?slug=eq.${enc(slug)}${borneCur}&select=id,attachment&order=id.asc&limit=${limite}`);
+    if (!Array.isArray(lot) || !lot.length) break;
+    examinees += lot.length;
+    curseur = lot[lot.length - 1].id;
+    for (const j of lot) {
+      const url = j.attachment && (typeof j.attachment === "object" ? j.attachment.url : j.attachment);
+      const chemin = cheminSurSlug(url, slug, base);   // hors du dossier du slug → null → jamais retiré (barrière 2)
+      const issue = await retirerFichier(chemin, { dryRun });
+      if (issue === true) fichiers += 1; else if (issue === false) fichiersErreur += 1;   // false = échec compté
+    }
+    supprimees += await effacerParIds("doc_presentation_messages", "id", lot.map((r) => r.id).filter((v) => v != null), { dryRun });
+    if (lot.length < limite) break;
+  }
+  return { supprimees, fichiers, fichiersErreur, examinees, tronque };
+}
+
+async function purgerRetention(now, optsBrutes = {}) {
+  let f, opts;
+  try { f = fenetresValidees(); opts = optionsValidees(optsBrutes); }
   catch (e) {
     if (!e.retentionInvalide) throw e;
     try { PLAYER.errors.capture(e, { route: "retention" }); } catch { /* jamais bloquant */ }
-    return { ok: false, error: e.message };   // config douteuse → zéro DELETE
+    return { ok: false, error: e.message };   // config OU option douteuse → zéro DELETE
   }
   const base = String((PLAYER.config && PLAYER.config.supabaseUrl) || "");
   const rapport = {};
@@ -125,24 +207,22 @@ async function purgerRetention(now, opts = {}) {
   const bPres = borne(now, f.presentationsMois);
   const mortes = await PLAYER.db.request(`doc_presentations?active=eq.false&updated_at=lt.${enc(bPres)}&select=slug&order=slug.asc&limit=${PLAFOND_PRESENTATIONS}`);
   const presRapport = { examinees: 0, supprimees: 0, messages: 0, presences: 0, fichiers: 0, fichiersErreur: 0, tronque: Array.isArray(mortes) && mortes.length >= PLAFOND_PRESENTATIONS };
-  const retirer = PLAYER.storage && typeof PLAYER.storage.remove === "function" ? PLAYER.storage.remove.bind(PLAYER.storage) : null;
   for (const p of (Array.isArray(mortes) ? mortes : [])) {
     const slug = p && p.slug; if (!slug) continue;
     presRapport.examinees += 1;
-    if (retirer && !opts.dryRun) {
-      const jointes = await PLAYER.db.request(`doc_presentation_messages?slug=eq.${enc(slug)}&attachment=not.is.null&select=attachment`);
-      for (const j of (Array.isArray(jointes) ? jointes : [])) {
-        const url = j && j.attachment && (typeof j.attachment === "object" ? j.attachment.url : j.attachment);
-        const chemin = cheminSurSlug(url, slug, base);
-        if (!chemin) continue;   // hors du dossier du slug → jamais supprimé (barrière 2)
-        try { if (await retirer("present-attachments", chemin)) presRapport.fichiers += 1; } catch { presRapport.fichiersErreur += 1; /* le fichier survit, la ligne part */ }
-      }
-    }
-    if (!opts.dryRun) {
-      presRapport.messages += (await purgerParLots("doc_presentation_messages", `slug=eq.${enc(slug)}`, "id", opts)).supprimees;
-      presRapport.presences += (await purgerParLots("doc_presentation_attendees", `slug=eq.${enc(slug)}`, "attendee_key", opts)).supprimees;
-    }
-    if (!opts.dryRun) {
+    // Messages : lot borné qui lit id ET attachment ENSEMBLE (la lecture des pièces jointes n'est
+    // plus une requête globale non bornée — P2), retire les fichiers du lot, puis supprime le lot.
+    const msgs = await purgerMessagesPresentation(slug, opts, base);
+    presRapport.messages += msgs.supprimees;
+    presRapport.fichiers += msgs.fichiers;
+    presRapport.fichiersErreur += msgs.fichiersErreur;
+    const pres = opts.dryRun ? { supprimees: 0, tronque: false } : await purgerParLots("doc_presentation_attendees", `slug=eq.${enc(slug)}`, "attendee_key", opts);
+    presRapport.presences += pres.supprimees;
+    // ⚠️ LA PRÉSENTATION N'EST SUPPRIMÉE QUE SI TOUS SES ENFANTS SONT PARTIS (P2 neuvième audit) :
+    // sinon 5 000 messages partent, le parent aussi, et 1 000 orphelins restent que le balayage
+    // suivant ne peut plus rattacher à leur présentation. Tronqués → on garde le parent inactif
+    // pour le passage suivant.
+    if (!opts.dryRun && !msgs.tronque && !pres.tronque) {
       presRapport.supprimees += (await purgerParLots("doc_presentations", `slug=eq.${enc(slug)}`, "slug", opts)).supprimees;
     }
   }

package/server/routes-liens.js

@@ -32,7 +32,14 @@ async function traiter(req, res, body, slug) {
           let admin = false;
           if (!hote) { const u = await PLAYER.identity.verifyToken(req.headers.authorization); admin = !!(u && PLAYER.identity.isAdmin(u)); }
           if (!hote && !admin) return jd(403, { ok: false, error: "retention.run : hôte de confiance ou admin requis" });
-          return jd(200, await require("./retention").purgerRetention(Date.now()));
+          // ⚠️ LES OPTIONS TRAVERSENT LA ROUTE (P1 neuvième audit) — dryRun compris, sinon la
+          // purge « à blanc » supprimait pour de vrai. La validation vit dans purgerRetention
+          // (avant tout DELETE) ; un refus (ok:false + error) devient un 400, pas un 200.
+          // Tout le corps SAUF `action` est passé au validateur : une clé inconnue (faute de
+          // frappe d'option) est ainsi refusée, pas ignorée en silence.
+          const { action: _a, ...opts } = body;
+          const resultat = await require("./retention").purgerRetention(Date.now(), opts);
+          return jd(resultat.ok === false ? 400 : 200, resultat);
         } catch (e) { try { PLAYER.errors.capture(e, { route: "retention" }); } catch { /* jamais bloquant */ } return jd(500, { ok: false }); }
       }
       if (String(body.action || "").startsWith("docshare.")) {
@@ -457,9 +464,11 @@ async function traiter(req, res, body, slug) {
       }
       res.statusCode = 200; res.setHeader("Content-Type", "application/json"); res.end('{"ok":true}');
       return;
-  // ⚠️ PAS de `return false` ici : le bloc ci-dessus est le REPLI POST d'origine — toute action
-  // qu'aucune famille n'a reconnue finit {"ok":true}, comme avant l'extraction. Cette famille
-  // répond donc TOUJOURS, et doit rester la DERNIÈRE du dispatch (handler le dit aussi).
+  // ⚠️ PAS de `return false` ici : le bloc ci-dessus est le repli ANALYTIQUE (open/page/heartbeat/
+  // session). Une action inconnue N'Y ARRIVE PLUS — elle est refusée en 400 unknown-action au
+  // début de ce repli (neuvième audit : le commentaire disait encore « finit ok:true », c'était
+  // faux depuis le huitième). Cette famille répond donc toujours pour un événement valide, et doit
+  // rester la DERNIÈRE du dispatch (handler le dit aussi).
 }
 
 module.exports = { init, traiter };

package/supabase/recensement-retention.sql

@@ -9,21 +9,30 @@
 -- Usage : psql -f supabase/recensement-retention.sql — chaque ligne rend « table|restantes ».
 -- Après une purge, tout doit être à zéro ; un reste est un mensonge de la purge OU un trou de
 -- son périmètre. La forge l'exécute à chaque course, après le banc base.
+--
+-- ⚠️ FENÊTRES PARAMÉTRABLES (neuvième audit) : si un hôte configure d'autres durées via
+-- `config.retention`, le recensement doit contrôler LA MÊME politique, pas les défauts figés.
+-- Les variables psql ci-dessous portent les défauts de RETENTION.md ; passez-les à l'appel pour
+-- une configuration non standard, ex. :
+--   psql -v journaux_mois=6 -v presentations_mois=3 -v liens_mois=6 -f supabase/recensement-retention.sql
+\if :{?journaux_mois}\else \set journaux_mois 13 \endif
+\if :{?presentations_mois}\else \set presentations_mois 12 \endif
+\if :{?liens_mois}\else \set liens_mois 13 \endif
 select 'commercial_doc_views' as perimetre, count(*) as restantes
   from public.commercial_doc_views
-  where at < now() - interval '13 months'
+  where at < now() - make_interval(months => :journaux_mois)
 union all
 select 'commercial_doc_sessions', count(*)
   from public.commercial_doc_sessions
-  where last_at < now() - interval '13 months'
+  where last_at < now() - make_interval(months => :journaux_mois)
 union all
 select 'commercial_doc_internal_sessions', count(*)
   from public.commercial_doc_internal_sessions
-  where last_at < now() - interval '13 months'
+  where last_at < now() - make_interval(months => :journaux_mois)
 union all
 select 'doc_bot_sessions', count(*)
   from public.doc_bot_sessions
-  where last_at < now() - interval '13 months'
+  where last_at < now() - make_interval(months => :journaux_mois)
 union all
 select 'player_rate_limits', count(*)
   from public.player_rate_limits
@@ -31,11 +40,11 @@ select 'player_rate_limits', count(*)
 union all
 select 'commercial_doc_shares_revoques', count(*)
   from public.commercial_doc_shares
-  where revoked and revoked_at < now() - interval '13 months'
+  where revoked and revoked_at < now() - make_interval(months => :liens_mois)
 union all
 select 'doc_presentations_mortes', count(*)
   from public.doc_presentations
-  where not active and updated_at < now() - interval '12 months'
+  where not active and updated_at < now() - make_interval(months => :presentations_mois)
 union all
 -- Messages et présences : orphelins d'une présentation morte-ancienne OU d'aucune présentation —
 -- formulé par NOT EXISTS, pas par la liste de slugs que la purge a construite.
@@ -44,11 +53,11 @@ select 'doc_presentation_messages_orphelins', count(*)
   where not exists (
     select 1 from public.doc_presentations p
     where p.slug = m.slug
-      and (p.active or p.updated_at >= now() - interval '12 months'))
+      and (p.active or p.updated_at >= now() - make_interval(months => :presentations_mois)))
 union all
 select 'doc_presentation_attendees_orphelins', count(*)
   from public.doc_presentation_attendees a
   where not exists (
     select 1 from public.doc_presentations p
     where p.slug = a.slug
-      and (p.active or p.updated_at >= now() - interval '12 months'));
+      and (p.active or p.updated_at >= now() - make_interval(months => :presentations_mois)));