SàT Pubsub is a server independent PEP/PubSub XMPP service, which aims to be complete and universal.

This project was born due to the fact that it is difficult to have feature-full PEP/PubSub on every XMPP servers, and even if it is the case there can be huge delays before seeing new functionalities implementation, or they can be difficult to extend.

The "Salut à Toi" project being using extensively XMPP PubSub functionalities, there was 2 ways to work around the issue:

  • to concentrate on a particular XMPP server, to recommend it, and if possible make it evolve in the wanted direction.
    This would mean being blocked on a specific XMPP server implementation and taking the risk to have incorrectly working (or not working at all) functionalities on other servers

  • create a server independent component, by using XMPP extensions to have a privileged access to server

The latter option has been retained, SàT PubSub uses XEPs (XMPP extensions) Namespace Delegation (XEP-0355) and Privileged Entity (XEP-0356) to be able to offer advanced features and PEP.

Beside the use of "SàT" in the name (which is due to its origins), you don't need to install or use Salut à Toi with this component, and it can be used by any XMPP compatible software.

SàT PubSub was already implementing MAM and RSM (allowing to do searches in archives and to use paginations to retrieve new items), the 0.3.0 version also brings:

  • the presence access model
  • +notify handling
  • notion of administrators, which are identifiers ("JID") with privileges
  • affiliations
  • the possibility to find items sorted by creation or modification date, thanks to Order-By (XEP-0413)
  • the "Node Schema" experimental feature, to associate data types to a node using Data Forms (XEP-0004). This feature is notably used by Salut à Toi for tickets
  • the "Serial IDs" experimental feature, which set new items identifiers using increments (1, 2, 3, etc.) instead of random values. This is notably useful for tickets.
  • the "PubSub Admin" experimental feature, which let administrators publish items by specifying an other publisher. This can be used to restore nodes backups.
  • the "consistent publisher" experimental feature which, once activated in node settings, keep the original publisher when an item is updated by the node owner or an administrator. This permit to update an item without preventing the original publisher do modify it himself or herself (for instance while editing a blog comment or updating a ticket status).
  • a config file can now be used with SàT PubSub, avoiding to have to specify settings – including the password – entirely on the command line. The same file as for Salut à Toi (sat.conf) is used, the settings for SàT PubSub must be set in the [pubsub] section.
  • a new documentation

You'll find more details in the CHANGELOG.

Version 0.4 development has already begun with a working Python 3 port, completing the port of the whole Salut à Toi ecosystem.

To install SàT PubSub, you just have to enter pip install sat_pubsub in a Python 2 virtual environment, check documentation for more details.

This message is not in English, click to display anyway

La version 0.3.0 de SàT Pubsub est disponible.

SàT PubSub est un service XMPP PEP/PubSub indépendant du serveur, qui vise à être complet et universel.

Ce projet est né du constat qu'il est difficile d'avoir des services PEP/PubSub complets sur tous les serveurs XMPP, et que même si c'est le cas ils peuvent tarder à implémenter de nouvelles fonctionnalités ou être difficiles à gérer.

Le projet « Salut à Toi » faisant un usage intensif des fonctionnalités PubSub de XMPP, 2 solutions étaient envisageables :

  • se concentrer sur un serveur XMPP particulier et le recommander, voire le faire évoluer dans la direction voulue. Ceci reviendrait à se bloquer sur une implémentation particulière d'un serveur XMPP et risquer de voir des fonctionnalités fonctionner incorrectement ou pas du tout sur les autres.

  • faire un composant indépendant du serveur, en utilisant des extensions XMPP pour avoir un accès privilégié au serveur

C'est la deuxième option qui a été retenue, SàT PubSub utilise les XEPs (extensions XMPP) Namespace Delegation (XEP-0355) et Privileged Entity (XEP-0356) pour pouvoir fournir des fonctionnalités avancés et PEP.

Bien que « SàT » soit utilisé dans le nom (par son origine), ce composant ne nécessite pas d'utiliser Salut à Toi et peut-être utilisé par tout logiciel XMPP.

SàT PubSub implémentait déjà MAM et RSM (permettant de faire des recherches dans les archives et d'utiliser la pagination pour retrouver les éléments), la version 0.3.0 apporte également :

  • le modèle d'accès presence
  • la gestion de +notify
  • la notion d'administrateurs, qui sont des identifiants (« JID ») avec des accès privilégiés
  • les affiliations
  • la possibilité de retrouver les éléments classés par date de création ou modification avec Order-By (XEP-0413)
  • la fonctionnalité expérimentale « Node Schema », pour associer des types de données à un nœud via les Data Forms (XEP-0004). Cette fonctionnalité est notamment utilisée dans Salut à Toi pour les tickets.
  • la fonctionnalité expérimentale « Serial IDs » qui permet d'attribuer des identifiants d'éléments utilisant des incréments (1, 2, 3, etc.) au lieu de valeurs aléatoires. Ceci est notamment utile pour les tickets.
  • la fonctionnalité expérimentale « PubSub Admin », qui permet aux administrateurs de publier des éléments en spécifiant un autre éditeur (« publisher »). Peut-être utilisé pour restaurer une sauvegarde.
  • la fonctionnalité expérimentale « consistent publisher » qui, une fois activée sur un nœud, garde l'éditeur (« publisher ») original quand un élément est modifié par le propriétaire du nœud ou un administrateur. Ceci permet de modifier l'élément sans empêcher l'éditeur original de le modifier à nouveau lui-même (par exemple en éditant un commentaire de blog, ou en changeant le statut d'un ticket).
  • un fichier de configuration peut désormais être utilisé avec SàT PubSub, évitant d'avoir à spécifier les options – dont le mot de passe – entièrement sur la ligne de commande. Le même fichier que pour Salut à Toi (sat.conf) est utilisé, les options de SàT PubSub doivent être mises dans la section [pubsub]).
  • une nouvelle documentation

Vous trouverez plus de détails dans le CHANGELOG.

Le développement sur la version 0.4 a déjà commencé avec le port pour Python 3 qui est fonctionnel et complète le reste de l'écosystème Salut à Toi.

Pour installer SàT PubSub, il vous suffit d'entrer pip install sat_pubsub dans un environement virtuel Python 2, référez-vous à la documentation pour plus de détails.

Salut to you!

It is with a big pleasure and a sort of relief that I announce you the release of "Salut à Toi" v0.7.0 (La Commune).

To remind you "Salut à Toi" (or SàT) is an ecosystem of decentralised communication, based on "XMPP" established standard.
It features many functionalities (instant chatting, file sharing, blogging/microblogging, events organisation, forums, etc.) and has the particularity of being multi-interfaced (different "frontends" are available for the web, desktop, mobile devices or even the terminal and command line).

The preparation of this version has taken 3 years. This is the first version we can call "general audience", in other words it is approachable also by those without technical background . Though, there are still some improvements to be done in the frontend and "user experience" level.

I shall not enumerate again all the functionalities with screenshots, you can consult the announcement of the alpha version to do so by yourself. I'd rather explain some major updates, which has been done:

Cagou, the desktop/mobile interface

As promised by our modest crowdfunding, Cagou is the name of the new desktop/mobile frontend (Android only at this moment). To share a little story with you, it is a reference to a beautiful bird, which does not fly, but barks, and is endemically present on the no less beautiful island of New-Caledonia. It is also a nod to Kivy, the framework we are using and from which the name and logo may remind you of Kiwi of New-Zeland.

