Loic Wiki - Modifications récentes [fr]

Accéder et capturer une page web via un tunnel SSH

Daneel — Fri, 17 Jul 2026 13:59:25 GMT

Création du guide de tunnel SSH, capture Chromium et envoi Telegram OpenClaw

Nouvelle page

{{DISPLAYTITLE:Accéder et capturer une page web via un tunnel SSH}}

Ce guide explique comment consulter depuis une autre machine un service web qui n'écoute que sur l'interface locale d'un serveur, vérifier son accès, en faire une capture d'écran puis envoyer cette capture dans Telegram avec OpenClaw.

L'exemple utilise l'application '''AI Tester''' de Hermes sur la machine <code>tas</code>. Le service est publié uniquement sur <code>tas:127.0.0.1:5000</code> : il n'est donc pas directement accessible depuis le réseau.

Dernière vérification : 17 juillet 2026.

__TOC__

== Principe ==

Le tunnel local SSH suit ce trajet :

<pre>
Chromium ou curl
→ client:127.0.0.1:15000
→ tunnel SSH
→ tas:127.0.0.1:5000
</pre>

Le port <code>15000</code> est le port d'entrée choisi sur la machine cliente. La destination <code>127.0.0.1:5000</code> est interprétée depuis le serveur SSH <code>tas</code>.

== Prérequis ==

Sur la machine cliente :

* un accès SSH par clé au compte <code>loic@tas</code> ;
* <code>curl</code> pour vérifier la réponse HTTP ;
* Google Chrome ou Chromium pour produire la capture ;
* OpenClaw configuré pour Telegram si la capture doit être envoyée par la CLI.

Le service doit déjà répondre sur <code>tas:127.0.0.1:5000</code>.

== Ouvrir le tunnel SSH ==

Dans un premier terminal sur la machine cliente :

<syntaxhighlight lang="bash">
ssh \
-N \
-o ExitOnForwardFailure=yes \
-L 127.0.0.1:15000:127.0.0.1:5000 \
loic@tas
</syntaxhighlight>

La commande reste au premier plan pendant toute l'utilisation du tunnel.

Signification des paramètres :

* <code>-N</code> : ne lance aucune commande distante ;
* <code>-L</code> : crée une redirection locale ;
* <code>127.0.0.1:15000</code> : adresse et port d'entrée sur la machine cliente ;
* <code>127.0.0.1:5000</code> : service de destination vu depuis <code>tas</code> ;
* <code>ExitOnForwardFailure=yes</code> : arrête immédiatement SSH si le tunnel ne peut pas être créé.

Si la clé n'est pas sélectionnée automatiquement, préciser son chemin :

<syntaxhighlight lang="bash">
ssh \
-i ~/.ssh/id_rsa_user \
-N \
-o ExitOnForwardFailure=yes \
-L 127.0.0.1:15000:127.0.0.1:5000 \
loic@tas
</syntaxhighlight>

Le préfixe local <code>127.0.0.1:</code> empêche les autres machines du réseau d'utiliser ce tunnel.

== Vérifier l'accès HTTP ==

Dans un second terminal sur la machine cliente :

<syntaxhighlight lang="bash">
curl --fail --show-error \
-o /dev/null \
-w 'HTTP %{http_code} | %{content_type}\n' \
http://127.0.0.1:15000/
</syntaxhighlight>

Réponse attendue :

<pre>
HTTP 200 | text/html; charset=utf-8
</pre>

Pour ouvrir la page manuellement, utiliser dans le navigateur de la machine cliente :

<pre>
http://127.0.0.1:15000/
</pre>

== Capturer la page avec Chromium ==

Avec Google Chrome :

<syntaxhighlight lang="bash">
google-chrome \
--headless \
--disable-gpu \
--screenshot="$PWD/hermes-ai-tester-home.png" \
--window-size=1440,1100 \
http://127.0.0.1:15000/
</syntaxhighlight>

Avec Chromium, remplacer simplement <code>google-chrome</code> par <code>chromium</code> ou <code>chromium-browser</code> selon la distribution.

Vérifier ensuite le fichier :

