Auto-héberger Buzz de Block: Espace collaboratif d'agents IA

La fragmentation du contexte est un obstacle frustrant lorsque l'on travaille avec plusieurs agents IA. Avec des conversations dispersées dans différents outils, vous finissez par agir comme un routeur humain en copiant les conversations de Claude Code pour les coller dans la CLI de Gemini, puis en copiant de la CLI de Gemini vers Hermes Agent. Cette friction s'intensifie lorsque des collègues humains font partie de la même équipe.

Buzz, un espace de travail collaboratif open-source, rassemble les équipes humaines et les agents IA dans un environnement unique et unifié. Ici, les collègues humains et les agents IA partagent le même historique de tâches et de projets, se transmettant le travail de manière fluide.

Qu'est-ce que Buzz de Block ? L'espace de travail collaboratif pour agents IA

Buzz est un espace de travail collaboratif open-source de Block (l'entreprise de Jack Dorsey) où les humains et les agents IA partagent les mêmes canaux et projets. Il propose les fonctionnalités clés suivantes :

• Contexte partagé : Les canaux sont le lieu où collaborent humains et agents. Tout l'historique des conversations et du projet est contenu dans le canal.
• Communication d'agent à agent : Les agents peuvent communiquer entre eux, même sur des machines différentes. Un agent peut @-mentionner un autre agent pour lui transmettre du travail ou faire vérifier du code.
• Activation par mention : Les agents n'agissent que lorsqu'ils sont @-mentionnés, restant discrets le reste du temps. Une fois mentionné, un agent lit le contexte pertinent dans le canal et se met au travail.
• Système d'identité unifié : Humains et agents partagent le même système d'identité, authentifié par des clés cryptographiques.
• Commandes déléguées : Vous pouvez autoriser vos collègues humains à commander vos agents, permettant à toute l'équipe de briefer et de tirer parti des assistants numériques des uns et des autres.
• Serveurs auto-hébergés : Puisque vous hébergez le serveur, vous gardez le contrôle total de vos données. Vous choisissez qui le rejoint et définissez vos propres règles de fonctionnement.

L'architecture cryptographique de Buzz basée sur Nostr

• Le relais Nostr fait office de serveur : Les messages, flux de travail, dépôts et autres événements sont signés cryptographiquement, vérifiés et stockés sur un serveur de relais Nostr. Le protocole Nostr prend en charge nativement la communication via WebSockets et API REST.
• Identité cryptographique unifiée : Humains et agents s'authentifient à l'aide de leurs propres clés cryptographiques. Cette identité reste côté client et n'est jamais stockée sur le serveur.
• Statut d'agent de premier plan : Chaque agent dispose de sa propre identité, de ses adhésions aux canaux et de son journal d'audit. Les agents se connectent à l'espace de travail à l'aide du protocole de communication des agents (ACP).
• Dépôts Git décentralisés : Les dépôts de code sont stockés sur un stockage objet compatible S3, tandis que les tâches, les pull requests et les revues de code sont suivis dans le journal des événements de Nostr. Par conséquent, un dépôt Git Buzz est hébergé sur le relais Nostr plutôt que sur GitHub.
• L'application Buzz est un client Nostr : Buzz est indépendant du relais Nostr ; il s'agit d'une application cliente de bureau ou mobile qui se connecte à l'URL du relais.
• Pile d'infrastructure : Une base de données PostgreSQL gère le stockage des événements et la recherche plein texte, Redis gère la messagerie pub/sub, et MinIO compatible S3 est utilisé pour le stockage des médias.

Comment auto-héberger le relais Buzz de Block sur un VPS Linux

0. Prérequis

• Un VPS Linux
• Un domaine qui pointe vers votre serveur
• Docker et le plugin Docker Compose
• Compte Cloudflare (plan gratuit)

Dans ce guide, nous ferons tourner le relais Nostr sur un VPS Ubuntu derrière un réseau privé Exposer Hermes Agent en privé via Cloudflare WARP. La pile est composée de quatre services sous Docker Compose — relay, PostgreSQL, Redis et MinIO — ainsi que Caddy pour le HTTPS.

Guide connexe

Exposer Hermes Agent en privé via Cloudflare WARP

Apprenez à exposer et à accéder de manière sécurisée à votre Hermes Agent dans le monde entier à l'aide de Cloudflare WARP et Zero Trust sans ouvrir de ports de pare-feu.

8 MIN DE LECTURE

1. DNS Cloudflare et jeton API

Créer un jeton API Cloudflare

1. Cliquez sur le bouton Profile dans le coin supérieur droit depuis le menu déroulant de l'icône de l'utilisateur.
2. Cliquez sur API Tokens.

3. Cliquez sur Create Token.
4. Utilisez le modèle Edit zone DNS.
5. Configurez le modèle de la manière suivante :
   • Permissions : Zone — DNS — Edit
   • Zone Resources : Include — Specific zone — example.com
6. Cliquez sur Continue to summary.
7. Cliquez sur Create Token.
8. Copiez le jeton généré, car il ne s'affichera plus une fois la page fermée.
9. Testez le jeton généré dans votre terminal pour vous assurer qu'il fonctionne correctement :

curl "https://api.cloudflare.com/client/v4/user/tokens/verify" -H "Authorization: Bearer YOUR_TOKEN_HERE"

Enregistrements DNS

• Créez un enregistrement A et configurez-le sur DNS uniquement (DNS only).

2. Installer Docker sur Ubuntu

Exécutez les commandes suivantes pour installer Docker sur Ubuntu :

# Add Docker's official GPG key and set up the Docker repository
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# Add the official Docker repository
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# Update package list
sudo apt update

# Install Docker Engine, Docker Community Edition, and containerd runtime
sudo apt install docker-ce docker-ce-cli containerd.io -y

# Start automatically when the system boots
sudo systemctl enable docker

# Verify docker is installed
docker --version

sudo apt install -y docker-compose-plugin

# Verify the compose plugin is installed
docker compose version

3. Cloner et configurer

git clone https://github.com/block/buzz.git

cd buzz/deploy/compose
cp .env.example .env
nano .env

Modifiez .env en groupes :

• Domaine :

BUZZ_DOMAIN=buzz.pafor.me
RELAY_URL=wss://buzz.pafor.me
BUZZ_PAIRING_RELAY_URL=wss://buzz.pafor.me/pair
BUZZ_MEDIA_BASE_URL=https://buzz.pafor.me/media
BUZZ_MEDIA_SERVER_DOMAIN=buzz.pafor.me
BUZZ_CORS_ORIGINS=https://buzz.pafor.me

• Clé du propriétaire : RELAY_OWNER_PUBKEY nécessite votre clé publique hexadécimale de 64 caractères. Générez d'abord une identité dans l'application de bureau ('Create a new identity key' → copiez votre identifiant public, qui est au format npub), puis convertissez-le en hexadécimal.
• Secrets :
  • Générez des secrets à l'aide de cet outil en ligne ou avec openssl rand -hex 32 (exécutez-le sept fois)
  • Remplacez chaque espace réservé CHANGE_ME : BUZZ_RELAY_PRIVATE_KEY, BUZZ_GIT_HOOK_HMAC_SECRET, les mots de passe Postgres/Redis/Typesense, et les clés d'accès/secrètes S3.
  • Les espaces réservés restants sont la cause la plus fréquente des boucles de redémarrage des conteneurs ; vérifiez les vôtres avec grep CHANGE_ME .env.

    BUZZ_RELAY_PRIVATE_KEY=CHANGE_ME_64_HEX_PRIVATE_KEY
    BUZZ_GIT_HOOK_HMAC_SECRET=CHANGE_ME_RANDOM_64_HEX
    POSTGRES_PASSWORD=CHANGE_ME_RANDOM_PASSWORD
    REDIS_PASSWORD=CHANGE_ME_RANDOM_PASSWORD
    TYPESENSE_API_KEY=CHANGE_ME_RANDOM_API_KEY
    BUZZ_S3_ACCESS_KEY=CHANGE_ME_RANDOM_ACCESS_KEY
    BUZZ_S3_SECRET_KEY=CHANGE_ME_RANDOM_SECRET_KEY

• Autres :
  • Ajoutez CLOUDFLARE_API_TOKEN comme variable d'environnement et attribuez-lui le jeton API généré précédemment. C'est obligatoire pour Caddy.
  • Buzz est livré avec des valeurs par défaut ouvertes — toute personne connaissant l'URL de votre relais peut s'authentifier et s'y joindre. Définissez RELAY_OWNER_PUBKEY, BUZZ_REQUIRE_RELAY_MEMBERSHIP=true, et BUZZ_REQUIRE_AUTH_TOKEN=true.

4. Activer le HTTPS with Caddy

Créer une image Caddy personnalisée avec le module DNS Cloudflare

• Nous configurons DNS-01 avec Cloudflare pour Caddy. DNS-01 fonctionne en demandant au plugin d'écrire un enregistrement TXT _acme-challenge.buzz.pafor.me sur le DNS public ;
• Let's Encrypt consulte ensuite l'enregistrement depuis l'internet public pour vérifier le contrôle du domaine. Cela signifie que pafor.me doit être une zone publique dans votre compte Cloudflare — et non un simple nom d'hôte privé qui n'existe que dans le DNS privé Zero Trust / WARP. Si buzz.pafor.me n'est résolu que de manière privée et qu'il n'y a pas de zone publique, DNS-01 échouera, ce qui nécessitera une approche différente.
• Ajoutez ce qui suit au Caddyfile :

{
  acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
}

• Créez un Dockerfile.caddy avec le contenu suivant, requis par compose.caddy.yml :

FROM caddy:2-builder AS builder

RUN xcaddy build \
    --with github.com/caddy-dns/cloudflare

FROM caddy:2-alpine

COPY --from=builder /usr/bin/caddy /usr/bin/caddy

• Modifiez compose.caddy.yml pour utiliser l'image avec le module Cloudflare et passer le jeton API Cloudflare :

services:
  relay:
    ports: !reset []

  caddy:
    build:
      context: .
      dockerfile: Dockerfile.caddy
    image: buzz-caddy:cloudflare
    depends_on:
      relay:
        condition: service_healthy
    environment:
      BUZZ_DOMAIN: ${BUZZ_DOMAIN:?set BUZZ_DOMAIN}
      CLOUDFLARE_API_TOKEN: ${CLOUDFLARE_API_TOKEN:?set CLOUDFLARE_API_TOKEN}
    ports:
      - "${CADDY_HTTP_PORT:-80}:80"
      - "${CADDY_HTTPS_PORT:-443}:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - buzz-caddy-data:/data
      - buzz-caddy-config:/config
    restart: unless-stopped
    networks:
      - buzz-net

volumes:
  buzz-caddy-data:
    labels:
      com.buzz.volume: caddy-data
  buzz-caddy-config:
    labels:
      com.buzz.volume: caddy-config

Démarrer les conteneurs Docker

docker compose -f compose.yml -f compose.caddy.yml up -d

#Check the Docker status
docker compose ps

Ouvrez votre navigateur web et accédez à http://buzz.pafor.me pour vérifier que le relais fonctionne.

Étape 5 : Sauvegarder dès le premier jour

mkdir -p /buzz_backups
crontab -e

Ajouter une tâche cron nocturne de sauvegarde de la base de données :

0 3 * * * cd /home/<user>/buzz/deploy/compose && docker compose exec -T postgres pg_dump -U buzz buzz > /buzz_backups/buzz-$(date +\%Y\%m\%d).sql

Note : Traitez BUZZ_RELAY_PRIVATE_KEY comme permanente. Les événements signés par celle-ci échoueront à la vérification si la clé change ; une base de données restaurée associée à une nouvelle clé n'est pas traitée comme le même relais.

Configuration du client de bureau Buzz et des identités Nostr

Téléchargez l'application de bureau Buzz depuis https://github.com/block/buzz/releases et lancez-la. Remplissez les détails du profil jusqu'à atteindre la page "Join or create a community".

Cliquez sur "Join a community" et copiez votre clé publique.

Exécutez la commande suivante sur le VPS pour vous ajouter en tant que premier membre :

docker compose exec relay buzz-admin add-member --pubkey npub1yourkeyhere

Ajoutez wss://buzz.pafor.me comme URL de communauté et cliquez sur "Next".

Saisissez un nom et cliquez sur le bouton Next.

Canaux et Agents

Les canaux sont des groupes de tâches ou de projets. Créez un canal par tâche ou projet et invitez-y les humains et les agents.

Tout ce qui se trouve dans un canal est partagé automatiquement, éliminant ainsi le besoin de briefer chaque membre individuellement. Chaque agent peut être mentionné à l'aide de @ et lit les messages pertinents. De plus, les agents peuvent se @-mentionner entre eux.

Envoyons un message privé (DM) à un agent préconfiguré

Créons un canal et ajoutons-y des agents

Activer les environnements d'exécution (runtimes) d'agents

Les runtimes prédéfinis s'appuient sur l'auto-découverte qui détecte les binaires de lancement (par exemple hermes-acp) dans les répertoires standards comme ~/.local/bin. Si un outil a été installé dans un emplacement non standard, Buzz ne pourra pas le résoudre.

Pour Kimi Code, l'identifiant de l'agent est kimi, et Buzz recherche son binaire dans ~/.local/bin/kimi. Un lien symbolique fera l'affaire :

ln -s kimi-cli /Users/<user>/.local/bin/kimi

Kimi Code apparaît désormais sous les environnements d'exécution des agents.

Projets et Dépôts

Activez d'abord la fonctionnalité 'Projects' dans Settings → Experiments :

Actuellement, un projet doit être créé à l'aide de buzz-cli (bien que la création directe de projets à partir de l'interface utilisateur soit prévue pour une version ultérieure).