So, this interface is multi-platforms, not focusing only on instant messaging: you can use it for file-sharing (e.g. the videos/photos between your computer and phone), or as a remote-control for your media player. It is of course planned that it will be able to cope with blogging in the close future.

Cagou is thought to be usable on a little screen, as well in full-screen mode of desktop, and allows the screen division into zones - to, for instance, follow several discussions at the same time.

On android, the application has still some problems with the reactivity and bugs time to time. Lot of problems will be corrected by with Python 3 port. Consider this version as the first one to have you commentaries et propositions.

Cagou sur Android

End-to-end encryption

Of course, SàT has been featuring end-to-end encryption for several years already through "OTR", however this version witnesses the arrival of "OMEMO", an algorithm correcting the issues of previous one (specially allowing sending of offline encrypted messages, or to display them on multi-devices). OMEMO is implemented only for simple conversation ("1:1", between 2 people) at the moment, but the next version will surely cope with end-to-end-encrypted conversations within groups.

Events, photo-albums, forums, ticket-handling, merge-requests

Numerous new functionalities has appeared in this version. You can now create and manage events (e.g. for the family) with the classic list of invited persons et the replies of type "RSVP" (attending, not attending, maybe attending). It is possible to invite people, even though they don't have XMPP account - using the "invitation" accounts which are automatically generated and sent to their emails.

You can create and share the photo albums, a specialisation of file-sharing. The possibility to create one is not yet available from graphic interface, however, this is planned to be improved soon. To consult the photos is simple from Libervia (web interface).

The forum is also in the party, as well as the tickets handling and merge requests. These two last functionalities have been implemented for the project needs, but they are very flexible and can be (in the next version) easily used in a everyday life (e.g. as a shopping lists, to do lists etc.)

All of this take profit from XMPP "PubSub" capabilities, and can benefit of its permission system (we can imagine the shopping list being shared between the family members indicating who bought what).

Remark - to actually benefit from all this it is necessary to use the "SàT Pubsub" service, the project made for the needs of Salut à Toi (but which can be used by all XMPP based programs)

un blog sur Libervia

album photo sur Libervia

Web Framework

The development of Libervia, the web frontend of SàT, has evolved to make it become a web framework. The reason of this evolution is the need of a very flexible interface, one which would allow implementation and testing of new ideas and functionalities easily. The goal is to have a naturally decentralised and federative framework (thanks to XMPP), which integrates simply to the ecosystem. I will speak only briefly about the technical details, but the point is to join Jinja2 with SàT and use PubSub as the database. Also CLI frontend (jp) allows to use the same models to make a static rendering (for instance to generate a static blog or chat archives).

It is with this framework that these above mentioned features were developed, they are organised in "pages" which are supposed to be simple to use and can work without JavaScript (when possible, it is not the case for the chat). The new official website works thanks to the new framework, you'll find there an introductory documentation.

Even More

I won't get too much into details as the updates are too numerous, but though it it worth mentioning that SàT can be also used to store your folders on the server (it can be used as a "component"), or jp, the command line frontend allows manage a lot of things (find or publish an article or blog, send encrypted or non-encrypted message, find someone's avatar, etc.)

Installation

Salut à Toi is available on Debian and its derivates, but attention! It is only the case for the backend, the console interface and the command line. By the way, a help to make the Cagou package land there too would be much appreciated.

It is also available on the Arch Linux's AUR repository, and you'll also find there the development versions.

The Flatpak packages allows the easy installation of Cagou, Primitivus (terminal) and jp (command line) on most of GNU/Linux distributions, you can find the links on the main page of the site.
You can of course, use as well pip, the Python packages manager. A simple pip2 install --user sat followed by pip2 install --user cagou and pip2 install --user libervia should be enough. The instructions are available in the site's documentations.

For Android, you can find a APK on this link (unsigned, a definitive version will follow in a couple of days). After the release, I will make steps to make it available on F-Droid, and eventually the "play store".

Even though SàT should technically be working on Mac OS X, Windows and *BSD, however on these platforms it is not yet tested (as I do not have any of this devices). I have had some feed-backs concerning Mac use. If you are interested, help with testing and packaging would be nice.

Future

The principal planned development of 0.8 is the port to Python 3, which is now finally possible, as no more dependency is blocking, and it is the only thing promised for the next version. Lot of big steps are to follow, and it will be inevitable to make some choices. Don't hesitate to give me opinions/feedback in the commentaries.

Video conference

With Jingle already implemented, the video conference has been planned for a long time. It shouldn't be too difficult to be implement it into the web interface (thanks to WebRTC), but certainly would need a lot of work on desktop/Android (to evaluate different options, GSTreamer is the hot candidate at the moment, and integrate with Cagou). This is an important work.

Improving the file sharing

SàT already allows advanced file sharing (more than a simple sending of the files to the server), including a server component. It is very possible, that the future developments will continue in this direction.

share a directory with Cagou

iOS Version

It would be technically possible to use Cagou on iPhone. Though, there are several obstacles to cope with - especially the legal ones (Apple store is not compatible with the current licence, AGPL 3+). Lot of time and investments would be needed. This is clearly not the priority, but keep in mind that an iOS version is doable.

ActivityPub Gateway

With this version, SàT can be used as a "component", i.e. a server service. This possibility can be used to build an ActivityPub gateway, that would allow 2 ways communication with projects using this protocol. There is already somebody working on a similar gateway for Prosody, , so I will certainly wait to see how it evolves before starting it by myself.

Chat Evolution

Though its already functional, the chat can become very complete if we take the time for it. Here, we speak of adding some missing features (like reactions or editing of the last sent message), improving the file handling, copy/pasting of code, end-to-end group encryption, etc.
All this is on the roadmap, the question is whether this is a priority or not.

Improvement of User Experience

This is probably the project which will have the priority, once Python 3 port is done. SàT has already lot of features, but the interfaces need some work to become really user-friendly. I would specially like to work on launch screen and contacts discovery. There are as well lots of "small details " which all together take lots of time, but in total make the user-experience much more pleasant: integration to desktop, file-sharing actions, easier file selection, etc.

Well, so much for the future steps, all of this would take time, but again - your feedbacks are highly welcomed. There are other ideas to think about, but one has to choose her priorities.

But…

Salut à Toi is an huge project with a potential - and it is currently developed by a single person. I have currently only one day a week dedicated to SàT (besides mornings, evenings and nights), the rhythm is very difficult to cope with. In the next months I will seriously study the projects financing possibilities. It will be necessary that I find a way to keep the project on track.

Useful Links

  • official website: https://salut-a-toi.org
  • documentation: https://salut-a-toi.org/documentation
  • my blog: https://www.goffi.org (I publish there weekly progress notes)

This message is not in English, click to display anyway

Salut à vous,

c'est avec plaisir et un certain soulagement que je vous annonce la sortie de « Salut à Toi » v0.7 (La Commune).

Pour mémoire « Salut à Toi » (ou SàT) est un écosystème de communication décentralisé, basé sur le standard établi « XMPP ».
Il vous permet de faire de nombreuses choses (messagerie instantanée, partage de fichiers, blogage/microblogage, événements, forums, etc.) et a la particularité d'être multi-interfaces (différents « frontaux » sont disponibles pour le web, le bureau, les appareils mobiles, ou encore le terminal et la ligne de commande).

