appiq-solution 1.4.7 → 1.4.9

package/#Tools/claude-talk-to-figma-mcp/src/talk_to_figma_mcp/utils/figma-helpers.ts

@@ -1,142 +0,0 @@
-/**
- * Utilidades para el procesamiento de nodos y respuestas de Figma
- */
-
-/**
- * Convierte un color RGBA a formato hexadecimal.
- * @param color - El color en formato RGBA con valores entre 0 y 1
- * @returns El color en formato hexadecimal (#RRGGBBAA)
- */
-export function rgbaToHex(color: any): string {
-  const r = Math.round(color.r * 255);
-  const g = Math.round(color.g * 255);
-  const b = Math.round(color.b * 255);
-  const a = Math.round(color.a * 255);
-
-  return `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}${a === 255 ? '' : a.toString(16).padStart(2, '0')}`;
-}
-
-/**
- * Filtra un nodo de Figma para reducir su complejidad y tamaño.
- * Convierte colores a formato hexadecimal y elimina datos innecesarios.
- * @param node - El nodo de Figma a filtrar
- * @returns El nodo filtrado o null si debe ser ignorado
- */
-export function filterFigmaNode(node: any) {
-  // Skip VECTOR type nodes
-  if (node.type === "VECTOR") {
-    return null;
-  }
-
-  const filtered: any = {
-    id: node.id,
-    name: node.name,
-    type: node.type,
-  };
-
-  if (node.fills && node.fills.length > 0) {
-    filtered.fills = node.fills.map((fill: any) => {
-      const processedFill = { ...fill };
-
-      // Remove boundVariables and imageRef
-      delete processedFill.boundVariables;
-      delete processedFill.imageRef;
-
-      // Process gradientStops if present
-      if (processedFill.gradientStops) {
-        processedFill.gradientStops = processedFill.gradientStops.map((stop: any) => {
-          const processedStop = { ...stop };
-          // Convert color to hex if present
-          if (processedStop.color) {
-            processedStop.color = rgbaToHex(processedStop.color);
-          }
-          // Remove boundVariables
-          delete processedStop.boundVariables;
-          return processedStop;
-        });
-      }
-
-      // Convert solid fill colors to hex
-      if (processedFill.color) {
-        processedFill.color = rgbaToHex(processedFill.color);
-      }
-
-      return processedFill;
-    });
-  }
-
-  if (node.strokes && node.strokes.length > 0) {
-    filtered.strokes = node.strokes.map((stroke: any) => {
-      const processedStroke = { ...stroke };
-      // Remove boundVariables
-      delete processedStroke.boundVariables;
-      // Convert color to hex if present
-      if (processedStroke.color) {
-        processedStroke.color = rgbaToHex(processedStroke.color);
-      }
-      return processedStroke;
-    });
-  }
-
-  if (node.cornerRadius !== undefined) {
-    filtered.cornerRadius = node.cornerRadius;
-  }
-
-  if (node.absoluteBoundingBox) {
-    filtered.absoluteBoundingBox = node.absoluteBoundingBox;
-  }
-
-  if (node.characters) {
-    filtered.characters = node.characters;
-  }
-
-  if (node.style) {
-    filtered.style = {
-      fontFamily: node.style.fontFamily,
-      fontStyle: node.style.fontStyle,
-      fontWeight: node.style.fontWeight,
-      fontSize: node.style.fontSize,
-      textAlignHorizontal: node.style.textAlignHorizontal,
-      letterSpacing: node.style.letterSpacing,
-      lineHeightPx: node.style.lineHeightPx
-    };
-  }
-
-  if (node.children) {
-    filtered.children = node.children
-      .map((child: any) => filterFigmaNode(child))
-      .filter((child: any) => child !== null); // Remove null children (VECTOR nodes)
-  }
-
-  return filtered;
-}
-
-/**
- * Procesa un nodo de respuesta de Figma para propósitos de logging.
- * @param result - El resultado a procesar
- * @returns El resultado original sin modificaciones
- */
-export function processFigmaNodeResponse(result: unknown): any {
-  if (!result || typeof result !== "object") {
-    return result;
-  }
-
-  // Check if this looks like a node response
-  const resultObj = result as Record<string, unknown>;
-  if ("id" in resultObj && typeof resultObj.id === "string") {
-    // It appears to be a node response, log the details
-    console.info(
-      `Processed Figma node: ${resultObj.name || "Unknown"} (ID: ${resultObj.id})`
-    );
-
-    if ("x" in resultObj && "y" in resultObj) {
-      console.debug(`Node position: (${resultObj.x}, ${resultObj.y})`);
-    }
-
-    if ("width" in resultObj && "height" in resultObj) {
-      console.debug(`Node dimensions: ${resultObj.width}×${resultObj.height}`);
-    }
-  }
-
-  return result;
-}

package/#Tools/claude-talk-to-figma-mcp/src/talk_to_figma_mcp/utils/logger.ts

