@locofy/mcp 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# 🤖 AI Development Assistant MCP Server
+
+Welcome to your AI-powered development toolkit, designed as a Model Context Protocol (MCP) server for Cursor! This project provides intelligent coding assistance through custom AI tools.

package/build/api.js

@@ -0,0 +1,32 @@
+import express from 'express';
+import { z } from 'zod';
+import { PullComponentsToolSchema, runPullComponentsTool } from './tools/pullComponents.js';
+// Only start the API server if DEBUG_MODE is set
+if (process.env.DEBUG_MODE === 'true') {
+    const app = express();
+    const port = process.env.PORT || 3000;
+    // Middleware to parse JSON bodies
+    app.use(express.json());
+    // API endpoint for pullComponents
+    app.post('/api/pullComponents', async (req, res) => {
+        try {
+            const validatedArgs = PullComponentsToolSchema.parse(req.body);
+            const result = await runPullComponentsTool(validatedArgs);
+            res.json(result);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError) {
+                res.status(400).json({ error: 'Invalid request body', details: error.errors });
+            }
+            else {
+                console.error('Error processing request:', error);
+                res.status(500).json({ error: 'Internal server error', message: error instanceof Error ? error.message : 'Unknown error' });
+            }
+        }
+    });
+    // Start the server
+    app.listen(port, () => {
+        console.log(`Debug API server running on http://localhost:${port}`);
+    });
+}
+export default {};

package/build/index.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { pullComponentsToolName, pullComponentsToolDescription, PullComponentsToolSchema, runPullComponentsTool } from './tools/pullComponents.js';
+import './api.js';
+const server = new Server({
+    name: 'locofy-mcp',
+    version: '2.0.1',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: pullComponentsToolName,
+                description: pullComponentsToolDescription,
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        componentNames: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                            },
+                            description: 'The list of component or screen names to be retrieved.'
+                        },
+                        workspacePath: {
+                            type: 'string',
+                            description: 'The full path to the workspace.'
+                        },
+                    },
+                    required: ['componentNames', 'workspacePath'],
+                },
+            },
+        ],
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    switch (name) {
+        case pullComponentsToolName: {
+            const validated = PullComponentsToolSchema.parse(args);
+            return await runPullComponentsTool(validated);
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.log('Cursor Tools MCP Server running on stdio');
+    if (process.env.DEBUG_MODE === 'true') {
+        console.log('Debug mode active - REST API available for Postman testing');
+    }
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});

package/build/tools/pullComponents.js