<syntaxhighlight lang="bash">
file "$PWD/hermes-ai-tester-home.png"
</syntaxhighlight>

== Envoyer la capture dans Telegram avec OpenClaw ==

Remplacer <code>IDENTIFIANT_DU_CHAT</code> par l'identifiant du chat Telegram destinataire :

<syntaxhighlight lang="bash">
openclaw message send \
--channel telegram \
--target 'IDENTIFIANT_DU_CHAT' \
--message 'Capture de la page d’accueil AI Tester via tunnel SSH.' \
--media "$PWD/hermes-ai-tester-home.png"
</syntaxhighlight>

Cette commande envoie un fichier existant. Elle ne lance pas de modèle de langage.

Pour vérifier la commande sans envoyer de message :

<syntaxhighlight lang="bash">
openclaw message send \
--dry-run \
--channel telegram \
--target 'IDENTIFIANT_DU_CHAT' \
--message 'Capture de test.' \
--media "$PWD/hermes-ai-tester-home.png"
</syntaxhighlight>

== Fermer le tunnel ==

Revenir dans le premier terminal et presser <code>Ctrl+C</code>. Le port local <code>15000</code> est alors libéré.

Vérification facultative :

<syntaxhighlight lang="bash">
curl --max-time 2 http://127.0.0.1:15000/
</syntaxhighlight>

Après fermeture, cette commande doit échouer avec une erreur de connexion.

== Dépannage ==

=== Le port local 15000 est déjà occupé ===

Choisir un autre port d'entrée, par exemple <code>15001</code>, dans la commande SSH et dans toutes les URL locales.

=== SSH affiche « No route to host » ===

Vérifier la résolution de <code>tas</code>, sa route réseau, son adresse IP et l'accessibilité du port SSH :

<syntaxhighlight lang="bash">
getent hosts tas
ssh -v loic@tas
</syntaxhighlight>

=== SSH affiche « Permission denied (publickey) » ===

Vérifier le compte distant, le chemin de la clé et la présence de sa clé publique dans <code>~/.ssh/authorized_keys</code> sur <code>tas</code>.

=== curl renvoie « Connection refused » ===

Le tunnel peut être établi alors que le service cible ne fonctionne pas. Depuis <code>tas</code>, contrôler directement :

<syntaxhighlight lang="bash">
curl -I http://127.0.0.1:5000/
</syntaxhighlight>

=== Précautions de sécurité ===

* conserver l'écoute locale du tunnel sur <code>127.0.0.1</code> ;
* ne pas publier directement AI Tester sur Internet ;
* ne pas exposer un serveur Flask/Werkzeug de développement sans authentification ni reverse proxy adapté ;
* vérifier le destinataire avant d'utiliser <code>openclaw message send</code> sans <code>--dry-run</code>.

== Résumé des commandes ==

<syntaxhighlight lang="bash">
# Terminal 1 : tunnel
ssh -N -o ExitOnForwardFailure=yes \
-L 127.0.0.1:15000:127.0.0.1:5000 loic@tas

# Terminal 2 : test
curl --fail --show-error -o /dev/null \
-w 'HTTP %{http_code} | %{content_type}\n' \
http://127.0.0.1:15000/

# Capture
google-chrome --headless --disable-gpu \
--screenshot="$PWD/hermes-ai-tester-home.png" \
--window-size=1440,1100 \
http://127.0.0.1:15000/

# Envoi Telegram
openclaw message send \
--channel telegram \
--target 'IDENTIFIANT_DU_CHAT' \
--message 'Capture AI Tester via tunnel SSH.' \
--media "$PWD/hermes-ai-tester-home.png"
</syntaxhighlight>

[[Category:SSH]]
[[Category:OpenClaw]]
[[Category:Hermes]]

Trace install tas - Hermes Agent

Daneel — Thu, 16 Jul 2026 21:22:07 GMT

Documente le port local 5000 et le tunnel SSH pour AI Tester

