get_svg

Instructions

Implementation Reference

• src/talk_to_figma_mcp/tools/svg-tools.ts:59-82 (handler)

  The handler function for the 'get_svg' tool. It receives a nodeId, sends the 'get_svg' command to Figma via WebSocket with a 120s timeout, and returns the SVG markup string as text content.

    async ({ nodeId }) => {
      try {
        const result = await sendCommandToFigma("get_svg", { nodeId }, 120000);
        const typedResult = result as { svgString: string; name: string };
        return {
          content: [
            {
              type: "text",
              text: typedResult.svgString,
            },
          ],
        };
      } catch (error) {
        return {
          content: [
            {
              type: "text",
              text: `Error exporting SVG: ${error instanceof Error ? error.message : String(error)}`,
            },
          ],
        };
      }
    }
  );

• src/talk_to_figma_mcp/tools/svg-tools.ts:53-82 (registration)

  Registration of the 'get_svg' tool on the MCP server via server.tool(), including its description 'Export a single node as an SVG string from Figma' and its schema (nodeId: string).

  server.tool(
    "get_svg",
    "Export a single node as an SVG string from Figma. Returns the SVG markup including all nested children.",
    {
      nodeId: z.string().describe("The ID of the node to export as SVG"),
    },
    async ({ nodeId }) => {
      try {
        const result = await sendCommandToFigma("get_svg", { nodeId }, 120000);
        const typedResult = result as { svgString: string; name: string };
        return {
          content: [
            {
              type: "text",
              text: typedResult.svgString,
            },
          ],
        };
      } catch (error) {
        return {
          content: [
            {
              type: "text",
              text: `Error exporting SVG: ${error instanceof Error ? error.message : String(error)}`,
            },
          ],
        };
      }
    }
  );

• src/talk_to_figma_mcp/tools/svg-tools.ts:56-58 (schema)

  Input schema for 'get_svg': expects a single required 'nodeId' parameter of type z.string().

  {
    nodeId: z.string().describe("The ID of the node to export as SVG"),
  },

• src/talk_to_figma_mcp/utils/websocket.ts:238-297 (helper)

  The sendCommandToFigma function that dispatches the 'get_svg' command over WebSocket to the Figma plugin and returns a promise that resolves with the result (including svgString).

  export function sendCommandToFigma(
    command: FigmaCommand,
    params: unknown = {},
    timeoutMs: number = 300000
  ): Promise<unknown> {
    return new Promise((resolve, reject) => {
      // If not connected, try to connect first
      if (!ws || ws.readyState !== WebSocket.OPEN) {
        connectToFigma();
        reject(new Error("Not connected to Figma. Attempting to connect..."));
        return;
      }
  
      // Check if we need a channel for this command
      const requiresChannel = command !== "join";
      if (requiresChannel && !currentChannel) {
        reject(new Error("Must join a channel before sending commands"));
        return;
      }
  
      const id = uuidv4();
      const request = {
        id,
        type: command === "join" ? "join" : "message",
        ...(command === "join"
          ? { channel: (params as any).channel, sessionId: SESSION_ID }
          : { channel: currentChannel }),
        message: {
          id,
          command,
          params: {
            ...(params as any),
            commandId: id, // Include the command ID in params
          },
        },
      };
  
      // Set timeout for request
      const timeout = setTimeout(() => {
        if (pendingRequests.has(id)) {
          pendingRequests.delete(id);
          logger.error(`Request ${id} to Figma timed out after ${timeoutMs / 1000} seconds`);
          reject(new Error('Request to Figma timed out'));
        }
      }, timeoutMs);
  
      // Store the promise callbacks to resolve/reject later
      pendingRequests.set(id, {
        resolve,
        reject,
        timeout,
        lastActivity: Date.now()
      });
  
      // Send the request
      logger.info(`Sending command to Figma: ${command}`);
      logger.debug(`Request details: ${JSON.stringify(request)}`);
      ws.send(JSON.stringify(request));
    });
  }

• src/talk_to_figma_mcp/tools/index.ts:17-28 (registration)

  The registerTools() function that aggregates all tool registrations; registerSvgTools(server) is called at line 25.

  export function registerTools(server: McpServer): void {
    // Register all tool categories
    registerDocumentTools(server);
    registerCreationTools(server);
    registerModificationTools(server);
    registerTextTools(server);
    registerComponentTools(server);
    registerImageTools(server);
    registerSvgTools(server);
    registerVariableTools(server);
    registerFigJamTools(server);
    registerStyleTools(server);