diff --git a/content/_index.es.md b/content/_index.es.md new file mode 100644 index 0000000..dd73773 --- /dev/null +++ b/content/_index.es.md @@ -0,0 +1,106 @@ ++++ +draft = false +title = '' ++++ + +
+ Banner + +
+

Construye bibliotecas
+ y plataformas
+ cooperativas e imparables.

+
+ Explorar Riff.CC + Crear un Lens +
+
+ +
+
+

Bibliotecas, no castillos de arena.

+

Las bibliotecas tradicionales son como castillos de arena: se construyen con un propósito y luego la marea se las lleva.

+

Estamos construyendo bibliotecas permanentes, descentralizadas, sostenibles y diseñadas para durar más que sus propios creadores.

+

Crea un Lens y construye una biblioteca.

+
+
+ Captura del sitio web de Riff.CC +
+
+ +
+
+

🌐 Descentralizado

+

Los Lenses están diseñados para distribuirse por todo el mundo y entregar contenido a tus usuarios a gran velocidad.

+ Descentralizado +
+ +
+

👥 Cooperativo

+

Puedes reflejar instantáneamente bibliotecas completas de contenido desde otros Lenses hacia el tuyo, y viceversa. A eso lo llamamos defederación.

+ Espejo +
+ +
+

♾️ Durable

+

Bibliotecas y plataformas diseñadas para perdurar. Usa nuestras herramientas para asegurarte de que tu contenido siga disponible durante generaciones.

+ Durable +
+
diff --git a/content/about.es.md b/content/about.es.md new file mode 100644 index 0000000..7f9272a --- /dev/null +++ b/content/about.es.md @@ -0,0 +1,29 @@ ++++ +title = 'Acerca de Riff.CC' +date = 2025-01-13T12:00:00Z +draft = false ++++ + +*"e cinere surgemus" (de las cenizas, nos levantamos)* + +Riff.CC está construyendo herramientas y plataformas para que los usuarios puedan crear y compartir contenido digital en espacios digitales permanentes y resilientes llamados Lenses. + +## ¿Qué es un Lens? +Un Lens es un espacio digital descentralizado y autoalojado, tu visión personal del mundo, que contiene medios, herramientas y contenido que puedes compartir o desarrollar junto con otras personas. Los Lenses pueden seguir a otros para sincronizar contenido al instante, haciendo posible una colaboración fluida y sin permisos. + +También está previsto el uso compartido privado, para que puedas controlar quién puede seguir tu Lens y acceder a él. + +Puedes aprender a [configurar un Lens](/docs/flagship/create-lens/) en nuestra [documentación](/docs). + +## Únete + +Tanto si eres desarrollador, creador, bibliotecario, como si simplemente crees en un internet libre y abierto, puedes ayudarnos a construir el futuro del contenido libre. + +Puedes [unirte a nuestra comunidad](https://discord.gg/cvYgQSfCrQ), consultar nuestra [documentación](/docs) o leer nuestro [código](https://github.com/riffcc). + +## Construye con nosotros +

Si quieres aprender cómo podrías usar el Lens SDK y las tecnologías Flagship de Riff.CC para construir tus propias aplicaciones, ya sean empresariales, de código abierto o personales, o si quieres saber qué podríamos construir para ti,