La préparation de cette version aura pris 3 ans, c'est la première version dite « grand public », autrement dit qui est utilisable par un public qui n'est pas forcément technique, même s'il y a encore des améliorations à faire au niveau de l'interface et l'« expérience utilisateur ».

Il n'est pas question de refaire une longue énumération de fonctionnalités avec captures d'écrans, vous pouvez vous référer à l'annonce de la version alpha pour ceci. Je vais plutôt expliquer certaines nouveautés majeures :

Cagou, l'interface bureau/appareils mobiles

Promis suite à notre modeste campagne de financement participatif, Cagou est le nom du nouveau frontal bureau/appareils mobiles (Android uniquement pour le moment). Pour la petite histoire, c'est une référence à un superbe oiseau qui ne vole pas et aboie, endémique à la non moins superbe Nouvelle-Calédonie, mais aussi un clin d'œil à Kivy, le cadriciel que nous utilisons et dont le nom et logo rappellent le Kiwi de la Nouvelle-Zélande.

Cette interface est donc multi-plateformes, et ne se contente pas de la messagerie instantanée : vous pouvez vous en servir pour transférer des fichiers (par exemple vos films/photos entre votre téléphone et votre ordinateur de bureau), ou comme télécommande pour votre lecteur de médias. Il est bien entendu prévu qu'il gère également le blogage dans un avenir proche.

Cagou est pensé pour être utilisable aussi bien sur un petit écran qu'en plein écran sur un grand moniteur de bureau, et permet de diviser facilement l'écran en zones pour, par exemple, suivre plusieurs salons de discussion en même temps.

Sur Android l'application souffre encore de quelques problèmes de lenteur et même parfois de plantages. Plusieurs problèmes seront corrigés avec le port sur Python 3, aussi considérez cette version comme un premier jet qui permet d'avoir vos commentaires et suggestions.

Cagou sur Android

Chiffrement de bout en bout

