@nbakka/mcp-appium 2.0.39 → 2.0.41

package/lib/server.js

@@ -374,8 +374,8 @@ const createMcpServer = () => {
             extractTextFromADF(issue.fields.description) :
             'No description available';
 
-          // Extract Figma links from description
-          const figmaLinks = extractFigmaLinks(description);
+          // Extract Figma links directly from ADF structure
+          const figmaLinks = extractFigmaLinksFromADF(issue.fields.description);
 
           // Format response
           const result = {
@@ -431,17 +431,225 @@ const createMcpServer = () => {
       return text.trim();
     }
 
-    // Helper function to extract Figma links from text
-    function extractFigmaLinks(text) {
-      if (!text || typeof text !== 'string') {
+    // Helper function to extract Figma links directly from ADF structure
+    function extractFigmaLinksFromADF(adfContent) {
+      if (!adfContent || typeof adfContent !== 'object') {
         return [];
       }
 
-      // Regular expression to match Figma URLs
-      const figmaRegex = /https?:\/\/(?:www\.)?figma\.com\/[^\s<>"{}|\\^`\[\]]+/gi;
-      const matches = text.match(figmaRegex);
+      const figmaLinks = [];
+
+      function traverse(node) {
+        // Check for inlineCard nodes with Figma URLs
+        if (node.type === 'inlineCard' && node.attrs && node.attrs.url) {
+          const url = node.attrs.url;
+          if (url.includes('figma.com')) {
+            figmaLinks.push(url);
+          }
+        }
+
+        // Check for link marks with Figma URLs
+        if (node.marks && Array.isArray(node.marks)) {
+          node.marks.forEach(mark => {
+            if (mark.type === 'link' && mark.attrs && mark.attrs.href) {
+              const href = mark.attrs.href;
+              if (href.includes('figma.com')) {
+                figmaLinks.push(href);
+              }
+            }
+          });
+        }
+
+        // Traverse child content
+        if (node.content && Array.isArray(node.content)) {
+          node.content.forEach(traverse);
+        }
+      }
+
+      if (adfContent.content) {
+        adfContent.content.forEach(traverse);
+      }
+
+      // Remove duplicates and return
+      return [...new Set(figmaLinks)];
+    }
+
+    tool(
+      "mobile_export_figma_images",
+      "Export all frames from Figma file as PNG images with sequential naming",
+      {
+        figmaUrl: zod_1.z.string().describe("The Figma file URL to export frames from")
+      },
+      async ({ figmaUrl }) => {
+        try {
+          // Read Figma credentials from desktop/figma.json file
+          const figmaConfigPath = path.join(os.homedir(), 'Desktop', 'figma.json');
+
+          let figmaConfig;
+          try {
+            const configContent = await fs.readFile(figmaConfigPath, 'utf-8');
+            figmaConfig = JSON.parse(configContent);
+          } catch (error) {
+            throw new Error(`Failed to read Figma config from ${figmaConfigPath}: ${error.message}`);
+          }
+
+          // Extract API token from config
+          const { token: figmaToken } = figmaConfig;
+
+          if (!figmaToken) {
+            throw new Error('Figma API token not found in figma.json file. Please ensure the file contains "token" field.');
+          }
+
+          // Extract file ID from Figma URL
+          const fileId = extractFileIdFromUrl(figmaUrl);
+          if (!fileId) {
+            throw new Error('Invalid Figma URL. Unable to extract file ID.');
+          }
+
+          // Set up export directory
+          const exportPath = path.join(os.homedir(), 'Desktop', 'figma');
+
+          // Create export directory if it doesn't exist
+          await fs.mkdir(exportPath, { recursive: true });
+
+          // Clear existing PNG files in the directory
+          try {
+            const existingFiles = await fs.readdir(exportPath);
+            const pngFiles = existingFiles.filter(file => file.endsWith('.png'));
+            for (const file of pngFiles) {
+              await fs.unlink(path.join(exportPath, file));
+            }
+          } catch (cleanupError) {
+            // Continue if cleanup fails
+            console.log('Could not clean existing files:', cleanupError.message);
+          }
+
+          // Get file information
+          console.log('Fetching Figma file information...');
+          const fileResponse = await axios.get(
+            `https://api.figma.com/v1/files/${fileId}`,
+            {
+              headers: {
+                'X-Figma-Token': figmaToken
+              }
+            }
+          );
+
+          const fileData = fileResponse.data;
+
+          // Extract only frame node IDs
+          const frameIds = extractFrameNodes(fileData.document);
+
+          if (frameIds.length === 0) {
+            return `No frames found in Figma file.`;
+          }
+
+          console.log(`Found ${frameIds.length} frames. Starting export...`);
+
+          // Request image exports for frames only
+          const exportResponse = await axios.get(
+            `https://api.figma.com/v1/images/${fileId}`,
+            {
+              headers: {
+                'X-Figma-Token': figmaToken
+              },
+              params: {
+                ids: frameIds.join(','),
+                format: 'png',
+                scale: 2
+              }
+            }
+          );
+
+          const imageUrls = exportResponse.data.images;
+          let successCount = 0;
+
+          // Download and save each image with sequential naming
+          for (let i = 0; i < frameIds.length; i++) {
+            const nodeId = frameIds[i];
+            const imageUrl = imageUrls[nodeId];
+
+            if (imageUrl) {
+              try {
+                const filename = `${i + 1}.png`;
+                const filepath = path.join(exportPath, filename);
+
+                // Download image
+                const imageResponse = await axios.get(imageUrl, {
+                  responseType: 'arraybuffer'
+                });
+
+                // Save image to file
+                await fs.writeFile(filepath, imageResponse.data);
+                successCount++;
+
+                console.log(`Exported: ${filename}`);
+              } catch (downloadError) {
+                console.error(`Failed to download frame ${i + 1}:`, downloadError.message);
+              }
+            }
+          }
+
+          return `Figma Export Complete!
+    Export Path: ${exportPath}
+    Successfully exported: ${successCount}/${frameIds.length} frames as PNG files
+    Files: ${Array.from({length: successCount}, (_, i) => `${i + 1}.png`).join(', ')}`;
+
+        } catch (error) {
+          if (error.response && error.response.status === 403) {
+            return `Error: Access denied. Please check your Figma API token and file permissions.`;
+          } else if (error.response && error.response.status === 404) {
+            return `Error: Figma file not found. Please check the URL and ensure the file is accessible.`;
+          } else {
+            return `Error exporting from Figma: ${error.message}`;
+          }
+        }
+      }
+    );
+
+    // Helper function to extract file ID from Figma URL
+    function extractFileIdFromUrl(url) {
+      const patterns = [
+        /figma\.com\/file\/([a-zA-Z0-9]+)/,
+        /figma\.com\/design\/([a-zA-Z0-9]+)/,
+        /figma\.com\/proto\/([a-zA-Z0-9]+)/
+      ];
+
+      for (const pattern of patterns) {
+        const match = url.match(pattern);
+        if (match) {
+          return match[1];
+        }
+      }
+      return null;
+    }
+
+    // Helper function to extract only frame node IDs
+    function extractFrameNodes(document) {
+      const frameIds = [];
+
+      function traverse(node) {
+        // Only collect frames, not components
+        if (node.type === 'FRAME') {
+          frameIds.push(node.id);
+        }
+
+        // Continue traversing children
+        if (node.children && Array.isArray(node.children)) {
+          node.children.forEach(traverse);
+        }
+      }
+
+      // Start traversal from document children (pages)
+      if (document.children && Array.isArray(document.children)) {
+        document.children.forEach(page => {
+          if (page.children && Array.isArray(page.children)) {
+            page.children.forEach(traverse);
+          }
+        });
+      }
 
-      return matches ? [...new Set(matches)] : []; // Remove duplicates
+      return frameIds;
     }
 
     return server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nbakka/mcp-appium",
-  "version": "2.0.39",
+  "version": "2.0.41",
   "description": "Appium MCP",
   "engines": {
     "node": ">=18"