figma-console-mcp 0.1.0

package/dist/cloudflare/core/logger.js

@@ -0,0 +1,53 @@
+/**
+ * Logging infrastructure using pino
+ */
+import pino from 'pino';
+/**
+ * Create logger instance
+ * Note: In Cloudflare Workers, console methods are automatically captured
+ */
+export function createLogger(level = 'info') {
+    // Check if running in Cloudflare Workers environment
+    const isWorkers = typeof globalThis.caches !== 'undefined';
+    if (isWorkers) {
+        // Cloudflare Workers: use simple console-based logging
+        return pino({
+            level: process.env.LOG_LEVEL || level,
+            browser: {
+                asObject: true,
+            },
+        });
+    }
+    // Node.js environment: detect MCP stdio mode
+    // When stdout is not a TTY, we're likely in MCP stdio mode
+    const isMCPStdio = !process.stdout.isTTY;
+    // MCP stdio mode: NO pretty printing, stderr only
+    if (isMCPStdio) {
+        return pino({ level: process.env.LOG_LEVEL || level }, pino.destination({ dest: 2, sync: false }));
+    }
+    // Development/terminal mode: use pretty printing
+    return pino({
+        level: process.env.LOG_LEVEL || level,
+        transport: process.env.NODE_ENV !== 'production'
+            ? {
+                target: 'pino-pretty',
+                options: {
+                    colorize: true,
+                    translateTime: 'HH:MM:ss',
+                    ignore: 'pid,hostname',
+                    destination: 2, // Explicit stderr for transport
+                },
+            }
+            : undefined,
+    });
+}
+/**
+ * Default logger instance
+ */
+export const logger = createLogger();
+/**
+ * Create child logger with additional context
+ */
+export function createChildLogger(bindings) {
+    return logger.child(bindings);
+}

package/dist/cloudflare/core/snippet-injector.js

@@ -0,0 +1,96 @@
+/**
+ * Snippet Injector
+ * Generates and manages console-based data extraction snippets for Figma
+ */
+import { createChildLogger } from './logger.js';
+const logger = createChildLogger({ component: 'snippet-injector' });
+export class SnippetInjector {
+    /**
+     * Generate variables extraction snippet for Figma console
+     */
+    generateVariablesSnippet() {
+        return `
+(async () => {
+  try {
+    const vars = await figma.variables.getLocalVariablesAsync();
+    const collections = await figma.variables.getLocalVariableCollectionsAsync();
+
+    const payload = {
+      timestamp: Date.now(),
+      variables: vars.map(v => ({
+        id: v.id,
+        name: v.name,
+        key: v.key,
+        resolvedType: v.resolvedType,
+        valuesByMode: v.valuesByMode,
+        variableCollectionId: v.variableCollectionId,
+        scopes: v.scopes,
+        description: v.description,
+        hiddenFromPublishing: v.hiddenFromPublishing
+      })),
+      variableCollections: collections.map(c => ({
+        id: c.id,
+        name: c.name,
+        key: c.key,
+        modes: c.modes.map(m => ({ modeId: m.modeId, name: m.name })),
+        defaultModeId: c.defaultModeId,
+        variableIds: c.variableIds
+      }))
+    };
+
+    console.log('[MCP_VARIABLES]', JSON.stringify(payload), '[MCP_VARIABLES_END]');
+    console.log('✅ Variables data captured! Run figma_get_variables({ parseFromConsole: true }) in Claude to retrieve.');
+
+  } catch (error) {
+    console.error('[MCP_VARIABLES_ERROR]', error.message);
+    console.log('❌ Make sure you\\'re running this in a Figma file with variables.');
+  }
+})();
+		`.trim();
+    }
+    /**
+     * Parse variables from console log entry
+     */
+    parseVariablesFromLog(logEntry) {
+        try {
+            // Check for marker
+            if (!logEntry.message.includes('[MCP_VARIABLES]')) {
+                return null;
+            }
+            // Extract JSON from args
+            // The snippet logs: console.log('[MCP_VARIABLES]', JSON.stringify(payload), '[MCP_VARIABLES_END]')
+            // So args[0] is the marker, args[1] is the JSON string
+            const jsonStr = logEntry.args[1] || logEntry.args[0];
+            if (!jsonStr) {
+                throw new Error('No data found in console log');
+            }
+            const data = typeof jsonStr === 'string' ? JSON.parse(jsonStr) : jsonStr;
+            logger.info({
+                variableCount: data.variables?.length || 0,
+                collectionCount: data.variableCollections?.length || 0,
+            }, 'Successfully parsed variables from console log');
+            return {
+                variables: data.variables || [],
+                variableCollections: data.variableCollections || [],
+                timestamp: data.timestamp || Date.now(),
+            };
+        }
+        catch (error) {
+            logger.error({ error }, 'Failed to parse variables from console log');
+            throw new Error(`Failed to parse variables from console log: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Find the most recent variables log entry
+     */
+    findVariablesLog(logs) {
+        // Search in reverse (most recent first)
+        for (let i = logs.length - 1; i >= 0; i--) {
+            const log = logs[i];
+            if (log.message.includes('[MCP_VARIABLES]')) {
+                return log;
+            }
+        }
+        return null;
+    }
+}

package/dist/cloudflare/core/types/enriched.js

@@ -0,0 +1,5 @@
+/**
+ * TypeScript types for enriched Figma data responses
+ * Phase 5: Enriched Data Extraction & Design System Auditing
+ */
+export {};

package/dist/cloudflare/core/types/index.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for Figma Console MCP
+ */
+export {};