Bien que SàT gère le chiffrement de bout en bout depuis plusieurs années via « OTR », cette version voit l'arrivée d'« OMEMO », un algorithme palliant des défauts du précédent (il permet notamment d'envoyer des messages chiffrés hors ligne, ou de les afficher sur plusieurs appareils). OMEMO n'est implémenté qu'en conversation simple (dites « 1:1 », entre 2 personnes) pour le moment, mais la prochaine version verra certainement la gestion des conversations de groupes chiffrées de bout en bout.

Événements, album photos, forums, gestion de tickets, requêtes de fusion

De nombreuses fonctionnalités font leur apparition. Vous pouvez désormais créer et gérer des événements (familiaux par exemples), avec une classique liste d'invités et de réponses types « RSVP » (je viens, je ne viens pas, je viens peut-être). Il est possible d'inviter des gens même s'ils ne sont pas sur le réseau XMPP en utilisant des comptes « invités » générés automatiquement et envoyés à des adresses de courriel.

Vous pouvez créer et partager des albums photos, une spécialisation du partage de fichiers. La création n'est pas encore disponible depuis les interfaces graphiques, c'est une amélioration à prévoir rapidement, la consultation par contre est simple depuis Libervia (l'interface web).

Un forum basique est également de la partie, ainsi qu'une gestion des tickets et requêtes de fusion (« merge requests »). Ces 2 dernières fonctionnalités ont été implémentées pour les besoins du projet, mais elles sont très souples et pourront (dans une prochaine version) facilement être utilisée dans la vie courante (par exemple pour des listes de courses ou de choses à faire).

Tout ceci tire parti des capacités de publication/abonnement (ou « PubSub ») de XMPP, et peuvent profiter de son système de permissions (on peut ainsi imaginer une liste de courses partagée entre les membres de la famille, pour indiquer qui a pris quoi).

À noter que pour en profiter il est actuellement nécessaire d'utiliser le service PubSub « SàT Pubsub », un project fait pour les besoins de Salut à Toi (mais utilisable par tout logiciel XMPP).

un blog sur Libervia

album photo sur Libervia

Cadriciel (framework) web

Le développement de Libervia, le frontal web, l'a mené à devenir un cadriciel (ou « framework ») web. La raison de cette évolution est qu'il fallait une interface très souple, permettant d'implémenter et tester facilement de nouvelles idées ou fonctionnalités. Le but est d'avoir un cadriciel naturellement décentralisé et fédéré (parce que basé sur XMPP), qui s'intègre simplement dans l'écosystème. Je passe rapidement sur les détails techniques, mais il s'agit de lier le moteur de rendu Jinja2 avec SàT et d'utiliser PubSub comme base de données. En outre, le frontal en ligne de commande (jp), permet d'utiliser les même modèles pour faire un rendu statique (par exemple pour générer un blog statique ou des archives d'un salon de discussion).

C'est avec ce cadriciel qu'ont été développées les fonctionnalités mentionnées ci-dessus, elles sont organisées en « pages » qui se veulent simple d'utilisation et peuvent fonctionner sans javascript (quand c'est possible, ce qui n'est pas le cas pour le « chat »). C'est grâce à lui que fonctionne le nouveau site officiel où vous trouverez une documentation d'introduction.

mais encore

Je ne vais pas trop m'étendre, les nouveautés sont trop nombreuses, mais il vaut tout de même la peine de mentionner que SàT peut également être utilisé pour stocker vos fichiers sur le serveur (il peut être utilisé en tant que « composant »), ou que jp, le frontal en ligne de commande permet de gérer beaucoup de choses (retrouver ou publier un article de blog, envoyer un message chiffré ou non, retrouver l'avatar de quelq'un, etc.).

Installation

Salut à Toi est disponible dans Debian et ses dérivées, mais attention c'est le cas seulement pour le backend, et les interfaces console et ligne de commandes, de l'aide serait d'ailleurs apprécié pour empaqueter Cagou (interface bureau/appareils mobiles) et Libervia (interface web).

Il est également disponible sur les dépôts AUR d'Arch Linux, et sur cette distribution il existe des paquets pour installer les versions de développement.

Des paquets Flatpak permettent une installation aisée de Cagou, Primitivus (console) et jp (ligne de commande) sur la plupart des distributions GNU/Linux, vous trouverez les liens sur la page principale du site.
Vous pouvez bien sûr aussi utiliser pip, le gestionnaire de paquets de Python. Un simple pip2 install --user sat suivit d'un pip2 install --user cagou voire d'un pip2 install --user libervia devrait suffire. Les instructions sont disponibles dans la documentation du site.

Pour Android, vous trouverez un Apk sur ce lien. Je vais faire les démarche pour le rentre disponible sur F-Droid, et éventuellement le « play store ».

Bien que SàT devrait techniquement fonctionner sur Mac OS X, Windows et les *BSD, il n'est pas testé sur ces plateformes (car je ne les ai pas à disposition). J'ai eu quelques retours sur Mac. Si des personnes sont intéressées, une aide pour tester et empaqueter serait plus que bienvenue.

Avenir

La principale chose attendue pour la 0.8 est le port sur Python 3, il est enfin possible maintenant que plus aucune dépendance ne bloque, et c'est la seule chose certaine pour la version à venir. Plusieurs grosses pistes sont envisagées ensuite et il va falloir faire des choix, n'hésitez pas à donner votre avis/préférence en commentaire.

Visioconférence

Jingle étant déjà implémentée, la visioconférence est prévue de longue date. Elle ne devrait pas être trop difficile à implémenter pour l'interface web (grâce à WebRTC), mais demandera certainement plus de travail sur bureau/Android (évaluer les différentes options, GSTreamer étant le candidat envisagé pour le moment, et intégrer ça à Cagou). C'est un chantier important.

Améliorer le partage de fichiers

SàT propose déjà un partage de fichiers avancé (plus qu'un simple envoi de fichier sur le serveur), incluant un composant serveur. Il est fort possible que des développements continuent dans cette direction.

partager un répertoire avec Cagou

Version iOS

Il serait techniquement possible de porter Cagou sur iPhone. Il y a plusieurs obstacles à cela, notamment juridique (l'Apple store n'est pas compatible avec la licence actuelle, AGPL 3+). IL faudrait également du matériel dédié, et du temps. Ce n'est clairement pas la priorité, mais sachez qu'une version iOS est envisageable.

Passerelle ActivityPub

Avec cette version, SàT peut désormais être utilisé en « composant », c'est-à-dire un service côté serveur. Cette possibilité peut être mise à profit pour créer une passerelle ActivityPub, ce qui permettrait de communiquer dans les 2 sens avec les projets utilisant ce protocole. Il y a déjà un projet en cours de passerelle XMPP pour Prosody, aussi je vais certainement attendre de voir son évolution avant de me lancer moi-même.

Évolution de la messagerie instantanée

Bien que déjà fonctionnelle, la messagerie instantanée peut devenir très complète si on y consacre du temps. Il s'agirait d'ajouter les quelques fonctionnalités manquantes (réactions, correction du dernier message), d'améliorer la gestion des fichiers, des copier-collers des morceaux de code, d'implémenter le chiffrement de bout en bout en groupe, etc. Tout ceci est prévu, la question est de savoir si on en fait la priorité ou pas.

Amélioration de l'utilisabilité

C'est probablement le chantier qui sera prioritaire une fois le port Python 3 effectué. SàT est déjà bien fourni en fonctionnalité, mais les interfaces ont besoin de travail pour être facilement utilisable. J'aimerais en particulier travailler sur le lancement de l'application et la découverte de contacts. Il y a également beaucoup de « petits détails » qui accumulés prennent du temps mais rendent le logiciel beaucoup plus agréable : intégration au bureau, aux actions de partage, une sélection plus agréable des fichiers, etc.

Voilà pour les pistes envisagées, chacune demande du temps et encore une fois vos commentaires/avis sont les bienvenus. Il y a d'autres idées qui traînent, aussi il va falloir bien choisir les priorités.

Mais…

Salut à Toi est un gros projet qui a un potentiel, mais il est pour le moment développé par une seule personne. Je n'ai qu'un jour par semaine consacré à SàT, et le rythme est très difficile à tenir. Dans les mois qui viennent je vais étudier les options de financement du projet. Il va être nécessaire que je trouve une solution à moyen terme pour que ce projet reste sur les rails.

Liens utiles

  • site officiels: https://salut-a-toi.org
  • documentation: https://salut-a-toi.org/documentation
  • notes de progression (en anglais): https://www.goffi.org/tag/S%C3%A0T%20progress

Pour les libristes habitant près de Lille, je serai à la Pycon cette semaine avec 2 jours de sprint autour de « Salut à Toi », puis une conférence le samedi à 16:30.

Si vous n'allez pas à la Pycon (et même si vous y allez ;) ), on peut aussi se voir pour une petite bière dans le vieux Lille en soirée. Bref n'hésitez pas à me contacter si vous voulez parler décentralisation, réseaux « sociaux », XMPP et/ou politique !

Time is running so fast that I can barely find some to write about the advancement of Salut à Toi, and there's a lot to say.

I'll be short this time (no more long list of features like alpha release ;) ).

If you are following SàT for long time, you may remember the experiment to have an universal remote control, and the demonstration with VLC.

Well, this is now implemented in a cleaner way, and it's user friendly. With Cagou running on your mobile device, it's quite useful as you can see in the video below.

Note: I'm testing Peertube to diffuse SàT demo videos, you can also see the video on the instance I'm trying.

If you have already SàT running on your desktop, all you have to do is run your media player (VLC for instance). Then on Cagou click on the new "remote control" icon, and you should see an icon for your media player. Note that this is working only on GNU/Linux (and probably *BSD) as it is relying on D-BUS which is not available everywhere.

The other thing to mention is that OMEMO support is now available in SàT (thanks to the work of Syndace on python-omemo, and his prompt reactions to feedback). It's not fully finished yet: fingerprint management is missing, encryption is only available on one2one conversations, and it's not yet available on Android, but the biggest part is done and working on desktop.

Note: this video is also available on Peertube

That's it. I'll publish a new alpha release in a couple of days. The list of features to implement before release become narrow, stabilisation phase should start soon.

Once again help is needed for packaging (Debian, Arch, or other GNU/Linux distributions, Docker, etc.), testing/packaging on many platforms (*BSD, Windows and Mac for instance), and would be welcome for development too. Also we have a very low visibility, don't hesitate to shout out loud about the project :).

It's my pleasure to announce the release of the first alpha version of Salut à Toi 0.7.

This is the occasion on one hand to show the state, advancement and direction of the project, and on the other hand to launch a call for contributions.

In this article I will show you a part of Salut à Toi capabilities, and explain briefly how to use them.

You'll find a link to an .apk file to test Cagou on Android in the "Test it!" section.

As a reminder, Salut à Toi is a collaborattive ecosystem, which is multi-frontends (web, desktop, mobile devices, terminal, command line), multi-platforms, and multipurpose. It let you handle your communications, organise yourself, share your files, etc. It is also, and above all, an activist project which think about the impact of new technologies on our lives, and which tries to stimulate public debate.

We'll concentrate on the web and desktop/mobile frontends, because those are the ones which will most probably be of interest to the mass.

Web frontend (named "Libervia")

Libervia has seen major changes, with a new web framework.

The idea, which has been explained in a blog post is to offer base components (account authentification, permissions, comments, etc.) ready-to-use and decentralised thanks to XMPP. This way we easily build website which are automatically decentralised and federated.

Please note that everything is prepared for translation, but for now only English is available. Help would be much appreciated to improve on that!

Let's check the available features:

Chat

screenshot of a "chat" discussion in Libervia

Let's start with the most obvious, there is an instant messaging page. To use it, you just have to click on "chat", et to log in if it's not already done.

You'll land on a panel with the rooms in your bookmarks, you just have to click on one of them, or to specify an identifier (jid) of a new room/contact.
It is for now quite basic, but still you can enter "/help" to check textual commands.

Blog

my own blog, powered by Libervia

One of the flagship features of SàT, really rare in XMPP world (the only actively developed other client implenting it being Movim), is the blog (which is then decentralised).

A click on the menu will bring you to a "discover" page where you'll find your contacts with a blog. Click on one of them to read, or specify an identifier to read a blog which is not in your contacts.

Forums

XMPP powered decentralised forums

Unique feature in XMPP world, SàT propose forums, allowing to organise discussions in categories. Because forums are under the hood the same thing as blogs, it is possible to use a blog as forum and vice versa.

The addition of new forums is done by an administrator using command line tool "jp" (see below).

Events

personal list of events

Other feature not seen elsewhere in XMPP (and in decentralised software?), SàT allows you to create events, and of course to invite people.

As with other features, the page is thought to be easy to use: you have a button "create an event" which bring you to a form. A name, location and date later (and optionally a picture to associate), and your event is created. You'll then land to an admin page where you'll have the possibility to invite people.

Events are private for now, only your guests and you have access to it, but public events are also planned.

a guest is answering to an event RSVP

Please note that it's possible (but not yet from the web interface) to add arbitrary fields to your events, for instance to let your guest specify what they'll bring to a picnic.

File sharing

sharing file from browser

Here we are talking about a feature useful daily, and in many circonstances. Salut à Toi has long been able to send files, or to upload them on your server, but we are talking here about sharing one or many directories, or to upload in an advanced way on a serveur component.

All of this is explained in a recent blog post, but let me add 2 use cases to understand well:

  • you are home, you've just taken a video and some photos on your phone that you want to get on your computer. You have installed Cagou, the desktop/Android frontend of SàT on your device and already shared your photo directory. From your desktop computer, in the "file sharing" mode you see your device and you can directly download the video and the photos from there. The connection will be done directly on your local network, from device to device, and your files will not go throught a external server located whoever knows where.

  • you have files that you want to access at any time from anywhere (pictures or working documents for instance). You put them in a virtual directory on your file sharing component (a SàT instance too) and you can access it as simply as for the previous example.

Note that while with Cagou the connection is done directly when possible, it's not the case for Libervia which will first download the file on the server, before taking it throught HTTPS. WebRTC will be needed for the direct connection, and that's planned for 0.8 release.

Permission are handled easily: you specify who can access your files in a couple of clicks.

Files are transfered in clear for now (unencrypted), but this should not be the case anymore once finale release is here.

Photos albums

a photos album with a comment

Based on previous feature, a photos album mode display a directory containing only photos with adapted view, an with comments.

Permissions are really useful here, allowing to let, for instance, only your family see an album.

It's not yet possible to access an album from the interface of Libervia, to test it you'll have to change the URL by hand from the file handling page (by replacing files/list by photos/album).

Tickets

SàT tickets, first ones have been imported from Bugzilla

Developed from our own needs, SàT now handles tickets in pretty much the same way as a code forge. This is classical issue tracking, bugs report, tasks to do, etc.

Fields are free, it's really easy to use this feature for any kind of list: TO-DO tasks, but also, for instance, shopping lists.

Merge requests

a major patch is being reviewed

In the same spirit as tickets, SàT also handle "merge requests". Developed and used primarly for SàT itself, this system has the benefit or not being tied to a specific tool (like Git or Mercurial). Il is currently used with Mercurial, but it is possible to use it with whatever we want, and I'm not only talking about software code here.

Those 2 features means that SàT is a decentralised code forge. Even if it's still relatively basic, it has the benefit of being easy to use, flexible and adaptable. Furthermore there are only a few decentralised code forge at the moment (we can probably count Fossil, maybe some others).

Once again, contributions would accelerate things and would permit to have a very powerful tool.

Application

the dynamic part, which in under minimal maintenance and will be re-written for 0.8

To conclude this small tour of Libervia, we have to mention the application which is an entirely dynamic page, more elaborated but also more complicated to use (one of the main base version goal is to be easy to use).

Libervia web application allows to use widgets that you can drop next to each other, to do end to end encryption (OTR), or to publish blog post in simple or WYSIWYG mode, with the syntax you like (Markdown for instance).

It's the historic application which, for technical reasons, is now under minimal maintainance and have a few issues (like the contacts which can appear 2 times as seen in the screenshot above). It will be re-written for SàT 0.8, but it's let in place in this release for people who want to use it.

Cagou (desktop/Android)

Promised after the success of our crowfunding campaign, which allowed us to get a bit more than 3000 €, Cagou is our new frontend for desktop and Android devices. Its goals are to be modern, easy to use, and powerful.

Its original UI is inspired from Blender, and let split the screen to show several widgets at once. This UI has been thought in a way that it can be used even without knowing this split capacity, while being straightforward to use once the feature has been discovered.

To change mode, you just have to click on the top left icon.

For now, 5 modes are available: chat, contacts, file sharing, widget selector, and settings.

On the very top, you have a menu (only on desktop), and a notification zone, where messages appear for a few seconds and are visible entirely when clicking on the head of the left Cagou. On the other side, an other Cagou head can appear when you get notifications needing a user interaction (new contact for instance, or authentification request – see below –). This way, no popup will steal your focus while you are writing a message or doing something else.

Split

It is possible de split the screen as much as you want by clicking on the 3 dots area (on top and left borders), and then moving your mouse/finger. If the bar is red, this means that you'll close the area.

Here is a small animation to make things more clear:

demo of Cagou's widget split ability

You can organise the way you want, and monitor several things at the same time. In the future, it should be possible to keep handy widgets organisations so you can re-use them easily.

Chat

Cagou "chat" mode screenshot

The chat should be relatively intuitive. The top area show the current room or the identifier (JID) of the person you're talking to. It is possible to enter an other identifier manually to change room. For instance you can enter sat@chat.jabberfr.org to come on Salut à Toi room.

Still on the top area, the "padlock" icon on the right (only visible in 1/1 discussions) allows you to encrypt the conversation end to end, with OTR only for now (see below).

If you have several discussions at the same time, you can switch from one to the other by swiping your finger horizontally. Only discussions not already visible somewhere on the screen will be available, and for now they are in alphanumeric order (most certainly recent discussions will be available first when stable release will be out).

Finally, in the bottom area, in addition to the text input, you can see a + button with a circle which allows you to open a media transfer panel. On the desktop for now you can only select a file from your file-system, but on Android you can select/take a picture/video, a file or record an audio message. In every cases you can choose if you want to upload the file on your server, or send it directly to your contact, without transiting by the server.

file sharing

The principle has already been explained for Libervia, here is an animation showing how to share a directory with Cagou:

sharing a directory from Cagou

As you can see, you just have to do a long click/touch on the directory or file to share, and to select people which will have access to it.

You can click on "share local files" button, in the header zone, to change mode and see the device which are sharing. You'll then see – as with Libervia – 3 areas: the first one with sharing component, if any, the second one with your own devices (your phone or desk computer for instance), and finally the devices of your contacts. Once again, the input area let your filter devices to show.

see devices which can share files

Third party website authentification

SàT is a project which push the use of XMPP in every directions, and this include authentifying on third party websites. The idea is to be able to authenticate yourself without having to create an account on any website just by giving your JID.

Here is a video demo, thanks to the demo website made by jnanar, the screen on the right is a phone (displayed thanks to scrcpy):

super easy authentication with XMPP

You can implement this in your own website either by using Chteufleur component (Chteufleur is actually the original implementer of the feature in SàT, many thanks), either by using a server where it's already available (it's for instance the case on jabberfr, thanks to the admins of this server).

Please note that once it's in place, in your website you just have to do a single HTTPS request to validate authentication.

Contacts

No need to take much time on this mode, but it's good to know that you can add a new contact there (with the top button), or delete an existing one with a long click/touch.

A simple click will launch the chat mode with the selected contact.

Command line (JP)

There are far too many new things in jp to describe everything here.

Some useful informations anyway:

  • in jp we always put commands first, then arguments (jp [command] [subcommand] --arg_1 --arg_2 --etc)
  • jp [command] --help tells you how to use a command
  • jp shell let you use a REPL shell
  • it is possible to have high level and low level commands. For instance with the blog, you can have blog posts in a nice way by using jp blog get -s bloger@somewhere.tld -O fancy, or the raw XML with jp pubsub get -s bloger@somewhere.tld -n urn:xmpp:microblog:0
  • many commands have an output mechanism with --output (or -O). For instance jp blog get -s bloger@somewhere.tld -O json let you find metadata of a blog feed in JSON
  • jp can generate static websites thanks to --output template
  • when the website generator handle it, you can directly use the blog URL to edit it. For instance, I can edit one of my last posts by using jp blog edit -u https://www.goffi.org/b/khii3yEKWDhmNYSDt5GGrY/vers-forge-decentralisee-basee-xmpp where https://www.goffi.org/b/khii3yEKWDhmNYSDt5GGrY/vers-forge-decentralisee-basee-xmpp is the URL of the HTML generated page. I then have my text editor showing the code of my page on one side (in my favorite syntax) and the metadata on the other. Note the this works with webpage generated by Libervia, but also by Movim.

A small demo of the shell to read a blog:

checking a blog from shell (jp)

Test it!

You can test all this, the installation instructions are available (in English only, we are lacking resources to translate) on the wiki by clicking here.

SàT (backend + jp (CLI) + Primitivus (TUI)) is available in Debian experimental (thanks to Robotux, Naha, Debacle and other packagers).

SàT and its frontends (jp, Primitivus, Cagou, Libervia) are available on Arch Linux (thanks to jnanar and Link Mauve)

We got confirmation that SàT and Cagou are working on Mac OS X (thanks to xma), we would like help of people to also test it on Windows, BSD*, or anything else.

You can test on Android by clicking on this link from your device (installation from external resources must be activated from settings).

Note that this is an alpha version, that means:

  • it crashes, the code is not stable
  • all features are not finished, or even here
  • it's not optimised yet
  • it's not polished

Oh, and while we are talking about features not yet implemented, there are strong possibilities that end to end encryption with OMEMO will be implemented before final release, thanks notably to the new Python module available (thanks to Syndace, the author). End to end encryption is already available for years in SàT, but only with OTR so far.

Participate!

A last animation to show you the automatic language detection, an experimental feature:

language detection, then messages filtering

Let's stop here for the features, but we have not seen all of them.

As you can see, there's a lot to play with, and there is enough for every taste in this project.

And that's good, with summer holidays you'll have more time, a perfect occasion to contribute to a unique project, ethics and activist.

Do not hesitate to come on SàT XMPP room (sat@chat.jabberfr.org, also available without account, from the web).

If you are lacking time (picnic on the beach is nice too), support on Liberapay and/or adhering to the association is also helping.

Try to spread the word around you, our project lack visibility and needs you. If you are willing to host an instance, you can start to test (in a "experimental/not stable" part of your website), and give us feedbacks. We are also looking for people helping to package in every place where it's possible.

Thanks in advance, and see you soon!

C'est avec plaisir que je vous annonce la sortie de la première version alpha de Salut à Toi 0.7. Cela permet d'une part de vous montrer l'état, les avancées et l'orientation du projet, mais aussi de faire un appel à la contribution. Je vais dans la suite de cet article vous présenter une partie des capacités de Salut à Toi, ainsi que vous expliquer briévement comme les utiliser.

Vous trouverez un lien vers un fichier .apk pour tester sur Android dans la section « Testez ! ».

Pour mémoire, Salut à Toi est un écosystème collaboratif, multi interfaces (web, bureau, appareils portatifs, terminal, ligne de commande), multi-plateformes, et multi-usages. Il permet de gérer vos communications, de vous organiser, de partager vos fichiers, etc. C'est aussi, et avant tout un projet engagé qui prend en compte l'impacte des nouvelles technologies sur nos vies, et qui cherche à stimuler le débat public.

Nous allons nous concentrer sur les interfaces Web, et bureau/appareils portatifs, car ce sont celles qui sont les plus susceptibles d'intéresser le plus grand nombre.

Interface web (appelée « Libervia »)

Libervia a entamé des changements très importants, avec l'apparition d'un cadriciel (« framework » en anglais) web.

L'idée, expliquée dans un billet de blog est de fournir les composants de base (comptes et authentification, permissions, commentaires, etc.) directement utilisables et décentralisés grâce à XMPP. On construit ainsi facilement des sites automatiquement décentralisés et fédérés.

Notez que tout est prévu pour la traduction dans différentes langues, mais que pour l'instant seul l'anglais est disponible. De l'aide serait grandement appréciée pour améliorer cela !

Voyons les fonctionnalités déjà disponibles :

Chat

capture d'une discussion avec le « chat » de Libervia

Probablement le plus évident, il y a une application de messagerie instantanée. Pour l'utiliser il faut cliquer sur « Chat », et vous connecter si ce n'est pas encore fait.

Vous arrivez alors dans un panneau indiquant les salons contenus dans vos marque-pages, il vous suffit de cliquer sur l'un d'eux, ou d'indiquer l'identifiant (jid) d'un nouveau salon. C'est pour le moment assez basique, vous pouvez toutefois entrer « /help » pour avoir accès à liste des commandes textuelles.

Blog

mon blog, qui tourne avec Libervia Une des fonctionnalités phares de SàT, et peu courante dans le monde XMPP (le seul client activement développé le permettant également étant Movim), est le blog (qui est donc décentralisé).

Un clique sur le menu vous amènera sur une page de « découverte » où vous pourrez voir vos contacts ayant un blog. Cliquez sur l'un d'eux pour le lire, ou indiquez un identifiant pour en lire un qui n'est pas dans vos contacts.

Forums

un forum décentralisé qui tourne sur XMPP

Fonctionnalité unique dans le monde XMPP, SàT propose un système de forums, qui permet en pratique d'organiser des discussions dans des catégories. Les forums étant en arrière plan la même chose que les blogs, il est possible d'utiliser un blog comme forum et vice versa.

La création de forums se fait par un ou une administrateur/ice en ligne de commande avec l'outil « jp » (voir ci-dessous).

Événements

la liste personnelle des événements

Autre fonctionnalité unique dans le milieu XMPP (et en décentralisé ?), SàT permet de créer des événements, et bien sûr d'y inviter du monde.

Comme pour les autres fonctionnalités, la page est prévue pour être simple à utiliser : vous avec un bouton « créer un événement », qui vous mène à un formulaire. Un nom, un lieu et une date plus tard (et éventuellement une photo pour le représenter), et votre événement est créé. Vous arrivez alors sur la page d'administration où vous pouvez indiquer les personnes à inviter.

Les événements sont pour le moment privés, uniquement vous et vos invités y ont accès, mais des événements publiques sont prévus.

un invité répond à la demande RSVP d'un événement

À noter qu'il est possible (mais pas encore depuis l'interface web) d'ajouter des champs arbitraires à vos événements, permettant par exemple de préciser ce que vos invités amènent à un pique-nique.

