refactor(stt): unifie le jeton Ghostfolio — source client unique, appel côté serveur (#41)

Avant : jeton Ghostfolio en double (config client pour l'intent vocal + secret k8s pour
le contexte serveur). Désormais une SEULE source — la config client — transmise au
serveur, qui fait tous les appels Ghostfolio (un seul code, lecture seule).

Serveur :
- sources.py : cœur _ghostfolio_fetch(token) partagé ; ghostfolio_block (contexte) et
  ghostfolio_phrase (intent) acceptent un jeton par requête (priorité client > env).
- app.py : /v1/ask accepte `secrets` (jetons client) passés aux sources ; nouvel
  endpoint POST /v1/portfolio {token} → valeur du portefeuille.
- bump 0.4.0 → 0.5.0.

Client :
- api.py : ServerClient.secrets transmis dans /v1/ask ; méthode portfolio() → /v1/portfolio.
- cli.py : _make_client renseigne secrets["ghostfolio_token"] depuis [ghostfolio].
- ui/app.py : l'intent « combien ghostfolio » appelle client.portfolio (serveur).
- supprime portal/ghostfolio.py (client) — l'appel API vit côté serveur.
- config : [ghostfolio] = juste access_token (transmis au serveur).
- bump 0.12.0 → 0.13.0.

Le secret k8s STT_GHOSTFOLIO_TOKEN devient un simple fallback. Validé bout-en-bout
contre une instance serveur locale + Ghostfolio réel : « …vaut environ 16 520 EUR. »

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

stt/client/config/stt.example.toml

@@ -69,7 +69,6 @@ local_db = "~/.local/share/stt/memory.sqlite"
 #   « état du cluster / des services »  → résumé de santé (parlé)
 #   « combien sur mon ghostfolio »      → valeur du portefeuille (ci-dessous)
 # Ghostfolio : access_token = « Security token » du compte (Réglages Ghostfolio).
+# Source UNIQUE du jeton — le client le transmet au serveur, qui appelle l'API.
 # [ghostfolio]
-# url = "http://ghostfolio.lab.local"
 # access_token = "TON_SECURITY_TOKEN"
-# timeout_sec = 6

stt/client/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stt"
-version = "0.12.0"
+version = "0.13.0"
 description = "STT — client vocal Jarvis du homelab Funk (voix + HUD, parle au STT-server)"
 requires-python = ">=3.11"
 readme = "README.md"

stt/client/stt/api.py

@@ -21,6 +21,9 @@ class ServerClient:
         # dernier contexte assemblé renvoyé par le serveur (pour le visualiseur)
         self.last_context: dict | None = None
         self.last_context_id: str | None = None
+        # jetons à transmettre au serveur (ex. {"ghostfolio_token": …}) — source UNIQUE
+        # du jeton, côté client ; le serveur les consomme (contexte + /v1/portfolio).
+        self.secrets: dict = {}
         # une session par run → mémoire court-terme côté serveur
         self.session_id = uuid.uuid4().hex
 
@@ -34,6 +37,8 @@ class ServerClient:
         }
         if self.context:
             payload["context"] = self.context
+        if self.secrets:
+            payload["secrets"] = self.secrets
         r = requests.post(f"{self.url}/v1/ask", json=payload, timeout=self.timeout)
         if r.status_code == 400:
             raise RuntimeError(r.json().get("detail", "requête invalide"))
@@ -44,6 +49,25 @@ class ServerClient:
         self.last_context_id = data.get("context_id")
         return data["reply"].strip()
 
