Add new features to MCP

HUGGINGFACE_PUBLISHING.md

@@ -0,0 +1,194 @@
+# Guía de Publicación en Hugging Face
+
+## 📋 Prerrequisitos
+
+1. Cuenta en Hugging Face: https://huggingface.co/join
+2. Git instalado
+3. Git LFS instalado (opcional pero recomendado)
+
+## 🚀 Método 1: Crear Space Directamente en Hugging Face
+
+### Paso 1: Crear el Space
+
+1. Ve a https://huggingface.co/new-space
+2. Configura:
+   - **Space name**: `mcp-figma-rest-api` (o el nombre que prefieras)
+   - **License**: MIT
+   - **Space SDK**: Static
+   - **Visibility**: Public
+
+### Paso 2: Clonar y Subir Contenido
+
+```bash
+# Clonar el Space vacío
+git clone https://huggingface.co/spaces/TU_USUARIO/mcp-figma-rest-api
+cd mcp-figma-rest-api
+
+# Copiar el README preparado para Hugging Face
+cp ../mcp-figma-comment-summary/README.huggingface.md README.md
+
+# Añadir y publicar
+git add README.md
+git commit -m "Add Complete Figma REST API MCP Server v2.0.0"
+git push
+```
+
+### Paso 3: Verificar
+
+Ve a `https://huggingface.co/spaces/TU_USUARIO/mcp-figma-rest-api` y verifica que todo se vea correctamente.
+
+---
+
+## 🔗 Método 2: Sincronizar desde GitHub
+
+### Opción A: Importar Repositorio Existente
+
+1. Ve a https://huggingface.co/new-space
+2. Selecciona **"Import from GitHub"**
+3. Conecta tu cuenta de GitHub
+4. Selecciona tu repositorio `mcp-figma-comment-summary`
+5. Hugging Face clonará automáticamente
+
+**IMPORTANTE:** Si usas este método, necesitas renombrar `README.huggingface.md` a `README.md` en tu repositorio de GitHub primero.
+
+### Opción B: Configurar Sincronización Bidireccional
+
+Si quieres mantener GitHub como fuente principal y que Hugging Face se sincronice automáticamente:
+
+```bash
+# En tu repositorio local
+cd /Users/fran/Documents/IN/Labs/mcp-figma-comment-summary
+
+# Añadir Hugging Face como remote adicional
+git remote add huggingface https://huggingface.co/spaces/TU_USUARIO/mcp-figma-rest-api
+
+# Crear una rama específica para Hugging Face (opcional)
+git checkout -b huggingface-sync
+
+# Renombrar README para Hugging Face
+mv README.md README.github.md
+mv README.huggingface.md README.md
+
+# Commit y push a Hugging Face
+git add .
+git commit -m "Prepare for Hugging Face deployment"
+git push huggingface huggingface-sync:main
+
+# Volver a la rama principal
+git checkout main
+```
+
+---
+
+## 📝 Personalizar la Página de Hugging Face
+
+El archivo `README.huggingface.md` ya tiene los metadatos necesarios en el frontmatter YAML:
+
+```yaml
+---
+title: Figma REST API MCP Server
+emoji: 🎨
+colorFrom: purple
+colorTo: blue
+sdk: static
+pinned: false
+tags:
+  - mcp
+  - model-context-protocol
+  - figma
+  - api
+  - design
+  - collaboration
+  - claude
+  - webhooks
+  - variables
+license: mit
+---
+```
+
+Puedes personalizar:
+- **title**: Nombre que aparece en Hugging Face
+- **emoji**: Icono del Space
+- **colorFrom/colorTo**: Gradiente del header
+- **tags**: Para búsqueda y descubrimiento
+- **pinned**: Si quieres que aparezca destacado en tu perfil
+
+---
+
+## 🔍 Verificación Post-Publicación
+
+Después de publicar, verifica:
+
+1. ✅ El README se muestra correctamente
+2. ✅ Los 29 endpoints están documentados
+3. ✅ Los ejemplos de uso funcionan
+4. ✅ Los enlaces a npm y GitHub funcionan
+5. ✅ Las instrucciones de instalación son claras
+
+---
+
+## 📦 Actualizar en el Futuro
+
+Cuando publiques actualizaciones:
+
+```bash
+# Si usas el método directo
+cd mcp-figma-rest-api
+# Actualiza README.md con los cambios
+git add .
+git commit -m "Update to v2.0.1"
+git push
+
+# Si sincronizas desde GitHub
+git push github main
+git push huggingface huggingface-sync:main
+```
+
+---
+
+## 🌟 Promoción
+
+Una vez publicado, puedes:
+
+1. Compartir el enlace en:
+   - Twitter/X con hashtags #MCP #Figma #Claude
+   - Discord de Model Context Protocol
+   - Comunidad de Figma
+
+2. Añadir badge en tu README de GitHub:
+   ```markdown
+   [![Hugging Face](https://img.shields.io/badge/🤗%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/TU_USUARIO/mcp-figma-rest-api)
+   ```
+
+3. Enlazar desde tu perfil de npm:
+   - Actualiza el `homepage` en `package.json` si quieres que apunte a Hugging Face
+
+---
+
+## ❓ Troubleshooting
+
+### El README no se muestra correctamente
+- Verifica que el archivo se llama exactamente `README.md`
+- Revisa que el frontmatter YAML esté correcto
+- Comprueba que no haya caracteres especiales mal formateados
+
+### Los cambios no se reflejan
+- Espera 1-2 minutos (Hugging Face puede tardar en actualizar)
+- Haz un hard refresh (Cmd+Shift+R en Mac, Ctrl+Shift+R en Windows)
+- Verifica que el push se completó correctamente
+
+### Error de permisos
+- Asegúrate de estar autenticado en Hugging Face
+- Configura tu token de acceso si es necesario:
+  ```bash
+  git config credential.helper store
+  ```
+
+---
+
+## 📚 Referencias
+
+- [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+- [Hugging Face Git LFS](https://huggingface.co/docs/hub/repositories-getting-started#terminal)
+- [Model Context Protocol](https://modelcontextprotocol.io/)
+- [Figma REST API Docs](https://developers.figma.com/docs/rest-api/)

README.huggingface.md

@@ -1,6 +1,6 @@
 ---
-title: Figma Comment Summary MCP
-emoji: 💬
+title: Figma REST API MCP Server
+emoji: 🎨
 colorFrom: purple
 colorTo: blue
 sdk: static
@@ -9,32 +9,54 @@ tags:
   - mcp
   - model-context-protocol
   - figma
-  - comments
+  - api
   - design
   - collaboration
   - claude
+  - webhooks
+  - variables
 license: mit
 ---
 
-# 💬 Figma Comment Summary MCP Server
+# 🎨 Complete Figma REST API MCP Server
 
-A [Model Context Protocol](https://modelcontextprotocol.io/) server that enables LLMs like Claude to **read, write, and analyze** comments in Figma files. Perfect for design review workflows, team collaboration analysis, and automated comment management.
+A comprehensive [Model Context Protocol](https://modelcontextprotocol.io/) server that gives Claude Desktop **complete access to the Figma REST API**. Access files, comments, variables, webhooks, projects, teams, dev resources, version history, and more - all through natural language.
 
-## 🎯 Capabilities
+## 🎯 Complete API Coverage - 29 Endpoints
 
-**📖 Read Operations:**
-- Retrieve all comments with full details (text, author, timestamp, location)
-- Generate automatic summaries and statistics
+**📖 Files & Content:**
+- Get complete file structure as JSON with all nodes and components
+- Retrieve specific nodes from files
+- Render images from nodes in any format (PNG, JPG, SVG, PDF)
+- Access image fills and assets
 
-**✍️ Write Operations:**
-- Create new comments anywhere in Figma files
-- Post comments on specific design elements
-- Reply to existing comment threads
+**💬 Comments & Collaboration:**
+- Read, create, delete comments with full threading support
+- React to comments with emojis
+- Reply to threads with @mentions
+- Track comment authors and resolution status
 
-**🤖 AI-Powered Workflows:**
-- Auto-respond to design feedback
-- Analyze and summarize design discussions
-- Coordinate team reviews efficiently
+**🎨 Variables & Design Systems (Enterprise):**
+- Access local and published variables
+- Create and update design tokens
+- Manage design system synchronization
+
+**🔔 Webhooks & Automation:**
+- Create webhooks for file updates and events
+- Manage webhook lifecycle (get, update, delete)
+- Debug webhook requests
+
+**👥 Projects & Teams:**
+- Access team projects and files
+- Navigate organizational structure
+
+**🔧 Dev Resources:**
+- Attach developer URLs to design nodes
+- Bridge design and development workflows
+
+**📜 Version History:**
+- Access file version history
+- Track design evolution
 
 ## 🚀 Quick Start
 
@@ -68,58 +90,133 @@ Add this configuration to your Claude Desktop config file:
 
 ## ✨ Features
 
-- 📝 **Retrieve Comments**: Get all comments from any Figma file with full details
-- 👥 **Author Information**: Extract author data, timestamps, and reply threads
-- 📊 **Smart Summaries**: Generate statistics by author, location, and resolution status
-- 🔧 **Easy Integration**: Works with Claude Desktop and any MCP client
+- 📄 **29 Endpoints** covering the complete Figma REST API
+- 💬 **Comments**: Full CRUD + reactions + @mentions (9 endpoints)
+- 📁 **Files**: Complete file access, node retrieval, image rendering (4 endpoints)
+- 🎨 **Variables**: Design tokens management - Enterprise (3 endpoints)
+- 🔔 **Webhooks**: Event-driven automations (6 endpoints)
+- 👥 **Teams & Projects**: Organizational navigation (2 endpoints)
+- 🔧 **Dev Resources**: Design-to-dev bridge (3 endpoints)
+- 📜 **Version History**: Track file changes (1 endpoint)
+- 👤 **Users**: Current user info (1 endpoint)
 - 🔒 **Secure**: Each user uses their own Figma token
 
-## 🛠️ Available Tools
+## 🛠️ Available Tools (29 Total)
+
+### 💬 Comments (9 endpoints)
+- `get_figma_comments` - Retrieve all comments with threads
+- `summarize_figma_comments` - Generate statistics
+- `get_comment_users` - List users for @mentions
+- `post_figma_comment` - Create comments with @mentions
+- `reply_to_figma_comment` - Reply to threads
+- `delete_figma_comment` - Delete comments
+- `get_comment_reactions` - Get emoji reactions
+- `post_comment_reaction` - Add reactions
+- `delete_comment_reaction` - Remove reactions
+
+### 📄 Files (4 endpoints)
+- `get_file` - Get complete file structure as JSON
+- `get_file_nodes` - Get specific nodes by ID
+- `render_images` - Render as PNG/JPG/SVG/PDF
+- `get_image_fills` - Get all image fill URLs
+
+### 👤 Users (1 endpoint)
+- `get_current_user` - Get authenticated user info
+
+### 📜 Version History (1 endpoint)
+- `get_version_history` - Get file version history
+
+### 👥 Projects & Teams (2 endpoints)
+- `get_team_projects` - List team projects
+- `get_project_files` - List project files
+
+### 🎨 Variables (3 endpoints - Enterprise)
+- `get_local_variables` - Get local variables
+- `get_published_variables` - Get published variables
+- `create_variables` - Create/update variables
+
+### 🔧 Dev Resources (3 endpoints)
+- `get_dev_resources` - Get developer URLs
+- `create_dev_resource` - Attach URL to node
+- `delete_dev_resource` - Remove resource
+
+### 🔔 Webhooks V2 (6 endpoints)
+- `create_webhook` - Create webhook for events
+- `get_webhook` - Get webhook by ID
+- `get_webhooks` - List all webhooks
+- `update_webhook` - Update webhook
+- `delete_webhook` - Delete webhook
+- `get_webhook_requests` - Debug webhook requests
 
-### `get_figma_comments`
+## 📖 Use Cases
 
-Retrieve all comments from a Figma file with complete information including text, authors, timestamps, locations, and reply threads.
+**💬 Comments & Collaboration:**
+- Design reviews and feedback management
+- Automated responses to comment threads
+- Comment sentiment analysis
+- Team collaboration analytics
+
+**📁 File Management:**
+- Extract complete design system structure
+- Generate documentation from Figma files
+- Export assets and images programmatically
+- Navigate file hierarchies
+
+**🎨 Design Systems (Enterprise):**
+- Synchronize design tokens across files
+- Track variable changes
+- Automate design system documentation
+- Validate token usage
+
+**🔔 Automation:**
+- Set up file update notifications
+- Trigger workflows on design changes
+- Monitor library publications
+- Track team activity
+
+**👥 Team Organization:**
+- Audit project file organization
+- Generate team activity reports
+- Navigate organizational structures
+
+**🔧 Developer Handoff:**
+- Attach implementation URLs to designs
+- Bridge design-to-development workflow
+- Track component implementation status
 
-**Parameters:**
-- `file_id` (string): The Figma file ID from the URL
+## 💡 Example Conversations
 
-**Example:**
+**💬 Comments:**
 ```
-Get all comments from Figma file ABC123XYZ
+"Get all comments from file ABC123 and reply to unresolved ones"
+"Delete comment 789 and add a 👍 reaction to comment 456"
+"Post a comment mentioning @john_designer to review colors"
 ```
 
-### `summarize_figma_comments`
-
-Generate a comprehensive summary and analysis of all comments in a Figma file.
-
-**Parameters:**
-- `file_id` (string): The Figma file ID from the URL
-
-**Example:**
+**📁 Files & Nodes:**
 ```
-Summarize the comments from Figma file ABC123XYZ
+"Get the complete structure of file ABC123"
+"Render nodes 1:5,1:6,1:7 as PNG at 2x scale"
+"Export node 123:456 as SVG"
 ```
 
-## 📖 Use Cases
-
-- **Design Reviews**: Quickly gather all feedback from stakeholders
-- **Team Collaboration**: Analyze comment patterns and identify bottlenecks
-- **Comment Management**: Track unresolved comments and resolution status
-- **Reporting**: Generate summaries for design sprint retrospectives
-- **AI Analysis**: Let Claude analyze sentiment and extract action items
-
-## 💡 Example Conversations
-
-Once installed, you can ask Claude:
-
+**🎨 Variables:**
+```
+"Get all local variables from file ABC123"
+"Create a new color variable named 'primary-blue'"
 ```
-"Get all comments from Figma file ABC123 and tell me which ones are unresolved"
-
-"Summarize the feedback on file XYZ123 and identify common themes"
 
-"Show me all comments by username 'john' in file ABC123"
+**🔔 Webhooks:**
+```
+"Create a webhook for FILE_UPDATE events on team T123"
+"List all webhooks and show request history"
+```
 
-"Which design elements in file XYZ have the most comments?"
+**Combined Workflows:**
+```
+"Get file structure, find all buttons, render as images, create catalog"
+"Analyze comments, group by theme, post summary with @mentions"
+"Set up webhook for updates, document all current variables"
 ```
 
 ## 🔍 Finding Your Figma File ID

README.md

@@ -1,42 +1,63 @@
 # mcp-figma-comment-summary
 
-> MCP server to retrieve, analyze, and create Figma file comments with Claude Desktop
+> Complete MCP server for Figma REST API - Full access to files, comments, variables, webhooks, projects, and more
 
 [![npm version](https://img.shields.io/npm/v/mcp-figma-comment-summary.svg)](https://www.npmjs.com/package/mcp-figma-comment-summary)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-A [Model Context Protocol](https://modelcontextprotocol.io/) server that enables Claude Desktop to retrieve, analyze, and create comments in Figma files. Perfect for design review workflows, team collaboration analysis, and comment management.
+A comprehensive [Model Context Protocol](https://modelcontextprotocol.io/) server that gives Claude Desktop **complete access to the Figma REST API**. Access files, comments, variables, webhooks, projects, teams, dev resources, version history, and more - all through natural language.
 
 ## 🎯 What Can This Do?
 
-This MCP gives Claude **full read and write access** to Figma comments:
+This MCP gives Claude **complete access to Figma's REST API with 29 endpoints**:
 
-**📖 Reading:**
-- Get all comments from any Figma file
-- View authors, timestamps, locations, and reply threads
-- Generate automatic summaries and statistics
+**📖 Files & Content:**
+- Get complete file structure as JSON with all nodes and components
+- Retrieve specific nodes from files
+- Render images from nodes in any format (PNG, JPG, SVG, PDF)
+- Access image fills and assets
 
-**✍️ Writing:**
-- Create new comments anywhere in a Figma file
-- Post comments on specific design elements (nodes)
-- Reply to existing comments to maintain conversations
-- Let Claude intelligently respond to feedback
+**💬 Comments & Collaboration:**
+- Read, create, delete comments with full threading support
+- React to comments with emojis
+- Reply to threads with @mentions
+- Track comment authors and resolution status
 
-**🤖 AI-Powered Workflows:**
-- Analyze designs and post constructive feedback
-- Automatically respond to comment threads
-- Summarize feedback for team meetings
-- Coordinate reviews across multiple stakeholders
+**🎨 Variables & Design Systems (Enterprise):**
+- Access local and published variables
+- Create and update design tokens
+- Manage design system synchronization
+
+**🔔 Webhooks & Automation:**
+- Create webhooks for file updates and events
+- Manage webhook lifecycle (get, update, delete)
+- Debug webhook requests
+
+**👥 Projects & Teams:**
+- Access team projects and files
+- Navigate organizational structure
+- Manage project resources
+
+**🔧 Dev Resources:**
+- Attach developer URLs to design nodes
+- Bridge design and development workflows
+- Track component implementations
+
+**📜 Version History:**
+- Access file version history
+- Track design evolution
 
 ## Features
 
-- 📝 Retrieve all comments from any Figma file with full details
-- ✍️ Create new comments and reply to existing ones
-- 👥 Extract author information, timestamps, and reply threads
-- 📊 Generate automatic summaries with statistics by author, location, and resolution status
-- 📍 Post comments to specific locations (nodes or coordinates)
-- 🔧 Easy integration with Claude Desktop and any MCP client
-- 🔒 Each user uses their own Figma token (secure and private)
+- 📄 **29 Endpoints** covering the complete Figma REST API
+- 💬 **Comments**: Full CRUD + reactions + @mentions
+- 📁 **Files**: Complete file access, node retrieval, image rendering
+- 🎨 **Variables**: Design tokens management (Enterprise)
+- 🔔 **Webhooks**: Event-driven automations
+- 👥 **Teams & Projects**: Organizational navigation
+- 🔧 **Dev Resources**: Design-to-dev bridge
+- 📜 **Version History**: Track file changes
+- 🔒 **Secure**: Each user uses their own Figma token
 
 ## Quick Start
 
@@ -83,15 +104,76 @@ After updating the configuration, completely quit and restart Claude Desktop to
 
 ## Available Tools
 
-This MCP provides **5 tools** split into **read** and **write** operations:
+This MCP provides **29 tools** covering the complete Figma REST API:
+
+### 💬 Comments (9 endpoints)
+
+| Tool | Method | Description |
+|------|--------|-------------|
+| `get_figma_comments` | GET | Retrieve all comments with full details, threads, and metadata |
+| `summarize_figma_comments` | GET | Generate statistics by author, location, and status |
+| `get_comment_users` | GET | List users for @mentions |
+| `post_figma_comment` | POST | Create comments with @mentions and location |
+| `reply_to_figma_comment` | POST | Reply to comment threads with @mentions |
+| `delete_figma_comment` | DELETE | Delete comments |
+| `get_comment_reactions` | GET | Get emoji reactions on comments |
+| `post_comment_reaction` | POST | Add emoji reactions |
+| `delete_comment_reaction` | DELETE | Remove emoji reactions |
+
+### 📄 Files (4 endpoints)
+
+| Tool | Method | Description |
+|------|--------|-------------|
+| `get_file` | GET | Get complete file structure as JSON |
+| `get_file_nodes` | GET | Get specific nodes by ID |
+| `render_images` | GET | Render nodes as images (PNG, JPG, SVG, PDF) |
+| `get_image_fills` | GET | Get all image fill URLs from document |
+
+### 👤 Users (1 endpoint)
+
+| Tool | Method | Description |
+|------|--------|-------------|
+| `get_current_user` | GET | Get authenticated user information |
+
+### 📜 Version History (1 endpoint)
+
+| Tool | Method | Description |
+|------|--------|-------------|
+| `get_version_history` | GET | Get file version history |
+
+### 👥 Projects & Teams (2 endpoints)
+
+| Tool | Method | Description |
+|------|--------|-------------|
+| `get_team_projects` | GET | List all projects in a team |
+| `get_project_files` | GET | List all files in a project |
+
+### 🎨 Variables (3 endpoints - Enterprise)
+
+| Tool | Method | Description |
+|------|--------|-------------|
+| `get_local_variables` | GET | Get local variables from file |
+| `get_published_variables` | GET | Get published variables |
+| `create_variables` | POST | Create/update variables |
+
+### 🔧 Dev Resources (3 endpoints)
+
+| Tool | Method | Description |
+|------|--------|-------------|
+| `get_dev_resources` | GET | Get developer URLs attached to nodes |
+| `create_dev_resource` | POST | Attach developer URL to node |
+| `delete_dev_resource` | DELETE | Remove developer resource |
 
-| Tool | Type | Description |
-|------|------|-------------|
-| `get_figma_comments` | 📖 Read | Retrieve all comments with full details |
-| `summarize_figma_comments` | 📖 Read | Generate statistics and analysis |
-| `get_comment_users` | 📖 Read | List users who have commented (useful for @mentions) |
-| `post_figma_comment` | ✍️ Write | Create new comments with optional @mentions |
-| `reply_to_figma_comment` | ✍️ Write | Reply to comments with optional @mentions |
+### 🔔 Webhooks V2 (6 endpoints)
+
+| Tool | Method | Description |
+|------|--------|-------------|
+| `create_webhook` | POST | Create webhook for events |
+| `get_webhook` | GET | Get webhook by ID |
+| `get_webhooks` | GET | List all webhooks |
+| `update_webhook` | PUT | Update webhook properties |
+| `delete_webhook` | DELETE | Delete webhook |
+| `get_webhook_requests` | GET | Get webhook request history (debugging) |
 
 ---
 
@@ -313,61 +395,107 @@ Claude will:
 
 ## Use Cases
 
-- **Design Reviews:** Quickly gather all feedback and comments from stakeholders
-- **Automated Feedback:** Let Claude post comments based on design analysis
-- **Team Collaboration:** Analyze comment patterns and identify bottlenecks
-- **Comment Management:** Find unresolved comments and track resolution status
-- **Batch Responses:** Reply to multiple comments efficiently with AI assistance
-- **Reporting:** Generate summaries for design sprint retrospectives
-- **AI Analysis:** Let Claude analyze comment sentiment and extract action items
-- **Proactive Commenting:** Claude can suggest and post improvement suggestions
+**💬 Comments & Collaboration:**
+- Design reviews and feedback management
+- Automated responses to comment threads
+- Comment sentiment analysis and action item extraction
+- Team collaboration analytics
+
+**📁 File Management:**
+- Extract complete design system structure
+- Generate documentation from Figma files
+- Export assets and images programmatically
+- Navigate file hierarchies
+
+**🎨 Design Systems (Enterprise):**
+- Synchronize design tokens across files
+- Track variable changes and updates
+- Automate design system documentation
+- Validate token usage
+
+**🔔 Automation:**
+- Set up file update notifications
+- Trigger workflows on design changes
+- Monitor library publications
+- Track team activity
+
+**👥 Team & Project Organization:**
+- Audit project file organization
+- Generate team activity reports
+- Navigate organizational structures
+- Track file ownership
+
+**🔧 Developer Handoff:**
+- Attach implementation URLs to designs
+- Bridge design-to-development workflow
+- Track component implementation status
+- Document design specifications
 
 ## Example Conversations with Claude
 
 Once installed, you can ask Claude:
 
-**Reading comments:**
+**💬 Comments:**
 ```
 "Get all comments from Figma file ABC123 and tell me which ones are unresolved"
-
-"Summarize the feedback on file XYZ123 and identify common themes"
-
-"Show me all comments by username 'john' in file ABC123"
-
-"Which design elements in file XYZ have the most comments?"
+"Reply to all unresolved comments asking for clarification"
+"Delete comment 789 from file ABC123"
+"Add a 👍 reaction to comment 456"
+"Post a comment mentioning @john_designer to review the colors"
 ```
 
-**Writing comments:**
+**📁 Files & Nodes:**
 ```
-"Post a comment on Figma file ABC123 saying 'Approved for development'"
-
-"Reply to all unresolved comments in file XYZ123 asking for clarification"
-
-"Add a comment to node 123:456 in file ABC: 'This button needs better contrast'"
-
-"Review all comments in file ABC123 and respond to the ones that need attention"
+"Get the complete structure of Figma file ABC123"
+"Show me node 123:456 from file ABC123"
+"Render nodes 1:5,1:6,1:7 as PNG images at 2x scale"
+"Export node 123:456 as SVG"
+"Get all image fills from file ABC123"
 ```
 
-**Using @mentions:**
+**👤 Users & Teams:**
+```
+"Who am I logged in as?"
+"Show me all projects in team T123"
+"List all files in project P456"
 ```
-"Show me who has commented on file ABC123"
-
-"Post a comment mentioning John: '@john_designer Please review the accessibility updates'"
-
-"Reply to comment 456 and mention Maria: '@maria_ux What are your thoughts on this?'"
 
-"Get all comments from Sarah and reply to each one mentioning her"
+**📜 Version History:**
+```
+"Show me the version history of file ABC123"
+"What changed in the last 3 versions?"
+```
 
-"Post a summary comment mentioning all users who commented: 'Thanks @john @maria @sarah for the feedback'"
+**🎨 Variables (Enterprise):**
+```
+"Get all local variables from file ABC123"
+"Show me published variables"
+"Create a new color variable named 'primary-blue'"
 ```
 
-**Combined workflows:**
+**🔧 Dev Resources:**
+```
+"Get all dev resources from file ABC123"
+"Attach Storybook URL to node 123:456"
+"Add implementation link https://... to node 1:5"
+"Delete dev resource DR789"
 ```
-"Get all unresolved comments from file ABC123, analyze them, and post a summary comment"
 
-"Find comments mentioning 'urgent' and reply with 'Working on this today'"
+**🔔 Webhooks:**
+```
+"Create a webhook for FILE_UPDATE events on team T123"
+"List all webhooks for my team"
+"Show me webhook requests for debugging"
+"Update webhook W456 to PAUSED status"
+"Delete webhook W789"
+```
 
-"Get user list, then reply to all comments from John mentioning him in each response"
+**Combined Workflows:**
+```
+"Get file structure, find all button components, render them as images, and create a visual catalog"
+"Analyze all comments, group by theme, and post a summary with @mentions"
+"Set up a webhook for file updates, then document all current variables"
+"Export all version history, compare changes, and highlight major updates"
 ```
 
 ## Verification
@@ -377,12 +505,15 @@ To verify the installation:
 1. Open Claude Desktop
 2. Look for the tools icon (🔧) in the interface
 3. You should see "figma-comments" listed as an available server
-4. The following **5 tools** should appear:
-   - `get_figma_comments` (Read)
-   - `summarize_figma_comments` (Read)
-   - `get_comment_users` (Read - for @mentions)
-   - `post_figma_comment` (Write - supports @mentions)
-   - `reply_to_figma_comment` (Write - supports @mentions)
+4. All **29 tools** should be available across these categories:
+   - **Comments** (9 tools): get, create, delete, react, reply, summarize, users
+   - **Files** (4 tools): get file, get nodes, render images, get image fills
+   - **Users** (1 tool): get current user
+   - **Version History** (1 tool): get versions
+   - **Projects & Teams** (2 tools): get projects, get files
+   - **Variables** (3 tools): get local, get published, create
+   - **Dev Resources** (3 tools): get, create, delete
+   - **Webhooks** (6 tools): create, get, list, update, delete, debug
 
 ## Troubleshooting
 

index.js

@@ -294,297 +294,1949 @@ async function replyToFigmaComment(fileId, commentId, message) {
 }
 
 /**
- * Generate a summary of comments
- * @param {Array} comments - Array of comment objects
- * @returns {Object} Summary statistics and structured data
+ * Delete a comment from a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @param {string} commentId - The ID of the comment to delete
+ * @returns {Promise<Object>} The deletion response
  */
-function summarizeComments(comments) {
-  const totalComments = comments.length;
-  const totalReplies = comments.reduce((sum, c) => sum + c.replies.length, 0);
-  const resolvedComments = comments.filter(c => c.resolvedAt).length;
-  const unresolvedComments = totalComments - resolvedComments;
+async function deleteFigmaComment(fileId, commentId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/comments/${commentId}`, {
+      method: 'DELETE',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
 
-  // Group by author
-  const authorStats = {};
-  comments.forEach(comment => {
-    const handle = comment.author.handle;
-    if (!authorStats[handle]) {
-      authorStats[handle] = { comments: 0, replies: 0 };
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
     }
-    authorStats[handle].comments++;
 
-    comment.replies.forEach(reply => {
-      const replyHandle = reply.author.handle;
-      if (!authorStats[replyHandle]) {
-        authorStats[replyHandle] = { comments: 0, replies: 0 };
-      }
-      authorStats[replyHandle].replies++;
+    return { success: true, message: 'Comment deleted successfully' };
+  } catch (error) {
+    throw new Error(`Failed to delete Figma comment: ${error.message}`);
+  }
+}
+
+/**
+ * Get reactions for a comment
+ * @param {string} fileId - The Figma file ID
+ * @param {string} commentId - The ID of the comment
+ * @returns {Promise<Object>} The reactions data
+ */
+async function getCommentReactions(fileId, commentId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/comments/${commentId}/reactions`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
     });
-  });
 
-  // Group by location (node)
-  const locationStats = {};
-  comments.forEach(comment => {
-    if (comment.location && comment.location.node_id) {
-      const nodeId = comment.location.node_id;
-      locationStats[nodeId] = (locationStats[nodeId] || 0) + 1;
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
     }
-  });
 
-  return {
-    summary: {
-      total_comments: totalComments,
-      total_replies: totalReplies,
-      resolved: resolvedComments,
-      unresolved: unresolvedComments,
-    },
-    by_author: authorStats,
-    by_location: locationStats,
-    comments: comments.map(c => ({
-      id: c.id,
-      preview: c.message.substring(0, 100) + (c.message.length > 100 ? '...' : ''),
-      author: c.author.handle,
-      timestamp: c.timestamp,
-      replies_count: c.replies.length,
-      resolved: !!c.resolvedAt,
-      location: c.location,
-    })),
-  };
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get comment reactions: ${error.message}`);
+  }
 }
 
-// Create MCP server
-const server = new Server(
-  {
-    name: 'mcp-figma-comment-summary',
-    version: '1.2.1',
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
+/**
+ * Post a reaction to a comment
+ * @param {string} fileId - The Figma file ID
+ * @param {string} commentId - The ID of the comment
+ * @param {string} emoji - The emoji reaction
+ * @returns {Promise<Object>} The created reaction
+ */
+async function postCommentReaction(fileId, commentId, emoji) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/comments/${commentId}/reactions`, {
+      method: 'POST',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ emoji }),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Figma API error: ${response.status} ${response.statusText} - ${errorData.message || ''}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to post comment reaction: ${error.message}`);
   }
-);
+}
 
-// Define available tools
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: 'get_figma_comments',
-        description: 'Retrieve all comments from a Figma file, including comment text, author info, timestamps, location, and reply threads',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            file_id: {
-              type: 'string',
-              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
-            },
-          },
-          required: ['file_id'],
-        },
+/**
+ * Delete a reaction from a comment
+ * @param {string} fileId - The Figma file ID
+ * @param {string} commentId - The ID of the comment
+ * @param {string} emoji - The emoji reaction to delete
+ * @returns {Promise<Object>} The deletion response
+ */
+async function deleteCommentReaction(fileId, commentId, emoji) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/comments/${commentId}/reactions?emoji=${encodeURIComponent(emoji)}`, {
+      method: 'DELETE',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
       },
-      {
-        name: 'summarize_figma_comments',
-        description: 'Get a summary and analysis of all comments in a Figma file, including statistics by author, location, and resolution status',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            file_id: {
-              type: 'string',
-              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
-            },
-          },
-          required: ['file_id'],
-        },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    return { success: true, message: 'Reaction deleted successfully' };
+  } catch (error) {
+    throw new Error(`Failed to delete comment reaction: ${error.message}`);
+  }
+}
+
+/**
+ * Get a Figma file as JSON
+ * @param {string} fileId - The Figma file ID
+ * @param {Object} options - Optional parameters (version, ids, depth, geometry)
+ * @returns {Promise<Object>} The file data
+ */
+async function getFile(fileId, options = {}) {
+  try {
+    const params = new URLSearchParams();
+    if (options.version) params.append('version', options.version);
+    if (options.ids) params.append('ids', options.ids);
+    if (options.depth) params.append('depth', options.depth);
+    if (options.geometry) params.append('geometry', options.geometry);
+
+    const queryString = params.toString();
+    const url = `${FIGMA_API_BASE}/files/${fileId}${queryString ? '?' + queryString : ''}`;
+
+    const response = await fetch(url, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
       },
-      {
-        name: 'post_figma_comment',
-        description: 'Create a new comment on a Figma file. Optionally specify a location (node_id and/or coordinates) where the comment should be placed',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            file_id: {
-              type: 'string',
-              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
-            },
-            message: {
-              type: 'string',
-              description: 'The text content of the comment. You can mention users using @username format (e.g., "Hey @john, please review this")',
-            },
-            node_id: {
-              type: 'string',
-              description: 'Optional: The ID of the node/element to attach the comment to',
-            },
-            x: {
-              type: 'number',
-              description: 'Optional: X coordinate for the comment position',
-            },
-            y: {
-              type: 'number',
-              description: 'Optional: Y coordinate for the comment position',
-            },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get Figma file: ${error.message}`);
+  }
+}
+
+/**
+ * Get specific nodes from a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @param {string} ids - Comma-separated list of node IDs
+ * @returns {Promise<Object>} The nodes data
+ */
+async function getFileNodes(fileId, ids) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/nodes?ids=${encodeURIComponent(ids)}`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get file nodes: ${error.message}`);
+  }
+}
+
+/**
+ * Render images from file nodes
+ * @param {string} fileId - The Figma file ID
+ * @param {Object} options - Options (ids, scale, format, svg_include_id, svg_simplify_stroke, use_absolute_bounds)
+ * @returns {Promise<Object>} The rendered images URLs
+ */
+async function renderImages(fileId, options = {}) {
+  try {
+    const params = new URLSearchParams();
+    if (options.ids) params.append('ids', options.ids);
+    if (options.scale) params.append('scale', options.scale);
+    if (options.format) params.append('format', options.format);
+    if (options.svg_include_id !== undefined) params.append('svg_include_id', options.svg_include_id);
+    if (options.svg_simplify_stroke !== undefined) params.append('svg_simplify_stroke', options.svg_simplify_stroke);
+    if (options.use_absolute_bounds !== undefined) params.append('use_absolute_bounds', options.use_absolute_bounds);
+
+    const queryString = params.toString();
+    const url = `${FIGMA_API_BASE}/images/${fileId}${queryString ? '?' + queryString : ''}`;
+
+    const response = await fetch(url, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to render images: ${error.message}`);
+  }
+}
+
+/**
+ * Get image fills from a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @returns {Promise<Object>} The image fills data
+ */
+async function getImageFills(fileId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/images`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get image fills: ${error.message}`);
+  }
+}
+
+/**
+ * Get current user information
+ * @returns {Promise<Object>} The user data
+ */
+async function getCurrentUser() {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/me`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get current user: ${error.message}`);
+  }
+}
+
+/**
+ * Get version history of a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @returns {Promise<Object>} The version history data
+ */
+async function getVersionHistory(fileId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/versions`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get version history: ${error.message}`);
+  }
+}
+
+/**
+ * Get team projects
+ * @param {string} teamId - The team ID
+ * @returns {Promise<Object>} The team projects data
+ */
+async function getTeamProjects(teamId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/teams/${teamId}/projects`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get team projects: ${error.message}`);
+  }
+}
+
+/**
+ * Get project files
+ * @param {string} projectId - The project ID
+ * @returns {Promise<Object>} The project files data
+ */
+async function getProjectFiles(projectId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/projects/${projectId}/files`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get project files: ${error.message}`);
+  }
+}
+
+/**
+ * Get local variables from a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @returns {Promise<Object>} The local variables data
+ */
+async function getLocalVariables(fileId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/variables/local`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get local variables: ${error.message}`);
+  }
+}
+
+/**
+ * Get published variables from a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @returns {Promise<Object>} The published variables data
+ */
+async function getPublishedVariables(fileId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/variables/published`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get published variables: ${error.message}`);
+  }
+}
+
+/**
+ * Create or update variables in a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @param {Object} variablesData - The variables data to create/update
+ * @returns {Promise<Object>} The created/updated variables
+ */
+async function createVariables(fileId, variablesData) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/variables`, {
+      method: 'POST',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(variablesData),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Figma API error: ${response.status} ${response.statusText} - ${errorData.message || ''}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to create variables: ${error.message}`);
+  }
+}
+
+/**
+ * Get dev resources from a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @param {string} nodeId - Optional node ID to filter resources
+ * @returns {Promise<Object>} The dev resources data
+ */
+async function getDevResources(fileId, nodeId = null) {
+  try {
+    const url = nodeId
+      ? `${FIGMA_API_BASE}/files/${fileId}/dev_resources?node_id=${encodeURIComponent(nodeId)}`
+      : `${FIGMA_API_BASE}/files/${fileId}/dev_resources`;
+
+    const response = await fetch(url, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get dev resources: ${error.message}`);
+  }
+}
+
+/**
+ * Create dev resources in a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @param {Object} devResourceData - The dev resource data (node_id, url, name)
+ * @returns {Promise<Object>} The created dev resource
+ */
+async function createDevResource(fileId, devResourceData) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/dev_resources`, {
+      method: 'POST',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(devResourceData),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Figma API error: ${response.status} ${response.statusText} - ${errorData.message || ''}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to create dev resource: ${error.message}`);
+  }
+}
+
+/**
+ * Delete a dev resource from a Figma file
+ * @param {string} fileId - The Figma file ID
+ * @param {string} devResourceId - The dev resource ID to delete
+ * @returns {Promise<Object>} The deletion response
+ */
+async function deleteDevResource(fileId, devResourceId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE}/files/${fileId}/dev_resources/${devResourceId}`, {
+      method: 'DELETE',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    return { success: true, message: 'Dev resource deleted successfully' };
+  } catch (error) {
+    throw new Error(`Failed to delete dev resource: ${error.message}`);
+  }
+}
+
+/**
+ * Create a webhook
+ * @param {Object} webhookData - The webhook data (event_type, team_id, passcode, endpoint, description)
+ * @returns {Promise<Object>} The created webhook
+ */
+async function createWebhook(webhookData) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE.replace('/v1', '/v2')}/webhooks`, {
+      method: 'POST',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(webhookData),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Figma API error: ${response.status} ${response.statusText} - ${errorData.message || ''}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to create webhook: ${error.message}`);
+  }
+}
+
+/**
+ * Get a webhook by ID
+ * @param {string} webhookId - The webhook ID
+ * @returns {Promise<Object>} The webhook data
+ */
+async function getWebhook(webhookId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE.replace('/v1', '/v2')}/webhooks/${webhookId}`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get webhook: ${error.message}`);
+  }
+}
+
+/**
+ * Get all webhooks
+ * @param {string} teamId - Optional team ID to filter webhooks
+ * @returns {Promise<Object>} The webhooks data
+ */
+async function getWebhooks(teamId = null) {
+  try {
+    const url = teamId
+      ? `${FIGMA_API_BASE.replace('/v1', '/v2')}/webhooks?team_id=${teamId}`
+      : `${FIGMA_API_BASE.replace('/v1', '/v2')}/webhooks`;
+
+    const response = await fetch(url, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get webhooks: ${error.message}`);
+  }
+}
+
+/**
+ * Update a webhook
+ * @param {string} webhookId - The webhook ID
+ * @param {Object} updateData - The data to update (status, description, endpoint, passcode)
+ * @returns {Promise<Object>} The updated webhook
+ */
+async function updateWebhook(webhookId, updateData) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE.replace('/v1', '/v2')}/webhooks/${webhookId}`, {
+      method: 'PUT',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(updateData),
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(`Figma API error: ${response.status} ${response.statusText} - ${errorData.message || ''}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to update webhook: ${error.message}`);
+  }
+}
+
+/**
+ * Delete a webhook
+ * @param {string} webhookId - The webhook ID
+ * @returns {Promise<Object>} The deletion response
+ */
+async function deleteWebhook(webhookId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE.replace('/v1', '/v2')}/webhooks/${webhookId}`, {
+      method: 'DELETE',
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    return { success: true, message: 'Webhook deleted successfully' };
+  } catch (error) {
+    throw new Error(`Failed to delete webhook: ${error.message}`);
+  }
+}
+
+/**
+ * Get webhook requests (for debugging)
+ * @param {string} webhookId - The webhook ID
+ * @returns {Promise<Object>} The webhook requests data
+ */
+async function getWebhookRequests(webhookId) {
+  try {
+    const response = await fetch(`${FIGMA_API_BASE.replace('/v1', '/v2')}/webhooks/${webhookId}/requests`, {
+      headers: {
+        'X-Figma-Token': FIGMA_TOKEN,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Figma API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    throw new Error(`Failed to get webhook requests: ${error.message}`);
+  }
+}
+
+/**
+ * Generate a summary of comments
+ * @param {Array} comments - Array of comment objects
+ * @returns {Object} Summary statistics and structured data
+ */
+function summarizeComments(comments) {
+  const totalComments = comments.length;
+  const totalReplies = comments.reduce((sum, c) => sum + c.replies.length, 0);
+  const resolvedComments = comments.filter(c => c.resolvedAt).length;
+  const unresolvedComments = totalComments - resolvedComments;
+
+  // Group by author
+  const authorStats = {};
+  comments.forEach(comment => {
+    const handle = comment.author.handle;
+    if (!authorStats[handle]) {
+      authorStats[handle] = { comments: 0, replies: 0 };
+    }
+    authorStats[handle].comments++;
+
+    comment.replies.forEach(reply => {
+      const replyHandle = reply.author.handle;
+      if (!authorStats[replyHandle]) {
+        authorStats[replyHandle] = { comments: 0, replies: 0 };
+      }
+      authorStats[replyHandle].replies++;
+    });
+  });
+
+  // Group by location (node)
+  const locationStats = {};
+  comments.forEach(comment => {
+    if (comment.location && comment.location.node_id) {
+      const nodeId = comment.location.node_id;
+      locationStats[nodeId] = (locationStats[nodeId] || 0) + 1;
+    }
+  });
+
+  return {
+    summary: {
+      total_comments: totalComments,
+      total_replies: totalReplies,
+      resolved: resolvedComments,
+      unresolved: unresolvedComments,
+    },
+    by_author: authorStats,
+    by_location: locationStats,
+    comments: comments.map(c => ({
+      id: c.id,
+      preview: c.message.substring(0, 100) + (c.message.length > 100 ? '...' : ''),
+      author: c.author.handle,
+      timestamp: c.timestamp,
+      replies_count: c.replies.length,
+      resolved: !!c.resolvedAt,
+      location: c.location,
+    })),
+  };
+}
+
+// Create MCP server
+const server = new Server(
+  {
+    name: 'mcp-figma-comment-summary',
+    version: '2.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Define available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      // Comments endpoints
+      {
+        name: 'get_figma_comments',
+        description: 'Retrieve all comments from a Figma file, including comment text, author info, timestamps, location, and reply threads',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      {
+        name: 'summarize_figma_comments',
+        description: 'Get a summary and analysis of all comments in a Figma file, including statistics by author, location, and resolution status',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      {
+        name: 'post_figma_comment',
+        description: 'Create a new comment on a Figma file. Optionally specify a location (node_id and/or coordinates) where the comment should be placed',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            message: {
+              type: 'string',
+              description: 'The text content of the comment. You can mention users using @username format (e.g., "Hey @john, please review this")',
+            },
+            node_id: {
+              type: 'string',
+              description: 'Optional: The ID of the node/element to attach the comment to',
+            },
+            x: {
+              type: 'number',
+              description: 'Optional: X coordinate for the comment position',
+            },
+            y: {
+              type: 'number',
+              description: 'Optional: Y coordinate for the comment position',
+            },
+          },
+          required: ['file_id', 'message'],
+        },
+      },
+      {
+        name: 'reply_to_figma_comment',
+        description: 'Reply to an existing comment in a Figma file',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            comment_id: {
+              type: 'string',
+              description: 'The ID of the comment to reply to',
+            },
+            message: {
+              type: 'string',
+              description: 'The text content of the reply. You can mention users using @username format (e.g., "@maria I agree with your point")',
+            },
+          },
+          required: ['file_id', 'comment_id', 'message'],
+        },
+      },
+      {
+        name: 'delete_figma_comment',
+        description: 'Delete a comment from a Figma file',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            comment_id: {
+              type: 'string',
+              description: 'The ID of the comment to delete',
+            },
+          },
+          required: ['file_id', 'comment_id'],
+        },
+      },
+      {
+        name: 'get_comment_reactions',
+        description: 'Get all reactions for a specific comment',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            comment_id: {
+              type: 'string',
+              description: 'The ID of the comment',
+            },
+          },
+          required: ['file_id', 'comment_id'],
+        },
+      },
+      {
+        name: 'post_comment_reaction',
+        description: 'Add a reaction (emoji) to a comment',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            comment_id: {
+              type: 'string',
+              description: 'The ID of the comment',
+            },
+            emoji: {
+              type: 'string',
+              description: 'The emoji reaction (e.g., "👍", "❤️", "😊")',
+            },
+          },
+          required: ['file_id', 'comment_id', 'emoji'],
+        },
+      },
+      {
+        name: 'delete_comment_reaction',
+        description: 'Remove a reaction (emoji) from a comment',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            comment_id: {
+              type: 'string',
+              description: 'The ID of the comment',
+            },
+            emoji: {
+              type: 'string',
+              description: 'The emoji reaction to remove (e.g., "👍", "❤️", "😊")',
+            },
+          },
+          required: ['file_id', 'comment_id', 'emoji'],
+        },
+      },
+      {
+        name: 'get_comment_users',
+        description: 'Get a list of all users who have commented on a Figma file. Useful to see who can be mentioned in comments using @username',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      // Files endpoints
+      {
+        name: 'get_file',
+        description: 'Get a Figma file as JSON with complete document structure, components, and metadata. Supports filtering by version, specific nodes, depth, and geometry',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            version: {
+              type: 'string',
+              description: 'Optional: A specific version ID to retrieve',
+            },
+            ids: {
+              type: 'string',
+              description: 'Optional: Comma-separated list of node IDs to retrieve (e.g., "1:5,1:6")',
+            },
+            depth: {
+              type: 'number',
+              description: 'Optional: Depth to traverse (default: traverse all)',
+            },
+            geometry: {
+              type: 'string',
+              description: 'Optional: Set to "paths" to export vector data',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      {
+        name: 'get_file_nodes',
+        description: 'Get specific nodes from a Figma file by their IDs',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            ids: {
+              type: 'string',
+              description: 'Comma-separated list of node IDs to retrieve (e.g., "1:5,1:6,1:7")',
+            },
+          },
+          required: ['file_id', 'ids'],
+        },
+      },
+      {
+        name: 'render_images',
+        description: 'Render images from file nodes in various formats (JPG, PNG, SVG, PDF) with customizable scale and options',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            ids: {
+              type: 'string',
+              description: 'Comma-separated list of node IDs to render as images (e.g., "1:5,1:6")',
+            },
+            scale: {
+              type: 'number',
+              description: 'Optional: Image scale (between 0.01 and 4)',
+            },
+            format: {
+              type: 'string',
+              description: 'Optional: Image format (jpg, png, svg, pdf). Default: png',
+            },
+            svg_include_id: {
+              type: 'boolean',
+              description: 'Optional: Whether to include id attributes in SVG',
+            },
+            svg_simplify_stroke: {
+              type: 'boolean',
+              description: 'Optional: Whether to simplify strokes in SVG',
+            },
+            use_absolute_bounds: {
+              type: 'boolean',
+              description: 'Optional: Use absolute bounding box',
+            },
+          },
+          required: ['file_id', 'ids'],
+        },
+      },
+      {
+        name: 'get_image_fills',
+        description: 'Get download links for all images used in image fills throughout the document',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      // Users endpoint
+      {
+        name: 'get_current_user',
+        description: 'Get information about the current user (the owner of the access token)',
+        inputSchema: {
+          type: 'object',
+          properties: {},
+        },
+      },
+      // Version History endpoint
+      {
+        name: 'get_version_history',
+        description: 'Get the version history of a Figma file',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      // Projects & Teams endpoints
+      {
+        name: 'get_team_projects',
+        description: 'Get all projects for a specific team',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            team_id: {
+              type: 'string',
+              description: 'The team ID',
+            },
+          },
+          required: ['team_id'],
+        },
+      },
+      {
+        name: 'get_project_files',
+        description: 'Get all files within a specific project',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            project_id: {
+              type: 'string',
+              description: 'The project ID',
+            },
+          },
+          required: ['project_id'],
+        },
+      },
+      // Variables endpoints
+      {
+        name: 'get_local_variables',
+        description: 'Get local variables defined in a Figma file (requires Enterprise plan)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      {
+        name: 'get_published_variables',
+        description: 'Get published variables from a Figma file (requires Enterprise plan)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      {
+        name: 'create_variables',
+        description: 'Create or update variables in a Figma file (requires Enterprise plan with file_variables:write scope)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            variables_data: {
+              type: 'object',
+              description: 'The variables data to create/update (refer to Figma API docs for structure)',
+            },
+          },
+          required: ['file_id', 'variables_data'],
+        },
+      },
+      // Dev Resources endpoints
+      {
+        name: 'get_dev_resources',
+        description: 'Get dev resources (developer-contributed URLs) attached to nodes in a Figma file',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            node_id: {
+              type: 'string',
+              description: 'Optional: Filter resources by specific node ID',
+            },
+          },
+          required: ['file_id'],
+        },
+      },
+      {
+        name: 'create_dev_resource',
+        description: 'Create a dev resource (developer-contributed URL) attached to a node in a Figma file',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            node_id: {
+              type: 'string',
+              description: 'The node ID to attach the resource to',
+            },
+            url: {
+              type: 'string',
+              description: 'The URL of the dev resource',
+            },
+            name: {
+              type: 'string',
+              description: 'The name/title of the dev resource',
+            },
+          },
+          required: ['file_id', 'node_id', 'url', 'name'],
+        },
+      },
+      {
+        name: 'delete_dev_resource',
+        description: 'Delete a dev resource from a Figma file',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            file_id: {
+              type: 'string',
+              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
+            },
+            dev_resource_id: {
+              type: 'string',
+              description: 'The ID of the dev resource to delete',
+            },
+          },
+          required: ['file_id', 'dev_resource_id'],
+        },
+      },
+      // Webhooks V2 endpoints
+      {
+        name: 'create_webhook',
+        description: 'Create a new webhook for Figma events (requires webhooks:write scope)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            event_type: {
+              type: 'string',
+              description: 'The event type (e.g., "FILE_UPDATE", "FILE_VERSION_UPDATE", "LIBRARY_PUBLISH")',
+            },
+            team_id: {
+              type: 'string',
+              description: 'The team ID',
+            },
+            endpoint: {
+              type: 'string',
+              description: 'The URL endpoint to receive webhook events',
+            },
+            passcode: {
+              type: 'string',
+              description: 'A passcode for webhook verification',
+            },
+            description: {
+              type: 'string',
+              description: 'Optional: Description of the webhook',
+            },
+          },
+          required: ['event_type', 'team_id', 'endpoint', 'passcode'],
+        },
+      },
+      {
+        name: 'get_webhook',
+        description: 'Get details of a specific webhook by ID',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            webhook_id: {
+              type: 'string',
+              description: 'The webhook ID',
+            },
+          },
+          required: ['webhook_id'],
+        },
+      },
+      {
+        name: 'get_webhooks',
+        description: 'Get all webhooks, optionally filtered by team',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            team_id: {
+              type: 'string',
+              description: 'Optional: Filter webhooks by team ID',
+            },
+          },
+        },
+      },
+      {
+        name: 'update_webhook',
+        description: 'Update an existing webhook',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            webhook_id: {
+              type: 'string',
+              description: 'The webhook ID to update',
+            },
+            status: {
+              type: 'string',
+              description: 'Optional: Webhook status (ACTIVE or PAUSED)',
+            },
+            description: {
+              type: 'string',
+              description: 'Optional: New description',
+            },
+            endpoint: {
+              type: 'string',
+              description: 'Optional: New endpoint URL',
+            },
+            passcode: {
+              type: 'string',
+              description: 'Optional: New passcode',
+            },
+          },
+          required: ['webhook_id'],
+        },
+      },
+      {
+        name: 'delete_webhook',
+        description: 'Delete a webhook',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            webhook_id: {
+              type: 'string',
+              description: 'The webhook ID to delete',
+            },
+          },
+          required: ['webhook_id'],
+        },
+      },
+      {
+        name: 'get_webhook_requests',
+        description: 'Get webhook requests for debugging (shows requests from the past 7 days)',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            webhook_id: {
+              type: 'string',
+              description: 'The webhook ID',
+            },
+          },
+          required: ['webhook_id'],
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    if (name === 'get_figma_comments') {
+      const { file_id } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      const comments = await getFigmaComments(file_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(comments, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (name === 'summarize_figma_comments') {
+      const { file_id } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      const comments = await getFigmaComments(file_id);
+      const summary = summarizeComments(comments);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(summary, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (name === 'post_figma_comment') {
+      const { file_id, message, node_id, x, y } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      if (!message) {
+        throw new Error('message is required');
+      }
+
+      // Build location object if any location parameters provided
+      const location = {};
+      if (node_id) location.node_id = node_id;
+      if (x !== undefined) location.x = x;
+      if (y !== undefined) location.y = y;
+
+      const result = await postFigmaComment(
+        file_id,
+        message,
+        Object.keys(location).length > 0 ? location : null
+      );
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Comment posted successfully!\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    if (name === 'reply_to_figma_comment') {
+      const { file_id, comment_id, message } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      if (!comment_id) {
+        throw new Error('comment_id is required');
+      }
+
+      if (!message) {
+        throw new Error('message is required');
+      }
+
+      const result = await replyToFigmaComment(file_id, comment_id, message);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Reply posted successfully!\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    if (name === 'get_comment_users') {
+      const { file_id } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      const { users } = await getCommentUsers(file_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Found ${users.length} user(s) who have commented:\n\n${JSON.stringify(users, null, 2)}\n\nYou can mention these users in comments using @${users.map(u => u.handle).join(', @')}`,
+          },
+        ],
+      };
+    }
+
+    // Comment deletion and reactions
+    if (name === 'delete_figma_comment') {
+      const { file_id, comment_id } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      if (!comment_id) {
+        throw new Error('comment_id is required');
+      }
+
+      const result = await deleteFigmaComment(file_id, comment_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `${result.message}\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    if (name === 'get_comment_reactions') {
+      const { file_id, comment_id } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      if (!comment_id) {
+        throw new Error('comment_id is required');
+      }
+
+      const result = await getCommentReactions(file_id, comment_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (name === 'post_comment_reaction') {
+      const { file_id, comment_id, emoji } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      if (!comment_id) {
+        throw new Error('comment_id is required');
+      }
+
+      if (!emoji) {
+        throw new Error('emoji is required');
+      }
+
+      const result = await postCommentReaction(file_id, comment_id, emoji);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Reaction posted successfully!\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    if (name === 'delete_comment_reaction') {
+      const { file_id, comment_id, emoji } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      if (!comment_id) {
+        throw new Error('comment_id is required');
+      }
+
+      if (!emoji) {
+        throw new Error('emoji is required');
+      }
+
+      const result = await deleteCommentReaction(file_id, comment_id, emoji);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `${result.message}\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    // Files endpoints
+    if (name === 'get_file') {
+      const { file_id, version, ids, depth, geometry } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      const options = {};
+      if (version) options.version = version;
+      if (ids) options.ids = ids;
+      if (depth) options.depth = depth;
+      if (geometry) options.geometry = geometry;
+
+      const result = await getFile(file_id, options);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (name === 'get_file_nodes') {
+      const { file_id, ids } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      if (!ids) {
+        throw new Error('ids is required');
+      }
+
+      const result = await getFileNodes(file_id, ids);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (name === 'render_images') {
+      const { file_id, ids, scale, format, svg_include_id, svg_simplify_stroke, use_absolute_bounds } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      if (!ids) {
+        throw new Error('ids is required');
+      }
+
+      const options = { ids };
+      if (scale) options.scale = scale;
+      if (format) options.format = format;
+      if (svg_include_id !== undefined) options.svg_include_id = svg_include_id;
+      if (svg_simplify_stroke !== undefined) options.svg_simplify_stroke = svg_simplify_stroke;
+      if (use_absolute_bounds !== undefined) options.use_absolute_bounds = use_absolute_bounds;
+
+      const result = await renderImages(file_id, options);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
           },
-          required: ['file_id', 'message'],
-        },
-      },
-      {
-        name: 'reply_to_figma_comment',
-        description: 'Reply to an existing comment in a Figma file',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            file_id: {
-              type: 'string',
-              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
-            },
-            comment_id: {
-              type: 'string',
-              description: 'The ID of the comment to reply to',
-            },
-            message: {
-              type: 'string',
-              description: 'The text content of the reply. You can mention users using @username format (e.g., "@maria I agree with your point")',
-            },
+        ],
+      };
+    }
+
+    if (name === 'get_image_fills') {
+      const { file_id } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      const result = await getImageFills(file_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
           },
-          required: ['file_id', 'comment_id', 'message'],
-        },
-      },
-      {
-        name: 'get_comment_users',
-        description: 'Get a list of all users who have commented on a Figma file. Useful to see who can be mentioned in comments using @username',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            file_id: {
-              type: 'string',
-              description: 'The Figma file ID (from the URL: figma.com/file/FILE_ID/...)',
-            },
+        ],
+      };
+    }
+
+    // Users endpoint
+    if (name === 'get_current_user') {
+      const result = await getCurrentUser();
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
           },
