fix

server.py

@@ -1,343 +1,90 @@
-from fastapi import FastAPI, Request, HTTPException
-from authlib.integrations.starlette_client import OAuth
-from starlette.middleware.sessions import SessionMiddleware
 import os
-from typing import Dict, List
-from dotenv import load_dotenv
-from datetime import datetime
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from starlette.middleware.sessions import SessionMiddleware
+from authlib.integrations.starlette_client import OAuth
 
-load_dotenv()
+from math_server import mcp as math_mcp
 
-# --- Vérification variables d'environnement ---
-required_env_vars = ["CLIENT_ID", "CLIENT_SECRET"]
-missing_vars = [v for v in required_env_vars if not os.getenv(v)]
-if missing_vars:
-    raise ValueError(f"Variables d'environnement manquantes: {', '.join(missing_vars)}")
+# -------------------------------
+# Directories
+# -------------------------------
+BASE_DIR = os.path.dirname(__file__)
+STATIC_DIR = os.path.join(BASE_DIR, "static")
+TEMPLATES_DIR = os.path.join(BASE_DIR, "templates")
 
-app = FastAPI(title="MCP IA Twitter Connector")
-app.add_middleware(SessionMiddleware, secret_key="SESSION_SECRET_KEY")
+# -------------------------------
+# App FastAPI
+# -------------------------------
+app = FastAPI()
+
+# Session middleware nécessaire pour OAuth
+app.add_middleware(SessionMiddleware, secret_key=os.environ.get("SESSION_SECRET", "UN_SECRET_123"))
 
-# --- OAuth Twitter ---
+# Static files
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+templates = Jinja2Templates(directory=TEMPLATES_DIR)
+
+# -------------------------------
+# Twitter OAuth configuration
+# -------------------------------
 oauth = OAuth()
 oauth.register(
     name="twitter",
-    client_id=os.getenv("CLIENT_ID"),
-    client_secret=os.getenv("CLIENT_SECRET"),
-    authorize_url="https://twitter.com/i/oauth2/authorize",
+    client_id=os.environ.get("TWITTER_CLIENT_ID"),
+    client_secret=os.environ.get("TWITTER_CLIENT_SECRET"),
+    request_token_url=None,
     access_token_url="https://api.twitter.com/2/oauth2/token",
-    client_kwargs={
-        "scope": "tweet.read tweet.write users.read offline.access",
-        "token_endpoint_auth_method": "client_secret_post"
-    }
+    authorize_url="https://twitter.com/i/oauth2/authorize",
+    client_kwargs={"scope": "tweet.read users.read offline.access"},
 )
 
-# --- MCP simple ---
-mcp_tools_available = True
-
-async def hello() -> str:
-    return "Hello depuis MCP IA 🎉"
-
-async def echo_message(message: str) -> Dict[str, str]:
-    return {"status": "success", "echoed_message": message, "timestamp": datetime.now().isoformat()}
-
-async def post_tweet(message: str, token: Dict) -> Dict[str, str]:
-    """Poste un tweet via Twitter API v2"""
-    import httpx
-    url = "https://api.twitter.com/2/tweets"
-    headers = {"Authorization": f"Bearer {token['access_token']}"}
-    json_data = {"text": message}
-    async with httpx.AsyncClient() as client:
-        resp = await client.post(url, headers=headers, json=json_data)
-    if resp.status_code != 201:
-        return {"error": resp.text}
-    return resp.json()
-
-async def get_my_tweets(token: Dict, max_results: int = 5) -> List[Dict]:
-    """Récupère les derniers tweets de l’utilisateur connecté"""
-    import httpx
-    url = "https://api.twitter.com/2/users/me"
-    headers = {"Authorization": f"Bearer {token['access_token']}"}
-    async with httpx.AsyncClient() as client:
-        user_resp = await client.get(url, headers=headers)
-        if user_resp.status_code != 200:
-            raise HTTPException(status_code=400, detail="Impossible de récupérer l'utilisateur")
-        user_id = user_resp.json()["data"]["id"]
-        tweets_resp = await client.get(f"https://api.twitter.com/2/users/{user_id}/tweets?max_results={max_results}", headers=headers)
-        if tweets_resp.status_code != 200:
-            raise HTTPException(status_code=400, detail="Impossible de récupérer les tweets")
-        return tweets_resp.json().get("data", [])
+# -------------------------------
+# Endpoint racine
+# -------------------------------
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    space_host = os.environ.get("SPACE_HOST")
+    if space_host and space_host.strip():
+        base_url = space_host.strip().rstrip("/")
+    else:
+        base_url = f"{request.url.scheme}://{request.url.netloc}"
+    
+    user = request.session.get("user")
+    return templates.TemplateResponse("index.html", {"request": request, "base_url": base_url, "user": user})
 
