bricks-builder-mcp 3.1.0

package/README.md

@@ -0,0 +1,70 @@
+# Bricks Builder MCP
+
+Serveur **Model Context Protocol (MCP)** qui permet à Claude (Desktop, Cowork, Claude Code) de piloter **Bricks Builder** sur un site WordPress : lister les pages, lire/modifier le JSON Bricks, ajouter ou réorganiser des sections, etc.
+
+## Architecture
+
+```
+Claude (Desktop / Cowork)
+    ↓ MCP (stdio)
+bricks-builder-mcp  (ce package)
+    ↓ HTTPS + X-API-Key
+WordPress + plugin "Bricks Builder MCP Server"
+    ↓
+Pages Bricks Builder
+```
+
+## Installation
+
+### Prérequis côté WordPress
+
+Le plugin compagnon **Bricks Builder MCP Server** doit être installé et activé sur le WordPress cible. Il expose les endpoints REST `/wp-json/bricks-mcp/v2/*` et permet de générer la clé API.
+
+### Configuration côté Claude
+
+Ajoute dans le fichier de configuration Claude (`claude_desktop_config.json` ou équivalent) :
+
+```json
+{
+  "mcpServers": {
+    "bricks-mcp": {
+      "command": "npx",
+      "args": ["-y", "bricks-builder-mcp"],
+      "env": {
+        "WORDPRESS_URL": "https://exemple-de-site.com",
+        "API_KEY": "bricks_xxxxxxxx"
+      }
+    }
+  }
+}
+```
+
+Redémarre Claude. C'est tout.
+
+## Variables d'environnement
+
+| Variable | Requis | Description |
+|---|---|---|
+| `WORDPRESS_URL` | oui | URL racine du site WordPress (ex : `https://exemple.com`) |
+| `API_KEY` | oui | Clé API générée dans les réglages du plugin WordPress |
+
+## Outils MCP exposés
+
+| Outil | Description |
+|---|---|
+| `list_bricks_pages` | Liste toutes les pages Bricks |
+| `get_page_json` | Récupère le JSON complet d'une page |
+| `update_page_json` | Sauvegarde le JSON complet d'une page |
+| `analyze_json_structure` | Analyse la structure d'un JSON Bricks |
+| `get_page_structure` | Vue d'ensemble légère (économe en tokens) |
+| `find_elements` | Recherche d'éléments par critères |
+| `get_element` | Récupère un élément précis |
+| `update_element` | Modifie un élément précis |
+| `add_element` | Ajoute un élément |
+| `batch_add` | Ajoute plusieurs éléments en une fois |
+| `delete_element` | Supprime un élément |
+| `reorder_sections` | Réorganise l'ordre des sections (header en haut, footer en bas) |
+
+## Licence
+
+MIT

package/package.json

@@ -0,0 +1,33 @@
+{
+  "type": "module",
+  "name": "bricks-builder-mcp",
+  "version": "3.1.0",
+  "description": "Serveur MCP pour piloter Bricks Builder (WordPress) depuis Claude — édition de pages, gestion d'éléments, réordonnancement des sections.",
+  "main": "server.js",
+  "bin": {
+    "bricks-builder-mcp": "./server.js"
+  },
+  "files": [
+    "server.js",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node server.js",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "mcp",
+    "bricks-builder",
+    "wordpress",
+    "claude",
+    "model-context-protocol"
+  ],
+  "author": "Mathieu Maap <mathieu.maap@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.23.0"
+  }
+}

package/server.js

