set_multiple_text_contents

Instructions

Implementation Reference

• src/talk_to_figma_mcp/tools/text-tools.ts:48-154 (handler)

  MCP tool handler for 'set_multiple_text_contents'. Registers the tool via server.tool() with Zod schema validation (nodeId as string, text as coerced JSON array of {nodeId, text} objects). The handler sends the 'set_multiple_text_contents' command to Figma via WebSocket (sendCommandToFigma), then formats progress and detailed results for the response.

  // Set Multiple Text Contents Tool
  server.tool(
    "set_multiple_text_contents",
    "Set multiple text contents parallelly in a node",
    {
      nodeId: z
        .string()
        .describe("The ID of the node containing the text nodes to replace"),
      text: coerceJson(z
        .array(
          z.object({
            nodeId: z.string().describe("The ID of the text node"),
            text: z.string().describe("The replacement text"),
          })
        ))
        .describe("Array of text node IDs and their replacement texts"),
    },
    async ({ nodeId, text }, extra) => {
      try {
        if (!text || text.length === 0) {
          return {
            content: [
              {
                type: "text",
                text: "No text provided",
              },
            ],
          };
        }
  
        // Initial response to indicate we're starting the process
        const initialStatus = {
          type: "text" as const,
          text: `Starting text replacement for ${text.length} nodes. This will be processed in batches of 5...`,
        };
  
        // Track overall progress
        let totalProcessed = 0;
        const totalToProcess = text.length;
  
        // Use the plugin's set_multiple_text_contents function with chunking
        const result = await sendCommandToFigma("set_multiple_text_contents", {
          nodeId,
          text,
        });
  
        // Cast the result to a specific type to work with it safely
        interface TextReplaceResult {
          success: boolean;
          nodeId: string;
          replacementsApplied?: number;
          replacementsFailed?: number;
          totalReplacements?: number;
          completedInChunks?: number;
          results?: Array<{
            success: boolean;
            nodeId: string;
            error?: string;
            originalText?: string;
            translatedText?: string;
          }>;
        }
  
        const typedResult = result as TextReplaceResult;
  
        // Format the results for display
        const success = typedResult.replacementsApplied && typedResult.replacementsApplied > 0;
        const progressText = `
        Text replacement completed:
        - ${typedResult.replacementsApplied || 0} of ${totalToProcess} successfully updated
        - ${typedResult.replacementsFailed || 0} failed
        - Processed in ${typedResult.completedInChunks || 1} batches
        `;
  
        // Detailed results
        const detailedResults = typedResult.results || [];
        const failedResults = detailedResults.filter(item => !item.success);
  
        // Create the detailed part of the response
        let detailedResponse = "";
        if (failedResults.length > 0) {
          detailedResponse = `\n\nNodes that failed:\n${failedResults.map(item =>
            `- ${item.nodeId}: ${item.error || "Unknown error"}`
          ).join('\n')}`;
        }
  
        return {
          content: [
            initialStatus,
            {
              type: "text" as const,
              text: progressText + detailedResponse,
            },
          ],
        };
      } catch (error) {
        return {
          content: [
            {
              type: "text",
              text: `Error setting multiple text contents: ${error instanceof Error ? error.message : String(error)}`,
            },
          ],
        };
      }
    }
  );

• src/talk_to_figma_mcp/tools/text-tools.ts:49-64 (schema)

  Input schema for 'set_multiple_text_contents' using Zod. Requires a nodeId (string) and text (coerced JSON array of objects with nodeId and text fields). The 'coerceJson' wrapper allows JSON string input to be auto-parsed.

  server.tool(
    "set_multiple_text_contents",
    "Set multiple text contents parallelly in a node",
    {
      nodeId: z
        .string()
        .describe("The ID of the node containing the text nodes to replace"),
      text: coerceJson(z
        .array(
          z.object({
            nodeId: z.string().describe("The ID of the text node"),
            text: z.string().describe("The replacement text"),
          })
        ))
        .describe("Array of text node IDs and their replacement texts"),
    },

• src/talk_to_figma_mcp/tools/text-tools.ts:48-49 (registration)

  Registration of the 'set_multiple_text_contents' tool via server.tool(). The tool is registered inside the registerTextTools() function exported from text-tools.ts, which is called from src/talk_to_figma_mcp/tools/index.ts line 22.

  // Set Multiple Text Contents Tool
  server.tool(

• src/talk_to_figma_mcp/utils/schema-helpers.ts:8-14 (helper)

  The 'coerceJson' helper function used in the schema. It wraps a Zod schema with z.preprocess to auto-parse JSON strings, enabling MCP to pass the 'text' parameter as either a JSON string or already-parsed array.

  export const coerceJson = <T extends z.ZodTypeAny>(schema: T) =>
    z.preprocess((val) => {
      if (typeof val === "string") {
        try { return JSON.parse(val); } catch { return val; }
      }
      return val;
    }, schema);

• src/talk_to_figma_mcp/types/index.ts:70-70 (schema)

  Type definition for the FigmaCommand union type, including 'set_multiple_text_contents' as a valid command string, ensuring type safety when sending commands via WebSocket.

  | "set_multiple_text_contents"