← Version précédente		Version du 16 juillet 2026 à 23:22
Ligne 25 :		Ligne 25 :
	== Accès ==		== Accès ==
	* Local service : `127.0.0.1:8642`		* Local service : `127.0.0.1:8642`
			* AI Tester local : `127.0.0.1:5000` lorsqu'une instance de l'application est lancée dans le conteneur
	* Public HTTP : aucun par défaut		* Public HTTP : aucun par défaut
	* Messagerie prévue : Telegram via un second bot dédié à créer		* Messagerie prévue : Telegram via un second bot dédié à créer
Ligne 30 :		Ligne 31 :
	== Ports ==		== Ports ==
	* `8642` local uniquement		* `8642` local uniquement
			* `5000` local uniquement, publié par le Quadlet pour AI Tester ; aucun accès direct depuis le LAN ou Internet
	* `9222` non publié ; accessible uniquement sur le réseau Podman privé `hermes-net`		* `9222` non publié ; accessible uniquement sur le réseau Podman privé `hermes-net`

			== Accès temporaire à AI Tester ==
			Le Quadlet publie `127.0.0.1:5000:5000`. L'application Flask doit néanmoins être lancée dans le conteneur :
			* `podman exec -d --user hermes --workdir /opt/data/ai-tester hermes uv run flask --app ai_tester.web run --host 0.0.0.0 --port 5000`
			* contrôle depuis `tas` : `curl -I http://127.0.0.1:5000/`

			Depuis une autre machine disposant d'un accès SSH à `tas` :
			* ouvrir le tunnel : `ssh -L 5000:127.0.0.1:5000 tas`
			* consulter ensuite `http://127.0.0.1:5000` dans le navigateur local

			Le serveur Werkzeug utilisé est un serveur de développement sans protection adaptée à une exposition publique. Ne pas publier ce port sur `0.0.0.0` et ne pas l'ajouter directement à Caddy. Le processus Flask lancé avec `podman exec -d` n'est pas persistant et disparaît lors d'une recréation de `hermes.service`.

	== Exécution / runtime ==		== Exécution / runtime ==

Utiliser les chats Hermes et OpenClaw en ligne de commande

Daneel — Thu, 16 Jul 2026 18:05:53 GMT

Création du guide CLI Hermes et OpenClaw avec sélection explicite de modèle

Nouvelle page

{{DISPLAYTITLE:Utiliser les chats Hermes et OpenClaw en ligne de commande}}

Ce guide décrit les commandes de consultation et de reprise de conversation pour Hermes Agent et OpenClaw sur la machine ''tas''.

Dernière vérification : 16 juillet 2026, avec Hermes dans le conteneur Podman <code>hermes</code> et OpenClaw 2026.7.1.

__TOC__

== Différence entre <code>hermes -z</code> et <code>hermes chat</code> ==

Hermes propose deux modes non interactifs principaux :

* <code>hermes -z "..."</code> : appel ponctuel destiné aux scripts, avec uniquement la réponse finale sur la sortie standard ;
* <code>hermes chat -q "..."</code> : tour de chat complet, capable de créer ou reprendre une session et offrant davantage de contrôles.

L'option <code>-z</code> contourne automatiquement les demandes d'approbation. Elle doit donc rester réservée aux demandes textuelles bornées, sans action sensible. Pour utiliser des outils, conserver un historique ou reprendre une conversation, préférer <code>hermes chat</code>.

== Requêter Hermes ==

=== Question ponctuelle sans action ===

<syntaxhighlight lang="bash">
podman exec hermes hermes -z \
"Définis Podman Quadlet en trois phrases, sans utiliser d'outil."
</syntaxhighlight>

Ne pas employer cette forme pour une consigne susceptible de modifier des fichiers, d'exécuter une commande dangereuse ou d'envoyer un message.

=== Requête contrôlée dans une session distincte ===

<syntaxhighlight lang="bash">
podman exec hermes hermes chat \
--query "Analyse cette architecture sans rien modifier." \
--quiet \
--source tool \
--max-turns 5
</syntaxhighlight>

* <code>--quiet</code> réduit l'affichage aux résultats utiles ;
* <code>--source tool</code> identifie la session comme un appel programmatique ;
* <code>--max-turns 5</code> borne le nombre d'itérations de l'agent.

=== Conversation interactive dans le terminal ===

<syntaxhighlight lang="bash">
podman exec -it hermes hermes chat --cli
</syntaxhighlight>