-# --- Routes OAuth Twitter ---
-@app.get("/login")
+# -------------------------------
+# Twitter OAuth endpoints
+# -------------------------------
+@app.get("/auth/twitter/login")
 async def login(request: Request):
     redirect_uri = request.url_for("auth_callback")
     return await oauth.twitter.authorize_redirect(request, redirect_uri)
 
-@app.get("/callback")
+@app.get("/auth/twitter/callback")
 async def auth_callback(request: Request):
     token = await oauth.twitter.authorize_access_token(request)
-    request.session["token"] = token
-    request.session["authenticated"] = True
-    return {"message": "Authentifié sur Twitter avec succès"}
+    user_info = await oauth.twitter.parse_id_token(request, token)
+    request.session["user"] = {"id": user_info.get("sub"), "username": user_info.get("name")}
+    return RedirectResponse(url="/")
 
-@app.get("/logout")
+@app.get("/auth/logout")
 async def logout(request: Request):
-    request.session.clear()
-    return {"message": "Déconnecté"}
-
-# --- MCP route POST pour le modèle IA ---
-@app.post("/mcp/api/call")
-async def mcp_call(request: Request):
-    if not request.session.get("authenticated"):
-        raise HTTPException(status_code=401, detail="Authentification requise")
-    
-    body = await request.json()
-    tool = body.get("tool")
-    params = body.get("params", {})
-    token = request.session.get("token")
-
-    if tool == "hello":
-        return {"result": await hello()}
-    elif tool == "echo_message":
-        msg = params.get("message", "")
-        return {"result": await echo_message(msg)}
-    elif tool == "post_tweet":
-        msg = params.get("message", "")
-        return {"result": await post_tweet(msg, token)}
-    elif tool == "get_my_tweets":
-        max_res = params.get("max_results", 5)
-        return {"result": await get_my_tweets(token, max_res)}
-    else:
-        raise HTTPException(status_code=400, detail=f"Outil inconnu: {tool}")
-
-# --- Health check ---
-@app.get("/health")
-async def health():
-    return {"status": "ok", "mcp_tools_available": mcp_tools_available}
-from fastapi import FastAPI, Request, HTTPException
-from authlib.integrations.starlette_client import OAuth
-from starlette.middleware.sessions import SessionMiddleware
-import os
-from typing import Dict
-from dotenv import load_dotenv
-from datetime import datetime
-
-load_dotenv()
-
-# Validation des variables d'environnement
-required_env_vars = ["CLIENT_ID", "CLIENT_SECRET"]
-missing_vars = [var for var in required_env_vars if not os.getenv(var)]
-if missing_vars:
-    raise ValueError(f"Variables d'environnement manquantes: {', '.join(missing_vars)}")
-
-app = FastAPI()
-
-# --- Config OAuth Twitter ---
-oauth = OAuth()
-oauth.register(
-    name='twitter',
-    client_id=os.getenv("CLIENT_ID"),
-    client_secret=os.getenv("CLIENT_SECRET"),
-    authorize_url="https://twitter.com/i/oauth2/authorize",
-    access_token_url="https://api.twitter.com/2/oauth2/token",
-    client_kwargs={
-        "scope": "tweet.read users.read offline.access",
-        "token_endpoint_auth_method": "client_secret_post"
-    }
-)
-
-# --- FastMCP simple ---
-mcp_available = False
-try:
-    from fastmcp import FastMCP
-
-    mcp = FastMCP(name="TwitterMCP")
-
-    @mcp.tool()
-    async def hello() -> str:
-        """Fonction de test MCP"""
-        return "Hello depuis FastMCP 🎉"
-
-    @mcp.tool()
-    async def echo_message(message: str) -> Dict[str, str]:
-        """Répète un message avec timestamp"""
-        return {
-            "status": "success",
-            "echoed_message": message,
-            "timestamp": datetime.now().isoformat()
-        }
-
-    @mcp.tool()
-    async def get_server_info() -> Dict[str, str]:
-        """Retourne des infos sur le serveur MCP"""
-        return {
-            "server": "TwitterMCP",
-            "version": "1.0.0",
-            "status": "running"
-        }
-
-    mcp_available = True
-    print("FastMCP disponible et configuré")
-
-except ImportError:
-    print("FastMCP non disponible, utilisation d'une implémentation basique")
-    mcp = None
-
-# --- Routes OAuth ---
-@app.get("/login")
-async def login(request: Request):
-    """Initie le processus d'authentification Twitter"""
-    try:
-        redirect_uri = request.url_for("auth_callback")
-        return await oauth.twitter.authorize_redirect(request, redirect_uri)
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erreur OAuth: {str(e)}")
-
-@app.get("/callback")
-async def auth_callback(request: Request) -> Dict[str, str]:
-    """Gère le callback OAuth et stocke les infos utilisateur"""
-    try:
-        token = await oauth.twitter.authorize_access_token(request)
-        user_req = await oauth.twitter.get(
-            "https://api.twitter.com/2/users/me",
-            token=token
-        )
-        if user_req.status_code != 200:
-            raise HTTPException(status_code=400, detail="Impossible de récupérer les infos utilisateur")
-        userinfo = user_req.json().get('data', {})
-        if not userinfo:
-            raise HTTPException(status_code=400, detail="Données utilisateur invalides")
-
-        request.session['user'] = userinfo
-        request.session['token'] = token
-        request.session['authenticated'] = True
-
-        return {"message": f"Connecté en tant que @{userinfo.get('username', 'utilisateur')}"}
-
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erreur lors de l'authentification: {str(e)}")
-
-@app.get("/logout")
-async def logout(request: Request):
-    """Déconnecte l'utilisateur"""
-    request.session.clear()
-    return {"message": "Déconnecté avec succès"}
-
-@app.get("/profile")
-async def get_profile(request: Request):
-    """Retourne le profil de l'utilisateur connecté"""
-    if not request.session.get('authenticated'):
-        raise HTTPException(status_code=401, detail="Non authentifié")
-    return {"user": request.session.get('user')}
-
-# --- Routes MCP ---
-@app.get("/mcp/status")
-async def mcp_status(request: Request):
-    """Statut du serveur MCP (nécessite authentification)"""
-    if not request.session.get('authenticated'):
-        raise HTTPException(status_code=401, detail="Authentification requise. Connectez-vous d'abord via /login")
-
-    user = request.session.get('user', {})
-    return {
-        "mcp_server": "TwitterMCP",
-        "status": "active",
-        "authenticated_user": user.get('username', 'unknown'),
-        "tools_available": ["hello", "echo_message", "get_server_info"],
-        "mcp_available": mcp_available
-    }
-
-@app.post("/mcp/api/call")
-async def mcp_call(request: Request):
-    """Appel des outils MCP"""
-    if not request.session.get('authenticated'):
-        raise HTTPException(status_code=401, detail="Authentification requise")
-    
-    if not mcp_available:
-        return {
-            "error": "FastMCP non disponible",
-            "available_tools": ["echo_message"],
-            "note": "Implémentation basique"
-        }
-    
-    try:
-        body = await request.json()
-        tool_name = body.get("tool")
-        params = body.get("params", {})
-        
-        if tool_name == "hello":
-            result = await hello()
-        elif tool_name == "echo_message":
-            message = params.get("message", "")
-            result = await echo_message(message)
-        elif tool_name == "get_server_info":
-            result = await get_server_info()
-        else:
-            raise HTTPException(status_code=400, detail=f"Outil inconnu: {tool_name}")
-        
-        return {"result": result}
-    
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Erreur lors de l'appel MCP: {str(e)}")
-
-# --- Routes MCP alternatives si FastMCP disponible ---
-if mcp_available and hasattr(mcp, 'router'):
-    # Si FastMCP a un router, l'utiliser
-    app.include_router(mcp.router, prefix="/mcp/fastapi")
-elif mcp_available:
-    # Si FastMCP est disponible mais sans router, créer des routes manuellement
-    @app.get("/mcp/tools")
-    async def list_mcp_tools(request: Request):
-        """Liste les outils MCP disponibles"""
-        if not request.session.get('authenticated'):
-            raise HTTPException(status_code=401, detail="Authentification requise")
-        
-        return {
-            "tools": [
-                {
-                    "name": "hello",
-                    "description": "Fonction de test MCP",
-                    "parameters": {}
-                },
-                {
-                    "name": "echo_message", 
-                    "description": "Répète un message avec timestamp",
-                    "parameters": {"message": "string"}
-                },
-                {
-                    "name": "get_server_info",
-                    "description": "Retourne des infos sur le serveur MCP", 
-                    "parameters": {}
-                }
-            ]
-        }
-
-# --- Route d'information ---
-@app.get("/")
-async def root():
-    return {
-        "message": "Serveur FastAPI + OAuth Twitter + MCP",
-        "authentication": "Visitez /login pour vous authentifier",
-        "profile": "Visitez /profile après authentification",
-        "mcp_status": "Visitez /mcp/status après authentification",
-        "mcp_api": "Utilisez /mcp/api/call pour appeler les outils MCP",
-        "health": "Visitez /health pour le statut du serveur",
-        "mcp_available": mcp_available
-    }
+    request.session.pop("user", None)
+    return RedirectResponse(url="/")
 
-# --- Route de santé ---
-@app.get("/health")
-async def health_check():
-    return {
-        "status": "ok", 
-        "message": "Service opérationnel",
-        "mcp_available": mcp_available
-    }
+# -------------------------------
+# Endpoint MCP math
+# -------------------------------
+app.mount("/math", math_mcp.http_app())  # juste le HTTP app, pas besoin de run()
 
+# -------------------------------
+# Lancer le serveur
+# -------------------------------
 PORT = int(os.environ.get("PORT", "10000"))
 
-# --- Lancement serveur ---
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=PORT)
+    uvicorn.run(app, host="0.0.0.0", port=PORT)