@dannote/figma-use 0.1.4 → 0.2.0

package/dist/proxy/index.js

@@ -19398,6 +19398,14 @@ var consola = createConsola2();
 
 // packages/proxy/src/index.ts
 var PORT = Number(process.env.PORT) || 38451;
+var TIMEOUT_LIGHT = 1e4;
+var TIMEOUT_HEAVY = 120000;
+var HEAVY_COMMANDS = new Set([
+  "export-node",
+  "screenshot",
+  "export-selection",
+  "eval"
+]);
 var pendingRequests = new Map;
 var sendToPlugin = null;
 new Elysia().ws("/plugin", {
@@ -19428,15 +19436,18 @@ new Elysia().ws("/plugin", {
   if (!sendToPlugin) {
     return { error: "Plugin not connected" };
   }
-  const { command, args } = body;
+  const { command, args, timeout: customTimeout } = body;
   const id = crypto.randomUUID();
   consola.info(`${command}`, args || "");
   try {
+    const defaultTimeout = HEAVY_COMMANDS.has(command) ? TIMEOUT_HEAVY : TIMEOUT_LIGHT;
+    const timeoutMs = customTimeout || defaultTimeout;
+    consola.info(`Timeout: ${timeoutMs}ms (custom: ${customTimeout}, default: ${defaultTimeout})`);
     const result = await new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         pendingRequests.delete(id);
         reject(new Error("Request timeout"));
-      }, 1e4);
+      }, timeoutMs);
       pendingRequests.set(id, { resolve, reject, timeout });
       sendToPlugin(JSON.stringify({ id, command, args }));
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dannote/figma-use",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Control Figma from the command line. Full read/write access for AI agents.",
   "type": "module",
   "bin": {
@@ -19,7 +19,9 @@
     "bin",
     "dist",
     "packages/plugin/dist",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md",
+    "SKILL.md"
   ],
   "keywords": [
     "figma",

package/packages/plugin/dist/main.js

@@ -64,6 +64,21 @@
           const node = yield figma.getNodeByIdAsync(id);
           return node ? serializeNode(node) : null;
         }
+        case "get-current-page":
+          return { id: figma.currentPage.id, name: figma.currentPage.name };
+        case "get-node-tree": {
+          const { id } = args;
+          const node = yield figma.getNodeByIdAsync(id);
+          if (!node) throw new Error("Node not found");
+          const serializeTree = (n) => {
+            const base = serializeNode(n);
+            if ("children" in n && n.children) {
+              base.children = n.children.map(serializeTree);
+            }
+            return base;
+          };
+          return serializeTree(node);
+        }
         case "get-all-components": {
           const components = [];
           figma.root.findAll((node) => {
@@ -120,7 +135,7 @@
               result.effectStyles = styles.map((s) => ({
                 id: s.id,
                 name: s.name,
-                effects: s.effects.map((e) => ({ type: e.type, radius: e.radius }))
+                effects: s.effects.map((e) => ({ type: e.type, radius: "radius" in e ? e.radius : void 0 }))
               }));
             }
           }
@@ -337,6 +352,7 @@
           } else if (type === "BLUR" || type === "BACKGROUND_BLUR") {
             style.effects = [{
               type,
+              blurType: "NORMAL",
               radius: radius || 10,
               visible: true
             }];
@@ -368,10 +384,12 @@
           return serializeNode(node);
         }
         case "set-stroke-color": {
-          const { id, color } = args;
+          const { id, color, weight, align } = args;
           const node = yield figma.getNodeByIdAsync(id);
           if (!node || !("strokes" in node)) throw new Error("Node not found");
           node.strokes = [{ type: "SOLID", color: hexToRgb(color) }];
+          if (weight !== void 0 && "strokeWeight" in node) node.strokeWeight = weight;
+          if (align && "strokeAlign" in node) node.strokeAlign = align;
           return serializeNode(node);
         }
         case "set-corner-radius": {
@@ -444,6 +462,7 @@
           } else if (type === "BLUR") {
             node.effects = [{
               type: "LAYER_BLUR",
+              blurType: "NORMAL",
               radius: radius != null ? radius : 8,
               visible: true
             }];
@@ -603,7 +622,7 @@
           const { id, angle } = args;
           const node = yield figma.getNodeByIdAsync(id);
           if (!node) throw new Error("Node not found");
-          node.rotation = angle;
+          if ("rotation" in node) node.rotation = angle;
           return serializeNode(node);
         }
         case "set-stroke-align": {
@@ -825,7 +844,7 @@
               }
             }
           }
-          const bytes = yield frame.exportAsync({ format: "PNG", scale: scale || 1 });
+          const bytes = yield frame.exportAsync({ format: "PNG", constraint: { type: "SCALE", value: scale || 1 } });
           frame.remove();
           return { data: figma.base64Encode(bytes) };
         }