Pour utiliser l'interface moderne, remplacer <code>--cli</code> par <code>--tui</code>.

=== Choisir explicitement un modèle Hermes ===

L'exemple suivant force <code>gpt-5.6-sol</code> via le provider <code>openai-codex</code> uniquement pour cet appel :

<syntaxhighlight lang="bash">
podman exec hermes hermes chat \
--provider openai-codex \
--model 'gpt-5.6-sol' \
--query "Compare Docker et Podman, sans effectuer d'action." \
--quiet \
--source tool
</syntaxhighlight>

Pour forcer à la place le modèle Ollama local de secours :

<syntaxhighlight lang="bash">
podman exec hermes hermes chat \
--provider custom \
--model 'gemma4:e4b-it-q8_0_128k' \
--query "Compare Docker et Podman, sans effectuer d'action." \
--quiet \
--source tool
</syntaxhighlight>

Ces choix temporaires ne modifient pas le modèle configuré par défaut.

== Reprendre le chat Hermes utilisé par Telegram ==

=== Retrouver la session Telegram ===

<syntaxhighlight lang="bash">
podman exec hermes hermes sessions list --source telegram --limit 10
</syntaxhighlight>

La colonne <code>ID</code> fournit l'identifiant à passer à <code>--resume</code>. Toujours relire la liste avant usage afin de sélectionner la bonne conversation.

=== Reprendre le contexte depuis le terminal ===

Mode interactif :

<syntaxhighlight lang="bash">
podman exec -it hermes hermes chat \
--resume ID_DE_SESSION \
--cli
</syntaxhighlight>

Tour unique :

<syntaxhighlight lang="bash">
podman exec hermes hermes chat \
--resume ID_DE_SESSION \
--query "Poursuis l'analyse précédente sans rien modifier." \
--quiet
</syntaxhighlight>

<code>--resume</code> recharge le contexte de la conversation Telegram, mais une réponse produite par la CLI reste affichée dans le terminal. Elle n'est pas publiée automatiquement dans Telegram.

=== Envoyer explicitement un texte dans Telegram ===

Après validation humaine du texte :

<syntaxhighlight lang="bash">
podman exec hermes hermes send \
--to telegram \
"Texte validé à publier dans le chat Telegram."
</syntaxhighlight>

<code>hermes send</code> ne lance aucun LLM : la commande livre seulement le texte fourni. Pour poursuivre naturellement le contexte et recevoir la réponse dans Telegram, la méthode la plus simple reste d'écrire directement à <code>@LoicHermesBot</code>.

== Commandes équivalentes avec OpenClaw ==

=== Tour ponctuel sans livraison externe ===

<syntaxhighlight lang="bash">
openclaw agent \
--agent main \
--session-key agent:main:consultation-cli \
--message "Définis Podman Quadlet en trois phrases." \
--json
</syntaxhighlight>

Sans <code>--deliver</code>, le résultat revient dans le terminal et n'est pas envoyé dans Telegram.

=== Choisir explicitement un modèle OpenClaw ===

Le modèle doit être un identifiant présent dans <code>openclaw models list</code>. Exemple :

<syntaxhighlight lang="bash">
openclaw agent \
--agent main \
--session-key agent:main:consultation-gpt54 \
--model 'openai/gpt-5.4' \
--message "Compare Docker et Podman en cinq points." \
--json
</syntaxhighlight>

Cette surcharge vaut pour ce tour ; elle ne change pas la configuration globale. Si l'identifiant n'est pas disponible dans l'installation, le remplacer par une valeur effectivement affichée par :

<syntaxhighlight lang="bash">
openclaw models list
</syntaxhighlight>

=== Lister et reprendre une session ===

<syntaxhighlight lang="bash">
openclaw sessions --agent main --limit 20
</syntaxhighlight>

Reprise par clé :

<syntaxhighlight lang="bash">
openclaw agent \
--session-key 'CLE_DE_SESSION' \
--message "Poursuis l'analyse précédente." \
--json
</syntaxhighlight>

Reprise par identifiant :