+    def portfolio(self) -> str:
+        """Valeur du portefeuille Ghostfolio via le serveur (jeton client transmis).
+
+        Unifie le jeton : c'est le serveur qui parle à Ghostfolio. Dégrade en message
+        clair si le serveur est antérieur (pas d'endpoint) ou injoignable.
+        """
+        import requests
+
+        try:
+            r = requests.post(
+                f"{self.url}/v1/portfolio",
+                json={"token": self.secrets.get("ghostfolio_token")},
+                timeout=self.timeout,
+            )
+            r.raise_for_status()
+            return (r.json().get("summary") or "").strip() or "Pas de réponse de Ghostfolio."
+        except requests.RequestException:
+            return "Je n'arrive pas à joindre le serveur pour Ghostfolio."
+
     def contexts(self) -> dict | None:
         """{'default':…, 'contexts':[{id,label,icon,description}]} ; None si indisponible.
 

stt/client/stt/cli.py

@@ -347,6 +347,10 @@ def _make_client(args):
     client = ServerClient(cfg["server"])
     if args.model:
         client.model = resolve_model(args.model)
+    # Jeton Ghostfolio (source unique côté client) → transmis au serveur par requête
+    gf_token = (cfg.get("ghostfolio") or {}).get("access_token")
+    if gf_token:
+        client.secrets["ghostfolio_token"] = gf_token
     return cfg, client
 
 

stt/client/stt/config.py

@@ -174,13 +174,11 @@ DEFAULT_CONFIG: dict[str, Any] = {
         "prometheus_url": "http://prometheus.lab.local",
         "alertmanager_url": "http://alertmanager.lab.local",
     },
-    # Ghostfolio — pour l'intention vocale « combien sur mon portefeuille ».
-    # access_token = « Security token » du compte (vide → l'assistant répond de le
-    # configurer). Lecture seule.
+    # Ghostfolio — jeton (« Security token » du compte). SOURCE UNIQUE du jeton :
+    # le client le transmet au serveur, qui fait l'appel API (intent « combien sur mon
+    # portefeuille » via /v1/portfolio + contexte Ghostfolio). Vide → indisponible.
     "ghostfolio": {
-        "url": "http://ghostfolio.lab.local",
         "access_token": "",
-        "timeout_sec": 6,
     },
 }
 

stt/client/stt/portal/__init__.py

@@ -8,12 +8,11 @@ La même source alimente le panneau « Services » du HUD et la commande vocale
 
 from __future__ import annotations
 
-from .ghostfolio import GhostfolioClient
 from .health import StatusPoller
 from .intents import route_intent, summarize_status
 from .registry import Component, Service, load_services, match_service
 
 __all__ = [
     "Component", "Service", "load_services", "match_service", "StatusPoller",
-    "GhostfolioClient", "route_intent", "summarize_status",
+    "route_intent", "summarize_status",
 ]

stt/client/stt/portal/ghostfolio.py

@@ -1,76 +0,0 @@
-"""Client minimal de l'API Ghostfolio — valeur du portefeuille (lecture seule).
-
-Flux Ghostfolio : POST /api/v1/auth/anonymous {accessToken} → JWT, puis
-GET /api/v1/portfolio/details (Bearer) → summary.currentValueInBaseCurrency.
-
-Le token (« Security token » du compte Ghostfolio) est config-driven, jamais en
-dur. Sans token → message d'aide ; toute erreur → message parlable, jamais d'exception.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-def _fmt_money(value: float) -> str:
-    """12345.6 → « 12 345 » (séparateur de milliers fin, arrondi à l'euro)."""
-    try:
-        return f"{round(float(value)):,}".replace(",", " ")
-    except (TypeError, ValueError):
-        return str(value)
-
-
-class GhostfolioClient:
-    def __init__(self, cfg: dict[str, Any]):
-        self.url = (cfg.get("url") or "http://ghostfolio.lab.local").rstrip("/")
-        self.token = cfg.get("access_token") or ""
-        self.timeout = float(cfg.get("timeout_sec", 6) or 6)
-
-    def _auth_token(self) -> str | None:
-        import requests
-
-        r = requests.post(
-            f"{self.url}/api/v1/auth/anonymous",
-            json={"accessToken": self.token}, timeout=self.timeout,
-        )
-        if r.status_code >= 400:
-            return None
-        return (r.json() or {}).get("authToken")
-
-    def _base_currency(self) -> str:
-        import requests
-
-        try:
-            r = requests.get(f"{self.url}/api/v1/info", timeout=self.timeout)
-            return (r.json() or {}).get("baseCurrency") or "EUR"
-        except (requests.RequestException, ValueError):
-            return "EUR"
-
-    def value_summary(self) -> str:
-        """Phrase parlable donnant la valeur du portefeuille (ou un message d'erreur clair)."""
-        import requests
-
-        if not self.token:
-            return ("Je n'ai pas de jeton Ghostfolio configuré. "
-                    "Ajoute ton « Security token » dans la section ghostfolio de la config.")
-        try:
-            jwt = self._auth_token()
-            if not jwt:
-                return "Je n'arrive pas à m'authentifier auprès de Ghostfolio — le jeton est peut-être invalide."
-            r = requests.get(
-                f"{self.url}/api/v1/portfolio/details",
-                headers={"Authorization": f"Bearer {jwt}"}, timeout=self.timeout,
-            )
-            r.raise_for_status()
-            summary = (r.json() or {}).get("summary", {}) or {}
-            val = (summary.get("currentValueInBaseCurrency")
-                   or summary.get("currentValue")
-                   or summary.get("netWorth"))
-            if val is None:
-                return "Je n'ai pas trouvé la valeur du portefeuille dans la réponse de Ghostfolio."
-            cur = self._base_currency()
-            return f"Ton portefeuille Ghostfolio vaut environ {_fmt_money(val)} {cur}."
-        except requests.RequestException:
-            return "Ghostfolio est injoignable pour le moment."
-        except (ValueError, KeyError):
-            return "Réponse inattendue de Ghostfolio — je n'ai pas pu lire la valeur."

stt/client/stt/ui/app.py

@@ -212,16 +212,16 @@ async def serve(cfg: dict[str, Any], make_engine, client) -> None:
     engine.context_provider = lambda: client.last_context
 
     # Intentions vocales locales (lecture seule) : « ouvre X », « état du cluster »,
-    # « combien sur ghostfolio ». Court-circuitent le LLM.
-    from stt.portal import GhostfolioClient, route_intent, summarize_status
+    # « combien sur ghostfolio ». Court-circuitent le LLM. Ghostfolio passe par le
+    # serveur (jeton client transmis) → une seule source de jeton, un seul code API.
+    from stt.portal import route_intent, summarize_status
 
-    _gf = GhostfolioClient(cfg.get("ghostfolio") or {})
     engine.intent_router = lambda text: route_intent(
         text,
         services=services,
         open_fn=open_service,
         status_fn=lambda: summarize_status(last_status, services),
-        ghostfolio_fn=_gf.value_summary,
+        ghostfolio_fn=client.portfolio,
     )
 
     # chargement Whisper + boucle audio dans un thread dédié