Un dépôt fraîchement cloné doit pouvoir passer un appel

# EN   from the cell's workstations. An empty LIVEKIT_URL disables video

# EN   conferencing; the product says so.

LIVEKIT_URL=ws://localhost:7880

# Adresse de l'API média vue depuis le serveur. Dans la composition Docker,

# l'hôte est le nom du service : « localhost » y désigne le conteneur

# applicatif lui-même. Laissez vide hors conteneur.

#

# EN — Address of the media API as seen from the server. In the Docker

# EN   composition the host is the service name: "localhost" there means the

# EN   application container itself. Leave empty outside a container.

LIVEKIT_INTERNAL_URL=http://livekit:7880

# Adresse de l'API média vue depuis le serveur, à renseigner UNIQUEMENT pour un

# serveur média mutualisé. La composition donne la sienne au conteneur, et hors

# conteneur l'adresse se déduit de LIVEKIT_URL — « ws:// » devient « http:// »,

# c'est le même port.

#

# La valeur « http://livekit:7880 » figurait ici par défaut : elle est juste

# dans la composition et introuvable hors d'elle, si bien que lancer l'API sur

# sa machine échouait sur « ENOTFOUND livekit » au premier appel.

#

# EN — Address of the media API as seen from the server, to be filled in ONLY

# EN   for a shared media server. The composition gives its own to the

# EN   container, and outside a container the address is derived from

# EN   LIVEKIT_URL — "ws://" becomes "http://", same port.

LIVEKIT_INTERNAL_URL=

LIVEKIT_KEY=kastell

LIVEKIT_SECRET=CHANGEZ-MOI-secret-media-au-moins-32-caracteres

  };

}

/**

 * L'adresse d'administration, quand personne ne l'a dite.

 *

 * `.env.example` invite à laisser LIVEKIT_INTERNAL_URL vide hors conteneur, et

 * la composition fournit la sienne au conteneur — la variable n'a donc de

 * raison d'être renseignée que sur un serveur média mutualisé.

 *

 * Mais vide, on retombait sur l'adresse du navigateur : « ws://… », que le SDK

 * d'administration ne sait pas composer — il attend http(s). Qui lance l'API

 * sur sa machine récoltait « fetch failed » au premier appel, sans que rien ne

 * désigne la bonne variable. La consigne de la documentation était donc juste

 * et inapplicable.

 *

 * On traduit le schéma plutôt que de le recopier. C'est la même adresse : la

 * signalisation et l'API d'administration vivent sur le même port.

 */

export function adresseAdministration(c: ConfigurationMedia): string {

  if (c.urlInterne) return c.urlInterne;

  return c.url.replace(/^ws(s?):\/\//i, "http$1://");

}

export function mediaLiveKit(c: ConfigurationMedia): Media {

  const administration = c.urlInterne ?? c.url;

  const administration = adresseAdministration(c);

  const salles = new RoomServiceClient(administration, c.cle, c.secret);

  const egress = new EgressClient(administration, c.cle, c.secret);

    laisseesVides.length > 0 && motif === "", motif);

  await verifierPortMedia(compose, r);

  // ── Ce que l'exemple promet, il doit le tenir ────────────────────────────

  //

  // « Laissez vide hors conteneur » était juste, et l'exemple livrait quand

  // même « http://livekit:7880 » — une adresse qui ne résout que dans la

  // composition. Qui lançait l'API sur sa machine récoltait « ENOTFOUND

  // livekit » au premier appel média, avec pour seule piste une variable que

  // la documentation lui disait de laisser vide.

  const exemple = await readFile(`${racine}.env.example`, "utf8");

  r.verifie("EX-26", "l'exemple laisse l'adresse média interne vide",

    /^LIVEKIT_INTERNAL_URL=\s*$/m.test(exemple),

    /^LIVEKIT_INTERNAL_URL=(.*)$/m.exec(exemple)?.[1] ?? "absente");

}

