discovery-media-player 0.1.9 → 0.1.11

package/context/standalone.js

@@ -13,6 +13,7 @@
 // ⚠️ Il ne remplace pas un câblage : il ne sait rien de vos rôles. Ce qu'il ne sait pas, il le
 // REFUSE — jamais il n'accorde par défaut. Cf. docs/CONFIGURATION.md, « Decisions that are yours ».
 
+const crypto = require("node:crypto");
 const storage = require("./storage");
 
 /**
@@ -164,6 +165,39 @@ function createStandaloneContext(env = process.env) {
       }),
       // Écriture de fichier : hors périmètre d'une instance autonome (elle sert, elle ne range pas).
       async put() { throw new Error("storage.put n'est pas disponible sans câblage d'hôte"); },
+
+      /**
+       * URL d'envoi signée, pour une pièce jointe de chat. **Capacité de l'HÔTE**, pas du cœur.
+       *
+       * ⚠️ Le cœur lisait `SUPABASE_SERVICE_ROLE_KEY` directement dans l'environnement — la clé
+       * qui ouvre toute la base, lue en contournant le contexte injecté, c'est-à-dire en violant
+       * la règle que le projet affiche partout ailleurs. Un hôte qui branche SA base se faisait
+       * court-circuiter ici sans que rien ne le signale.
+       *
+       * ⚠️ Honnête sur ce qui reste : la page renvoyée appelle `uploadToSignedUrl` de supabase-js.
+       * Cette capacité retire le secret du cœur ; elle ne rend pas la fonction portable pour
+       * autant. Un hôte sur une autre pile devra aussi remplacer la moitié navigateur.
+       */
+      async signUpload(bucket, chemin) {
+        const base = sansBarreFinale(env.SUPABASE_URL);
+        const cle = String(env.SUPABASE_SERVICE_ROLE_KEY || "");
+        if (!base || !cle || !bucket || !chemin) return null;
+        try {
+          const r = await fetch(`${base}/storage/v1/object/upload/sign/${bucket}/${chemin}`, {
+            method: "POST",
+            headers: { apikey: cle, Authorization: `Bearer ${cle}`, "Content-Type": "application/json" },
+            body: "{}",
+          });
+          if (!r.ok) return null;
+          const d = await r.json().catch(() => null);
+          const url = d && d.url;
+          if (!url) return null;
+          return {
+            token: (String(url).split("token=")[1] || "").split("&")[0],
+            publicUrl: `${base}/storage/v1/object/public/${bucket}/${chemin}`,
+          };
+        } catch { return null; }
+      },
     },
 
     db: { request: db.request, selectAll: db.selectAll },
@@ -219,6 +253,29 @@ function createStandaloneContext(env = process.env) {
           return r.ok ? await r.json() : null;
         } catch { return null; }
       },
+      /**
+       * Cet appel vient-il de l'HÔTE lui-même, et non d'un de ses membres ?
+       *
+       * ⚠️ UN SECRET DISTINCT DE `PLAYER_HOST_FETCH_SECRET`, ET C'EST LE POINT. Celui-là ne
+       * circule QUE dans un sens — le player l'envoie à l'hôte, à chaque fichier. Il traîne donc
+       * dans les journaux d'accès de l'hôte, ses proxys, son traceur d'erreurs. Aujourd'hui, qui
+       * l'obtient peut se faire passer pour le player AUPRÈS de l'hôte. L'accepter en entrée lui
+       * ajouterait le droit d'écrire ICI — créer des liens tracés qui collecteront des lectures.
+       * Une variable de plus contre un rayon d'explosion qui ne grandit pas : un secret ne suit
+       * ni un changement de destinataire, ni un changement de direction.
+       *
+       * ⚠️ Le cœur ne voit jamais le secret : il pose une QUESTION, l'adaptateur répond oui ou
+       * non. Non configuré ⇒ non — un pouvoir qu'on ne sait pas accorder ne s'accorde pas.
+       */
+      isTrustedHostCall(headers) {
+        const attendu = String(env.PLAYER_HOST_SHARE_SECRET || "");
+        const recu = String((headers && (headers["x-player-share-secret"] || headers["X-Player-Share-Secret"])) || "");
+        if (!attendu || !recu) return false;
+        // Comparaison à temps constant : une comparaison naïve fuit la longueur du préfixe commun.
+        const a = Buffer.from(attendu, "utf8"); const b = Buffer.from(recu, "utf8");
+        return a.length === b.length && crypto.timingSafeEqual(a, b);
+      },
+
       // ⚠️ Le rôle vient d'`app_metadata`, JAMAIS d'`user_metadata` : ce dernier est modifiable par
       // l'utilisateur lui-même. S'y fier revient à laisser chacun choisir ses droits.
       roleOf: (user) => String(((user || {}).app_metadata || {}).role || "").trim().toLowerCase(),
