figma-code-agent-mcp 1.0.0

package/dist/tools/moveNode.js

@@ -0,0 +1,31 @@
+import { figmaWebSocket } from '../websocket.js';
+export const moveNodeSchema = {
+    name: 'move_node',
+    description: 'Move a node to a new parent or reorder within its current parent. Use index to control position among siblings.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            nodeId: {
+                type: 'string',
+                description: 'ID of the node to move',
+            },
+            parentId: {
+                type: 'string',
+                description: 'ID of the new parent node. If not provided, keeps current parent.',
+            },
+            index: {
+                type: 'number',
+                description: 'Position among siblings (0 = first/top in layer order). If not provided, appends to end.',
+            },
+            returnScreenshot: {
+                type: 'boolean',
+                description: 'If true, returns a screenshot of the moved node for visual verification',
+                default: false,
+            },
+        },
+        required: ['nodeId'],
+    },
+};
+export async function moveNode(params) {
+    return figmaWebSocket.sendCommand('moveNode', params);
+}

package/dist/tools/openInEditor.d.ts

@@ -0,0 +1,21 @@
+export declare const openInEditorSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            editor: {
+                type: string;
+                description: string;
+                enum: string[];
+                default: string;
+            };
+        };
+        required: never[];
+    };
+};
+export declare function openInEditor(params: Record<string, unknown>): Promise<string>;

package/dist/tools/openInEditor.js

@@ -0,0 +1,98 @@
+import { execFile } from 'node:child_process';
+import { access } from 'node:fs/promises';
+import { resolve } from 'node:path';
+export const openInEditorSchema = {
+    name: 'open_in_editor',
+    description: 'Open a workspace folder (or file) in VS Code or WebStorm. Defaults to the current working directory.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            path: {
+                type: 'string',
+                description: 'Absolute or relative path to open. Defaults to the current working directory.',
+            },
+            editor: {
+                type: 'string',
+                description: 'Editor to open with',
+                enum: ['vscode', 'webstorm'],
+                default: 'vscode',
+            },
+        },
+        required: [],
+    },
+};
+const EDITORS = {
+    vscode: {
+        commands: ['code'],
+        name: 'VS Code',
+    },
+    webstorm: {
+        commands: ['webstorm', 'wstorm'],
+        name: 'WebStorm',
+    },
+};
+async function which(command) {
+    return new Promise((resolve) => {
+        execFile('which', [command], (error, stdout) => {
+            resolve(error ? null : stdout.trim());
+        });
+    });
+}
+async function findEditorBinary(editor) {
+    const config = EDITORS[editor];
+    if (!config) {
+        throw new Error(`Unknown editor: ${editor}. Supported: ${Object.keys(EDITORS).join(', ')}`);
+    }
+    for (const cmd of config.commands) {
+        const bin = await which(cmd);
+        if (bin)
+            return cmd;
+    }
+    // macOS fallback: try opening via application name
+    if (process.platform === 'darwin') {
+        const appNames = {
+            vscode: ['Visual Studio Code', 'Visual Studio Code - Insiders'],
+            webstorm: ['WebStorm'],
+        };
+        for (const app of appNames[editor] || []) {
+            try {
+                await access(`/Applications/${app}.app`);
+                return `open -a "${app}"`;
+            }
+            catch { /* not found */ }
+        }
+    }
+    throw new Error(`${config.name} CLI not found. ` +
+        (editor === 'vscode'
+            ? 'Install the "code" command: VS Code → Cmd+Shift+P → "Shell Command: Install \'code\' command in PATH"'
+            : 'Ensure the "webstorm" CLI launcher is installed: WebStorm → Tools → Create Command-line Launcher'));
+}
+export async function openInEditor(params) {
+    const editor = params.editor || 'vscode';
+    const targetPath = resolve(params.path || process.cwd());
+    // Verify path exists
+    await access(targetPath).catch(() => {
+        throw new Error(`Path does not exist: ${targetPath}`);
+    });
+    const bin = await findEditorBinary(editor);
+    return new Promise((resolve, reject) => {
+        // Handle "open -a ..." macOS fallback
+        if (bin.startsWith('open ')) {
+            const parts = bin.split(' ');
+            execFile(parts[0], [...parts.slice(1), targetPath], (error) => {
+                if (error)
+                    reject(new Error(`Failed to open ${EDITORS[editor].name}: ${error.message}`));
+                else
+                    resolve(`Opened ${targetPath} in ${EDITORS[editor].name}`);
+            });
+        }
+        else {
+            execFile(bin, [targetPath], (error) => {
+                if (error)
+                    reject(new Error(`Failed to open ${EDITORS[editor].name}: ${error.message}`));
+                else
+                    resolve(`Opened ${targetPath} in ${EDITORS[editor].name}`);
+            });
+        }
+    });
+}

package/dist/tools/searchNodes.d.ts

@@ -0,0 +1,30 @@
+export declare const searchNodesSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            caseSensitive: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            limit: {
+                type: string;
+                description: string;
+                default: number;
+            };
+        };
+        required: never[];
+    };
+};
+export declare function searchNodes(params: Record<string, unknown>): Promise<unknown>;

package/dist/tools/searchNodes.js