@@ -888,6 +907,79 @@
           const fn = new AsyncFunction("figma", wrappedCode);
           return yield fn(figma);
         }
+        // ==================== VARIABLES ====================
+        case "get-variables": {
+          const { type } = args;
+          const variables = yield figma.variables.getLocalVariablesAsync(type);
+          return variables.map((v) => serializeVariable(v));
+        }
+        case "get-variable": {
+          const { id } = args;
+          const variable = yield figma.variables.getVariableByIdAsync(id);
+          if (!variable) throw new Error("Variable not found");
+          return serializeVariable(variable);
+        }
+        case "create-variable": {
+          const { name, collectionId, type, value } = args;
+          const collection = yield figma.variables.getVariableCollectionByIdAsync(collectionId);
+          if (!collection) throw new Error("Collection not found");
+          const variable = figma.variables.createVariable(name, collection, type);
+          if (value !== void 0 && collection.modes.length > 0) {
+            const modeId = collection.modes[0].modeId;
+            variable.setValueForMode(modeId, parseVariableValue(value, type));
+          }
+          return serializeVariable(variable);
+        }
+        case "set-variable-value": {
+          const { id, modeId, value } = args;
+          const variable = yield figma.variables.getVariableByIdAsync(id);
+          if (!variable) throw new Error("Variable not found");
+          variable.setValueForMode(modeId, parseVariableValue(value, variable.resolvedType));
+          return serializeVariable(variable);
+        }
+        case "delete-variable": {
+          const { id } = args;
+          const variable = yield figma.variables.getVariableByIdAsync(id);
+          if (!variable) throw new Error("Variable not found");
+          variable.remove();
+          return { deleted: true };
+        }
+        case "bind-variable": {
+          const { nodeId, field, variableId } = args;
+          const node = yield figma.getNodeByIdAsync(nodeId);
+          if (!node) throw new Error("Node not found");
+          const variable = yield figma.variables.getVariableByIdAsync(variableId);
+          if (!variable) throw new Error("Variable not found");
+          if ("setBoundVariable" in node) {
+            node.setBoundVariable(field, variable);
+          } else {
+            throw new Error("Node does not support variable binding");
+          }
+          return serializeNode(node);
+        }
+        // ==================== VARIABLE COLLECTIONS ====================
+        case "get-variable-collections": {
+          const collections = yield figma.variables.getLocalVariableCollectionsAsync();
+          return collections.map((c) => serializeCollection(c));
+        }
+        case "get-variable-collection": {
+          const { id } = args;
+          const collection = yield figma.variables.getVariableCollectionByIdAsync(id);
+          if (!collection) throw new Error("Collection not found");
+          return serializeCollection(collection);
+        }
+        case "create-variable-collection": {
+          const { name } = args;
+          const collection = figma.variables.createVariableCollection(name);
+          return serializeCollection(collection);
+        }
+        case "delete-variable-collection": {
+          const { id } = args;
+          const collection = yield figma.variables.getVariableCollectionByIdAsync(id);
+          if (!collection) throw new Error("Collection not found");
+          collection.remove();
+          return { deleted: true };
+        }
         default:
           throw new Error(`Unknown command: ${command}`);
       }
@@ -1004,4 +1096,49 @@
       a: hasAlpha ? parseInt(clean.slice(6, 8), 16) / 255 : 1
     };
   }
+  function serializeVariable(v) {
+    return {
+      id: v.id,
+      name: v.name,
+      type: v.resolvedType,
+      collectionId: v.variableCollectionId,
+      description: v.description || void 0,
+      valuesByMode: Object.fromEntries(
+        Object.entries(v.valuesByMode).map(([modeId, value]) => [
+          modeId,
+          serializeVariableValue(value, v.resolvedType)
+        ])
+      )
+    };
+  }
+  function serializeCollection(c) {
+    return {
+      id: c.id,
+      name: c.name,
+      modes: c.modes.map((m) => ({ modeId: m.modeId, name: m.name })),
+      variableIds: c.variableIds
+    };
+  }
+  function serializeVariableValue(value, type) {
+    if (type === "COLOR" && typeof value === "object" && "r" in value) {
+      return rgbToHex(value);
+    }
+    if (typeof value === "object" && "type" in value && value.type === "VARIABLE_ALIAS") {
+      return { alias: value.id };
+    }
+    return value;
+  }
+  function parseVariableValue(value, type) {
+    switch (type) {
+      case "COLOR":
+        return hexToRgb(value);
+      case "FLOAT":
+        return parseFloat(value);
+      case "BOOLEAN":
+        return value === "true";
+      case "STRING":
+      default:
+        return value;
+    }
+  }
 })();