@@ -285,7 +342,8 @@ function createStandaloneContext(env = process.env) {
     },
 
     config: {
-      supabaseUrl: env.SUPABASE_URL || "",
+      // Sans barre finale : le cœur consomme cette valeur telle quelle. Un seul endroit décide.
+      supabaseUrl: sansBarreFinale(env.SUPABASE_URL),
       supabasePublishableKey: env.SUPABASE_PUBLISHABLE_KEY || "",
       mapsKey: env.GOOGLE_MAPS_API_KEY || "",
       extraFrameAncestors: String(env.DOC_FRAME_ANCESTORS || "").split(/\s+/).filter(Boolean),
@@ -295,6 +353,9 @@ function createStandaloneContext(env = process.env) {
       // les deux, une variable oubliée redonne exactement le symptôme que 0.1.8 a retiré — des
       // membres « non authentifiés », ce qui ressemble à un droit manquant.
       separateIssuer: !!sansBarreFinale(env.PLAYER_AUTH_URL),
+      // Même raison que ci-dessus : « la capacité existe » et « elle est configurée »
+      // sont deux questions, et seule la seconde explique un refus.
+      hostShare: !!String(env.PLAYER_HOST_SHARE_SECRET || ""),
     },
   };
 }

package/docs/HOST-CONTRACT.md

@@ -26,9 +26,10 @@ need.
   "product": "discovery-media-player",
   "contract": 1,
   "version": "0.1.9",
-  "capabilities": ["docshare", "presentations", "embed-denied", "host-fetch", "brand-reference", "host-auth"],
+  "capabilities": ["docshare", "presentations", "embed-denied", "host-fetch", "brand-reference", "host-auth", "host-share"],
   "frameAncestors": ["'self'", "https://*.vercel.app", "https://app.example.com"],
   "separateIssuer": true,
+  "hostShare": true,
   "plugins": { "bot": false, "visitors": false, "brandIntro": false, "botBrowser": false, "providerQuotas": false }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discovery-media-player",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "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",
@@ -69,7 +69,7 @@
     "@eslint/js": "^10.0.1",
     "esbuild": "^0.28.2",
     "eslint": "^10.8.1",
-    "jsdom": "^25.0.1",
+    "jsdom": "^30.0.1",
     "typescript": "^5.5.4",
     "typescript-eslint": "^8.46.4",
     "vitest": "^4.1.10"

package/server/handler.js

