"""Connecteurs de l'agent (v7.55.0) — socle : catalogue, statut, fetch gardé SSRF. 5 connecteurs **natifs** (gitea, github, web, google, ms365) servis à la volée, plus des connecteurs **personnels** persistés (URL + clé) en base avec un ``kind`` : ``custom`` | ``discord`` (auth « Bot ») | ``telegram`` (jeton dans l'URL via ``{secret}``) | ``mcp`` (serveur Model Context Protocol, cache d'outils dans ``tools_json``). ponytail : un seul fichier (pas de package ``connectors/`` ni de classe par provider) — 3 probes dans un dict + 1 fetch. Les adapters lourds des phases 6-7 (Google, M365, Discord/Telegram, MCP) arriveront avec leur propre module. """ from __future__ import annotations import json import logging from app.config import settings from app.db import get_conn from app.services import oauth_connectors from app.services.sso_provisioning import decrypt_secret, encrypt_secret logger = logging.getLogger(__name__) NATIVE_KINDS = ("gitea", "github", "web", "google", "ms365") CUSTOM_KINDS = ("custom", "discord", "telegram", "mcp", "tiktak") AUTH_SCHEMES = ("bearer", "bot", "none") # Presets proposés par le formulaire du menu ＋ (le jeton reste toujours saisi # par l'utilisateur — jamais codé en dur ici). PRESETS = { "discord": {"url": "https://discord.com/api/v10", "auth": "bot", "hint": "Bot Discord Developers → Token"}, "telegram": {"url": "https://api.telegram.org/bot{secret}", "auth": "none", "hint": "BotFather → Bot Token (jeton dans l'URL)"}, "mcp": {"url": "https://", "auth": "bearer", "hint": "URL du endpoint MCP (streamable HTTP)"}, # Fusion ACC-2.1 — première paire de fédération : le serveur MCP en # lecture de TikTak (POST /mcp, JSON-RPC) ; la clé `tck_` se crée # dans TikTak → Réglages → Intégrations. Comportement MCP standard # (probe, cache d'outils, outils dynamiques mcp_tiktak_*). "tiktak": {"url": "https://tiktak.dracodev.net/mcp", "auth": "bearer", "hint": "TikTak → Réglages → Intégrations → clé API tck_…"}, } OAUTH_KINDS = oauth_connectors.OAUTH_KINDS FETCH_LIMIT = 20000 # caractères max renvoyés au LLM (ponytail : borne fixe) # ── Natifs (config, sans réseau) ───────────────────────────────────────────── def native_state(kind: str, user_id: int | None = None) -> tuple[str, str]: """(status, detail) d'un connecteur natif — dérivé de la config, sans réseau.""" if kind in OAUTH_KINDS: try: oauth_connectors._client(kind) # lève si client_id/secret absents except ValueError as exc: return ("missing", str(exc)) tok = oauth_connectors.tokens(kind, user_id) if tok.get("access_token"): scope = (tok.get("scope") or "").split() return ("ok", f"connecté · {len(scope)} scope(s)") return ("missing", "non connecté — lancer la connexion OAuth") if kind == "gitea": ok = bool(settings.gitea_url) and settings.gitea_token not in ("", "change-me") return ("ok", settings.gitea_url if ok else "GITEA_TOKEN non configuré") if kind == "github": if settings.github_token: return ("ok", "PAT configuré (30 req/min)") return ("missing", "aucun GITHUB_TOKEN (10 req/min anonyme)") return ("ok", f"recherche web via {settings.web_search_provider or 'duckduckgo'}") def _row(r) -> dict: """Ligne `agent_connectors` → dict API (le jeton n'y figure jamais).""" try: tools = json.loads(r["tools_json"] or "[]") if "tools_json" in r.keys() else [] except (ValueError, TypeError): tools = [] return { "id": r["id"], "builtin": False, "kind": r["kind"], "name": r["name"], "url": r["url"], "auth": r["auth"], "enabled": bool(r["enabled"]), "status": r["status"], "detail": r["detail"] or "", "has_secret": bool(r["secret_encrypted"]), "oauth": False, "tools_count": len(tools), } def list_connectors(user_id: int | None = None) -> list[dict]: """Catalogue : natifs (toujours présents) + connecteurs personnels.""" out: list[dict] = [] for kind in NATIVE_KINDS: status, detail = native_state(kind, user_id) out.append({ "id": None, "builtin": True, "kind": kind, "name": (oauth_connectors.PROVIDERS[kind]["name"] if kind in OAUTH_KINDS else kind.capitalize()), "url": "", "enabled": True, "status": status, "detail": detail, "has_secret": False, "oauth": kind in OAUTH_KINDS, }) with get_conn() as conn: rows = conn.execute( "SELECT id, name, url, secret_encrypted, enabled, status, detail, " "kind, auth, tools_json FROM agent_connectors ORDER BY id" ).fetchall() return out + [_row(r) for r in rows] def get(connector_id: int) -> dict | None: with get_conn() as conn: r = conn.execute( "SELECT id, name, url, secret_encrypted, enabled, status, detail, " "kind, auth, tools_json FROM agent_connectors WHERE id=?", (connector_id,), ).fetchone() return _row(r) if r else None # ── CRUD (personnels) ──────────────────────────────────────────────────────── def create_connector(name: str, url: str, secret: str = "", *, kind: str = "custom", auth: str = "bearer") -> dict: """Valide l'URL (garde SSRF) puis stocke la clé **chiffrée** (Fernet).""" from app.services.importers.url_fetch import _validate_url name = (name or "").strip() if not name: raise ValueError("name est requis") if kind not in CUSTOM_KINDS: raise ValueError(f"kind invalide: {kind} (attendu {', '.join(CUSTOM_KINDS)})") if auth not in AUTH_SCHEMES: raise ValueError(f"auth invalide: {auth} (attendu {', '.join(AUTH_SCHEMES)})") url = (url or "").strip() if "{secret}" in url and not (secret or "").strip(): raise ValueError("clé requise : l'URL contient {secret}") url = _validate_url(url) # lève ValueError si hôte interne with get_conn() as conn: cur = conn.execute( "INSERT INTO agent_connectors (name, url, secret_encrypted, status, " "detail, kind, auth) VALUES (?,?,?,?,?,?,?)", (name, url, encrypt_secret(secret or ""), "unknown", "", kind, auth), ) conn.commit() cid = cur.lastrowid return get(cid) def update_connector(connector_id: int, *, name=None, enabled=None, secret=None) -> dict | None: row = get(connector_id) if row is None: return None sets, params = [], [] if name is not None: name = str(name).strip() if not name: raise ValueError("name est requis") sets.append("name=?") params.append(name) if enabled is not None: sets.append("enabled=?") params.append(1 if enabled else 0) if secret is not None: sets.append("secret_encrypted=?") params.append(encrypt_secret(str(secret))) if sets: with get_conn() as conn: params.append(connector_id) conn.execute(f"UPDATE agent_connectors SET {', '.join(sets)} WHERE id=?", params) conn.commit() return get(connector_id) def delete_connector(connector_id: int) -> bool: with get_conn() as conn: cur = conn.execute("DELETE FROM agent_connectors WHERE id=?", (connector_id,)) conn.commit() return cur.rowcount > 0 # ── Réseau (toujours gardé SSRF) ───────────────────────────────────────────── def _headers(connector_id: int | None = None) -> dict: """En-têtes d'appel : la clé n'est lue (et déchiffrée) qu'ici, jamais renvoyée. ``auth`` = bearer (défaut) | bot (Discord, jeton préfixé) | none (jeton ailleurs). """ headers = {"User-Agent": "FlowDeck-Connectors/1.0"} secret, auth = "", "bearer" if connector_id: with get_conn() as conn: r = conn.execute( "SELECT secret_encrypted, auth FROM agent_connectors WHERE id=?", (connector_id,), ).fetchone() if r: secret = decrypt_secret(r["secret_encrypted"] or "") auth = r["auth"] or "bearer" if secret and auth == "bot": headers["Authorization"] = f"Bot {secret}" elif secret and auth != "none": headers["Authorization"] = f"Bearer {secret}" headers["X-Api-Key"] = secret return headers def _with_secret(url: str, connector_id: int) -> str: """Substitue ``{secret}`` (Telegram : le jeton vit dans l'URL, jamais stocké clair).""" if "{secret}" not in url: return url with get_conn() as conn: r = conn.execute( "SELECT secret_encrypted FROM agent_connectors WHERE id=?", (connector_id,), ).fetchone() secret = decrypt_secret((r["secret_encrypted"] if r else "") or "") if not secret: raise ValueError("clé manquante pour une URL contenant {secret}") return url.replace("{secret}", secret) async def _get(url: str, headers: dict | None = None) -> tuple[int, str]: """GET gardé SSRF (validation + re-vérification après redirection). Point d'injection des tests : on monkeypatche ``connectors._get``. """ from app.services.http_client import shared_client from app.services.importers.url_fetch import _is_public_host, _validate_url safe = _validate_url(url) async with shared_client(timeout=10, follow_redirects=True, headers=headers or {}) as client: resp = await client.get(safe) if resp.url.host and not _is_public_host(resp.url.host): raise ValueError("Redirection vers un hôte non autorisé") return resp.status_code, (resp.text or "")[:FETCH_LIMIT] def _resolve(connector: str) -> tuple[str, str | int]: """« 3 », « Ma clé API » ou « gitea » → (kind, id_custom|kind).""" token = str(connector or "").strip() if not token: raise ValueError("connector est requis") if token.isdigit(): row = get(int(token)) if row is None: raise ValueError(f"Connecteur inconnu: {token}") return (row["kind"], row["id"]) low = token.lower() if low in NATIVE_KINDS: return (low, low) with get_conn() as conn: row = conn.execute( "SELECT id FROM agent_connectors WHERE lower(name)=?", (low,) ).fetchone() if row: return (get(row["id"])["kind"], row["id"]) raise ValueError(f"Connecteur inconnu: {token}") async def probe(connector: str, user_id: int | None = None) -> dict: """Teste un connecteur et **persiste** le résultat (personnel uniquement).""" kind, ref = _resolve(connector) try: if kind in ("mcp", "tiktak"): from app.services import mcp_client tools = await mcp_client.initialize_and_list(int(ref)) status, detail = "ok", f"MCP · {len(tools)} outil(s)" elif kind in OAUTH_KINDS: res = await oauth_connectors.api_get(kind, user_id, oauth_connectors.PROVIDERS[kind]["probe_path"]) status, detail = res["status"], res["text"][:200] elif kind == "gitea": code, _ = await _get(f"{settings.gitea_url.rstrip('/')}/api/v1/version", {"Authorization": f"token {settings.gitea_token}"}) status, detail = ("ok" if code < 400 else "error"), f"HTTP {code}" elif kind == "github": code, _ = await _get("https://api.github.com/rate_limit", _gh_headers()) status, detail = ("ok" if code < 400 else "error"), f"HTTP {code}" elif kind == "web": status, detail = "ok", native_state("web")[1] else: row = get(int(ref)) url = _with_secret(row["url"], int(ref)) code, _ = await _get(url, _headers(int(ref))) status, detail = ("ok" if code < 400 else "error"), f"HTTP {code}" except Exception as exc: # noqa: BLE001 — un probe ne casse jamais l'UI logger.info("Connector probe failed (%s): %s", connector, exc) status, detail = "error", str(exc)[:200] if kind not in NATIVE_KINDS: with get_conn() as conn: conn.execute( "UPDATE agent_connectors SET status=?, detail=? WHERE id=?", (status, detail, int(ref)), ) conn.commit() return {"connector": connector, "status": status, "detail": detail} def _gh_headers() -> dict: headers = {"User-Agent": "FlowDeck-Connectors/1.0", "Accept": "application/vnd.github+json"} if settings.github_token: headers["Authorization"] = f"Bearer {settings.github_token}" return headers async def connector_fetch(connector: str, path: str = "", query: str = "", user_id: int | None = None) -> dict: """Lit un connecteur pour l'LLM : natif = API, web = recherche, perso = GET.""" kind, ref = _resolve(connector) path = (path or "").strip() if kind in OAUTH_KINDS: return await oauth_connectors.api_get(kind, user_id, path) if kind in ("mcp", "tiktak"): from app.services import mcp_client return {"status": "ok", "text": mcp_client.tools_text(int(ref))} if kind == "gitea": base = settings.gitea_url.rstrip("/") url = f"{base}/{path.lstrip('/')}" if path else f"{base}/api/v1/version" code, text = await _get(url, {"Authorization": f"token {settings.gitea_token}"}) elif kind == "github": url = "https://api.github.com/" + path.lstrip("/") if path else "https://api.github.com/rate_limit" code, text = await _get(url, _gh_headers()) elif kind == "web": from app.services.web_search import search_web if not (query or "").strip(): return {"status": "error", "text": "query est requis pour le connecteur web"} results, provider = await search_web(query.strip(), 5) text = "\n".join(f"- {r.get('title', '')} — {r.get('url', '')}\n {r.get('snippet', '')}" for r in results) or "Aucun résultat." return {"status": "ok", "text": f"provider: {provider}\n{text}"[:FETCH_LIMIT]} else: row = get(int(ref)) if row is None: return {"status": "error", "text": "Connecteur supprimé"} if not row["enabled"]: return {"status": "error", "text": "Connecteur désactivé"} url = _with_secret(row["url"], int(ref)).rstrip("/") if path: url += "/" + path.lstrip("/") code, text = await _get(url, _headers(int(ref))) if code >= 400: return {"status": "error", "text": f"HTTP {code} — {text[:400]}"} return {"status": "ok", "text": text[:FETCH_LIMIT]}