@@ -1,8 +0,0 @@
-// Custom logging functions that write to stderr instead of stdout to avoid being captured
-export const logger = {
-  info: (message: string) => process.stderr.write(`[INFO] ${message}\n`),
-  debug: (message: string) => process.stderr.write(`[DEBUG] ${message}\n`),
-  warn: (message: string) => process.stderr.write(`[WARN] ${message}\n`),
-  error: (message: string) => process.stderr.write(`[ERROR] ${message}\n`),
-  log: (message: string) => process.stderr.write(`[LOG] ${message}\n`)
-};

package/#Tools/claude-talk-to-figma-mcp/src/talk_to_figma_mcp/utils/websocket.ts

@@ -1,258 +0,0 @@
-import WebSocket from "ws";
-import { v4 as uuidv4 } from "uuid";
-import { logger } from "./logger";
-import { serverUrl, defaultPort, WS_URL, reconnectInterval } from "../config/config";
-import { FigmaCommand, FigmaResponse, CommandProgressUpdate, PendingRequest, ProgressMessage } from "../types";
-
-// WebSocket connection and request tracking
-let ws: WebSocket | null = null;
-let currentChannel: string | null = null;
-
-// Map of pending requests for promise tracking
-const pendingRequests = new Map<string, PendingRequest>();
-
-/**
- * Connects to the Figma server via WebSocket.
- * @param port - Optional port for the connection (defaults to defaultPort from config)
- */
-export function connectToFigma(port: number = defaultPort) {
-  // If already connected, do nothing
-  if (ws && ws.readyState === WebSocket.OPEN) {
-    logger.info('Already connected to Figma');
-    return;
-  }
-
-  // If connection is in progress (CONNECTING state), wait
-  if (ws && ws.readyState === WebSocket.CONNECTING) {
-    logger.info('Connection to Figma is already in progress');
-    return;
-  }
-
-  // If there's an existing socket in a closing state, clean it up
-  if (ws && (ws.readyState === WebSocket.CLOSING || ws.readyState === WebSocket.CLOSED)) {
-    ws.removeAllListeners();
-    ws = null;
-  }
-
-  const wsUrl = serverUrl === 'localhost' ? `${WS_URL}:${port}` : WS_URL;
-  logger.info(`Connecting to Figma socket server at ${wsUrl}...`);
-  
-  try {
-    ws = new WebSocket(wsUrl);
-    
-    // Add connection timeout
-    const connectionTimeout = setTimeout(() => {
-      if (ws && ws.readyState === WebSocket.CONNECTING) {
-        logger.error('Connection to Figma timed out');
-        ws.terminate();
-      }
-    }, 10000); // 10 second connection timeout
-    
-    ws.on('open', () => {
-      clearTimeout(connectionTimeout);
-      logger.info('Connected to Figma socket server');
-      // Reset channel on new connection
-      currentChannel = null;
-    });
-
-    ws.on("message", (data: any) => {
-      try {
-        const json = JSON.parse(data) as ProgressMessage;
-
-        // Handle progress updates
-        if (json.type === 'progress_update') {
-          const progressData = json.message.data as CommandProgressUpdate;
-          const requestId = json.id || '';
-
-          if (requestId && pendingRequests.has(requestId)) {
-            const request = pendingRequests.get(requestId)!;
-
-            // Update last activity timestamp
-            request.lastActivity = Date.now();
-
-            // Reset the timeout to prevent timeouts during long-running operations
-            clearTimeout(request.timeout);
-
-            // Create a new timeout
-            request.timeout = setTimeout(() => {
-              if (pendingRequests.has(requestId)) {
-                logger.error(`Request ${requestId} timed out after extended period of inactivity`);
-                pendingRequests.delete(requestId);
-                request.reject(new Error('Request to Figma timed out'));
-              }
-            }, 60000); // 60 second timeout for inactivity
-
-            // Log progress
-            logger.info(`Progress update for ${progressData.commandType}: ${progressData.progress}% - ${progressData.message}`);
-
-            // For completed updates, we could resolve the request early if desired
-            if (progressData.status === 'completed' && progressData.progress === 100) {
-              // Optionally resolve early with partial data
-              // request.resolve(progressData.payload);
-              // pendingRequests.delete(requestId);
-
-              // Instead, just log the completion, wait for final result from Figma
-              logger.info(`Operation ${progressData.commandType} completed, waiting for final result`);
-            }
-          }
-          return;
-        }
-
-        // Handle regular responses
-        const myResponse = json.message;
-        logger.debug(`Received message: ${JSON.stringify(myResponse)}`);
-        logger.log('myResponse' + JSON.stringify(myResponse));
-
-        // Handle response to a request
-        if (
-          myResponse.id &&
-          pendingRequests.has(myResponse.id) &&
-          myResponse.result
-        ) {
-          const request = pendingRequests.get(myResponse.id)!;
-          clearTimeout(request.timeout);
-
-          if (myResponse.error) {
-            logger.error(`Error from Figma: ${myResponse.error}`);
-            request.reject(new Error(myResponse.error));
-          } else {
-            if (myResponse.result) {
-              request.resolve(myResponse.result);
-            }
-          }
-
-          pendingRequests.delete(myResponse.id);
-        } else {
-          // Handle broadcast messages or events
-          logger.info(`Received broadcast message: ${JSON.stringify(myResponse)}`);
-        }
-      } catch (error) {
-        logger.error(`Error parsing message: ${error instanceof Error ? error.message : String(error)}`);
-      }
-    });
-
-    ws.on('error', (error) => {
-      logger.error(`Socket error: ${error}`);
-      // Don't attempt to reconnect here, let the close handler do it
-    });
-
-    ws.on('close', (code, reason) => {
-      clearTimeout(connectionTimeout);
-      logger.info(`Disconnected from Figma socket server with code ${code} and reason: ${reason || 'No reason provided'}`);
-      ws = null;
-
-      // Reject all pending requests
-      for (const [id, request] of pendingRequests.entries()) {
-        clearTimeout(request.timeout);
-        request.reject(new Error(`Connection closed with code ${code}: ${reason || 'No reason provided'}`));
-        pendingRequests.delete(id);
-      }
-
-      // Attempt to reconnect with exponential backoff
-      const backoff = Math.min(30000, reconnectInterval * Math.pow(1.5, Math.floor(Math.random() * 5))); // Max 30s
-      logger.info(`Attempting to reconnect in ${backoff/1000} seconds...`);
-      setTimeout(() => connectToFigma(port), backoff);
-    });
-    
-  } catch (error) {
-    logger.error(`Failed to create WebSocket connection: ${error instanceof Error ? error.message : String(error)}`);
-    // Attempt to reconnect after a delay
-    setTimeout(() => connectToFigma(port), reconnectInterval);
-  }
-}
-
-/**
- * Join a specific channel in Figma.
- * @param channelName - Name of the channel to join
- * @returns Promise that resolves when successfully joined the channel
- */
-export 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;
-  }
-}
-
-/**
- * Get the current channel the connection is joined to.
- * @returns The current channel name or null if not connected to any channel
- */
-export function getCurrentChannel(): string | null {
-  return currentChannel;
-}
-
-/**
- * Send a command to Figma via WebSocket.
- * @param command - The command to send
- * @param params - Additional parameters for the command
- * @param timeoutMs - Timeout in milliseconds before failing
- * @returns A promise that resolves with the Figma response
- */
-export function sendCommandToFigma(
-  command: FigmaCommand,
-  params: unknown = {},
-  timeoutMs: number = 30000
-): 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 }
-        : { 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));
-  });
-}

