Figma MCP/
├── talk-to-figma/
│   ├── src/
│   │   ├── talk_to_figma_mcp/   # MCP server implementation
│   │   │   └── server.ts
│   │   ├── cursor_mcp_plugin/   # Figma plugin code
│   │   │   ├── manifest.json
│   │   │   ├── ui.html
│   │   │   └── code.ts
│   │   └── socket.ts            # WebSocket server
│   ├── package.json
│   └── readme.md
└── package.json

{
  "mcpServers": {
    "TalkToFigma": {
      "command": "bunx",
      "args": ["cursor-talk-to-figma-mcp@latest"]
    }
  }
}

{
  "mcpServers": {
    "TalkToFigma": {
      "command": "bun",
      "args": ["/path/to/figma-mcp/src/talk_to_figma_mcp/server.ts"]
    }
  }
}

// Example tool definition
const tools = [
  {
    name: 'get_selection',
    description: 'Get currently selected layers in Figma',
    inputSchema: {
      type: 'object',
      properties: {}
    }
  },
  {
    name: 'set_property',
    description: 'Set a property on Figma nodes',
    inputSchema: {
      type: 'object',
      properties: {
        nodeIds: { type: 'array', items: { type: 'string' } },
        property: { type: 'string' },
        value: { type: 'any' }
      },
      required: ['nodeIds', 'property', 'value']
    }
  },
  // ... more tools
];

// socket.ts
import { WebSocketServer } from 'ws';

const wss = new WebSocketServer({ port: 3000 });

wss.on('connection', (ws) => {
  console.log('Figma plugin connected');
  
  ws.on('message', (data) => {
    const message = JSON.parse(data.toString());
    
    if (message.type === 'response') {
      // Forward response to MCP server
      handleMCPResponse(message);
    }
  });
  
  // Send commands from MCP server to Figma
  mcpServer.on('command', (cmd) => {
    ws.send(JSON.stringify(cmd));
  });
});

// cursor_mcp_plugin/code.ts
figma.showUI(__html__, { width: 300, height: 200 });

const ws = new WebSocket('ws://localhost:3000');

ws.onmessage = async (event) => {
  const command = JSON.parse(event.data);
  
  // Execute command in Figma
  const result = await executeCommand(command);
  
  // Send result back
  ws.send(JSON.stringify({
    type: 'response',
    commandId: command.id,
    result
  }));
};

async function executeCommand(command: Command) {
  switch (command.name) {
    case 'get_selection':
      return figma.currentPage.selection.map(node => ({
        id: node.id,
        name: node.name,
        type: node.type
      }));
    
    case 'set_text':
      const textNode = figma.getNodeById(command.nodeId) as TextNode;
      await figma.loadFontAsync(textNode.fontName as FontName);
      textNode.characters = command.text;
      return { success: true };
    
    // ... more commands
  }
}