Partage de fichiers

le partage de fichier depuis le navigateur

Là on touche à une fonctionnalité utile au quotidien, et dans beaucoup de circonstances. Salut à toi permettait depuis longtemps de s'envoyer des fichiers, ou d'en déposer sur votre serveur, mais il s'agit ici de partager un ou des répertoires, ou de déposer des fichiers sur un serveur.

Tout ceci est expliqué dans un récent billet de blog, mais je vous donne tout de même 2 exemples pour bien comprendre :

  • vous êtes chez vous, vous venez de prendre une vidéo et des photos sur votre téléphone que vous voulez voir sur votre ordinateur. Vous avez installé Cagou, l'interface bureau/Android de SàT sur votre appareil et partagé votre répertoire photo. Depuis votre ordinateur de bureau, dans la partie « partage de fichiers » vous voyez votre appareil et pouvez télécharger directement la vidéo et les photos. La connexion se fera directement sur le réseau local d'appareil à appareil, vos fichiers ne transiteront pas par un serveur situé on ne sait où.

  • vous avez des fichiers que vous voulez accéder de n'importe où n'importe quand (des photos ou des documents de travail par exemple). Vous les mettez dans un répertoire virtuel sur votre composant de partage de fichier (une instance SàT également, voir plus bas), et vous y accédez aussi simplement que dans l'exemple précédent.

