mcp-figma-toolkit 1.0.9 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-figma-toolkit",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "MCP server that enables AI agents to manipulate Figma documents - create shapes, text, styles, components, variables, and more",
   "type": "module",
   "main": "dist/server.js",

package/plugin/plugin.js

@@ -27,16 +27,73 @@ function serializePaints(paints) {
       base.hex = rgbToHex(p.color);
     } else if (p.type && p.type.indexOf("GRADIENT") === 0 && p.gradientStops) {
       base.gradientStops = p.gradientStops.map(function(s) {
-        return {
+        var stop = {
           position: s.position,
           hex: s.color ? rgbToHex(s.color) : null,
           opacity: s.color && s.color.a != null ? s.color.a : 1
         };
+        if (s.boundVariables) {
+          var sbv = {};
+          var stopBVKeys = ["color"];
+          for (var sk in s.boundVariables) {
+            var sb = s.boundVariables[sk];
+            if (sb && sb.id) {
+              sbv[sk] = { type: sb.type, id: sb.id };
+              try {
+                var sv = figma.variables.getVariableById(sb.id);
+                if (sv) { sbv[sk].name = sv.name; sbv[sk].resolvedType = sv.resolvedType; }
+              } catch (_) {}
+            }
+          }
+          for (var si = 0; si < stopBVKeys.length; si++) {
+            var spk = stopBVKeys[si];
+            if (!(spk in sbv)) {
+              try {
+                var spb = s.boundVariables[spk];
+                if (spb && spb.id) {
+                  sbv[spk] = { type: spb.type, id: spb.id };
+                  var spv = figma.variables.getVariableById(spb.id);
+                  if (spv) { sbv[spk].name = spv.name; sbv[spk].resolvedType = spv.resolvedType; }
+                }
+              } catch (_) {}
+            }
+          }
+          if (Object.keys(sbv).length > 0) stop.boundVariables = sbv;
+        }
+        return stop;
       });
     } else if (p.type === "IMAGE") {
       base.scaleMode = p.scaleMode;
       base.imageHash = p.imageHash;
     }
+    if (p.boundVariables) {
+      var pbv = {};
+      var paintBVKeys = ["color", "opacity"];
+      for (var pk in p.boundVariables) {
+        var pb = p.boundVariables[pk];
+        if (pb && pb.id) {
+          pbv[pk] = { type: pb.type, id: pb.id };
+          try {
+            var pv = figma.variables.getVariableById(pb.id);
+            if (pv) { pbv[pk].name = pv.name; pbv[pk].resolvedType = pv.resolvedType; }
+          } catch (_) {}
+        }
+      }
+      for (var pi = 0; pi < paintBVKeys.length; pi++) {
+        var ppk = paintBVKeys[pi];
+        if (!(ppk in pbv)) {
+          try {
+            var ppb = p.boundVariables[ppk];
+            if (ppb && ppb.id) {
+              pbv[ppk] = { type: ppb.type, id: ppb.id };
+              var ppv = figma.variables.getVariableById(ppb.id);
+              if (ppv) { pbv[ppk].name = ppv.name; pbv[ppk].resolvedType = ppv.resolvedType; }
+            }
+          } catch (_) {}
+        }
+      }
+      if (Object.keys(pbv).length > 0) base.boundVariables = pbv;
+    }
     return base;
   });
 }
@@ -53,6 +110,22 @@ function serializeEffects(effects) {
       base.hex = rgbToHex(e.color);
       base.opacity = e.color.a != null ? e.color.a : 1;
     }
+    if (e.boundVariables) {
+      var ebv = {};
+      var ebvKeys = ["radius", "spread", "color", "offsetX", "offsetY"];
+      for (var ei = 0; ei < ebvKeys.length; ei++) {
+        var ek = ebvKeys[ei];
+        try {
+          var eb = e.boundVariables[ek];
+          if (eb && eb.id) {
+            ebv[ek] = { type: eb.type, id: eb.id };
+            var ev = figma.variables.getVariableById(eb.id);
+            if (ev) { ebv[ek].name = ev.name; ebv[ek].resolvedType = ev.resolvedType; }
+          }
+        } catch (_) {}
+      }
+      if (Object.keys(ebv).length > 0) base.boundVariables = ebv;
+    }
     return base;
   });
 }
@@ -718,6 +791,45 @@ function getNodeInfo({ nodeId }) {
     try { info.effects = serializeEffects(node.effects); } catch (_) {}
   }
 
