diff --git a/content/_index.fr.md b/content/_index.fr.md new file mode 100644 index 0000000..d0bf731 --- /dev/null +++ b/content/_index.fr.md @@ -0,0 +1,106 @@ ++++ +draft = false +title = '' ++++ + +
+ Bannière + +
+

Construisez des bibliothèques
+ et des plateformes
+ coopératives et inarrêtables.

+
+ Explorer Riff.CC + Créer un Lens +
+
+ +
+
+

Des bibliothèques, pas des châteaux de sable.

+

Les bibliothèques traditionnelles sont comme des châteaux de sable: construites pour un objectif, puis effacées par la marée.

+

Nous construisons des bibliothèques permanentes, décentralisées, durables, et conçues pour survivre à leurs créateurs.

+

Créez un Lens, et construisez une bibliothèque.

+
+
+ Capture d'écran du site Riff.CC +
+
+ +
+
+

🌐 Décentralisé

+

Les Lenses sont conçus pour être distribués dans le monde entier et livrer du contenu à vos utilisateurs à très grande vitesse.

+ Décentralisé +
+ +
+

👥 Coopératif

+

Vous pouvez mirrorer instantanément des bibliothèques de contenu entières depuis d'autres Lenses vers le vôtre, et inversement. Nous appelons cela la défédérisation.

+ Miroir +
+ +
+

♾️ Durable

+

Des bibliothèques et des plateformes conçues pour durer. Utilisez nos outils pour rendre votre contenu accessible pendant des générations.

+ Durable +
+
diff --git a/content/about.fr.md b/content/about.fr.md new file mode 100644 index 0000000..2101578 --- /dev/null +++ b/content/about.fr.md @@ -0,0 +1,29 @@ ++++ +title = 'À propos de Riff.CC' +date = 2025-01-13T12:00:00Z +draft = false ++++ + +*"e cinere surgemus" (des cendres, nous nous relevons)* + +Riff.CC construit des outils et des plateformes qui permettent aux utilisateurs de créer et de partager du contenu numérique dans des espaces numériques permanents et résilients appelés Lenses. + +## Qu'est-ce qu'un Lens ? +Un Lens est un espace numérique décentralisé et auto-hébergé, votre propre vision du monde, contenant des médias, des outils et du contenu que vous pouvez partager ou élaborer ensemble. Les Lenses peuvent suivre d'autres Lenses pour synchroniser instantanément le contenu, ce qui permet une collaboration fluide et sans permission. + +Le partage privé est également prévu, afin que vous puissiez contrôler qui peut suivre votre Lens et y accéder. + +Vous pouvez apprendre à [configurer un Lens](/docs/flagship/create-lens/) dans notre [documentation](/docs). + +## Rejoignez-nous + +Que vous soyez développeur, créateur, bibliothécaire, ou simplement quelqu'un qui croit en un Internet libre et ouvert, vous pouvez nous aider à construire l'avenir du contenu libre. + +Vous pouvez [rejoindre notre communauté](https://discord.gg/cvYgQSfCrQ), consulter notre [documentation](/docs) ou lire notre [code](https://github.com/riffcc). + +## Construisez avec nous +

Si vous voulez découvrir comment utiliser le Lens SDK et les technologies Flagship de Riff.CC pour créer vos propres applications, qu'elles soient d'entreprise, open source, ou personnelles, ou si vous voulez savoir ce que nous pourrions construire pour vous,