-          required: ['file_id'],
-        },
-      },
-    ],
-  };
-});
+        ],
+      };
+    }
 
-// Handle tool calls
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  const { name, arguments: args } = request.params;
+    // Version History endpoint
+    if (name === 'get_version_history') {
+      const { file_id } = args;
 
-  try {
-    if (name === 'get_figma_comments') {
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      const result = await getVersionHistory(file_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    // Projects & Teams endpoints
+    if (name === 'get_team_projects') {
+      const { team_id } = args;
+
+      if (!team_id) {
+        throw new Error('team_id is required');
+      }
+
+      const result = await getTeamProjects(team_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (name === 'get_project_files') {
+      const { project_id } = args;
+
+      if (!project_id) {
+        throw new Error('project_id is required');
+      }
+
+      const result = await getProjectFiles(project_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    // Variables endpoints
+    if (name === 'get_local_variables') {
       const { file_id } = args;
 
       if (!file_id) {
         throw new Error('file_id is required');
       }
 
-      const comments = await getFigmaComments(file_id);
+      const result = await getLocalVariables(file_id);
 
       return {
         content: [
           {
             type: 'text',
-            text: JSON.stringify(comments, null, 2),
+            text: JSON.stringify(result, null, 2),
           },
         ],
       };
     }
 
-    if (name === 'summarize_figma_comments') {
+    if (name === 'get_published_variables') {
       const { file_id } = args;
 
       if (!file_id) {
         throw new Error('file_id is required');
       }
 
-      const comments = await getFigmaComments(file_id);
-      const summary = summarizeComments(comments);
+      const result = await getPublishedVariables(file_id);
 
       return {
         content: [
           {
             type: 'text',
-            text: JSON.stringify(summary, null, 2),
+            text: JSON.stringify(result, null, 2),
           },
         ],
       };
     }
 
-    if (name === 'post_figma_comment') {
-      const { file_id, message, node_id, x, y } = args;
+    if (name === 'create_variables') {
+      const { file_id, variables_data } = args;
 
       if (!file_id) {
         throw new Error('file_id is required');
       }
 
-      if (!message) {
-        throw new Error('message is required');
+      if (!variables_data) {
+        throw new Error('variables_data is required');
       }
 
-      // Build location object if any location parameters provided
-      const location = {};
-      if (node_id) location.node_id = node_id;
-      if (x !== undefined) location.x = x;
-      if (y !== undefined) location.y = y;
+      const result = await createVariables(file_id, variables_data);
 
-      const result = await postFigmaComment(
-        file_id,
-        message,
-        Object.keys(location).length > 0 ? location : null
-      );
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Variables created/updated successfully!\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    // Dev Resources endpoints
+    if (name === 'get_dev_resources') {
+      const { file_id, node_id } = args;
+
+      if (!file_id) {
+        throw new Error('file_id is required');
+      }
+
+      const result = await getDevResources(file_id, node_id || null);
 
       return {
         content: [
           {
             type: 'text',
-            text: `Comment posted successfully!\n\n${JSON.stringify(result, null, 2)}`,
+            text: JSON.stringify(result, null, 2),
           },
         ],
       };
     }
 
-    if (name === 'reply_to_figma_comment') {
-      const { file_id, comment_id, message } = args;
+    if (name === 'create_dev_resource') {
+      const { file_id, node_id, url, name: resourceName } = args;
 
       if (!file_id) {
         throw new Error('file_id is required');
       }
 
-      if (!comment_id) {
-        throw new Error('comment_id is required');
+      if (!node_id) {
+        throw new Error('node_id is required');
       }
 
-      if (!message) {
-        throw new Error('message is required');
+      if (!url) {
+        throw new Error('url is required');
       }
 
-      const result = await replyToFigmaComment(file_id, comment_id, message);
+      if (!resourceName) {
+        throw new Error('name is required');
+      }
+
+      const devResourceData = {
+        node_id,
+        url,
+        name: resourceName,
+      };
+
+      const result = await createDevResource(file_id, devResourceData);
 
       return {
         content: [
           {
             type: 'text',
-            text: `Reply posted successfully!\n\n${JSON.stringify(result, null, 2)}`,
+            text: `Dev resource created successfully!\n\n${JSON.stringify(result, null, 2)}`,
           },
         ],
       };
     }
 
-    if (name === 'get_comment_users') {
-      const { file_id } = args;
+    if (name === 'delete_dev_resource') {
+      const { file_id, dev_resource_id } = args;
 
       if (!file_id) {
         throw new Error('file_id is required');
       }
 
-      const { users } = await getCommentUsers(file_id);
+      if (!dev_resource_id) {
+        throw new Error('dev_resource_id is required');
+      }
+
+      const result = await deleteDevResource(file_id, dev_resource_id);
 
       return {
         content: [
           {
             type: 'text',
-            text: `Found ${users.length} user(s) who have commented:\n\n${JSON.stringify(users, null, 2)}\n\nYou can mention these users in comments using @${users.map(u => u.handle).join(', @')}`,
+            text: `${result.message}\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    // Webhooks V2 endpoints
+    if (name === 'create_webhook') {
+      const { event_type, team_id, endpoint, passcode, description } = args;
+
+      if (!event_type) {
+        throw new Error('event_type is required');
+      }
+
+      if (!team_id) {
+        throw new Error('team_id is required');
+      }
+
+      if (!endpoint) {
+        throw new Error('endpoint is required');
+      }
+
+      if (!passcode) {
+        throw new Error('passcode is required');
+      }
+
+      const webhookData = {
+        event_type,
+        team_id,
+        endpoint,
+        passcode,
+      };
+
+      if (description) {
+        webhookData.description = description;
+      }
+
+      const result = await createWebhook(webhookData);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Webhook created successfully!\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    if (name === 'get_webhook') {
+      const { webhook_id } = args;
+
+      if (!webhook_id) {
+        throw new Error('webhook_id is required');
+      }
+
+      const result = await getWebhook(webhook_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (name === 'get_webhooks') {
+      const { team_id } = args;
+
+      const result = await getWebhooks(team_id || null);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    }
+
+    if (name === 'update_webhook') {
+      const { webhook_id, status, description, endpoint, passcode } = args;
+
+      if (!webhook_id) {
+        throw new Error('webhook_id is required');
+      }
+
+      const updateData = {};
+      if (status) updateData.status = status;
+      if (description) updateData.description = description;
+      if (endpoint) updateData.endpoint = endpoint;
+      if (passcode) updateData.passcode = passcode;
+
+      const result = await updateWebhook(webhook_id, updateData);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Webhook updated successfully!\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    if (name === 'delete_webhook') {
+      const { webhook_id } = args;
+
+      if (!webhook_id) {
+        throw new Error('webhook_id is required');
+      }
+
+      const result = await deleteWebhook(webhook_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `${result.message}\n\n${JSON.stringify(result, null, 2)}`,
+          },
+        ],
+      };
+    }
+
+    if (name === 'get_webhook_requests') {
+      const { webhook_id } = args;
+
+      if (!webhook_id) {
+        throw new Error('webhook_id is required');
+      }
+
+      const result = await getWebhookRequests(webhook_id);
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(result, null, 2),
           },
         ],
       };

package.json

@@ -1,7 +1,7 @@
 {
   "name": "mcp-figma-comment-summary",
-  "version": "1.2.1",
-  "description": "MCP server to retrieve, create, and analyze Figma file comments with @mentions - enables Claude Desktop to read and write design feedback with proper user notifications",
+  "version": "2.0.0",
+  "description": "Complete MCP server for Figma REST API - access files, comments, variables, webhooks, projects, teams, dev resources, and more through Claude Desktop",
   "type": "module",
   "main": "index.js",
   "bin": {