@@ -0,0 +1,512 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+// Configuration du fichier de log
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const LOG_FILE = join(__dirname, 'bricks-mcp-debug.log');
+
+function logToFile(message) {
+  const timestamp = new Date().toISOString();
+  const logMessage = `[${timestamp}] ${message}\n`;
+  try {
+    fs.appendFileSync(LOG_FILE, logMessage);
+  } catch (err) {
+    // Ignorer les erreurs de log
+  }
+}
+
+// Remplacer console.error
+const originalConsoleError = console.error;
+console.error = (...args) => {
+  const message = args.map(arg => 
+    typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+  ).join(' ');
+  logToFile(message);
+  originalConsoleError(...args);
+};
+
+logToFile('========================================');
+logToFile('DÉMARRAGE BRICKS MCP SERVER v3.0');
+logToFile('========================================');
+
+// Configuration WordPress
+// Priorité : variables d'environnement > valeurs par défaut (ancien site, pour compatibilité)
+const WORDPRESS_URL = process.env.WORDPRESS_URL || "https://aidetravauxfibre0002.live-website.com";
+const API_KEY = process.env.API_KEY || "bricks_syectnbripq";
+const API_ENDPOINT = `${WORDPRESS_URL}/wp-json/bricks-mcp/v2`;
+
+logToFile(`[CONFIG] WORDPRESS_URL = ${WORDPRESS_URL}`);
+logToFile(`[CONFIG] API_KEY = ${API_KEY ? API_KEY.substring(0, 10) + '...' : 'NON DÉFINIE'}`);
+
+if (!process.env.WORDPRESS_URL || !process.env.API_KEY) {
+  logToFile('[WARN] WORDPRESS_URL ou API_KEY non définies dans l\'environnement, utilisation des valeurs par défaut');
+}
+
+const mcpServer = new Server(
+  {
+    name: "bricks-mcp-v3",
+    version: "3.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// Fonction pour appeler l'API WordPress
+async function callWordPressAPI(endpoint, method = "GET", body = null) {
+  const options = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": API_KEY,
+    },
+  };
+
+  if (body) {
+    options.body = JSON.stringify(body);
+    console.error(`[LOG] Envoi vers ${endpoint}:`, JSON.stringify(body, null, 2));
+  }
+
+  try {
+    const response = await fetch(`${API_ENDPOINT}${endpoint}`, options);
+    console.error(`[LOG] Réponse status: ${response.status}`);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`[LOG] Erreur API: ${errorText}`);
+      throw new Error(`API Error: ${response.statusText}`);
+    }
+
+    const data = await response.json();
+    console.error(`[LOG] Réponse reçue:`, JSON.stringify(data, null, 2));
+    return data;
+  } catch (error) {
+    console.error(`[LOG] Exception:`, error.message);
+    throw new Error(`Erreur API: ${error.message}`);
+  }
+}
+
+// Définir les tools disponibles
+mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      // ===== OUTILS EXISTANTS (compatibilité) =====
+      {
+        name: "list_bricks_pages",
+        description: "Liste toutes les pages Bricks Builder du site.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: [],
+        },
+      },
+      {
+        name: "get_page_json",
+        description: "Récupère le JSON COMPLET d'une page. Utilise ceci pour les gros travaux ou refonte complète.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page WordPress",
+            },
+          },
+          required: ["pageId"],
+        },
+      },
+      {
+        name: "update_page_json",
+        description: "Sauvegarde le JSON COMPLET d'une page. Utilise ceci après get_page_json pour grosse refonte.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page",
+            },
+            newJsonData: {
+              type: "array",
+              description: "Le JSON complet (TABLEAU)",
+              items: {
+                type: "object",
+              }
+            },
+          },
+          required: ["pageId", "newJsonData"],
+        },
+      },
+      {
+        name: "analyze_json_structure",
+        description: "Analyse la structure d'un JSON Bricks.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            jsonData: {
+              type: ["object", "array", "string"],
+              description: "Le JSON à analyser",
+            },
+          },
+          required: ["jsonData"],
+        },
+      },
+
+      // ===== OUTILS v2.0 (OPTIMISÉS) =====
+      
+      {
+        name: "get_page_structure",
+        description: "Récupère une VUE D'ENSEMBLE LÉGÈRE de la page (juste id, name, parent, children, aperçu texte). Économise 80% de tokens vs get_page_json. Utilise pour comprendre la structure sans charger tous les détails.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page",
+            },
+          },
+          required: ["pageId"],
+        },
+      },
+      
+      {
+        name: "find_elements",
+        description: "Trouve des éléments par CRITÈRES sans charger toute la page. Très économe en tokens. Utilise pour chercher des boutons, headings, sections spécifiques, etc.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page",
+            },
+            criteria: {
+              type: "object",
+              description: "Critères de recherche",
+              properties: {
+                type: {
+                  type: "string",
+                  description: "Type d'élément : heading, button, section, container, etc."
+                },
+                parent: {
+                  type: "string",
+                  description: "ID du parent"
+                },
+                hasText: {
+                  type: "string",
+                  description: "Texte contenu dans l'élément"
+                },
+                className: {
+                  type: "string",
+                  description: "Classe CSS de l'élément"
+                }
+              }
+            },
+            limit: {
+              type: "number",
+              description: "Nombre max de résultats (défaut: 100)",
+            },
+          },
+          required: ["pageId"],
+        },
+      },
+      
+      {
+        name: "get_element",
+        description: "Récupère UN SEUL élément en détail. Utilise quand tu connais l'ID et veux les détails complets.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page",
+            },
+            elementId: {
+              type: "string",
+              description: "L'ID de l'élément à récupérer",
+            },
+          },
+          required: ["pageId", "elementId"],
+        },
+      },
+      
+      {
+        name: "update_element",
+        description: "Modifie UN SEUL élément sans recharger/renvoyer toute la page. Ultra économe en tokens. Utilise pour changer une couleur, un texte, etc.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page",
+            },
+            elementId: {
+              type: "string",
+              description: "L'ID de l'élément à modifier",
+            },
+            newSettings: {
+              type: "object",
+              description: "Les nouveaux settings (fusionnés avec les anciens)",
+            },
+          },
+          required: ["pageId", "elementId", "newSettings"],
+        },
+      },
+      
+      {
+        name: "add_element",
+        description: "Ajoute UN SEUL nouvel élément à la page. Utilise pour ajouter un bouton, un paragraphe, etc.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page",
+            },
+            element: {
+              type: "object",
+              description: "L'élément complet à ajouter (avec id, name, parent, children, settings)",
+            },
+            position: {
+              type: "number",
+              description: "Position dans le tableau (optionnel, défaut: fin)",
+            },
+          },
+          required: ["pageId", "element"],
+        },
+      },
+      
+      {
+        name: "batch_add",
+        description: "Ajoute PLUSIEURS éléments en UNE SEULE fois. Utilise pour créer une section complète (5-10 éléments). Plus efficace que add_element en boucle.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page",
+            },
+            elements: {
+              type: "array",
+              description: "Tableau des éléments à ajouter",
+              items: {
+                type: "object"
+              }
+            },
+          },
+          required: ["pageId", "elements"],
+        },
+      },
+      
+      {
+        name: "delete_element",
+        description: "Supprime UN élément et nettoie les références parent/enfant.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page",
+            },
+            elementId: {
+              type: "string",
+              description: "L'ID de l'élément à supprimer",
+            },
+          },
+          required: ["pageId", "elementId"],
+        },
+      },
+
+      // ===== 🆕 NOUVEL OUTIL v3.0 : REORDER_SECTIONS =====
+      
+      {
+        name: "reorder_sections",
+        description: "Réorganise l'ordre d'affichage des sections principales (parent: 0). CRITIQUE : Dans Bricks, l'ordre dans le tableau JSON détermine l'ordre de rendu. Utilise TOUJOURS cet outil après création d'un header/footer pour le placer correctement. Exemple : reorder_sections(9, ['header_pro', 'hero_section', 'services_section']) met le header en premier.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            pageId: {
+              type: "number",
+              description: "L'ID de la page WordPress",
+            },
+            orderedIds: {
+              type: "array",
+              items: { type: "string" },
+              description: "Tableau des IDs des sections dans l'ordre souhaité (ex: ['header_pro', 'hero_section', 'services_section']). Les sections non listées seront placées à la fin.",
+            },
+          },
+          required: ["pageId", "orderedIds"],
+        },
+      },
+    ],
+  };
+});
+
+// Gérer les appels de tools
+mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  console.error(`\n========================================`);
+  console.error(`[LOG] Tool appelé: ${name}`);
+  console.error(`[LOG] Arguments reçus:`, JSON.stringify(args, null, 2));
+  console.error(`========================================\n`);
+
+  try {
+    let result;
+
+    switch (name) {
+      // ===== OUTILS EXISTANTS =====
+      case "list_bricks_pages":
+        console.error(`[LOG] Exécution: list_bricks_pages`);
+        result = await callWordPressAPI("/list-pages");
+        break;
+
+      case "get_page_json":
+        console.error(`[LOG] Exécution: get_page_json avec pageId=${args.pageId}`);
+        result = await callWordPressAPI("/get-page-json", "POST", {
+          pageId: args.pageId,
+        });
+        break;
+
+      case "update_page_json":
+        console.error(`[LOG] Exécution: update_page_json`);
+        console.error(`[LOG] pageId: ${args.pageId}`);
+        console.error(`[LOG] newJsonData type:`, typeof args.newJsonData);
+        console.error(`[LOG] newJsonData est un array?`, Array.isArray(args.newJsonData));
+        result = await callWordPressAPI("/update-page-json", "POST", {
+          pageId: args.pageId,
+          newJsonData: args.newJsonData,
+        });
+        break;
+
+      case "analyze_json_structure":
+        console.error(`[LOG] Exécution: analyze_json_structure`);
+        result = await callWordPressAPI("/analyze-json", "POST", {
+          jsonData: args.jsonData,
+        });
+        break;
+
+      // ===== OUTILS v2.0 =====
+      
+      case "get_page_structure":
+        console.error(`[LOG] Exécution: get_page_structure avec pageId=${args.pageId}`);
+        result = await callWordPressAPI("/get-page-structure", "POST", {
+          pageId: args.pageId,
+        });
+        break;
+
+      case "find_elements":
+        console.error(`[LOG] Exécution: find_elements`);
+        console.error(`[LOG] Critères:`, JSON.stringify(args.criteria, null, 2));
+        result = await callWordPressAPI("/find-elements", "POST", {
+          pageId: args.pageId,
+          criteria: args.criteria || {},
+          limit: args.limit || 100,
+        });
+        break;
+
+      case "get_element":
+        console.error(`[LOG] Exécution: get_element`);
+        console.error(`[LOG] pageId: ${args.pageId}, elementId: ${args.elementId}`);
+        result = await callWordPressAPI("/get-element", "POST", {
+          pageId: args.pageId,
+          elementId: args.elementId,
+        });
+        break;
+
+      case "update_element":
+        console.error(`[LOG] Exécution: update_element`);
+        console.error(`[LOG] Modification de l'élément ${args.elementId}`);
+        result = await callWordPressAPI("/update-element", "POST", {
+          pageId: args.pageId,
+          elementId: args.elementId,
+          newSettings: args.newSettings,
+        });
+        break;
+
+      case "add_element":
+        console.error(`[LOG] Exécution: add_element`);
+        console.error(`[LOG] Ajout de l'élément:`, JSON.stringify(args.element, null, 2));
+        result = await callWordPressAPI("/add-element", "POST", {
+          pageId: args.pageId,
+          element: args.element,
+          position: args.position,
+        });
+        break;
+
+      case "batch_add":
+        console.error(`[LOG] Exécution: batch_add`);
+        console.error(`[LOG] Ajout de ${args.elements.length} éléments`);
+        result = await callWordPressAPI("/batch-add", "POST", {
+          pageId: args.pageId,
+          elements: args.elements,
+        });
+        break;
+
+      case "delete_element":
+        console.error(`[LOG] Exécution: delete_element`);
+        console.error(`[LOG] Suppression de l'élément ${args.elementId}`);
+        result = await callWordPressAPI("/delete-element", "POST", {
+          pageId: args.pageId,
+          elementId: args.elementId,
+        });
+        break;
+
+      // ===== 🆕 NOUVEL OUTIL v3.0 : REORDER_SECTIONS =====
+      
+      case "reorder_sections":
+        console.error(`[LOG] Exécution: reorder_sections`);
+        console.error(`[LOG] pageId: ${args.pageId}`);
+        console.error(`[LOG] orderedIds:`, JSON.stringify(args.orderedIds, null, 2));
+        result = await callWordPressAPI("/reorder-sections", "POST", {
+          pageId: args.pageId,
+          orderedIds: args.orderedIds,
+        });
+        break;
+
+      default:
+        console.error(`[LOG] Tool inconnu: ${name}`);
+        result = { error: `Tool ${name} not found` };
+    }
+
+    console.error(`[LOG] Résultat:`, JSON.stringify(result, null, 2));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    console.error(`[LOG] ERREUR:`, error.message);
+    console.error(`[LOG] Stack:`, error.stack);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Erreur: ${error.message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Démarrer le serveur
+async function main() {
+  const transport = new StdioServerTransport();
+  await mcpServer.connect(transport);
+  console.error("[READY] MCP Bricks Builder v3.0 démarré et connecté");
+}
+
+main().catch(console.error);