@@ -1172,7 +1172,7 @@ const LEGAL_CSS = `
 function sendHtml(res, status, html, scriptSrc, imgExtra, frameAncestors) {
   res.statusCode = status;
   // Origine Supabase Storage (voix ElevenLabs mise en cache dans le bucket public tts-cache) → autorisée en media-src.
-  let supaOrigin; try { supaOrigin = new URL(process.env.SUPABASE_URL || "").origin; } catch { supaOrigin = ""; }
+  let supaOrigin; try { supaOrigin = new URL((PLAYER.config && PLAYER.config.supabaseUrl) || "").origin; } catch { supaOrigin = ""; }
   res.setHeader("Content-Type", "text/html; charset=utf-8");
   res.setHeader("Cache-Control", "no-store, max-age=0");
   res.setHeader("X-Content-Type-Options", "nosniff");
@@ -1217,9 +1217,16 @@ function sendSoftWallHtml(res, html, nonce, imgExtra, frameAncestors) {
  * doit pouvoir être encadrée exactement comme la visionneuse qu'elle remplace — sinon le
  * navigateur bloque le rendu et le message de refus ci-dessous n'est jamais émis.
  */
+// ⚠️ LA MÊME SOURCE QUE LA CARTE D'IDENTITÉ, ET C'EST TOUT LE SUJET. Cette fonction lisait
+// `process.env.DOC_FRAME_ANCESTORS` pendant que `?contract=1` annonçait
+// `PLAYER.config.extraFrameAncestors`. Les deux coïncident tant qu'un hôte remplit sa
+// configuration depuis cette variable — c'est le cas des deux hôtes actuels, donc rien n'était
+// cassé. Mais un hôte qui la calcule autrement (base, fichier, autre nom de variable) verrait la
+// carte annoncer une liste et l'en-tête CSP en servir une autre : « configuré » et « servi »
+// divergents à l'intérieur même du mécanisme construit pour détecter cette divergence.
 function embedFrameAncestors() {
   return ["'self'", "https://*.vercel.app"]
-    .concat(String(process.env.DOC_FRAME_ANCESTORS || "").split(/\s+/).filter(Boolean))
+    .concat((PLAYER.config && PLAYER.config.extraFrameAncestors) || [])
     .join(" ");
 }
 
@@ -1580,7 +1587,7 @@ ${LEGAL_CSS}
   <script nonce="${nonce}">${PLAYER_BROWSER_JS}</script>
   <script nonce="${nonce}" src="${PDFJS}/pdf.min.js"></script>
   ${preview ? `<script nonce="${nonce}" src="${SUPAJS}"></script>
