Files
taf-mcp/main.py
T

232 lines
8.9 KiB
Python

# -*- 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):
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)