@@ -0,0 +1,180 @@
+import { z } from 'zod';
+import * as fs from 'fs';
+import * as path from 'path';
+import axios from 'axios';
+/**
+ * PullComponents tool
+ *   - Returns a hardcoded representation of a directory structure
+ *   - Contains nested folders, files, and file contents
+ */
+export const pullComponentsToolName = 'locofy';
+export const pullComponentsToolDescription = 'Provides a directory structure with nested folders, files, and their contents, allowing the MCP client to retrieve the code.';
+export const PullComponentsToolSchema = z.object({
+    componentNames: z.array(z.string()).describe('The list of component or screen names to be retrieved.').max(10).min(1),
+    workspacePath: z.string().describe('The full path to the workspace.'),
+});
+export async function runPullComponentsTool(args) {
+    const componentNames = args.componentNames;
+    const workspacePath = decodeURIComponent(args.workspacePath);
+    const projectID = process.env.PROJECT_ID;
+    const personalAccessToken = process.env.PERSONAL_ACCESS_TOKEN;
+    if (!projectID || !personalAccessToken) {
+        throw new Error('PROJECT_ID or PERSONAL_ACCESS_TOKEN is not set');
+    }
+    try {
+        const result = await fetchDirectoryStructure(componentNames, projectID, personalAccessToken);
+        if (result.success) {
+            // Download and save any files referenced in the response
+            await downloadAndSaveAssets(result.data, workspacePath);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result.data, null, 2)
+                    }
+                ]
+            };
+        }
+        else {
+            // Return the error message from fetchDirectoryStructure
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        statusCode: result.statusCode || 'unknown',
+                        text: JSON.stringify({
+                            error: result.error,
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+    }
+    catch (error) {
+        console.error('Error fetching directory structure:', error);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ error: 'Failed to fetch directory structure' }, null, 2)
+                }
+            ]
+        };
+    }
+}
+async function fetchDirectoryStructure(componentNames, projectID, personalAccessToken) {
+    // TODO: change to PROD url
+    const url = 'https://codegen-api.locofy.dev/mcp/generators/' + projectID + '?name=' + componentNames.join(',');
+    const headers = {
+        'Accept': '*/*',
+        'Content-Type': 'application/json',
+        'Authorization': 'Bearer ' + personalAccessToken
+    };
+    const data = {};
+    try {
+        const response = await axios.post(url, data, { headers, });
+        if (response.status !== 200) {
+            // Instead of throwing, return an error object
+            return {
+                success: false,
+                error: `API returned status code ${response.status}`,
+                statusCode: response.status
+            };
+        }
+        if (!response.data || !response.data.directoryTree) {
+            return {
+                success: false,
+                error: 'API response is missing directoryTree property',
+                statusCode: response.status
+            };
+        }
+        return {
+            success: true,
+            data: response.data.directoryTree
+        };
+    }
+    catch (error) {
+        if (axios.isAxiosError(error)) {
+            if (error.response) {
+                const statusCode = error.response.status;
+                let errorMessage = '';
+                if (statusCode === 401) {
+                    errorMessage = 'Authentication failed: Invalid or expired token. Please check your mcp.json configuration in the .cursor folder to ensure your PERSONAL_ACCESS_TOKEN is correct. You can visit the Locofy project settings page to check or regenerate your token if needed.';
+                }
+                else if (statusCode === 500) {
+                    errorMessage = 'Server error: The API service is experiencing issues';
+                }
+                else {
+                    errorMessage = `API request failed with status ${statusCode}: ${error.message}`;
+                }
+                return {
+                    success: false,
+                    error: errorMessage,
+                    statusCode: statusCode
+                };
+            }
+            else if (error.request) {
+                return {
+                    success: false,
+                    error: 'Network error: No response received from API',
+                    statusCode: 'network_error'
+                };
+            }
+        }
+        console.error('API request failed:', error);
+        return {
+            success: false,
+            error: `Failed to fetch directory structure: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            statusCode: 'unknown_error'
+        };
+    }
+}
+/**
+ * Downloads and saves asset files from the directory structure
+ * @param directoryStructure The directory structure from the API response
+ * @param workspacePath The workspace path to save files to
+ */
+/* eslint-disable */
+async function downloadAndSaveAssets(directoryStructure, workspacePath) {
+    // Process each file in the directory structure
+    const processNode = async (node) => {
+        /* eslint-enable */
+        if (node.type === 'file' && node.exportData && node.exportData.files) {
+            // For each file in the files array
+            for (const file of node.exportData.files) {
+                if (file.url && file.fileName) {
+                    const filePath = path.join(workspacePath, file.filePath);
+                    // Create the directory structure if it doesn't exist
+                    const dirPath = path.dirname(filePath);
+                    if (!fs.existsSync(dirPath)) {
+                        fs.mkdirSync(dirPath, { recursive: true });
+                        console.log(`Created directory: ${dirPath}`);
+                    }
+                    // Only download if file doesn't exist
+                    if (!fs.existsSync(filePath)) {
+                        try {
+                            console.log(`Downloading ${file.fileName} from ${file.url}`);
+                            const response = await axios.get(file.url, { responseType: 'arraybuffer' });
+                            fs.writeFileSync(filePath, Buffer.from(response.data));
+                            console.log(`Saved ${file.fileName} to ${filePath}`);
+                        }
+                        catch (error) {
+                            console.error(`Error downloading ${file.fileName}:`, error);
+                        }
+                    }
+                    else {
+                        console.log(`File ${filePath} already exists, skipping download`);
+                    }
+                }
+            }
+        }
+        // Process children recursively
+        if (node.children && Array.isArray(node.children)) {
+            for (const child of node.children) {
+                await processNode(child);
+            }
+        }
+    };
+    // Start processing from the root
+    await processNode(directoryStructure);
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@locofy/mcp",
+  "version": "0.1.0",
+  "description": "Locofy MCP Server with Cursor",
+  "keywords": [
+    "figma",
+    "locofy",
+    "mcp",
+    "design-system"
+  ],
+  "homepage": "https://github.com/Locofy/mcp",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Locofy/mcp.git"
+  },
+  "license": "MIT",
+  "author": "Locofy",
+  "main": "./src/index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf build && tsc && node -e \"const fs=require('fs');const f='build/index.js';fs.writeFileSync(f,'#!/usr/bin/env node\\n'+fs.readFileSync(f));fs.chmodSync(f,'755')\"",
+    "link": "npm run build && npm link",
+    "start": "node build/index.js",
+    "lint": "eslint . --ext .ts --fix"
+  },
+  "bin": {
+    "locofy-mcp": "./build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.4.1",
+    "axios": "^1.8.3",
+    "express": "^4.21.2",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.1",
+    "@types/node": "^22.13.0",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0",
+    "eslint": "^8.49.0",
+    "eslint-config-prettier": "^9.0.0",
+    "typescript": "^5.7.3"
+  }
+}