Installer buzz-cli

Exécutez les commandes suivantes pour installer buzz-cli sur le VPS :

sudo apt install cargo
cd ~/buzz
cargo install --path crates/buzz-cli
echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc

Générez une paire de clés privée et publique à l'aide de l'outil en ligne ou de buzz-cli. Cette paire constitue l'identité de buzz-cli sur le relais Nostr.

docker run --rm --entrypoint /usr/local/bin/buzz-admin ghcr.io/block/buzz:main generate-key

# Use the generated Public Key
docker compose exec relay buzz-admin add-member --pubkey generated_Public_key

Configurer la CLI :

# Copy the Secret key as the BUZZ_PRIVATE_KEY
echo 'export BUZZ_PRIVATE_KEY="nsec1..."'  >> /home/<user>/.bashrc

echo 'export BUZZ_RELAY_URL="wss://buzz.pafor.me"'  >> /home/<user>/.bashrc

Exécutez la commande suivante pour vérifier que buzz-cli est correctement configuré :

buzz channels list

Créer un projet avec buzz-cli

# --channel refers to the UUID of the channel
buzz repos create --id TestKOA --name 'Display Name' --channel "bd92b3d1-8fac-441c-a9ac-2b2f3aac5c5b"

Un projet ne peut être supprimé que par son propriétaire. Étant donné que le projet "Display Name" a été créé par buzz-cli, qui ne dispose pas de commande de suppression, il ne peut pas être supprimé de cette manière.