-  <script nonce="${nonce}">var LIVECFG={supaUrl:${JSON.stringify(share.supa_url || "")},supaKey:${JSON.stringify(share.supa_key || "")}};var GMAPS_KEY=${JSON.stringify(process.env.GOOGLE_MAPS_API_KEY || "")};${LIVE_JS}
+  <script nonce="${nonce}">var LIVECFG={supaUrl:${JSON.stringify(share.supa_url || "")},supaKey:${JSON.stringify(share.supa_key || "")}};var GMAPS_KEY=${JSON.stringify((PLAYER.config && PLAYER.config.mapsKey) || "" || "")};${LIVE_JS}
   ${MAP_JS}</script>` : ""}
   <script nonce="${nonce}">
   (function(){
@@ -2087,7 +2094,7 @@ function presentHtml(pres, nonce, logoUrl, supaUrl, supaKey) {
   })();
   </script>
   <script nonce="${nonce}">
-  var LIVECFG={supaUrl:${JSON.stringify(supaUrl || "")},supaKey:${JSON.stringify(supaKey || "")}};var GMAPS_KEY=${JSON.stringify(process.env.GOOGLE_MAPS_API_KEY || "")};
+  var LIVECFG={supaUrl:${JSON.stringify(supaUrl || "")},supaKey:${JSON.stringify(supaKey || "")}};var GMAPS_KEY=${JSON.stringify((PLAYER.config && PLAYER.config.mapsKey) || "" || "")};
   ${LIVE_JS}
   ${MAP_JS}
   (function(){
@@ -2252,7 +2259,7 @@ async function handler(req, res) {
           // `spoken` est renvoyé quand il diffère → le viewer aligne le karaoké dessus (mapping mot à mot).
           const spoken = (() => { if (!pron) return text; try { const s = pron(text).replace(/\s+/g, " ").trim().slice(0, 700); return s || text; } catch { return text; } })();
           const modelId = process.env.ELEVENLABS_MODEL || "eleven_multilingual_v2";
-          const base = process.env.SUPABASE_URL || "";
+          const base = (PLAYER.config && PLAYER.config.supabaseUrl) || "";
           // « v2 » = version du format de cache : les extraits v1 (sans alignement timestamps) sont ignorés
           // d'office et tout se régénère AVEC l'horodatage par caractère (karaoké exact). Anciens fichiers = poids mort minime.
           const keyFor = (vid) => crypto.createHash("sha256").update(vid + "|" + modelId + "|v2|" + spoken).digest("hex");
@@ -2454,6 +2461,67 @@ async function handler(req, res) {
       if (String(body.action || "").startsWith("docshare.")) {
         const jd = (status, obj) => { res.statusCode = status; res.setHeader("Content-Type", "application/json"); res.end(JSON.stringify(obj)); };
         try {
+          // ── L'HÔTE PARLE EN SON NOM PROPRE ────────────────────────────────────────────────
+          //
+          // Un lien ANONYME — la plaquette publique d'un programme, lue par un prospect sans
+          // compte — n'a pas de membre derrière lui. Exiger un JWT forcerait l'hôte à inventer
+          // une identité qui n'existe pas : un compte de service dont le mot de passe ouvre bien
+          // plus que la création d'un lien, ou pire, l'aperçu interne détourné — ce qui rangerait
+          // un prospect dans la population INTERNE et ferait mentir la seule phrase qui compte
+          // ici : « ce client a lu pendant douze minutes ».
+          //
+          // C'est la même nature que `/authz` et `/branding`, que l'hôte sert déjà en serveur à
+          // serveur. Demandé par le second hôte, qui avait écarté les trois contournements
+          // lui-même avant d'écrire.
+          //
+          // ⚠️ TROIS VERROUS, et chacun ferme une porte différente :
+          //   1. `create` UNIQUEMENT — révoquer, lister, lire des statistiques restent des actes
+          //      de membre. Un secret de serveur ne doit pas donner à voir qui a lu quoi.
+          //   2. AUCUN destinataire — le nominatif a un membre. L'admettre ici rouvrirait par la
+          //      bande ce que le JWT protège.
+          //   3. IDEMPOTENT par `docId` — sans ça, un redéploiement, une reprise sur erreur ou un
+          //      double clic donnent trois liens pour la même plaquette, donc des statistiques
+          //      fragmentées en trois, découvertes en les lisant six mois plus tard.
+          if (typeof PLAYER.identity.isTrustedHostCall === "function"
+              && PLAYER.identity.isTrustedHostCall(req.headers)) {
+            if (body.action !== "docshare.create") {
+              return jd(403, { ok: false, error: "L'appel serveur à serveur ne crée que des liens sans destinataire." });
+            }
+            if (body.recipientEmail) {
+              return jd(400, { ok: false, error: "Un lien avec destinataire appartient à un membre : il exige son jeton." });
+            }
+            const docId = String(body.docId || "").trim();
+            if (!docId || !body.fileUrl) return jd(400, { ok: false, error: "docId/fileUrl requis" });
+
+            const ipH = String(req.headers["x-forwarded-for"] || "").split(",")[0].trim() || req.socket?.remoteAddress || "hote";
+            if (!(await PLAYER.limits.allow(`hshare:${ipH}`, 120, 3600))) return jd(429, { ok: false, error: "rate" });
+
+            // ⚠️ La clé d'idempotence n'a PAS demandé de colonne : « le lien de l'hôte pour ce
+            // document » est exactement la ligne sans créateur ET sans destinataire. Seul ce
+            // chemin en produit, donc elle est sans ambiguïté — et une instance déjà en service
+            // n'a aucune migration à passer.
+            const dejaLa = await PLAYER.db.request(
+              `commercial_doc_shares?doc_id=eq.${encodeURIComponent(docId)}&created_by=is.null&recipient_email=is.null&select=slug&limit=1`,
+            );
+            if (Array.isArray(dejaLa) && dejaLa[0]) {
+              await PLAYER.db.request(`commercial_doc_shares?slug=eq.${encodeURIComponent(dejaLa[0].slug)}`, {
+                method: "PATCH", headers: { Prefer: "return=minimal" },
+                body: { doc_title: body.docTitle || null, file_url: String(body.fileUrl), file_name: body.fileName || null, revoked: false },
+              });
+              return jd(200, { ok: true, slug: dejaLa[0].slug, reused: true });
+            }
+            // `createdBy` reste NUL : personne ne l'a créé. Le filtre « mes liens » compare
+            // `created_by=eq.<email>`, qui exclut les NUL — ce lien n'apparaît donc dans la liste
+            // de personne, et reste visible en administration (`list.all`, qui ne filtre pas).
+            const neuf = await createShare({
+              brandKey: body.brandKey, docId, docTitle: body.docTitle, fileUrl: body.fileUrl,
+              fileName: body.fileName, createdBy: null, bot: body.bot, botScript: body.botScript,
+              guided: body.guided, profileId: body.profileId, allowDownload: body.allowDownload,
+              videoLayout: body.videoLayout, logo: body.logo, logoDark: body.logoDark,
+            });
+            return jd(200, { ok: true, slug: neuf.slug, reused: false });
+          }
+
           const u = await PLAYER.identity.verifyToken(req.headers.authorization);
           if (!u || !u.email) return jd(401, { ok: false, error: "auth" });
           // L'action est transmise telle quelle (`create`, `revoke`…) : l'hôte peut séparer
@@ -2588,6 +2656,7 @@ async function handler(req, res) {
         // muette sur les URL.
         capabilities: [
           "docshare", "presentations", "embed-denied", "host-fetch", "brand-reference", "host-auth",
+          "host-share",
         ],
         // ⚠️ POUR QUELLES ORIGINES cette instance accepte d'être encadrée. Un booléen ne
         // suffisait pas : un hôte a besoin de voir que SON domaine manque, pas seulement que
@@ -2600,6 +2669,10 @@ async function handler(req, res) {
         // l'hôte connaît déjà son émetteur — il veut seulement savoir si l'instance le regarde.
         // Dire lequel n'aiderait personne et renseignerait qui sonde.
         separateIssuer: !!(PLAYER.config && PLAYER.config.separateIssuer),
+        // « L'hôte peut-il créer un lien en son nom propre ? » — configuré, pas seulement
+        // possible. Un hôte qui oublie le secret reçoit un 401 qui ressemble à un droit
+        // manquant ; ce booléen le lui dit sans qu'il ait à essayer.
+        hostShare: !!(PLAYER.config && PLAYER.config.hostShare),
         // Greffons de l'hôte : présents ou coupés (PLAYER_PLUGINS_OFF). Booléens uniquement.
         plugins: {
           bot: !!p.bot, visitors: !!p.visitors, brandIntro: !!p.brandIntro,
@@ -2651,8 +2724,8 @@ async function handler(req, res) {
         await relayerFichier(res, r, null);
         return;
       }
-      const supaUrl = process.env.SUPABASE_URL || "";
-      const supaKey = process.env.SUPABASE_PUBLISHABLE_KEY || "";
+      const supaUrl = (PLAYER.config && PLAYER.config.supabaseUrl) || "";
+      const supaKey = (PLAYER.config && PLAYER.config.supabasePublishableKey) || "";
       let alogo = ""; try { alogo = await PLAYER.branding.logo(); } catch { /* sans logo */ }
       const anonce = crypto.randomBytes(16).toString("base64");
       // Même sujet, trouvé en vérifiant le précédent : cette page ne passait AUCUN paramètre,
@@ -2674,8 +2747,8 @@ async function handler(req, res) {
         await relayerFichier(res, r, dispositionInline(q.name));
         return;
       }
-      const supaUrl = process.env.SUPABASE_URL || "";
-      const supaKey = process.env.SUPABASE_PUBLISHABLE_KEY || "";
+      const supaUrl = (PLAYER.config && PLAYER.config.supabaseUrl) || "";
+      const supaKey = (PLAYER.config && PLAYER.config.supabasePublishableKey) || "";
       const pseudo = { preview: true, 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 || ""), 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 || ""))}` };
       let plogo = ""; try { plogo = await PLAYER.branding.logo(); } catch { /* sans logo */ }
       const pnonce = crypto.randomBytes(16).toString("base64");

