232 lines
8.9 KiB
Python
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)
|