@@ -0,0 +1,46 @@
+import { figmaWebSocket } from '../websocket.js';
+export const searchNodesSchema = {
+    name: 'search_nodes',
+    description: 'Search for nodes in the current page by name, type, or text content. Returns lightweight results with id, name, type, and path in the tree hierarchy.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Search query - matches against node name or text content (case-insensitive)',
+            },
+            type: {
+                type: 'string',
+                description: 'Filter by node type (e.g., FRAME, TEXT, RECTANGLE, INSTANCE, COMPONENT)',
+                enum: [
+                    'FRAME',
+                    'TEXT',
+                    'RECTANGLE',
+                    'ELLIPSE',
+                    'LINE',
+                    'VECTOR',
+                    'INSTANCE',
+                    'COMPONENT',
+                    'COMPONENT_SET',
+                    'GROUP',
+                    'SECTION',
+                    'BOOLEAN_OPERATION',
+                ],
+            },
+            caseSensitive: {
+                type: 'boolean',
+                description: 'Whether search should be case-sensitive (default: false)',
+                default: false,
+            },
+            limit: {
+                type: 'number',
+                description: 'Maximum number of results to return (default: 50)',
+                default: 50,
+            },
+        },
+        required: [],
+    },
+};
+export async function searchNodes(params) {
+    return figmaWebSocket.sendCommand('searchNodes', params);
+}

package/dist/tools/searchTools.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Schema for the search_tools tool — progressive discovery of figma.* API methods.
+ */
+export declare const searchToolsSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            category: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            detail_level: {
+                type: string;
+                enum: string[];
+                description: string;
+                default: string;
+            };
+        };
+        required: string[];
+    };
+};

package/dist/tools/searchTools.js

@@ -0,0 +1,28 @@
+/**
+ * Schema for the search_tools tool — progressive discovery of figma.* API methods.
+ */
+export const searchToolsSchema = {
+    name: 'search_tools',
+    description: 'Search available figma.* API methods for use with the execute tool. Use this to discover method names, parameters, and usage examples.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            query: {
+                type: 'string',
+                description: 'Search query — matches against method names and descriptions (e.g., "create", "layout", "text", "component")',
+            },
+            category: {
+                type: 'string',
+                enum: ['create', 'read', 'update', 'delete', 'tokens', 'components', 'accessibility', 'figjam'],
+                description: 'Filter by operation category. Use "figjam" for FigJam-specific methods (sections, stickies, shapes).',
+            },
+            detail_level: {
+                type: 'string',
+                enum: ['name', 'description', 'full'],
+                description: 'Amount of detail: "name" = just names, "description" = names + descriptions, "full" = everything including parameters and examples. Default: "description"',
+                default: 'description',
+            },
+        },
+        required: ['query'],
+    },
+};

package/dist/tools/swapComponent.d.ts

@@ -0,0 +1,23 @@
+export declare const swapComponentSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            instanceId: {
+                type: string;
+                description: string;
+            };
+            newComponentId: {
+                type: string;
+                description: string;
+            };
+            newComponentKey: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function swapComponent(params: Record<string, unknown>): Promise<unknown>;

package/dist/tools/swapComponent.js

@@ -0,0 +1,26 @@
+import { figmaWebSocket } from '../websocket.js';
+export const swapComponentSchema = {
+    name: 'swap_component',
+    description: 'Swap a component instance to a different component or variant. Use this to change variants or swap nested components within instances.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            instanceId: {
+                type: 'string',
+                description: 'ID of the instance node to swap',
+            },
+            newComponentId: {
+                type: 'string',
+                description: 'ID of the new component to swap to (for local components)',
+            },
+            newComponentKey: {
+                type: 'string',
+                description: 'Key of the new component to swap to (for library components)',
+            },
+        },
+        required: ['instanceId'],
+    },
+};
+export async function swapComponent(params) {
+    return figmaWebSocket.sendCommand('swapComponent', params);
+}

package/dist/tools/updateNode.d.ts

@@ -0,0 +1,194 @@
+export declare const updateNodeSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            nodeId: {
+                type: string;
+                description: string;
+            };
+            properties: {
+                type: string;
+                description: string;
+                properties: {
+                    name: {
+                        type: string;
+                        description: string;
+                    };
+                    x: {
+                        type: string;
+                        description: string;
+                    };
+                    y: {
+                        type: string;
+                        description: string;
+                    };
+                    width: {
+                        type: string;
+                        description: string;
+                    };
+                    height: {
+                        type: string;
+                        description: string;
+                    };
+                    fillColor: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            r: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            g: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            b: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            a: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                                default: number;
+                            };
+                        };
+                        required: string[];
+                    };
+                    opacity: {
+                        type: string;
+                        description: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                    visible: {
+                        type: string;
+                        description: string;
+                    };
+                    locked: {
+                        type: string;
+                        description: string;
+                    };
+                    text: {
+                        type: string;
+                        description: string;
+                    };
+                    fontSize: {
+                        type: string;
+                        description: string;
+                    };
+                    fontWeight: {
+                        type: string;
+                        description: string;
+                    };
+                    cornerRadius: {
+                        type: string;
+                        description: string;
+                    };
+                    strokeColor: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            r: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            g: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            b: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                            };
+                            a: {
+                                type: string;
+                                minimum: number;
+                                maximum: number;
+                                default: number;
+                            };
+                        };
+                        required: string[];
+                    };
+                    strokeWeight: {
+                        type: string;
+                        description: string;
+                    };
+                    copyFillsFrom: {
+                        type: string;
+                        description: string;
+                    };
+                    copyStrokesFrom: {
+                        type: string;
+                        description: string;
+                    };
+                    layoutMode: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                    primaryAxisSizingMode: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                    counterAxisSizingMode: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                    primaryAxisAlignItems: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                    counterAxisAlignItems: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                    itemSpacing: {
+                        type: string;
+                        description: string;
+                    };
+                    paddingTop: {
+                        type: string;
+                        description: string;
+                    };
+                    paddingBottom: {
+                        type: string;
+                        description: string;
+                    };
+                    paddingLeft: {
+                        type: string;
+                        description: string;
+                    };
+                    paddingRight: {
+                        type: string;
+                        description: string;
+                    };
+                    layoutWrap: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                };
+            };
+            returnScreenshot: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function updateNode(params: Record<string, unknown>): Promise<unknown>;