+  // Constraints
+  if ("constraints" in node) {
+    info.constraints = {
+      horizontal: node.constraints.horizontal,
+      vertical: node.constraints.vertical
+    };
+  }
+
+  // Clips content (for frames)
+  if ("clipsContent" in node) info.clipsContent = node.clipsContent;
+
+  // Layout positioning within auto-layout parent
+  if ("layoutAlign" in node) info.layoutAlign = node.layoutAlign;
+  if ("layoutGrow" in node) info.layoutGrow = node.layoutGrow;
+  if ("layoutPositioning" in node) info.layoutPositioning = node.layoutPositioning;
+
+  // Style IDs (paint styles, text styles, effect styles)
+  if ("fillStyleId" in node && node.fillStyleId && node.fillStyleId !== "") {
+    info.fillStyleId = node.fillStyleId;
+  }
+  if ("strokeStyleId" in node && node.strokeStyleId && node.strokeStyleId !== "") {
+    info.strokeStyleId = node.strokeStyleId;
+  }
+  if ("effectStyleId" in node && node.effectStyleId && node.effectStyleId !== "") {
+    info.effectStyleId = node.effectStyleId;
+  }
+  if ("textStyleId" in node && node.textStyleId && node.textStyleId !== "") {
+    info.textStyleId = node.textStyleId;
+  }
+
+  // Mask
+  if ("isMask" in node) info.isMask = node.isMask;
+
+  // Min/max size
+  if ("minWidth" in node && node.minWidth != null) info.minWidth = node.minWidth;
+  if ("maxWidth" in node && node.maxWidth != null) info.maxWidth = node.maxWidth;
+  if ("minHeight" in node && node.minHeight != null) info.minHeight = node.minHeight;
+  if ("maxHeight" in node && node.maxHeight != null) info.maxHeight = node.maxHeight;
+
   // Auto-layout properties
   if ("layoutMode" in node && node.layoutMode !== "NONE") {
     info.autoLayout = {
@@ -731,7 +843,8 @@ function getNodeInfo({ nodeId }) {
       primaryAxisAlignItems: node.primaryAxisAlignItems,
       counterAxisAlignItems: node.counterAxisAlignItems,
       layoutSizingHorizontal: node.layoutSizingHorizontal,
-      layoutSizingVertical: node.layoutSizingVertical
+      layoutSizingVertical: node.layoutSizingVertical,
+      layoutWrap: node.layoutWrap
     };
   }
 
@@ -783,10 +896,25 @@ function getNodeInfo({ nodeId }) {
     try {
       var bv = node.boundVariables;
       var bvResult = {};
-      for (var key in bv) {
-        var binding = bv[key];
+      var knownBVKeys = [
+        "fills", "strokes", "effects",
+        "layoutGrids", "componentProperties",
+        "fontSize", "fontFamily", "fontStyle", "fontWeight",
+        "lineHeight", "letterSpacing", "paragraphSpacing", "paragraphIndent",
+        "textCase", "textDecoration",
+        "visible", "opacity",
+        "topLeftRadius", "topRightRadius", "bottomLeftRadius", "bottomRightRadius",
+        "itemSpacing", "counterAxisSpacing",
+        "paddingLeft", "paddingRight", "paddingTop", "paddingBottom",
+        "strokeWeight", "strokeTopWeight", "strokeBottomWeight", "strokeLeftWeight", "strokeRightWeight",
+        "width", "height",
+        "minWidth", "maxWidth", "minHeight", "maxHeight",
+        "characters"
+      ];
+
+      function extractBinding(binding) {
         if (Array.isArray(binding)) {
-          bvResult[key] = binding.map(function(b) {
+          return binding.map(function(b) {
             var entry = { type: b.type, id: b.id };
             try {
               var v = figma.variables.getVariableById(b.id);
@@ -795,10 +923,31 @@ function getNodeInfo({ nodeId }) {
             return entry;
           });
         } else if (binding && binding.id) {
-          bvResult[key] = { type: binding.type, id: binding.id };
+          var single = { type: binding.type, id: binding.id };
           try {
             var v2 = figma.variables.getVariableById(binding.id);
-            if (v2) { bvResult[key].name = v2.name; bvResult[key].resolvedType = v2.resolvedType; }
+            if (v2) { single.name = v2.name; single.resolvedType = v2.resolvedType; }
+          } catch (_) {}
+          return single;
+        }
+        return null;
+      }
+
+      // First try for...in (catches any enumerable keys)
+      for (var key in bv) {
+        var result = extractBinding(bv[key]);
+        if (result != null) bvResult[key] = result;
+      }
+      // Supplement with explicit key access (Figma proxies may not enumerate all keys)
+      for (var ki = 0; ki < knownBVKeys.length; ki++) {
+        var bvKey = knownBVKeys[ki];
+        if (!(bvKey in bvResult)) {
+          try {
+            var val = bv[bvKey];
+            if (val != null) {
+              var r = extractBinding(val);
+              if (r != null) bvResult[bvKey] = r;
+            }
           } catch (_) {}
         }
       }