discovery-media-player 0.1.46 → 0.1.48

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "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

@@ -29,6 +29,9 @@ function init(ctx) {
   require("./shares").init(ctx);
   require("./presentations").init(ctx);
   require("./brands").init(ctx);
+  // ⚠️ Réinitialisé avec le contexte : les réponses de la sonde valent pour UNE base. Un hôte qui
+  // rebranche son contexte sur un autre projet doit reposer la question, pas hériter des réponses.
+  require("./schema").init(ctx);
   docbot = ctx.plugins.bot;
   brandIntroRuntime = ctx.plugins.brandIntro && ctx.plugins.brandIntro.brandIntroRuntime;
   botBrowser = ctx.plugins.botBrowser;
@@ -2409,6 +2412,53 @@ ${botOn && botBrowser ? botBrowser.botViewerJs(ICONS) : ""}
 
 // CSP de la page audience (Présenter) : autorise pdf.js (cdnjs), supabase-js (jsdelivr) et la connexion
 // Realtime (https + wss vers le projet Supabase). Plus permissive que la visionneuse, limitée à cette page.
+/**
+ * Les origines d'images qu'une page a le droit de charger.
+ *
+ * ⚠️ FOURNIR UNE URL SANS AUTORISER SON ORIGINE REVIENT À NE PAS LA FOURNIR — avec l'apparence du
+ * contraire. Le HTML est parfait, le fichier répond 200, et le navigateur refuse quand même. C'est
+ * arrivé en 0.1.47 : la marque du client était résolue, écrite dans la page, et bloquée. Le chemin
+ * du lien tracé ajoutait bien son origine ; celui de l'aperçu, non. Deux politiques sur la même
+ * instance, à la même minute.
+ *
+ * ⚠️ ET AUCUNE SONDE SERVEUR NE PEUT LE VOIR. Le HTML rendu est correct, le script se compile, le
+ * paquet est conforme. Ni notre étape de fumée, ni la garde d'artefact, ni un test qui exécute la
+ * page ne mordent : seul un navigateur le montre. C'est le second hôte qui l'a vu, à l'œil, chez son
+ * client.
+ *
+ * D'où cette fonction : une seule liste, pour toutes les routes qui rendent la visionneuse. La
+ * remplir est une décision ; l'oublier n'est plus possible, parce qu'il n'y a plus qu'un endroit.
+ *
+ * ⚠️ CE QU'ELLE NE COUVRE PAS, ET QUI EST UN AUTRE PROBLÈME. La page d'AUDIENCE affiche les avatars
+ * des participants, qui arrivent par la présence — donc à l'exécution, et depuis autant d'origines
+ * qu'il y a de membres chez l'hôte. Aucune liste posée au rendu ne peut les prévoir. Les
+ * pré-autoriser demanderait d'élargir la politique à une origine d'hôte entière, ce qui est une
+ * décision à prendre séparément, pas un oubli à corriger ici.
+ *
+ * ⚠️ ON NE DÉRIVE PAS CETTE LISTE DU HTML RENDU, et c'est délibéré. Ce serait plus général et ça
+ * viderait la politique de son sens : autoriser tout ce que la page référence, c'est autoriser aussi
+ * ce qu'une valeur mal filtrée y aurait glissé. La liste porte des CHAMPS connus, pas des URL
+ * trouvées.
+ */
+function originesImages(logoInstance, share) {
+  const s = share || {};
+  return [
+    originOf(logoInstance),
+    originOf(s.brand_logo),
+    originOf(s.bot_avatar),
+    // ⚠️ Celui-ci ne cassait pas, et c'est pire qu'un défaut visible : il marchait PAR ACCIDENT,
+    // parce que la photo du présentateur et l'avatar de l'assistant sortent en général du même
+    // stockage, donc de la même origine. Le jour où un hôte range l'une ailleurs, elle disparaît
+    // sans que rien n'ait changé chez lui.
+    originOf(s.bot_vphoto),
+    // ⚠️ Trouvé par la garde à son premier passage, et il ne se voyait pas : cette adresse ne part
+    // pas dans le HTML mais dans la configuration, et c'est la couche live qui en fait une image à
+    // l'exécution — dans la liste des participants. Un défaut de politique sur une image construite
+    // par du script se lit encore moins qu'un autre : la page est déjà chargée quand il se produit.
+    originOf(s.presenter_avatar),
+  ].filter(Boolean).join(" ");
+}
+
 function sendPresentHtml(res, html, nonce, supaUrl, imgExtra, frameAncestors) {
   const wss = String(supaUrl || "").replace(/^https:/, "wss:");
   res.statusCode = 200;
@@ -3614,7 +3664,18 @@ async function handler(req, res) {
       }
       const supaUrl = (PLAYER.config && PLAYER.config.supabaseUrl) || "";
       const supaKey = (PLAYER.config && PLAYER.config.supabasePublishableKey) || "";
-      const pseudo = { preview: true, embed, slug: "", file_name: String(q.name || "document.pdf"), doc_title: String(q.title || q.name || "Document"), raw_url: url, doc_id: String(q.docId || ""), presenter_name: String(q.by || ""), presenter_avatar: String(q.av || ""), internal_email: String(q.uemail || ""), internal_token: String(q.it || ""), supa_url: supaUrl, supa_key: supaKey, auto_present: String(q.autopresent || "") === "1", resume_slug: String(q.resume || ""), stream_url: `/api/doc?preview=1&stream=1&url=${encodeURIComponent(url)}&name=${encodeURIComponent(String(q.name || ""))}` };
+      const pseudo = { preview: true, embed, slug: "", file_name: String(q.name || "document.pdf"), doc_title: String(q.title || q.name || "Document"), raw_url: url, doc_id: String(q.docId || ""), presenter_name: String(q.by || ""), presenter_avatar: String(q.av || ""), internal_email: String(q.uemail || ""), internal_token: String(q.it || ""), supa_url: supaUrl, supa_key: supaKey, auto_present: String(q.autopresent || "") === "1", resume_slug: String(q.resume || ""), brand_key: String(q.brand || "") || null, stream_url: `/api/doc?preview=1&stream=1&url=${encodeURIComponent(url)}&name=${encodeURIComponent(String(q.name || ""))}` };
+      // ⚠️ LA MARQUE MANQUAIT ICI, ET SEULEMENT ICI. Toute la machinerie existe — l'hôte répond à
+      // `PLAYER_HOST_BRAND_URL`, `branding.forKey` résout, les liens tracés affichent la bonne
+      // marque. Ce chemin-ci ne l'appelait simplement pas, et aucun paramètre ne transportait la
+      // clé. Un hôte à plusieurs marques servait donc, sur le domaine d'un client, le loader d'un
+      // autre — le visiteur voyant l'enseigne d'une entreprise qu'il ne connaît pas.
+      //
+      // Signalé par le second hôte, sur une notice ouverte chez son client.
+      try {
+        const marque = await brands.brandForShare(pseudo);
+        if (marque) { pseudo.brand_logo = marque.logo; pseudo.brand_name = marque.name; pseudo.brand_dark = marque.dark; }
+      } catch { /* le loader dégrade, il n'empêche pas de lire */ }
       let plogo = ""; try { plogo = await PLAYER.branding.logo(); } catch { /* sans logo */ }
       const pnonce = crypto.randomBytes(16).toString("base64");
       // Aperçu interne : CSP relâchée (supabase-js jsdelivr + Realtime wss) pour la présence + le chat live,
@@ -3629,7 +3690,7 @@ async function handler(req, res) {
       // Conséquence absurde relevée par cet hôte : la page de REFUS, corrigée la veille, était
       // encadrable chez lui — pas la page de SUCCÈS. Le chemin d'erreur était plus portable que
       // le chemin nominal.
-      return sendPresentHtml(res, viewerHtml(pseudo, pnonce, plogo), pnonce, supaUrl, originOf(plogo),
+      return sendPresentHtml(res, viewerHtml(pseudo, pnonce, plogo), pnonce, supaUrl, originesImages(plogo, pseudo),
         embed ? embedFrameAncestors() : "'self'");
     }
 
@@ -3728,7 +3789,7 @@ async function handler(req, res) {
     const frameAncestors = share.embed
       ? embedFrameAncestors()
       : "'self'";
-    return sendHtml(res, 200, viewerHtml(share, nonce, logoUrl, pitch), `'nonce-${nonce}'`, [originOf(logoUrl), originOf(share.bot_avatar), originOf(share.brand_logo)].filter(Boolean).join(" "), frameAncestors);
+    return sendHtml(res, 200, viewerHtml(share, nonce, logoUrl, pitch), `'nonce-${nonce}'`, originesImages(logoUrl, share), frameAncestors);
   } catch (error) {
     try { await PLAYER.errors.capture(error, { route: "doc", method: req.method }); } catch { /* ignore */ }
     res.statusCode = 500; res.end("Erreur");

package/server/schema.js

@@ -0,0 +1,97 @@
+// CE QUE LA BASE PORTE VRAIMENT, ET NON CE QU'ON CROIT LUI AVOIR APPLIQUÉ.
+//
+// ⚠️ LE PLAYER N'APPLIQUE PAS LES MIGRATIONS, ET NE LE POURRA JAMAIS. Il parle à la base uniquement
+// par PostgREST, qui n'exécute pas de DDL. Lui donner ce pouvoir supposerait d'exposer une fonction
+// capable d'exécuter du SQL arbitraire — dans un service qui sert des liens publics. C'est l'hôte qui
+// applique ; le player doit seulement SAVOIR.
+//
+// ⚠️ ET IL DEMANDE PLUTÔT QU'IL NE RETIENT. Une table de suivi des migrations aurait dû être créée
+// par une migration : le premier pas serait retombé sur le problème qu'elle résout. Et un registre
+// dit ce qu'on CROIT avoir appliqué ; une sonde dit ce qui EST. Les deux divergent le jour où
+// quelqu'un applique à la main — c'est-à-dire le jour où ça compte.
+//
+// ⚠️ POURQUOI CE FICHIER EXISTE. PostgREST rejette un `PATCH` portant une colonne inconnue. Un hôte
+// qui déploie le code avant la migration voit donc TOUTES ses écritures échouer sur ce chemin, pas
+// seulement la fonction nouvelle — et le message parle d'une colonne, pas d'une version. Deux
+// chantiers ont été repoussés pour cette seule raison. Avec cette sonde, l'ordre de déploiement
+// cesse d'être un piège.
+
+let PLAYER = null;
+/**
+ * Une question posée une fois, retenue pour le processus.
+ *
+ * ⚠️ C'EST AUSSI CE QUI DÉDOUBLONNE LE JOURNAL, et il n'y a donc rien d'autre à écrire pour ça. La
+ * première version portait un second ensemble « déjà signalé » : vidé exactement quand celui-ci
+ * l'est, donc inatteignable. Une mutation qui le retirait ne faisait échouer aucun test — la bonne
+ * réponse n'était pas d'ajouter un test pour le justifier, c'était de constater qu'il ne servait à
+ * rien. Une garde qu'on ne peut pas voir refuser n'est pas une garde.
+ */
+const connues = new Map();
+
+function init(ctx) {
+  PLAYER = ctx;
+  connues.clear();
+}
+
+/**
+ * La base porte-t-elle cette colonne ?
+ *
+ * ⚠️ EN CAS DE DOUTE, ABSENTE. Supposer présente ferait échouer l'écriture ENTIÈRE — la nouvelle
+ * fonction et tout ce qui l'accompagne. Supposer absente fait attendre la fonction seule. Une
+ * fonction qui attend vaut mieux qu'une écriture perdue, et c'est la seule direction où l'erreur se
+ * répare toute seule quand la migration arrive.
+ *
+ * @param {string} table
+ * @param {string} colonne
+ * @param {string} migration le fichier à appliquer — c'est LUI qu'on nomme dans le journal
+ */
+function aLaColonne(table, colonne, migration) {
+  const cle = `${table}.${colonne}`;
+  if (!connues.has(cle)) connues.set(cle, sonder(table, colonne, migration, cle));
+  return connues.get(cle);
+}
+
+async function sonder(table, colonne, migration, cle) {
+  try {
+    // `limit=0` : on ne veut aucune ligne, seulement savoir si la colonne se sélectionne. PostgREST
+    // répond 400 « column … does not exist » quand elle manque — donc l'échec EST la réponse.
+    //
+    // ⚠️ LA PART ENCODÉE EST CALCULÉE À PART, ET PAS POUR LA LISIBILITÉ. La garde de portabilité de
+    // la CI traque la syntaxe propre à PostgREST — les ressources imbriquées « select=a(b) », les
+    // arbres booléens — en cherchant une parenthèse après « select= ». Écrite dans le gabarit,
+    // l'appel à encodeURIComponent en produisait une : la garde accusait une requête parfaitement
+    // portable. On lève l'ambiguïté du côté du code, pas du côté de la garde.
+    //
+    // ⚠️ ET CETTE SONDE EST LE SEUL ENDROIT QUI DÉPEND DU COMPORTEMENT D'ERREUR DE PostgREST. Sur
+    // une autre base, « la colonne manque » se demanderait autrement. C'est isolé ici exprès : un
+    // portage a un fichier à réécrire, pas une habitude à retrouver partout.
+    const champ = encodeURIComponent(colonne);
+    await PLAYER.db.request(`${table}?select=${champ}&limit=0`);
+    return true;
+  } catch {
+    // ⚠️ ON NE DISTINGUE PAS « COLONNE ABSENTE » DE « BASE INJOIGNABLE », ET C'EST VOULU. Les deux
+    // mènent à la même décision — ne pas écrire ce champ — et distinguer supposerait de lire un
+    // message d'erreur, c'est-à-dire de dépendre du texte d'un service tiers. Ce qui change entre
+    // les deux, c'est la durée : une base injoignable le redevient, et le processus suivant reposera
+    // la question.
+    signaler(cle, migration);
+    return false;
+  }
+}
+
+/**
+ * ⚠️ ON NOMME LE FICHIER, PAS L'ERREUR. « column does not exist » envoie l'exploitant lire du
+ * PostgREST ; « appliquez supabase/migrations/0001-…sql » lui dit quoi faire. La différence entre
+ * les deux se compte en heures.
+ */
+function signaler(cle, migration) {
+  const quoi = migration ? `Appliquez ${migration}.` : "Une migration est en attente.";
+  try {
+    console.warn(`[player] la colonne « ${cle} » manque : la fonction qui en dépend reste inactive. ${quoi}`);
+  } catch { /* sans console */ }
+}
+
+/** Pour les tests et l'exploitation : reposer la question. */
+function oublier() { connues.clear(); }
+
+module.exports = { init, aLaColonne, oublier };

package/supabase/migrations/0001-destinataire-atteste.sql

@@ -0,0 +1,30 @@
+-- 0001 — le destinataire ATTESTÉ par l'hôte, séparé de qui peut expédier en son nom
+--
+-- Pour : un hôte qui identifie lui-même son visiteur (code à usage unique, espace projet) et veut
+--        que ses lectures soient comptées, attribuées et révocables — sans lui donner de lien
+--        anonyme, et sans exiger le jeton d'un membre qu'il n'a pas.
+--
+-- Sans lui : rien ne change. Les liens attestés ne peuvent pas être créés, et le player refuse la
+--            demande en le disant. Aucune fonction existante n'est affectée.
+--
+-- Sûre pendant que la version précédente tourne : oui — additive, et personne ne lit ni n'écrit
+-- cette colonne tant que le code qui la connaît n'est pas déployé.
+--
+-- ⚠️ POURQUOI UNE COLONNE PLUTÔT QU'UN DRAPEAU. `recipient_email` porte aujourd'hui DEUX faits :
+-- « à qui ce lien est destiné » et « qui a le droit d'expédier en son nom au repartage ». Un lien
+-- attesté par l'hôte doit avoir le premier sans le second — son visiteur n'a jamais engagé sa
+-- responsabilité chez nous.
+--
+-- Un drapeau `atteste_par_hote` dirait « ne fais pas la chose » : il décrirait le correctif au lieu
+-- du fait, et quelqu'un l'ignorerait dans six mois pour un cas qui semblerait différent. Avec deux
+-- colonnes, la garde d'envoi (qui exige `recipient_email`) et l'héritage du repartage refusent tous
+-- deux SANS SAVOIR POURQUOI on les protège. La règle devient une conséquence de la donnée.
+--
+-- Formulé par le second hôte, dont la demande a produit la séparation.
+
+alter table public.commercial_doc_shares
+  add column if not exists attested_recipient_email text;
+
+comment on column public.commercial_doc_shares.attested_recipient_email is
+  'Destinataire attesté par l''hôte : sert à ATTRIBUER une lecture, jamais à expédier en son nom. '
+  'La colonne recipient_email, elle, dit qui peut expédier — vide quand personne ne le peut.';