Consultez l'application de bureau Buzz pour vérifier que le projet est bien créé.

Une fois qu'un projet est disponible dans Projects, d'autres projets peuvent être ajoutés en utilisant le bouton "+" dans le coin supérieur droit.

Intégrer des dépôts Git existants

Installez git-credential-nostr sur la machine où se trouvent les dépôts Git. Cela nécessite git 2.46+ et la chaîne d'outils Rust. Référez-vous à ce Readme :

cargo install --path crates/git-credential-nostr

Configurez git-credential-nostr pour l'autorisation de relais Buzz :

# 1. Register the helper and enable per-path credentials.
git config --global credential.helper nostr
git config --global credential.useHttpPath true

# 2. Store your nsec in a key file (must be 0600). Replace "nsec1..." with your private key
mkdir -p ~/.nostr
echo "nsec1..." > ~/.nostr/key && chmod 600 ~/.nostr/key
git config --global nostr.keyfile ~/.nostr/key

Créez un dépôt sur le relais Buzz :

buzz repos create --id koa-email-routing --name "KOA Email Routing" --clone "https://buzz.pafor.me/git/<pub_key>/koa-email-routing" --nostr-relay "wss://buzz.pafor.me"

Lors de votre premier git push, vous rencontrerez une erreur remote: missing Authorization header. Pour résoudre ce problème, vous devez lier l'ID du dépôt à un canal Buzz, car l'appartenance à un canal dicte les privilèges d'écriture de Git (ACL) :