Notez que bien qu'avec Cagou la connexion se fait directement quand c'est possible, ça n'est pas encore le cas pour Libervia qui téléchargera d'abord le fichier sur le serveur avant de la fournir en HTTPS. La connexion directe nécessitera WebRTC qui est prévu pour la version 0.8.

Les permissions se gèrent très simplement : vous indiquez qui a le droit d'accéder à vos fichiers en quelques cliques.

Les fichiers passent pour le moment en clair (non chiffré), mais ceci ne devrait plus être le cas d'ici la version finale.

Albums photos

un album photo avec un commentaire

Basé sur la fonctionnalité précédente, un mode album photos permet de présenter un dossier qui ne contient que des photos avec une vue adaptée, et de le commenter.

Les permissions sont très utiles ici, permettant de ne laisser, par exemple, que votre famille visionner un album.

Il n'est pas encore possible d’accéder à un album depuis l'interface de Libervia, pour tester vous allez devoir changer l'URL à la main depuis le partage de fichiers (en remplaçant files/list par photos/album).

Tickets

les tickets de SàT, les premiers ont été importés de Bugzilla

Développé pour nos propres besoins, SàT permet désormais de gérer des tickets à la façon d'une forge logicielle. On est dans le classique ticket de suivi, rapport de bogue, tâche à faire, etc.

