🚀 Serveur MCP Figma avec API REST - Version finale avec vraie intégration Figma

README.md

@@ -9,56 +9,178 @@ app_file: app.py
 pinned: false
 ---
 
-# 🎨 Sigma - Serveur MCP Figma
+# 🎨 Figma MCP Server
 
-Serveur MCP (Model Context Protocol) pour contrôler Figma via Claude/Cursor.
+**Serveur MCP pour contrôler Figma via Claude/Cursor avec l'API REST officielle**
 
-## 🔗 Utilisation
+## 🚀 Fonctionnalités
 
-**URL du serveur MCP:** `https://aktraiser-sigma.hf.space/gradio_api/mcp/sse`
+- ✅ **Authentification Figma** avec Personal Access Token
+- ✅ **Vraie API REST Figma** pour toutes les opérations
+- ✅ **Serveur MCP** compatible Claude Desktop et Cursor
+- ✅ **Hébergé sur HF Spaces** - pas d'installation locale
+- ✅ **Interface de test** intégrée
 
-### Configuration Claude Desktop
+## 🏗️ Architecture
+
+```
+Claude/Cursor ←→ MCP (SSE) ←→ Gradio Server ←→ API REST Figma
+             https://...sse           HF Spaces        api.figma.com
+```
+
+## 🔧 Configuration
+
+### 1. **Obtenir un Personal Access Token Figma**
+
+1. Aller sur [Figma Settings > Personal Access Tokens](https://www.figma.com/settings)
+2. Cliquer sur "Generate new token"
+3. Donner un nom à votre token
+4. Copier le token (commence par `figd_` ou `figc_`)
+
+### 2. **Obtenir l'ID de votre fichier Figma**
+
+1. Ouvrir votre fichier Figma dans le navigateur
+2. Copier l'ID depuis l'URL : `https://www.figma.com/file/FILE_ID/nom-du-fichier`
+3. L'ID est la partie entre `/file/` et `/`
+
+### 3. **Configurer Claude Desktop**
+
+Ajouter dans `claude_desktop_config.json` :
 
 ```json
 {
   "mcpServers": {
     "figma": {
-      "command": "npx",
-      "args": [
-        "mcp-remote",
-        "https://aktraiser-sigma.hf.space/gradio_api/mcp/sse"
-      ]
+      "command": "sse",
+      "args": ["https://aktraiser-sigma.hf.space/gradio_api/mcp/sse"]
     }
   }
 }
 ```
 
-### Configuration Cursor
+### 4. **Configurer Cursor**
+
+Ajouter dans `.cursorrules` ou les paramètres MCP :
 
 ```json
 {
-  "mcpServers": {
-    "figma": {
-      "transport": "sse",
-      "url": "https://aktraiser-sigma.hf.space/gradio_api/mcp/sse"
-    }
+  "mcp": {
+    "figma": "https://aktraiser-sigma.hf.space/gradio_api/mcp/sse"
   }
 }
 ```
 
-## 🛠️ Outils disponibles
+## 🛠️ Outils MCP disponibles
 
-- `join_figma_channel` - Rejoindre un canal Figma
-- `get_figma_document_info` - Infos du document
-- `create_figma_rectangle/frame/text` - Création d'éléments
-- `set_figma_fill_color` - Couleurs
-- `move_figma_node` / `resize_figma_node` - Modifications
-- `delete_figma_node` - Suppression
+### Configuration
+- `configure_figma_token(token)` - Configure le token d'accès Figma
+- `configure_figma_file_id(file_id)` - Configure l'ID du fichier à utiliser
 
-## 🏗️ Architecture
+### Informations
+- `get_figma_file_info(file_id?)` - Récupère les infos d'un fichier
+- `get_figma_user_info()` - Info de l'utilisateur connecté
+- `get_figma_comments(file_id?)` - Liste les commentaires
+
+### Création d'éléments (via commentaires)
+- `create_figma_rectangle(x, y, width, height, name?, color?)` - Crée un rectangle
+- `create_figma_frame(x, y, width, height, name?)` - Crée un frame
+- `create_figma_text(x, y, text, name?, font_size?)` - Crée un texte
+
+### Projets et équipes
+- `list_figma_team_projects(team_id?)` - Liste les projets d'une équipe
+
+## 📝 Utilisation
+
+### Exemple avec Claude
 
 ```
-Claude/Cursor ←→ MCP ←→ Gradio Server ←→ WebSocket ←→ Plugin Figma
+User: Configure mon token Figma et commence à créer un design
+
+Claude: Je vais d'abord configurer votre token Figma. Pouvez-vous me donner votre Personal Access Token ?
+
+[Après avoir reçu le token]
+
+configure_figma_token("figd_your_token_here")
+
+Maintenant, donnez-moi l'ID de votre fichier Figma...
+
+configure_figma_file_id("YOUR_FILE_ID")
+
+Parfait ! Je peux maintenant créer des éléments. Créons un rectangle rouge :
+
+create_figma_rectangle("100", "100", "200", "150", "Mon Rectangle", "#FF0000")
 ```
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 🧪 Interface de test
+
+L'application inclut une interface de test accessible sur :
+https://aktraiser-sigma.hf.space
+
+Cette interface permet de :
+- Tester la configuration du token
+- Vérifier l'accès aux fichiers
+- Afficher les informations du fichier
+- Lister les commentaires
+
+## ⚠️ Limitations actuelles
+
+### Création d'éléments
+Pour l'instant, la création d'éléments (rectangles, frames, texte) se fait via **commentaires** car l'API REST Figma ne permet pas de créer directement des nœuds. Les commentaires apparaîtront dans votre fichier Figma avec les instructions de création.
+
+### Permissions
+- Vous devez avoir accès en écriture au fichier
+- Le token doit avoir les bonnes permissions (défini lors de la création)
+
+## 🔄 Fonctionnement
+
+1. **Claude/Cursor** appelle les outils MCP
+2. **Serveur MCP** reçoit la requête via SSE
+3. **Gradio** traite la requête et appelle l'**API REST Figma**
+4. **Figma** renvoie la réponse
+5. **Serveur MCP** retourne le résultat à **Claude/Cursor**
+
+## 🚀 Déploiement
+
+Le serveur est automatiquement déployé sur Hugging Face Spaces :
+- **URL MCP :** `https://aktraiser-sigma.hf.space/gradio_api/mcp/sse`
+- **Interface web :** `https://aktraiser-sigma.hf.space`
+
+## 🔒 Sécurité
+
+- Les tokens ne sont **jamais stockés** de façon persistante
+- Ils ne sont conservés qu'en mémoire pendant la session
+- Utilisez toujours des tokens avec des permissions limitées
+
+## 📚 API Figma
+
+Documentation officielle : https://www.figma.com/developers/api
+
+## 🐛 Dépannage
+
+### Erreurs courantes
+
+**Token invalide**
+```
+❌ Token invalide. Le token doit commencer par 'figd_' ou 'figc_'
+```
+→ Vérifiez que votre token est correct
+
+**Fichier inaccessible**
+```
+❌ Impossible d'accéder au fichier : 403
+```
+→ Vérifiez que vous avez les permissions sur le fichier
+
+**Token non configuré**
+```
+❌ Token Figma non configuré
+```
+→ Appelez `configure_figma_token()` d'abord
+
+## 🤝 Contribution
+
+Ce projet est open source ! N'hésitez pas à contribuer.
+
+## 📄 Licence
+
+MIT License

app.py

@@ -1,13 +1,13 @@
 #!/usr/bin/env python3
 """
 🎨 Figma MCP Server - Hébergé sur Hugging Face Spaces
-Serveur MCP pour contrôler Figma via Claude/Cursor
+Serveur MCP pour contrôler Figma via Claude/Cursor avec la vraie API REST
 """
 import gradio as gr
 import asyncio
 import json
-import uuid
 import logging
+import requests
 from typing import Dict, Any, Optional, List
 from PIL import Image
 import base64
@@ -17,389 +17,394 @@ import io
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Variables globales pour stocker les connexions
-connected_clients: List[Dict[str, Any]] = []
-channels: Dict[str, List[str]] = {}
+# Configuration Figma API
+FIGMA_API_BASE = "https://api.figma.com/v1"
 
-# === COMMUNICATION AVEC LE PLUGIN FIGMA VIA GRADIO ===
+# === CONFIGURATION ET ÉTAT ===
 
-def handle_plugin_connection(channel_name: str, action: str = "join") -> str:
-    """Gère la connexion du plugin Figma"""
-    global connected_clients, channels
-    
-    if action == "join":
-        # Ajouter le client
-        client_info = {
-            "id": str(uuid.uuid4()),
-            "channel": channel_name,
-            "connected_at": str(asyncio.get_event_loop().time()) if asyncio.get_event_loop().is_running() else "0"
-        }
-        connected_clients.append(client_info)
-        
-        # Ajouter au canal
-        if channel_name not in channels:
-            channels[channel_name] = []
-        channels[channel_name].append(client_info["id"])
-        
-        logger.info(f"Plugin rejoint le canal {channel_name}")
-        return json.dumps({
-            "type": "system",
-            "channel": channel_name,
-            "message": {
-                "result": f"Joined channel {channel_name}",
-                "channel": channel_name
-            }
-        })
+# Variables globales pour stocker la configuration
+figma_config = {
+    "token": None,
+    "file_id": None,
+    "team_id": None
+}
+
+def configure_figma_token(token: str) -> str:
+    """Configure le token d'accès Figma"""
+    global figma_config
     
-    elif action == "disconnect":
-        # Retirer le client
-        connected_clients[:] = [c for c in connected_clients if c.get("channel") != channel_name]
-        if channel_name in channels:
-            del channels[channel_name]
-        
-        return json.dumps({
-            "type": "system",
-            "message": {"result": f"Disconnected from channel {channel_name}"}
-        })
+    if not token or not token.startswith(('figd_', 'figc_')):
+        return "❌ Token invalide. Le token doit commencer par 'figd_' ou 'figc_'"
     
-    return json.dumps({"type": "error", "message": "Action non reconnue"})
-
-def execute_figma_command_bridge(command: str, params_json: str) -> str:
-    """Pont entre les outils MCP et les commandes Figma"""
+    figma_config["token"] = token
+    
+    # Test de connexion
     try:
-        params = json.loads(params_json) if params_json else {}
+        headers = {"X-Figma-Token": token}
+        response = requests.get(f"{FIGMA_API_BASE}/me", headers=headers, timeout=10)
         
-        if command == "get_document_info":
-            return json.dumps({"type": "result", "data": {"message": "Document info récupéré", "command": command}})
-        elif command == "get_selection":
-            return json.dumps({"type": "result", "data": {"message": "Sélection récupérée", "command": command}})
-        elif command == "create_rectangle":
-            return json.dumps({"type": "result", "data": {"message": "Rectangle créé", "params": params}})
-        elif command == "create_frame":
-            return json.dumps({"type": "result", "data": {"message": "Frame créé", "params": params}})
-        elif command == "create_text":
-            return json.dumps({"type": "result", "data": {"message": "Texte créé", "params": params}})
-        elif command == "set_fill_color":
-            return json.dumps({"type": "result", "data": {"message": "Couleur définie", "params": params}})
+        if response.status_code == 200:
+            user_data = response.json()
+            username = user_data.get("handle", "Utilisateur inconnu")
+            return f"✅ Token configuré avec succès ! Connecté en tant que : {username}"
         else:
-            return json.dumps({"type": "error", "message": f"Commande inconnue: {command}"})
+            return f"❌ Erreur lors de la vérification du token : {response.status_code}"
             
     except Exception as e:
-        return json.dumps({"type": "error", "message": str(e)})
-
-# === OUTILS MCP POUR FIGMA ===
+        return f"❌ Erreur de connexion à l'API Figma : {str(e)}"
 
-def join_figma_channel(channel: str) -> str:
-    """
-    Rejoint un canal Figma pour commencer à communiquer.
+def configure_figma_file_id(file_id: str) -> str:
+    """Configure l'ID du fichier Figma à utiliser"""
+    global figma_config
     
-    Args:
-        channel (str): Nom du canal Figma à rejoindre
-        
-    Returns:
-        str: Message de confirmation ou d'erreur
-    """
-    result = handle_plugin_connection(channel, "join")
-    return f"✅ Canal Figma configuré: {channel}\n📡 Plugin peut se connecter sur: https://aktraiser-sigma.hf.space"
-
-def get_figma_document_info() -> str:
-    """
-    Récupère les informations détaillées du document Figma actuel.
-    
-    Returns:
-        str: Informations du document en format JSON
-    """
-    result = execute_figma_command_bridge("get_document_info", "{}")
-    return f"📄 Commande get_document_info envoyée au plugin Figma\n{result}"
+    if not file_id:
+        return "❌ L'ID du fichier est requis"
+    
+    figma_config["file_id"] = file_id
+    
+    # Test d'accès au fichier
+    if figma_config["token"]:
+        try:
+            headers = {"X-Figma-Token": figma_config["token"]}
+            response = requests.get(f"{FIGMA_API_BASE}/files/{file_id}", headers=headers, timeout=10)
+            
+            if response.status_code == 200:
+                file_data = response.json()
+                file_name = file_data.get("name", "Fichier inconnu")
+                return f"✅ Fichier configuré avec succès : {file_name}"
+            else:
+                return f"❌ Impossible d'accéder au fichier : {response.status_code}"
+                
+        except Exception as e:
+            return f"❌ Erreur lors de l'accès au fichier : {str(e)}"
+    else:
+        return "⚠️ ID du fichier configuré, mais token manquant"
 
-def get_figma_selection() -> str:
-    """
-    Récupère les informations sur la sélection actuelle dans Figma.
-    
-    Returns:
-        str: Informations de la sélection en format JSON
-    """
-    result = execute_figma_command_bridge("get_selection", "{}")
-    return f"🎯 Commande get_selection envoyée au plugin Figma\n{result}"
+# === FONCTIONS API FIGMA ===
 
-def get_figma_node_info(node_id: str) -> str:
-    """
-    Récupère les informations détaillées d'un nœud spécifique dans Figma.
+def make_figma_request(endpoint: str, method: str = "GET", data: Dict = None) -> Dict[str, Any]:
+    """Effectue une requête à l'API Figma"""
+    if not figma_config["token"]:
+        return {"error": "Token Figma non configuré"}
     
-    Args:
-        node_id (str): ID du nœud Figma à analyser
-        
-    Returns:
-        str: Informations du nœud en format JSON
-    """
-    params = json.dumps({"nodeId": node_id})
-    result = execute_figma_command_bridge("get_node_info", params)
-    return f"🔍 Commande get_node_info pour {node_id} envoyée au plugin Figma\n{result}"
-
-def create_figma_rectangle(x: str, y: str, width: str, height: str, name: str = "Rectangle", parent_id: str = "") -> str:
-    """
-    Crée un nouveau rectangle dans Figma.
-    
-    Args:
-        x (str): Position X du rectangle
-        y (str): Position Y du rectangle  
-        width (str): Largeur du rectangle
-        height (str): Hauteur du rectangle
-        name (str): Nom optionnel du rectangle
-        parent_id (str): ID du nœud parent (optionnel)
-        
-    Returns:
-        str: Informations du rectangle créé
-    """
-    params = {
-        "x": float(x),
-        "y": float(y), 
-        "width": float(width),
-        "height": float(height),
-        "name": name
+    headers = {
+        "X-Figma-Token": figma_config["token"],
+        "Content-Type": "application/json"
     }
-    if parent_id:
-        params["parentId"] = parent_id
     
-    result = execute_figma_command_bridge("create_rectangle", json.dumps(params))
-    return f"🟦 Rectangle {name} créé ({width}x{height}) à ({x},{y})\n{result}"
-
-def create_figma_frame(x: str, y: str, width: str, height: str, name: str = "Frame", parent_id: str = "") -> str:
-    """
-    Crée un nouveau frame (conteneur) dans Figma.
-    
-    Args:
-        x (str): Position X du frame
-        y (str): Position Y du frame
-        width (str): Largeur du frame
-        height (str): Hauteur du frame
-        name (str): Nom optionnel du frame
-        parent_id (str): ID du nœud parent (optionnel)
-        
-    Returns:
-        str: Informations du frame créé avec son ID
-    """
-    params = {
-        "x": float(x),
-        "y": float(y),
-        "width": float(width), 
-        "height": float(height),
-        "name": name
-    }
-    if parent_id:
-        params["parentId"] = parent_id
+    url = f"{FIGMA_API_BASE}/{endpoint}"
     
-    result = execute_figma_command_bridge("create_frame", json.dumps(params))
-    return f"🖼️ Frame {name} créé ({width}x{height}) à ({x},{y})\n{result}"
-
-def create_figma_text(x: str, y: str, text: str, font_size: str = "14", name: str = "Text", parent_id: str = "") -> str:
-    """
-    Crée un nouvel élément texte dans Figma.
-    
-    Args:
-        x (str): Position X du texte
-        y (str): Position Y du texte
-        text (str): Contenu du texte
-        font_size (str): Taille de la police (défaut: 14)
-        name (str): Nom optionnel de l'élément texte
-        parent_id (str): ID du nœud parent (optionnel)
+    try:
+        if method == "GET":
+            response = requests.get(url, headers=headers, timeout=30)
+        elif method == "POST":
+            response = requests.post(url, headers=headers, json=data, timeout=30)
+        elif method == "PUT":
+            response = requests.put(url, headers=headers, json=data, timeout=30)
+        elif method == "DELETE":
+            response = requests.delete(url, headers=headers, timeout=30)
+        else:
+            return {"error": f"Méthode HTTP non supportée : {method}"}
         
-    Returns:
-        str: Informations du texte créé
-    """
-    params = {
-        "x": float(x),
-        "y": float(y),
-        "text": text,
-        "fontSize": float(font_size),
-        "name": name
+        if response.status_code in [200, 201]:
+            return response.json()
+        else:
+            return {"error": f"Erreur API {response.status_code}: {response.text}"}
+            
+    except Exception as e:
+        return {"error": f"Erreur de requête : {str(e)}"}
+
+# === OUTILS MCP FIGMA ===
+
+def get_figma_file_info(file_id: str = "") -> str:
+    """Récupère les informations d'un fichier Figma"""
+    file_id = file_id or figma_config["file_id"]
+    
+    if not file_id:
+        return "❌ ID du fichier requis. Utilisez configure_figma_file_id() d'abord."
+    
+    result = make_figma_request(f"files/{file_id}")
+    
+    if "error" in result:
+        return f"❌ Erreur : {result['error']}"
+    
+    file_info = {
+        "nom": result.get("name", ""),
+        "derniere_modification": result.get("lastModified", ""),
+        "version": result.get("version", ""),
+        "pages": [page.get("name", "") for page in result.get("document", {}).get("children", [])]
     }
-    if parent_id:
-        params["parentId"] = parent_id
     
-    result = execute_figma_command_bridge("create_text", json.dumps(params))
-    return f"📝 Texte '{text}' créé (taille {font_size}) à ({x},{y})\n{result}"
+    return f"📄 **Fichier Figma :**\n{json.dumps(file_info, indent=2, ensure_ascii=False)}"
 
-def set_figma_fill_color(node_id: str, r: str, g: str, b: str, a: str = "1.0") -> str:
-    """
-    Définit la couleur de remplissage d'un nœud Figma.
-    
-    Args:
-        node_id (str): ID du nœud à modifier
-        r (str): Composant rouge (0-1)
-        g (str): Composant vert (0-1)
-        b (str): Composant bleu (0-1)
-        a (str): Composant alpha/transparence (0-1, défaut: 1.0)
+def create_figma_rectangle(x: str, y: str, width: str, height: str, name: str = "Rectangle", color: str = "#FF0000") -> str:
+    """Crée un rectangle dans Figma (via commentaire pour notification)"""
+    if not figma_config["file_id"]:
+        return "❌ ID du fichier requis. Utilisez configure_figma_file_id() d'abord."
+    
+    try:
+        x_pos, y_pos = float(x), float(y)
+        w, h = float(width), float(height)
+        
+        # Créer un commentaire avec les instructions de création
+        comment_text = f"🟦 **Rectangle à créer :**\n- Nom: {name}\n- Position: ({x_pos}, {y_pos})\n- Taille: {w}x{h}\n- Couleur: {color}"
         
-    Returns:
-        str: Confirmation de la modification
-    """
-    params = {
-        "nodeId": node_id,
-        "color": {
-            "r": float(r),
-            "g": float(g), 
-            "b": float(b),
-            "a": float(a)
+        comment_data = {
+            "message": comment_text,
+            "client_meta": {
+                "x": x_pos,
+                "y": y_pos
+            }
         }
-    }
-    result = execute_figma_command_bridge("set_fill_color", json.dumps(params))
-    return f"🎨 Couleur RGBA({r},{g},{b},{a}) appliquée au nœud {node_id}\n{result}"
-
-def move_figma_node(node_id: str, x: str, y: str) -> str:
-    """
-    Déplace un nœud Figma vers une nouvelle position.
-    
-    Args:
-        node_id (str): ID du nœud à déplacer
-        x (str): Nouvelle position X
-        y (str): Nouvelle position Y
         
-    Returns:
-        str: Confirmation du déplacement
-    """
-    params = {
-        "nodeId": node_id,
-        "x": float(x),
-        "y": float(y)
-    }
-    result = execute_figma_command_bridge("move_node", json.dumps(params))
-    return f"📐 Nœud {node_id} déplacé vers ({x},{y})\n{result}"
+        result = make_figma_request(f"files/{figma_config['file_id']}/comments", "POST", comment_data)
+        
+        if "error" in result:
+            return f"❌ Erreur lors de la création du commentaire : {result['error']}"
+        
+        return f"✅ Rectangle {name} créé (via commentaire) à ({x_pos}, {y_pos}) avec la taille {w}x{h}"
+        
+    except ValueError:
+        return "❌ Les coordonnées et dimensions doivent être des nombres"
 
-def resize_figma_node(node_id: str, width: str, height: str) -> str:
-    """
-    Redimensionne un nœud Figma.
-    
-    Args:
-        node_id (str): ID du nœud à redimensionner
-        width (str): Nouvelle largeur
-        height (str): Nouvelle hauteur
+def create_figma_frame(x: str, y: str, width: str, height: str, name: str = "Frame") -> str:
+    """Crée un frame dans Figma (via commentaire pour notification)"""
+    if not figma_config["file_id"]:
+        return "❌ ID du fichier requis. Utilisez configure_figma_file_id() d'abord."
+    
+    try:
+        x_pos, y_pos = float(x), float(y)
+        w, h = float(width), float(height)
         
-    Returns:
-        str: Confirmation du redimensionnement
-    """
-    params = {
-        "nodeId": node_id,
-        "width": float(width),
-        "height": float(height)
-    }
-    result = execute_figma_command_bridge("resize_node", json.dumps(params))
-    return f"📏 Nœud {node_id} redimensionné à {width}x{height}\n{result}"
+        comment_text = f"🖼️ **Frame à créer :**\n- Nom: {name}\n- Position: ({x_pos}, {y_pos})\n- Taille: {w}x{h}"
+        
+        comment_data = {
+            "message": comment_text,
+            "client_meta": {
+                "x": x_pos,
+                "y": y_pos
+            }
+        }
+        
+        result = make_figma_request(f"files/{figma_config['file_id']}/comments", "POST", comment_data)
+        
+        if "error" in result:
+            return f"❌ Erreur lors de la création du commentaire : {result['error']}"
+        
+        return f"✅ Frame {name} créé (via commentaire) à ({x_pos}, {y_pos}) avec la taille {w}x{h}"
+        
+    except ValueError:
+        return "❌ Les coordonnées et dimensions doivent être des nombres"
 
-def delete_figma_node(node_id: str) -> str:
-    """
-    Supprime un nœud dans Figma.
+def create_figma_text(x: str, y: str, text: str, name: str = "Text", font_size: str = "16") -> str:
+    """Crée un élément texte dans Figma (via commentaire pour notification)"""
+    if not figma_config["file_id"]:
+        return "❌ ID du fichier requis. Utilisez configure_figma_file_id() d'abord."
     
-    Args:
-        node_id (str): ID du nœud à supprimer
+    try:
+        x_pos, y_pos = float(x), float(y)
+        size = float(font_size)
+        
+        comment_text = f"📝 **Texte à créer :**\n- Nom: {name}\n- Position: ({x_pos}, {y_pos})\n- Texte: \"{text}\"\n- Taille: {size}px"
+        
+        comment_data = {
+            "message": comment_text,
+            "client_meta": {
+                "x": x_pos,
+                "y": y_pos
+            }
+        }
+        
+        result = make_figma_request(f"files/{figma_config['file_id']}/comments", "POST", comment_data)
         
-    Returns:
-        str: Confirmation de la suppression
-    """
-    result = execute_figma_command_bridge("delete_node", json.dumps({"nodeId": node_id}))
-    return f"🗑️ Nœud {node_id} supprimé\n{result}"
+        if "error" in result:
+            return f"❌ Erreur lors de la création du commentaire : {result['error']}"
+        
+        return f"✅ Texte \"{text}\" créé (via commentaire) à ({x_pos}, {y_pos})"
+        
+    except ValueError:
+        return "❌ Les coordonnées et la taille doivent être des nombres"
 
-def get_figma_styles() -> str:
-    """
-    Récupère tous les styles du document Figma.
-    
-    Returns:
-        str: Liste des styles en format JSON
-    """
-    result = execute_figma_command_bridge("get_styles", "{}")
-    return f"🎨 Styles du document récupérés\n{result}"
+def get_figma_comments(file_id: str = "") -> str:
+    """Récupère tous les commentaires d'un fichier Figma"""
+    file_id = file_id or figma_config["file_id"]
+    
+    if not file_id:
+        return "❌ ID du fichier requis"
+    
+    result = make_figma_request(f"files/{file_id}/comments")
+    
+    if "error" in result:
+        return f"❌ Erreur : {result['error']}"
+    
+    comments = result.get("comments", [])
+    
+    if not comments:
+        return "📝 Aucun commentaire trouvé dans ce fichier"
+    
+    comment_list = []
+    for comment in comments[:10]:  # Limiter à 10 commentaires
+        user = comment.get("user", {}).get("handle", "Anonyme")
+        message = comment.get("message", "")
+        created_at = comment.get("created_at", "")
+        comment_list.append(f"👤 {user} ({created_at}): {message}")
+    
+    return f"📝 **Commentaires récents :**\n" + "\n\n".join(comment_list)
 
-def get_figma_components() -> str:
-    """
-    Récupère tous les composants locaux du document Figma.
-    
-    Returns:
-        str: Liste des composants en format JSON
-    """
-    result = execute_figma_command_bridge("get_local_components", "{}")
-    return f"🧩 Composants locaux récupérés\n{result}"
+def get_figma_user_info() -> str:
+    """Récupère les informations de l'utilisateur connecté"""
+    result = make_figma_request("me")
+    
+    if "error" in result:
+        return f"❌ Erreur : {result['error']}"
+    
+    user_info = {
+        "nom": result.get("handle", ""),
+        "email": result.get("email", ""),
+        "id": result.get("id", "")
+    }
+    
+    return f"👤 **Utilisateur connecté :**\n{json.dumps(user_info, indent=2, ensure_ascii=False)}"
 
-# === INTERFACE GRADIO ===
+def list_figma_team_projects(team_id: str = "") -> str:
+    """Liste les projets d'une équipe Figma"""
+    team_id = team_id or figma_config["team_id"]
+    
+    if not team_id:
+        return "❌ ID de l'équipe requis. Configurez-le avec figma_config['team_id'] = 'VOTRE_TEAM_ID'"
+    
+    result = make_figma_request(f"teams/{team_id}/projects")
+    
+    if "error" in result:
+        return f"❌ Erreur : {result['error']}"
+    
+    projects = result.get("projects", [])
+    
+    if not projects:
+        return "📁 Aucun projet trouvé dans cette équipe"
+    
+    project_list = []
+    for project in projects[:10]:  # Limiter à 10 projets
+        name = project.get("name", "Sans nom")
+        project_id = project.get("id", "")
+        project_list.append(f"📁 {name} (ID: {project_id})")
+    
+    return f"📁 **Projets de l'équipe :**\n" + "\n".join(project_list)
 
-def health_check() -> str:
-    """
-    Vérifie l'état de santé du serveur MCP Figma.
-    
-    Returns:
-        str: État de la connexion
-    """
-    client_count = len(connected_clients)
-    channel_count = len(channels)
-    return f"✅ Serveur MCP Figma actif\n📱 {client_count} clients connectés\n📡 {channel_count} canaux actifs"
+# === CONFIGURATION DE L'APPLICATION GRADIO ===
 
-# Interface Gradio avec communication plugin
-with gr.Blocks(title="🎨 Figma MCP Server") as demo:
-    gr.Markdown("# 🎨 Serveur MCP Figma")
-    gr.Markdown("Serveur MCP hébergé sur Hugging Face Spaces pour contrôler Figma via Claude/Cursor")
+def setup_demo():
+    """Configure l'interface Gradio pour le serveur MCP"""
     
-    with gr.Row():
-        status_btn = gr.Button("Vérifier l'état", variant="primary")
-        status_output = gr.Textbox(label="État du serveur", interactive=False)
-    
-    with gr.Tab("🔌 Communication Plugin"):
-        gr.Markdown("### Interface de communication avec le plugin Figma")
+    with gr.Blocks(
+        title="🎨 Figma MCP Server",
+        theme=gr.themes.Soft(),
+    ) as demo:
         
-        with gr.Row():
-            channel_input = gr.Textbox(label="Canal", placeholder="nom-du-canal")
-            join_btn = gr.Button("Rejoindre Canal", variant="primary")
-            
-        plugin_output = gr.Textbox(label="Réponse du plugin", interactive=False, lines=3)
+        gr.Markdown("""
+        # 🎨 Figma MCP Server
+        **Serveur MCP pour contrôler Figma via Claude/Cursor avec l'API REST**
+        
+        ## 📋 **Instructions de configuration :**
+        
+        ### 1. **Obtenir un token Figma :**
+        - Aller sur [Figma Settings > Personal Access Tokens](https://www.figma.com/settings)
+        - Créer un nouveau token
+        - Copier le token (commence par `figd_` ou `figc_`)
+        
+        ### 2. **Obtenir l'ID d'un fichier :**
+        - Ouvrir votre fichier Figma
+        - Copier l'ID depuis l'URL : `https://www.figma.com/file/FILE_ID/nom-du-fichier`
         
-        with gr.Row():
-            command_input = gr.Dropdown(
-                choices=["get_document_info", "get_selection", "create_rectangle", "create_frame", "create_text"],
-                label="Commande Test"
+        ### 3. **Configurer Claude/Cursor :**
+        ```json
+        {
+          "mcpServers": {
+            "figma": {
+              "command": "sse",
+              "args": ["https://aktraiser-sigma.hf.space/gradio_api/mcp/sse"]
+            }
+          }
+        }
+        ```
+        """)
+        
+        # Interface de test (optionnelle)
+        with gr.Tab("🧪 Test"):
+            with gr.Row():
+                token_input = gr.Textbox(
+                    placeholder="figd_...",
+                    label="Token Figma",
+                    type="password"
+                )
+                token_btn = gr.Button("Configurer Token")
+            
+            with gr.Row():
+                file_input = gr.Textbox(
+                    placeholder="ID du fichier",
+                    label="ID du fichier Figma"
+                )
+                file_btn = gr.Button("Configurer Fichier")
+            
+            status_output = gr.Textbox(label="Status", lines=3)
+            
+            # Actions de test
+            with gr.Row():
+                test_info_btn = gr.Button("📄 Info Fichier")
+                test_comments_btn = gr.Button("📝 Commentaires")
+                test_user_btn = gr.Button("👤 Info Utilisateur")
+            
+            # Connexions des événements
+            token_btn.click(
+                configure_figma_token,
+                inputs=[token_input],
+                outputs=[status_output]
+            )
+            
+            file_btn.click(
+                configure_figma_file_id,
+                inputs=[file_input],
+                outputs=[status_output]
+            )
+            
+            test_info_btn.click(
+                lambda: get_figma_file_info(),
+                outputs=[status_output]
+            )
+            
+            test_comments_btn.click(
+                lambda: get_figma_comments(),
+                outputs=[status_output]
             )
-            params_input = gr.Textbox(label="Paramètres JSON", placeholder='{"x": 10, "y": 20}')
-            execute_btn = gr.Button("Exécuter Commande")
             
-        command_output = gr.Textbox(label="Résultat commande", interactive=False, lines=3)
-    
-    gr.Markdown("""
-    ## 🔗 Utilisation
-    
-    ### Serveur MCP (Claude/Cursor)
-    **URL:** `https://aktraiser-sigma.hf.space/gradio_api/mcp/sse`
-    
-    ### Plugin Figma
-    Le plugin peut maintenant utiliser cette interface pour communiquer directement !
-    
-    ## 🛠️ Outils MCP disponibles
-    - `join_figma_channel` - Rejoindre un canal Figma
-    - `get_figma_document_info` - Infos du document
-    - `create_figma_rectangle/frame/text` - Création d'éléments
-    - `set_figma_fill_color` - Couleurs
-    - `move_figma_node` / `resize_figma_node` - Modifications
-    - `delete_figma_node` - Suppression
-    
-    ## 🏗️ Architecture Simplifiée
-    ```
-    Claude/Cursor ←→ MCP ←→ Gradio Server ←→ Interface Plugin ←→ Plugin Figma
-    ```
-    """)
-    
-    # Event handlers
-    status_btn.click(health_check, outputs=[status_output])
-    join_btn.click(
-        lambda channel: handle_plugin_connection(channel, "join"),
-        inputs=[channel_input],
-        outputs=[plugin_output]
-    )
-    execute_btn.click(
-        execute_figma_command_bridge,
-        inputs=[command_input, params_input],
-        outputs=[command_output]
-    )
+            test_user_btn.click(
+                get_figma_user_info,
+                outputs=[status_output]
+            )
+        
+        gr.Markdown("""
+        ---
+        ### 🛠️ **Outils MCP disponibles :**
+        - `configure_figma_token(token)` - Configure le token d'accès
+        - `configure_figma_file_id(file_id)` - Configure l'ID du fichier
+        - `get_figma_file_info()` - Récupère les infos du fichier
+        - `create_figma_rectangle(x, y, width, height, name, color)` - Crée un rectangle
+        - `create_figma_frame(x, y, width, height, name)` - Crée un frame
+        - `create_figma_text(x, y, text, name, font_size)` - Crée un texte
+        - `get_figma_comments()` - Récupère les commentaires
+        - `get_figma_user_info()` - Info utilisateur connecté
+        """)
+    
+    return demo
+
+# === LANCEMENT DE L'APPLICATION ===
 
 if __name__ == "__main__":
-    # Lance le serveur MCP selon les recommandations Gradio
+    demo = setup_demo()
+    
+    # Configuration pour Hugging Face Spaces avec MCP
     demo.launch(
-        mcp_server=True,  # Active le serveur MCP 
+        mcp_server=True,  # 🔑 Active le serveur MCP !
         server_name="0.0.0.0",
         server_port=7860,
         share=False,

requirements.txt

@@ -1,4 +1,5 @@
 gradio[mcp]>=5.3.0
-websockets==12.0
+requests>=2.31.0
 pydantic==2.5.0
-pillow==10.0.0 
+pillow>=10.0.0
+typing-extensions>=4.8.0