<syntaxhighlight lang="bash">
openclaw agent \
--session-id 'ID_DE_SESSION' \
--message "Poursuis l'analyse précédente." \
--json
</syntaxhighlight>

=== Interface terminal ===

<syntaxhighlight lang="bash">
openclaw tui --session 'CLE_DE_SESSION'
</syntaxhighlight>

Ajouter <code>--deliver</code> uniquement si les réponses doivent être livrées au canal externe associé à la session.

=== Répondre dans une conversation Telegram OpenClaw ===

Retrouver d'abord la session :

<syntaxhighlight lang="bash">
openclaw sessions --agent main --json
</syntaxhighlight>

Puis lancer le tour sur sa clé exacte avec livraison explicite :

<syntaxhighlight lang="bash">
openclaw agent \
--session-key 'CLE_DE_SESSION_TELEGRAM' \
--message "Poursuis notre échange précédent." \
--channel telegram \
--deliver
</syntaxhighlight>

Pour imposer une destination de réponse distincte :

<syntaxhighlight lang="bash">
openclaw agent \
--session-key 'CLE_DE_SESSION_TELEGRAM' \
--message "Prépare puis envoie la réponse." \
--deliver \
--reply-channel telegram \
--reply-to 'IDENTIFIANT_DU_CHAT'
</syntaxhighlight>

=== Envoyer un texte sans appeler le LLM ===

<syntaxhighlight lang="bash">
openclaw message send \
--channel telegram \
--target 'IDENTIFIANT_DU_CHAT' \
--message "Texte déjà validé."
</syntaxhighlight>

Cette commande livre un texte existant ; elle ne lance pas de tour d'agent.

== Correspondances rapides ==

{| class="wikitable"
! Besoin
! Hermes
! OpenClaw
|-
| Question ponctuelle
| <code>hermes -z "..."</code>
| <code>openclaw agent --message "..."</code>
|-
| Tour contrôlé
| <code>hermes chat -q "..."</code>
| <code>openclaw agent --message "..."</code>
|-
| Lister les sessions
| <code>hermes sessions list</code>
| <code>openclaw sessions</code>
|-
| Reprendre une session
| <code>hermes chat --resume ID</code>
| <code>openclaw agent --session-key CLE</code>
|-
| Terminal interactif
| <code>hermes chat --resume ID --cli</code>
| <code>openclaw tui --session CLE</code>
|-
| Envoyer sans LLM
| <code>hermes send --to telegram</code>
| <code>openclaw message send --channel telegram</code>
|}

== Précautions ==

# Ne jamais ajouter <code>--yolo</code> pour une simple consultation Hermes.
# Réserver <code>hermes -z</code> aux questions sans effet de bord.
# Utiliser <code>--source tool</code> pour isoler les appels programmatiques Hermes.
# Vérifier l'identifiant de session avant toute reprise.
# Avec OpenClaw, omettre <code>--deliver</code> tant que la réponse ne doit pas quitter le terminal.
# Relire tout contenu avant d'utiliser <code>hermes send</code>, <code>openclaw agent --deliver</code> ou <code>openclaw message send</code>.

== Voir aussi ==

* [[Trace install tas - Hermes Agent]]
* [[Trace install tas]]

Trace install tas - Hermes Agent

Daneel — Thu, 16 Jul 2026 09:46:51 GMT

Correction rendu commandes podman inspect

Voir les modifications

Trace install tas - Hermes Agent

Daneel — Mon, 13 Jul 2026 08:57:56 GMT

Publication de la page Trace install tas - Hermes Agent

Nouvelle page

= Trace install tas - Hermes Agent =

== Rôle ==
Agent IA outillé exposé via sa gateway de messagerie, avec état persistant sur disque dédié.

== Statut opérationnel ==
Dernière mise à jour documentaire : '''13 juillet 2026'''.

Capacités actuellement actives et vérifiées :
* [x] gateway Telegram dédiée via `@LoicHermesBot`
* [x] modèle local Ollama via `gemma4:e4b-it-q8_0_128k`
* [x] outils fichiers / terminal / mémoire / délégation
* [x] browser local embarqué
* [x] STT local et TTS Edge
* [x] `web_search` via backend `ddgs` sans clé API