Les champs sont libres, il est ainsi très facile d'utiliser cette fonctionnalité pour tout type de listes : tâches à faire, mais aussi, par exemple, liste de courses.

Requêtes de fusion

un patch essentiel est en cours de revue

Dans la lignée des tickets, SàT gère également les « requêtes de fusion » (ou « merge requests » en anglais). Développé et utilisé en premier lieu pour le développement de SàT lui-même, ce système a l'avantage de ne pas être lié à un outil particulier (comme Git ou Mercurial). Il est actuellement utilisé avec Mercurial, mais il est possible de l'utiliser avec ce que l'on souhaite, et cela n'est pas réservé au développement de code logiciel.

Ces 2 dernières fonctionnalités font de SàT une forge décentralisée. Même si elle est encore basique, elle a l'avantage d'être simple d'utilisation, souple et facilement adaptable, et surtout il n'existe pas ou peu de forge décentralisées à l'heure actuelle (on peut sans doute compter Fossil, et peut être d'autres).

Encore une fois, l'arrivée de contributions permettrait d’accélérer les choses et d'en faire un outil très puissant.

Application

la partie dynamique, qui est en maintenance minimal et sera réécrite pour la 0.8

Pour conclure ce petit tour de Libervia, notons l'application qui vous amènera à une version entièrement dynamique, plus élaborée mais également plus difficile à utiliser, la version de base voulant être facile à prendre en main.

L'application web Libervia permet d'utiliser des widgets que vous pouvez déposer côte à côte, de faire du chiffrement de bout en bout (via OTR), ou de publier des billets de blog en mode simple ou WYSIWYG, avec la syntaxe qui vous convient (Markdown par exemple).

Il s'agit de l'application historique qui pour des raisons techniques n'est plus qu'en maintenance minimale et comporte un certain nombre de problèmes (comme le contact qui apparait 2 fois, visible dans la capture ci-dessus). Elle sera réécrite pour SàT 0.8, mais est laissée dans cette version en l'état pour ceux qui souhaitent toujours l'utiliser.

Cagou (bureau/Android)

Promise suite à notre campagne de financement, qui nous a permis de récolter un peu plus de 3000 €, Cagou est notre nouvelle interface de bureau et pour appareils Android. Elle se veut moderne, facile à utiliser, et puissante.

Son interface originale est inspirée de Blender, elle permet de diviser l'écran pour afficher plusieurs widgets en même temps. Cette interface a été pensée pour qu'on puisse l'utiliser même sans connaître cette capacité de division, tout en étant évidant à utiliser une fois celle-ci découverte.

Pour utiliser un widget, cliquez tout simplement sur l’icône en haut à gauche du widget en cours pour sélectionner un autre.

Pour le moment, 5 widgets sont disponibles : chat, liste de contacts, partage de fichiers, sélectionneur de widgets et paramètres.