+ +écrivez-nous à [team@riff.cc](mailto:team@riff.cc) et nous prendrons le temps d'échanger sur vos besoins et sur la manière dont nous pouvons vous aider. + +Que vous construisiez vos applications vous-même ou que vous souhaitiez les construire avec nous, nous pouvons vous aider à adapter le Lens SDK à presque n'importe quel usage. diff --git a/content/contact.fr.md b/content/contact.fr.md new file mode 100644 index 0000000..b6979dc --- /dev/null +++ b/content/contact.fr.md @@ -0,0 +1,14 @@ ++++ +title = 'Nous contacter' +draft = false ++++ + +Vous pouvez nous joindre par e-mail à [team@riff.cc](mailto:team@riff.cc). + +Nous utilisons Discord pour notre communauté et pour coordonner le développement. + +Rejoignez notre communauté sur Discord à l'adresse [https://discord.gg/cvYgQSfCrQ](https://discord.gg/cvYgQSfCrQ) et venez nous dire bonjour. + +Pour les partenariats et les demandes commerciales, veuillez écrire à [wings@riff.cc](mailto:wings@riff.cc). + +Pour les questions ou réclamations liées au droit d'auteur, veuillez contacter [dmca@riff.cc](mailto:dmca@riff.cc). diff --git a/content/docs/_index.fr.md b/content/docs/_index.fr.md new file mode 100644 index 0000000..3c479a9 --- /dev/null +++ b/content/docs/_index.fr.md @@ -0,0 +1,14 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Documentation' +weight = 1 ++++ + +Bienvenue dans la documentation de Riff.CC ! + +Nous vous conseillons de commencer par [Flagship](/fr/docs/flagship), le logiciel qui fait fonctionner Riff.CC. + +Vous pouvez également lire la section [Riff.CC](/fr/docs/riff.cc), le service de streaming qui vous permet de regarder, partager et organiser du contenu média légalement libre. + +Quand vous serez prêt, envisagez aussi de [créer votre propre Lens](/fr/docs/flagship/create-lens) ! diff --git a/content/docs/concepts/_index.fr.md b/content/docs/concepts/_index.fr.md new file mode 100644 index 0000000..47ff127 --- /dev/null +++ b/content/docs/concepts/_index.fr.md @@ -0,0 +1,39 @@ +--- +draft: false +title: 'Concepts' +weight: 1 +sidebar: + open: true +--- + +Riff.CC repose sur plusieurs concepts clés qui définissent son fonctionnement et la manière dont il interagit avec ses utilisateurs. Ces concepts constituent la base de notre service de streaming décentralisé et de notre modèle de bibliothèque coopérative. + +Vous pouvez en apprendre davantage sur chaque concept dans les pages dédiées. + +## Creative Commons + +Riff.CC se concentre sur des contenus média légalement libres, principalement sous licence Creative Commons. Cela permet aux utilisateurs de partager, remixer et développer des œuvres existantes tout en respectant les droits des créateurs. Nous hébergeons également des œuvres du domaine public afin de proposer un large éventail de médias accessibles. + +Vous pouvez en savoir plus sur l'organisation Creative Commons sur [creativecommons.org](https://creativecommons.org/). + +## [Lenses](/fr/docs/concepts/lenses/) + +Un Lens est une instance individuelle de Flagship qui agit à la fois comme bibliothèque et comme passerelle vers le réseau plus large. Chaque Lens peut : + +- Héberger sa propre collection de contenu +- Miroiter du contenu provenant d'autres Lenses +- Participer au réseau fédéré +- Fonctionner de manière indépendante si nécessaire + +Lisez la page [Lenses](/fr/docs/concepts/lenses/) pour en savoir plus et apprendre à créer le vôtre. + +## [Fédération décentralisée (Defederation)](/fr/docs/concepts/defederation/) + +Contrairement aux plateformes centralisées traditionnelles, Flagship utilise un modèle de fédération dans lequel : + +- Il n'existe pas de point de défaillance unique +- Le contenu est réparti sur plusieurs nœuds +- Chaque Lens conserve son autonomie tout en partageant des ressources +- Le réseau devient plus fort à chaque nouveau participant + +Nous appelons cela la Defederation, car les Lenses doivent explicitement choisir de se fédérer entre eux. Vous pouvez en lire davantage sur la page [Defederation](/fr/docs/concepts/defederation/). diff --git a/content/docs/concepts/defederation.fr.md b/content/docs/concepts/defederation.fr.md new file mode 100644 index 0000000..1acb276 --- /dev/null +++ b/content/docs/concepts/defederation.fr.md @@ -0,0 +1,25 @@ ++++ +draft = false +title = 'Defederation' +weight = 1 ++++ + +La Defederation, ou fédération décentralisée, est notre système de gestion des réseaux décentralisés de contenu et de communautés. + +Elle permet aux Lenses de se suivre mutuellement et de répliquer instantanément tout le contenu des Lenses suivis. + +## Exemples +Le site D peut construire sa bibliothèque en suivant le site B, et donc le site C par extension. Le site D peut aussi avoir son propre contenu. + +Schéma montrant l'architecture de Flagship +Schéma montrant l'architecture de Flagship + +Dans cet exemple, le site D aurait 9 éléments de contenu, tous présentés dans une expérience unifiée, comme s'ils faisaient partie d'une seule et même bibliothèque. + +## Détails techniques + +Peerbit est utilisé pour synchroniser et fédérer les Lenses, et constitue la technologie centrale qui rend cela possible. + +Notre Lens SDK étend Peerbit pour fournir cette fonctionnalité. + +Chaque Lens reçoit son propre identifiant de site, utilisé à la fois pour l'identifier sur le réseau et pour permettre aux autres Lenses de le suivre. diff --git a/content/docs/concepts/lenses.fr.md b/content/docs/concepts/lenses.fr.md new file mode 100644 index 0000000..9f36712 --- /dev/null +++ b/content/docs/concepts/lenses.fr.md @@ -0,0 +1,39 @@ ++++ +draft = false +title = 'Lenses' +weight = 2 ++++ + +Un Lens est une instance individuelle de Flagship qui agit à la fois comme bibliothèque et comme passerelle vers le réseau plus large. Chaque Lens peut : + +- Héberger son propre contenu +- Suivre d'autres Lenses +- Être suivi par d'autres Lenses + +Voici comment cela fonctionne. + +## Créer un Lens +Créer votre propre Lens est simple. Cela consiste à télécharger et configurer le logiciel Flagship. + +Nous proposons également une configuration Docker pour démarrer rapidement. + +Consultez la page [Créer un Lens](/fr/docs/flagship/create-lens/) pour les instructions détaillées. + +Une fois votre Lens créé, vous pouvez donner à d'autres personnes votre Site ID afin qu'elles le suivent. + +## Suivre des Lenses +Vous pouvez également faire en sorte que votre Lens suive d'autres Lenses. + +Copiez simplement le Site ID du Lens que vous souhaitez suivre, puis allez dans la section *Admin* de votre Lens, puis *Subscriptions*. + +Collez le Site ID du Lens à suivre, puis cliquez sur *Subscribe*. + +![Ajout d'un abonnement](/images/docs/concepts/follow-a-lens.png) + +Après l'avoir ajouté, vous le verrez apparaître dans la liste des abonnements. + +Une fois l'abonnement ajouté, le contenu du Lens suivi apparaîtra dans votre Lens. + +![Ajout d'un abonnement](/images/docs/concepts/follow-a-lens-2.png) + +Pour cesser de suivre un Lens, cliquez simplement sur l'icône de corbeille à côté du Lens concerné. diff --git a/content/docs/concepts/threshold-funding.fr.md b/content/docs/concepts/threshold-funding.fr.md new file mode 100644 index 0000000..864dfc7 --- /dev/null +++ b/content/docs/concepts/threshold-funding.fr.md @@ -0,0 +1,52 @@ ++++ +draft = false +title = 'Threshold Funding' ++++ + +Imaginez ceci : un groupe veut enregistrer un disque. Il lui faut 50 000 $ pour le studio, le mixage, le mastering et la production. Les options classiques ? Céder ses droits à un label, lancer une campagne de financement participatif en espérant que cela fonctionne, ou s'endetter. + +Le threshold funding propose une alternative, permettant aux utilisateurs de soutenir directement les artistes tout en recevant des récompenses. + +## Comment cela fonctionne + +Le groupe publie son projet comme "à venir" sur Riff, en partageant des démos, des enregistrements live et sa vision de l'album. Les fans peuvent s'abonner à l'artiste pour 10 $ par an. Voici ce qui devient intéressant : + +- Quand suffisamment de personnes s'abonnent pour atteindre le seuil de 50 000 $, la production commence +- Tous ceux qui se sont abonnés pendant la période de financement reçoivent automatiquement l'album en haute qualité à sa sortie +- Le groupe conserve le contrôle créatif complet et la propriété de son œuvre + +## La dimension des communs + +Mais voici la partie révolutionnaire : le groupe s'engage à publier automatiquement le disque sous licence Creative Commons (non commerciale) une fois qu'il en a tiré 250 000 $. + +Cela signifie : +- Le groupe continue à vendre sur Riff après le seuil +- Une fois le total de 250 000 $ atteint, l'album devient légalement libre pour un usage non commercial +- La musique entre dans les communs et enrichit notre culture partagée +- Le groupe est justement rémunéré pour son travail et peut continuer à vendre des copies physiques et collector, tout en finançant ses projets futurs de la même manière + +## Contributions à la plateforme + +Les artistes comme les fans peuvent choisir de soutenir la plateforme via un curseur de contribution dans leurs paramètres. + +Cette contribution est **optionnelle** et **explicitement volontaire**. Par défaut, nous prélevons 0 % des revenus. + +**Modèle de contribution des artistes :** +- Si 100 artistes lèvent chacun 50 000 $ par an : 50 M$ de financement artiste +- Si 5 % des artistes activent une contribution plateforme de 5 % : 125 000 $ de revenus plateforme +- Cela pourrait soutenir durablement une communauté d'environ 1 à 2 millions d'utilisateurs + +**Modèle de contribution des utilisateurs :** +- 1 M d'utilisateurs × 50 $ de dépense annuelle moyenne × 5 % de part plateforme × 5 % de participation = 125 000 $ de revenus plateforme supplémentaires +- Combinée aux contributions des artistes, la plateforme devient pleinement soutenable avec des taux de participation modestes + +## Pourquoi cela fonctionne + +1. **Les artistes gagnent** : financement direct, contrôle créatif, rémunération équitable +2. **Les fans gagnent** : soutien direct aux artistes, accès anticipé exclusif +3. **La culture gagne** : davantage de musique rejoint les communs au fil du temps +4. **La plateforme gagne** : revenus durables sans exploitation des créateurs + +Il ne s'agit pas seulement de financer des albums. Il s'agit de construire une économie où le travail créatif est valorisé, où les artistes sont rémunérés équitablement et où la culture finit par être partagée. + +Le modèle de threshold funding transforme le système traditionnel du "tous droits réservés" en "tous droits réservés, puis certains droits réservés", garantissant à la fois une rémunération juste et un enrichissement culturel. diff --git a/content/docs/flagship/_index.fr.md b/content/docs/flagship/_index.fr.md new file mode 100644 index 0000000..bede69b --- /dev/null +++ b/content/docs/flagship/_index.fr.md @@ -0,0 +1,30 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Flagship' +weight = 5 ++++ + +Flagship est notre plateforme de bibliotheque decentralisee qui permet aux communautes de construire et de maintenir leurs propres bibliotheques numeriques impossibles a arreter. + +Il s'agit d'une implementation de preuve de concept d'une plateforme media decentralisee pour regarder, partager, distribuer et organiser du contenu multimedia legalement libre. + +Construite comme une application Electron avec des capacites de deploiement web, elle combine l'experience utilisateur de plateformes centralisees comme Netflix et YouTube avec l'architecture decentralisee des reseaux pair a pair. + +Le logiciel permet aux utilisateurs de : + +* Televerser et partager du contenu multimedia (audio, video, livres et plus encore) +* Decouvrir du contenu grace a des systemes de categorisation et de mise en avant +* Participer a un reseau federatif de noeuds de partage de contenu +* Auto-heberger des instances tout en restant connectes au reseau plus large + +## Vue d'ensemble de l'architecture du systeme + +Flagship met en oeuvre une architecture hybride qui peut fonctionner a la fois comme application Electron de bureau et comme application web, construite sur une base de technologies reseau pair a pair. + +Un diagramme montrant l'architecture de Flagship +Un diagramme montrant l'architecture de Flagship + +## Credits : +* Contributeurs de Riff.CC, passes et presents. +* Certaines informations ont ete generees par DeepWiki (voir [https://deepwiki.com/riffcc/flagship](https://deepwiki.com/riffcc/flagship)). Merci a Cognition pour cet excellent service. diff --git a/content/docs/flagship/create-lens.fr.md b/content/docs/flagship/create-lens.fr.md new file mode 100644 index 0000000..b14122a --- /dev/null +++ b/content/docs/flagship/create-lens.fr.md @@ -0,0 +1,323 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Creer une Lens (Demarrage rapide)' +weight = 2 ++++ + +Pour creer votre propre Lens, vous aurez besoin d'un nom de domaine (un sous-domaine peut aussi convenir) et d'un fournisseur d'hebergement. + +Le processus est simple et prend environ 10 a 30 minutes selon votre aisance avec la ligne de commande. + +{{< callout type="info"emoji="🌐" >}} + Nous prevoyons de proposer plus tard des services d'hebergement Lens abordables. + + Nous publierons egalement en open source les logiciels permettant a n'importe qui d'exploiter son propre fournisseur d'hebergement Lens. +{{< /callout >}} + +Nous suggerons d'utiliser Hetzner ou DigitalOcean, mais presque n'importe quel fournisseur conviendra. + +Vous pouvez aussi auto-heberger votre propre Lens, mais vous devrez etre a l'aise avec la ligne de commande et comprendre les bases de la configuration d'un serveur. + +## Configurer votre domaine + +Faites pointer votre nom de domaine ou votre sous-domaine vers l'adresse IP de votre serveur au moyen d'un enregistrement DNS `A` ou `AAAA`. + +Vous pouvez demander a votre hebergeur comment proceder, ou nous demander de l'aide. + +## Preparation + +Vous devrez effectuer un petit travail preparatoire avant de commencer. + +### Dependances +Avant d'installer Flagship, vous devez installer les dependances suivantes : + +```sh +sudo apt install libnss3-dev libgtk-3-0 libgbm1 libasound2-dev libatk1.0-0 node-pre-gyp git curl +``` + +### Node.js + +Vous devrez egalement installer Node.js. + +Nous vous recommandons le [guide d'installation NodeSource](https://github.com/nodesource/distributions#installation-instructions). + +1. Telechargez et importez la cle GPG de NodeSource + +```sh +sudo apt-get update +sudo apt-get install -y ca-certificates curl gnupg +sudo mkdir -p /etc/apt/keyrings +curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg +``` + +2. Creez le depot Debian + +```sh +echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_22.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list +``` + +3. Lancez `apt update` puis installez le paquet Node.js + +```sh +sudo apt-get update +sudo apt-get install nodejs -y +``` + +4. Telechargez le script officiel d'installation de pnpm : + +```sh +curl -fsSL https://get.pnpm.io/install.sh | sh - +``` + +5. Rechargez votre fichier `.bashrc` pour que le systeme reconnaisse correctement le chemin de pnpm (ou `zshrc` pour les utilisateurs de Zsh, etc.) : + +```sh +source ~/.bashrc +``` + +### Git + +Vous devrez installer Git. La plupart des systemes l'ont deja, sinon vous pouvez l'installer avec : + +```sh +sudo apt-get install git -y +``` + +## Installer le noeud Lens + +Utilisez `pnpm` pour installer le noeud Lens. + +```sh +pnpm install -g @riffcc/lens-node +``` + +Si vous y etes invite, lancez aussi `pnpm approve-builds -g` pour permettre la compilation correcte des dependances. + +``` +wings@blackberry:~$ pnpm approve-builds -g +✔ Choose which packages to build (Press to select, to toggle all, to invert selection) · @ipshipyard/node-datachannel, better-sqlite3, classic-level +✔ The next packages will now be built: @ipshipyard/node-datachannel, better-sqlite3, classic-level. +Do you approve? (y/N) · true +.pnpm/@ipshipyard+node-datachannel@0.26.6/node_modules/@ipshipyard/node-datachannel: Running install script, done in 98ms +.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3: Running install script, done in 71ms +.pnpm/classic-level@3.0.0/node_modules/classic-level: Running install script, done in 46ms +``` + +## Configurer votre Lens + +1. **Configurez votre noeud Lens :** + La premiere etape consiste a initialiser votre noeud. Cela cree un repertoire de donnees, genere les identites cryptographiques necessaires et cree un fichier de configuration. + + ```bash + lens-node setup + ``` + + Cette commande : + - cree un repertoire dans `~/.lens-node` (ou un chemin personnalise avec `--dir`) ; + - si le repertoire existe deja, vous demandera de confirmer la reconfiguration ; + - initialise un client Peerbit et un site Lens ; + - enregistre la configuration, y compris l'adresse du site Lens, dans `config.json` du repertoire de donnees ; + - affiche des informations importantes telles que votre Peer ID, votre cle publique et l'adresse du site. + + {{< callout emoji="🐉" >}} + Vous pouvez voir un avertissement au sujet de "The node directory \"/home/$USER/.lens-node\" already exists" meme si vous n'avez jamais cree de Lens auparavant. + + C'est un bug du noeud Lens ; il peut etre ignore sans risque lors de la *premiere* creation d'une Lens. Il sera corrige dans une future version. + + Repondez simplement "Yes" a l'invite pour poursuivre. + {{< /callout >}} + + Voici un exemple de sortie : + + ``` + wings@blackberry:~$ lens-node setup + ✔ The node directory "/home/wings/.lens-node" already exists. Do you want to reconfigure for setup? This action is irreversible. Yes + Node directory cleared and ready for new configuration at: /home/wings/.lens-node + [Site] Access controllers open: 334.832ms + [Site] Data stores open: 114.121ms + [Site] Total open time: 449.201ms + + Lens Node setup complete! + -------------------------------------------------- + Node Directory: /home/wings/.lens-node + Configuration saved to: /home/wings/.lens-node/config.json + Peer ID: 12D3KooWAo2AC2Aga6gxon6Fd8jXMoxRtBkQrBBK3hsuQs3wtnNT + Node Public Key: ed25119p/0e837b3358453b3384ba0a86701e440e79b009fba4f010b0a944f054df21b8c8 + Site Address: zb2rhjCvmPfrgmgjGvnsYLQpzwbLGgvDWs2AsJp5qN4Zxwt7Z + -------------------------------------------------- + You can now run your node using: lens-node run + ``` + + Conservez l'adresse du site, car vous en aurez besoin plus tard. Vous pourrez toujours la retrouver dans `~/.lens-node/config.json` si besoin. + +2. **Demarrez votre noeud Lens :** + Pour lancer votre noeud, executez : + + ```bash + lens-node run + ``` + + Cela demarre le demon du noeud, se connecte au reseau Peerbit et ouvre votre site Lens. Un terminal interactif s'ouvrira et vous pourrez l'utiliser pour gerer votre noeud. + + Nous conseillons d'executer le noeud dans une session `screen` ou `tmux`, afin qu'il continue a tourner en arriere-plan si vous fermez le terminal. + + Copiez l'adresse d'ecoute `ws` pour l'utiliser plus tard, par exemple `/ip4/127.0.0.1/tcp/8002/ws/p2p/12D3KooWAo2AC2Aga6gxon6Fd8jXMoxRtBkQrBBK3hsuQs3wtnNT`. + +## Installer Flagship + +1. Clonez le depot GitHub de Flagship : + ```sh + git clone https://github.com/riffcc/flagship.git + ``` + +2. Placez-vous dans le repertoire de Flagship et installez les dependances : + ```sh + cd flagship + pnpm install + ``` + +3. Copiez le fichier `.env.example` vers `.env` : + ```sh + cp .env.example .env + ``` + +4. Modifiez le fichier `.env` afin de definir `VITE_SITE_ADDRESS` avec l'adresse du site que vous avez conservee plus tot. Definissez `VITE_BOOTSTRAPPERS` avec l'adresse d'ecoute `ws` copiee plus tot. + +5. Lancez l'application en mode developpement (avec rechargement a chaud) : + ```sh + pnpm watch:web + ``` + +6. Ouvrez l'application dans votre navigateur a l'adresse `http://localhost:5175/#/account`. + +7. Vous devriez maintenant voir l'application Flagship. + + ![Application Flagship](/images/docs/flagship/installing-flagship-account.png) + + {{< callout emoji="🐉" >}} + Vous pouvez ignorer sans risque l'avertissement "Not implemented" en bas de la page. + {{< /callout >}} + +8. Cliquez sur la cle publique sous le titre "Public Key" pour la copier dans votre presse-papiers. + +## Creer un compte administrateur + +Sur le serveur qui heberge votre Lens, ouvrez l'action ` > Authorise an account`. + +``` +Lens Node is running. Press Ctrl+C to stop OR use the menu below. +-------------------------------------------------- +Node Directory: /home/wings/.lens-node +Peer ID: 12D3KooWAo2AC2Aga6gxon6Fd8jXMoxRtBkQrBBK3hsuQs3wtnNT +Node Public Key: ed25119p/0e837b3358453b3384ba0a86701e440e79b009fba4f010b0a944f054df21b8c8 +Site Address: zb2rhjCvmPfrgmgjGvnsYLQpzwbLGgvDWs2AsJp5qN4Zxwt7Z +Listening on: [ + "/ip4/127.0.0.1/tcp/8002/ws/p2p/12D3KooWAo2AC2Aga6gxon6Fd8jXMoxRtBkQrBBK3hsuQs3wtnNT", + "/ip4/127.0.0.1/tcp/8001/p2p/12D3KooWAo2AC2Aga6gxon6Fd8jXMoxRtBkQrBBK3hsuQs3wtnNT" +] +-------------------------------------------------- +? Actions: (Use arrow keys) +❯ Authorise an account + ────────────── + Manage Subscriptions + ────────────── + Shutdown Node +``` + +Appuyez sur Entree, puis collez la cle publique copiee plus tot : + +``` +✔ Actions: Authorise an account +✔ Enter the string public key of the account: ed25119p/1a1b2a241f1734f6088fa4715bc763f448dbbf0d1ab8c100a959dec765ba5a58 +? Select the account type (Use arrow keys) +❯ Member + Admin +``` + +Selectionnez "Admin" avec les fleches, puis appuyez sur Entree. + +Vous devriez voir un message de succes : +``` +2025-07-15 23:13:41.822 [info] Account authorized successfully +{ + "publicKey": "ed25119p/1a1b2a241f1734f6088fa4715bc763f448dbbf0d1ab8c100a959dec765ba5a58", + "accountType": "Admin" +} +``` + +Rafraichissez l'application Flagship dans votre navigateur. Vous devriez maintenant etre "Admin" et voir l'onglet "Admin". + +## Gerer votre Lens +### Ajouter du contenu a votre Lens + +Il est temps de televerser votre premier contenu. Comme exemple, nous allons televerser le film **RiP: A Remix Manifesto**, un documentaire legalement libre sur la culture du remix. + +1. Cliquez sur le bouton "Upload" dans le menu du haut. +2. Saisissez un nom, par exemple "RiP: A Remix Manifesto". +3. Saisissez un CID de contenu, ici `QmTWWUmvC9txvE7aHs9xHd541qLx3ax58urvx3Kb3SFK2Q`. +4. Selectionnez la categorie "Movies". +5. Definissez le CID de miniature sur `Qmb3eeESRoX5L6NhTYLEtFFUS1FZgqe1e7hdBk2f57DUGh`. +6. Cliquez sur le bouton "Upload". + +Vous devriez maintenant voir le film dans votre Lens si vous allez dans l'onglet "Movies". + +### Mettre du contenu en avant + +Vous pouvez mettre du contenu en avant pour le faire apparaitre sur la page d'accueil de votre Lens. + +1. Cliquez sur l'onglet "Admin" dans le menu du haut. +2. Cliquez sur l'onglet "Content" dans le menu lateral du panneau d'administration. +3. Cliquez sur le bouton "Feature" a cote du film que vous avez televerse (l'etoile avec un signe plus). + +Vous serez redirige vers la page *New Featured Releases*. + +Le curseur "Promoted" sera regle sur "Yes" par defaut. Le contenu promu apparaitra dans le carrousel hero de la page d'accueil, tandis qu'un contenu seulement mis en avant apparaitra lui aussi en page d'accueil mais avec moins d'emphase. + +4. Cliquez sur le bouton "Create" pour creer la mise en avant. + +Vous devriez maintenant voir le film sur la page d'accueil de votre Lens ! + +![Page d'accueil d'une Lens](/images/docs/flagship/frontpage-generic.png) + +### Ajouter des details a une sortie mise en avant + +{{< callout emoji="🚧" >}} +Cette section est en cours de construction. +{{< /callout >}} + +Vous pouvez ajouter plus de details a la sortie mise en avant en cliquant sur le bouton "Edit" a cote de cette mise en avant, puis sur l'onglet "Advanced". + +Cela vous permettra d'ajouter une description, des etiquettes et d'autres details a la sortie mise en avant. + +Vous pouvez egalement ajouter une image de banniere qui sera affichee a la place de la miniature lorsque la sortie est promue dans le carrousel hero. + +## Etapes suivantes + +### Rejoindre notre communaute + +Nous avons un serveur Discord ou vous pouvez poser des questions, partager votre Lens et obtenir de l'aide de la communaute. + +[Rejoindre notre serveur Discord](https://discord.gg/cvYgQSfCrQ) + +### Suivre une Lens (facultatif) + +L'un des meilleurs aspects du fait d'exploiter une Lens est la possibilite de suivre d'autres Lenses et de voir leur contenu. + +Copiez simplement l'identifiant du site de la Lens que vous souhaitez suivre, puis allez dans la section *Admin* de votre Lens, ensuite dans *Subscriptions*. + +Collez l'identifiant du site de la Lens que vous souhaitez suivre et cliquez sur *Subscribe*. + +{{< callout type="info" emoji="ℹ️" >}} +L'identifiant du site de la Lens actuelle de Riff.CC est `zb2rhoGguxQaNZy47DvRPLRmpT84mwvwuvekUhmCgF7nkhTCn`, si vous voulez quelque chose a suivre. +{{< /callout >}} + +![Ajouter un abonnement](/images/docs/concepts/follow-a-lens.png) + +Apres l'avoir ajoute, vous le verrez apparaitre dans la liste des abonnements. + +Une fois l'abonnement ajoute, le contenu de la Lens suivie apparaitra dans votre Lens. + +![Ajouter un abonnement](/images/docs/concepts/follow-a-lens-2.png) + +Pour ne plus suivre une Lens, cliquez simplement sur l'icone de corbeille a cote de la Lens que vous souhaitez retirer. diff --git a/content/docs/flagship/introduction.fr.md b/content/docs/flagship/introduction.fr.md new file mode 100644 index 0000000..25fccbc --- /dev/null +++ b/content/docs/flagship/introduction.fr.md @@ -0,0 +1,16 @@ ++++ +title = 'Introduction' +weight = 1 ++++ + +Flagship est l'implementation de reference d'une bibliotheque impossible a arreter : une plateforme decentralisee pour partager et preserver du contenu numerique qui ne peut ni etre censure ni etre mis hors service. + +Comme chaque Lens peut etre repliquee ou mise en miroir par n'importe quel nombre d'autres Lenses, Flagship offre une maniere auto-reparatrice et resistante a la censure de publier et partager. La perte d'une Lens individuelle n'affecte pas la disponibilite du contenu qu'elle contient, tant que d'autres communautes en conservent des copies. + +Il fournit une interface web (et plus tard des applications Electron pour ordinateur et mobile) pour creer, gerer et partager votre propre Lens, une instance de Flagship capable de mettre en miroir du contenu provenant d'autres Lenses et de participer au reseau de federation decentralise. + +## Pour commencer + +Pret a creer votre propre bibliotheque impossible a arreter ? Consultez : + +- [Creer une Lens](/fr/docs/flagship/create-lens) - Guide de demarrage rapide pour lancer votre premiere Lens diff --git a/content/docs/flagship/production-setup.fr.md b/content/docs/flagship/production-setup.fr.md new file mode 100644 index 0000000..9c75fda --- /dev/null +++ b/content/docs/flagship/production-setup.fr.md @@ -0,0 +1,364 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Configuration de production' +weight = 3 ++++ + +### **Production : deploiement d'une instance Flagship avec un noeud Lens** + +Ce guide vous accompagne dans le deploiement d'une instance Flagship prete pour la production, y compris la mise en place d'un serveur, la configuration DNS, la securisation avec SSL et l'execution du noeud Lens dans une session de terminal persistante. + +### **Prerequis** + +* Une instance de serveur (par exemple AWS EC2 ou DigitalOcean Droplet) executant une distribution Linux recente comme Ubuntu 22.04. + * **Specifications recommandees :** 2 coeurs CPU ou plus, 4 Go de RAM ou plus. +* Un nom de domaine enregistre (par exemple `your-domain.com`). +* Un acces au panneau de gestion DNS de votre domaine. +* Les logiciels suivants installes sur votre serveur : + * [Node.js](https://nodejs.org/) + * [pnpm](https://pnpm.io/installation) + * [Git](https://git-scm.com/downloads) + * [Nginx](https://www.nginx.com/) + * [Screen](https://www.gnu.org/software/screen/) (`sudo apt install screen`) + +--- + +### **Partie 1 : configuration du serveur et du domaine** + +Cette section couvre la configuration initiale de votre serveur, du DNS et des certificats SSL. + +#### **Etape 1 : faire pointer votre domaine vers le serveur** + +Dans le panneau de controle de votre fournisseur DNS, creez deux enregistrements `A` pointant vers l'adresse IP publique de votre serveur : + +1. Un enregistrement `A` pour votre domaine principal : + * **Type :** `A` + * **Nom/Hote :** `@` (ou `your-domain.com`) + * **Valeur/Pointe vers :** `your-server-ip` + +2. Un enregistrement `A` pour le sous-domaine du noeud Lens : + * **Type :** `A` + * **Nom/Hote :** `lens` + * **Valeur/Pointe vers :** `your-server-ip` + +> **Remarque :** la propagation des changements DNS peut prendre un peu de temps. + +#### **Etape 2 : installer Nginx et obtenir des certificats SSL** + +1. **Installez Nginx et Certbot :** + ```bash + sudo apt update + sudo apt install nginx certbot python3-certbot-nginx + ``` + +2. **Obtenez les certificats SSL.** Nous utiliserons Certbot pour obtenir des certificats pour vos deux domaines. Cette commande arretera temporairement Nginx afin de liberer le port 80 pour la validation. + ```bash + sudo systemctl stop nginx + sudo certbot certonly --standalone -d your-domain.com -d lens.your-domain.com + ``` + Suivez les invites pour terminer le processus. Une fois termine, Certbot aura cree vos fichiers de certificat. + +#### **Etape 3 : configurer Nginx** + +Nous allons maintenant creer les fichiers de configuration Nginx pour servir votre site Flagship et proxyfier les requetes vers le noeud Lens. + +1. **Creez la configuration Nginx pour votre site principal Flagship :** + ```bash + sudo nano /etc/nginx/sites-available/your-domain.com + ``` + Collez ce qui suit en remplacant `your-domain.com` par votre domaine reel : + ```nginx + server { + listen 80; + server_name your-domain.com; + # Redirect all HTTP requests to HTTPS + return 301 https://$host$request_uri; + } + + server { + listen 443 ssl; + server_name your-domain.com; + + root /var/www/your-domain.com/html; + index index.html; + + # SSL configuration + ssl_certificate /etc/letsencrypt/live/your-domain.com/fullchain.pem; + ssl_certificate_key /etc/letsencrypt/live/your-domain.com/privkey.pem; + include /etc/letsencrypt/options-ssl-nginx.conf; + ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; + + location / { + try_files $uri $uri/ /index.html; + } + } + ``` + +2. **Creez le repertoire racine web du site Flagship :** + ```bash + sudo mkdir -p /var/www/your-domain.com/html + ``` + +3. **Creez la configuration Nginx pour le sous-domaine du noeud Lens :** + ```bash + sudo nano /etc/nginx/sites-available/lens.your-domain.com + ``` + Collez dans le fichier l'integralite du bloc de configuration ci-dessous. + + > **IMPORTANT :** vous devez remplacer chaque occurrence de **`$YOUR_SUBDOMAIN`** par votre sous-domaine reel (par exemple `lens.your-domain.com`). + + ```nginx + server_names_hash_bucket_size 128; + + server { + server_name $YOUR_SUBDOMAIN; + listen [::]:4002 ssl ipv6only=on; + listen 4002 ssl; + + # Load the certificate files. + ssl_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/fullchain.pem; + ssl_certificate_key /etc/letsencrypt/live/$YOUR_SUBDOMAIN/privkey.pem; + ssl_trusted_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/chain.pem; + + # Load the Diffie-Hellman parameter. + ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; + + location / { + proxy_pass http://127.0.0.1:8001; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + } + } + + server { + server_name $YOUR_SUBDOMAIN; + listen [::]:4003 ssl ipv6only=on; + listen 4003 ssl; + + # Load the certificate files. + ssl_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/fullchain.pem; + ssl_certificate_key /etc/letsencrypt/live/$YOUR_SUBDOMAIN/privkey.pem; + ssl_trusted_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/chain.pem; + + # Load the Diffie-Hellman parameter. + ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; + + location / { + proxy_pass http://127.0.0.1:8002; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + } + } + + server { + server_name $YOUR_SUBDOMAIN; + listen [::]:4004 ssl ipv6only=on; + listen 4004 ssl; + + # Load the certificate files. + ssl_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/fullchain.pem; + ssl_certificate_key /etc/letsencrypt/live/$YOUR_SUBDOMAIN/privkey.pem; + ssl_trusted_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/chain.pem; + + # Load the Diffie-Hellman parameter. + ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; + + location / { + proxy_pass http://127.0.0.1:8083; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + } + } + + server { + server_name $YOUR_SUBDOMAIN; + listen [::]:4005 ssl ipv6only=on; + listen 4005 ssl; + + # Load the certificate files. + ssl_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/fullchain.pem; + ssl_certificate_key /etc/letsencrypt/live/$YOUR_SUBDOMAIN/privkey.pem; + ssl_trusted_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/chain.pem; + + # Load the Diffie-Hellman parameter. + ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; + + location / { + proxy_pass http://127.0.0.1:8084; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + } + } + + server { + server_name $YOUR_SUBDOMAIN; # managed by Certbot + + root /usr/share/nginx/html; + index index.html index.htm; + + location / { + try_files $uri $uri/ =404; + } + + listen [::]:443 ssl; # managed by Certbot + listen 443 ssl; # managed by Certbot + + # Load the certificate files. + ssl_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/fullchain.pem; + ssl_certificate_key /etc/letsencrypt/live/$YOUR_SUBDOMAIN/privkey.pem; + ssl_trusted_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/chain.pem; + + # Load the Diffie-Hellman parameter. + ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; + } + server { + server_name $YOUR_SUBDOMAIN; + listen [::]:9002 ssl ipv6only=on; + listen 9002 ssl; + + # Load the certificate files. + ssl_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/fullchain.pem; + ssl_certificate_key /etc/letsencrypt/live/$YOUR_SUBDOMAIN/privkey.pem; + ssl_trusted_certificate /etc/letsencrypt/live/$YOUR_SUBDOMAIN/chain.pem; + + # Load the Diffie-Hellman parameter. + ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; + + location / { + proxy_pass http://127.0.0.1:8082; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + } + } + + server { + listen 80; + listen [::]:80 ; + server_name $YOUR_SUBDOMAIN; + + # Anything requesting this particular URL should be served content from + # Certbot's folder so the HTTP-01 ACME challenges can be completed for the + # HTTPS certificates. + location '/.well-known/acme-challenge' { + default_type "text/plain"; + root /var/www/letsencrypt; + } + + if ($host = $YOUR_SUBDOMAIN) { + return 301 https://$host$request_uri; + } # managed by Certbot + + return 404; # managed by Certbot + } + ``` + +4. **Activez les deux sites en creant des liens symboliques :** + ```bash + sudo ln -s /etc/nginx/sites-available/your-domain.com /etc/nginx/sites-enabled/ + sudo ln -s /etc/nginx/sites-available/lens.your-domain.com /etc/nginx/sites-enabled/ + ``` + +5. **Testez votre configuration Nginx puis redemarrez le service :** + ```bash + sudo nginx -t + sudo systemctl restart nginx + ``` + +--- + +### **Partie 2 : configurer et executer le noeud Lens** + +Nous utiliserons `screen` pour executer le processus du noeud Lens en arriere-plan, afin qu'il continue de tourner meme apres votre deconnexion SSH. + +1. **Installez globalement le noeud Lens :** + ```bash + pnpm install -g @riffcc/lens-node + ``` + +2. **Lancez la configuration initiale :** + ```bash + lens-node setup + ``` + +3. **Demarrez une nouvelle session `screen` :** + ```bash + screen -S lens-node + ``` + Votre terminal sera efface et vous serez alors dans une nouvelle session virtuelle nommee `lens-node`. + +4. **Demarrez le noeud dans la session screen.** Remplacez `lens.your-domain.com` par votre vrai sous-domaine. + ```bash + lens-node run --domain lens.your-domain.com --relay + ``` + +5. Une fois le noeud demarre, vous verrez une sortie semblable a celle-ci. **Notez bien votre `Site Address` ainsi que l'adresse `Listening on` contenant `/wss`**. + + ```bash + Node Directory: /root/.lens-node + Peer ID: 12D3KooWFzrhasG7pouxZSsSP3bHP45C3TCq2MYirTPC5oA9Lj2v + Site Address: zb2rhoGguxQaNZy47DvRPLRmpT84mwvwuvekUhmCgF7nkhTCn + Listening on: [ + "/dns4/lens.your-domain.com/tcp/4002/p2p/12D3KooWFzrhasG7pouxZSsSP3bHP45C3TCq2MYirTPC5oA9Lj2v", + "/dns4/lens.your-domain.com/tcp/4003/wss/p2p/12D3KooWFzrhasG7pouxZSsSP3bHP45C3TCq2MYirTPC5oA9Lj2v" + ] + ``` + +6. **Detachez-vous de la session screen** en laissant le noeud tourner. Appuyez sur **`Ctrl+A`**, puis sur **`D`**. + +Vous avez maintenant un noeud Lens qui fonctionne en arriere-plan. + +> **Pour gerer le noeud :** +> * **Reattachez-vous a la session** pour voir les journaux ou arreter le processus : `screen -r lens-node` +> * **Pour arreter le noeud**, reattachez-vous et appuyez sur `Ctrl+C`. +> * **Avertissement :** cette methode ne survit pas a un redemarrage du serveur. Vous devrez relancer manuellement le noeud dans une nouvelle session screen si le serveur redemarre. + +--- + +### **Partie 3 : deployer l'instance Flagship** + +Enfin, configurez, construisez et deployez l'application frontend Flagship. + +1. **Clonez le depot et entrez dans le repertoire :** + ```bash + git clone https://github.com/riffcc/flagship + cd flagship + ``` + +2. **Creez le fichier d'environnement :** + ```bash + cp .env.example .env + ``` + +3. **Configurez les variables d'environnement.** Ouvrez le fichier `.env` et definissez les variables suivantes en utilisant les valeurs de votre noeud Lens actif : + + ```dotenv + # Paste the "Site Address" from your node's output here + VITE_SITE_ADDRESS=zb2rhoGguxQaNZy47DvRPLRmpT84mwvwuvekUhmCgF7nkhTCn + + # Paste the secure "/wss" listening address here + VITE_BOOTSTRAPPERS=/dns4/lens.your-domain.com/tcp/4003/wss/p2p/12D3KooWFzrhasG7pouxZSsSP3bHP45C3TCq2MYirTPC5oA9Lj2v + ``` + +4. **Installez les dependances et construisez l'application :** + ```bash + pnpm install + pnpm compile:web + ``` + +5. **Deployez les fichiers construits dans la racine web de Nginx.** + ```bash + sudo cp -r packages/renderer/dist/web/* /var/www/your-domain.com/html/ + ``` + +6. **Attribuez les bons droits de propriete aux fichiers web :** + ```bash + sudo chown -R www-data:www-data /var/www/your-domain.com/html + ``` + +Votre instance Flagship est maintenant en ligne. Vous pouvez y acceder en allant sur `https://your-domain.com` dans votre navigateur. diff --git a/content/docs/lens-sdk/_index.fr.md b/content/docs/lens-sdk/_index.fr.md new file mode 100644 index 0000000..a6bd920 --- /dev/null +++ b/content/docs/lens-sdk/_index.fr.md @@ -0,0 +1,57 @@ +--- +date: '2025-07-22T04:50:31+02:00' +draft: false +title: 'SDK Lens' +sidebar: + open: true +--- + +## Vue d'ensemble + +Le SDK Lens est un kit de developpement logiciel complet, robuste et adapte aux usages d'entreprise, concu pour construire des reseaux sophistiques de federation et de distribution de contenu decentralises. En s'appuyant sur la puissance du cadre P2P Peerbit, le SDK Lens fournit une architecture complete en couches pour creer des applications de contenu souveraines, interoperables et resilientes. + +Ce SDK s'adresse aux developpeurs et aux organisations qui veulent creer des applications ou l'integrite des donnees, la propriete par les utilisateurs et la collaboration decentralisee sont essentielles. Il abstrait la complexite du reseautage pair a pair, de la synchronisation de base de donnees et de l'identite cryptographique, en offrant une API claire et de haut niveau pour un developpement rapide et securise. + +## Philosophie centrale + +La conception du SDK Lens repose sur plusieurs principes fondamentaux : + +1. **Souverainete des donnees :** les utilisateurs et les communautes gardent le controle ultime de leurs donnees et de leurs espaces numeriques. Chaque instance du programme `Site` est une entite souveraine, gouvernee par ses propres regles et administrateurs. + +2. **Federation structuree :** la communication inter-applications n'est pas arbitraire. Il s'agit d'un processus structure et autorise, fonde sur des "subscriptions" explicites. Ce modele garantit que le partage de donnees est intentionnel et securise, empeche l'injection de donnees non sollicitee et cree un reseau fonde sur la confiance. + +3. **Architecture modulaire et en couches :** le SDK impose une separation stricte des responsabilites, de la logique P2P bas niveau jusqu'a l'API de service haut niveau. Cette architecture en couches renforce la securite, simplifie la maintenance et favorise des pratiques de developpement evolutives. + +4. **Provenance verifiable :** toutes les donnees creees et partagees sur le reseau sont signees cryptographiquement et marquees avec l'adresse de leur `Site` d'origine. Cela fournit une piste d'audit immuable et verifiable pour tout contenu, garantissant que son authenticite peut toujours etre confirmee. + +## Fonctionnalites principales + +* **Application decentralisee prete a l'emploi (programme `Site`) :** le SDK inclut un programme P2P puissant et complet, le `Site`. Il prend en charge nativement les publications de contenu, les categories, les mises en avant et les outils de moderation. + +* **Controle d'acces flexible base sur les roles (RBAC) :** un systeme d'autorisations sophistique, securise et extensible. Il fournit une hierarchie claire de roles par defaut (`Admin`, `Moderator`, `Member`) et permet de creer des roles personnalises avec des autorisations fines pour controler precisement la creation, la gestion de contenu et l'administration du site. + +* **Federation et synchronisation automatisees :** un `FederationManager` sophistique gere tous les aspects de la communication inter-sites, notamment : + * **Synchronisation historique :** reconstitue automatiquement le contenu lorsqu'une nouvelle subscription est etablie. + * **Mises a jour live via pub/sub :** assure une synchronisation en temps reel entre les sites federes. + * **Gestion d'etat des connexions :** gere intelligemment le cycle de vie des connexions federatives, y compris le nettoyage automatise des donnees lors d'un desabonnement. + +* **API de service haut niveau (`LensService`) :** une interface conviviale qui sert de point d'entree unique pour l'integration applicative. Elle fournit une API stable basee sur des promesses qui masque toute la complexite P2P sous-jacente. + +* **Schemas extensibles :** toutes les structures de donnees sont definies via des schemas fortement types, ce qui garantit la coherence et l'integrite des donnees a travers le reseau tout en restant extensible pour les besoins futurs. + +## A qui s'adresse ce SDK ? + +Le SDK Lens convient parfaitement aux developpeurs et aux organisations qui construisent : + +* **Des plateformes de contenu decentralisees :** pour les createurs independants, journalistes ou artistes qui ont besoin d'outils de publication resistants a la censure. +* **Des forums et archives detenus par la communaute :** ou les membres contribuent ensemble a un depot partage de connaissances ou de donnees et le gouvernent. +* **Des applications de reseaux sociaux federes :** permettant aux utilisateurs d'exploiter leurs propres noeuds tout en participant a un graphe social plus large et interconnecte. +* **Des reseaux de partage de donnees pour l'entreprise :** des reseaux prives et securises pour partager des donnees versionnees et des artefacts entre partenaires de confiance. + +## Pour commencer + +Pour debuter avec le SDK Lens, nous vous recommandons de lire les sections suivantes : + +1. **[Concepts fondamentaux](/fr/docs/lens-sdk/core-concepts) :** une explication detaillee du programme `Site`, de la federation et des principes architecturaux du SDK. +2. **[Demarrage rapide](/fr/docs/lens-sdk/quick-start) :** un tutoriel pas a pas pour mettre en route une application de base. +3. **[Reference d'API](/fr/docs/lens-sdk/api-reference) :** une documentation complete de `LensService`, de ses methodes et de ses types de donnees. diff --git a/content/docs/lens-sdk/advanced-topics.fr.md b/content/docs/lens-sdk/advanced-topics.fr.md new file mode 100644 index 0000000..dc8f73e --- /dev/null +++ b/content/docs/lens-sdk/advanced-topics.fr.md @@ -0,0 +1,208 @@ ++++ +date = '2025-07-22T12:25:02+02:00' +draft = false +title = 'Sujets avances' +weight = 3 ++++ + +Cette section couvre des concepts avances et des bonnes pratiques pour construire des applications robustes, evolutives et securisees avec le SDK Lens. Elle s'adresse aux developpeurs qui maitrisent deja les sujets presentes dans le guide de demarrage rapide et les concepts fondamentaux. + +### 1. Utiliser un portefeuille pour l'identite utilisateur + +La fonctionnalite la plus puissante pour construire des dApps avec le SDK Lens est la possibilite d'utiliser un portefeuille externe, comme MetaMask, comme identite de l'utilisateur. Cela permet a l'utilisateur de signer directement toutes ses actions, ce qui garantit qu'il ou elle reste le veritable proprietaire de son contenu. + +Pour cela, vous devez creer un objet `Identity` compatible Peerbit a partir d'un signataire `ethers.js`. + +#### Etape 1 : ajouter les dependances + +Vous aurez besoin de `ethers` pour interagir avec les portefeuilles du navigateur. + +```bash +pnpm install ethers +``` + +#### Etape 2 : creer l'identite a partir d'un signataire + +Le SDK fournit une fonction utilitaire, `createIdentityFromSigner`, pour simplifier cela. Dans une application web, vous recupererez generalement le signataire depuis le fournisseur `window.ethereum`. + +```typescript +import { ethers } from 'ethers'; +import { LensService, createIdentityFromSigner } from '@riffcc/lens-sdk'; + +async function setupWithWallet() { + // In a browser environment: + const provider = new ethers.BrowserProvider(window.ethereum); + const signer = await provider.getSigner(); + + // Create a Peerbit-compatible identity from the ethers signer. + const walletIdentity = await createIdentityFromSigner(signer); + + // Instantiate the LensService, passing the custom identity. + const lens = new LensService({ + identity: walletIdentity, + debug: true, + }); + + // Now, all calls like `lens.addRelease()` will trigger a signature + // request in the user's wallet. + await lens.init(); + // ... rest of your application logic +} +``` + +#### Etape 3 : creer un site avec l'identite du portefeuille + +Si l'utilisateur est la premiere personne a creer un `Site`, la cle publique de son portefeuille doit etre utilisee comme administrateur racine. Vous pouvez passer directement `walletIdentity.publicKey` au constructeur `Site`. + +```typescript +import { Site } from '@riffcc/lens-sdk/programs'; +// ... assuming lens and walletIdentity are set up from the previous step + +// The user's wallet public key becomes the root of trust for the new Site. +const rootAdminKey = walletIdentity.publicKey; +const newSite = new Site(rootAdminKey); + +// Open the site. The user's wallet will sign for this action. +await lens.openSite(newSite); + +console.log(`Site created successfully! Address: ${lens.siteProgram.address}`); +``` + +Ce modele est fondamental pour creer des applications non custodiales dans lesquelles les utilisateurs gardent un controle complet. + +### 2. Gerer le client Peerbit en externe + +Dans certaines applications complexes, il peut etre necessaire de gerer vous-meme le cycle de vie du client P2P Peerbit, en particulier si votre application utilise d'autres programmes Peerbit en plus du programme `Site`. + +Le constructeur `LensService` accepte en option une instance de client `peerbit`. Lorsqu'un client est fourni de cette maniere, le service ne tente pas d'en gerer le cycle de vie. + +**Cas d'usage :** votre application doit executer un programme `Site` et un autre programme personnalise `Chat` sur le meme noeud Peerbit. + +```typescript +import { Peerbit } from 'peerbit'; +import { LensService } from '@riffcc/lens-sdk'; +import { ChatProgram } from './my-chat-program'; // Your custom program + +async function setup() { + // 1. Create and manage the Peerbit client yourself. + const peerbit = await Peerbit.create({ directory: './shared-p2p-node' }); + + // 2. Pass the external client to the LensService. + const lens = new LensService({ peerbit: peerbit, debug: true }); + + // 3. You can now open a Site... + await lens.openSite('EXISTING_SITE_ADDRESS'); + + // 4. ...and also open your other custom programs on the same node. + const chat = await peerbit.open(new ChatProgram()); + + // ... application logic ... + + // 5. You are responsible for stopping the client. + // The lens.stop() call will NOT stop the external client. + await lens.stop(); // Only stops the Site program and FederationManager + await peerbit.stop(); +} +``` + +### 3. Personnaliser la replication (`SiteArgs`) + +Par defaut, un programme `Site` tente de repliquer ses magasins de donnees avec un faible facteur de replication afin d'economiser des ressources. Pour les applications qui exigent une meilleure disponibilite ou de meilleures performances, vous pouvez fournir des arguments de replication personnalises lors de l'ouverture d'un site. + +L'objet `SiteArgs` vous permet de definir les options `replicate` de chaque magasin de donnees dans le `Site`. + +**Cas d'usage :** vous exploitez un noeud de "pinning" dedie qui doit conserver une copie complete de toutes les donnees pour une disponibilite maximale. + +```typescript +import { Site } from '@riffcc/lens-sdk/programs'; + +const dedicatedPinningNodeArgs = { + // Setting 'replicate: true' means "replicate everything you can find." + releasesArgs: { replicate: true }, + featuredReleasesArgs: { replicate: true }, + contentCategoriesArgs: { replicate: true }, + // ACLs and Subscriptions should always be fully replicated on an admin node. + membersArg: { replicate: true }, + administratorsArgs: { replicate: true }, + subscriptionsArgs: { replicate: true } +}; + +const site = new Site(myPublicKey); +await lens.openSite(site, { siteArgs: dedicatedPinningNodeArgs }); +``` + +Pour des options de replication detaillees, reportez-vous a la documentation Peerbit sur `ReplicationOptions`. + +### 4. Comprendre les performances de federation + +Le `FederationManager` est concu pour etre efficace, mais dans les reseaux de grande taille, il est utile d'en comprendre le comportement : + +* **Synchronisation historique :** c'est la partie la plus gourmande en ressources de la federation. Lorsqu'un site contenant des milliers de releases est abonne, la synchronisation initiale peut prendre du temps et consommer de la bande passante. Ce processus s'execute en arriere-plan et ne bloque pas les autres operations. +* **Synchronisation live :** les mises a jour live via pub/sub sont tres legeres. Un message `FederationUpdate` contient uniquement les hachages cryptographiques et les metadonnees des entrees modifiees, et non les donnees completes, ce qui rend les mises a jour en temps reel tres rapides. +* **Topologie reseau :** les performances de federation dependent du reseau libp2p sous-jacent. Pour des performances optimales, veillez a ce que les noeuds, surtout ceux qui se federent frequemment entre eux, soient bien connectes. Vous pouvez utiliser `peerbit.dial()` pour etablir manuellement des connexions si necessaire. + +### 5. Moderation de contenu de niveau production (`BlockedContent` et listes de refus) + +Le SDK Lens est concu autour d'une architecture puissante de moderation de contenu qui va au-dela du simple filtrage applicatif et touche l'infrastructure elle-meme. Cette section expose la vision d'ensemble, en distinguant ce qui est deja disponible de ce qui est en cours ou prevu. + +#### Suppressions logiques vs suppressions dures + +Il est important de distinguer les deux formes de retrait de contenu : + +* **`deleteRelease()` (suppression logique) :** il s'agit d'une fonctionnalite standard. Lorsqu'un administrateur appelle `deleteRelease()`, cela retire le document `Release` de la base de donnees du site. C'est une suppression "douce" ou logique du point de vue de l'application. Le fichier de donnees sous-jacent sur IPFS n'est pas immediatement affecte. + +* **`BlockedContent` (fondation pour une suppression dure) :** ce schema sert de base a un processus de "hard delete". Il est concu pour creer un enregistrement permanent et verifiable indiquant qu'un contenu identifie par son CID doit etre purge non seulement de l'application, mais aussi de toute l'infrastructure de stockage. + +#### Le modele de moderation "Bad Bits" : etat actuel et vision future + +Le modele recommande pour une moderation robuste suit les principes de formats etablis de listes de refus comme la denylist ["Bad Bits"](https://badbits.dwebops.pub/). + +Voici le flux de travail, avec l'etat de chaque composant : + +1. **Action de l'administrateur :** un administrateur identifie un contenu, via son identifiant IPFS CID, qui doit etre bloque. + +2. **Double hachage et creation d'enregistrement (en cours) :** + * **Fonctionnalite :** pour proteger la vie privee, le CID original est **doublement hache**, par exemple SHA256(SHA256(CID)), avant d'etre stocke. Cela empeche un observateur occasionnel d'identifier directement le contenu sur la liste de blocage. + * **Etat :** les methodes de haut niveau `LensService` pour realiser cette operation, comme `blockContent()`, sont **actuellement en cours de developpement**. Elles offriront aux administrateurs un moyen simple et securise d'ajouter des entrees dans le magasin `blockedContent` sans interagir directement avec le programme. + +3. **Synchronisation avec l'infrastructure (implementation future) :** + * **Vision :** a long terme, un service backend de confiance, ou "Operator", surveillera le magasin `blockedContent` du `Site`. Cet Operator generera un fichier de denylist standard a partir des hachages stockes et le distribuera a toute l'infrastructure centrale. + * **Etat :** l'implementation de ce **service Operator est prevue pour plus tard**. Une fois terminee, elle permettra au magasin `blockedContent` d'agir comme source de verite decentralisee capable d'ordonner aux noeuds IPFS, clusters et CDN de refuser de servir un contenu bloque et de le supprimer definitivement. + +#### Resume des fonctionnalites de moderation + +| Feature | Status | Description | +|-------------------------------------------|-------------------|---------------------------------------------------------------------------------------------------------| +| **Logical Deletion** (`deleteRelease`) | ✅ **Implemented** | Removes content metadata from the `Site`'s database. | +| **Blocklist Schema** (`BlockedContent`) | ✅ **Implemented** | The on-chain data structure for recording moderation decisions exists. | +| **Service API for Blocking** (`blockContent`) | ⏳ **In Progress** | High-level `LensService` methods for easy and secure management of the `blockedContent` store. | +| **Operator for Infrastructure Sync** | 🗺️ **Future** | A service to automate the syncing of the on-chain blocklist to IPFS nodes, clusters, and CDNs. | + +Cette feuille de route trace un chemin clair entre les capacites actuelles et un systeme complet de moderation de contenu de bout en bout, a la fois puissant et respectueux de la vie privee. + +### 6. Interaction directe avec le programme (pour cas avances) + +Bien que `LensService` doive couvrir 99 % des interactions, il existe de rares cas ou une interaction directe avec le programme `Site` s'impose, par exemple dans des scripts administratifs cote serveur. + +L'instance active du programme `Site` est disponible via `lensService.siteProgram`. + +**Cas d'usage :** un script doit inspecter l'etat de replication bas niveau d'une base de donnees specifique. + +```typescript +// This is NOT a typical application pattern. Use with caution. +const site: Site | null = lens.siteProgram; + +if (site) { + // Accessing the underlying log of a store + const releaseLog = site.releases.log; + + // Get the cryptographic heads of the log + const heads = await releaseLog.log.getHeads().all(); + console.log('Current release log heads:', heads.map(h => h.hash)); + + // Directly interacting with ACLs + await site._authorise(AccountType.MEMBER, 'some_public_key'); +} +``` + +**Avertissement :** en contournant `LensService`, vous perdez ses verifications de securite, sa gestion des erreurs et la stabilite de son contrat d'API. Cela ne doit etre fait que si vous avez une tres bonne connaissance de Peerbit et de la logique interne du programme `Site`. diff --git a/content/docs/lens-sdk/api-reference.fr.md b/content/docs/lens-sdk/api-reference.fr.md new file mode 100644 index 0000000..c4d2464 --- /dev/null +++ b/content/docs/lens-sdk/api-reference.fr.md @@ -0,0 +1,357 @@ ++++ +date = '2025-07-22T05:45:03+02:00' +draft = false +title = 'Reference d API' +weight = 5 ++++ + +Ce document fournit une reference detaillee de l'API publique du SDK Lens, en se concentrant principalement sur la classe `LensService`. `LensService` est le seul point d'entree prevu pour les developpeurs qui construisent des applications avec le SDK. + +## `LensService` + +La classe `LensService` fournit une interface asynchrone de haut niveau pour toutes les fonctionnalites du SDK. Elle gere le client Peerbit, le cycle de vie du programme `Site` et toutes les operations exposees aux utilisateurs. + +### Constructeur + +```typescript +new LensService(options?: { + peerbit?: ProgramClient; + debug?: boolean; + customPrefix?: string; + identity?: Identity; +}) +``` + +Initialise une nouvelle instance du service. + +| Parameter | Type | Optional | Description | +|----------------|-----------------|:--------:|---------------------------------------------------------------------------------------------------------| +| `options` | `object` | **Yes** | Configuration de l'instance de service. | +| `options.peerbit`| `ProgramClient` | **Yes** | Un client Peerbit gere en externe. S'il est fourni, `init()` et `stop()` n'affecteront pas son cycle de vie. | +| `options.debug`| `boolean` | **Yes** | Active les journaux de diagnostic detailles dans la console. La valeur par defaut est `false`. | +| `options.customPrefix`| `string` | **Yes** | Definit un prefixe personnalise pour les messages de log. La valeur par defaut est `'[LensService]'`. | +| `options.identity`| `Identity` | **Yes** | Une identite personnalisee centree sur l'utilisateur, par exemple depuis un portefeuille, a utiliser pour toutes les signatures. Si elle est omise, le service utilise l'identite par defaut du noeud Peerbit. | + +--- + +## Methodes de cycle de vie + +Ces methodes controlent la connexion au reseau Peerbit et au programme `Site` actif. + +### `init()` + +```typescript +init(directory?: string): Promise +``` + +Initialise et demarre un nouveau client Peerbit gere en interne. Cette methode doit etre appelee avant toute autre operation si le service n'a pas ete construit avec un client externe. + +| Parameter | Type | Optional | Description | +|-------------|----------|:--------:|--------------------------------------------------------------------------------------------| +| `directory` | `string` | **Yes** | Chemin du systeme de fichiers pour stocker l'identite pair et les donnees. Si omis, les donnees sont stockees en memoire. | + +### `stop()` + +```typescript +stop(): Promise +``` + +Arrete proprement le service en fermant le `Site` actif et en stoppant le client Peerbit, lorsqu'il est gere en interne. + +### `openSite()` + +```typescript +openSite( + siteOrAddress: Site | string, + options?: { siteArgs?: SiteArgs, federate?: boolean } +): Promise +``` + +Ouvre un programme `Site` et en fait le contexte actif pour tous les appels API suivants. + +| Parameter | Type | Optional | Description | +|-------------------|---------------------|:--------:|------------------------------------------------------------------------------------------------------------| +| `siteOrAddress` | `Site \| string` | No | Pour creer un nouveau `Site`, passez une instance `new Site(rootTrust)`. Pour ouvrir un site existant, passez son adresse. | +| `options` | `object` | **Yes** | Configuration supplementaire. | +| `options.siteArgs`| `SiteArgs` | **Yes** | Configuration avancee de la replication de base de donnees. | +| `options.federate`| `boolean` | **Yes** | Si `true`, demarre le `FederationManager` pour ce site afin de gerer les subscriptions. La valeur par defaut est `true`. | + +--- + +## Methodes de compte et d'etat + +Methodes permettant de recuperer des informations sur l'utilisateur courant. + +### `getAccountStatus()` + +```typescript +getAccountStatus(): Promise +``` + +Determine l'etat complet des permissions de l'**identite active** actuelle, identite de portefeuille personnalisee ou identite par defaut du noeud, pour le `Site` actif. C'est la methode principale pour recuperer les informations necessaires au rendu d'une interface adaptee aux capacites de l'utilisateur. + +```typescript +interface AccountStatusResponse { + isAdmin: boolean; // True if the user is a top-level administrator + roles: string[]; // An array of role names assigned to the user (e.g., ["moderator", "member"]) + permissions: string[]; // A flattened, unique list of all permissions granted by the user's roles +} +``` + +--- + +### Types d'entree API + +Pour simplifier les interactions, `LensService` utilise deux principaux modeles d'entree pour creer et modifier des documents. + +* **`AddInput`** : utilise pour creer de nouveaux documents, par exemple dans `addRelease`. Le type `AddInput` est simplement un alias de `T`. Vous fournissez uniquement les proprietes de donnees principales du document a creer. `LensService` se charge d'ajouter automatiquement les champs requis `id`, `postedBy` et `siteAddress`. + +* **`EditInput`** : utilise pour mettre a jour des documents existants, par exemple dans `editRelease`. Ce type est un alias de `T & ImmutableProps`. Vous devez fournir toutes les donnees du document, y compris `id`, `postedBy` et `siteAddress` du document existant. Le service verifie que les proprietes immuables, `postedBy` et `siteAddress`, n'ont pas ete modifiees. + +--- + +## Gestion du contenu (`Releases`) + +Methodes permettant de creer et gerer le type principal de contenu, `Release`. + +### `addRelease()` + +```typescript +addRelease(data: AddInput): Promise +``` + +Cree et enregistre un nouveau document `Release`. Necessite un role disposant de la permission `release:create`, par exemple `Member`, `Moderator` ou `Admin`. + +| Parameter | Type | Description | +|-----------|---------------------|---------------------------------------------------------------------------------------------------------| +| `data` | `AddInput` | Objet contenant les proprietes de la release, comme `name`, `categoryId`, etc. | + +### `editRelease()` + +```typescript +editRelease(data: EditInput): Promise +``` + +Met a jour une `Release` existante. La permission requise depend de l'action : + +* Un utilisateur disposant de la permission `release:edit:own` peut modifier une release dont il ou elle est `postedBy`. +* Un utilisateur disposant de la permission `release:edit:any` peut modifier n'importe quelle release. + +| Parameter | Type | Description | +|-----------|---------------------|-------------------------------------------------------------------------------------------------------------------------------------------| +| `data` | `EditInput` | Les donnees completes de la `Release`, y compris l'`id` du document a mettre a jour. Le service rejettera la modification si `postedBy` ou `siteAddress` sont modifies. | + +Met a jour une `Release` existante. L'objet `data` doit inclure l'`id`. Necessite des privileges `ADMIN`. + +### `deleteRelease()` + +```typescript +deleteRelease(id: string): Promise +``` + +Supprime une `Release` a partir de son identifiant. Necessite la permission `release:delete`, par exemple `Moderator` ou `Admin`. + +### `getRelease()` + +```typescript +getRelease(id: string): Promise | undefined> +``` + +Recupere une `Release` unique a partir de son identifiant. + +### `getReleases()` + +```typescript +getReleases(options?: SearchOptions): Promise[]> +``` + +Recupere un tableau de documents `Release`. + +--- + +## Gestion du contenu mis en avant + +Methodes pour gerer les entrees `FeaturedRelease`. Ces operations necessitent un role disposant de la permission `featured:manage`, par exemple `Moderator` ou `Admin`. + +### `addFeaturedRelease()` + +```typescript +addFeaturedRelease(data: AddInput): Promise +``` + +Cree une `FeaturedRelease` afin de mettre en avant une `Release` existante. + +### `editFeaturedRelease()` + +```typescript +editFeaturedRelease(data: EditInput): Promise +``` + +Met a jour une `FeaturedRelease` existante. L'`id` doit etre present, et les proprietes principales `postedBy` et `siteAddress` ne peuvent pas etre modifiees. + +### `deleteFeaturedRelease()` + +```typescript +deleteFeaturedRelease(id:string): Promise +``` + +Supprime une `FeaturedRelease` a partir de son identifiant. + +*(Les methodes `getFeaturedRelease` et `getFeaturedReleases` suivent le meme schema que leurs equivalents pour `Release`.)* + +--- + +## Gestion des categories de contenu + +Methodes permettant de gerer les documents `ContentCategory`. Ces operations necessitent un role disposant de la permission `category:manage`, par exemple `Moderator` ou `Admin`. + +### `addContentCategory()` + +```typescript +addContentCategory(data: AddInput): Promise +``` + +Cree une nouvelle `ContentCategory`. Le champ `categoryId` doit etre unique. + +### `editContentCategory()` + +```typescript +editContentCategory(data: EditInput): Promise +``` + +Met a jour une `ContentCategory` existante. Le service rejettera la mise a jour si des champs immuables, `postedBy`, `siteAddress` ou `categoryId`, sont modifies. + +### `deleteContentCategory()` + +```typescript +deleteContentCategory(id: string): Promise +``` + +Supprime une `ContentCategory` a partir de son identifiant. + +### `getContentCategory()` + +```typescript +getContentCategory(id: string): Promise | undefined> +``` + +Recupere une `ContentCategory` unique a partir de son identifiant. + +### `getContentCategories()` + +```typescript +getContentCategories(options?: SearchOptions): Promise[]> +``` + +Recupere un tableau de tous les documents `ContentCategory`. + +--- + +## Gestion de la federation (`Subscription`) + +Methodes permettant de gerer les relations de federation. Ces operations necessitent un role disposant de la permission `subscription:manage`, par exemple `Moderator` ou `Admin`. + +### `addSubscription()` + +```typescript +addSubscription(data: AddInput): Promise +``` + +S'abonne a un autre `Site`, ce qui declenche la federation. + +| Parameter | Type | Description | +|-----------|------------|-------------------------------------------------------------| +| `data` | `AddInput` | Objet contenant les proprietes de subscription. `SubscriptionData` vaut `{ to: string }`. | + +### `deleteSubscription()` + +```typescript +deleteSubscription(data: { id?: string; to?: string }): Promise +``` + +Se desabonne d'un `Site`, stoppe la federation et purge son contenu. + +| Parameter | Type | Description | +|-----------|----------|----------------------------------------------------------------------| +| `data` | `object` | Objet contenant soit l'`id` de la subscription, soit l'adresse `to` du site cible a supprimer. | + +### `getSubscriptions()` + +```typescript +getSubscriptions(options?: SearchOptions): Promise +``` + +Recupere la liste de tous les documents `Subscription` actuels. + +## Gestion du controle d'acces + +Methodes pour gerer les permissions des utilisateurs sur le `Site` actif. Ces operations sont privilegiees et **ne peuvent etre effectuees que par un Administrator**. + +### `addAdmin()` + +```typescript +addAdmin(publicKey: string | PublicSignKey): Promise +``` + +Promouvoit un autre utilisateur au rang d'Administrator complet en l'ajoutant au `TrustedNetwork` racine du site. + +| Parameter | Type | Description | +|-------------|------------------------|------------------------------------------------------------| +| `publicKey` | `string \| PublicSignKey` | Cle publique de l'utilisateur a promouvoir. | + +### `assignRole()` + +```typescript +assignRole(publicKey: string | PublicSignKey, roleId: string): Promise +``` + +Attribue un role specifique a un utilisateur. + +| Parameter | Type | Description | +|-------------|------------------------|-----------------------------------------------------------------------------| +| `publicKey` | `string \| PublicSignKey` | Cle publique de l'utilisateur. | +| `roleId` | `string` | Identifiant texte du role a attribuer, par exemple `"member"` ou `"moderator"`. | + +### `revokeRole()` + +```typescript +revokeRole(publicKey: string | PublicSignKey, roleId: string): Promise +``` + +Retire un role specifique a un utilisateur. + +| Parameter | Type | Description | +|-------------|------------------------|-----------------------------------------------------------------------------| +| `publicKey` | `string \| PublicSignKey` | Cle publique de l'utilisateur. | +| `roleId` | `string` | Identifiant texte du role a revoquer. | + +## Objets de reponse courants + +La plupart des methodes de `LensService` renvoient l'un des objets de reponse standardises suivants afin de garantir une gestion des erreurs et un retour coherents. + +### `BaseResponse` + +L'objet de reponse le plus simple, indiquant seulement le succes ou l'echec. + +| Field | Type | Description | +|-----------|-----------|-------------------------------------------------------| +| `success` | `boolean` | `true` si l'operation a reussi, sinon `false`. | +| `error` | `string` | Message d'erreur si `success` vaut `false`. | + +### `IdResponse` + +Etend `BaseResponse` pour inclure l'identifiant unique du document affecte. + +| Field | Type | Description | +|-------|----------|-----------------------------------------------------------| +| `id` | `string` | Identifiant unique du document cree ou modifie. | +| *(...inherits from `BaseResponse`)* | | | + +### `HashResponse` + +Etend `IdResponse` afin d'inclure egalement le hachage cryptographique de l'entree de journal de l'operation, qui peut servir a la verification. + +| Field | Type | Description | +|-------|----------|------------------------------------------------------| +| `hash`| `string` | Hachage cryptographique de l'entree du log P2P sous-jacent. | +| *(...inherits from `IdResponse`)* | | | diff --git a/content/docs/lens-sdk/core-concepts.fr.md b/content/docs/lens-sdk/core-concepts.fr.md new file mode 100644 index 0000000..f9142a0 --- /dev/null +++ b/content/docs/lens-sdk/core-concepts.fr.md @@ -0,0 +1,101 @@ ++++ +date = '2025-07-22T05:44:53+02:00' +draft = false +title = 'Concepts fondamentaux' +weight = 2 ++++ + +Le SDK Lens est concu autour d'un ensemble de composants robustes et interoperables. Une bonne maitrise de ces concepts fondamentaux est essentielle pour exploiter toute la puissance et toute la securite du SDK. Ce document offre une vue detaillee des piliers fondateurs de l'architecture Lens : `LensService`, le programme `Site`, le modele de federation et le systeme de controle d'acces. + +## 1. L'architecture en couches + +Le SDK adopte une architecture stricte en couches afin de favoriser la modularite, la securite et la maintenabilite. Chaque couche a une responsabilite distincte, et la communication circule verticalement au travers d'interfaces bien definies. + +```mermaid +graph TD + A[📱 Application Layer
UI, Backend, CLI] -->|Consumes| B[🧩 Service Layer
LensService: Public API] + B -->|Orchestrates| C[🔗 Federation & Program Layer
FederationManager, Site Program] + C -->|Built Upon| D[🌐 P2P Framework Layer:
Peerbit] + + %% Styling + classDef layer stroke-width:1px,rx:10,ry:10; + class A,B,C,D layer; + +``` + +* **Couche de service (`LensService`) :** il s'agit de l'interface publique canonique du SDK. C'est le seul point d'entree pour toute application consommatrice. Son role est de fournir une API stable, asynchrone et de haut niveau qui abstrait entierement la complexite du reseau P2P et de la logique de programme sous-jacents. La couche de service gere le cycle de vie du client P2P et du programme `Site` actif. + +* **Couche programme (programme `Site`) :** il s'agit du backend decentralise "on-chain" de l'application. Le programme `Site` est un "smart contract" replicable et stateful qui definit les schemas de donnees, les bases de donnees et les regles immuables governant l'acces aux donnees. C'est la source de verite ultime pour tout le contenu et toutes les autorisations au sein d'un `Site`. + +* **Couche de federation (`FederationManager`) :** c'est un composant interne specialise gere par `LensService`. Il orchestre toute la communication inter-programmes. Alors que le programme `Site` definit *quelles* donnees existent, le `FederationManager` definit *comment* ces donnees sont decouvertes, synchronisees et partagees entre les differentes instances de `Site`. + +* **Couche du framework P2P (Peerbit) :** la couche fondamentale qui fournit les primitives necessaires au reseautage pair a pair, a la creation de bases de donnees, a la replication de donnees et a l'identite cryptographique. Le SDK Lens est construit directement au-dessus de ce cadre robuste. + +## 2. Le programme `Site` : une entite numerique souveraine + +La construction centrale de l'ecosysteme Lens est le `Site`. Conceptuellement, un `Site` est un espace numerique souverain, adressable et autonome. Il fonctionne comme une instance d'application decentralisee complete avec ses propres bases de donnees et son propre systeme de controle d'acces. + +### Caracteristiques principales d'un `Site` + +* **Adresse unique et verifiable :** chaque `Site` est identifie par une adresse cryptographique permanente derivee de la cle publique de son proprietaire et de ses parametres initiaux. Cette adresse est utilisee pour localiser, ouvrir et interagir avec le `Site` sur le reseau. +* **Magasins de donnees structures :** un `Site` est compose de plusieurs magasins de donnees distincts et specialement concus pour les `Releases`, `ContentCategories`, `Subscriptions` et plus encore. Cette approche structuree assure l'integrite des donnees et une organisation claire. +* **Autorisations explicites :** l'acces a un `Site` n'est pas public par defaut. Toutes les autorisations d'ecriture sont explicitement accordees par un **Administrator** via un systeme robuste de controle d'acces base sur les roles (RBAC). + +## 3. Le modele de federation : un echange de donnees fonde sur des principes + +La federation est le processus par lequel des instances independantes de `Site` partagent des donnees. Le SDK Lens met en oeuvre un modele fonde sur les subscriptions pour garantir que tous les echanges de donnees sont intentionnels et securises. + +### Le cycle de vie de la federation + +1. **Subscription explicite :** le processus est initie par un utilisateur disposant de la permission `subscription:manage`, en general un `Moderator` ou un `Admin`. Pour federer, cette personne cree un enregistrement `Subscription` contenant l'adresse du `Site` cible. Cette action constitue une declaration de confiance deliberee. + +2. **Synchronisation d'etat :** a la creation d'une `Subscription`, le `FederationManager` realise deux types de synchronisation : + * **Synchronisation historique :** un processus ponctuel qui se connecte au `Site` distant et replique son contenu public existant, comme les `Releases`. + * **Synchronisation live :** le gestionnaire s'abonne au topic pub/sub dedie du `Site` distant, creant un canal de communication persistant en temps reel pour les mises a jour immediates. + +3. **Provenance des donnees :** toutes les donnees recues via federation sont immuables et conservent la signature cryptographique de leur auteur d'origine ainsi que l'adresse de leur `Site` d'origine. Cela garantit que la source de tout contenu peut etre verifiee. + +4. **Fin de cycle :** si une `Subscription` est supprimee, le `FederationManager` effectue un nettoyage en purgeant de ses bases de donnees locales toutes les donnees associees au `Site` desabonne. + +## 4. Le systeme de controle d'acces (RBAC) + +La securite est un element central du programme `Site`. Le systeme repose sur un modele robuste et securise de **Role-Based Access Control (RBAC)** gere par un `RoleBasedccessController` interne dedie. Ce controleur est l'autorite ultime pour toutes les actions au sein d'un `Site`. + +### Identite et signatures + +Toute action qui modifie un `Site`, comme l'ajout d'une release ou l'attribution d'un role, doit etre signee cryptographiquement. Le SDK Lens prend en charge deux modeles d'identite : + +1. **Identite par defaut du noeud :** si vous initialisez `LensService` sans fournir d'identite personnalisee, il utilisera une identite auto-generee liee au noeud Peerbit lui-meme. Cela convient aux scripts cote serveur ou aux noeuds sans interface, quand une identite unique et stable est souhaitee. + +2. **Identite de portefeuille personnalisee :** pour les applications destinees aux utilisateurs, l'approche recommandee est de fournir une identite derivee du portefeuille de l'utilisateur, par exemple MetaMask. Lorsque vous instanciez `LensService` avec cette identite, **toutes les actions suivantes sont signees par le portefeuille de l'utilisateur**. Cela garantit que l'utilisateur, et non le noeud applicatif, reste le veritable proprietaire et auteur de son contenu. C'est la base de la souverainete des donnees dans le SDK Lens. + +### Les composants du RBAC + +* **Administrateurs (`TrustedNetwork`) :** au sommet se trouve un `TrustedNetwork` d'administrateurs. Toute personne dont la cle publique appartient a ce reseau est consideree comme **Admin**. Les admins disposent de permissions universelles et sont les seuls a pouvoir gerer le systeme RBAC lui-meme, par exemple creer de nouveaux roles, les attribuer a des utilisateurs ou ajouter d'autres admins. Le createur initial d'un `Site` devient son premier `Admin`. + +* **Roles :** un `Role` est un ensemble nomme de permissions specifiques. Un `Site` est initialise avec un ensemble de roles par defaut, et les admins peuvent creer d'autres roles personnalises si necessaire. + +* **Permissions :** une `Permission` est une chaine granulaire representant une action precise, generalement au format `"resource:action"`, par exemple `"release:delete"`. + +* **Attributions :** une `Assignment` est un lien verifiable entre la cle publique d'un utilisateur et un `Role`. Un utilisateur obtient des permissions du fait des roles qui lui sont attribues. + +### Tableau des roles et permissions par defaut + +Un `Site` est livre avec un ensemble clair de roles par defaut, ce qui fournit une structure d'autorisations pertinente des le depart. Un **Admin** peut effectuer toutes les actions listees ci-dessous. + +| Action / Permission (`resource:action`) | Moderator | Member | Guest | Description | +|-----------------------------------------|:---------:|:------:|:-----:|--------------------------------------------------------------------------| +| **`release:create`** | ✅ | ✅ | ❌ | Peut publier de nouveaux documents `Release`. | +| **`release:edit:own`** | ✅ | ✅ | ❌ | Peut modifier les documents `Release` qu'il ou elle a publies. | +| **`release:edit:any`** | ✅ | ❌ | ❌ | Peut modifier les documents `Release` publies par *n'importe quel* utilisateur du site. | +| **`release:delete`** | ✅ | ❌ | ❌ | Peut supprimer n'importe quelle `Release` du site. | +| **`featured:manage`** | ✅ | ❌ | ❌ | Peut creer, modifier ou supprimer des entrees `FeaturedRelease`. | +| **`category:manage`** | ✅ | ❌ | ❌ | Peut creer, modifier ou supprimer des documents `ContentCategory`. | +| **`blocklist:manage`** | ✅ | ❌ | ❌ | Peut creer ou supprimer des entrees `BlockedContent`. | +| **`subscription:manage`** | ✅ | ❌ | ❌ | Peut s'abonner a d'autres sites ou s'en desabonner. | + +* **Guest (role implicite) :** c'est le statut par defaut de toute personne qui n'est ni admin ni titulaire d'un role attribue. Les `Guests` disposent d'un acces en lecture seule et ne peuvent effectuer aucune ecriture. + +### Federation et permissions + +Le modele RBAC s'etend intelligemment au contenu federatif. Meme si la confiance repose d'abord sur la subscription, le SDK Lens offre une capacite de reprise de controle puissante : **un `Admin` ou `Moderator` local peut toujours agir sur le contenu federatif**, par exemple supprimer une publication obsolete provenant d'un site desabonne. Cela garantit que les proprietaires du site local gardent le controle ultime du contenu stocke dans leurs bases de donnees. diff --git a/content/docs/lens-sdk/quick-start.fr.md b/content/docs/lens-sdk/quick-start.fr.md new file mode 100644 index 0000000..a2e7345 --- /dev/null +++ b/content/docs/lens-sdk/quick-start.fr.md @@ -0,0 +1,128 @@ ++++ +date = '2025-07-22T12:22:36+02:00' +draft = false +title = 'Demarrage rapide' +weight = 1 ++++ + +Ce guide propose un parcours pas a pas pour lancer une application de base avec le SDK Lens. A la fin, vous aurez initialise le service, cree un nouveau `Site`, rempli ses categories de contenu par defaut, ajoute du contenu et recupere ce contenu. + +### Prerequis + +* Node.js, version 18 ou superieure recommandee +* Un environnement de projet pret pour TypeScript + +### Etape 1 : installation + +Commencez par ajouter le SDK Lens aux dependances de votre projet. + +```bash +pnpm install @riffcc/lens-sdk +``` + +### Etape 2 : initialiser `LensService` + +`LensService` est le point d'entree principal pour toutes les fonctionnalites du SDK. La premiere etape consiste a creer une instance et a initialiser son client P2P sous-jacent. + +```typescript +import { LensService } from '@riffcc/lens-sdk'; +import { Site } from '@riffcc/lens-sdk/programs'; + +async function main() { + console.log("Initializing Lens Service..."); + // We enable 'debug' for verbose logging during development. + const lens = new LensService({ debug: true }); + + // The init() method creates and starts the Peerbit client. + // We provide a directory to persist the user's identity and data. + await lens.init('./my-first-site-data'); + + console.log("Service Initialized."); + + // We'll add more code here in the next steps... + + // Always remember to stop the service gracefully. + await lens.stop(); + console.log("Service Stopped."); +} + +main().catch(console.error); +``` + +### Etape 3 : creer et ouvrir un `Site` + +Un `Site` est votre hub de contenu decentralise. Pour en creer un nouveau, vous instanciez le programme `Site` avec votre cle publique en tant qu'administrateur racine, puis vous demandez au service de l'ouvrir. + +```typescript +// Inside your main() function, after lens.init() + +// 1. Get the public key of the current user from the initialized client. +const myPublicKey = lens.peerbit.identity.publicKey; + +// 2. Create a new Site instance, making yourself the root administrator. +const mySite = new Site(myPublicKey); + +// 3. Open the site. This registers it on the network and creates default roles. +console.log("Opening a new Site..."); +await lens.openSite(mySite); + +const siteAddress = lens.siteProgram.address; +console.log(`Site created and opened successfully! Address: ${siteAddress}`); +``` + +> **Utiliser une identite personnalisee :** l'exemple ci-dessus utilise l'identite par defaut generee automatiquement pour le noeud Peerbit. Pour les applications destinees aux utilisateurs, l'approche recommandee consiste a utiliser le portefeuille de l'utilisateur, comme MetaMask, comme identite. Pour savoir comment faire, consultez la section **Utiliser un portefeuille pour l'identite utilisateur** dans notre [guide des sujets avances](/fr/docs/lens-sdk/advanced-topics/#1-using-a-wallet-for-user-identity). + +### Etape 4 : initialiser les categories de contenu du site + +Un nouveau `Site` est vide par defaut. En tant qu'administrateur racine, vous devez l'initialiser avec un ensemble de documents `ContentCategory`. Il s'agit d'une operation unique qui remplit le site avec les modeles necessaires a la publication de contenu. + +```typescript +// Inside your main() function, after lens.openSite() + +console.log("Initializing site with default content categories..."); +// This is a privileged, direct interaction with the Site program. +await lens.siteProgram.initializeDefaultContentCategories(); +console.log("Default categories initialized successfully."); +``` + +### Etape 5 : ajouter du contenu (creer une `Release`) + +Maintenant que le `Site` a ete initialise avec ses categories, vous pouvez ajouter du contenu. Ajoutons une premiere `Release` en la reliant a la categorie par defaut `"music"`. + +```typescript +// Inside your main() function, after initializing categories + +console.log("Adding a new Release to the Site..."); + +const releaseData = { + name: "Hello, Decentralized World!", + categoryId: "music", // Link to the 'music' category we just created + contentCID: "bafybeigdyrzt5sfp7vu572pausrk236q2762rqcbqcnwqwixituoxuejm4" // Example CID +}; + +const response = await lens.addRelease(releaseData); + +if (response.success) { + console.log(`Release added successfully! ID: ${response.id}`); +} else { + console.error(`Failed to add release: ${response.error}`); +} +``` + +### Etape 6 : recuperer le contenu + +Enfin, verifions que le contenu a bien ete enregistre en recuperant toutes les releases du site. + +```typescript +// Inside your main() function, after adding the release + +console.log("Retrieving all releases..."); +const allReleases = await lens.getReleases(); + +console.log(`Found ${allReleases.length} release(s):`); +allReleases.forEach(release => { + console.log(`- ID: ${release.id}, Name: "${release.name}"`); +}); +``` + +Felicitations. Vous avez cree avec succes un `Site` decentralise, l'avez initialise, avez gere les permissions, ajoute du contenu et l'avez recupere. Vous pouvez maintenant approfondir les [Concepts fondamentaux](./core-concepts) ou consulter la [Reference d'API](./api-reference). diff --git a/content/docs/lens-sdk/site-reference.fr.md b/content/docs/lens-sdk/site-reference.fr.md new file mode 100644 index 0000000..6428cb8 --- /dev/null +++ b/content/docs/lens-sdk/site-reference.fr.md @@ -0,0 +1,85 @@ ++++ +date = '2025-07-22T06:21:22+02:00' +draft = false +title = 'Reference de Site' +weight = 4 ++++ + +### Schemas + +Ce document fournit une reference detaillee des schemas de donnees qui constituent un programme `Site`. Comprendre ces schemas est essentiel pour preparer les donnees des appels d'API et pour interpreter les donnees renvoyees par `LensService`. + +Tous les objets de donnees soumis a `LensService` pour creation ou modification doivent respecter les structures decrites ci-dessous. + +#### Proprietes communes des documents + +Bien qu'il n'existe pas de classe de base rigide, la plupart des documents partagent un ensemble de proprietes fondamentales. Lors de la creation d'un nouvel element de contenu, comme une `Release`, les champs `id`, `postedBy` et `siteAddress` sont automatiquement geres par `LensService`. + +| Field | Type | Description | +|---------------|-------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `id` | `string` | Un identifiant unique pour le document. Generalement un UUID genere automatiquement a la creation. Requis lors de la modification d'un document existant. | +| `postedBy` | `PublicSignKey` or `Uint8Array` | La cle publique cryptographique de l'identite associee au document. Lors de la creation de contenu, elle est automatiquement definie sur l'utilisateur courant, sauf indication contraire. | +| `siteAddress` | `string` | L'adresse unique du `Site` dans lequel ce document a ete cree a l'origine. Elle est toujours definie par le service et reste immuable. | + +> **Remarque sur l'immutabilite :** les champs `postedBy` et `siteAddress` sont consideres comme immuables. Une fois un document cree, ces valeurs ne peuvent pas etre modifiees via une operation `edit`. Le SDK applique cette regle au niveau du service. + +--- + +#### 1. `Release` + +La `Release` est l'objet principal de contenu. Elle represente un element unique publiable, comme un album de musique, une video ou un article. + +| Field | Type | Required | Description | +|----------------|----------|:--------:|---------------------------------------------------------------------------| +| `name` | `string` | **Yes** | Le titre affiche de la release. | +| `categoryId` | `string` | **Yes** | L'`id` de la `ContentCategory` a laquelle cette release appartient, par exemple `"music"`. | +| `contentCID` | `string` | **Yes** | L'identifiant de contenu IPFS, ou CID, du ou des fichiers principaux de cette release. | +| `thumbnailCID` | `string` | No | Le CID IPFS d'une miniature ou image de couverture associee a la release. | +| `metadata` | `string` | No | Une chaine JSON contenant des metadonnees supplementaires specifiques a la categorie. | + +#### 2. `ContentCategory` + +Une `ContentCategory` definit un modele pour un type de contenu, y compris les metadonnees attendues. Elles sont generalement creees par un administrateur de `Site` ou initialisees a partir d'un ensemble par defaut. + +| Field | Type | Required | Description | +|----------------|----------|:--------:|---------------------------------------------------------------------------------------------------------------| +| `categoryId` | `string` | **Yes** | Un identifiant unique lisible par un humain, par exemple `"movies"` ou `"tv-shows"`. **Ce champ est immuable.** | +| `displayName` | `string` | **Yes** | Le nom lisible par un humain pour la categorie, par exemple `"TV Shows"`. | +| `featured` | `boolean`| No | Indique si cette categorie doit etre affichee de facon proeminente. La valeur par defaut est `false`. | +| `description` | `string` | No | Une breve explication du type de contenu qui appartient a cette categorie. | +| `metadataSchema`| `string` | No | Une chaine JSON definissant la structure du champ `metadata` pour les `Releases` de cette categorie. Voir [defaults.ts](https://github.com/riffcc/lens-sdk/blob/main/src/programs/site/defaults.ts) pour des exemples. | + +> **Remarque sur l'immutabilite de `categoryId` :** le champ `categoryId` agit comme une "business key" stable. Une fois une categorie creee, cet identifiant ne peut pas etre modifie afin de garantir que toutes les `Releases` qui y sont liees restent valides. Le SDK applique cette regle. + +#### 3. `FeaturedRelease` + +Une `FeaturedRelease` agit comme une "epingle" ou un raccourci vers une `Release` existante, permettant de la mettre en avant. + +| Field | Type | Required | Description | +|-------------|-----------|:--------:|------------------------------------------------------------------------| +| `releaseId` | `string` | **Yes** | L'`id` du document `Release` qui est mis en avant. | +| `startTime` | `string` | **Yes** | Une date-heure ISO 8601 indiquant quand la mise en avant devient active. | +| `endTime` | `string` | **Yes** | Une date-heure ISO 8601 indiquant quand la mise en avant expire. | +| `promoted` | `boolean` | **Yes** | Un indicateur pour appliquer un style ou une priorite supplementaires dans une section promue. | + +#### 4. `Subscription` + +Une `Subscription` represente une action unilaterale de "suivi", a la base de la federation. Lorsqu'une `Subscription` est creee, le `FederationManager` commence a synchroniser le contenu du `Site` cible. + +| Field | Type | Required | Description | +|---------------|----------|:--------:|-----------------------------------------------------------------------------------------------------------| +| `to` | `string` | **Yes** | L'adresse unique complete du programme `Site` distant auquel on s'abonne. | + +>Remarque : l'`id` d'une subscription est genere de facon deterministe a partir d'une combinaison des adresses du site abonne et du site cible afin d'eviter les doublons. + +#### 5. `BlockedContent` + +Un enregistrement `BlockedContent` est un outil de moderation utilise par les administrateurs de `Site` pour masquer un contenu ou empecher son affichage. + +| Field | Type | Required | Description | +|-------|----------|:--------:|----------------------------------------------| +| `cid` | `string` | **Yes** | Le CID IPFS du contenu a bloquer. | + +--- + +Cette reference fournit aux developpeurs les details necessaires pour formater correctement les donnees pour toutes les interactions API. Pour savoir comment creer, recuperer ou gerer des documents avec ces schemas, consultez la [**Reference d'API**](/fr/docs/lens-sdk/api-reference). diff --git a/content/docs/librarian/_index.fr.md b/content/docs/librarian/_index.fr.md new file mode 100644 index 0000000..b4c7e47 --- /dev/null +++ b/content/docs/librarian/_index.fr.md @@ -0,0 +1,8 @@ +--- +date: '2025-07-07T15:37:53+01:00' +draft: true +title: 'Bibliothecaire' +weight: 6 +sidebar: + open: true +--- diff --git a/content/docs/riff.cc/_index.fr.md b/content/docs/riff.cc/_index.fr.md new file mode 100644 index 0000000..e7f7972 --- /dev/null +++ b/content/docs/riff.cc/_index.fr.md @@ -0,0 +1,21 @@ +--- +date: '2025-07-07T15:37:53+01:00' +draft: false +title: 'Riff.CC' +weight: 1 +sidebar: + open: true +--- + +> Liberer la culture du monde +> pour celles et ceux qui la creent. + +Nous proposons un service de streaming appele Riff.CC qui permet aux utilisateurs de regarder, partager et organiser du contenu multimedia legalement libre. + +Notre plateforme repose sur des principes decentralises, afin de garantir que le contenu reste accessible et resilient face a la censure. + +Il s'agit de la premiere bibliotheque impossible a arreter, qui permet a chacun de mettre en miroir sa propre bibliotheque a partir de la notre et de la partager avec d'autres. Vous pouvez en apprendre davantage sur les bibliotheques impossibles a arreter en lisant la documentation sur [Flagship](/fr/docs/flagship), le logiciel qui alimente Riff.CC. + +Vous pouvez egalement exploiter votre propre service de streaming grace a notre logiciel open source, et meme mettre en miroir notre bibliotheque dans la votre. + +Consultez notre [site de developpement en direct](https://ftwc.xyz) pour vous faire une idee de ce qu'est Riff.CC. diff --git a/content/docs/riff.cc/roadmap.fr.md b/content/docs/riff.cc/roadmap.fr.md new file mode 100644 index 0000000..176f2ba --- /dev/null +++ b/content/docs/riff.cc/roadmap.fr.md @@ -0,0 +1,69 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Feuille de route' +weight = 2 ++++ + +Voici ce qui arrive pour Riff.CC : + +## 📅 2025 +{{% steps %}} + +### Aout 2025 : beta publique + +Beta publique initiale de Riff.CC + +* Musique, films, livres et livres audio disponibles en streaming ou en telechargement. +* Lenses auto-hebergees permettant aux utilisateurs de creer leurs propres bibliotheques. + +### Septembre 2025 : televersements utilisateur + +Ajout de la prise en charge des televersements directs par les utilisateurs + +* Permettre aux utilisateurs de televerser directement leur propre contenu sur Riff.CC +* Voir la replication de vos donnees sur le reseau en temps reel + +### Octobre 2025 : pages artistes et albums + +Pages artistes et fonctionnalites communautaires + +* Pages artistes et albums pour une meilleure decouverte de contenu +* Fonctionnalites communautaires pour partager et organiser du contenu + +### Novembre 2025 : Lenses hebergees + +Lenses hebergees et services de sauvegarde pour les Lenses + +* Lancement de Lenses hebergees pour les utilisateurs qui veulent creer des bibliotheques sans auto-hebergement +* Fourniture de services de sauvegarde pour les Lenses qui veulent assurer la continuite et la disponibilite de leur contenu + +### Decembre 2025 : lancement public complet + +Lancement public complet de Riff.CC + +* Bibliotheque de contenu elargie avec des televersements generes par les utilisateurs +* Fonctions de decouverte ameliorees pour trouver et partager du contenu + +{{% /steps %}} + +## 📅 2026 + +{{% steps %}} + +### Janvier 2026 : chaines utilisateur + +Prise en charge initiale des chaines utilisateur et des abonnements + +* Creez et gerez votre propre chaine, qui peut afficher du contenu provenant d'autres chaines ou Lenses +* Prise en charge des abonnements aux chaines afin que les utilisateurs puissent suivre et recevoir des mises a jour de leurs chaines preferees + +### Fevrier 2026 : financement a seuil + +Etendre Riff.CC pour prendre en charge le financement a seuil + +* Permettre aux artistes de mettre en place des campagnes de financement a seuil pour leurs prochaines oeuvres +* Permettre aux utilisateurs de soutenir directement les artistes et de recevoir des recompenses +* Les artistes publient automatiquement leur oeuvre sous licence Creative Commons (non commerciale) une fois qu'ils ont gagne suffisamment d'argent avec + +{{% /steps %}} diff --git a/content/docs/riff.cc/team.fr.md b/content/docs/riff.cc/team.fr.md new file mode 100644 index 0000000..9a28881 --- /dev/null +++ b/content/docs/riff.cc/team.fr.md @@ -0,0 +1,67 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Equipe' +weight = 2 ++++ + +Nous avons une petite equipe, mais passionnee, de developpeurs, d'ingenieurs et de curateurs. + +{{< cards >}} + {{< card title="Michaela Andrus" + tag="Ingenieure solutions" + subtitle="Michaela dirige Riff Labs Perth. Elle est aussi ingenieure logiciel et chercheuse." + >}} + {{< card title="Lucas Jovanovich" + tag="Ingenieur principal" + subtitle="Lucas travaille sur la plateforme principale de Riff.CC et son architecture P2P." + >}} + {{< card title="Benjamin Arntzen" + tag="Fondateur" + subtitle="Benjamin est le fondateur de Riff.CC. C'est un chercheur P2P et architecte en systemes distribues." + >}} + {{< card title="Julien Malard-Adam" + tag="Ingenieur principal" + subtitle="Julien travaille sur la scalabilite et les performances de la plateforme principale de Riff.CC." + >}} + {{< card title="Phoebe Sleet" + tag="A venir" + subtitle="Davantage de details seront annonces prochainement." + >}} + {{< card title="Bill Schreckenstein" + tag="Relations partenaires" + subtitle="Bill travaille a construire des partenariats avec d'autres organisations et projets." + >}} + {{< card title="Preeti Aarya" + tag="Developpeuse web" + subtitle="Preeti travaille a ameliorer l'experience frontend de Riff.CC." + >}} + {{< card title="Muskan Paswan" + tag="Developpeuse web" + subtitle="Muskan travaille a ameliorer l'apparence et l'experience de Riff.CC et des Lenses." + >}} + {{< card title="Evelyn Collins" + tag="Bibliothecaire P2P" + subtitle="Evelyn est chercheuse et curatrice de contenu. Elle aide a construire et organiser la bibliotheque Riff.CC." + >}} + {{< card title="Roniel Contreras" + tag="Ingenieur principal" + subtitle="Roniel travaille sur la plateforme principale de Riff.CC ainsi que l'UI/UX de Flagship, et sur le developpement pour nos partenaires." + >}} + {{< card title="Gabriel Cruz" + tag="Ingenieur en systemes distribues" + subtitle="Gabriel travaille sur notre systeme de fichiers distribue et notre architecture P2P." + >}} + {{< card title="Peter Raven" + tag="Execution technique" + subtitle="Peter est consultant en execution technique. Il nous aide a nous assurer que nous *livrons*." + >}} + {{< card title="Ehab Fayez" + tag="Design et UX" + subtitle="Ehab est notre designer interne et expert UX. Il travaille sur l'apparence et l'experience de Riff.CC et des Lenses." + >}} + {{< card title="Kai Hamilton" + tag="Ingenieur automatisation" + subtitle="Kai travaille sur l'automatisation et les outils comme Dragonfly." + >}} +{{< /cards >}} diff --git a/content/docs/riff.cc/visiting-riff.fr.md b/content/docs/riff.cc/visiting-riff.fr.md new file mode 100644 index 0000000..b5464ed --- /dev/null +++ b/content/docs/riff.cc/visiting-riff.fr.md @@ -0,0 +1,12 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Visiter Riff.CC' +weight = 1 ++++ + +Vous pouvez visiter l'instantane de developpement actuel de Riff.CC sur notre site de developpement, [ftwc.xyz](https://ftwc.xyz). + +![Une capture d'ecran du site de developpement Riff.CC](/images/docs/riff.cc/home.png) + +Nous prevoyons de lancer la plateforme publique complete Riff.CC au quatrieme trimestre 2025. diff --git a/content/privacy.fr.md b/content/privacy.fr.md new file mode 100644 index 0000000..b594bcb --- /dev/null +++ b/content/privacy.fr.md @@ -0,0 +1,41 @@ ++++ +title = 'Confidentialité' +date = 2025-07-16T03:00:00Z +draft = false ++++ + +*Dernière mise à jour: 16 juillet 2025* + +## Version courte + +Nous ne collectons pas et ne vendons pas vos informations personnelles. Nous ne vous envoyons pas de spam. Nous respectons votre vie privée. + +## Ce que nous ne faisons pas + +- **Nous ne vous suivons pas** - Pas d'analytics, pas de cookies, pas de pixels de suivi +- **Nous ne vendons pas vos données** - Vos informations ne sont jamais vendues à des tiers +- **Nous ne vous spammons pas** - Nous vous contactons uniquement si vous le demandez explicitement +- **Nous ne vous profilons pas** - Pas d'analyse comportementale ni de publicité ciblée + +## Ce que nous faisons + +- **Collecte minimale de données** - Nous ne collectons que ce qui est nécessaire au fonctionnement du service +- **Infrastructure sécurisée** - Vos données sont protégées par des pratiques de sécurité conformes aux standards du secteur +- **Pratiques transparentes** - Nous sommes ouverts sur nos pratiques en matière de confidentialité + +## Vos droits + +Vous avez le droit de : +- Accéder à toutes les données que nous détenons à votre sujet +- Demander la suppression de vos données +- Refuser toute communication + +## Nous contacter + +Des questions sur cette politique de confidentialité ? Contactez-nous à privacy@riff.cc. + +
+ +--- + +*Cette politique peut évoluer. Nous informerons les utilisateurs de toute mise à jour importante.* diff --git a/content/projects.fr.md b/content/projects.fr.md new file mode 100644 index 0000000..152284e --- /dev/null +++ b/content/projects.fr.md @@ -0,0 +1,46 @@ ++++ +title = 'Projets' +date = 2025-01-13T12:00:00Z +draft = false ++++ + +## 📚 Flagship + +Notre plateforme de bibliothèque décentralisée qui permet aux communautés de construire et de maintenir leurs propres bibliothèques numériques inarrêtables. + +Durable + +[Essayer](https://ftwc.xyz) | [Code source](https://github.com/riffcc/flagship) | [Documentation](/docs/flagship) + +**Statut**: Développement actif, proche d'une bêta + +## 🛠️ Librarian + +Un ensemble d'outils pour gérer et organiser le contenu dans des bibliothèques décentralisées, afin de préserver et de rendre le savoir accessible. + +[Code source](https://github.com/riffcc/librarian) + +**Statut**: Développement actif, prototype précoce + +## 🎁 Showcase + +Une plateforme pour présenter le meilleur de votre travail et vous relier à une communauté de créateurs et de publics. + +**Statut**: Développement précoce + +## 🌌 Starmap + +Un outil d'exploration visuelle pour découvrir et parcourir le vaste paysage du contenu décentralisé. + +**Statut**: Phase de conception et d'exploration + +## Participer + +Tous nos projets sont open source et portés par la communauté. Voici comment contribuer : + +- **Développeurs**: Consultez notre [GitHub](https://github.com/riffcc) pour les issues ouvertes et les consignes de contribution +- **Bibliothécaires**: Aidez-nous à organiser et préserver le contenu +- **Créateurs**: Testez nos plateformes et donnez-nous votre avis +- **Tout le monde**: Faites connaître les bibliothèques et plateformes inarrêtables + +[Voir sur GitHub](https://github.com/riffcc) | [Rejoindre Discord](/contact) diff --git a/content/terms.fr.md b/content/terms.fr.md new file mode 100644 index 0000000..4232ee0 --- /dev/null +++ b/content/terms.fr.md @@ -0,0 +1,55 @@ ++++ +title = "Conditions d'utilisation" +date = 2025-07-16T03:00:00Z +draft = false ++++ + +*Dernière mise à jour: 16 juillet 2025* + +## Version courte + +Ne soyez pas odieux. N'envoyez pas de contenu illégal. Ne nuisez pas aux autres. Utilisez le service de manière responsable. + +## Contenu interdit + +Vous ne pouvez **PAS** téléverser, partager, faciliter, ni distribuer : + +- **Contenu abusif** - Tolérance zéro pour les contenus abusifs, y compris les contenus pédocriminels +- **Contenu piraté** - Aucune violation du droit d'auteur ni propriété intellectuelle volée +- **Comportement abusif** - Pas de harcèlement, de menaces, ni d'attaques ciblées +- **Discours haineux** - Aucun contenu raciste, sexiste ou discriminatoire +- **Malware** - N'envoyez pas de virus, de chevaux de Troie, ni de code malveillant +- **Spam** - Aucun message commercial non sollicité ni envoi massif +- **Tromperie** - N'envoyez pas de contenu trompeur et n'usurpez pas l'identité d'autrui + +## Vos responsabilités + +En utilisant ce service, vous acceptez de : + +- Respecter les autres et leur contenu +- Respecter toutes les lois applicables dans votre juridiction +- Assumer la responsabilité du contenu que vous téléversez +- Ne pas tenter d'endommager ou de perturber le service + +## Nos droits + +Nous nous réservons le droit de : + +- Supprimer tout contenu qui viole ces conditions +- Suspendre ou résilier des comptes en cas de violation +- Signaler les contenus illégaux aux autorités +- Modifier ces conditions avec un préavis raisonnable + +## Absence de garantie + +Ce service est fourni "tel quel", sans aucune garantie. Vous l'utilisez à vos propres risques. + +## Nous contacter + +Des questions sur ces conditions ? Contactez-nous à legal@riff.cc + +
+ +--- + +*En utilisant le service Riff.CC, vous acceptez ces conditions.*