# -*- coding: utf-8 -*- """Serveur MCP pour l'espace Idées de TAF. Expose exactement six outils de gestion des idées pour OpenClaw-Perso et autres assistants. Conforme au ticket perso-2026-10-218. """ import os import json import hmac import uuid import logging import urllib.request import urllib.error from contextlib import asynccontextmanager from typing import Any, Dict, List, Optional from starlette.applications import Starlette from starlette.responses import JSONResponse from starlette.routing import Route, Mount from starlette.middleware.base import BaseHTTPMiddleware from mcp.server.fastmcp import FastMCP from mcp.server.streamable_http_manager import StreamableHTTPSessionManager logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s") logger = logging.getLogger("taf-mcp") TAF_BASE = os.environ.get("TAF_BASE_URL", "http://taf:8000").rstrip("/") def get_taf_headers() -> Dict[str, str]: token = os.environ.get("TAF_TOKEN", "").strip() return { "Authorization": f"Bearer {token}", "Content-Type": "application/json" } def taf_request(method: str, path: str, json_data: Any = None) -> Any: url = f"{TAF_BASE}{path}" headers = get_taf_headers() data = None if json_data is not None: data = json.dumps(json_data).encode("utf-8") req = urllib.request.Request(url, data=data, headers=headers, method=method) try: with urllib.request.urlopen(req, timeout=15) as resp: content = resp.read().decode("utf-8") return json.loads(content) if content else {} except urllib.error.HTTPError as e: err_msg = e.read().decode("utf-8", errors="replace") raise RuntimeError(f"Erreur TAF {e.code}: {err_msg[:300]}") except Exception as e: raise RuntimeError(f"Erreur connexion TAF: {e}") def get_all_tasks() -> List[Dict[str, Any]]: data = taf_request("GET", "/api/v1/tasks?space=all") return data.get("tasks", []) def check_idea_access(task_id: str) -> Dict[str, Any]: tasks = get_all_tasks() matching = [t for t in tasks if t.get("id") == task_id] if not matching: raise ValueError(f"Erreur : idée introuvable ({task_id})") item = matching[0] if item.get("space") == "taches": raise ValueError(f"Erreur d'accès : la tâche {task_id} appartient à l'espace taches (seul l'espace idees est autorisé)") if item.get("space") != "idees": raise ValueError(f"Erreur d'accès : l'élément {task_id} n'est pas dans l'espace idees") return item mcp = FastMCP("taf-mcp") @mcp.tool() def idee_ajouter(texte: str = "", etiquettes: Optional[List[str]] = None, text: Optional[str] = None) -> dict: """Ajoute une idée dans l'espace Idées de TAF. Force l'espace à 'idees' et la source à 'openclaw'.""" content = texte or text or "" if not content.strip(): raise ValueError("Le texte de l'idée ne peut pas être vide") tags = etiquettes if etiquettes is not None else [] if isinstance(tags, str): tags = [tags] body = { "text": content, "space": "idees", "source": "openclaw", "status": "nouvelle", "tags": tags } return taf_request("POST", "/api/v1/tasks", json_data=body) @mcp.tool() def idees_lister(statut: Optional[str] = None, etiquette: Optional[str] = None, depuis: Optional[str] = None) -> dict: """Liste les idées actives de l'espace Idées avec filtres optionnels par statut, étiquette ou date de modification.""" path = "/api/v1/tasks?space=idees" if depuis: path += f"&since={depuis}" data = taf_request("GET", path) tasks = data.get("tasks", []) filtered = [] for t in tasks: if t.get("deleted"): continue if t.get("space") != "idees": continue if statut and t.get("status") != statut: continue if etiquette and etiquette not in (t.get("tags") or []): continue filtered.append(t) return {"idees": filtered, "total": len(filtered)} @mcp.tool() def idee_rechercher(mot: str) -> dict: """Recherche des idées dans l'espace Idées par mot-clé (cherche dans le texte brut, la reformulation et les étiquettes).""" q = (mot or "").strip().lower() if not q: return {"resultats": [], "total": 0} data = taf_request("GET", "/api/v1/tasks?space=idees") tasks = data.get("tasks", []) matching = [] for t in tasks: if t.get("deleted") or t.get("space") != "idees": continue t_text = (t.get("text") or "").lower() t_reframed = (t.get("reframed") or "").lower() t_tags = [str(tag).lower() for tag in (t.get("tags") or [])] if q in t_text or q in t_reframed or any(q in tag for tag in t_tags): matching.append(t) return {"resultats": matching, "total": len(matching)} @mcp.tool() def idee_recadrer(id: str, reformulation: str, text: Optional[str] = None, texte: Optional[str] = None) -> dict: """Recadre ou reformule une idée existante. Interdiction absolue de modifier le texte brut original.""" if text is not None or texte is not None: raise ValueError("le texte brut de Nabil est intouchable, utiliser idee_recadrer") check_idea_access(id) body = {"reframed": reformulation} return taf_request("PATCH", f"/api/v1/tasks/{id}", json_data=body) @mcp.tool() def idee_statut(id: str, statut: str, text: Optional[str] = None, texte: Optional[str] = None) -> dict: """Modifie le statut d'une idée (nouvelle, a_creuser, en_cours, abandonnee).""" if text is not None or texte is not None: raise ValueError("le texte brut de Nabil est intouchable, utiliser idee_recadrer") valid_statuses = ("nouvelle", "a_creuser", "en_cours", "abandonnee") if statut not in valid_statuses: raise ValueError(f"Statut invalide : {statut}. Valeurs autorisées : {', '.join(valid_statuses)}") check_idea_access(id) body = {"status": statut} return taf_request("PATCH", f"/api/v1/tasks/{id}", json_data=body) @mcp.tool() def idee_etiqueter(id: str, etiquettes: List[str], text: Optional[str] = None, texte: Optional[str] = None) -> dict: """Met à jour les étiquettes d'une idée (au plus 8 étiquettes de 40 caractères max).""" if text is not None or texte is not None: raise ValueError("le texte brut de Nabil est intouchable, utiliser idee_recadrer") tags = etiquettes if isinstance(tags, str): tags = [tags] if len(tags) > 8: raise ValueError("Au plus 8 étiquettes") for tag in tags: if len(tag) > 40: raise ValueError("Chaque étiquette doit faire au plus 40 caractères") check_idea_access(id) body = {"tags": tags} return taf_request("PATCH", f"/api/v1/tasks/{id}", json_data=body) session_manager = StreamableHTTPSessionManager(mcp._mcp_server, stateless=True, json_response=True) class AuthAndSessionMiddleware(BaseHTTPMiddleware): async def dispatch(self, request, call_next): if request.url.path == "/health": return await call_next(request) auth = request.headers.get("authorization", "").strip() if not auth.startswith("Bearer "): logger.warning("Auth refusée : en-tête Bearer manquant ou invalide (chemin=%s)", request.url.path) return JSONResponse({"error": "jeton manquant ou invalide"}, status_code=401) token = auth[len("Bearer "):].strip() openclaw_tok = os.environ.get("TAF_MCP_TOKEN_OPENCLAW_PERSO", "").strip() authenticated = False if openclaw_tok and hmac.compare_digest(token, openclaw_tok): authenticated = True else: for k, v in os.environ.items(): if k.startswith("TAF_MCP_TOKEN_") and k != "TAF_MCP_TOKEN_OPENCLAW_PERSO": if v and hmac.compare_digest(token, v.strip()): authenticated = True break if not authenticated: logger.warning("Auth refusée : jeton invalide (chemin=%s)", request.url.path) return JSONResponse({"error": "jeton invalide"}, status_code=401) response = await call_next(request) if "mcp-session-id" not in response.headers: req_sid = request.headers.get("mcp-session-id") response.headers["mcp-session-id"] = req_sid or str(uuid.uuid4()) return response async def health(request): return JSONResponse({"status": "ok", "service": "taf-mcp", "tools": 6}) @asynccontextmanager async def lifespan(app_instance): global session_manager if getattr(session_manager, "_has_started", False): session_manager = StreamableHTTPSessionManager(mcp._mcp_server, stateless=True, json_response=True) async with session_manager.run(): yield app = Starlette( routes=[ Route("/health", health), Mount("/mcp", app=session_manager.handle_request), Mount("/", app=session_manager.handle_request), ], lifespan=lifespan ) app.add_middleware(AuthAndSessionMiddleware) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)