From c3c9b0f06edc61881d697b6910b7cd2009addf4f Mon Sep 17 00:00:00 2001 From: bolbol Date: Wed, 28 Oct 2026 08:09:40 +0000 Subject: [PATCH] feat(mcp): initialisation serveur MCP taf-mcp espace Idees (perso-2026-10-218) --- .gitignore | 5 + Dockerfile | 13 +++ README.md | 30 ++++++ docker-compose.yml | 23 +++++ main.py | 231 +++++++++++++++++++++++++++++++++++++++++++ requirements.txt | 6 ++ tests/__init__.py | 0 tests/test_server.py | 115 +++++++++++++++++++++ 8 files changed, 423 insertions(+) create mode 100644 .gitignore create mode 100644 Dockerfile create mode 100644 README.md create mode 100644 docker-compose.yml create mode 100644 main.py create mode 100644 requirements.txt create mode 100644 tests/__init__.py create mode 100644 tests/test_server.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5a81215 --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.env +__pycache__/ +*.py[cod] +*$py.class +.pytest_cache/ diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..5ba18ec --- /dev/null +++ b/Dockerfile @@ -0,0 +1,13 @@ +FROM python:3.12-slim +WORKDIR /app +ENV PYTHONPATH=/app +ENV PYTHONDONTWRITEBYTECODE=1 +RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/* +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt +COPY main.py . +COPY tests/ ./tests/ +RUN useradd -m -u 1026 appuser && chown -R appuser:appuser /app +USER appuser +EXPOSE 8000 +CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "1"] diff --git a/README.md b/README.md new file mode 100644 index 0000000..a5d69ef --- /dev/null +++ b/README.md @@ -0,0 +1,30 @@ +# taf-mcp — Serveur MCP pour l'espace Idées de TAF + +Serveur MCP exposant l'espace **Idées** de TAF (Ticket `perso-2026-10-218`) pour OpenClaw-Perso (NAS) et les autres assistants. + +## Architecture + +- **Protocole** : MCP via FastMCP et StreamableHTTP (`/mcp` et `/`). +- **Réseau Docker** : `mcp-vps` (accès direct à l'API de TAF sur `http://taf:8000`). +- **Ports d'écoute** : Publié **strictement** sur `127.0.0.1:3105` et `100.94.90.119:3105` (aucun accès 0.0.0.0 ni ::). +- **Authentification** : Bearer token par assistant, validé en temps constant (`hmac.compare_digest`). Jeton OpenClaw-Perso transmis par la variable `TAF_MCP_TOKEN_OPENCLAW_PERSO`. +- **Intégrité & Sécurité** : + - Aucun montage de `docker.sock`. + - Conteneur exécuté en utilisateur non-root (`appuser`, uid 1026). + - Politique de redémarrage : `unless-stopped`. + - Healthcheck HTTP sur `/health`. + +## Les 6 Outils MCP + +1. `idee_ajouter(texte, etiquettes)` : Ajoute une idée (force `space=idees`, `source=openclaw`, `status=nouvelle`). +2. `idees_lister(statut, etiquette, depuis)` : Liste les idées actives selon les filtres. +3. `idee_rechercher(mot)` : Recherche textuelle dans le texte brut, la reformulation et les étiquettes. +4. `idee_recadrer(id, reformulation)` : Met à jour la reformulation (`reframed`). Toute tentative de modifier le texte brut original (`text` ou `texte`) est formellement rejetée (« le texte brut de Nabil est intouchable, utiliser idee_recadrer »). +5. `idee_statut(id, statut)` : Modifie le statut (`nouvelle`, `a_creuser`, `en_cours`, `abandonnee`). +6. `idee_etiqueter(id, etiquettes)` : Met à jour les étiquettes (maximum 8 étiquettes de 40 caractères). + +## Règles Dures Imposées + +- **Texte brut intouchable** : Aucun outil ne peut modifier le champ `text` d'une idée créée. +- **Cloisonnement strict** : Tout accès à un identifiant appartenant à l'espace `taches` est rejeté. +- **Aucune suppression** : Aucun outil de suppression n'est exposé. diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..3380658 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,23 @@ +services: + taf-mcp: + build: . + image: taf-mcp:latest + container_name: taf-mcp + restart: unless-stopped + ports: + - "127.0.0.1:3105:8000" + - "100.94.90.119:3105:8000" + env_file: + - .env + networks: + - mcp-vps + healthcheck: + test: ["CMD-SHELL", "curl -f http://127.0.0.1:8000/health || exit 1"] + interval: 10s + timeout: 5s + retries: 3 + start_period: 5s + +networks: + mcp-vps: + external: true diff --git a/main.py b/main.py new file mode 100644 index 0000000..4445914 --- /dev/null +++ b/main.py @@ -0,0 +1,231 @@ +# -*- 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) diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..b8d01f2 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +starlette==0.37.2 +uvicorn==0.29.0 +requests==2.32.3 +mcp>=1.2.0,<2.0.0 +pytest==8.3.3 +httpx==0.27.2 diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_server.py b/tests/test_server.py new file mode 100644 index 0000000..683cb4f --- /dev/null +++ b/tests/test_server.py @@ -0,0 +1,115 @@ +# -*- coding: utf-8 -*- +"""Tests unitaires et d'intégration pour le serveur MCP taf-mcp.""" +import os +import json +import pytest +from starlette.testclient import TestClient + +# Mock environnement de test si absent +if "TAF_MCP_TOKEN_OPENCLAW_PERSO" not in os.environ: + os.environ["TAF_MCP_TOKEN_OPENCLAW_PERSO"] = "test_token_openclaw_perso_123456789" +if "TAF_TOKEN" not in os.environ: + os.environ["TAF_TOKEN"] = "mock_taf_token" + +from main import app, mcp + +TEST_TOKEN = os.environ["TAF_MCP_TOKEN_OPENCLAW_PERSO"] +AUTH_HEADERS = { + "Authorization": f"Bearer {TEST_TOKEN}", + "Accept": "application/json, text/event-stream" +} + +EXPECTED_TOOLS = { + "idee_ajouter", + "idees_lister", + "idee_rechercher", + "idee_recadrer", + "idee_statut", + "idee_etiqueter", +} + +def test_health(): + with TestClient(app) as client: + r = client.get("/health") + assert r.status_code == 200 + data = r.json() + assert data.get("status") == "ok" + assert data.get("service") == "taf-mcp" + assert data.get("tools") == 6 + +def test_auth_rejection(): + with TestClient(app) as client: + # Sans header auth + r1 = client.post("/mcp", headers={"Accept": "application/json, text/event-stream"}, json={"jsonrpc": "2.0", "id": 1, "method": "tools/list"}) + assert r1.status_code == 401 + + # Mauvais token + r2 = client.post("/mcp", headers={"Authorization": "Bearer faux-jeton", "Accept": "application/json, text/event-stream"}, json={"jsonrpc": "2.0", "id": 1, "method": "tools/list"}) + assert r2.status_code == 401 + +def test_mcp_session_and_tools_list(): + with TestClient(app) as client: + # Initialize + r_init = client.post( + "/mcp", + headers=AUTH_HEADERS, + json={ + "jsonrpc": "2.0", + "id": 1, + "method": "initialize", + "params": { + "protocolVersion": "2025-03-26", + "capabilities": {}, + "clientInfo": {"name": "test-client", "version": "1.0"} + } + } + ) + assert r_init.status_code == 200 + sid = r_init.headers.get("mcp-session-id") + assert sid is not None and len(sid) > 0 + + # Initialized notification + headers_sid = {**AUTH_HEADERS, "mcp-session-id": sid} + r_notif = client.post( + "/mcp", + headers=headers_sid, + json={"jsonrpc": "2.0", "method": "notifications/initialized"} + ) + assert r_notif.status_code in (200, 202) + + # Tools list + r_tools = client.post( + "/mcp", + headers=headers_sid, + json={"jsonrpc": "2.0", "id": 2, "method": "tools/list"} + ) + assert r_tools.status_code == 200 + data = r_tools.json() + tools = data.get("result", {}).get("tools", []) + tool_names = {t["name"] for t in tools} + assert tool_names == EXPECTED_TOOLS + +def test_rule_a_text_intouchable(): + from main import idee_recadrer, idee_statut, idee_etiqueter + + with pytest.raises(ValueError, match="le texte brut de Nabil est intouchable, utiliser idee_recadrer"): + idee_recadrer(id="123", reformulation="reformule", text="nouveau") + + with pytest.raises(ValueError, match="le texte brut de Nabil est intouchable, utiliser idee_recadrer"): + idee_recadrer(id="123", reformulation="reformule", texte="nouveau") + + with pytest.raises(ValueError, match="le texte brut de Nabil est intouchable, utiliser idee_recadrer"): + idee_statut(id="123", statut="en_cours", text="nouveau") + + with pytest.raises(ValueError, match="le texte brut de Nabil est intouchable, utiliser idee_recadrer"): + idee_etiqueter(id="123", etiquettes=["test"], texte="nouveau") + +def test_rule_b_taches_refused(monkeypatch): + import main + # Mock get_all_tasks renvoyant une tâche de l'espace 'taches' + monkeypatch.setattr(main, "get_all_tasks", lambda: [ + {"id": "task-taches-1", "text": "Faire les courses", "space": "taches", "deleted": False} + ]) + + with pytest.raises(ValueError, match="appartient à l'espace taches"): + main.check_idea_access("task-taches-1")