package/#Tools/claude-talk-to-figma-mcp/tests/fixtures/test-data.ts

@@ -1,32 +0,0 @@
-import { Color, ColorWithDefaults } from '../../src/talk_to_figma_mcp/types/color';
-
-export const testColors: Record<string, Color> = {
-  fullyTransparent: { r: 1, g: 0, b: 0, a: 0 },
-  fullyOpaque: { r: 1, g: 0, b: 0, a: 1 },
-  semiTransparent: { r: 1, g: 0, b: 0, a: 0.5 },
-  undefinedOpacity: { r: 1, g: 0, b: 0 },
-  
-  pureBlack: { r: 0, g: 0, b: 0, a: 1 },
-  pureWhite: { r: 1, g: 1, b: 1, a: 1 },
-  transparentBlack: { r: 0, g: 0, b: 0, a: 0 },
-  
-  noRed: { r: 0, g: 0.5, b: 0.8, a: 1 },
-  noGreen: { r: 0.5, g: 0, b: 0.8, a: 1 },
-  noBlue: { r: 0.5, g: 0.8, b: 0, a: 1 },
-};
-
-export const expectedColorWithDefaults: Record<string, ColorWithDefaults> = {
-  fullyTransparent: { r: 1, g: 0, b: 0, a: 0 },
-  fullyOpaque: { r: 1, g: 0, b: 0, a: 1 },
-  semiTransparent: { r: 1, g: 0, b: 0, a: 0.5 },
-  undefinedOpacity: { r: 1, g: 0, b: 0, a: 1 },
-  
-  pureBlack: { r: 0, g: 0, b: 0, a: 1 },
-  pureWhite: { r: 1, g: 1, b: 1, a: 1 },
-  transparentBlack: { r: 0, g: 0, b: 0, a: 0 },
-  
-  noRed: { r: 0, g: 0.5, b: 0.8, a: 1 },
-  noGreen: { r: 0.5, g: 0, b: 0.8, a: 1 },
-  noBlue: { r: 0.5, g: 0.8, b: 0, a: 1 },
-};
-