Tout en haut, vous avez un menu (uniquement sur le bureau) et une zone de notification, ou les messages apparaissent quelques secondes (et sont visibles en entier en cliquant sur la tête de Cagou gauche). De l'autre côté, une autre tête de Cagou peut apparaître quand vous recevez des notifications nécessitant une action de l'utilisateur (nouveau contact par exemple, ou demande d'authentification, voir ci-dessous). Ainsi pas de popup qui vole le focus quand vous tapez un message ou autre.

Split

Originalité de Cagou, inspirée de Blender, il est possible de diviser l'écran à volonté en cliquant sur les zones avec 3 points (en haut et à gauche) puis en les faisant glisser. Si la barre apparaît en rouge, cela veut signifie que vous allez fermer la zone. Une image animée devrait rendre les choses plus claires :

démonstration des capacités de séparation des widgets (split) de Cagou

Vous pouvez ainsi vous organiser comme vous l'entendez, et surveiller plusieurs choses en même temps. À terme il devrait être possible de garder les dispositions pratiques pour les remettre en place facilement.

Chat

capture du mode « chat » de Cagou

Le chat devrait être relativement intuitif. La zone du haut indique le salon ou l'identifiant (JID) de la personne avec laquelle vous discutez. Il est possible d'entrer un autre identifiant manuellement pour changer de salon, par exemple entrez sat@chat.jabberfr.org pour venir sur le salon de Salut à Toi.

Toujours en haut, l’icône « cadenas » à droite (visible uniquement dans les conversations 1/1) vous permet de chiffrer de bout en bout la conversation, avec OTR uniquement pour l'instant (voir plus bas).

Si vous avez plusieurs conversations en cours, vous pouvez passer de l'une à l'autre en balayant l'écran avec votre doigt horizontalement (mouvement aussi appelé « swipe »). Seules les conversations non déjà visibles sur l'écran seront disponibles, et pour le moment elles sont dans un ordre alphabétique (il est fort probable que les conversations récentes soit disponibles en premier d'ici la version stable).

Enfin dans la zone du bas, outre la zone de saisie vous voyer un bouton + cerclé qui permet d'ouvrir le panneau d'envoi de médias. Sur bureau vous n'avez pour le moment que la possibilité de choisir un fichier, mais sur Android vous pouvez sélectionner/prendre une photo, une vidéo, sélectionner un fichier, ou encore enregistrer un message audio. Dans tous les cas, vous pouvez choisir si vous voulez téléverser le fichier sur votre serveur, ou l'envoyer directement à votre correspondant, sans passer par le serveur.

Transfert de fichiers

Le principe a déjà été expliqué pour Libervia, voici une animation montrant comment partager un répertoire sur Cagou :

partager un répertoire depuis Cagou

Comme vous le voyez, il suffit de faire un clique/appui long sur le répertoire ou fichier à partager, et de sélectionner les personnes qui y auront accès.

Si vous cliquez sur le bouton « share local files » dans la zone d'en-tête pour changer de mode et voir les appareils qui partagent. Vous verrez alors apparaître – comme sur Libervia – 3 zones : la première avec les éventuels composants de partage, la deuxième avec vos propres appareils (votre téléphone ou ordinateur de bureau par exemple), et enfin les appareils de vos contacts. Là encore, la zone de saisie permet de filtrer les appareils affichés.

voir les appareils qui peuvent partager des fichiers

Authentification sur un site externe

SàT est un projet qui pousse à l'exploitation des différentes possibilités de XMPP, et notamment l'authentification sur des sites externes. Le principe est de pouvoir vous authentifier sans créer de compte sur n'importe quel site en indiquant juste votre JID.

Démonstration en vidéo, grâce au site de démo mis en place par jnanar, l'écran sur la droite est un téléphone (capturé avec scrcpy):

s'authentifier très simplement avec XMPP

Vous pouvez très facilement intégrer cela dans votre propre site soit en utilisant le composant de Chteufleur (qui est d’ailleurs à l'origine de l'implémentation dans SàT, un grand merci à lui), soit en utilisant un serveur où c'est déjà en place (c'est pas exemple le cas sur jabberfr grâce aux GA – gentils admins – de ce site).

Notez bien qu'une fois ceci en place, dans votre site vous n'avez besoin d'effectuer qu'une seule requête HTTPS pour valider une authentification (et ça serait super qu'un lecteur fasse l'implémentation pour LinuxFr).

Contacts

Pas besoin de s'éterniser sur ce mode, mais il est bon de savoir qu'il permet d'ajouter un contact en cliquant sur le bouton idoine en haut. Un/une clique/touche long(ue) permet également de supprimer un contact.

Un clique simple va lancer le mode discussion avec la personne choisie.

Ligne de commande (JP)

Il y a beaucoup trop de choses nouvelles dans jp pour tout décrire ici.

Quelques informations utiles tout de même :

  • dans jp on met toujours les commandes puis les arguments (jp [commande] [sous-commande] --arg_1 --arg_2 --etc)
  • jp [commande] --help vous permet de savoir comment utiliser une commande
  • jp shell vous permet d'avoir une invite de commande REPL
  • il est possible d'avoir des commandes haut niveau et bas niveau. Par exemple pour le blog, vous pouvez avoir les billets d'un blog mis en forme en faisant jp blog get -s blogueur@quelquepart.ext -O fancy, ou le XML bas niveau avec jp pubsub get -s blogueur@quelquepart.ext -n urn:xmpp:microblog:0
  • beaucoup de commandes disposent d'un système de mise en forme avec --output (ou -O). ainsi jp blog get -s blogueur@quelquepart.ext -O json vous permet de retrouver les métadonnées d'un fil de blog en JSON
  • jp est capable de générer des sites statiques grâce à --output template
  • quand le générateur de site le supporte, vous pouvez directement utiliser l'URL d'un blog pour l'éditer. Par exemple, je peux éditer un de mes derniers billets de blog en faisant jp blog edit -u https://www.goffi.org/b/khii3yEKWDhmNYSDt5GGrY/vers-forge-decentralisee-basee-xmpphttps://www.goffi.org/b/khii3yEKWDhmNYSDt5GGrY/vers-forge-decentralisee-basee-xmpp est l'URL de la page générée en HTML. Je me retrouve alors avec mon éditeur de texte affichant le code de ma page d'un côté (dans la syntaxe de mon choix) et les métadonnées de l'autre. Notez que cela fonctionne avec les sites générés par Libervia, mais également avec Movim.

Petite démonstration du shell pour lire un blog :

lecture d'un blog depuis le shell (jp)

Testez !

Vous pouvez tester tout cela, les instructions d'installations sont disponibles (en anglais seulement, nous manquons de moyens pour traduire) sur le wiki en cliquant ici.

SàT (backend + jp (CLI) + Primitivus (TUI)) est disponible dans Debian experimental (merci à Robotux, Naha, Debacle et les autres empaqueteurs).

SàT et ses frontaux (jp, Primitivus, Cagou, Libervia) sont disponibles sur Arch Linux (merci à jnanar et Link Mauve)

Nous avons eu confirmation que SàT et Cagou fonctionnent sur Mac OS X (merci à xma), nous aimerions du monde pour tester également sur Windows, BSD*, ou autre.

Vous pouvez tester sur Android en cliquant sur ce lien depuis votre appareil (il faut avoir autorisé les installations depuis les sources externes).

Notez bien qu'il s'agit d'une version alpha, ce qui signifie :

  • que ça plante, le code n'est pas encore stable
  • que toutes les fonctionnalités ne sont pas finies, ou présentes
  • que ça n'est pas optimisé
  • que ça n'est pas poli (graphiquement, il ne va vous insulter si vous êtes gentil avec lui)

Ah, en parlant de fonctionnalité non encore présente, il y a de très fortes chances que le chiffrement de bout en bout avec OMEMO soit implémenté d'ici la version finale, grâce entre autres à la disponibilité d'un nouveau module Python (merci à Syndace, son auteur). Le chiffrement de bout en bout est déjà disponible depuis plusieurs années, mais via OTR uniquement jusqu'ici.

Participez !

Une dernière animation pour vous montrer la détection automatique de la langue, une fonctionnalité expérimentale :

détection de la langue, puis filtrage des messages

Arrêtons-nous là pour les fonctionnalités, mais nous n'avons pas fait le tour.

Comme vous le voyez, il y a de quoi s'amuser et il y en a pour tous les goûts dans ce projet. Et ça tombe bien, avec les grandes vacances, vous avez certainement du temps devant vous, idéal pour contribuer sur un projet unique et engagé (engagez-vous qu'il disait) !

Vous pouvez commencer, par exemple, avec ce tutoriel pour écrire un greffon qui fonctionnera avec tous les frontaux.

N'hésitez pas à passer sur le salon XMPP de SàT (sat@chat.jabberfr.org, aussi accessible sans compte via le web).

Si jamais vous n'avez pas le temps (les pique-niques à plage c'est bien aussi), un soutien sur Liberapay et/ou une adhésion à l'association nous aide.

Essayez de faire passer le mot autour de vous, le projet manque de visibilité et a besoin de vous. Si vous souhaitez héberger une instance, vous pouvez commencer à tester (dans une partie « expérimentale/non stable » de votre site), et à nous faire des retours. Nous cherchons aussi du monde pour nous aider à empaqueter partout où c'est possible.

Merci d'avance, et à bientôt !