/**

  r.verifie("EF-803", "et c'est le même numéro des deux côtés",

    declare !== null && publie !== null && declare[1] === publie[1],

    `livekit.yaml ${declare?.[1] ?? "—"} / compose ${publie?.[1] ?? "—"}`);

  // ── Le fichier livré est celui d'un poste de développement ───────────────

  //

  // Il annonce la boucle locale, et c'est délibéré : le navigateur et le

  // conteneur sont sur la même machine. Déployé tel quel il échoue tout de

  // suite et franchement, là où l'ancien « use_external_ip: false » annonçait

  // l'adresse de pont du conteneur — injoignable, mais silencieusement.

  //

  // L'installateur écrit l'autre dès que l'adresse publique n'est pas locale.

  // Ce contrôle tombe si quelqu'un met ici une adresse de serveur, ce qui

  // ferait du fichier livré une configuration de production par accident.

  const annonce = /^\s*node_ip:\s*(\S+)\s*$/m.exec(livekit);

  r.verifie("EF-803", "le fichier livré n'annonce que la boucle locale",

    annonce?.[1] === "127.0.0.1", annonce?.[1] ?? "aucun node_ip");

}

import * as chat from "../domaine/chat.js";

import { mainCourante } from "../noyau/rejeu.js";

import { verifierEnBase } from "../noyau/integrite.js";

import { definirMedia, mediaEssai, mediaLiveKit } from "../adaptateurs/media.js";

import {

  adresseAdministration, definirMedia, mediaEssai, mediaLiveKit,

} from "../adaptateurs/media.js";

import { stockage, stockageConfigure } from "../adaptateurs/stockage.js";

import type { Rapport } from "./rapport.js";

    JSON.stringify(corps.controles).includes("443"));

  // ── Le jeton du fournisseur ──────────────────────────────────────────────

  // ── L'adresse d'administration, quand personne ne la dit ─────────────────

  r.titre("Adresse du serveur média");

  r.verifie("EF-801", "vide, elle se déduit de celle du navigateur",

    adresseAdministration({

      url: "ws://localhost:7880", cle: "c", secret: "s",

      stockage: { region: "r", seau: "s", acces: "a", secret: "x" },

    }) === "http://localhost:7880");

  r.verifie("EF-801", "le chiffrement suit : wss donne https",

    adresseAdministration({

      url: "wss://media.exemple.fr", cle: "c", secret: "s",

      stockage: { region: "r", seau: "s", acces: "a", secret: "x" },

    }) === "https://media.exemple.fr");

  r.verifie("EF-801", "renseignée, elle l'emporte — le cas du serveur mutualisé",

    adresseAdministration({

      url: "wss://media.exemple.fr", urlInterne: "http://172.17.0.1:7880",

      cle: "c", secret: "s",

      stockage: { region: "r", seau: "s", acces: "a", secret: "x" },

    }) === "http://172.17.0.1:7880");

  r.titre("Jeton média");

  const vrai = mediaLiveKit({

    url: "ws://livekit.invalide", cle: "cle-de-verification",

  # que la signalisation ou le TURN — c'est-à-dire de la façon qui marche déjà

  # partout. Il épargne aussi cent processus « docker-proxy » sur l'hôte.

  udp_port: 50000

  use_external_ip: false

  # Adresse annoncée aux navigateurs. La boucle locale, parce que ce fichier

  # est celui d'un poste de développement : le navigateur et le conteneur y

  # sont sur la même machine, et Docker publie ce port sur elle.

  #

  # Ne le déployez pas tel quel. Un conteneur qui annonce sa propre adresse de

  # pont — ce que fait « use_external_ip: false » — n'est joignable par aucun

  # navigateur extérieur, et l'appel échoue sur « ICE failed » sans rien dire

  # d'utile. La boucle locale échoue au moins franchement, et tout de suite.

  #

  # L'installateur écrit docker/livekit.local.yaml dès que l'adresse publique

  # n'est pas locale, avec « use_external_ip: true » et le vrai domaine TURN.

  node_ip: 127.0.0.1

# Relais TURN.

#