feat(mcp): initialisation serveur MCP taf-mcp espace Idees (perso-2026-10-218)

This commit is contained in:
bolbol committed 2026-10-28 08:09:40 +00:00
commit c3c9b0f06e
8 files changed
+423

No files matched your search

+5
View File
@@ -0,0 +1,5 @@
.env
__pycache__/
*.py[cod]
*$py.class
.pytest_cache/
+13
View File
@@ -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"]
+30
View File
@@ -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é.
+23
View File
@@ -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
+231
View File
@@ -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)
+6
View File
@@ -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
View File
Whitespace-only changes.
+115
View File
@@ -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")