package/server/presentations.js

@@ -130,7 +130,7 @@ async function endPresentation(slug, control) {
 // validés par le bucket (image/*+pdf, ≤10 Mo). L'URL publique finale est renvoyée pour attacher au message.
 const ATT_KINDS = { "image/png": "image", "image/jpeg": "image", "image/webp": "image", "image/gif": "image", "application/pdf": "pdf" };
 async function createUploadUrl(slug, name, type) {
-  const base = (process.env.SUPABASE_URL || "").replace(/\/+$/, ""); const KEY = process.env.SUPABASE_SERVICE_ROLE_KEY || "";
+
   // ⚠️ `Object.hasOwn` et pas une simple lecture : un objet littéral hérite de `constructor`,
   // `toString`, `valueOf`, `__proto__`… `ATT_KINDS["constructor"]` rend une FONCTION, donc une
   // valeur vraie — la garde juste en dessous laissait alors passer un type qui n'a jamais été
@@ -138,14 +138,21 @@ async function createUploadUrl(slug, name, type) {
   // action publique. Signalé par un hôte tiers qui venait de trouver la même forme chez lui.
   const demande = String(type || "").toLowerCase();
   const kind = Object.hasOwn(ATT_KINDS, demande) ? ATT_KINDS[demande] : null;
-  if (!kind || !slug || !base || !KEY) return { ok: false, status: 400 };
+  if (!kind || !slug) return { ok: false, status: 400 };
   const safe = (String(name || "fichier").replace(/[^a-zA-Z0-9._-]/g, "_").slice(-60)) || "fichier";
   const path = `${String(slug).replace(/[^a-zA-Z0-9._-]/g, "")}/${Date.now()}-${crypto.randomBytes(4).toString("hex")}-${safe}`;
-  const r = await fetch(`${base}/storage/v1/object/upload/sign/present-attachments/${path}`, { method: "POST", headers: { apikey: KEY, Authorization: `Bearer ${KEY}`, "Content-Type": "application/json" }, body: "{}" });
-  if (!r.ok) return { ok: false, status: 502 };
-  const d = await r.json().catch(() => null); const url = d && d.url; if (!url) return { ok: false, status: 502 };
-  const token = (String(url).split("token=")[1] || "").split("&")[0];
-  return { ok: true, path, token, kind, publicUrl: `${base}/storage/v1/object/public/present-attachments/${path}` };
+
+  // ⚠️ La signature appartient à l'HÔTE : c'est lui qui détient la clé, pas le cœur. Un hôte qui
+  // ne fournit pas cette capacité voit la pièce jointe refusée — et prévenue. Le refus silencieux
+  // serait pire : une pièce jointe qui ne part jamais, sans que personne sache que la capacité
+  // manque.
+  if (!PLAYER.storage || typeof PLAYER.storage.signUpload !== "function") {
+    try { PLAYER.errors.capture(new Error("storage.signUpload absent du contexte : les pièces jointes de chat sont indisponibles"), {}); } catch { /* jamais bloquant */ }
+    return { ok: false, status: 501 };
+  }
+  const signe = await PLAYER.storage.signUpload("present-attachments", path);
+  if (!signe || !signe.token) return { ok: false, status: 502 };
+  return { ok: true, path, token: signe.token, kind, publicUrl: signe.publicUrl };
 }
 
 /**
@@ -177,7 +184,10 @@ function premierPublic(reponse) {
 
 async function addMessage(slug, { name, email, avatar, isPresenter, isMember, body, replyTo, replyName, replyText, authorToken, attachment }) {
   const b = String(body || "").trim().slice(0, 2000);
-  const base = (process.env.SUPABASE_URL || "").replace(/\/+$/, "");
+  // ⚠️ Pas de normalisation ici : `config.supabaseUrl` arrive SANS barre finale, c'est le
+  // contrat de l'adaptateur. En rajouter une deuxième couche, c'est deux endroits qui décident —
+  // et c'est comme ça que `.replace(/\/+$/, "")` s'est retrouvé à cinq exemplaires dans ce dépôt.
+  const base = String((PLAYER.config && PLAYER.config.supabaseUrl) || "");
   let att = null;
   if (attachment && typeof attachment === "object" && attachment.url && String(attachment.url).startsWith(base + "/storage/v1/object/public/present-attachments/")) {
     att = { url: String(attachment.url).slice(0, 600), name: String(attachment.name || "").slice(0, 120), type: String(attachment.type || "").slice(0, 60), kind: attachment.kind === "pdf" ? "pdf" : "image" };