@biolab/talk-to-figma 0.6.0 → 0.8.0

package/figma-plugin/code.js

@@ -263,6 +263,20 @@ async function handleCommand(command, params) {
       return await createComponent(params);
     case "create_component_set":
       return await createComponentSet(params);
+    case "set_component_text_property":
+      return await setComponentTextProperty(params);
+    case "rename_node":
+      return await renameNode(params);
+    case "rename_nodes":
+      return await renameNodes(params);
+    case "add_boolean_property":
+      return await addBooleanProperty(params);
+    case "add_instance_swap_property":
+      return await addInstanceSwapProperty(params);
+    case "sync_layer_fills":
+      return await syncLayerFills(params);
+    case "move_child_to_index":
+      return await moveChildToIndex(params);
     default:
       throw new Error(`Unknown command: ${command}`);
   }
@@ -1515,20 +1529,42 @@ async function setVariableBinding(params) {
 }
 
 async function createComponentInstance(params) {
-  const { componentKey, x = 0, y = 0 } = params || {};
+  const { componentKey, x = 0, y = 0, parentId } = params || {};
 
   if (!componentKey) {
     throw new Error("Missing componentKey parameter");
   }
 
   try {
-    const component = await figma.importComponentByKeyAsync(componentKey);
+    var component;
+    // If componentKey contains ":", treat as node ID (local component)
+    if (componentKey.indexOf(":") !== -1) {
+      var localNode = await figma.getNodeByIdAsync(componentKey);
+      if (!localNode || localNode.type !== "COMPONENT") {
+        throw new Error("Local component not found with ID: " + componentKey);
+      }
+      component = localNode;
+    } else {
+      // Try import by key (published library components)
+      component = await figma.importComponentByKeyAsync(componentKey);
+    }
     const instance = component.createInstance();
 
     instance.x = x;
     instance.y = y;
 
-    figma.currentPage.appendChild(instance);
+    if (parentId) {
+      const parentNode = await figma.getNodeByIdAsync(parentId);
+      if (!parentNode) {
+        throw new Error(`Parent node not found: ${parentId}`);
+      }
+      if (!("appendChild" in parentNode)) {
+        throw new Error(`Parent node does not support children: ${parentId}`);
+      }
+      parentNode.appendChild(instance);
+    } else {
+      figma.currentPage.appendChild(instance);
+    }
 
     return {
       id: instance.id,
@@ -1646,6 +1682,69 @@ async function createComponentSet(params) {
   }
 }
 
+async function renameNode(params) {
+  var nodeId = (params || {}).nodeId;
+  var name = (params || {}).name;
+
+  if (!nodeId) {
+    throw new Error("Missing nodeId parameter");
+  }
+  if (!name && name !== "") {
+    throw new Error("Missing name parameter");
+  }
+
+  var node = await figma.getNodeByIdAsync(nodeId);
+  if (!node) {
+    throw new Error("Node not found with ID: " + nodeId);
+  }
+
+  node.name = name;
+
+  return {
+    id: node.id,
+    name: node.name,
+    type: node.type,
+  };
+}
+
+async function renameNodes(params) {
+  var nodes = (params || {}).nodes;
+
+  if (!nodes || !Array.isArray(nodes) || nodes.length === 0) {
+    throw new Error("Missing or empty nodes array. Provide [{nodeId, name}].");
+  }
+
+  var results = [];
+  var errors = [];
+
+  for (var i = 0; i < nodes.length; i++) {
+    var item = nodes[i];
+    var nodeId = item.nodeId;
+    var name = item.name;
+
+    if (!nodeId || (!name && name !== "")) {
+      errors.push("Invalid entry at index " + i + ": missing nodeId or name");
+      continue;
+    }
+
+    var node = await figma.getNodeByIdAsync(nodeId);
+    if (!node) {
+      errors.push("Node not found: " + nodeId);
+      continue;
+    }
+
+    node.name = name;
+    results.push({ id: node.id, name: node.name, type: node.type });
+  }
+
+  return {
+    renamed: results.length,
+    errors: errors.length,
+    results: results,
+    errorMessages: errors,
+  };
+}
+
 async function exportNodeAsImage(params) {
   const { nodeId, scale = 1 } = params || {};
 
@@ -4561,3 +4660,390 @@ async function setSelections(params) {
     message: `Selected ${nodes.length} nodes${notFoundIds.length > 0 ? ` (${notFoundIds.length} not found)` : ''}`
   };
 }
+
+async function setComponentTextProperty(params) {
+  const { componentId, propertyName, defaultValue, textNodeIds } = params;
+
+  if (!componentId) throw new Error("Missing componentId parameter");
+  if (!propertyName) throw new Error("Missing propertyName parameter");
+  if (!textNodeIds || !Array.isArray(textNodeIds) || textNodeIds.length === 0) {
+    throw new Error("Missing or empty textNodeIds parameter");
+  }
+
+  const componentNode = await figma.getNodeByIdAsync(componentId);
+  if (!componentNode) {
+    throw new Error(`Node not found with ID: ${componentId}`);
+  }
+
+  if (componentNode.type !== "COMPONENT" && componentNode.type !== "COMPONENT_SET") {
+    throw new Error(`Node ${componentId} is type ${componentNode.type}, expected COMPONENT or COMPONENT_SET`);
+  }
+
+  const results = [];
+  const errors = [];
+
+  // Determine the property owner (ComponentSet or standalone Component)
+  var propertyOwner = componentNode;
+
+  // For ComponentSet, property must be added on the set itself, not variants
+  var propDefault = defaultValue || "Button";
+
+  // Check if property already exists on the property owner
+  var existingProps = propertyOwner.componentPropertyDefinitions;
+  var propertyKey = null;
+
+  for (var key in existingProps) {
+    if (existingProps.hasOwnProperty(key)) {
+      var def = existingProps[key];
+      if (def.type === "TEXT" && key.startsWith(propertyName + "#")) {
+        propertyKey = key;
+        break;
+      }
+    }
+  }
+
+  // Add property on the owner if it doesn't exist
+  if (!propertyKey) {
+    propertyKey = propertyOwner.addComponentProperty(propertyName, "TEXT", propDefault);
+  }
+
+  // Get all component nodes that contain the text nodes
+  var components = [];
+  if (componentNode.type === "COMPONENT_SET") {
+    components = componentNode.children.filter(function(c) { return c.type === "COMPONENT"; });
+  } else {
+    components = [componentNode];
+  }
+
+  for (var i = 0; i < components.length; i++) {
+    var comp = components[i];
+    try {
+      // Find text nodes in this component that match the requested IDs
+      for (var j = 0; j < textNodeIds.length; j++) {
+        var textNodeId = textNodeIds[j];
+        var textNode = comp.findOne(function(n) { return n.id === textNodeId; });
+        if (textNode && textNode.type === "TEXT") {
+          // Load font for the text node
+          await figma.loadFontAsync(textNode.fontName);
+
+          var existingRefs = textNode.componentPropertyReferences || {};
+          var newRefs = Object.assign({}, existingRefs);
+          newRefs.characters = propertyKey;
+          textNode.componentPropertyReferences = newRefs;
+          results.push({
+            componentId: comp.id,
+            componentName: comp.name,
+            textNodeId: textNode.id,
+            propertyKey: propertyKey,
+          });
+        }
+      }
+    } catch (err) {
+      errors.push({
+        componentId: comp.id,
+        componentName: comp.name,
+        error: err.message || String(err),
+      });
+    }
+  }
+
+  return {
+    success: true,
+    linked: results.length,
+    errors: errors.length,
+    propertyKey: propertyKey,
+    results: results,
+    errorDetails: errors,
+    message: "Linked " + results.length + " text nodes to \"" + propertyName + "\" property" + (errors.length > 0 ? " (" + errors.length + " errors)" : ""),
+  };
+}
+
+async function addBooleanProperty(params) {
+  var componentSetId = (params || {}).componentSetId;
+  var propertyName = (params || {}).propertyName;
+  var defaultValue = (params || {}).defaultValue;
+  var layerName = (params || {}).layerName;
+
+  if (!componentSetId) throw new Error("Missing componentSetId parameter");
+  if (!propertyName) throw new Error("Missing propertyName parameter");
+  if (defaultValue === undefined) defaultValue = true;
+  if (!layerName) throw new Error("Missing layerName parameter");
+
+  var componentSet = await figma.getNodeByIdAsync(componentSetId);
+  if (!componentSet) throw new Error("Node not found: " + componentSetId);
+  if (componentSet.type !== "COMPONENT_SET" && componentSet.type !== "COMPONENT") {
+    throw new Error("Node must be COMPONENT_SET or COMPONENT, got " + componentSet.type);
+  }
+
+  // Check if property already exists
+  var existingProps = componentSet.componentPropertyDefinitions;
+  var propertyKey = null;
+  for (var key in existingProps) {
+    if (existingProps.hasOwnProperty(key)) {
+      var def = existingProps[key];
+      if (def.type === "BOOLEAN" && key.startsWith(propertyName + "#")) {
+        propertyKey = key;
+        break;
+      }
+    }
+  }
+
+  if (!propertyKey) {
+    propertyKey = componentSet.addComponentProperty(propertyName, "BOOLEAN", defaultValue);
+  }
+
+  // Find layers matching layerName across all variants and link visibility
+  var components = [];
+  if (componentSet.type === "COMPONENT_SET") {
+    components = componentSet.children.filter(function(c) { return c.type === "COMPONENT"; });
+  } else {
+    components = [componentSet];
+  }
+
+  var linked = 0;
+  var errors = [];
+  for (var i = 0; i < components.length; i++) {
+    var comp = components[i];
+    try {
+      var layer = comp.findOne(function(n) { return n.name === layerName; });
+      if (layer) {
+        var existingRefs = layer.componentPropertyReferences || {};
+        var newRefs = Object.assign({}, existingRefs);
+        newRefs.visible = propertyKey;
+        layer.componentPropertyReferences = newRefs;
+        linked++;
+      }
+    } catch (err) {
+      errors.push(comp.id + ": " + (err.message || String(err)));
+    }
+  }
+
+  return {
+    success: true,
+    propertyKey: propertyKey,
+    linked: linked,
+    totalVariants: components.length,
+    errors: errors,
+    message: "Added BOOLEAN property '" + propertyName + "', linked " + linked + " layers",
+  };
+}
+
+async function addInstanceSwapProperty(params) {
+  var componentSetId = (params || {}).componentSetId;
+  var propertyName = (params || {}).propertyName;
+  var defaultComponentId = (params || {}).defaultComponentId;
+  var layerName = (params || {}).layerName;
+
+  if (!componentSetId) throw new Error("Missing componentSetId parameter");
+  if (!propertyName) throw new Error("Missing propertyName parameter");
+  if (!defaultComponentId) throw new Error("Missing defaultComponentId parameter");
+  if (!layerName) throw new Error("Missing layerName parameter");
+
+  var componentSet = await figma.getNodeByIdAsync(componentSetId);
+  if (!componentSet) throw new Error("Node not found: " + componentSetId);
+  if (componentSet.type !== "COMPONENT_SET" && componentSet.type !== "COMPONENT") {
+    throw new Error("Node must be COMPONENT_SET or COMPONENT, got " + componentSet.type);
+  }
+
+  // Get the default component for the instance swap
+  var defaultComponent = await figma.getNodeByIdAsync(defaultComponentId);
+  if (!defaultComponent || defaultComponent.type !== "COMPONENT") {
+    throw new Error("Default component not found or not a COMPONENT: " + defaultComponentId);
+  }
+
+  // Check if property already exists
+  var existingProps = componentSet.componentPropertyDefinitions;
+  var propertyKey = null;
+  for (var key in existingProps) {
+    if (existingProps.hasOwnProperty(key)) {
+      var def = existingProps[key];
+      if (def.type === "INSTANCE_SWAP" && key.startsWith(propertyName + "#")) {
+        propertyKey = key;
+        break;
+      }
+    }
+  }
+
+  if (!propertyKey) {
+    propertyKey = componentSet.addComponentProperty(propertyName, "INSTANCE_SWAP", defaultComponent.id);
+  }
+
+  // Find instance layers matching layerName across all variants and link
+  var components = [];
+  if (componentSet.type === "COMPONENT_SET") {
+    components = componentSet.children.filter(function(c) { return c.type === "COMPONENT"; });
+  } else {
+    components = [componentSet];
+  }
+
+  var linked = 0;
+  var errors = [];
+  for (var i = 0; i < components.length; i++) {
+    var comp = components[i];
+    try {
+      var layer = comp.findOne(function(n) { return n.name === layerName; });
+      if (layer && layer.type === "INSTANCE") {
+        var existingRefs = layer.componentPropertyReferences || {};
+        var newRefs = Object.assign({}, existingRefs);
+        newRefs.mainComponent = propertyKey;
+        layer.componentPropertyReferences = newRefs;
+        linked++;
+      }
+    } catch (err) {
+      errors.push(comp.id + ": " + (err.message || String(err)));
+    }
+  }
+
+  return {
+    success: true,
+    propertyKey: propertyKey,
+    linked: linked,
+    totalVariants: components.length,
+    errors: errors,
+    message: "Added INSTANCE_SWAP property '" + propertyName + "', linked " + linked + " instances",
+  };
+}
+
+async function syncLayerFills(params) {
+  var componentSetId = (params || {}).componentSetId;
+  var sourceLayerName = (params || {}).sourceLayerName;
+  var targetLayerName = (params || {}).targetLayerName;
+
+  if (!componentSetId) throw new Error("Missing componentSetId parameter");
+  if (!sourceLayerName) throw new Error("Missing sourceLayerName parameter");
+  if (!targetLayerName) throw new Error("Missing targetLayerName parameter");
+
+  var componentSet = await figma.getNodeByIdAsync(componentSetId);
+  if (!componentSet) throw new Error("Node not found: " + componentSetId);
+  if (componentSet.type !== "COMPONENT_SET" && componentSet.type !== "COMPONENT") {
+    throw new Error("Node must be COMPONENT_SET or COMPONENT, got " + componentSet.type);
+  }
+
+  var components = [];
+  if (componentSet.type === "COMPONENT_SET") {
+    components = componentSet.children.filter(function(c) { return c.type === "COMPONENT"; });
+  } else {
+    components = [componentSet];
+  }
+
+  function applyFillsRecursive(node, fills, boundVarFills) {
+    // Apply fills to nodes that support fills (not groups, not pages)
+    if ("fills" in node && node.type !== "GROUP") {
+      try {
+        node.fills = fills;
+        // Copy variable bindings for fills if available
+        if (boundVarFills && boundVarFills.length > 0) {
+          for (var fi = 0; fi < boundVarFills.length; fi++) {
+            var bv = boundVarFills[fi];
+            if (bv && bv.id) {
+              figma.variables.getVariableByIdAsync(bv.id).then(function(variable) {
+                if (variable) {
+                  try { node.setBoundVariable("fills", fi, variable); } catch(e) {}
+                }
+              });
+            }
+          }
+        }
+      } catch (e) {
+        // Some nodes may not support setting fills
+      }
+    }
+    // Recurse into children
+    if ("children" in node) {
+      for (var ci = 0; ci < node.children.length; ci++) {
+        applyFillsRecursive(node.children[ci], fills, boundVarFills);
+      }
+    }
+  }
+
+  var synced = 0;
+  var errors = [];
+  for (var i = 0; i < components.length; i++) {
+    var comp = components[i];
+    try {
+      var sourceLayer = comp.findOne(function(n) { return n.name === sourceLayerName; });
+      var targetLayer = comp.findOne(function(n) { return n.name === targetLayerName; });
+      if (!sourceLayer) {
+        errors.push(comp.id + ": source layer '" + sourceLayerName + "' not found");
+        continue;
+      }
+      if (!targetLayer) {
+        errors.push(comp.id + ": target layer '" + targetLayerName + "' not found");
+        continue;
+      }
+      if (!("fills" in sourceLayer)) {
+        errors.push(comp.id + ": source layer has no fills");
+        continue;
+      }
+
+      var sourceFills = JSON.parse(JSON.stringify(sourceLayer.fills));
+      // Get bound variable references for fills
+      var boundVarFills = [];
+      try {
+        var bv = sourceLayer.boundVariables;
+        if (bv && bv.fills) {
+          boundVarFills = bv.fills;
+        }
+      } catch (e) {}
+
+      applyFillsRecursive(targetLayer, sourceFills, boundVarFills);
+      synced++;
+    } catch (err) {
+      errors.push(comp.id + ": " + (err.message || String(err)));
+    }
+  }
+
+  return {
+    success: true,
+    synced: synced,
+    totalVariants: components.length,
+    errors: errors,
+    message: "Synced fills from '" + sourceLayerName + "' to '" + targetLayerName + "' in " + synced + " variants",
+  };
+}
+
+async function moveChildToIndex(params) {
+  var componentSetId = (params || {}).componentSetId;
+  var layerName = (params || {}).layerName;
+  var targetIndex = (params || {}).targetIndex;
+
+  if (!componentSetId) throw new Error("Missing componentSetId parameter");
+  if (!layerName) throw new Error("Missing layerName parameter");
+  if (targetIndex === undefined) throw new Error("Missing targetIndex parameter");
+
+  var componentSet = await figma.getNodeByIdAsync(componentSetId);
+  if (!componentSet) throw new Error("Node not found: " + componentSetId);
+  if (componentSet.type !== "COMPONENT_SET" && componentSet.type !== "COMPONENT") {
+    throw new Error("Node must be COMPONENT_SET or COMPONENT, got " + componentSet.type);
+  }
+
+  var components = [];
+  if (componentSet.type === "COMPONENT_SET") {
+    components = componentSet.children.filter(function(c) { return c.type === "COMPONENT"; });
+  } else {
+    components = [componentSet];
+  }
+
+  var moved = 0;
+  var errors = [];
+  for (var i = 0; i < components.length; i++) {
+    var comp = components[i];
+    try {
+      var layer = comp.findOne(function(n) { return n.name === layerName; });
+      if (layer) {
+        comp.insertChild(targetIndex, layer);
+        moved++;
+      }
+    } catch (err) {
+      errors.push(comp.id + ": " + (err.message || String(err)));
+    }
+  }
+
+  return {
+    success: true,
+    moved: moved,
+    totalVariants: components.length,
+    errors: errors,
+    message: "Moved '" + layerName + "' to index " + targetIndex + " in " + moved + " variants",
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@biolab/talk-to-figma",
   "description": "Talk to Figma MCP Server",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "module": "dist/server.js",
   "main": "dist/server.js",
   "bin": {