+ +escríbenos a [team@riff.cc](mailto:team@riff.cc) y hablaremos contigo sobre tus necesidades y cómo podemos ayudarte. + +Tanto si construyes las aplicaciones por tu cuenta como si quieres que las construyamos contigo, podemos ayudarte a adaptar el Lens SDK a casi cualquier caso de uso. diff --git a/content/contact.es.md b/content/contact.es.md new file mode 100644 index 0000000..ef95790 --- /dev/null +++ b/content/contact.es.md @@ -0,0 +1,14 @@ ++++ +title = 'Contáctanos' +draft = false ++++ + +Puedes escribirnos por correo electrónico a [team@riff.cc](mailto:team@riff.cc). + +Usamos Discord para la comunidad y para coordinar el desarrollo. + +Únete a nuestra comunidad en Discord en [https://discord.gg/cvYgQSfCrQ](https://discord.gg/cvYgQSfCrQ) y ven a saludar. + +Para alianzas y consultas comerciales, escribe a [wings@riff.cc](mailto:wings@riff.cc). + +Para consultas o reclamaciones relacionadas con derechos de autor, contacta con [dmca@riff.cc](mailto:dmca@riff.cc). diff --git a/content/docs/_index.es.md b/content/docs/_index.es.md new file mode 100644 index 0000000..8009a8e --- /dev/null +++ b/content/docs/_index.es.md @@ -0,0 +1,14 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Documentación' +weight = 1 ++++ + +¡Bienvenido a la documentación de Riff.CC! + +Te recomendamos empezar por [Flagship](/es/docs/flagship), el software que impulsa Riff.CC. + +También puedes leer sobre [Riff.CC](/es/docs/riff.cc), el servicio de streaming que te permite ver, compartir y curar contenido multimedia legalmente libre. + +Cuando estés listo, considera [crear tu propio Lens](/es/docs/flagship/create-lens). diff --git a/content/docs/concepts/_index.es.md b/content/docs/concepts/_index.es.md new file mode 100644 index 0000000..6d5267d --- /dev/null +++ b/content/docs/concepts/_index.es.md @@ -0,0 +1,39 @@ +--- +draft: false +title: 'Conceptos' +weight: 1 +sidebar: + open: true +--- + +Riff.CC se construye alrededor de varios conceptos clave que definen cómo funciona e interactúa con sus usuarios. Estos conceptos forman la base de nuestro servicio de streaming descentralizado y de nuestro modelo de biblioteca cooperativa. + +Puedes leer más sobre cada concepto en sus páginas dedicadas. + +## Creative Commons + +Riff.CC se centra en contenido multimedia legalmente libre, principalmente bajo licencias Creative Commons. Esto permite a los usuarios compartir, remezclar y construir sobre obras existentes respetando los derechos de sus creadores. También alojamos contenido de dominio público para garantizar una amplia gama de medios accesibles. + +Puedes leer más sobre la organización Creative Commons en [creativecommons.org](https://creativecommons.org/). + +## [Lenses](/es/docs/concepts/lenses/) + +Un Lens es una instancia individual de Flagship que actúa tanto como biblioteca como pasarela hacia la red más amplia. Cada Lens puede: + +- Alojar su propia colección de contenido +- Reflejar contenido desde otros Lenses +- Participar en la red federada +- Funcionar de manera independiente si hace falta + +Lee más sobre los Lenses y cómo crear el tuyo en la página [Lenses](/es/docs/concepts/lenses/). + +## [Federación descentralizada (Defederation)](/es/docs/concepts/defederation/) + +A diferencia de las plataformas centralizadas tradicionales, Flagship usa un modelo de federación donde: + +- No existe un único punto de fallo +- El contenido se distribuye entre múltiples nodos +- Cada Lens mantiene su autonomía mientras comparte recursos +- La red se vuelve más fuerte con cada nuevo participante + +Llamamos a esto Defederation, porque los Lenses deben optar explícitamente por federarse entre sí. Puedes leer más en la página [Defederation](/es/docs/concepts/defederation/). diff --git a/content/docs/concepts/defederation.es.md b/content/docs/concepts/defederation.es.md new file mode 100644 index 0000000..4d3ea31 --- /dev/null +++ b/content/docs/concepts/defederation.es.md @@ -0,0 +1,25 @@ ++++ +draft = false +title = 'Defederation' +weight = 1 ++++ + +Defederation, o federación descentralizada, es nuestro sistema para gestionar redes descentralizadas de contenido y comunidades. + +Permite que los Lenses se sigan entre sí y repliquen instantáneamente todo el contenido de los Lenses seguidos. + +## Ejemplos +El sitio D podría construir su biblioteca siguiendo al sitio B, y por extensión al sitio C. El sitio D también puede tener contenido propio. + +Diagrama que muestra la arquitectura de Flagship +Diagrama que muestra la arquitectura de Flagship + +En este ejemplo, el sitio D tendría 9 piezas de contenido, y todas se mostrarían en una experiencia unificada, como si formaran parte de una sola biblioteca. + +## Detalles técnicos + +Peerbit se utiliza para sincronizar y federar entre Lenses, y es la tecnología central que hace esto posible. + +Nuestro Lens SDK amplía Peerbit para habilitar esta funcionalidad. + +Cada Lens obtiene su propio Site ID, que se usa tanto para identificarlo en la red como para permitir que otros Lenses lo sigan. diff --git a/content/docs/concepts/lenses.es.md b/content/docs/concepts/lenses.es.md new file mode 100644 index 0000000..0bfb47b --- /dev/null +++ b/content/docs/concepts/lenses.es.md @@ -0,0 +1,39 @@ ++++ +draft = false +title = 'Lenses' +weight = 2 ++++ + +Un Lens es una instancia individual de Flagship que actúa tanto como biblioteca como pasarela hacia la red más amplia. Cada Lens puede: + +- Alojar su propio contenido +- Seguir a otros Lenses +- Ser seguido por otros Lenses + +Así es como funciona. + +## Crear un Lens +Crear tu propio Lens es sencillo. Consiste en descargar y configurar el software Flagship. + +También ofrecemos una configuración Docker para empezar rápidamente. + +Visita la página [Crear un Lens](/es/docs/flagship/create-lens/) para obtener instrucciones detalladas. + +Una vez que hayas creado tu Lens, puedes compartir tu Site ID para que otras personas lo sigan. + +## Seguir Lenses +También puedes hacer que tu Lens siga a otros Lenses. + +Solo copia el Site ID del Lens que quieres seguir y ve a la sección *Admin* de tu Lens, luego a *Subscriptions*. + +Pega el Site ID del Lens que quieras seguir y haz clic en *Subscribe*. + +![Añadir una suscripción](/images/docs/concepts/follow-a-lens.png) + +Después de añadirlo, aparecerá en la lista de suscripciones. + +Una vez añadida la suscripción, el contenido del Lens seguido aparecerá en tu Lens. + +![Añadir una suscripción](/images/docs/concepts/follow-a-lens-2.png) + +Para dejar de seguir un Lens, simplemente haz clic en el icono de la papelera junto al Lens que quieras dejar de seguir. diff --git a/content/docs/concepts/threshold-funding.es.md b/content/docs/concepts/threshold-funding.es.md new file mode 100644 index 0000000..91c2b33 --- /dev/null +++ b/content/docs/concepts/threshold-funding.es.md @@ -0,0 +1,52 @@ ++++ +draft = false +title = 'Threshold Funding' ++++ + +Imagina esto: una banda quiere grabar un disco. Necesita 50 000 dólares para cubrir estudio, mezcla, masterización y producción. ¿Las opciones tradicionales? Ceder derechos a un sello, lanzar una campaña de crowdfunding y esperar que funcione, o endeudarse. + +Threshold funding ofrece una alternativa a ese dilema, permitiendo que los usuarios apoyen directamente a los artistas y reciban recompensas por hacerlo. + +## Cómo funciona + +La banda publica su proyecto como "próximamente" en Riff, compartiendo demos, grabaciones en vivo y su visión del álbum. Los fans pueden suscribirse al artista por 10 dólares al año. Aquí es donde se pone interesante: + +- Cuando suficientes personas se suscriben para alcanzar el umbral de 50 000 dólares, comienza la producción +- Quienes se suscribieron durante el período de financiación reciben automáticamente el álbum en alta calidad cuando se publica +- La banda conserva el control creativo total y la propiedad de la obra + +## El giro de los comunes + +Pero aquí está la parte revolucionaria: la banda se compromete a publicar automáticamente el disco bajo Creative Commons (no comercial) una vez que haya ganado 250 000 dólares con él. + +Eso significa: +- La banda sigue vendiendo en Riff después del umbral +- Una vez alcanzados los 250 000 dólares de ingresos totales, el álbum pasa a ser legalmente libre para uso no comercial +- La música entra en los comunes y enriquece nuestra cultura compartida +- La banda recibe una compensación justa por su trabajo y puede seguir vendiendo copias físicas y de colección, además de financiar futuros proyectos del mismo modo + +## Contribuciones a la plataforma + +Tanto artistas como fans pueden elegir apoyar a la plataforma mediante un control de contribución en su configuración. + +Esta contribución es **opcional** y **explícitamente voluntaria**. Por defecto, no tomamos ningún porcentaje de las ganancias. + +**Modelo de contribución de artistas:** +- Si 100 artistas recaudan 50 000 dólares al año cada uno: 50 millones de dólares en financiación para artistas +- Si el 5 % de los artistas establece una contribución del 5 % a la plataforma: 125 000 dólares de ingresos para la plataforma +- Esto podría sostener de forma duradera una comunidad de aproximadamente 1 a 2 millones de usuarios + +**Modelo de contribución de usuarios:** +- 1 millón de usuarios × 50 dólares de gasto anual promedio × 5 % para la plataforma × 5 % de participación = 125 000 dólares adicionales de ingresos para la plataforma +- Combinado con las contribuciones de artistas, la plataforma se vuelve plenamente sostenible incluso con niveles modestos de participación + +## Por qué funciona + +1. **Ganan los artistas**: financiación directa, control creativo y compensación justa +2. **Ganan los fans**: apoyan directamente a los artistas y obtienen acceso anticipado exclusivo +3. **Gana la cultura**: más música entra en los comunes con el tiempo +4. **Gana la plataforma**: ingresos sostenibles sin explotar a los creadores + +No se trata solo de financiar álbumes. Se trata de construir una economía donde el trabajo creativo se valore, donde los artistas reciban una compensación justa y donde la cultura termine siendo compartida. + +El modelo de threshold funding transforma el sistema tradicional de "todos los derechos reservados" en "todos los derechos reservados, luego algunos derechos reservados", garantizando tanto una compensación justa como un enriquecimiento cultural. diff --git a/content/docs/flagship/_index.es.md b/content/docs/flagship/_index.es.md new file mode 100644 index 0000000..c2da735 --- /dev/null +++ b/content/docs/flagship/_index.es.md @@ -0,0 +1,30 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Flagship' +weight = 5 ++++ + +Flagship es nuestra plataforma de biblioteca descentralizada que permite a las comunidades crear y mantener sus propias bibliotecas digitales imparables. + +Es una implementacion de prueba de concepto de una plataforma de medios descentralizada para ver, compartir, distribuir y curar contenido multimedia legalmente libre. + +Construida como una aplicacion Electron con capacidades de despliegue web, combina la experiencia de usuario de plataformas centralizadas como Netflix y YouTube con la arquitectura descentralizada de las redes peer-to-peer. + +El software permite a los usuarios: + +* Subir y compartir contenido multimedia (audio, video, libros y mas) +* Descubrir contenido mediante sistemas de categorizacion y contenido destacado +* Participar en una red federada de nodos que comparten contenido +* Autoalojar instancias manteniendo la conectividad con la red mas amplia + +## Vision general de la arquitectura del sistema + +Flagship implementa una arquitectura hibrida que puede funcionar tanto como aplicacion de escritorio Electron como aplicacion web, construida sobre una base de tecnologias de red peer-to-peer. + +Un diagrama que muestra la arquitectura de Flagship +Un diagrama que muestra la arquitectura de Flagship + +## Creditos: +* Colaboradores de Riff.CC, pasados y presentes. +* Parte de la informacion fue generada por DeepWiki (ver [https://deepwiki.com/riffcc/flagship](https://deepwiki.com/riffcc/flagship)). Gracias a Cognition por ofrecer un servicio excelente. diff --git a/content/docs/flagship/create-lens.es.md b/content/docs/flagship/create-lens.es.md new file mode 100644 index 0000000..4c63429 --- /dev/null +++ b/content/docs/flagship/create-lens.es.md @@ -0,0 +1,323 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Crear una Lens (Inicio rapido)' +weight = 2 ++++ + +Para crear tu propia Lens, necesitaras un nombre de dominio (tambien puede servir un subdominio) y un proveedor de alojamiento. + +El proceso es sencillo y suele tardar entre 10 y 30 minutos, segun tu comodidad con la linea de comandos. + +{{< callout type="info"emoji="🌐" >}} + Planeamos ofrecer mas adelante servicios de alojamiento Lens asequibles. + + Tambien vamos a liberar como codigo abierto el software para que cualquiera pueda operar su propio proveedor de alojamiento Lens. +{{< /callout >}} + +Sugerimos usar Hetzner o DigitalOcean, pero practicamente cualquier proveedor funcionara. + +Tambien puedes autoalojar tu propia Lens, pero necesitaras sentirte comodo con la linea de comandos y tener una comprension basica de como configurar un servidor. + +## Configurar tu dominio + +Haz que tu dominio o subdominio apunte a la direccion IP de tu servidor mediante un registro DNS `A` o `AAAA`. + +Puedes consultar a tu proveedor de hosting para saber como hacerlo, o pedirnos ayuda. + +## Preparacion + +Necesitaras hacer un poco de trabajo previo antes de empezar. + +### Dependencias +Antes de instalar Flagship, debes instalar las siguientes dependencias: + +```sh +sudo apt install libnss3-dev libgtk-3-0 libgbm1 libasound2-dev libatk1.0-0 node-pre-gyp git curl +``` + +### Node.js + +Tambien necesitaras instalar Node.js. + +Te sugerimos usar la [guia de instalacion de NodeSource](https://github.com/nodesource/distributions#installation-instructions). + +1. Descarga e importa la clave 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. Crea el repositorio 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. Ejecuta `apt update` e instala el paquete Node.js + +```sh +sudo apt-get update +sudo apt-get install nodejs -y +``` + +4. Descarga el script oficial de instalacion de pnpm: + +```sh +curl -fsSL https://get.pnpm.io/install.sh | sh - +``` + +5. Recarga tu archivo `.bashrc` para que el sistema reconozca correctamente la ruta de pnpm (o `zshrc` para usuarios de Zsh, etc.): + +```sh +source ~/.bashrc +``` + +### Git + +Necesitaras instalar Git. La mayoria de los sistemas ya lo incluyen, pero si no es asi puedes instalarlo con: + +```sh +sudo apt-get install git -y +``` + +## Instalar el nodo Lens + +Usa `pnpm` para instalar el nodo Lens. + +```sh +pnpm install -g @riffcc/lens-node +``` + +Si se te solicita, ejecuta tambien `pnpm approve-builds -g` para permitir que las dependencias se compilen correctamente. + +``` +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 +``` + +## Configurar tu Lens + +1. **Configura tu nodo Lens:** + El primer paso es inicializar tu nodo. Esto creara un directorio de datos, generara las identidades criptograficas necesarias y creara un archivo de configuracion. + + ```bash + lens-node setup + ``` + + Este comando: + - crea un directorio en `~/.lens-node` (o una ruta personalizada si especificas `--dir`); + - si el directorio ya existe, te pedira que confirmes la reconfiguracion; + - inicializa un cliente Peerbit y un sitio Lens; + - guarda la configuracion, incluida la direccion del sitio Lens, en `config.json` dentro del directorio de datos; + - muestra detalles importantes como tu Peer ID, tu clave publica y la direccion del sitio. + + {{< callout emoji="🐉" >}} + Puede que veas una advertencia sobre "The node directory \"/home/$USER/.lens-node\" already exists" incluso si nunca has creado una Lens antes. + + Es un error del nodo Lens y se puede ignorar con seguridad al crear una Lens por *primera* vez. Se corregira en una version futura. + + Simplemente responde "Yes" al mensaje y la configuracion continuara. + {{< /callout >}} + + Aqui tienes un ejemplo de la salida: + + ``` + 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 + ``` + + Guarda la direccion del sitio, porque la necesitaras mas adelante. Siempre puedes encontrarla en `~/.lens-node/config.json` si la olvidas. + +2. **Inicia tu nodo Lens:** + Para arrancar tu nodo, ejecuta: + + ```bash + lens-node run + ``` + + Esto iniciara el daemon del nodo, se conectara a la red Peerbit y abrira tu sitio Lens. Se abrira un terminal interactivo y podras usarlo para administrar tu nodo. + + Sugerimos ejecutar el nodo dentro de una sesion `screen` o `tmux`, para que siga funcionando en segundo plano si cierras el terminal. + + Copia la direccion de escucha `ws` para usarla mas adelante, por ejemplo `/ip4/127.0.0.1/tcp/8002/ws/p2p/12D3KooWAo2AC2Aga6gxon6Fd8jXMoxRtBkQrBBK3hsuQs3wtnNT`. + +## Instalar Flagship + +1. Clona el repositorio de GitHub de Flagship: + ```sh + git clone https://github.com/riffcc/flagship.git + ``` + +2. Entra en el directorio de Flagship e instala sus dependencias: + ```sh + cd flagship + pnpm install + ``` + +3. Copia el archivo `.env.example` a `.env`: + ```sh + cp .env.example .env + ``` + +4. Edita el archivo `.env` para establecer `VITE_SITE_ADDRESS` con la direccion del sitio que guardaste antes. Establece `VITE_BOOTSTRAPPERS` con la direccion de escucha `ws` que copiaste antes. + +5. Ejecuta la aplicacion en modo desarrollo (con hot reloading): + ```sh + pnpm watch:web + ``` + +6. Visita la aplicacion en tu navegador en `http://localhost:5175/#/account`. + +7. Ahora deberias ver la aplicacion Flagship. + + ![Aplicacion Flagship](/images/docs/flagship/installing-flagship-account.png) + + {{< callout emoji="🐉" >}} + Puedes ignorar con seguridad la advertencia "Not implemented" al pie de la pagina. + {{< /callout >}} + +8. Haz clic en la clave publica bajo el encabezado "Public Key" para copiarla al portapapeles. + +## Crear una cuenta de administrador + +En el servidor que aloja tu Lens, ve a la accion ` > 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 +``` + +Pulsa Intro y pega la clave publica que copiaste antes: + +``` +✔ Actions: Authorise an account +✔ Enter the string public key of the account: ed25119p/1a1b2a241f1734f6088fa4715bc763f448dbbf0d1ab8c100a959dec765ba5a58 +? Select the account type (Use arrow keys) +❯ Member + Admin +``` + +Selecciona "Admin" con las flechas y luego pulsa Intro. + +Deberias ver un mensaje de exito: +``` +2025-07-15 23:13:41.822 [info] Account authorized successfully +{ + "publicKey": "ed25119p/1a1b2a241f1734f6088fa4715bc763f448dbbf0d1ab8c100a959dec765ba5a58", + "accountType": "Admin" +} +``` + +Actualiza la aplicacion Flagship en tu navegador. Ahora deberias ser "Admin" y ver la pestana "Admin". + +## Administrar tu Lens +### Anadir contenido a tu Lens + +Es hora de subir tu primera pieza de contenido. Como ejemplo, subiremos la pelicula **RiP: A Remix Manifesto**, un documental legalmente libre sobre la cultura del remix. + +1. Haz clic en el boton "Upload" del menu superior. +2. Introduce un nombre, como "RiP: A Remix Manifesto". +3. Introduce un CID de contenido; en este caso `QmTWWUmvC9txvE7aHs9xHd541qLx3ax58urvx3Kb3SFK2Q`. +4. Selecciona la categoria "Movies". +5. Establece el CID de miniatura en `Qmb3eeESRoX5L6NhTYLEtFFUS1FZgqe1e7hdBk2f57DUGh`. +6. Haz clic en el boton "Upload". + +Ahora deberias ver la pelicula en tu Lens si vas a la pestana "Movies". + +### Destacar contenido + +Puedes destacar contenido para que aparezca en la pagina principal de tu Lens. + +1. Haz clic en la pestana "Admin" del menu superior. +2. Haz clic en la pestana "Content" del menu lateral del panel de administracion. +3. Haz clic en el boton "Feature" junto a la pelicula que subiste (la estrella con un signo mas). + +Iras a la pagina *New Featured Releases*. + +El control "Promoted" estara en "Yes" por defecto. El contenido promocionado aparecera en el hero slider de la portada, mientras que el contenido solo destacado seguira apareciendo en la portada pero con menos protagonismo. + +4. Haz clic en el boton "Create" para crear la entrada destacada. + +Ahora deberias ver la pelicula en la pagina principal de tu Lens. + +![Portada de una Lens](/images/docs/flagship/frontpage-generic.png) + +### Anadir detalles a una publicacion destacada + +{{< callout emoji="🚧" >}} +Esta seccion esta en construccion. +{{< /callout >}} + +Puedes anadir mas detalles a la publicacion destacada haciendo clic en el boton "Edit" junto a la entrada destacada y luego en la pestana "Advanced". + +Esto te permitira anadir una descripcion, etiquetas y otros detalles a la publicacion destacada. + +Tambien puedes anadir una imagen de banner para que se muestre en lugar del CID de miniatura cuando la publicacion se promocione en el hero slider. + +## Siguientes pasos + +### Unete a nuestra comunidad + +Tenemos un servidor de Discord donde puedes hacer preguntas, compartir tu Lens y recibir ayuda de la comunidad. + +[Unete a nuestro servidor de Discord](https://discord.gg/cvYgQSfCrQ) + +### Seguir una Lens (Opcional) + +Una de las mejores partes de gestionar una Lens es poder seguir otras Lenses y ver su contenido. + +Solo copia el Site ID de la Lens que quieras seguir y ve a la seccion *Admin* de tu Lens, luego a *Subscriptions*. + +Pega el Site ID de la Lens que quieras seguir y haz clic en *Subscribe*. + +{{< callout type="info" emoji="ℹ️" >}} +El Site ID de la Lens actual de Riff.CC es `zb2rhoGguxQaNZy47DvRPLRmpT84mwvwuvekUhmCgF7nkhTCn`, por si quieres algo que seguir. +{{< /callout >}} + +![Anadir una suscripcion](/images/docs/concepts/follow-a-lens.png) + +Despues de anadirla, la veras aparecer en la lista de suscripciones. + +Una vez anadida la suscripcion, el contenido de la Lens seguida aparecera en tu Lens. + +![Anadir una suscripcion](/images/docs/concepts/follow-a-lens-2.png) + +Para dejar de seguir una Lens, solo haz clic en el icono de papelera junto a la Lens que quieras dejar de seguir. diff --git a/content/docs/flagship/introduction.es.md b/content/docs/flagship/introduction.es.md new file mode 100644 index 0000000..3f41547 --- /dev/null +++ b/content/docs/flagship/introduction.es.md @@ -0,0 +1,16 @@ ++++ +title = 'Introduccion' +weight = 1 ++++ + +Flagship es la implementacion de referencia de una biblioteca imparable: una plataforma descentralizada para compartir y preservar contenido digital que no puede ser censurado ni apagado. + +Como cada Lens puede ser replicada o reflejada por cualquier numero de otras Lenses, Flagship ofrece una forma autorreparable y resistente a la censura de publicar y compartir. La perdida de una Lens individual no afecta la disponibilidad del contenido que contiene, siempre que otras comunidades conserven copias. + +Ofrece una interfaz web (y mas adelante aplicaciones Electron para escritorio y movil) para crear, administrar y compartir tu propia Lens, una instancia de Flagship que puede reflejar contenido de otras Lenses y participar en la red de federacion descentralizada. + +## Primeros pasos + +¿Listo para crear tu propia biblioteca imparable? Consulta: + +- [Crear una Lens](/es/docs/flagship/create-lens) - Guia de inicio rapido para lanzar tu primera Lens diff --git a/content/docs/flagship/production-setup.es.md b/content/docs/flagship/production-setup.es.md new file mode 100644 index 0000000..c165705 --- /dev/null +++ b/content/docs/flagship/production-setup.es.md @@ -0,0 +1,364 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Configuracion de produccion' +weight = 3 ++++ + +### **Produccion: desplegar una instancia de Flagship con un nodo Lens** + +Esta guia te llevara paso a paso por el despliegue de una instancia de Flagship lista para produccion, incluida la configuracion de un servidor, DNS, SSL y la ejecucion del nodo Lens en una sesion persistente de terminal. + +### **Requisitos previos** + +* Una instancia de servidor (por ejemplo, AWS EC2 o DigitalOcean Droplet) con una distribucion Linux moderna como Ubuntu 22.04. + * **Especificaciones recomendadas:** 2 o mas nucleos de CPU, 4 GB o mas de RAM. +* Un nombre de dominio registrado (por ejemplo, `your-domain.com`). +* Acceso al panel de gestion DNS de tu dominio. +* El siguiente software instalado en tu servidor: + * [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`) + +--- + +### **Parte 1: configuracion del servidor y del dominio** + +Esta seccion cubre la configuracion inicial del servidor, DNS y certificados SSL. + +#### **Paso 1: apuntar tu dominio al servidor** + +En el panel de control de tu proveedor DNS, crea dos registros `A` que apunten a la IP publica de tu servidor: + +1. Un registro `A` para tu dominio principal: + * **Tipo:** `A` + * **Nombre/Host:** `@` (o `your-domain.com`) + * **Valor/Apunta a:** `your-server-ip` + +2. Un registro `A` para el subdominio del nodo Lens: + * **Tipo:** `A` + * **Nombre/Host:** `lens` + * **Valor/Apunta a:** `your-server-ip` + +> **Nota:** los cambios DNS pueden tardar un poco en propagarse. + +#### **Paso 2: instalar Nginx y obtener certificados SSL** + +1. **Instala Nginx y Certbot:** + ```bash + sudo apt update + sudo apt install nginx certbot python3-certbot-nginx + ``` + +2. **Obtén los certificados SSL.** Usaremos Certbot para obtener certificados para ambos dominios. Este comando detendra temporalmente Nginx para liberar el puerto 80 durante la validacion. + ```bash + sudo systemctl stop nginx + sudo certbot certonly --standalone -d your-domain.com -d lens.your-domain.com + ``` + Sigue las indicaciones para completar el proceso. Al terminar, Certbot habra creado tus archivos de certificado. + +#### **Paso 3: configurar Nginx** + +Ahora crearemos los archivos de configuracion de Nginx para servir tu sitio Flagship y hacer proxy de las peticiones al nodo Lens. + +1. **Crea la configuracion Nginx para tu sitio principal de Flagship:** + ```bash + sudo nano /etc/nginx/sites-available/your-domain.com + ``` + Pega lo siguiente, sustituyendo `your-domain.com` por tu dominio real: + ```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. **Crea el directorio raiz web para el sitio Flagship:** + ```bash + sudo mkdir -p /var/www/your-domain.com/html + ``` + +3. **Crea la configuracion Nginx para el subdominio del nodo Lens:** + ```bash + sudo nano /etc/nginx/sites-available/lens.your-domain.com + ``` + Pega en el archivo todo el bloque de configuracion de abajo. + + > **IMPORTANTE:** debes sustituir cada instancia de **`$YOUR_SUBDOMAIN`** por tu subdominio real (por ejemplo `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. **Activa ambos sitios creando enlaces simbolicos:** + ```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. **Prueba tu configuracion de Nginx y reinicia el servicio:** + ```bash + sudo nginx -t + sudo systemctl restart nginx + ``` + +--- + +### **Parte 2: configurar y ejecutar el nodo Lens** + +Usaremos `screen` para ejecutar el proceso del nodo Lens en segundo plano, permitiendo que siga funcionando incluso despues de cerrar tu sesion SSH. + +1. **Instala globalmente el nodo Lens:** + ```bash + pnpm install -g @riffcc/lens-node + ``` + +2. **Ejecuta el proceso de configuracion inicial:** + ```bash + lens-node setup + ``` + +3. **Inicia una nueva sesion `screen`:** + ```bash + screen -S lens-node + ``` + Tu terminal se limpiara y ahora estaras dentro de una nueva sesion virtual llamada `lens-node`. + +4. **Inicia el nodo dentro de la sesion screen.** Sustituye `lens.your-domain.com` por tu subdominio real. + ```bash + lens-node run --domain lens.your-domain.com --relay + ``` + +5. Una vez en marcha, veras una salida parecida a esta. **Toma nota de tu `Site Address` y de la direccion `Listening on` que contiene `/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. **Desacoplate de la sesion screen** dejando el nodo en ejecucion. Pulsa **`Ctrl+A`** y luego **`D`**. + +Ahora tienes un nodo Lens funcionando correctamente en segundo plano. + +> **Para administrar el nodo:** +> * **Vuelve a adjuntarte a la sesion** para ver logs o detener el proceso: `screen -r lens-node` +> * **Para detener el nodo**, vuelve a adjuntarte y pulsa `Ctrl+C`. +> * **Advertencia:** este metodo no sobrevive a un reinicio del servidor. Tendras que reiniciar manualmente el nodo en una nueva sesion `screen` si el servidor se reinicia. + +--- + +### **Parte 3: desplegar la instancia de Flagship** + +Por ultimo, configura, compila y despliega la aplicacion frontend de Flagship. + +1. **Clona el repositorio y entra en el directorio:** + ```bash + git clone https://github.com/riffcc/flagship + cd flagship + ``` + +2. **Crea el archivo de entorno:** + ```bash + cp .env.example .env + ``` + +3. **Configura las variables de entorno.** Abre el archivo `.env` y establece las siguientes variables usando los valores de tu nodo Lens en ejecucion: + + ```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. **Instala las dependencias y compila la aplicacion:** + ```bash + pnpm install + pnpm compile:web + ``` + +5. **Despliega los archivos compilados en la raiz web de Nginx.** + ```bash + sudo cp -r packages/renderer/dist/web/* /var/www/your-domain.com/html/ + ``` + +6. **Establece la propiedad correcta para los archivos web:** + ```bash + sudo chown -R www-data:www-data /var/www/your-domain.com/html + ``` + +Tu instancia de Flagship ya esta en linea. Puedes acceder a ella navegando a `https://your-domain.com` en tu navegador. diff --git a/content/docs/lens-sdk/_index.es.md b/content/docs/lens-sdk/_index.es.md new file mode 100644 index 0000000..0d96aad --- /dev/null +++ b/content/docs/lens-sdk/_index.es.md @@ -0,0 +1,57 @@ +--- +date: '2025-07-22T04:50:31+02:00' +draft: false +title: 'SDK de Lens' +sidebar: + open: true +--- + +## Resumen + +El SDK de Lens es un kit de desarrollo de software completo, robusto y preparado para entornos empresariales, disenado para crear redes sofisticadas de distribucion de contenido y federacion descentralizada. Aprovechando la potencia del framework P2P Peerbit, el SDK de Lens proporciona una arquitectura completa por capas para construir aplicaciones de contenido soberanas, interoperables y resilientes. + +Este SDK esta pensado para desarrolladores y organizaciones que buscan crear aplicaciones donde la integridad de los datos, la propiedad por parte de las personas usuarias y la colaboracion descentralizada sean fundamentales. Abstrae la complejidad de las redes peer-to-peer, la sincronizacion de bases de datos y la identidad criptografica, ofreciendo una API limpia y de alto nivel para un desarrollo rapido y seguro. + +## Filosofia central + +El diseno del SDK de Lens esta guiado por varios principios fundamentales: + +1. **Soberania de los datos:** las personas usuarias y las comunidades mantienen el control ultimo sobre sus propios datos y espacios digitales. Cada instancia del programa `Site` es una entidad soberana, gobernada por sus propias reglas y administradores. + +2. **Federacion estructurada:** la comunicacion entre aplicaciones no es arbitraria. Es un proceso estructurado y autorizado basado en "subscriptions" explicitas. Este modelo garantiza que el intercambio de datos sea intencional y seguro, evita la inyeccion de datos no solicitados y crea una red basada en la confianza. + +3. **Arquitectura modular y por capas:** el SDK impone una separacion estricta de responsabilidades, desde la logica P2P de bajo nivel hasta la API de servicio de alto nivel. Este diseno por capas mejora la seguridad, simplifica el mantenimiento y promueve practicas de desarrollo escalables. + +4. **Procedencia verificable:** todos los datos creados y compartidos a traves de la red se firman criptograficamente y quedan marcados con la direccion de su `Site` de origen. Esto proporciona un rastro de auditoria inmutable y verificable para todo el contenido, garantizando que su autenticidad pueda confirmarse siempre. + +## Funcionalidades clave + +* **Aplicacion descentralizada lista para usar (programa `Site`):** el SDK incluye un programa P2P potente y completo, `Site`. Ofrece compatibilidad inmediata con publicaciones de contenido, categorias, elementos destacados y herramientas de moderacion. + +* **Control de acceso flexible basado en roles (RBAC):** un sistema de permisos sofisticado, seguro y extensible. Proporciona una jerarquia clara de roles predeterminados (`Admin`, `Moderator`, `Member`) y permite crear roles personalizados con permisos granulares para controlar con precision la creacion de contenido, su gestion y la administracion del sitio. + +* **Federacion y sincronizacion automatizadas:** un `FederationManager` sofisticado se encarga de todos los aspectos de la comunicacion entre sitios, incluidos: + * **Sincronizacion historica:** rellena automaticamente el contenido cuando se establece una nueva subscription. + * **Actualizaciones en vivo con pub/sub:** garantiza la sincronizacion en tiempo real entre sitios federados. + * **Gestion del estado de las conexiones:** gestiona de forma inteligente el ciclo de vida de las conexiones federadas, incluida la limpieza automatica de datos al cancelar una suscripcion. + +* **API de servicio de alto nivel (`LensService`):** una interfaz amigable para desarrolladores que sirve como punto de entrada unico para integrar aplicaciones. Proporciona una API estable basada en promesas que abstrae toda la complejidad P2P subyacente. + +* **Esquemas extensibles:** todas las estructuras de datos se definen mediante esquemas fuertemente tipados, lo que garantiza la coherencia e integridad de los datos en toda la red, manteniendose a la vez extensibles para necesidades futuras. + +## Quien deberia usar este SDK? + +El SDK de Lens es ideal para desarrolladores y organizaciones que construyen: + +* **Plataformas de contenido descentralizadas:** para creadores independientes, periodistas o artistas que necesitan herramientas de publicacion resistentes a la censura. +* **Foros y archivos propiedad de la comunidad:** donde las personas miembros contribuyen y gobiernan de forma colaborativa un repositorio compartido de conocimiento o datos. +* **Aplicaciones de redes sociales federadas:** aplicaciones que permiten a las personas usuarias ejecutar sus propios nodos mientras siguen participando en un grafo social mas amplio e interconectado. +* **Redes empresariales de intercambio de datos:** redes privadas y seguras para compartir datos versionados y artefactos entre socios corporativos de confianza. + +## Primeros pasos + +Para empezar a trabajar con el SDK de Lens, recomendamos revisar las siguientes secciones: + +1. **[Conceptos fundamentales](/es/docs/lens-sdk/core-concepts):** una explicacion detallada del programa `Site`, la federacion y los principios arquitectonicos del SDK. +2. **[Inicio rapido](/es/docs/lens-sdk/quick-start):** un tutorial paso a paso para poner en marcha una aplicacion basica. +3. **[Referencia de API](/es/docs/lens-sdk/api-reference):** documentacion completa de `LensService`, sus metodos y sus tipos de datos. diff --git a/content/docs/lens-sdk/advanced-topics.es.md b/content/docs/lens-sdk/advanced-topics.es.md new file mode 100644 index 0000000..ca2f3f9 --- /dev/null +++ b/content/docs/lens-sdk/advanced-topics.es.md @@ -0,0 +1,208 @@ ++++ +date = '2025-07-22T12:25:02+02:00' +draft = false +title = 'Temas avanzados' +weight = 3 ++++ + +Esta seccion cubre conceptos avanzados y buenas practicas para crear aplicaciones robustas, escalables y seguras con el SDK de Lens. Esta pensada para desarrolladores que ya estan familiarizados con los temas tratados en la guia de inicio rapido y en los conceptos fundamentales. + +### 1. Usar una cartera para la identidad de usuario + +La caracteristica mas potente para crear dApps con el SDK de Lens es la capacidad de utilizar una cartera externa, como MetaMask, como identidad de la persona usuaria. Esto permite que las personas usuarias firmen directamente todas sus acciones, garantizando que sean las verdaderas propietarias de su contenido. + +Para hacerlo, necesitas crear un objeto `Identity` compatible con Peerbit a partir de un firmante de `ethers.js`. + +#### Paso 1: anadir dependencias + +Necesitaras `ethers` para interactuar con carteras del navegador. + +```bash +pnpm install ethers +``` + +#### Paso 2: crear la identidad a partir de un firmante + +El SDK proporciona una funcion utilitaria, `createIdentityFromSigner`, para facilitar este paso. En una aplicacion de navegador, normalmente obtendrias el firmante desde el proveedor `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 +} +``` + +#### Paso 3: crear un sitio con la identidad de la cartera + +Si la persona usuaria es la primera en crear un `Site`, la clave publica de su cartera debe usarse como administracion raiz. Puedes pasar `walletIdentity.publicKey` directamente al constructor de `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}`); +``` + +Este patron es fundamental para crear aplicaciones no custodiales en las que las personas usuarias tienen control total. + +### 2. Gestionar externamente el cliente Peerbit + +En algunas aplicaciones complejas, puede que necesites gestionar por tu cuenta el ciclo de vida del cliente P2P Peerbit, especialmente si tu aplicacion usa otros programas Peerbit ademas del programa `Site`. + +El constructor de `LensService` acepta opcionalmente una instancia cliente `peerbit`. Cuando se proporciona un cliente de esta forma, el servicio no intentara gestionar su ciclo de vida. + +**Caso de uso:** tu aplicacion necesita ejecutar un programa `Site` y un programa personalizado `Chat` en el mismo nodo 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. Personalizar la replicacion (`SiteArgs`) + +Por defecto, un programa `Site` intenta replicar sus almacenes de datos con un factor de replicacion bajo para ahorrar recursos. En aplicaciones que requieren mayor disponibilidad o mejor rendimiento, puedes proporcionar argumentos de replicacion personalizados al abrir un sitio. + +El objeto `SiteArgs` te permite especificar opciones `replicate` para cada almacen de datos dentro del `Site`. + +**Caso de uso:** estas ejecutando un nodo dedicado de "pinning" que debe almacenar una copia completa de todos los datos para ofrecer la maxima disponibilidad. + +```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 }); +``` + +Para conocer opciones detalladas de replicacion, consulta la documentacion de Peerbit sobre `ReplicationOptions`. + +### 4. Entender el rendimiento de la federacion + +`FederationManager` esta disenado para ser eficiente, pero en redes a gran escala resulta util comprender su comportamiento: + +* **Sincronizacion historica:** es la parte de la federacion que mas recursos consume. Cuando se suscribe un sitio con miles de releases, la sincronizacion inicial puede tardar tiempo y consumir ancho de banda. Este proceso se ejecuta en segundo plano y no bloquea otras operaciones. +* **Sincronizacion en vivo:** las actualizaciones en vivo mediante pub/sub son extremadamente ligeras. Un mensaje `FederationUpdate` solo contiene hashes criptograficos y metadatos de las entradas modificadas, no los datos completos, lo que hace que las actualizaciones en tiempo real sean muy rapidas. +* **Topologia de red:** el rendimiento de la federacion depende de la red libp2p subyacente. Para un rendimiento optimo, asegurate de que los nodos, especialmente aquellos que se federan con frecuencia entre si, esten bien conectados. Puedes usar `peerbit.dial()` para establecer conexiones manualmente si es necesario. + +### 5. Moderacion de contenido a nivel de produccion (`BlockedContent` y listas de denegacion) + +El SDK de Lens esta disenado con una potente arquitectura de moderacion de contenido que va mas alla del simple filtrado dentro de la aplicacion y se extiende hasta la infraestructura central. Esta seccion describe la vision completa, separando lo que ya esta disponible de las funciones que estan en curso o previstas para el futuro. + +#### Eliminaciones logicas frente a eliminaciones duras + +Es importante distinguir entre las dos formas de eliminar contenido: + +* **`deleteRelease()` (eliminacion logica):** esta es una funcion estandar. Cuando un administrador llama a `deleteRelease()`, elimina el documento `Release` de la base de datos del sitio. Es una eliminacion "suave" o logica dentro de la vista de la aplicacion. El archivo de datos subyacente en IPFS no se ve afectado de inmediato. + +* **`BlockedContent` (base para la eliminacion dura):** este esquema es la base de un proceso de "hard delete". Esta disenado para crear un registro permanente y verificable de que una pieza de contenido, identificada por su CID, debe purgarse no solo de la aplicacion, sino de toda la infraestructura de almacenamiento. + +#### El patron de moderacion "Bad Bits": estado actual y vision futura + +El patron recomendado para una moderacion robusta sigue los principios de formatos de listas de denegacion ya consolidados, como la denylist ["Bad Bits"](https://badbits.dwebops.pub/). + +Este es el flujo de trabajo, incluyendo el estado de cada componente: + +1. **Accion del administrador:** una persona administradora identifica una pieza de contenido por su IPFS CID que debe bloquearse. + +2. **Doble hash y creacion del registro (en progreso):** + * **Funcionamiento:** para proteger la privacidad, el CID original se **hashea dos veces**, por ejemplo SHA256(SHA256(CID)), antes de almacenarse. Esto evita que observadores casuales identifiquen directamente el contenido en la lista de bloqueo. + * **Estado:** los metodos de alto nivel de `LensService` para realizar esta accion, como `blockContent()`, estan **actualmente en desarrollo**. Esto proporcionara una forma simple y segura para que las personas administradoras anadan entradas al almacen `blockedContent` sin interactuar directamente con el programa. + +3. **Sincronizacion con la infraestructura (implementacion futura):** + * **Vision:** la vision a largo plazo es que un servicio backend de confianza, u "Operator", supervise el almacen `blockedContent` del `Site`. Este Operator generara un archivo de denylist estandar a partir de los hashes almacenados y lo distribuira a toda la infraestructura principal. + * **Estado:** la implementacion de este **servicio Operator esta prevista para el futuro**. Cuando este terminada, permitira que el almacen `blockedContent` actue como una fuente de verdad descentralizada capaz de indicar a nodos IPFS, clusters y CDN que se nieguen a servir y eliminen permanentemente el contenido bloqueado. + +#### Resumen de las funciones de moderacion + +| 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. | + +Esta hoja de ruta proporciona un camino claro desde las capacidades actuales hasta un sistema completo de moderacion de contenido de extremo a extremo que sea potente y al mismo tiempo respete la privacidad. + +### 6. Interaccion directa con el programa (para casos avanzados) + +Aunque `LensService` deberia cubrir el 99 % de las interacciones, puede haber casos raros en los que sea necesario interactuar directamente con el programa `Site`, por ejemplo en scripts administrativos del lado del servidor. + +La instancia activa del programa `Site` esta disponible en `lensService.siteProgram`. + +**Caso de uso:** un script necesita inspeccionar el estado de replicacion de bajo nivel de una base de datos concreta. + +```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'); +} +``` + +**Advertencia:** al omitir `LensService`, pierdes sus comprobaciones de seguridad, su gestion de errores y la estabilidad de su contrato de API. Esto solo debe hacerse si tienes una comprension profunda de Peerbit y de la logica interna del programa `Site`. diff --git a/content/docs/lens-sdk/api-reference.es.md b/content/docs/lens-sdk/api-reference.es.md new file mode 100644 index 0000000..037c6ee --- /dev/null +++ b/content/docs/lens-sdk/api-reference.es.md @@ -0,0 +1,357 @@ ++++ +date = '2025-07-22T05:45:03+02:00' +draft = false +title = 'Referencia de API' +weight = 5 ++++ + +Este documento proporciona una referencia detallada de la API publica del SDK de Lens, centrada principalmente en la clase `LensService`. `LensService` es el unico punto de entrada previsto para desarrolladores que construyen aplicaciones con el SDK. + +## `LensService` + +La clase `LensService` proporciona una interfaz asincrona y de alto nivel para todas las funcionalidades del SDK. Gestiona el cliente Peerbit, el ciclo de vida del programa `Site` y todas las operaciones orientadas a las personas usuarias. + +### Constructor + +```typescript +new LensService(options?: { + peerbit?: ProgramClient; + debug?: boolean; + customPrefix?: string; + identity?: Identity; +}) +``` + +Inicializa una nueva instancia del servicio. + +| Parameter | Type | Optional | Description | +|----------------|-----------------|:--------:|---------------------------------------------------------------------------------------------------------| +| `options` | `object` | **Yes** | Configuracion de la instancia del servicio. | +| `options.peerbit`| `ProgramClient` | **Yes** | Un cliente Peerbit gestionado externamente. Si se proporciona, `init()` y `stop()` no afectaran a su ciclo de vida. | +| `options.debug`| `boolean` | **Yes** | Activa el registro diagnostico detallado en la consola. El valor predeterminado es `false`. | +| `options.customPrefix`| `string` | **Yes** | Establece un prefijo personalizado para los mensajes de registro. El valor predeterminado es `'[LensService]'`. | +| `options.identity`| `Identity` | **Yes** | Una identidad personalizada centrada en la persona usuaria, por ejemplo procedente de una cartera, para todas las operaciones de firma. Si se omite, el servicio usa la identidad predeterminada del nodo Peerbit. | + +--- + +## Metodos de ciclo de vida + +Estos metodos controlan la conexion con la red Peerbit y con el programa `Site` activo. + +### `init()` + +```typescript +init(directory?: string): Promise +``` + +Inicializa y arranca un nuevo cliente Peerbit gestionado internamente. Este metodo debe llamarse antes de cualquier otra operacion si el servicio no se construyo con un cliente externo. + +| Parameter | Type | Optional | Description | +|-------------|----------|:--------:|--------------------------------------------------------------------------------------------| +| `directory` | `string` | **Yes** | Ruta del sistema de archivos para almacenar la identidad del peer y los datos. Si se omite, los datos se almacenan en memoria. | + +### `stop()` + +```typescript +stop(): Promise +``` + +Detiene el servicio de forma ordenada, cerrando el `Site` activo y deteniendo el cliente Peerbit si esta gestionado internamente. + +### `openSite()` + +```typescript +openSite( + siteOrAddress: Site | string, + options?: { siteArgs?: SiteArgs, federate?: boolean } +): Promise +``` + +Abre un programa `Site`, convirtiendolo en el contexto activo para todas las llamadas API posteriores. + +| Parameter | Type | Optional | Description | +|-------------------|---------------------|:--------:|------------------------------------------------------------------------------------------------------------| +| `siteOrAddress` | `Site \| string` | No | Para crear un nuevo `Site`, pasa una instancia `new Site(rootTrust)`. Para abrir uno existente, pasa su direccion. | +| `options` | `object` | **Yes** | Configuracion adicional. | +| `options.siteArgs`| `SiteArgs` | **Yes** | Configuracion avanzada para la replicacion de base de datos. | +| `options.federate`| `boolean` | **Yes** | Si es `true`, inicia `FederationManager` para ese sitio y gestiona las subscriptions. El valor predeterminado es `true`. | + +--- + +## Metodos de cuenta y estado + +Metodos para recuperar informacion sobre la persona usuaria actual. + +### `getAccountStatus()` + +```typescript +getAccountStatus(): Promise +``` + +Determina el estado completo de permisos de la **identidad activa** actual, ya sea una identidad personalizada de cartera o la identidad predeterminada del nodo, para el `Site` activo. Este es el metodo principal para obtener la informacion necesaria para renderizar una interfaz de usuario adaptada a sus capacidades. + +```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 +} +``` + +--- + +### Tipos de entrada de la API + +Para simplificar las interacciones, `LensService` utiliza dos patrones principales de entrada para crear y editar documentos. + +* **`AddInput`**: se utiliza para crear documentos nuevos, por ejemplo en `addRelease`. El tipo `AddInput` es simplemente un alias de `T`. Tu proporcionas solo las propiedades de datos principales del documento que quieres crear. `LensService` se encarga de anadir automaticamente los campos requeridos `id`, `postedBy` y `siteAddress`. + +* **`EditInput`**: se utiliza para actualizar documentos existentes, por ejemplo en `editRelease`. Este tipo es un alias de `T & ImmutableProps`. Debes proporcionar todos los datos del documento, incluidos `id`, `postedBy` y `siteAddress` del documento existente. El servicio comprobara que las propiedades inmutables, `postedBy` y `siteAddress`, no hayan cambiado. + +--- + +## Gestion de contenido (`Releases`) + +Metodos para crear y gestionar el tipo principal de contenido, `Release`. + +### `addRelease()` + +```typescript +addRelease(data: AddInput): Promise +``` + +Crea y guarda un nuevo documento `Release`. Requiere que la persona usuaria tenga un rol con el permiso `release:create`, por ejemplo `Member`, `Moderator` o `Admin`. + +| Parameter | Type | Description | +|-----------|---------------------|---------------------------------------------------------------------------------------------------------| +| `data` | `AddInput` | Un objeto con las propiedades de la release, como `name`, `categoryId`, etc. | + +### `editRelease()` + +```typescript +editRelease(data: EditInput): Promise +``` + +Actualiza una `Release` existente. El permiso requerido depende de la accion: + +* Una persona usuaria con el permiso `release:edit:own` puede editar una release en la que sea `postedBy`. +* Una persona usuaria con el permiso `release:edit:any` puede editar cualquier release. + +| Parameter | Type | Description | +|-----------|---------------------|-------------------------------------------------------------------------------------------------------------------------------------------| +| `data` | `EditInput` | Los datos completos de la `Release`, incluido el `id` del documento que se va a actualizar. El servicio rechazara la edicion si se modifican `postedBy` o `siteAddress`. | + +Actualiza una `Release` existente. El objeto `data` debe incluir el `id`. Requiere privilegios `ADMIN`. + +### `deleteRelease()` + +```typescript +deleteRelease(id: string): Promise +``` + +Elimina una `Release` por su identificador. Requiere el permiso `release:delete`, por ejemplo `Moderator` o `Admin`. + +### `getRelease()` + +```typescript +getRelease(id: string): Promise | undefined> +``` + +Recupera una sola `Release` por su identificador. + +### `getReleases()` + +```typescript +getReleases(options?: SearchOptions): Promise[]> +``` + +Recupera un array de documentos `Release`. + +--- + +## Gestion de contenido destacado + +Metodos para gestionar entradas `FeaturedRelease`. Estas operaciones requieren un rol con el permiso `featured:manage`, por ejemplo `Moderator` o `Admin`. + +### `addFeaturedRelease()` + +```typescript +addFeaturedRelease(data: AddInput): Promise +``` + +Crea una `FeaturedRelease` para destacar una `Release` existente. + +### `editFeaturedRelease()` + +```typescript +editFeaturedRelease(data: EditInput): Promise +``` + +Actualiza una `FeaturedRelease` existente. El `id` debe estar presente y las propiedades principales `postedBy` y `siteAddress` no pueden modificarse. + +### `deleteFeaturedRelease()` + +```typescript +deleteFeaturedRelease(id:string): Promise +``` + +Elimina una `FeaturedRelease` por su identificador. + +*(Los metodos `getFeaturedRelease` y `getFeaturedReleases` siguen el mismo patron que sus equivalentes de `Release`.)* + +--- + +## Gestion de categorias de contenido + +Metodos para gestionar documentos `ContentCategory`. Estas operaciones requieren un rol con el permiso `category:manage`, por ejemplo `Moderator` o `Admin`. + +### `addContentCategory()` + +```typescript +addContentCategory(data: AddInput): Promise +``` + +Crea una nueva `ContentCategory`. `categoryId` debe ser unico. + +### `editContentCategory()` + +```typescript +editContentCategory(data: EditInput): Promise +``` + +Actualiza una `ContentCategory` existente. El servicio rechazara la actualizacion si se modifican campos inmutables como `postedBy`, `siteAddress` o `categoryId`. + +### `deleteContentCategory()` + +```typescript +deleteContentCategory(id: string): Promise +``` + +Elimina una `ContentCategory` por su identificador. + +### `getContentCategory()` + +```typescript +getContentCategory(id: string): Promise | undefined> +``` + +Recupera una sola `ContentCategory` por su identificador. + +### `getContentCategories()` + +```typescript +getContentCategories(options?: SearchOptions): Promise[]> +``` + +Recupera un array de todos los documentos `ContentCategory`. + +--- + +## Gestion de federacion (`Subscription`) + +Metodos para gestionar relaciones de federacion. Estas operaciones requieren un rol con el permiso `subscription:manage`, por ejemplo `Moderator` o `Admin`. + +### `addSubscription()` + +```typescript +addSubscription(data: AddInput): Promise +``` + +Se suscribe a otro `Site`, iniciando la federacion. + +| Parameter | Type | Description | +|-----------|------------|-------------------------------------------------------------| +| `data` | `AddInput` | Objeto con las propiedades de la subscription. `SubscriptionData` es `{ to: string }`. | + +### `deleteSubscription()` + +```typescript +deleteSubscription(data: { id?: string; to?: string }): Promise +``` + +Cancela la suscripcion a un `Site`, detiene la federacion y purga su contenido. + +| Parameter | Type | Description | +|-----------|----------|----------------------------------------------------------------------| +| `data` | `object` | Objeto que contiene el `id` de la subscription o la direccion `to` del sitio objetivo que debe eliminarse. | + +### `getSubscriptions()` + +```typescript +getSubscriptions(options?: SearchOptions): Promise +``` + +Recupera una lista de todos los documentos `Subscription` actuales. + +## Gestion del control de acceso + +Metodos para gestionar permisos de personas usuarias en el `Site` activo. Estas operaciones son privilegiadas y **solo puede realizarlas un Administrator**. + +### `addAdmin()` + +```typescript +addAdmin(publicKey: string | PublicSignKey): Promise +``` + +Promociona a otra persona usuaria a Administrator completo, anadiendola al `TrustedNetwork` raiz del sitio. + +| Parameter | Type | Description | +|-------------|------------------------|------------------------------------------------------------| +| `publicKey` | `string \| PublicSignKey` | La clave publica de la persona usuaria que se va a promocionar. | + +### `assignRole()` + +```typescript +assignRole(publicKey: string | PublicSignKey, roleId: string): Promise +``` + +Asigna un rol especifico a una persona usuaria. + +| Parameter | Type | Description | +|-------------|------------------------|-----------------------------------------------------------------------------| +| `publicKey` | `string \| PublicSignKey` | La clave publica de la persona usuaria. | +| `roleId` | `string` | El identificador de cadena del rol que se va a asignar, por ejemplo `"member"` o `"moderator"`. | + +### `revokeRole()` + +```typescript +revokeRole(publicKey: string | PublicSignKey, roleId: string): Promise +``` + +Revoca un rol especifico a una persona usuaria. + +| Parameter | Type | Description | +|-------------|------------------------|-----------------------------------------------------------------------------| +| `publicKey` | `string \| PublicSignKey` | La clave publica de la persona usuaria. | +| `roleId` | `string` | El identificador de cadena del rol que se va a revocar. | + +## Objetos de respuesta comunes + +La mayoria de metodos de `LensService` devuelven uno de los siguientes objetos de respuesta estandarizados para garantizar un manejo coherente de errores y una retroalimentacion consistente. + +### `BaseResponse` + +El objeto de respuesta mas simple, que solo indica exito o fracaso. + +| Field | Type | Description | +|-----------|-----------|-------------------------------------------------------| +| `success` | `boolean` | `true` si la operacion fue exitosa; de lo contrario `false`. | +| `error` | `string` | Mensaje de error si `success` es `false`. | + +### `IdResponse` + +Amplia `BaseResponse` para incluir el identificador unico del documento afectado. + +| Field | Type | Description | +|-------|----------|-----------------------------------------------------------| +| `id` | `string` | El identificador unico del documento creado o modificado. | +| *(...inherits from `BaseResponse`)* | | | + +### `HashResponse` + +Amplia `IdResponse` para incluir tambien el hash criptografico de la entrada de log de la operacion, que puede usarse para verificacion. + +| Field | Type | Description | +|-------|----------|------------------------------------------------------| +| `hash`| `string` | El hash criptografico de la entrada subyacente del log P2P. | +| *(...inherits from `IdResponse`)* | | | diff --git a/content/docs/lens-sdk/core-concepts.es.md b/content/docs/lens-sdk/core-concepts.es.md new file mode 100644 index 0000000..d689ef1 --- /dev/null +++ b/content/docs/lens-sdk/core-concepts.es.md @@ -0,0 +1,101 @@ ++++ +date = '2025-07-22T05:44:53+02:00' +draft = false +title = 'Conceptos fundamentales' +weight = 2 ++++ + +El SDK de Lens esta disenado alrededor de un conjunto de componentes robustos e interoperables. Comprender bien estos conceptos fundamentales es esencial para aprovechar toda la potencia y seguridad del SDK. Este documento ofrece una vision detallada de los pilares fundacionales de la arquitectura Lens: `LensService`, el programa `Site`, el modelo de federacion y el sistema de control de acceso. + +## 1. La arquitectura por capas + +El SDK emplea una arquitectura estricta por capas para promover la modularidad, la seguridad y la mantenibilidad. Cada capa tiene una responsabilidad distinta y la comunicacion fluye verticalmente a traves de interfaces bien definidas. + +```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; + +``` + +* **Capa de servicio (`LensService`):** esta es la interfaz publica canonica del SDK. Es el unico punto de entrada para cualquier aplicacion consumidora. Su objetivo es proporcionar una API estable, de alto nivel y asincrona que abstrae completamente la complejidad de la red P2P subyacente y de la logica del programa. La capa de servicio se encarga de gestionar el ciclo de vida del cliente P2P y del programa `Site` activo. + +* **Capa de programa (programa `Site`):** este es el backend descentralizado "on-chain" de la aplicacion. El programa `Site` es un "smart contract" replicable y con estado que define los esquemas de datos, las bases de datos y las reglas inmutables que gobiernan el acceso a los datos. Es la fuente de verdad definitiva para todo el contenido y todos los permisos dentro de un `Site`. + +* **Capa de federacion (`FederationManager`):** este es un componente interno especializado gestionado por `LensService`. Orquesta toda la comunicacion entre programas. Mientras el programa `Site` define *que* datos existen, `FederationManager` define *como* se descubren, sincronizan y comparten esos datos entre distintas instancias de `Site`. + +* **Capa del framework P2P (Peerbit):** la capa fundacional que proporciona las primitivas necesarias para redes peer-to-peer, creacion de bases de datos, replicacion de datos e identidad criptografica. El SDK de Lens esta construido directamente sobre este framework robusto. + +## 2. El programa `Site`: una entidad digital soberana + +La construccion central del ecosistema Lens es el `Site`. Conceptualmente, un `Site` es un espacio digital soberano, direccionable y autocontenido. Funciona como una instancia de aplicacion descentralizada completa con sus propias bases de datos y su propio sistema de control de acceso. + +### Caracteristicas clave de un `Site` + +* **Direccion unica y verificable:** cada `Site` se identifica mediante una direccion criptografica permanente derivada de la clave publica de su propietario y de sus parametros iniciales. Esta direccion se utiliza para localizar, abrir e interactuar con el `Site` en la red. +* **Almacenes de datos estructurados:** un `Site` es una coleccion de almacenes de datos discretos y orientados a propositos concretos para `Releases`, `ContentCategories`, `Subscriptions` y mas. Este enfoque estructurado garantiza la integridad de los datos y una organizacion clara. +* **Permisos explicitos:** el acceso a un `Site` no es publico por defecto. Todos los permisos de escritura son concedidos explicitamente por un **Administrator** mediante un robusto sistema de control de acceso basado en roles (RBAC). + +## 3. El modelo de federacion: intercambio de datos con principios + +La federacion es el proceso mediante el cual instancias independientes de `Site` comparten datos. El SDK de Lens implementa un modelo basado en subscriptions para garantizar que todo intercambio de datos sea intencional y seguro. + +### El ciclo de vida de la federacion + +1. **Subscription explicita:** el proceso lo inicia una persona usuaria con permiso `subscription:manage`, normalmente un `Moderator` o un `Admin`. Para federarse, crea un registro `Subscription` que contiene la direccion del `Site` objetivo. Esta accion es una declaracion deliberada de confianza. + +2. **Sincronizacion de estado:** al crear una `Subscription`, `FederationManager` realiza dos tipos de sincronizacion: + * **Sincronizacion historica:** un proceso puntual que se conecta al `Site` remoto y replica su contenido publico existente, por ejemplo sus `Releases`. + * **Sincronizacion en vivo:** el gestor se suscribe al tema pub/sub dedicado del `Site` remoto, creando un canal persistente de comunicacion en tiempo real para actualizaciones inmediatas. + +3. **Procedencia de los datos:** todos los datos recibidos mediante federacion son inmutables y conservan la firma criptografica de su autor original y la direccion de su `Site` de origen. Esto garantiza que la fuente de todo contenido pueda verificarse. + +4. **Finalizacion del ciclo:** si se elimina una `Subscription`, `FederationManager` realiza una operacion de limpieza purgando de sus bases de datos locales todos los datos asociados al `Site` dado de baja. + +## 4. El sistema de control de acceso (RBAC) + +La seguridad es parte integral del programa `Site`. El sistema se basa en un modelo robusto y seguro de **Role-Based Access Control (RBAC)** gestionado por un `RoleBasedccessController` interno dedicado. Este controlador es la autoridad ultima para todas las acciones dentro de un `Site`. + +### Identidad y firma + +Toda accion que modifica un `Site`, como anadir una release o asignar un rol, debe firmarse criptograficamente. El SDK de Lens admite dos modelos de identidad: + +1. **Identidad predeterminada del nodo:** si inicializas `LensService` sin especificar una identidad personalizada, usara una identidad autogenerada vinculada al propio nodo Peerbit. Esto es adecuado para scripts del lado del servidor o nodos sin interfaz donde se desea una identidad unica y estable. + +2. **Identidad personalizada de cartera:** para aplicaciones orientadas a personas usuarias, el enfoque recomendado es proporcionar una identidad derivada de la cartera de la persona usuaria, por ejemplo MetaMask. Cuando instancias `LensService` con esta identidad personalizada, **todas las acciones posteriores se firman con la cartera de la persona usuaria**. Esto garantiza que la persona usuaria, y no el nodo de la aplicacion, sea la verdadera propietaria y autora de su contenido. Esta es la base de la soberania de datos en el SDK de Lens. + +### Los componentes de RBAC + +* **Administradores (`TrustedNetwork`):** en el nivel superior existe una `TrustedNetwork` de administradores. Cualquier persona cuya clave publica se encuentre en esta red se considera **Admin**. Los admins tienen permisos universales y son las unicas personas usuarias que pueden gestionar el propio sistema RBAC, por ejemplo crear nuevos roles, asignarlos a personas usuarias o anadir otros admins. La persona creadora inicial de un `Site` es su primer `Admin`. + +* **Roles:** un `Role` es una coleccion con nombre de permisos especificos. Un `Site` se inicializa con un conjunto de roles predeterminados y los admins pueden crear nuevos roles personalizados segun sea necesario. + +* **Permisos:** un `Permission` es una cadena granular que representa una accion especifica, normalmente con el formato `"resource:action"`, por ejemplo `"release:delete"`. + +* **Asignaciones:** una `Assignment` es un vinculo verificable entre la clave publica de una persona usuaria y un `Role`. Una persona usuaria obtiene permisos en virtud de los roles que se le asignan. + +### Tabla de roles y permisos predeterminados + +Un `Site` incluye un conjunto claro de roles predeterminados, lo que proporciona una estructura de permisos sensata desde el primer momento. Un **Admin** puede realizar todas las acciones enumeradas a continuacion. + +| Action / Permission (`resource:action`) | Moderator | Member | Guest | Description | +|-----------------------------------------|:---------:|:------:|:-----:|--------------------------------------------------------------------------| +| **`release:create`** | ✅ | ✅ | ❌ | Puede publicar nuevos documentos `Release`. | +| **`release:edit:own`** | ✅ | ✅ | ❌ | Puede editar los documentos `Release` que haya publicado personalmente. | +| **`release:edit:any`** | ✅ | ❌ | ❌ | Puede editar documentos `Release` publicados por *cualquier* persona usuaria del sitio. | +| **`release:delete`** | ✅ | ❌ | ❌ | Puede eliminar cualquier `Release` del sitio. | +| **`featured:manage`** | ✅ | ❌ | ❌ | Puede crear, editar o eliminar entradas `FeaturedRelease`. | +| **`category:manage`** | ✅ | ❌ | ❌ | Puede crear, editar o eliminar documentos `ContentCategory`. | +| **`blocklist:manage`** | ✅ | ❌ | ❌ | Puede crear o eliminar entradas `BlockedContent`. | +| **`subscription:manage`** | ✅ | ❌ | ❌ | Puede suscribirse a otros sitios o dejar de seguirlos. | + +* **Guest (rol implicito):** este es el estado predeterminado de cualquier persona usuaria que no sea admin ni tenga roles asignados. Los `Guests` tienen acceso de solo lectura y no pueden realizar operaciones de escritura. + +### Federacion y permisos + +El modelo RBAC se extiende de forma inteligente al contenido federado. Aunque la confianza se basa principalmente en la subscription, el SDK de Lens proporciona una capacidad de control local muy potente: **un `Admin` o `Moderator` local siempre puede actuar sobre contenido federado**, por ejemplo eliminar una publicacion obsoleta procedente de un sitio ya no suscrito. Esto garantiza que las personas propietarias del sitio local mantengan el control ultimo sobre el contenido almacenado en sus bases de datos. diff --git a/content/docs/lens-sdk/quick-start.es.md b/content/docs/lens-sdk/quick-start.es.md new file mode 100644 index 0000000..6b1bdd9 --- /dev/null +++ b/content/docs/lens-sdk/quick-start.es.md @@ -0,0 +1,128 @@ ++++ +date = '2025-07-22T12:22:36+02:00' +draft = false +title = 'Inicio rapido' +weight = 1 ++++ + +Esta guia ofrece un recorrido paso a paso para poner en marcha una aplicacion basica con el SDK de Lens. Al terminar, habras inicializado el servicio, creado un nuevo `Site`, llenado sus categorias de contenido predeterminadas, anadido contenido y recuperado ese contenido. + +### Requisitos previos + +* Node.js, se recomienda la version 18 o superior +* Un entorno de proyecto preparado para TypeScript + +### Paso 1: instalacion + +Primero, anade el SDK de Lens a las dependencias de tu proyecto. + +```bash +pnpm install @riffcc/lens-sdk +``` + +### Paso 2: inicializar `LensService` + +`LensService` es el punto de entrada principal para toda la funcionalidad del SDK. El primer paso consiste en crear una instancia e inicializar su cliente P2P subyacente. + +```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); +``` + +### Paso 3: crear y abrir un `Site` + +Un `Site` es tu centro de contenido descentralizado. Para crear uno nuevo, instancias el programa `Site` con tu clave publica como administracion raiz y luego pides al servicio que lo abra. + +```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}`); +``` + +> **Usar una identidad personalizada:** el ejemplo anterior utiliza la identidad predeterminada generada automaticamente para el nodo Peerbit. Para aplicaciones orientadas a personas usuarias, el enfoque recomendado es usar la propia cartera de la persona usuaria, como MetaMask, como identidad. Para aprender a implementarlo, consulta la seccion **Usar una cartera para la identidad de usuario** en nuestra [guia de temas avanzados](/es/docs/lens-sdk/advanced-topics/#1-using-a-wallet-for-user-identity). + +### Paso 4: inicializar las categorias de contenido del sitio + +Un `Site` nuevo esta vacio por defecto. Como administracion raiz, debes inicializarlo con un conjunto de documentos `ContentCategory`. Es una operacion unica que rellena el sitio con las plantillas necesarias para publicar contenido. + +```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."); +``` + +### Paso 5: anadir contenido (crear una `Release`) + +Ahora que el `Site` se ha inicializado con categorias, puedes anadir contenido. Vamos a anadir tu primera `Release`, vinculandola con la categoria predeterminada `"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}`); +} +``` + +### Paso 6: recuperar contenido + +Por ultimo, verifiquemos que el contenido se ha guardado recuperando todas las releases del sitio. + +```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}"`); +}); +``` + +Enhorabuena. Has creado correctamente un `Site` descentralizado, lo has inicializado, has gestionado permisos, has anadido contenido y lo has recuperado. A partir de aqui puedes explorar los [Conceptos fundamentales](./core-concepts) o consultar la [Referencia de API](./api-reference). diff --git a/content/docs/lens-sdk/site-reference.es.md b/content/docs/lens-sdk/site-reference.es.md new file mode 100644 index 0000000..bb533c6 --- /dev/null +++ b/content/docs/lens-sdk/site-reference.es.md @@ -0,0 +1,85 @@ ++++ +date = '2025-07-22T06:21:22+02:00' +draft = false +title = 'Referencia de Site' +weight = 4 ++++ + +### Esquemas + +Este documento proporciona una referencia detallada de los esquemas de datos que constituyen un programa `Site`. Comprender estos esquemas es fundamental para preparar los datos de las llamadas API y para interpretar los datos devueltos por `LensService`. + +Todos los objetos de datos enviados a `LensService` para su creacion o edicion deben ajustarse a las estructuras descritas a continuacion. + +#### Propiedades comunes de los documentos + +Aunque no existe una clase base rigida, la mayoria de los documentos comparten un conjunto de propiedades fundamentales. Al crear un nuevo elemento de contenido, como una `Release`, los campos `id`, `postedBy` y `siteAddress` son gestionados automaticamente por `LensService`. + +| Field | Type | Description | +|---------------|-------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `id` | `string` | Un identificador unico para el documento. Normalmente un UUID generado automaticamente al crearlo. Obligatorio al editar un documento existente. | +| `postedBy` | `PublicSignKey` or `Uint8Array` | La clave publica criptografica de la identidad asociada al documento. Al crear contenido, este campo se establece automaticamente con la persona usuaria actual salvo que se indique lo contrario. | +| `siteAddress` | `string` | La direccion unica del `Site` donde se creo originalmente este documento. Siempre la establece el servicio y es inmutable. | + +> **Nota sobre la inmutabilidad:** los campos `postedBy` y `siteAddress` se consideran inmutables. Una vez creado un documento, estos valores no pueden cambiarse mediante una operacion `edit`. El SDK aplica esta regla en la capa de servicio. + +--- + +#### 1. `Release` + +`Release` es el objeto principal de contenido. Representa un unico elemento publicable, como un album musical, un video o un articulo. + +| Field | Type | Required | Description | +|----------------|----------|:--------:|---------------------------------------------------------------------------| +| `name` | `string` | **Yes** | El titulo visible de la release. | +| `categoryId` | `string` | **Yes** | El `id` de la `ContentCategory` a la que pertenece esta release, por ejemplo `"music"`. | +| `contentCID` | `string` | **Yes** | El identificador de contenido IPFS, o CID, del archivo principal o archivos principales de esta release. | +| `thumbnailCID` | `string` | No | El CID de IPFS de una miniatura o imagen de portada asociada a la release. | +| `metadata` | `string` | No | Una cadena JSON que contiene metadatos adicionales especificos de la categoria. | + +#### 2. `ContentCategory` + +Una `ContentCategory` define una plantilla para un tipo de contenido, incluido el tipo de metadatos esperado. Normalmente las crea una persona administradora del `Site` o se inicializan a partir de un conjunto predeterminado. + +| Field | Type | Required | Description | +|----------------|----------|:--------:|---------------------------------------------------------------------------------------------------------------| +| `categoryId` | `string` | **Yes** | Un identificador unico y legible por humanos, por ejemplo `"movies"` o `"tv-shows"`. **Este campo es inmutable.** | +| `displayName` | `string` | **Yes** | El nombre legible por humanos de la categoria, por ejemplo `"TV Shows"`. | +| `featured` | `boolean`| No | Indica si esta categoria debe mostrarse de forma destacada. Su valor predeterminado es `false`. | +| `description` | `string` | No | Una breve explicacion del tipo de contenido que pertenece a esta categoria. | +| `metadataSchema`| `string` | No | Una cadena JSON que define la estructura del campo `metadata` para las `Releases` de esta categoria. Consulta [defaults.ts](https://github.com/riffcc/lens-sdk/blob/main/src/programs/site/defaults.ts) para ver ejemplos. | + +> **Nota sobre la inmutabilidad de `categoryId`:** el campo `categoryId` funciona como una "business key" estable. Una vez creada una categoria, este identificador no puede cambiarse para garantizar que todas las `Releases` enlazadas a ella sigan siendo validas. El SDK aplica esta regla. + +#### 3. `FeaturedRelease` + +Una `FeaturedRelease` actua como un "pin" o acceso directo a una `Release` existente, lo que permite destacarla. + +| Field | Type | Required | Description | +|-------------|-----------|:--------:|------------------------------------------------------------------------| +| `releaseId` | `string` | **Yes** | El `id` del documento `Release` que se esta destacando. | +| `startTime` | `string` | **Yes** | Una cadena de fecha y hora con formato ISO 8601 que indica cuando debe activarse el destacado. | +| `endTime` | `string` | **Yes** | Una cadena de fecha y hora con formato ISO 8601 que indica cuando debe caducar el destacado. | +| `promoted` | `boolean` | **Yes** | Un indicador para aplicar estilo o prioridad adicional en una seccion "promoted". | + +#### 4. `Subscription` + +Una `Subscription` representa una accion unilateral de "seguir", que constituye la base de la federacion. Cuando se crea una `Subscription`, `FederationManager` empieza a sincronizar el contenido del `Site` de destino. + +| Field | Type | Required | Description | +|---------------|----------|:--------:|-----------------------------------------------------------------------------------------------------------| +| `to` | `string` | **Yes** | La direccion unica completa del programa `Site` remoto al que se esta suscribiendo. | + +>Nota: el `id` de una subscription se genera de forma determinista a partir de una combinacion de las direcciones del sitio suscriptor y del sitio objetivo para evitar suscripciones duplicadas. + +#### 5. `BlockedContent` + +Un registro `BlockedContent` es una herramienta de moderacion utilizada por las personas administradoras del `Site` para ocultar contenido o impedir que se muestre. + +| Field | Type | Required | Description | +|-------|----------|:--------:|----------------------------------------------| +| `cid` | `string` | **Yes** | El CID de IPFS del contenido que se debe bloquear. | + +--- + +Esta referencia proporciona el detalle necesario para que las personas desarrolladoras den formato correctamente a los datos en todas las interacciones API. Para obtener informacion sobre como crear, recuperar o gestionar documentos mediante estos esquemas, consulta la [**Referencia de API**](/es/docs/lens-sdk/api-reference). diff --git a/content/docs/librarian/_index.es.md b/content/docs/librarian/_index.es.md new file mode 100644 index 0000000..06a0450 --- /dev/null +++ b/content/docs/librarian/_index.es.md @@ -0,0 +1,8 @@ +--- +date: '2025-07-07T15:37:53+01:00' +draft: true +title: 'Bibliotecario' +weight: 6 +sidebar: + open: true +--- diff --git a/content/docs/riff.cc/_index.es.md b/content/docs/riff.cc/_index.es.md new file mode 100644 index 0000000..0f8b467 --- /dev/null +++ b/content/docs/riff.cc/_index.es.md @@ -0,0 +1,21 @@ +--- +date: '2025-07-07T15:37:53+01:00' +draft: false +title: 'Riff.CC' +weight: 1 +sidebar: + open: true +--- + +> Libera la cultura del mundo +> para quienes la crean. + +Ofrecemos un servicio de streaming llamado Riff.CC que permite a los usuarios ver, compartir y curar contenido multimedia legalmente libre. + +Nuestra plataforma se basa en principios descentralizados, garantizando que el contenido siga siendo accesible y resistente frente a la censura. + +Es la primera biblioteca imparable, que permite a cualquiera reflejar su propia biblioteca a partir de la nuestra y compartirla con otras personas. Puedes aprender mas sobre las bibliotecas imparables leyendo sobre [Flagship](/es/docs/flagship), el software que impulsa Riff.CC. + +Tambien puedes gestionar tu propio servicio de streaming utilizando nuestro software de codigo abierto e incluso reflejar nuestra biblioteca en la tuya. + +Visita nuestro [sitio de desarrollo en vivo](https://ftwc.xyz) para hacerte una idea de lo que representa Riff.CC. diff --git a/content/docs/riff.cc/roadmap.es.md b/content/docs/riff.cc/roadmap.es.md new file mode 100644 index 0000000..13d2cb8 --- /dev/null +++ b/content/docs/riff.cc/roadmap.es.md @@ -0,0 +1,69 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Hoja de ruta' +weight = 2 ++++ + +Esto es lo que viene para Riff.CC: + +## 📅 2025 +{{% steps %}} + +### Agosto de 2025: beta publica + +Beta publica inicial de Riff.CC + +* Musica, peliculas, libros y audiolibros disponibles para streaming o descarga. +* Lenses autoalojadas para que los usuarios creen sus propias bibliotecas. + +### Septiembre de 2025: subidas de usuarios + +Anadir soporte para subidas directas de usuarios + +* Permitir que los usuarios suban su propio contenido directamente a Riff.CC +* Ver la replicacion de tus datos por la red en tiempo real + +### Octubre de 2025: paginas de artistas y albumes + +Paginas de artistas y funciones comunitarias + +* Paginas de artistas y albumes para mejorar el descubrimiento de contenido +* Funciones comunitarias para compartir y curar contenido + +### Noviembre de 2025: Lenses alojadas + +Lenses alojadas y servicios de respaldo para Lenses + +* Lanzar Lenses alojadas para usuarios que quieran crear bibliotecas sin autoalojarse +* Ofrecer servicios de respaldo para Lenses que quieran garantizar la continuidad y disponibilidad de su contenido + +### Diciembre de 2025: lanzamiento publico completo + +Lanzamiento publico completo de Riff.CC + +* Biblioteca de contenido ampliada con subidas generadas por usuarios +* Funciones de descubrimiento mejoradas para encontrar y compartir contenido + +{{% /steps %}} + +## 📅 2026 + +{{% steps %}} + +### Enero de 2026: canales de usuario + +Soporte inicial para canales de usuario y suscripciones + +* Crea y gestiona tu propio canal, que puede mostrar contenido de otros canales o Lenses +* Soporte para suscripciones a canales, permitiendo que los usuarios sigan y reciban actualizaciones de sus canales favoritos + +### Febrero de 2026: financiacion por umbral + +Ampliar Riff.CC para admitir financiacion por umbral + +* Permitir que los artistas configuren campanas de financiacion por umbral para su proximo trabajo +* Permitir que los usuarios apoyen directamente a los artistas y obtengan recompensas por hacerlo +* Los artistas publican automaticamente su obra bajo Creative Commons (no comercial) una vez que hayan ganado suficiente dinero con ella + +{{% /steps %}} diff --git a/content/docs/riff.cc/team.es.md b/content/docs/riff.cc/team.es.md new file mode 100644 index 0000000..e2688f1 --- /dev/null +++ b/content/docs/riff.cc/team.es.md @@ -0,0 +1,67 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Equipo' +weight = 2 ++++ + +Tenemos un equipo pequeno pero apasionado de desarrolladores, ingenieros y curadores. + +{{< cards >}} + {{< card title="Michaela Andrus" + tag="Ingeniera de soluciones" + subtitle="Michaela dirige Riff Labs Perth. Tambien es ingeniera de software e investigadora." + >}} + {{< card title="Lucas Jovanovich" + tag="Ingeniero principal" + subtitle="Lucas trabaja en la plataforma principal de Riff.CC y en su arquitectura P2P." + >}} + {{< card title="Benjamin Arntzen" + tag="Fundador" + subtitle="Benjamin es el fundador de Riff.CC. Es investigador de P2P y arquitecto de sistemas distribuidos." + >}} + {{< card title="Julien Malard-Adam" + tag="Ingeniero principal" + subtitle="Julien trabaja en la escalabilidad y el rendimiento de la plataforma principal de Riff.CC." + >}} + {{< card title="Phoebe Sleet" + tag="Por anunciar" + subtitle="Se anunciaran mas detalles pronto." + >}} + {{< card title="Bill Schreckenstein" + tag="Relaciones con socios" + subtitle="Bill trabaja en construir alianzas con otras organizaciones y proyectos." + >}} + {{< card title="Preeti Aarya" + tag="Desarrolladora web" + subtitle="Preeti trabaja en mejorar la experiencia frontend de Riff.CC." + >}} + {{< card title="Muskan Paswan" + tag="Desarrolladora web" + subtitle="Muskan trabaja en mejorar el aspecto y la experiencia de Riff.CC y las Lenses." + >}} + {{< card title="Evelyn Collins" + tag="Bibliotecaria P2P" + subtitle="Evelyn es investigadora y curadora de contenido. Ayuda a construir y curar la biblioteca de Riff.CC." + >}} + {{< card title="Roniel Contreras" + tag="Ingeniero principal" + subtitle="Roniel trabaja en la plataforma principal de Riff.CC y en la UI/UX de Flagship, ademas del desarrollo para nuestros socios." + >}} + {{< card title="Gabriel Cruz" + tag="Ingeniero de sistemas distribuidos" + subtitle="Gabriel trabaja en nuestro sistema de archivos distribuido y en la arquitectura P2P." + >}} + {{< card title="Peter Raven" + tag="Ejecucion tecnica" + subtitle="Peter es consultor de ejecucion tecnica. Nos ayuda a asegurarnos de que *entregamos*." + >}} + {{< card title="Ehab Fayez" + tag="Diseno y UX" + subtitle="Ehab es nuestro disenador interno y experto en UX. Trabaja en el aspecto y la experiencia de Riff.CC y las Lenses." + >}} + {{< card title="Kai Hamilton" + tag="Ingeniero de automatizacion" + subtitle="Kai trabaja en automatizacion y herramientas como Dragonfly." + >}} +{{< /cards >}} diff --git a/content/docs/riff.cc/visiting-riff.es.md b/content/docs/riff.cc/visiting-riff.es.md new file mode 100644 index 0000000..e1db1ff --- /dev/null +++ b/content/docs/riff.cc/visiting-riff.es.md @@ -0,0 +1,12 @@ ++++ +date = '2025-07-07T15:37:53+01:00' +draft = false +title = 'Visitar Riff.CC' +weight = 1 ++++ + +Puedes visitar la instantanea actual de desarrollo de Riff.CC en nuestro sitio de desarrollo, [ftwc.xyz](https://ftwc.xyz). + +![Una captura de pantalla del sitio de desarrollo de Riff.CC](/images/docs/riff.cc/home.png) + +Planeamos lanzar la plataforma publica completa de Riff.CC en el cuarto trimestre de 2025. diff --git a/content/privacy.es.md b/content/privacy.es.md new file mode 100644 index 0000000..399c864 --- /dev/null +++ b/content/privacy.es.md @@ -0,0 +1,41 @@ ++++ +title = 'Privacidad' +date = 2025-07-16T03:00:00Z +draft = false ++++ + +*Última actualización: 16 de julio de 2025* + +## Versión corta + +No recopilamos ni vendemos tu información personal. No te enviamos spam. Respetamos tu privacidad. + +## Lo que no hacemos + +- **No te rastreamos** - Sin analíticas, sin cookies, sin píxeles de seguimiento +- **No vendemos tus datos** - Tu información nunca se vende a terceros +- **No te enviamos spam** - Solo te contactamos si lo solicitas explícitamente +- **No elaboramos perfiles** - Sin análisis de comportamiento ni publicidad dirigida + +## Lo que sí hacemos + +- **Recopilación mínima de datos** - Solo recopilamos lo necesario para que el servicio funcione +- **Infraestructura segura** - Tus datos están protegidos con prácticas de seguridad estándar del sector +- **Prácticas transparentes** - Somos claros sobre nuestras prácticas de privacidad + +## Tus derechos + +Tienes derecho a: +- Acceder a cualquier dato que tengamos sobre ti +- Solicitar la eliminación de tus datos +- Optar por no recibir comunicaciones + +## Contáctanos + +¿Preguntas sobre esta política de privacidad? Escríbenos a privacy@riff.cc. + +
+ +--- + +*Esta política puede cambiar. Avisaremos a los usuarios sobre cualquier actualización importante.* diff --git a/content/projects.es.md b/content/projects.es.md new file mode 100644 index 0000000..70f3328 --- /dev/null +++ b/content/projects.es.md @@ -0,0 +1,46 @@ ++++ +title = 'Proyectos' +date = 2025-01-13T12:00:00Z +draft = false ++++ + +## 📚 Flagship + +Nuestra plataforma de bibliotecas descentralizadas que permite a las comunidades construir y mantener sus propias bibliotecas digitales imparables. + +Durable + +[Probar](https://ftwc.xyz) | [Código fuente](https://github.com/riffcc/flagship) | [Documentación](/docs/flagship) + +**Estado**: Desarrollo activo, acercándose a la beta + +## 🛠️ Librarian + +Un conjunto de herramientas para gestionar y curar contenido en bibliotecas descentralizadas, asegurando que el conocimiento se preserve y siga siendo accesible. + +[Código fuente](https://github.com/riffcc/librarian) + +**Estado**: Desarrollo activo, prototipo temprano + +## 🎁 Showcase + +Una plataforma para mostrar lo mejor de tu trabajo y conectarte con una comunidad de creadores y audiencias. + +**Estado**: Desarrollo temprano + +## 🌌 Starmap + +Una herramienta de exploración visual para descubrir y navegar el vasto paisaje del contenido descentralizado. + +**Estado**: Fase de concepto y diseño + +## Participa + +Todos nuestros proyectos son de código abierto y están impulsados por la comunidad. Así puedes contribuir: + +- **Desarrolladores**: Consulta nuestro [GitHub](https://github.com/riffcc) para issues abiertas y guías de contribución +- **Bibliotecarios**: Ayúdanos a curar y organizar contenido para su preservación +- **Creadores**: Prueba nuestras plataformas y compártenos tu opinión +- **Todo el mundo**: Corre la voz sobre bibliotecas y plataformas imparables + +[Ver en GitHub](https://github.com/riffcc) | [Unirse a Discord](/contact) diff --git a/content/terms.es.md b/content/terms.es.md new file mode 100644 index 0000000..604aebf --- /dev/null +++ b/content/terms.es.md @@ -0,0 +1,55 @@ ++++ +title = 'Términos de servicio' +date = 2025-07-16T03:00:00Z +draft = false ++++ + +*Última actualización: 16 de julio de 2025* + +## Versión corta + +No seas una mala persona. No subas contenido ilegal. No dañes a los demás. Usa el servicio de forma responsable. + +## Contenido prohibido + +**NO** puedes subir, compartir, facilitar ni distribuir: + +- **Contenido abusivo** - Tolerancia cero al contenido abusivo, incluido material de abuso sexual infantil +- **Contenido pirateado** - Nada de infracciones de copyright ni propiedad intelectual robada +- **Comportamiento abusivo** - Nada de acoso, amenazas ni ataques dirigidos +- **Discurso de odio** - Ningún contenido racista, sexista o discriminatorio +- **Malware** - No subas virus, troyanos ni código malicioso +- **Spam** - No envíes mensajes masivos no solicitados ni spam comercial +- **Engaño** - No subas contenido engañoso ni suplantes a otras personas + +## Tus responsabilidades + +Al usar este servicio, aceptas: + +- Respetar a los demás y su contenido +- Cumplir todas las leyes aplicables en tu jurisdicción +- Asumir la responsabilidad por el contenido que subas +- No intentar dañar ni interrumpir el servicio + +## Nuestros derechos + +Nos reservamos el derecho de: + +- Eliminar contenido que viole estos términos +- Suspender o cancelar cuentas por infracciones +- Informar a las autoridades sobre contenido ilegal +- Modificar estos términos con un aviso razonable + +## Sin garantía + +Este servicio se ofrece "tal cual", sin garantías de ningún tipo. Úsalo bajo tu propia responsabilidad. + +## Contáctanos + +¿Preguntas sobre estos términos? Escríbenos a legal@riff.cc + +
+ +--- + +*Al usar el servicio Riff.CC, aceptas estos términos.*