Capacités encore bloquées ou partielles :
* [ ] `web_extract` avec backend dédié
* [ ] `image_generate`
* [ ] `browser_cdp` et `browser_dialog`
* [ ] `read_terminal` et `close_terminal` hors application desktop Hermes
* [ ] `computer_use` dans ce gateway Telegram sans contexte desktop/X11

== Accès ==
* Local service : `127.0.0.1:8642`
* Public HTTP : aucun par défaut
* Messagerie prévue : Telegram via un second bot dédié à créer

== Ports ==
* `8642` local uniquement

== Exécution / runtime ==
Quadlet systemd user : `hermes.container` ; unité générée : `hermes.service`.

Commande de démarrage :
* `gateway run`

Image :
* `docker.io/nousresearch/hermes-agent:latest`

== Chemins de configuration ==
* `/home/loic/.config/containers/systemd/hermes.container`
* `/home/loic/hermes-config/hermes.env`
* `/media/loic/nem/hermes/config.yaml`

Sources de vérité :
* le quadlet gère le runtime Podman rootless
* `hermes.env` porte les secrets / variables Telegram
* `config.yaml` porte la configuration non secrète Hermes

== Volumes / persistance ==
* `/media/loic/nem/hermes:/opt/data`

Contenu notable dans la persistance :
* `config.yaml`
* historiques / sessions Hermes
* mémoire et skills synchronisés par Hermes

== Dépendances ==
* Podman rootless
* Ollama local via `http://host.containers.internal:11434/v1`
* second bot Telegram dédié avec token distinct de l'instance OpenClaw existante
* package Python `ddgs` installé via `hermes tools post-setup ddgs` le `13 juillet 2026`

== Modèle LLM principal ==
Configuration Hermes actuellement retenue :
* provider : `custom`
* backend : API Ollama locale sur `http://host.containers.internal:11434/v1`
* modèle par défaut : `gemma4:e4b-it-q8_0_128k`
* contexte cible : `131072` tokens

== Outils et backends activés ==
Activation explicite actuellement retenue dans `config.yaml` :
* `web.search_backend: ddgs`

Conséquences :
* `web_search` devient disponible sans clé API
* `web_extract` n'a pas encore de backend dédié, donc la recherche web est activée mais l'extraction avancée reste à compléter

Backends non activés à ce stade :
* aucun backend `image_gen`
* aucun `browser.cdp_url`

== Intégration Telegram préparée ==
Configuration locale maintenant active :
* fichier dédié : `/home/loic/hermes-config/hermes.env`
* allowlist utilisateur configurée sur l'identifiant Telegram de Loïc : `5910858583`
* canal home Telegram préparé sur `5910858583`
* bot dédié configuré : `@LoicHermesBot`

Important :
* le token du bot dédié est maintenant renseigné dans `hermes.env`
* il faut un bot distinct de `@LoicBoBBot` pour éviter le conflit `getUpdates` avec OpenClaw

Variables prévues dans `hermes.env` :
* `TELEGRAM_ALLOWED_USERS=5910858583`
* `TELEGRAM_HOME_CHANNEL=5910858583`
* `TELEGRAM_BOT_TOKEN=...` configuré pour `@LoicHermesBot`

== Procédure pour finaliser le second bot ==
Bot dédié déjà créé et validé :
* nom : `Hermes`
* username : `@LoicHermesBot`

Pour refaire la procédure sur une autre instance :
* créer un bot dédié via `@BotFather`
* renseigner `TELEGRAM_BOT_TOKEN` dans `/home/loic/hermes-config/hermes.env`
* `systemctl --user daemon-reload`
* `systemctl --user restart hermes.service`
* vérifier `journalctl --user -u hermes.service -n 100 --no-pager`

== Procédure de relance / diagnostic ==
Commandes utiles :
* `systemctl --user status hermes.service --no-pager -l`
* `systemctl --user restart hermes.service`
* `journalctl --user -u hermes.service -n 100 --no-pager`
* `ss -ltn | rg 8642`
* `podman exec hermes /opt/hermes/.venv/bin/python -c "from tools.web_tools import check_web_api_key; print(check_web_api_key())"`

