nemesis-cli 1.0.2__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,11 @@
1
+ Metadata-Version: 2.4
2
+ Name: nemesis-cli
3
+ Version: 1.0.2
4
+ Summary: Client terminal NEMESIS — agents IA depuis le terminal
5
+ Requires-Python: >=3.11
6
+ Requires-Dist: rich>=13.0
7
+ Requires-Dist: prompt_toolkit>=3.0
8
+ Requires-Dist: click>=8.0
9
+ Requires-Dist: httpx>=0.27
10
+ Requires-Dist: rich-pixels>=3.0
11
+ Requires-Dist: pillow>=10.0
@@ -0,0 +1,82 @@
1
+ # NEMESIS
2
+
3
+ Plateforme d'orchestration d'agents IA autonomes.
4
+
5
+ ## Structure
6
+
7
+ - `backend/` — Cœur du système (Python, CrewAI)
8
+ - `frontend/` — Interface et landing (React, Vite)
9
+ - `docs/` — Documentation
10
+
11
+ ## Stack
12
+
13
+ Backend : Python 3.12, CrewAI, FastAPI, LiteLLM
14
+ Frontend : React 19, Vite 8, Tailwind CSS 4
15
+ LLM : OpenRouter (principal), Groq, Cerebras (fallbacks)
16
+ Pilotage : Web, Telegram, CLI
17
+
18
+ ## Lancer en local
19
+
20
+ ### 1. Backend (`backend/.env`)
21
+
22
+ Copier `backend/.env.example` → `backend/.env` et renseigner les
23
+ variables (le `.env` est lu quel que soit le dossier de lancement) :
24
+
25
+ - LLM : `OPENROUTER_API_KEY`, `GROQ_API_KEY`, `CEREBRAS_API_KEY`
26
+ - Recherche : `SERPER_API_KEY`
27
+ - Supabase : `SUPABASE_URL`, `SUPABASE_SERVICE_ROLE_KEY`, `SUPABASE_JWT_SECRET`
28
+ - CORS local (obligatoire : aucune origine locale n'est acceptée par défaut) :
29
+ `CORS_ORIGINS=http://localhost:5173,http://127.0.0.1:5173`
30
+
31
+ ```bash
32
+ cd backend
33
+ venv\Scripts\activate # Windows (ou source venv/bin/activate)
34
+ pip install -r requirements.txt
35
+ uvicorn api.main:app --host 127.0.0.1 --port 8000 --reload
36
+ ```
37
+
38
+ ### 2. Frontend (`frontend/.env.local`)
39
+
40
+ Copier `frontend/.env.example` → `frontend/.env.local` :
41
+
42
+ ```
43
+ VITE_API_URL=http://127.0.0.1:8000
44
+ VITE_SUPABASE_URL=…
45
+ VITE_SUPABASE_ANON_KEY=…
46
+ ```
47
+
48
+ ⚠️ Utiliser `127.0.0.1` si uvicorn écoute sur `127.0.0.1` : sous Windows,
49
+ `localhost` peut résoudre en `::1` (IPv6) alors que le serveur n'écoute
50
+ qu'en IPv4 → « Failed to fetch » dans le navigateur.
51
+
52
+ ```bash
53
+ cd frontend
54
+ npm install
55
+ npm run dev # http://localhost:5173
56
+ ```
57
+
58
+ ### 3. Supabase Dashboard (auth en local)
59
+
60
+ Dans **Authentication → URL Configuration** :
61
+
62
+ - **Site URL** : `http://localhost:5173`
63
+ - **Redirect URLs** : ajouter `http://localhost:5173/auth/callback`
64
+ (et `http://127.0.0.1:5173/auth/callback` si vous ouvrez le front en IP)
65
+
66
+ Sans ces URLs, le login Google retombe sur l'URL de production.
67
+
68
+ ### Sécurité
69
+
70
+ Les fichiers `.env`, `.env.local` et `*.local` sont ignorés par git —
71
+ ne jamais les committer. Les `.env.example` ne contiennent que des noms.
72
+
73
+ ## Auteur
74
+
75
+ Yrigalé Saint Michel
76
+ - GitHub : https://github.com/BigsaintMichel
77
+ - LinkedIn : https://www.linkedin.com/in/saint-michel-yirigale-945570328
78
+ - Email : saintmichelyirigale@gmail.com
79
+
80
+ ## Licence
81
+
82
+ Projet privé — Tous droits réservés.
@@ -0,0 +1,3 @@
1
+ """Client terminal NEMESIS — commande `nemesis`."""
2
+
3
+ __version__ = "1.0.2"
@@ -0,0 +1,4 @@
1
+ """`python -m nemesis_cli` — point d'entrée module."""
2
+ from .main import main
3
+
4
+ main()
@@ -0,0 +1,209 @@
1
+ """Client HTTP vers l'API NEMESIS + auth Supabase (grant password/refresh)."""
2
+ from __future__ import annotations
3
+
4
+ import base64
5
+ import json
6
+ import time
7
+
8
+ import httpx
9
+
10
+ from .config import SUPABASE_ANON_KEY, SUPABASE_URL
11
+
12
+
13
+ class ErreurAPI(Exception):
14
+ """Erreur HTTP/réseau traduite en français pour l'utilisateur."""
15
+
16
+ def __init__(self, message: str, status: int = 0):
17
+ super().__init__(message)
18
+ self.status = status
19
+
20
+
21
+ def _detail(res: httpx.Response) -> str:
22
+ try:
23
+ data = res.json()
24
+ return str(data.get("detail") or data.get("error_description")
25
+ or data.get("msg") or "")
26
+ except Exception:
27
+ return ""
28
+
29
+
30
+ def _traduire(status: int, detail: str = "") -> str:
31
+ if status == 401:
32
+ return "Session expirée ou jeton invalide — relance `nemesis login`."
33
+ if status == 403:
34
+ return detail or ("Accès refusé : compte non invité, suspendu ou "
35
+ "ressource interdite.")
36
+ if status == 404:
37
+ return detail or "Route introuvable — l'API n'est peut-être pas à jour."
38
+ if status == 429:
39
+ return detail or ("Quota de tokens atteint : réessaie demain ou "
40
+ "passe à un plan supérieur (Premium / Ultra).")
41
+ if status >= 500:
42
+ return detail or (f"Erreur serveur ({status}) — l'API est "
43
+ "peut-être en redémarrage, réessaie dans un instant.")
44
+ return detail or f"Erreur HTTP {status}"
45
+
46
+
47
+ def connexion(email: str, mdp: str,
48
+ url_supa: str = SUPABASE_URL,
49
+ cle: str = SUPABASE_ANON_KEY) -> dict:
50
+ """Grant password Supabase → {jeton, refresh, email} pour la config."""
51
+ try:
52
+ res = httpx.post(
53
+ f"{url_supa.rstrip('/')}/auth/v1/token?grant_type=password",
54
+ headers={"apikey": cle},
55
+ json={"email": email, "password": mdp},
56
+ timeout=20,
57
+ )
58
+ except httpx.HTTPError:
59
+ raise ErreurAPI("Serveur d'authentification injoignable — "
60
+ "vérifie ta connexion réseau.")
61
+ if res.status_code == 400:
62
+ raise ErreurAPI("E-mail ou mot de passe incorrect.", 400)
63
+ if res.status_code != 200:
64
+ raise ErreurAPI(_traduire(res.status_code, _detail(res)),
65
+ res.status_code)
66
+ data = res.json()
67
+ return {
68
+ "jeton": data["access_token"],
69
+ "refresh": data.get("refresh_token", ""),
70
+ "email": (data.get("user") or {}).get("email") or email,
71
+ }
72
+
73
+
74
+ def echanger_code_pkce(code: str, code_verifier: str,
75
+ url_supa: str = SUPABASE_URL,
76
+ cle: str = SUPABASE_ANON_KEY) -> dict:
77
+ """Échange un code OAuth PKCE contre une session {jeton, refresh, email}."""
78
+ try:
79
+ res = httpx.post(
80
+ f"{url_supa.rstrip('/')}/auth/v1/token?grant_type=pkce",
81
+ headers={"apikey": cle},
82
+ json={"auth_code": code, "code_verifier": code_verifier},
83
+ timeout=20,
84
+ )
85
+ except httpx.HTTPError:
86
+ raise ErreurAPI("Serveur d'authentification injoignable — "
87
+ "vérifie ta connexion réseau.")
88
+ if res.status_code != 200:
89
+ raise ErreurAPI("Échec de la connexion OAuth — réessaie "
90
+ "`nemesis login --google`.", res.status_code)
91
+ data = res.json()
92
+ return {
93
+ "jeton": data["access_token"],
94
+ "refresh": data.get("refresh_token", ""),
95
+ "email": (data.get("user") or {}).get("email") or "",
96
+ }
97
+
98
+
99
+ def jeton_expire(jeton: str, marge: int = 60) -> bool:
100
+ """True si le JWT expire dans moins de `marge` s — décodage local, sans
101
+ vérification de signature (c'est le serveur qui la vérifie)."""
102
+ try:
103
+ payload = jeton.split(".")[1]
104
+ payload += "=" * (-len(payload) % 4)
105
+ exp = json.loads(base64.urlsafe_b64decode(payload))["exp"]
106
+ return exp < time.time() + marge
107
+ except Exception:
108
+ return False
109
+
110
+
111
+ def rafraichir(refresh: str,
112
+ url_supa: str = SUPABASE_URL,
113
+ cle: str = SUPABASE_ANON_KEY) -> dict:
114
+ """Refresh grant → {jeton, refresh}. Échec = session morte."""
115
+ try:
116
+ res = httpx.post(
117
+ f"{url_supa.rstrip('/')}/auth/v1/token?grant_type=refresh_token",
118
+ headers={"apikey": cle},
119
+ json={"refresh_token": refresh},
120
+ timeout=15,
121
+ )
122
+ except httpx.HTTPError:
123
+ raise ErreurAPI("Impossible de joindre l'authentification — "
124
+ "vérifie ta connexion.")
125
+ if res.status_code != 200:
126
+ raise ErreurAPI("Session expirée — relance `nemesis login`.", 401)
127
+ data = res.json()
128
+ return {"jeton": data["access_token"],
129
+ "refresh": data.get("refresh_token", refresh)}
130
+
131
+
132
+ class API:
133
+ """Client des routes /api/* — Bearer JWT, erreurs traduites."""
134
+
135
+ def __init__(self, url: str, jeton: str = ""):
136
+ self.url = url.rstrip("/")
137
+ self.jeton = jeton
138
+ self.client = httpx.Client(
139
+ timeout=httpx.Timeout(60.0, connect=10.0))
140
+
141
+ def _req(self, methode: str, chemin: str, **kw) -> httpx.Response:
142
+ h = {"Content-Type": "application/json"}
143
+ if self.jeton:
144
+ h["Authorization"] = f"Bearer {self.jeton}"
145
+ try:
146
+ res = self.client.request(
147
+ methode, f"{self.url}{chemin}", headers=h, **kw)
148
+ except httpx.ConnectError:
149
+ raise ErreurAPI(
150
+ f"API injoignable : {self.url}\n"
151
+ "Vérifie l'URL (NEMESIS_API_URL / nemesis login) "
152
+ "et ta connexion.")
153
+ except httpx.HTTPError as e:
154
+ raise ErreurAPI(
155
+ f"Erreur réseau ({e.__class__.__name__}) — réessaie.")
156
+ if res.status_code >= 400:
157
+ raise ErreurAPI(
158
+ _traduire(res.status_code, _detail(res)), res.status_code)
159
+ return res
160
+
161
+ def get(self, chemin: str) -> dict:
162
+ return self._req("GET", chemin).json()
163
+
164
+ def post(self, chemin: str, data: dict) -> dict:
165
+ return self._req("POST", chemin, json=data).json()
166
+
167
+ def soumettre(self, message: str, template: str = "auto",
168
+ contexte: str | None = None) -> str:
169
+ rep = self.post("/api/jobs", {
170
+ "message": message, "template": template, "context": contexte,
171
+ })
172
+ return rep["job_id"]
173
+
174
+ def completions(self, message: str,
175
+ historique: list[dict] | None = None) -> str:
176
+ """POST /v1/chat/completions (format OpenAI) — réponse directe,
177
+ sans job à poller. Pour `nemesis chat "…"`."""
178
+ messages = [
179
+ {"role": m["role"], "content": m["content"]}
180
+ for m in (historique or [])
181
+ if m.get("role") in ("user", "assistant")]
182
+ messages.append({"role": "user", "content": message})
183
+ rep = self.post("/v1/chat/completions",
184
+ {"model": "nemesis", "messages": messages})
185
+ return rep["choices"][0]["message"]["content"]
186
+
187
+ def job(self, job_id: str) -> dict:
188
+ return self.get(f"/api/jobs/{job_id}")
189
+
190
+ def quota(self) -> dict:
191
+ try:
192
+ return self.get("/api/jobs/quota")
193
+ except ErreurAPI:
194
+ return {}
195
+
196
+ def statut(self) -> dict:
197
+ return self.get("/api/user/status")
198
+
199
+ def telecharger(self, chemin_relatif: str) -> tuple[bytes, str]:
200
+ """GET /api/download/{id} → (contenu, nom de fichier)."""
201
+ res = self._req("GET", chemin_relatif)
202
+ nom = "nemesis.pdf"
203
+ cd = res.headers.get("Content-Disposition", "")
204
+ if 'filename="' in cd:
205
+ nom = cd.split('filename="', 1)[1].split('"', 1)[0]
206
+ return res.content, nom
207
+
208
+ def close(self) -> None:
209
+ self.client.close()
@@ -0,0 +1,210 @@
1
+ """Commandes slash, garde-fous /file et /save, presse-papiers."""
2
+ from __future__ import annotations
3
+
4
+ import re
5
+ import shlex
6
+ import subprocess
7
+ import sys
8
+ from pathlib import Path
9
+
10
+ from . import ui
11
+
12
+ COMMANDES = {
13
+ "/help": "affiche cette aide",
14
+ "/exit": "quitte le chat (alias : /quit)",
15
+ "/quit": "quitte le chat",
16
+ "/clear": "efface l'écran et remet le contexte à zéro",
17
+ "/file <chemin> [autres…]": "joint des fichiers texte au prochain message",
18
+ "/save [nom]": "enregistre la dernière réponse ou le dernier bloc de code",
19
+ "/copy": "copie le dernier bloc de code dans le presse-papiers",
20
+ "/pdf <titre>": "génère un rapport PDF et le télécharge ici",
21
+ "/history": "affiche les échanges du contexte",
22
+ "/whoami": "affiche compte, plan et quota du mois",
23
+ "/quota": "affiche les tokens restants ce mois-ci",
24
+ "/compact": "réduit le contexte aux 4 derniers échanges",
25
+ }
26
+
27
+ TAILLE_MAX = 200 * 1024 # 200 Ko
28
+ LIGNES_APERTU = 400 # extrait si le fichier est énorme mais accepté
29
+
30
+ CHEMIN_SENSIBLE = re.compile(
31
+ r"(^|[/\\])\.env(\.|$)|\.pem$|id_rsa|\.key$|[/\\]\.ssh|[/\\]\.aws|"
32
+ r"[/\\]\.nemesis|\.pfx$|credentials\.json$", re.IGNORECASE)
33
+
34
+ SECRET_EVIDENT = re.compile(
35
+ r"sk-[A-Za-z0-9_\-]{10,}" # OpenAI/OpenRouter
36
+ r"|sk-ant-[A-Za-z0-9_\-]{10,}" # Anthropic
37
+ r"|xox[baprs]-[A-Za-z0-9\-]{10,}" # Slack
38
+ r"|AKIA[0-9A-Z]{16}" # AWS access key
39
+ r"|gh[pousr]_[A-Za-z0-9]{20,}" # GitHub
40
+ r"|-----BEGIN [A-Z ]*PRIVATE KEY-----"
41
+ r"|service_role['\"\s:=]+[A-Za-z0-9_\-\.]{20,}"
42
+ r"|eyJ[A-Za-z0-9_\-]{10,}\.eyJ[A-Za-z0-9_\-]{10,}") # JWT
43
+
44
+
45
+ def parser_commande(ligne: str) -> tuple[str, list[str]] | None:
46
+ """'/pdf rapport marché' → ('/pdf', ['rapport', 'marché']). None sinon."""
47
+ ligne = ligne.strip()
48
+ if not ligne.startswith("/"):
49
+ return None
50
+ try:
51
+ mots = shlex.split(ligne)
52
+ except ValueError:
53
+ mots = ligne.split()
54
+ if not mots:
55
+ return None
56
+ return mots[0].lower(), mots[1:]
57
+
58
+
59
+ def aide() -> str:
60
+ lignes = ["Commandes :"]
61
+ for cmd, desc in COMMANDES.items():
62
+ lignes.append(f" {cmd:34s} {desc}")
63
+ lignes.append(" Entrée=envoyer · Alt+Maj+Entrée=nouvelle ligne · "
64
+ "Ctrl+C=annule · Ctrl+D=quitte")
65
+ return "\n".join(lignes)
66
+
67
+
68
+ # ───────────────────────────── /file ─────────────────────────────
69
+
70
+ def lire_fichier(chemin: str, confirmer=ui.demander_confirm) -> str | None:
71
+ """Lit un fichier avec garde-fous. Renvoie le bloc de contexte markdown
72
+ ou None si refusé. Lève ValueError avec message français."""
73
+ p = Path(chemin).expanduser()
74
+ if not p.exists():
75
+ raise ValueError(f"Fichier introuvable : {chemin}")
76
+ if not p.is_file():
77
+ raise ValueError(f"Pas un fichier : {chemin}")
78
+
79
+ rel = str(p)
80
+ if CHEMIN_SENSIBLE.search(rel) or CHEMIN_SENSIBLE.search(p.name):
81
+ if not confirmer(f"⚠ {p.name} est un chemin sensible "
82
+ f"(clés/env). L'envoyer quand même ?"):
83
+ raise ValueError(f"{p.name} : envoi refusé (chemin sensible).")
84
+
85
+ taille = p.stat().st_size
86
+ if taille > TAILLE_MAX:
87
+ raise ValueError(
88
+ f"{p.name} fait {taille // 1024} Ko (max 200 Ko). "
89
+ "Coupe-le ou résume-le d'abord.")
90
+ try:
91
+ texte = p.read_text(encoding="utf-8")
92
+ except UnicodeDecodeError:
93
+ raise ValueError(f"{p.name} n'est pas du texte lisible "
94
+ "(binaire ?).")
95
+
96
+ if SECRET_EVIDENT.search(texte):
97
+ if not confirmer(f"⚠ {p.name} semble contenir des secrets "
98
+ f"(clés API, tokens…). Envoyer quand même ?"):
99
+ raise ValueError(f"{p.name} : envoi refusé (secret détecté).")
100
+
101
+ lignes = texte.splitlines()
102
+ extrait = texte
103
+ if len(lignes) > LIGNES_APERTU:
104
+ extrait = "\n".join(lignes[:LIGNES_APERTU])
105
+ extrait += f"\n… ({len(lignes) - LIGNES_APERTU} lignes restantes)"
106
+ ui.info(f"📎 {p.name} ({len(lignes)} lignes) joint")
107
+ return f"### Fichier `{p.name}`\n```\n{extrait}\n```"
108
+
109
+
110
+ def jointures(chemins: list[str], confirmer=ui.demander_confirm) -> str:
111
+ """/file a b c → un bloc de contexte markdown. Erreurs collectées."""
112
+ blocs, erreurs = [], []
113
+ for c in chemins:
114
+ try:
115
+ blocs.append(lire_fichier(c, confirmer))
116
+ except ValueError as e:
117
+ erreurs.append(str(e))
118
+ for e in erreurs:
119
+ ui.afficher_erreur(ValueError(e))
120
+ return "\n\n".join(b for b in blocs if b)
121
+
122
+
123
+ # ───────────────────────────── /save & /copy ─────────────────────────────
124
+
125
+ EXTS = {"python": ".py", "py": ".py", "javascript": ".js", "js": ".js",
126
+ "typescript": ".ts", "ts": ".ts", "html": ".html", "css": ".css",
127
+ "bash": ".sh", "sh": ".sh", "json": ".json", "sql": ".sql",
128
+ "yaml": ".yaml", "yml": ".yml", "go": ".go", "rust": ".rs",
129
+ "java": ".java", "c": ".c", "cpp": ".cpp"}
130
+
131
+
132
+ def dernier_bloc_code(texte: str) -> tuple[str, str] | None:
133
+ """Extrait le dernier ```lang … ``` → (lang, code)."""
134
+ blocs = re.findall(r"```(\w*)\n(.*?)```", texte, re.DOTALL)
135
+ if not blocs:
136
+ return None
137
+ return blocs[-1]
138
+
139
+
140
+ def nom_defaut(texte: str, base: str = "nemesis") -> str:
141
+ bloc = dernier_bloc_code(texte)
142
+ if bloc:
143
+ return base + EXTS.get(bloc[0].lower(), ".txt")
144
+ return base + ".md"
145
+
146
+
147
+ def sauvegarder(contenu: str, nom: str,
148
+ confirmer=ui.demander_confirm) -> Path | None:
149
+ """Écrit `contenu` dans `nom` — jamais hors du dossier courant ni
150
+ écrasement sans confirmation. Renvoie le chemin absolu."""
151
+ dest = Path(nom).expanduser()
152
+ if not dest.is_absolute():
153
+ dest = (Path.cwd() / dest).resolve()
154
+ else:
155
+ dest = dest.resolve()
156
+
157
+ if Path.cwd() not in dest.parents and dest != Path.cwd():
158
+ if not confirmer(f"⚠ {dest} est hors du dossier courant "
159
+ f"({Path.cwd()}). Écrire quand même ?"):
160
+ ui.avertir("Enregistrement annulé (hors dossier courant).")
161
+ return None
162
+ if dest.exists():
163
+ if not confirmer(f"⚠ {dest.name} existe déjà. Écraser ?"):
164
+ ui.avertir("Enregistrement annulé.")
165
+ return None
166
+ dest.parent.mkdir(parents=True, exist_ok=True)
167
+ dest.write_text(contenu, encoding="utf-8")
168
+ ui.info(f"✓ Enregistré : {dest}")
169
+ return dest
170
+
171
+
172
+ def sauvegarder_bytes(data: bytes, nom: str,
173
+ confirmer=ui.demander_confirm) -> Path | None:
174
+ """Idem sauvegarder() mais pour du binaire (PDF téléchargé)."""
175
+ dest = Path(nom)
176
+ if not dest.is_absolute():
177
+ dest = (Path.cwd() / dest).resolve()
178
+ if Path.cwd() not in dest.parents and dest != Path.cwd():
179
+ if not confirmer(f"⚠ {dest} est hors du dossier courant. "
180
+ "Écrire quand même ?"):
181
+ ui.avertir("Enregistrement annulé.")
182
+ return None
183
+ if dest.exists() and not confirmer(f"⚠ {dest.name} existe. Écraser ?"):
184
+ ui.avertir("Enregistrement annulé.")
185
+ return None
186
+ dest.parent.mkdir(parents=True, exist_ok=True)
187
+ dest.write_bytes(data)
188
+ ui.info(f"✓ Enregistré : {dest}")
189
+ return dest
190
+
191
+
192
+ def copier(texte: str) -> bool:
193
+ """Copie dans le presse-papiers (clip.exe / pbcopy / xclip / wl-copy)."""
194
+ essais = []
195
+ if sys.platform.startswith("win"):
196
+ essais = [["clip"]]
197
+ elif sys.platform == "darwin":
198
+ essais = [["pbcopy"]]
199
+ else:
200
+ essais = [["wl-copy"], ["xclip", "-selection", "clipboard"],
201
+ ["xsel", "-b"]]
202
+ for cmd in essais:
203
+ try:
204
+ subprocess.run(cmd, input=texte.encode("utf-8"),
205
+ check=True, capture_output=True, timeout=5)
206
+ return True
207
+ except (FileNotFoundError, subprocess.CalledProcessError,
208
+ subprocess.TimeoutExpired):
209
+ continue
210
+ return False
@@ -0,0 +1,61 @@
1
+ """Configuration du CLI : ~/.nemesis/config.toml (chmod 600) + variables d'env.
2
+
3
+ Priorité : NEMESIS_API_URL / NEMESIS_TOKEN > config.toml > défauts.
4
+ Le .env du backend n'est JAMAIS chargé ici (sauf mode --local explicite).
5
+ """
6
+ from __future__ import annotations
7
+
8
+ import os
9
+ import stat
10
+ import tomllib
11
+ from pathlib import Path
12
+
13
+ DOSSIER = Path.home() / ".nemesis"
14
+ FICHIER = DOSSIER / "config.toml"
15
+ HISTORIQUE = DOSSIER / "historique"
16
+
17
+ # Instance publique par défaut. La clé anon Supabase est « publishable » :
18
+ # elle est déjà servie à tous les navigateurs par le frontend — pas un secret.
19
+ API_URL_DEFAUT = "https://nemesis-ia-production-d93c.up.railway.app"
20
+ SUPABASE_URL = "https://zxjlmbftwnsabupkcpto.supabase.co"
21
+ SUPABASE_ANON_KEY = "sb_publishable_5DVn_Ztn-ZBMH2z1mNejiw_-XsKNFDm"
22
+
23
+
24
+ def charger() -> dict:
25
+ """Renvoie {url_api, jeton, refresh, email} fusionné fichier + env."""
26
+ cfg = {"url_api": API_URL_DEFAUT, "jeton": "", "refresh": "", "email": ""}
27
+ if FICHIER.exists():
28
+ try:
29
+ cfg.update({k: v for k, v in tomllib.loads(
30
+ FICHIER.read_text(encoding="utf-8")).items() if isinstance(v, str)})
31
+ except Exception:
32
+ pass # config corrompue → défauts
33
+ if os.getenv("NEMESIS_API_URL"):
34
+ cfg["url_api"] = os.environ["NEMESIS_API_URL"]
35
+ if os.getenv("NEMESIS_TOKEN"):
36
+ cfg["jeton"] = os.environ["NEMESIS_TOKEN"]
37
+ cfg["url_api"] = cfg["url_api"].rstrip("/")
38
+ return cfg
39
+
40
+
41
+ def sauvegarder(cfg: dict) -> None:
42
+ """Écrit config.toml en 600 — le jeton n'est jamais affiché ni logué."""
43
+ DOSSIER.mkdir(parents=True, exist_ok=True)
44
+ lignes = []
45
+ for k, v in cfg.items():
46
+ if v:
47
+ v = str(v).replace("\\", "\\\\").replace('"', '\\"')
48
+ lignes.append(f'{k} = "{v}"')
49
+ FICHIER.write_text("\n".join(lignes) + "\n", encoding="utf-8")
50
+ try:
51
+ os.chmod(FICHIER, stat.S_IRUSR | stat.S_IWUSR)
52
+ except OSError:
53
+ pass # Windows : les ACL du profil utilisateur s'appliquent déjà
54
+
55
+
56
+ def effacer() -> None:
57
+ """logout : supprime le jeton, conserve l'URL de l'API."""
58
+ cfg = charger()
59
+ for cle in ("jeton", "refresh", "email"):
60
+ cfg.pop(cle, None)
61
+ sauvegarder(cfg)