Talk to Figma MCP

Instructions

Implementation Reference

• src/talk_to_figma_mcp/server.ts:2961-3006 (registration)

  MCP tool registration for 'join_channel', including schema and handler function that calls joinChannel to connect to a WebSocket channel for Figma communication.

  server.tool(
    "join_channel",
    "Join a specific channel to communicate with Figma",
    {
      channel: z.string().describe("The name of the channel to join").default(""),
    },
    async ({ channel }) => {
      try {
        if (!channel) {
          // If no channel provided, ask the user for input
          return {
            content: [
              {
                type: "text",
                text: "Please provide a channel name to join:",
              },
            ],
            followUp: {
              tool: "join_channel",
              description: "Join the specified channel",
            },
          };
        }
  
        await joinChannel(channel);
        return {
          content: [
            {
              type: "text",
              text: `Successfully joined channel: ${channel}`,
            },
          ],
        };
      } catch (error) {
        return {
          content: [
            {
              type: "text",
              text: `Error joining channel: ${error instanceof Error ? error.message : String(error)
                }`,
            },
          ],
        };
      }
    }
  );

• src/talk_to_figma_mcp/server.ts:2883-2896 (handler)

  Handler helper function 'joinChannel' that sends the 'join' command via WebSocket to the socket server, setting the current channel.

  async function joinChannel(channelName: string): Promise<void> {
    if (!ws || ws.readyState !== WebSocket.OPEN) {
      throw new Error("Not connected to Figma");
    }
  
    try {
      await sendCommandToFigma("join", { channel: channelName });
      currentChannel = channelName;
      logger.info(`Joined channel: ${channelName}`);
    } catch (error) {
      logger.error(`Failed to join channel: ${error instanceof Error ? error.message : String(error)}`);
      throw error;
    }
  }

• src/talk_to_figma_mcp/server.ts:2964-2965 (schema)

  Zod schema for join_channel tool input: channel name (string, default empty).

  {
    channel: z.string().describe("The name of the channel to join").default(""),

• src/socket.ts:169-176 (helper)

  WebSocket server handles client disconnection from channels (related to join_channel functionality).

        channels.forEach((clients) => {
          clients.delete(ws);
        });
      }
    }
  });
  
  console.log(`WebSocket server running on port ${server.port}`);

• src/socket.ts:80-127 (handler)

  WebSocket server handler for 'join' type messages, which implements the channel joining logic used by the MCP tool.

  if (data.type === "join") {
    const channelName = data.channel;
    if (!channelName || typeof channelName !== "string") {
      ws.send(JSON.stringify({
        type: "error",
        message: "Channel name is required"
      }));
      return;
    }
  
    // Create channel if it doesn't exist
    if (!channels.has(channelName)) {
      channels.set(channelName, new Set());
    }
  
    // Add client to channel
    const channelClients = channels.get(channelName)!;
    channelClients.add(ws);
  
    // Notify client they joined successfully
    ws.send(JSON.stringify({
      type: "system",
      message: `Joined channel: ${channelName}`,
      channel: channelName
    }));
  
    console.log("Sending message to client:", data.id);
  
    ws.send(JSON.stringify({
      type: "system",
      message: {
        id: data.id,
        result: "Connected to channel: " + channelName,
      },
      channel: channelName
    }));
  
    // Notify other clients in channel
    channelClients.forEach((client) => {
      if (client !== ws && client.readyState === WebSocket.OPEN) {
        client.send(JSON.stringify({
          type: "system",
          message: "A new user has joined the channel",
          channel: channelName
        }));
      }
    });
    return;