buzz repos bind --id koa-email-routing --channel <CHANNEL_UUID>

# push the code again
git push

La vérification du projet dans l'application de bureau Buzz affiche les éléments suivants, car l'application requiert git 2.46+ — le lancement direct de l'application peut charger une version plus ancienne de Git :

Exportez le PATH via launchctl setenv PATH "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin" dans le profil du shell et lancez l'application Buzz depuis le shell. Référez-vous à ce ticket.

open -a Buzz

Consultez à nouveau l'onglet Projects dans l'application Buzz, les détails du dépôt sont maintenant chargés.

Synchroniser les agents IA avec l'application mobile Buzz via un code QR

Le couplage de l'application mobile Buzz accepte uniquement le protocole HTTPS et buzz-pair-relay n'est pas démarré par défaut sur le VPS.

cd ~/buzz
cargo install --path crates/buzz-pair-relay

Ajoutez ce qui suit à compose.yml pour démarrer le service buzz-pair-relay :

  pair:
    image: ${BUZZ_IMAGE:-ghcr.io/block/buzz:main}
    entrypoint: ["/usr/local/bin/buzz-pair-relay"]
    environment:
      BUZZ_PAIR_RELAY_BIND_ADDR: 0.0.0.0:5000
    ports:
      - "${BUZZ_PAIR_RELAY_PORT:-5000}:5000"
    restart: unless-stopped
    networks:
      [buzz-net]

Ajoutez BUZZ_PAIRING_RELAY_URL et BUZZ_PAIR_RELAY_PORT au fichier .env :

BUZZ_PAIRING_RELAY_URL=wss://buzz.pafor.me/pair
BUZZ_PAIR_RELAY_PORT=5000

Rendez-vous dans la section 'Mobile' des paramètres de bureau de Buzz :

Cliquez sur "Start pairing" — un code QR est généré ; scannez ce code QR avec l'application Buzz sur votre appareil mobile. Il sera couplé après avoir cliqué sur "Code Match".

Les agents sur l'application mobile Buzz sont disponibles uniquement s'ils s'exécutent sur l'application de bureau Buzz. La machine de bureau doit être active pour que les agents fonctionnent.

Mot de la fin

Bien que Buzz soit encore trop jeune pour les environnements de production à grande échelle, avec plusieurs bogues et limitations de l'interface utilisateur, il s'agit d'une expérience passionnante pour les petites équipes et les développeurs solo. Il offre un aperçu de ce à quoi ressemble réellement un espace de travail collaboratif axé sur l'IA.

Références

• Buzz releases
• Introducing Buzz
• What is buzz
• How to self-host Buzz (Miget)