Interprétation rapide :
* si le service tourne mais logue `No messaging platforms enabled`, le token Telegram n'est pas encore actif
* si le service refuse de démarrer après ajout du token, vérifier d'abord le format du token et l'unicité du bot
* si un conflit de token apparaît, s'assurer que le bot Hermes n'est pas le même que celui d'OpenClaw
* si Telegram est bien pris en compte, les logs montrent une phase de connexion du type `Connecting to Telegram`
* si `check_web_api_key()` renvoie `True` avec `search_provider=ddgs`, la recherche web est activée même sans clé API

== Plan d'activation des potentiels ==
Checklist de suivi :
* [x] sécuriser le runtime rootless + backups de config
* [x] activer Telegram dédié
* [x] basculer sur le modèle local `gemma4:e4b-it-q8_0_128k`
* [x] activer `web_search` gratuit via `ddgs`
* [ ] choisir et brancher un backend `web_extract`
* [ ] choisir et brancher un backend `image_generate`
* [ ] fournir un endpoint CDP persistant si l'on veut `browser_cdp`
* [ ] décider si un contexte desktop dédié doit être exposé à Hermes

Intervention attendue de Loïc pour débloquer la suite :
* `web_extract` : fournir un choix de provider et sa config (`TAVILY_API_KEY`, `FIRECRAWL_API_KEY`, `EXA_API_KEY`, ou une URL `SEARXNG_URL` si une instance maison existe)
* `image_generate` : fournir un provider et un secret ou une auth exploitable dans le conteneur (`OPENAI_API_KEY`, `FAL_KEY`, ou auth Codex dans Hermes)
* `browser_cdp` : fournir une cible CDP réelle et durable (`browser.cdp_url`)

== Données / emplacements à sauvegarder ==
* `/home/loic/.config/containers/systemd/hermes.container`
* `/home/loic/hermes-config/hermes.env`
* `/media/loic/nem/hermes`

== Sauvegarde ==
Avant modification de la config critique :
* sauvegarder le quadlet Hermes
* sauvegarder `hermes.env`
* sauvegarder la persistance `/media/loic/nem/hermes`

== Restauration ==
* restaurer `hermes.container`
* restaurer `hermes.env`
* restaurer `/media/loic/nem/hermes`
* recharger systemd user
* relancer `hermes.service`

== Rollback ==
Si l'intégration Telegram du second bot casse Hermes :
* recommenter `TELEGRAM_BOT_TOKEN` dans `/home/loic/hermes-config/hermes.env`
* redémarrer `hermes.service`
* revenir au backup du quadlet si nécessaire

== Maintenance documentaire ==
Lors d'un changement d'image, de provider LLM, de chemin de persistance, de port local, de bot Telegram ou de stratégie d'allowlist, mettre à jour cette page et la trace centrale.

== Trace documentaire ==
Cette page fait partie de [[Trace install tas]].

Trace install tas

Daneel — Mon, 13 Jul 2026 08:57:14 GMT

Ajout du lien vers Trace install tas - Hermes Agent et synchro de la page centrale

← Version précédente		Version du 13 juillet 2026 à 10:57
Ligne 38 :		Ligne 38 :
	* [[Trace install tas - Trilium Notes]]		* [[Trace install tas - Trilium Notes]]
	* [[Trace install tas - Stalwart]]		* [[Trace install tas - Stalwart]]
			* [[Trace install tas - Hermes Agent]]

	== Vue synthétique ==		== Vue synthétique ==
Ligne 82 :		Ligne 83 :
	\|-		\|-
	\| Stalwart \|\| 1025 / 1465 / 1587 / 1993 / 18080 \|\| aucun à date \|\| mail.lololand.org / lololand.org (MX à basculer) \|\| Serveur mail local		\| Stalwart \|\| 1025 / 1465 / 1587 / 1993 / 18080 \|\| aucun à date \|\| mail.lololand.org / lololand.org (MX à basculer) \|\| Serveur mail local
			\|-
			\| Hermes Agent \|\| 8642 \|\| aucun à date \|\| \|\| Agent IA outillé via gateway de messagerie
	\|}		\|}