opsiom-cli 1.2.5__tar.gz → 1.4.0__tar.gz

{opsiom_cli-1.2.5 → opsiom_cli-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.2.5
+Version: 1.4.0
 Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
 Author-email: Jules Ecorcheville <jules.ecorcheville@gmail.com>
 License-Expression: MIT

{opsiom_cli-1.2.5 → opsiom_cli-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opsiom-cli"
-version = "1.2.5"
+version = "1.4.0"
 description = "CLI de chat pour Opsiom, l'assistant IA francophone."
 readme = "README.md"
 requires-python = ">=3.9"
@@ -20,4 +20,4 @@ Homepage = "https://github.com/ton-compte/opsiom-cli"
 opsiom = "opsiom_cli.cli:main"
 
 [tool.setuptools.packages.find]
-where = ["src"]
+where = ["src"]

{opsiom_cli-1.2.5 → opsiom_cli-1.4.0}/src/opsiom_cli/cli.py

@@ -10,23 +10,37 @@
 # Dépendances : uniquement `requests`
 #   pip install requests
 #
+# Deux types de serveur sont gérés (détectés d'après l'URL, ou forcés avec
+# --backend) :
+#   - "api" : le serveur d'inférence classique (ngrok, Render…), routes
+#             /api/*, authentification par clé API (en-tête X-API-Key) ;
+#   - "hf"  : un Space Hugging Face (*.hf.space) qui fait tourner l'interface
+#             Opsiom, routes /status, /models, /chat/stream, authentification
+#             par compte Octix (pseudo + mot de passe, session par cookie).
+#
 # Configuration (aucune URL n'est codée en dur dans ce fichier) :
 #   Au premier lancement, le CLI demande l'URL du serveur (et une éventuelle
-#   clé API) puis les enregistre dans ~/.config/opsiom/config.json.
-#   Alternative : variables d'environnement OPSIOM_URL / OPSIOM_API_KEY,
-#   ou options --url / --api-key.
+#   clé API, ou le pseudo Octix pour un Space) puis les enregistre dans
+#   ~/.config/opsiom/config.json. Le mot de passe n'est JAMAIS enregistré.
+#   Alternative : variables d'environnement OPSIOM_URL / OPSIOM_API_KEY /
+#   OPSIOM_USERNAME / OPSIOM_PASSWORD, ou options --url / --api-key /
+#   --username / --backend.
 # ============================================================================
 
 import os
+import re
 import sys
 import json
 import time
+import html
 import shutil
+import getpass
 import hashlib
 import argparse
 import threading
 import itertools
 from pathlib import Path
+from urllib.parse import urlparse
 
 try:
     import requests
@@ -39,7 +53,7 @@ try:
 except ImportError:
     readline = None  # absent par défaut sur certains Windows (pyreadline3 comble le manque)
 
-VERSION = "1.2.5"
+VERSION = "1.4.0"
 CONFIG_PATH = Path.home() / ".config" / "opsiom" / "config.json"
 HISTORY_PATH = Path.home() / ".local" / "share" / "opsiom" / "history"
 TRANSCRIPTS_DIR = Path.home() / "opsiom-conversations"
@@ -128,7 +142,17 @@ OCTOPUS_MARK = [
 
 
 
-def print_header(url, connected, api_key, models_loaded, current_model, show_mark=True):
+def quota_exhausted(state):
+    return not state["unlimited"] and state["remaining"] <= 0
+
+
+def quota_summary(state):
+    if state["unlimited"]:
+        return "illimité"
+    return f"{state['used']}/{state['limit']} tokens aujourd’hui ({state['remaining']} restants)"
+
+
+def print_header(client, connected, models_loaded, current_model, show_mark=True):
     print()
     if show_mark:
         for line in OCTOPUS_MARK:
@@ -138,12 +162,12 @@ def print_header(url, connected, api_key, models_loaded, current_model, show_mar
     print(f"  {muted('assistant IA francophone')}")
     print()
     status_symbol = ok_text("✓") if connected else error_text("✗")
-    print(f"  {status_symbol} {muted('connecté à')} {url}")
-    print(f"    {muted('auth')}      {muted('clé API' if api_key else 'aucune')}")
-    if api_key:
-        used, remaining = get_quota_state(api_key)
-        quota_color = error_text if remaining <= 0 else muted
-        print(f"    {muted('quota')}     {quota_color(f'{used}/{DAILY_TOKEN_QUOTA} tokens aujourd’hui ({remaining} restants)')}")
+    print(f"  {status_symbol} {muted('connecté à')} {client.base_url}")
+    print(f"    {muted('auth')}      {muted(client.auth_label)}")
+    if client.tracks_quota:
+        state = get_quota_state(client.identity)
+        quota_color = error_text if quota_exhausted(state) else muted
+        print(f"    {muted('quota')}     {quota_color(quota_summary(state))}")
     if models_loaded:
         print(f"    {muted('modèles')}   {' · '.join(models_loaded)}")
     if current_model:
@@ -255,38 +279,88 @@ def save_config(config):
     CONFIG_PATH.write_text(json.dumps(config, indent=2))
 
 
-def prompt_for_config():
+def normalize_url(raw):
+    """Nettoie l'URL saisie : ajoute le schéma manquant et transforme la page
+    d'un Space (https://huggingface.co/spaces/Auteur/Nom) en son URL directe
+    (https://auteur-nom.hf.space)."""
+    url = (raw or "").strip().strip("\"'").rstrip("/")
+    if not url:
+        return ""
+    if "://" not in url:
+        local = url.startswith(("localhost", "127.0.0.1"))
+        url = ("http://" if local else "https://") + url
+    parsed = urlparse(url)
+    match = re.match(r"^/spaces/([^/]+)/([^/]+)", parsed.path)
+    if parsed.netloc in ("huggingface.co", "www.huggingface.co") and match:
+        owner, name = (re.sub(r"[._]", "-", part).lower() for part in match.groups())
+        return f"https://{owner}-{name}.hf.space"
+    return url
+
+
+def detect_backend(url, preference="auto"):
+    """'hf' pour un Space Hugging Face, 'api' sinon (ngrok, Render…).
+    Une préférence explicite ('api' ou 'hf') l'emporte sur la détection."""
+    if preference in ("api", "hf"):
+        return preference
+    host = (urlparse(url).hostname or "").lower()
+    return "hf" if host.endswith(".hf.space") or host == "huggingface.co" else "api"
+
+
+def prompt_for_config(backend_pref="auto"):
     print(f"  {accent('Configuration initiale', bold=True)}")
     print(f"  {muted('ces informations te sont transmises par la personne qui héberge Opsiom')} ")
-    url = input("  URL du serveur : ").strip().rstrip("/")
-    api_key = input("  Clé API (vide si aucune) : ").strip()
+    url = normalize_url(input("  URL du serveur (ngrok, ou Space Hugging Face) : "))
+    backend = detect_backend(url, backend_pref)
+    config = {"url": url, "backend": backend, "api_key": "", "username": ""}
+    if backend == "hf":
+        print(muted("  → Space Hugging Face : connexion avec ton compte Octix."))
+        config["username"] = input("  Pseudo Octix : ").strip()
+    else:
+        config["api_key"] = input("  Clé API (vide si aucune) : ").strip()
     save = input(muted("  Sauvegarder localement pour la prochaine fois ? [O/n] ")).strip().lower()
-    config = {"url": url, "api_key": api_key}
     if save in ("", "o", "oui", "y", "yes"):
         save_config(config)
-        print(muted(f"  → enregistré dans {CONFIG_PATH} "))
+        print(muted(f"  → enregistré dans {CONFIG_PATH} (le mot de passe n'est jamais enregistré) "))
     return config
 
 
 def resolve_settings(args):
     config = {} if args.configure else load_config()
-    url = args.url or os.environ.get("OPSIOM_URL") or config.get("url")
+    url_override = args.url or os.environ.get("OPSIOM_URL")
+    url = normalize_url(url_override or config.get("url"))
+    # Le type de serveur enregistré ne vaut que pour l'URL enregistrée : si
+    # l'URL vient d'une option ou d'une variable d'environnement, on le redétecte.
+    backend_pref = args.backend or os.environ.get("OPSIOM_BACKEND") or (
+        "auto" if url_override else config.get("backend", "auto"))
     api_key = args.api_key or os.environ.get("OPSIOM_API_KEY") or config.get("api_key")
+    username = args.username or os.environ.get("OPSIOM_USERNAME") or config.get("username")
     if args.configure or not url:
-        new_config = prompt_for_config()
+        new_config = prompt_for_config(backend_pref)
         url = new_config["url"] or url
+        backend_pref = new_config["backend"]
         api_key = new_config["api_key"] or api_key
-    return url, api_key
+        username = new_config["username"] or username
+    return {
+        "url": url,
+        "backend": detect_backend(url, backend_pref),
+        "api_key": api_key,
+        "username": username,
+        "hf_token": args.hf_token or os.environ.get("OPSIOM_HF_TOKEN") or os.environ.get("HF_TOKEN"),
+    }
 
 
 # ----------------------------------------------------------------------------
-# Quota — 500 tokens/jour par clé API. Le fichier usage.json ne sert plus
-# qu'à AFFICHER un dernier quota connu avant la toute première requête de la
-# session (utile pour /quota juste après le lancement) : dès qu'une réponse
-# arrive, c'est le "remaining_quota" renvoyé par le serveur (lui-même décompté
-# côté Octix) qui fait foi et remplace la valeur locale. Un utilisateur qui
-# modifierait usage.json à la main ne gagnerait donc plus rien : le serveur
-# refuse désormais les requêtes une fois son propre compteur à zéro (429).
+# Quota — 500 tokens/jour par clé API ; sur un Space Hugging Face la limite
+# dépend du forfait du compte (elle est donc lue dans la réponse du serveur,
+# jamais supposée). Le fichier usage.json ne sert plus qu'à AFFICHER un dernier
+# quota connu avant la toute première requête de la session (utile pour
+# /quota juste après le lancement) : dès qu'une réponse arrive, c'est le
+# quota renvoyé par le serveur ("remaining_quota" pour le serveur API,
+# objet "quota" pour un Space) qui fait foi et remplace la valeur locale. Un
+# utilisateur qui modifierait usage.json à la main ne gagnerait donc plus
+# rien : le serveur refuse les requêtes une fois son propre compteur à zéro (429).
+# Les entrées sont indexées par "identité" : empreinte de la clé API, ou du
+# couple (Space, pseudo) pour un compte Octix.
 # ----------------------------------------------------------------------------
 
 def _api_key_id(api_key):
@@ -298,6 +372,12 @@ def _api_key_id(api_key):
     return hashlib.sha256(api_key.encode("utf-8")).hexdigest()[:16]
 
 
+def _account_id(url, username):
+    """Identité d'un compte Octix sur un Space (empreinte, pas de clair)."""
+    raw = f"{url.rstrip('/').lower()}|{(username or '').lower()}"
+    return "hf-" + hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
+
+
 def today_str():
     return time.strftime("%Y-%m-%d")
 
@@ -323,37 +403,89 @@ def save_usage(usage):
     USAGE_PATH.write_text(json.dumps(usage, indent=2))
 
 
-def get_quota_state(api_key):
-    """(tokens utilisés aujourd'hui, tokens restants). Le compteur se
-    réinitialise tout seul dès que la date enregistrée n'est plus celle
-    du jour -- pas besoin de tâche planifiée."""
-    entry = load_usage().get(_api_key_id(api_key), {})
+def get_quota_state(identity):
+    """{'used', 'limit', 'remaining', 'unlimited'} pour aujourd'hui. Le
+    compteur se réinitialise tout seul dès que la date enregistrée n'est plus
+    celle du jour -- pas besoin de tâche planifiée. Pour un compte sans
+    limite, 'remaining' vaut None."""
+    entry = load_usage().get(identity, {})
     if entry.get("date") != today_str():
-        return 0, DAILY_TOKEN_QUOTA
+        return {"used": 0, "limit": DAILY_TOKEN_QUOTA, "remaining": DAILY_TOKEN_QUOTA, "unlimited": False}
     used = entry.get("tokens_used", 0)
-    return used, max(0, DAILY_TOKEN_QUOTA - used)
-
-
-def record_authoritative_remaining(api_key, remaining):
-    """Remplace le compteur local par le quota restant renvoyé par le
-    serveur (lui-même décompté côté Octix) — c'est la seule valeur qui
-    compte désormais, le fichier local n'est qu'un cache d'affichage."""
-    if remaining is None:
+    if entry.get("unlimited"):
+        return {"used": used, "limit": 0, "remaining": None, "unlimited": True}
+    limit = entry.get("limit", DAILY_TOKEN_QUOTA)
+    return {"used": used, "limit": limit, "remaining": max(0, limit - used), "unlimited": False}
+
+
+def record_server_quota(identity, remaining=None, used=None, limit=None, unlimited=False):
+    """Remplace le compteur local par le quota renvoyé par le serveur (lui-même
+    décompté côté Octix) — c'est la seule valeur qui compte, le fichier local
+    n'est qu'un cache d'affichage. Un Space donne (used, limit) ; le serveur
+    API ne donne que 'remaining', pour une limite fixe de DAILY_TOKEN_QUOTA."""
+    if unlimited:
+        entry = {"date": today_str(), "tokens_used": used or 0, "unlimited": True}
+    elif used is not None and limit is not None:
+        entry = {"date": today_str(), "tokens_used": used, "limit": limit}
+    elif remaining is not None:
+        entry = {"date": today_str(), "tokens_used": max(0, DAILY_TOKEN_QUOTA - remaining)}
+    else:
         return
     usage = load_usage()
-    key_id = _api_key_id(api_key)
-    usage[key_id] = {
-        "date": today_str(),
-        "tokens_used": max(0, DAILY_TOKEN_QUOTA - remaining),
-    }
+    usage[identity] = entry
     save_usage(usage)
 
 
 # ----------------------------------------------------------------------------
-# Client API
+# Clients — un par type de serveur, avec la même interface pour le chat :
+#   health()       -> {"status": "ok"|..., "models_loaded": [...], ...}
+#   list_models()  -> {"models": [{"id","label","params"[,"locked"]}], "default"}
+#   chat_stream()  -> générateur : fragments de texte, puis le dict final
+# Attributs communs : backend, base_url, identity (clé du cache de quota),
+# auth_label, auth_error, tracks_quota.
 # ----------------------------------------------------------------------------
 
+class ServerError(Exception):
+    """Erreur signalée par le serveur DANS le flux SSE (après un statut 200)."""
+
+
+def server_error_message(http_error):
+    """Message d'erreur JSON ({"error": "..."}) d'une réponse HTTP, ou None."""
+    try:
+        return http_error.response.json().get("error")
+    except (ValueError, AttributeError):
+        return None
+
+
+def stream_pieces(response):
+    """Décode un flux SSE ("data: {...}") : cède chaque fragment de texte, puis
+    le dict final (évènement "done"). Lève ServerError sur un évènement
+    {"error": "..."}."""
+    response.encoding = "utf-8"
+    for line in response.iter_lines(decode_unicode=True):
+        if not line or not line.startswith("data: "):
+            continue
+        try:
+            event = json.loads(line[len("data: "):])
+        except ValueError:
+            continue
+        if event.get("error"):
+            raise ServerError(event["error"])
+        if event.get("done"):
+            yield event
+            return
+        token = event.get("token")
+        if token:
+            yield token
+
+
 class OpsiomClient:
+    """Serveur d'inférence classique (ngrok, Render…) : routes /api/*,
+    authentification par clé API (X-API-Key)."""
+
+    backend = "api"
+    auth_error = ("clé API invalide ou expirée.", "reconfigure avec : opsiom --configure")
+
     def __init__(self, base_url, api_key=None, timeout=60):
         self.base_url = base_url.rstrip("/")
         self.timeout = timeout
@@ -362,6 +494,12 @@ class OpsiomClient:
         if api_key:
             headers["X-API-Key"] = api_key
         self.session.headers.update(headers)
+        self.identity = _api_key_id(api_key)
+        self.auth_label = "clé API" if api_key else "aucune"
+        self.tracks_quota = bool(api_key)
+
+    def new_conversation(self):
+        return False  # le serveur ne garde aucun historique
 
     def health(self):
         r = self.session.get(f"{self.base_url}/api/health", timeout=10)
@@ -398,16 +536,118 @@ class OpsiomClient:
             timeout=self.timeout, stream=True,
         )
         r.raise_for_status()
-        for line in r.iter_lines(decode_unicode=True):
-            if not line or not line.startswith("data: "):
-                continue
-            event = json.loads(line[len("data: "):])
-            if event.get("done"):
-                yield event
-                return
-            token = event.get("token")
-            if token:
-                yield token
+        yield from stream_pieces(r)
+
+
+class HFSpaceClient:
+    """Space Hugging Face qui héberge l'interface Opsiom. Le Space n'a pas de
+    clé API : il authentifie un COMPTE Octix par une session (cookie) ouverte
+    via son formulaire /login. Routes : /status, /models, /chat/stream.
+    Le quota (forfait, codes de promo) et l'historique des conversations
+    sont tenus côté Space, par compte -- le même qu'à l'usage sur le web."""
+
+    backend = "hf"
+    tracks_quota = True
+    auth_error = ("session expirée ou refusée par le Space.", None)
+
+    def __init__(self, base_url, username=None, hf_token=None, timeout=120):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout          # CPU partagé : le premier fragment peut tarder
+        self.username = username
+        self.identity = _account_id(self.base_url, username)
+        self.conversation_id = None     # historique serveur : une conversation par session
+        self.session = requests.Session()
+        if hf_token:                    # Space privé : jeton d'accès Hugging Face
+            self.session.headers["Authorization"] = f"Bearer {hf_token}"
+
+    @property
+    def auth_label(self):
+        return f"compte Octix ({self.username})" if self.username else "compte Octix"
+
+    def new_conversation(self):
+        self.conversation_id = None
+        return True
+
+    def login(self, username, password):
+        """Ouvre la session Octix du Space (même formulaire que la page /login).
+        Renvoie (True, None) ou (False, message)."""
+        try:
+            r = self.session.post(
+                f"{self.base_url}/login",
+                data={"username": username, "password": password},
+                timeout=90,  # un Space endormi met un moment à se réveiller
+                allow_redirects=False,
+            )
+        except requests.RequestException as e:
+            return False, f"Space injoignable : {e}"
+        if r.status_code in (301, 302, 303, 307, 308):
+            self.username = username
+            self.identity = _account_id(self.base_url, username)
+            return True, None
+        flash = re.search(r'<li class="flash[^"]*">(.*?)</li>', r.text or "", re.S)
+        if flash:
+            return False, html.unescape(flash.group(1)).strip()
+        if r.status_code in (400, 401):
+            return False, "pseudo ou mot de passe refusé."
+        return False, (f"réponse inattendue du serveur (HTTP {r.status_code}) — "
+                       "le Space est peut-être en train de démarrer, réessaie dans une minute.")
+
+    def health(self):
+        r = self.session.get(f"{self.base_url}/status", timeout=30)
+        r.raise_for_status()
+        data = r.json()
+        return {
+            "status": "ok" if data.get("online") else (data.get("error") or "indisponible"),
+            "models_loaded": data.get("models_loaded", []),
+            "message": data.get("message"),
+            "quota": data.get("quota"),
+        }
+
+    def list_models(self):
+        r = self.session.get(f"{self.base_url}/models", timeout=30)
+        r.raise_for_status()
+        return r.json()
+
+    def chat_stream(self, message, model=None, **params):
+        """Même contrat que OpsiomClient.chat_stream, avec en plus le suivi de
+        la conversation (sinon chaque message créerait une conversation dans
+        l'historique du compte). Le dict final porte 'quota' (used/limit/...)."""
+        payload = {"message": message}
+        if model:
+            payload["model"] = model
+        if self.conversation_id:
+            payload["conversation_id"] = self.conversation_id
+        payload.update(params)
+        r = self.session.post(
+            f"{self.base_url}/chat/stream", json=payload,
+            timeout=self.timeout, stream=True,
+        )
+        r.raise_for_status()
+        for piece in stream_pieces(r):
+            if isinstance(piece, dict):
+                self.conversation_id = piece.get("conversation_id") or self.conversation_id
+            yield piece
+
+
+def login_interactive(client, username=None, attempts=3):
+    """Demande le mot de passe (jamais affiché ni enregistré) et ouvre la
+    session. OPSIOM_PASSWORD, s'il est défini, est essayé en premier."""
+    try:
+        username = username or input("  Pseudo Octix : ").strip()
+        password = os.environ.get("OPSIOM_PASSWORD")
+        for _ in range(attempts):
+            if not password:
+                password = getpass.getpass(f"  Mot de passe Octix de {username} : ")
+            print(muted("  connexion… "), end="\r", flush=True)
+            ok, message = client.login(username, password)
+            print("\033[K", end="")
+            if ok:
+                return True
+            print_error("connexion refusée.", message)
+            password = None
+    except (EOFError, KeyboardInterrupt):
+        print()
+    return False
 
 
 # ----------------------------------------------------------------------------
@@ -421,6 +661,7 @@ HELP_TEXT = """
   /status           réaffiche l'en-tête de connexion
   /quota            affiche le quota de tokens restant aujourd'hui
   /save [nom]       exporte la conversation en Markdown
+  /new              nouvelle conversation (Space Hugging Face : nouvel historique)
   /clear            efface l'écran
   /help             affiche cette aide
   /quit, /exit      quitte le CLI
@@ -453,6 +694,8 @@ def print_models(models_payload, current_model):
         marker = accent("›") if is_current else " "
         label = accent(m["label"], bold=True) if is_current else m["label"]
         detail = f"{m['params']} · {m['id']}"
+        if m.get("locked"):
+            detail += " · non inclus dans ton forfait"
         print(f"  {marker} {muted(f'[{i}]')} {label}  {muted(detail)}")
 
 
@@ -469,6 +712,10 @@ def resolve_model_choice(choice, models):
     return matches[0] if len(matches) == 1 else None
 
 
+def model_is_locked(models, model_id):
+    return any(m["id"] == model_id and m.get("locked") for m in models)
+
+
 def select_model_interactively(models_payload, current_model):
     models = models_payload.get("models", [])
     if not models:
@@ -482,6 +729,9 @@ def select_model_interactively(models_payload, current_model):
     if resolved is None:
         print_error(f"choix invalide : '{choice}'")
         return current_model
+    if model_is_locked(models, resolved):
+        print_error(f"le modèle « {resolved} » n'est pas inclus dans ton forfait.")
+        return current_model
     print(f"  {accent('→')} modèle actif : {accent(resolved, bold=True)}")
     return resolved
 
@@ -541,19 +791,26 @@ class StreamPrinter:
         print()
 
 
-def run_chat(client: OpsiomClient, url, api_key):
+def run_chat(client):
     setup_history()
     transcript = []
     current_model = None
     models_payload = {"models": []}
     connected = False
     models_loaded = []
+    server_notice = None
 
     invalid_key = False
     try:
         health = client.health()
         connected = health.get("status") == "ok"
         models_loaded = health.get("models_loaded", [])
+        if not connected:
+            server_notice = health.get("message")
+        quota = health.get("quota")
+        if isinstance(quota, dict):
+            record_server_quota(client.identity, remaining=quota.get("remaining"), used=quota.get("used"),
+                                limit=quota.get("limit"), unlimited=bool(quota.get("unlimited")))
     except requests.HTTPError as e:
         connected = False
         invalid_key = e.response is not None and e.response.status_code in (401, 403)
@@ -567,9 +824,11 @@ def run_chat(client: OpsiomClient, url, api_key):
         pass
 
     if invalid_key:
-        print_error("clé API invalide ou expirée.", "reconfigure avec : opsiom --configure")
+        print_error(*client.auth_error)
+    elif server_notice:
+        print_error(server_notice)
 
-    print_header(url, connected, api_key, models_loaded, current_model)
+    print_header(client, connected, models_loaded, current_model)
     print(f"  {muted('Tapez votre message, ou /help pour la liste des commandes.')} ")
 
     while True:
@@ -595,10 +854,19 @@ def run_chat(client: OpsiomClient, url, api_key):
                 sys.stdout.write("\033[H\033[J")
                 sys.stdout.flush()
             elif cmd == "status":
-                print_header(url, connected, api_key, models_loaded, current_model, show_mark=False)
+                print_header(client, connected, models_loaded, current_model, show_mark=False)
             elif cmd == "quota":
-                used, remaining = get_quota_state(api_key)
-                print(f"  {muted(f'{used}/{DAILY_TOKEN_QUOTA} tokens utilisés aujourd’hui — {remaining} restants.')}")
+                state = get_quota_state(client.identity)
+                if state["unlimited"]:
+                    print(f"  {muted('quota illimité sur ce compte.')}")
+                else:
+                    text = f"{state['used']}/{state['limit']} tokens utilisés aujourd’hui — {state['remaining']} restants."
+                    print(f"  {muted(text)}")
+            elif cmd == "new":
+                if client.new_conversation():
+                    print(f"  {accent('→')} nouvelle conversation")
+                else:
+                    print(muted("  ce serveur ne garde pas d'historique : chaque message est indépendant."))
             elif cmd == "save":
                 if not transcript:
                     print(muted("  rien à enregistrer pour l'instant."))
@@ -616,17 +884,23 @@ def run_chat(client: OpsiomClient, url, api_key):
                     current_model = select_model_interactively(models_payload, current_model)
                 else:
                     resolved = resolve_model_choice(arg, models_payload.get("models", [])) or arg
-                    current_model = resolved
-                    print(f"  {accent('→')} modèle actif : {accent(resolved, bold=True)}")
+                    if model_is_locked(models_payload.get("models", []), resolved):
+                        print_error(f"le modèle « {resolved} » n'est pas inclus dans ton forfait.")
+                    else:
+                        current_model = resolved
+                        print(f"  {accent('→')} modèle actif : {accent(resolved, bold=True)}")
             else:
                 print_error(f"commande inconnue : /{cmd}")
             print()
             continue
 
-        _, remaining_quota = get_quota_state(api_key)
-        if remaining_quota <= 0:
+        # Serveur API : garde-fou local. Space : le quota (forfait, codes de promo)
+        # change côté serveur sans que le CLI le sache -- on laisse donc le
+        # Space trancher (réponse 429 avec son propre message).
+        state = get_quota_state(client.identity)
+        if client.backend == "api" and quota_exhausted(state):
             print_error(
-                f"quota quotidien de {DAILY_TOKEN_QUOTA} tokens atteint.",
+                f"quota quotidien de {state['limit']} tokens atteint.",
                 "réessaie demain, ou utilise une autre clé API avec --configure",
             )
             print()
@@ -656,18 +930,28 @@ def run_chat(client: OpsiomClient, url, api_key):
                 spinner.stop()
             print(muted("\n  (requête annulée) "))
             continue
+        except ServerError as e:
+            if spinner_running:
+                spinner.stop()
+            elif response_parts:
+                printer.close()  # termine proprement la ligne en cours
+            print_error(str(e))
+            print()
+            continue
         except requests.HTTPError as e:
             if spinner_running:
                 spinner.stop()
-            if e.response is not None and e.response.status_code in (401, 403):
-                print_error("clé API invalide ou expirée.", "reconfigure avec : opsiom --configure")
-            elif e.response is not None and e.response.status_code == 429:
-                detail = None
-                try:
-                    detail = e.response.json().get("error")
-                except (ValueError, AttributeError):
-                    pass
+            status = e.response.status_code if e.response is not None else None
+            detail = server_error_message(e)
+            if status == 401 or (status == 403 and client.backend == "api"):
+                print_error(*client.auth_error)
+                if client.backend == "hf" and login_interactive(client, client.username, attempts=1):
+                    print(muted("  reconnecté — renvoie ton message."))
+            elif status == 429:
                 print_error("quota dépassé côté serveur.", detail or "réessaie plus tard")
+            elif detail:
+                # p. ex. 403 « modèle non inclus dans ton forfait », 413, 503 « modèles en chargement »
+                print_error(detail)
             else:
                 print_error("la requête a échoué ", str(e))
             print()
@@ -688,24 +972,32 @@ def run_chat(client: OpsiomClient, url, api_key):
         used_model = final_event.get("model", current_model or "?")
         print(f"  {muted(format_elapsed(elapsed_ms))}")
 
-        remaining_quota = final_event.get("remaining_quota")
-        if remaining_quota is not None:
-            record_authoritative_remaining(api_key, remaining_quota)
+        server_quota = final_event.get("quota")            # Space : {used, limit, remaining, ...}
+        remaining_quota = final_event.get("remaining_quota")  # serveur API
+        if isinstance(server_quota, dict):
+            record_server_quota(client.identity, remaining=server_quota.get("remaining"),
+                                used=server_quota.get("used"), limit=server_quota.get("limit"),
+                                unlimited=bool(server_quota.get("unlimited")))
+        elif remaining_quota is not None:
+            record_server_quota(client.identity, remaining=remaining_quota)
         else:
             # Le serveur n'a pas renvoyé de quota faisant autorité (Octix
             # injoignable côté serveur, p. ex.) : on retombe sur l'estimation
             # locale plutôt que de ne rien afficher.
             estimated = estimate_tokens(user_input) + estimate_tokens(response_text)
             usage = load_usage()
-            key_id = _api_key_id(api_key)
-            entry = usage.get(key_id, {})
+            entry = usage.get(client.identity, {})
             if entry.get("date") != today_str():
                 entry = {"date": today_str(), "tokens_used": 0}
             entry["tokens_used"] = entry.get("tokens_used", 0) + estimated
-            usage[key_id] = entry
+            usage[client.identity] = entry
             save_usage(usage)
-            _, remaining_quota = get_quota_state(api_key)
-        print(f"  {muted(f'{remaining_quota} tokens restants aujourd’hui')}")
+        state = get_quota_state(client.identity)
+        if state["unlimited"]:
+            print(f"  {muted('quota illimité')}")
+        else:
+            text = f"{state['remaining']} tokens restants aujourd’hui"
+            print(f"  {muted(text)}")
         print()
         transcript.append({"role": "assistant", "text": response_text, "model": used_model, "elapsed_ms": elapsed_ms})
 
@@ -718,25 +1010,35 @@ def run_chat(client: OpsiomClient, url, api_key):
 
 def main():
     parser = argparse.ArgumentParser(prog="opsiom", description="CLI de chat pour Opsiom")
-    parser.add_argument("--url", default=None, help="URL du serveur Opsiom (sinon config/prompt)")
-    parser.add_argument("--api-key", default=None, help="clé API si le serveur en exige une")
+    parser.add_argument("--url", default=None, help="URL du serveur Opsiom ou du Space Hugging Face (sinon config/prompt)")
+    parser.add_argument("--api-key", default=None, help="clé API si le serveur en exige une (serveur API)")
+    parser.add_argument("--backend", choices=("auto", "api", "hf"), default=None,
+                        help="type de serveur : api (ngrok…) ou hf (Space Hugging Face) ; auto = d'après l'URL")
+    parser.add_argument("--username", default=None, help="pseudo Octix (Space Hugging Face)")
+    parser.add_argument("--hf-token", default=None,
+                        help="jeton d'accès Hugging Face, si le Space est privé (ou variable HF_TOKEN)")
     parser.add_argument("--configure", action="store_true", help="reconfigure l'URL/clé et les réenregistre")
     parser.add_argument("--no-logo", action="store_true", help="masque le repère ASCII au démarrage")
     parser.add_argument("--version", action="version", version=f"opsiom-cli {VERSION}")
     args = parser.parse_args()
     
 
-    url, api_key = resolve_settings(args)
-    if not url:
+    settings = resolve_settings(args)
+    if not settings["url"]:
         print_error("aucune URL configurée, abandon.")
         sys.exit(1)
 
-    client = OpsiomClient(url, api_key=api_key)
+    if settings["backend"] == "hf":
+        client = HFSpaceClient(settings["url"], username=settings["username"], hf_token=settings["hf_token"])
+        if not login_interactive(client, settings["username"]):
+            sys.exit(1)
+    else:
+        client = OpsiomClient(settings["url"], api_key=settings["api_key"])
     if args.no_logo:
         global OCTOPUS_MARK
         OCTOPUS_MARK = []
 
-    run_chat(client, url, api_key)
+    run_chat(client)
 
 
 if __name__ == "__main__":

{opsiom_cli-1.2.5 → opsiom_cli-1.4.0}/src/opsiom_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opsiom-cli
-Version: 1.2.5
+Version: 1.4.0
 Summary: CLI de chat pour Opsiom, l'assistant IA francophone.
 Author-email: Jules Ecorcheville <jules.ecorcheville@gmail.com>
 License-Expression: MIT