bricks-builder-mcp 3.6.5 → 3.7.1

package/README.md

@@ -2,6 +2,8 @@
 
 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.
 
+💬 **Communauté Discord** : [https://discord.gg/rX22zHRzH](https://discord.gg/rX22zHRzH) — viens discuter Bricks + IA, partager tes builds et signaler des bugs.
+
 ## Architecture
 
 ```

package/package.json

@@ -1,8 +1,9 @@
 {
   "type": "module",
   "name": "bricks-builder-mcp",
-  "version": "3.6.5",
-  "description": "Serveur MCP pour piloter Bricks Builder (WordPress) depuis Claude — édition de pages, gestion d'éléments, réordonnancement des sections, vérification visuelle + technique (verify_element).",
+  "version": "3.7.1",
+  "description": "Serveur MCP pour piloter Bricks Builder (WordPress) depuis Claude — édition de pages, gestion d'éléments, réordonnancement des sections, vérification visuelle (verify_element), upload optimisé WebP. Communauté Discord : https://discord.gg/rX22zHRzH",
+  "homepage": "https://discord.gg/rX22zHRzH",
   "main": "server.js",
   "bin": {
     "bricks-builder-mcp": "./server.js"

package/server.js

@@ -76,6 +76,49 @@ process.on('exit', () => {
     try { _browser.close(); } catch {}
   }
 });
+
+// ===== v3.7.0 — Helpers upload local =====
+// Le MCP server tourne sur la machine user (lancé par Claude Desktop via stdio),
+// donc il a accès direct au filesystem user. Il peut lire les fichiers et les
+// encoder en base64 LOCALEMENT pour les envoyer au plugin sans jamais que les
+// bytes passent dans le contexte de l'AI.
+
+const MIME_BY_EXT = {
+  png: 'image/png',
+  jpg: 'image/jpeg',
+  jpeg: 'image/jpeg',
+  gif: 'image/gif',
+  webp: 'image/webp',
+  svg: 'image/svg+xml',
+  avif: 'image/avif',
+  mp4: 'video/mp4',
+  webm: 'video/webm',
+  mov: 'video/quicktime',
+};
+
+function readLocalFileAsDataUri(localPath) {
+  if (!fs.existsSync(localPath)) {
+    throw new Error(`Fichier introuvable : ${localPath}`);
+  }
+  const stat = fs.statSync(localPath);
+  if (!stat.isFile()) {
+    throw new Error(`Pas un fichier : ${localPath}`);
+  }
+  const ext = (localPath.split('.').pop() || '').toLowerCase();
+  const mime = MIME_BY_EXT[ext];
+  if (!mime) {
+    throw new Error(`Extension non supportée : ${ext} (formats: ${Object.keys(MIME_BY_EXT).join(', ')})`);
+  }
+  const bytes = fs.readFileSync(localPath);
+  const b64 = bytes.toString('base64');
+  return {
+    dataUri: `data:${mime};base64,${b64}`,
+    size: stat.size,
+    mime,
+    ext,
+    basename: localPath.split('/').pop(),
+  };
+}
 process.on('SIGINT', () => {
   if (_browser) {
     try { _browser.close(); } catch {}
@@ -1014,6 +1057,51 @@ mcpServer.setRequestHandler(ListToolsRequestSchema, async () => {
         },
       },
 
+      // ===== v3.7.0 — UPLOAD FROM LOCAL FILESYSTEM =====
+      // Lit le fichier directement sur le disque (le MCP server tourne en local),
+      // encode en base64 LOCALEMENT, et l'envoie au plugin via data URI.
+      // L'AI ne voit JAMAIS les bytes — elle donne juste le path.
+      {
+        name: "upload_local_file",
+        description: "⭐ UPLOAD OPTIMAL pour des fichiers locaux. L'AI donne juste le path, le MCP server lit le fichier en local et l'envoie au plugin. Aucun b64 ne transite par le contexte AI. Param `optimize: true` (recommandé) convertit en WebP qualité 80, redim à 2000px max, et renomme avec extension .webp. Idéal pour SEO + perf web. Retourne {success, id, url, filename, optimization: {originalSize, optimizedSize, savings}}.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            localPath: { type: "string", description: "Chemin absolu du fichier local (ex: /Users/.../jt-assets/logo.png)" },
+            title: { type: "string", description: "Titre WP (sert aussi de nom de fichier slugifié — utilisé pour SEO)" },
+            alt: { type: "string", description: "Texte alternatif (OBLIGATOIRE pour SEO + accessibilité)" },
+            caption: { type: "string", description: "Légende optionnelle" },
+            optimize: { type: "boolean", description: "Convertit en WebP qualité 80, redim à 2000px max. Défaut: true (recommandé)." },
+          },
+          required: ["localPath"],
+        },
+      },
+      {
+        name: "upload_local_files_batch",
+        description: "Upload plusieurs fichiers locaux en 1 appel. Même principe que upload_local_file mais en lot. Continue même si certains échouent. Recommandé pour intégrer un dossier d'assets (logos, photos, etc.) en 1 commande.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            items: {
+              type: "array",
+              description: "Liste des fichiers à uploader",
+              items: {
+                type: "object",
+                properties: {
+                  localPath: { type: "string", description: "Chemin absolu du fichier local" },
+                  title: { type: "string", description: "Titre WP (slugifié pour le nom de fichier)" },
+                  alt: { type: "string", description: "Alt SEO" },
+                  caption: { type: "string", description: "Légende" },
+                },
+                required: ["localPath"],
+              },
+            },
+            optimize: { type: "boolean", description: "Convertit tous en WebP. Défaut: true." },
+          },
+          required: ["items"],
+        },
+      },
+
       // ===== v3.6.0 — UPLOAD MEDIA BATCH =====
       {
         name: "upload_media_batch",
@@ -1733,9 +1821,65 @@ mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
       case "upload_media_batch":
         result = await callWordPressAPI("/upload-media-batch", "POST", {
           items: args.items,
+          optimize: args.optimize,
         });
         break;
 
+      // ===== v3.7.0 — UPLOAD FROM LOCAL FILESYSTEM =====
+      case "upload_local_file": {
+        try {
+          const fileData = readLocalFileAsDataUri(args.localPath);
+          logToFile(`[upload_local_file] ${args.localPath} (${fileData.size} bytes ${fileData.mime})`);
+          // Le b64 est généré ici, dans le MCP server. Il part vers le plugin
+          // mais ne transite JAMAIS par le contexte AI.
+          result = await callWordPressAPI("/upload-media", "POST", {
+            sourceUrl: fileData.dataUri,
+            title: args.title || fileData.basename.replace(/\.[^.]+$/, ''),
+            alt: args.alt,
+            caption: args.caption,
+            optimize: args.optimize !== false, // défaut true
+          });
+        } catch (err) {
+          result = { success: false, error: err.message, localPath: args.localPath };
+        }
+        break;
+      }
+
+      case "upload_local_files_batch": {
+        const batchItems = [];
+        const readErrors = [];
+        for (const item of (args.items || [])) {
+          try {
+            const fileData = readLocalFileAsDataUri(item.localPath);
+            batchItems.push({
+              sourceUrl: fileData.dataUri,
+              title: item.title || fileData.basename.replace(/\.[^.]+$/, ''),
+              alt: item.alt,
+              caption: item.caption,
+            });
+          } catch (err) {
+            readErrors.push({ localPath: item.localPath, error: err.message });
+          }
+        }
+        if (batchItems.length === 0) {
+          result = {
+            success: false,
+            error: "Aucun fichier lisible",
+            readErrors,
+          };
+          break;
+        }
+        result = await callWordPressAPI("/upload-media-batch", "POST", {
+          items: batchItems,
+          optimize: args.optimize !== false, // défaut true
+        });
+        // Joindre les erreurs de lecture locales au résultat
+        if (readErrors.length > 0) {
+          result.localReadErrors = readErrors;
+        }
+        break;
+      }
+
       default:
         console.error(`[LOG] Tool inconnu: ${name}`);
         result = { error: `Tool ${name} not found` };