iflow-mcp_cwahlfeldt_blender-mcp 0.1.0__py3-none-any.whl

blender/__init__.py

@@ -0,0 +1 @@
+# blender module initialization

blender/executor.py

@@ -0,0 +1,160 @@
+import subprocess
+import os
+import tempfile
+from pathlib import Path
+import logging
+
+class BlenderExecutor:
+    """Class to handle script execution in Blender"""
+    
+    def __init__(self, blender_path=None, timeout=60):
+        """
+        Initialize the BlenderExecutor
+        
+        Args:
+            blender_path (str, optional): Path to the Blender executable. If None, will try to find it.
+            timeout (int, optional): Timeout for script execution in seconds
+        """
+        self.blender_path = blender_path or self._find_blender_executable()
+        self.timeout = timeout
+        self.temp_dir = Path(tempfile.gettempdir()) / "blender_mcp"
+        self._setup()
+    
+    def _setup(self):
+        """Setup the executor, create necessary directories"""
+        os.makedirs(self.temp_dir, exist_ok=True)
+    
+    def _find_blender_executable(self):
+        """Find Blender executable path"""
+        # Try common locations
+        common_paths = [
+            "blender",  # If it's in PATH
+            "/usr/bin/blender",
+            "/usr/local/bin/blender",
+            "/Applications/Blender.app/Contents/MacOS/Blender",
+            "C:\\Program Files\\Blender Foundation\\Blender\\blender.exe",
+        ]
+        
+        for path in common_paths:
+            try:
+                # Just check if we can run it with --version
+                subprocess.run([path, "--version"], 
+                               stdout=subprocess.PIPE, 
+                               stderr=subprocess.PIPE, 
+                               timeout=5)
+                return path
+            except (subprocess.SubprocessError, FileNotFoundError):
+                continue
+        
+        # If we couldn't find it, default to "blender" and hope it's in PATH
+        return "blender"
+    
+    def execute(self, script_name, script_content, blend_file=None):
+        """
+        Execute a script in Blender
+        
+        Args:
+            script_name (str): Name of the script
+            script_content (str): Content of the script to execute
+            blend_file (str, optional): Path to a .blend file to use
+            
+        Returns:
+            str: Output of the script execution
+        """
+        # Create a temporary script file
+        script_file = self.temp_dir / f"{script_name}.py"
+        output_file = self.temp_dir / f"{script_name}.out"
+        
+        # Prepare variables to avoid f-string backslash issues
+        output_file_str = str(output_file)
+        newlines = "\n\n"
+        
+        # Write the script content with output capture
+        with open(script_file, "w") as f:
+            # Add code to capture stdout and stderr
+            indented_script = script_content.replace('\n', '\n    ')
+            wrapped_script = f"""
+import sys
+import io
+import traceback
+
+# Redirect stdout and stderr
+old_stdout = sys.stdout
+old_stderr = sys.stderr
+stdout_buffer = io.StringIO()
+stderr_buffer = io.StringIO()
+sys.stdout = stdout_buffer
+sys.stderr = stderr_buffer
+
+try:
+    # Execute the script
+{indented_script}
+except Exception as e:
+    print(f"Error executing script: {{e}}")
+    traceback.print_exc()
+finally:
+    # Restore stdout and stderr
+    sys.stdout = old_stdout
+    sys.stderr = old_stderr
+    
+    # Write output to file
+    with open(r"{output_file_str}", "w") as output:
+        output.write(stdout_buffer.getvalue())
+        output.write("{newlines}")
+        output.write(stderr_buffer.getvalue())
+"""
+            f.write(wrapped_script)
+        
+        try:
+            # Run Blender with the script
+            cmd = [
+                self.blender_path,
+                "--background",  # Run without GUI
+            ]
+            
+            # Add blend file if provided
+            if blend_file:
+                if os.path.exists(blend_file):
+                    cmd.extend(["--file", blend_file])
+                else:
+                    return f"Error: Blend file not found: {blend_file}"
+            
+            # Add Python script
+            cmd.extend(["--python", str(script_file)])
+            
+            process = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                timeout=self.timeout,
+                text=True
+            )
+            
+            # Check if the output file exists
+            if output_file.exists():
+                with open(output_file, "r") as f:
+                    script_output = f.read()
+            else:
+                script_output = "No output captured from script."
+            
+            # Add Blender's stdout/stderr if there was an error
+            if process.returncode != 0:
+                script_output += "\n\nBlender process output:\n"
+                script_output += f"STDOUT: {process.stdout}\n"
+                script_output += f"STDERR: {process.stderr}"
+            
+            return script_output
+        
+        except subprocess.TimeoutExpired:
+            return f"Script execution timed out after {self.timeout} seconds"
+        except Exception as e:
+            return f"Error executing script: {str(e)}"
+        finally:
+            # Clean up temp files
+            try:
+                if script_file.exists():
+                    script_file.unlink()
+                if output_file.exists():
+                    output_file.unlink()
+            except Exception as e:
+                logging.warning(f"Failed to clean up temp files: {e}")

blender/uv_tools.py

@@ -0,0 +1,323 @@
+import os
+import json
+from pathlib import Path
+import tempfile
+
+class UVTools:
+    """Tools for UV mapping operations in Blender"""
+    
+    def __init__(self, executor):
+        """
+        Initialize UV tools with a BlenderExecutor
+        
+        Args:
+            executor: BlenderExecutor instance for running scripts
+        """
+        self.executor = executor
+        self.temp_dir = Path(tempfile.gettempdir()) / "blender_mcp_uv"
+        self._setup()
+    
+    def _setup(self):
+        """Setup the UV tools, create necessary directories"""
+        os.makedirs(self.temp_dir, exist_ok=True)
+    
+    def unwrap_object(self, object_name, method="ANGLE_BASED", blend_file=None):
+        """
+        Unwrap a specific object in a blend file
+        
+        Args:
+            object_name (str): Name of the object to unwrap
+            method (str): Unwrapping method (ANGLE_BASED, CONFORMAL, or SMART_PROJECT)
+            blend_file (str): Path to the blend file
+            
+        Returns:
+            dict: Result of the operation
+        """
+        if blend_file is None or not os.path.exists(blend_file):
+            return {"error": f"Blend file not found: {blend_file}"}
+        
+        script = f"""
+import bpy
+import json
+
+result = {{"success": False, "message": ""}}
+
+# Check if the object exists
+if "{object_name}" not in bpy.data.objects:
+    result["message"] = f"Object '{object_name}' not found in the blend file"
+else:
+    obj = bpy.data.objects["{object_name}"]
+    
+    # Check if it's a mesh
+    if obj.type != 'MESH':
+        result["message"] = f"Object '{object_name}' is not a mesh (type: {{obj.type}})"
+    else:
+        # Select only this object and make it active
+        bpy.ops.object.select_all(action='DESELECT')
+        obj.select_set(True)
+        bpy.context.view_layer.objects.active = obj
+        
+        # Go to edit mode
+        bpy.ops.object.mode_set(mode='EDIT')
+        
+        # Select all faces
+        bpy.ops.mesh.select_all(action='SELECT')
+        
+        # Perform the unwrap operation
+        try:
+            method = "{method}"
+            if method == "SMART_PROJECT":
+                bpy.ops.uv.smart_project(angle_limit=66, island_margin=0.02)
+            else:
+                # ANGLE_BASED or CONFORMAL
+                bpy.ops.uv.unwrap(method=method, margin=0.02)
+                
+            result["success"] = True
+            result["message"] = f"Successfully unwrapped {{obj.name}} using {{method}} method"
+            
+            # Get UV stats
+            me = obj.data
+            if me.uv_layers:
+                result["uv_layers"] = [layer.name for layer in me.uv_layers]
+                result["active_uv"] = me.uv_layers.active.name if me.uv_layers.active else None
+                result["uv_count"] = len(me.uv_layers)
+            else:
+                result["message"] += "\\nNo UV layers found after unwrapping. This may indicate an error."
+        except Exception as e:
+            result["message"] = f"Error during unwrapping: {{str(e)}}"
+        
+        # Return to object mode
+        bpy.ops.object.mode_set(mode='OBJECT')
+        
+        # Save the file
+        bpy.ops.wm.save_mainfile()
+
+# Print the result as JSON for parsing
+print(json.dumps(result))
+"""
+        
+        # Execute the script
+        output = self.executor.execute("unwrap_object", script, blend_file)
+        
+        # Try to parse the JSON result
+        try:
+            # Extract JSON from the output (it may contain other print statements)
+            lines = output.strip().split('\n')
+            for line in lines:
+                try:
+                    result = json.loads(line)
+                    if isinstance(result, dict) and "success" in result:
+                        return result
+                except json.JSONDecodeError:
+                    pass
+            
+            # If no valid JSON found, return the raw output
+            return {"error": "Could not parse result", "output": output}
+        except Exception as e:
+            return {"error": f"Error parsing result: {str(e)}", "output": output}
+    
+    def mark_seams(self, object_name, blend_file=None, seam_angle=80):
+        """
+        Mark seams on an object based on angle
+        
+        Args:
+            object_name (str): Name of the object to mark seams on
+            blend_file (str): Path to the blend file
+            seam_angle (float): Angle in degrees to use for marking seams
+            
+        Returns:
+            dict: Result of the operation
+        """
+        if blend_file is None or not os.path.exists(blend_file):
+            return {"error": f"Blend file not found: {blend_file}"}
+        
+        script = f"""
+import bpy
+import json
+import math
+import bmesh
+
+result = {{"success": False, "message": ""}}
+
+# Check if the object exists
+if "{object_name}" not in bpy.data.objects:
+    result["message"] = f"Object '{object_name}' not found in the blend file"
+else:
+    obj = bpy.data.objects["{object_name}"]
+    
+    # Check if it's a mesh
+    if obj.type != 'MESH':
+        result["message"] = f"Object '{object_name}' is not a mesh (type: {{obj.type}})"
+    else:
+        # Select only this object and make it active
+        bpy.ops.object.select_all(action='DESELECT')
+        obj.select_set(True)
+        bpy.context.view_layer.objects.active = obj
+        
+        # Go to edit mode
+        bpy.ops.object.mode_set(mode='EDIT')
+        
+        # Get the bmesh
+        me = obj.data
+        bm = bmesh.from_edit_mesh(me)
+        
+        # Ensure we have custom data layers for seams
+        if not bm.edges.layers.seam:
+            bm.edges.layers.seam.new()
+        
+        seam_layer = bm.edges.layers.seam.active
+        
+        # Mark seams by angle
+        seam_angle_rad = {seam_angle} * (math.pi / 180.0)
+        seam_count = 0
+        
+        for edge in bm.edges:
+            if edge.is_boundary:
+                # Mark boundary edges as seams
+                edge[seam_layer] = True
+                seam_count += 1
+                continue
+            
+            # Get connected faces
+            if len(edge.link_faces) == 2:
+                f1, f2 = edge.link_faces
+                angle = f1.normal.angle(f2.normal)
+                
+                # If angle between faces exceeds threshold, mark as seam
+                if angle > seam_angle_rad:
+                    edge[seam_layer] = True
+                    seam_count += 1
+        
+        # Update the mesh and unwrap
+        bmesh.update_edit_mesh(me)
+        
+        # Select all faces
+        bpy.ops.mesh.select_all(action='SELECT')
+        
+        # Unwrap using the seams
+        bpy.ops.uv.unwrap(method='ANGLE_BASED', margin=0.02)
+        
+        result["success"] = True
+        result["message"] = f"Marked {{seam_count}} seams on {{obj.name}} using angle threshold of {seam_angle}° and unwrapped"
+        result["seam_count"] = seam_count
+        
+        # Return to object mode
+        bpy.ops.object.mode_set(mode='OBJECT')
+        
+        # Save the file
+        bpy.ops.wm.save_mainfile()
+
+# Print the result as JSON for parsing
+print(json.dumps(result))
+"""
+        
+        # Execute the script
+        output = self.executor.execute("mark_seams", script, blend_file)
+        
+        # Try to parse the JSON result
+        try:
+            # Extract JSON from the output
+            lines = output.strip().split('\n')
+            for line in lines:
+                try:
+                    result = json.loads(line)
+                    if isinstance(result, dict) and "success" in result:
+                        return result
+                except json.JSONDecodeError:
+                    pass
+            
+            # If no valid JSON found, return the raw output
+            return {"error": "Could not parse result", "output": output}
+        except Exception as e:
+            return {"error": f"Error parsing result: {str(e)}", "output": output}
+    
+    def texture_object(self, object_name, blend_file=None, texture_type="checker", color1=None, color2=None):
+        """
+        Apply a textured material to an object using its UV maps
+        
+        Args:
+            object_name (str): Name of the object to texture
+            blend_file (str): Path to the blend file
+            texture_type (str): Type of texture (checker, gradient, grid)
+            color1 (list): First color as [r, g, b] (0.0-1.0 range)
+            color2 (list): Second color as [r, g, b] (0.0-1.0 range)
+            
+        Returns:
+            dict: Result of the operation
+        """
+        if blend_file is None or not os.path.exists(blend_file):
+            return {"error": f"Blend file not found: {blend_file}"}
+        
+        # Set default colors if none provided
+        if color1 is None:
+            color1 = [0.8, 0.1, 0.1]  # Red
+        if color2 is None:
+            color2 = [0.1, 0.1, 0.8]  # Blue
+        
+        script = f"""
+import bpy
+import json
+
+result = {{"success": False, "message": ""}}
+
+# Check if the object exists
+if "{object_name}" not in bpy.data.objects:
+    result["message"] = f"Object '{object_name}' not found in the blend file"
+else:
+    obj = bpy.data.objects["{object_name}"]
+    
+    # Check if it's a mesh
+    if obj.type != 'MESH':
+        result["message"] = f"Object '{object_name}' is not a mesh (type: {{obj.type}})"
+    else:
+        # Check if the object has UVs
+        if not obj.data.uv_layers:
+            result["message"] = f"Object '{object_name}' has no UV layers. Unwrap it first."
+        else:
+            # Create a new material
+            mat_name = f"{{obj.name}}_{{'{texture_type}'}}_Material"
+            mat = bpy.data.materials.new(name=mat_name)
+            mat.use_nodes = True
+            
+            # Clear default nodes
+            node_tree = mat.node_tree
+            for node in node_tree.nodes:
+                node_tree.nodes.remove(node)
+            
+            # Create texture coordinate node
+            tex_coord = node_tree.nodes.new(type='ShaderNodeTexCoord')
+            tex_coord.location = (-600, 0)
+            
+            # Create BSDF node
+            bsdf = node_tree.nodes.new(type='ShaderNodeBsdfPrincipled')
+            bsdf.location = (0, 0)
+            
+            # Create output node
+            output = node_tree.nodes.new(type='ShaderNodeOutputMaterial')
+            output.location = (200, 0)
+            
+            # Different texture setup based on type
+            texture_type = "{texture_type}".lower()
+            
+            if texture_type == "checker":
+                # Create checker texture node
+                checker = node_tree.nodes.new(type='ShaderNodeTexChecker')
+                checker.location = (-400, 0)
+                checker.inputs['Scale'].default_value = 4.0
+                checker.inputs['Color1'].default_value = {color1 + [1.0]}
+                checker.inputs['Color2'].default_value = {color2 + [1.0]}
+                
+                # Link nodes
+                node_tree.links.new(tex_coord.outputs['UV'], checker.inputs['Vector'])
+                node_tree.links.new(checker.outputs['Color'], bsdf.inputs['Base Color'])
+                
+            elif texture_type == "gradient":
+                # Create gradient texture node
+                gradient = node_tree.nodes.new(type='ShaderNodeTexGradient')
+                gradient.location = (-400, 0)
+                
+                # Create color ramp for the gradient
+                color_ramp = node_tree.nodes.new(type='ShaderNodeValToRGB')
+                color_ramp.location = (-200, 0)
+                # Customize the color ramp
+                color_ramp

iflow_mcp_cwahlfeldt_blender_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_cwahlfeldt_blender-mcp
+Version: 0.1.0
+Summary: MCP server for executing Blender scripts
+Author: Blender MCP Team
+Requires-Python: >=3.11
+Requires-Dist: mcp>=0.1.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: isort>=5.12.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Blender MCP Server
+
+A Model Context Protocol (MCP) server for managing and executing Blender scripts.
+
+## Features
+
+- Add, edit, execute, and remove Blender Python scripts
+- Execute scripts in a headless Blender environment
+- View execution results and errors
+- Track script metadata (creation date, last modified, execution count)
+
+## Requirements
+
+- Python 3.7+
+- Blender installed and accessible
+- MCP library (`pip install mcp`)
+
+## Usage
+
+1. Start the server:
+   ```
+   python server.py
+   ```
+
+2. Connect to the server using an MCP client (like Claude Desktop)
+
+3. Use the provided tools to manage scripts:
+   - `add_script(name, content)` - Add a new script
+   - `edit_script(name, content)` - Edit an existing script
+   - `execute_script(name, blend_file=None)` - Execute a script in Blender, optionally specifying a .blend file
+   - `remove_script(name)` - Remove a script
+
+4. Access resources to get information:
+   - `scripts://list` - Get list of available scripts
+   - `script://{name}` - Get content of a specific script
+   - `result://{name}` - Get execution result of a script
+
+## Examples
+
+### Basic Example
+
+```python
+# Add a simple script
+add_script("hello_cube", '''
+import bpy
+
+# Clear existing objects
+bpy.ops.object.select_all(action='SELECT')
+bpy.ops.object.delete()
+
+# Create a cube
+bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 0))
+print("Cube created!")
+''')
+
+# Execute the script
+execute_script("hello_cube")
+
+# Get the result
+# Access using: result://hello_cube
+```
+
+### Working with Blend Files
+
+```python
+# Add a script that works with a blend file
+add_script("analyze_scene", '''
+import bpy
+
+# Print information about the current scene
+print(f"Current Blender version: {bpy.app.version_string}")
+print(f"Current file: {bpy.data.filepath}")
+
+# List all objects in the scene
+print("\\nObjects in the scene:")
+for obj in bpy.data.objects:
+    print(f" - {obj.name} ({obj.type})")
+''')
+
+# Execute with a specific blend file
+execute_script("analyze_scene", blend_file="/path/to/your/project.blend")
+
+# Get the result
+# Access using: result://analyze_scene
+```
+
+## How It Works
+
+1. When a script is added, it's stored in the `script_files/scripts` directory
+2. When executed, the script is run in a headless Blender instance
+   - If a blend file is specified, Blender will open that file before running the script
+   - Otherwise, a default empty Blender scene is used
+3. Output and errors are captured and stored in the `script_files/results` directory
+4. Metadata about scripts is tracked in `script_files/metadata.json`
+
+## Installation
+
+1. Clone this repository
+2. Install the MCP library: `pip install mcp`
+3. Ensure Blender is installed and accessible from your PATH
+
+## License
+
+MIT

iflow_mcp_cwahlfeldt_blender_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+blender/__init__.py,sha256=-nr6dwd6f_6xfJEy_nRV7D5unQMFxXvEEvYdk_gHjyo,32
+blender/executor.py,sha256=UbrmYIXjNloWEkUMtsgOoeVqvrtnLtztcbWtvUxD9tU,5464
+blender/uv_tools.py,sha256=anfOL3hW1fZdPTi1LDA2nMC123hCx95rvQfKer_nBrY,11658
+scripts/__init__.py,sha256=x78bZpSWEjokJ24WqB-bvGAx3PnvixRCZ4xzWgmORBo,32
+scripts/manager.py,sha256=06f5O8rCex-jDBMdxuEHEaq5SHFwPojOYnrIPBItVT0,6122
+utils/__init__.py,sha256=XkLKwxjypuJhs2A-RPst7CZ1G_tWfvdHwFFFtZTjAQI,30
+utils/helpers.py,sha256=EZkvfxRBFdr5Jm8Niwzikqv5QmR3WkIE2_MFvusRNqk,5452
+utils/uv_integration.py,sha256=FQuhOTPPRxeUPZWYwGwLEQbkj10gKx-sg0ushKfRPt4,8630
+utils/uv_manager.py,sha256=OCj8r3g6SPj-jHh-zti6H6EKubRkF8OLiCBAlzuARuY,1964
+iflow_mcp_cwahlfeldt_blender_mcp-0.1.0.dist-info/METADATA,sha256=VHchiyQQOtDbh2d2O_H1e6BIrXQO_-kpG_MC23VPJnk,3124
+iflow_mcp_cwahlfeldt_blender_mcp-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iflow_mcp_cwahlfeldt_blender_mcp-0.1.0.dist-info/entry_points.txt,sha256=QnyWp9XwL2dm3qqSZH1WdCgLZQ0nkmTBgsRJ1wRM3Xc,43
+iflow_mcp_cwahlfeldt_blender_mcp-0.1.0.dist-info/RECORD,,

iflow_mcp_cwahlfeldt_blender_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

iflow_mcp_cwahlfeldt_blender_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blender-mcp = server:mcp

scripts/__init__.py

@@ -0,0 +1 @@
+# scripts module initialization

scripts/manager.py

@@ -0,0 +1,200 @@
+import os
+import json
+from pathlib import Path
+import datetime
+import re
+
+class ScriptManager:
+    """Class to manage Blender scripts"""
+    
+    def __init__(self, scripts_dir=None):
+        """
+        Initialize the ScriptManager
+        
+        Args:
+            scripts_dir (str, optional): Directory to store scripts. If None, will use ./scripts
+        """
+        self.scripts_dir = Path(scripts_dir or Path.cwd() / "script_files")
+        self.scripts_dir.mkdir(exist_ok=True, parents=True)
+        
+        # Create subdirectories
+        self.scripts_path = self.scripts_dir / "scripts"
+        self.results_path = self.scripts_dir / "results"
+        self.metadata_path = self.scripts_dir / "metadata.json"
+        
+        self.scripts_path.mkdir(exist_ok=True)
+        self.results_path.mkdir(exist_ok=True)
+        
+        # Initialize metadata
+        self._init_metadata()
+    
+    def _init_metadata(self):
+        """Initialize or load metadata file"""
+        if not self.metadata_path.exists():
+            self.metadata = {}
+            self._save_metadata()
+        else:
+            try:
+                with open(self.metadata_path, "r") as f:
+                    self.metadata = json.load(f)
+            except json.JSONDecodeError:
+                # If the file is corrupted, initialize new metadata
+                self.metadata = {}
+                self._save_metadata()
+    
+    def _save_metadata(self):
+        """Save metadata to file"""
+        with open(self.metadata_path, "w") as f:
+            json.dump(self.metadata, f, indent=2)
+    
+    def _validate_script_name(self, name):
+        """Validate script name"""
+        if not re.match(r'^[a-zA-Z0-9_-]+$', name):
+            raise ValueError("Script name can only contain letters, numbers, underscores, and hyphens")
+        return name
+    
+    def list_scripts(self):
+        """List all available scripts with metadata"""
+        scripts = []
+        for script_name, metadata in self.metadata.items():
+            script_info = metadata.copy()
+            script_info["name"] = script_name
+            scripts.append(script_info)
+        return scripts
+    
+    def add_script(self, name, content):
+        """
+        Add a new script
+        
+        Args:
+            name (str): Script name
+            content (str): Script content
+        """
+        name = self._validate_script_name(name)
+        script_path = self.scripts_path / f"{name}.py"
+        
+        if script_path.exists():
+            raise ValueError(f"Script '{name}' already exists")
+        
+        # Save script content
+        with open(script_path, "w") as f:
+            f.write(content)
+        
+        # Update metadata
+        now = datetime.datetime.now().isoformat()
+        self.metadata[name] = {
+            "created": now,
+            "last_modified": now,
+            "last_executed": None,
+            "execution_count": 0
+        }
+        self._save_metadata()
+    
+    def edit_script(self, name, content):
+        """
+        Edit an existing script
+        
+        Args:
+            name (str): Script name
+            content (str): New script content
+        """
+        name = self._validate_script_name(name)
+        script_path = self.scripts_path / f"{name}.py"
+        
+        if not script_path.exists():
+            raise ValueError(f"Script '{name}' not found")
+        
+        # Save script content
+        with open(script_path, "w") as f:
+            f.write(content)
+        
+        # Update metadata
+        now = datetime.datetime.now().isoformat()
+        self.metadata[name]["last_modified"] = now
+        self._save_metadata()
+    
+    def get_script(self, name):
+        """
+        Get script content
+        
+        Args:
+            name (str): Script name
+            
+        Returns:
+            str: Script content
+        """
+        name = self._validate_script_name(name)
+        script_path = self.scripts_path / f"{name}.py"
+        
+        if not script_path.exists():
+            raise ValueError(f"Script '{name}' not found")
+        
+        with open(script_path, "r") as f:
+            return f.read()
+    
+    def remove_script(self, name):
+        """
+        Remove a script
+        
+        Args:
+            name (str): Script name
+        """
+        name = self._validate_script_name(name)
+        script_path = self.scripts_path / f"{name}.py"
+        result_path = self.results_path / f"{name}.txt"
+        
+        if not script_path.exists():
+            raise ValueError(f"Script '{name}' not found")
+        
+        # Remove script file
+        script_path.unlink()
+        
+        # Remove result file if it exists
+        if result_path.exists():
+            result_path.unlink()
+        
+        # Update metadata
+        if name in self.metadata:
+            del self.metadata[name]
+            self._save_metadata()
+    
+    def save_result(self, name, result):
+        """
+        Save script execution result
+        
+        Args:
+            name (str): Script name
+            result (str): Execution result
+        """
+        name = self._validate_script_name(name)
+        result_path = self.results_path / f"{name}.txt"
+        
+        # Save result
+        with open(result_path, "w") as f:
+            f.write(result)
+        
+        # Update metadata
+        if name in self.metadata:
+            now = datetime.datetime.now().isoformat()
+            self.metadata[name]["last_executed"] = now
+            self.metadata[name]["execution_count"] = self.metadata[name].get("execution_count", 0) + 1
+            self._save_metadata()
+    
+    def get_result(self, name):
+        """
+        Get script execution result
+        
+        Args:
+            name (str): Script name
+            
+        Returns:
+            str: Execution result
+        """
+        name = self._validate_script_name(name)
+        result_path = self.results_path / f"{name}.txt"
+        
+        if not result_path.exists():
+            return f"No execution results found for script '{name}'"
+        
+        with open(result_path, "r") as f:
+            return f.read()

utils/__init__.py

@@ -0,0 +1 @@
+# utils module initialization

utils/helpers.py

@@ -0,0 +1,206 @@
+import os
+import sys
+import subprocess
+from pathlib import Path
+import logging
+
+def setup_logger(name, level=logging.INFO):
+    """Set up and return a logger"""
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+    
+    # Create console handler
+    ch = logging.StreamHandler()
+    ch.setLevel(level)
+    
+    # Create formatter
+    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    ch.setFormatter(formatter)
+    
+    # Add handler to logger
+    logger.addHandler(ch)
+    
+    return logger
+
+def verify_blender_installation():
+    """
+    Verify Blender is installed and return its version
+    
+    Returns:
+        tuple: (bool, str) - (is_installed, version_or_error_message)
+    """
+    common_paths = [
+        "blender",  # If it's in PATH
+        "/usr/bin/blender",
+        "/usr/local/bin/blender",
+        "/Applications/Blender.app/Contents/MacOS/Blender",
+        "C:\\Program Files\\Blender Foundation\\Blender\\blender.exe",
+    ]
+    
+    for path in common_paths:
+        try:
+            result = subprocess.run(
+                [path, "--version"], 
+                stdout=subprocess.PIPE, 
+                stderr=subprocess.PIPE, 
+                timeout=5,
+                text=True
+            )
+            
+            # Extract version from output
+            version_output = result.stdout
+            return True, version_output.strip()
+        except (subprocess.SubprocessError, FileNotFoundError):
+            continue
+    
+    return False, "Blender not found. Please install Blender or set the correct path."
+
+def generate_example_script():
+    """Generate an example Blender script"""
+    return """
+import bpy
+
+# Clear existing objects
+bpy.ops.object.select_all(action='SELECT')
+bpy.ops.object.delete()
+
+# Create a cube
+bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 0))
+
+# Create a material
+mat = bpy.data.materials.new(name="Red Material")
+mat.diffuse_color = (1, 0, 0, 1)  # Red
+
+# Assign material to the cube
+cube = bpy.context.active_object
+if cube.data.materials:
+    cube.data.materials[0] = mat
+else:
+    cube.data.materials.append(mat)
+
+# Print confirmation
+print("Created a red cube at the origin!")
+"""
+
+def generate_blend_file_example_script():
+    """Generate an example script that works with a blend file"""
+    return """
+import bpy
+import os
+
+# Print information about the current scene
+print(f"Current Blender version: {bpy.app.version_string}")
+print(f"Current file: {bpy.data.filepath}")
+
+# List all objects in the scene
+print("\\nObjects in the scene:")
+for obj in bpy.data.objects:
+    print(f" - {obj.name} ({obj.type})")
+
+# List all materials
+print("\\nMaterials in the scene:")
+for mat in bpy.data.materials:
+    print(f" - {mat.name}")
+
+# List all scenes
+print("\\nScenes in the file:")
+for scene in bpy.data.scenes:
+    print(f" - {scene.name}")
+
+# Make a small change to demonstrate saving
+if bpy.data.objects:
+    # Move the first object up by 1 unit
+    obj = bpy.data.objects[0]
+    original_loc = obj.location.copy()
+    obj.location.z += 1
+    print(f"\\nMoved {obj.name} up by 1 unit (from {original_loc.z} to {obj.location.z})")
+
+    # Note about saving
+    print("\\nNote: To save changes to the blend file, uncomment the save line below.")
+    # bpy.ops.wm.save_mainfile()
+"""
+
+def generate_readme():
+    """Generate README content for the project"""
+    return """# Blender MCP Server
+
+A Model Context Protocol (MCP) server for managing and executing Blender scripts.
+
+## Features
+
+- Add, edit, execute, and remove Blender Python scripts
+- Execute scripts in a headless Blender environment
+- View execution results and errors
+- Track script metadata (creation date, last modified, execution count)
+
+## Requirements
+
+- Python 3.7+
+- Blender installed and accessible
+- MCP library (`pip install mcp`)
+
+## Usage
+
+1. Start the server:
+   ```
+   python server.py
+   ```
+
+2. Connect to the server using an MCP client (like Claude Desktop)
+
+3. Use the provided tools to manage scripts:
+   - `add_script(name, content)` - Add a new script
+   - `edit_script(name, content)` - Edit an existing script
+   - `execute_script(name)` - Execute a script in Blender
+   - `remove_script(name)` - Remove a script
+
+4. Access resources to get information:
+   - `scripts://list` - Get list of available scripts
+   - `script://{name}` - Get content of a specific script
+   - `result://{name}` - Get execution result of a script
+
+## Example
+
+```python
+# Add a simple script
+add_script("hello_cube", '''
+import bpy
+
+# Clear existing objects
+bpy.ops.object.select_all(action='SELECT')
+bpy.ops.object.delete()
+
+# Create a cube
+bpy.ops.mesh.primitive_cube_add(size=2, location=(0, 0, 0))
+print("Cube created!")
+''')
+
+# Execute the script
+execute_script("hello_cube")
+
+# Get the result
+result = get_resource("result://hello_cube")
+print(result)
+```
+
+## License
+
+MIT
+"""
+
+def create_empty_init_files(root_dir):
+    """
+    Create empty __init__.py files in all subdirectories
+    
+    Args:
+        root_dir (str): Root directory path
+    """
+    for dirpath, dirnames, filenames in os.walk(root_dir):
+        # Skip hidden directories
+        dirnames[:] = [d for d in dirnames if not d.startswith('.')]
+        
+        # Create __init__.py if it doesn't exist
+        init_file = os.path.join(dirpath, "__init__.py")
+        if not os.path.exists(init_file):
+            with open(init_file, 'w') as f:
+                pass  # Create empty file

utils/uv_integration.py

@@ -0,0 +1,264 @@
+import os
+import subprocess
+import sys
+import json
+from pathlib import Path
+import logging
+
+logger = logging.getLogger(__name__)
+
+class UVIntegration:
+    """Integration with UV Python for package management"""
+    
+    def __init__(self):
+        """Initialize UV integration utils"""
+        self.uv_path = self._find_uv_executable()
+        self.has_uv = self.uv_path is not None
+    
+    def _find_uv_executable(self):
+        """Find the UV executable in the system"""
+        # Try common locations
+        common_names = ["uv", "uv.exe"]
+        
+        for name in common_names:
+            try:
+                # Just check if we can run it with --version
+                subprocess.run([name, "--version"], 
+                               stdout=subprocess.PIPE, 
+                               stderr=subprocess.PIPE, 
+                               timeout=5)
+                return name
+            except (subprocess.SubprocessError, FileNotFoundError):
+                continue
+        
+        return None
+    
+    def is_available(self):
+        """Check if UV is available on the system"""
+        return self.has_uv
+    
+    def install_dependencies(self, dependencies, venv_path=None):
+        """
+        Install dependencies using UV
+        
+        Args:
+            dependencies (list): List of dependencies to install
+            venv_path (str, optional): Path to virtual environment
+            
+        Returns:
+            dict: Result of the operation
+        """
+        if not self.has_uv:
+            return {
+                "success": False,
+                "message": "UV Python is not available. Please install it first."
+            }
+        
+        cmd = [self.uv_path, "pip", "install"]
+        cmd.extend(dependencies)
+        
+        env = os.environ.copy()
+        if venv_path:
+            # Set virtual environment path
+            if sys.platform == "win32":
+                env["VIRTUAL_ENV"] = venv_path
+                env["PATH"] = os.path.join(venv_path, "Scripts") + os.pathsep + env["PATH"]
+            else:
+                env["VIRTUAL_ENV"] = venv_path
+                env["PATH"] = os.path.join(venv_path, "bin") + os.pathsep + env["PATH"]
+        
+        try:
+            result = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                text=True
+            )
+            
+            if result.returncode == 0:
+                return {
+                    "success": True,
+                    "message": f"Successfully installed dependencies: {', '.join(dependencies)}",
+                    "output": result.stdout
+                }
+            else:
+                return {
+                    "success": False,
+                    "message": "Failed to install dependencies",
+                    "error": result.stderr,
+                    "output": result.stdout
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "message": f"Error during installation: {str(e)}"
+            }
+    
+    def create_venv(self, path):
+        """
+        Create a virtual environment using UV
+        
+        Args:
+            path (str): Path for the virtual environment
+            
+        Returns:
+            dict: Result of the operation
+        """
+        if not self.has_uv:
+            return {
+                "success": False,
+                "message": "UV Python is not available. Please install it first."
+            }
+        
+        path = os.path.abspath(path)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        
+        cmd = [self.uv_path, "venv", path]
+        
+        try:
+            result = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            if result.returncode == 0:
+                return {
+                    "success": True,
+                    "message": f"Successfully created virtual environment at {path}",
+                    "path": path,
+                    "output": result.stdout
+                }
+            else:
+                return {
+                    "success": False,
+                    "message": "Failed to create virtual environment",
+                    "error": result.stderr,
+                    "output": result.stdout
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "message": f"Error creating virtual environment: {str(e)}"
+            }
+    
+    def get_installed_packages(self, venv_path=None):
+        """
+        Get list of installed packages
+        
+        Args:
+            venv_path (str, optional): Path to virtual environment
+            
+        Returns:
+            dict: Result of the operation with list of packages
+        """
+        if not self.has_uv:
+            return {
+                "success": False,
+                "message": "UV Python is not available. Please install it first."
+            }
+        
+        cmd = [self.uv_path, "pip", "list", "--format=json"]
+        
+        env = os.environ.copy()
+        if venv_path:
+            # Set virtual environment path
+            if sys.platform == "win32":
+                env["VIRTUAL_ENV"] = venv_path
+                env["PATH"] = os.path.join(venv_path, "Scripts") + os.pathsep + env["PATH"]
+            else:
+                env["VIRTUAL_ENV"] = venv_path
+                env["PATH"] = os.path.join(venv_path, "bin") + os.pathsep + env["PATH"]
+        
+        try:
+            result = subprocess.run(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                text=True
+            )
+            
+            if result.returncode == 0:
+                try:
+                    packages = json.loads(result.stdout)
+                    return {
+                        "success": True,
+                        "packages": packages,
+                        "count": len(packages)
+                    }
+                except json.JSONDecodeError:
+                    return {
+                        "success": False,
+                        "message": "Failed to parse package list",
+                        "output": result.stdout
+                    }
+            else:
+                return {
+                    "success": False,
+                    "message": "Failed to get list of packages",
+                    "error": result.stderr,
+                    "output": result.stdout
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "message": f"Error getting packages: {str(e)}"
+            }
+    
+    def run_script_in_venv(self, script_path, venv_path):
+        """
+        Run a Python script in a virtual environment
+        
+        Args:
+            script_path (str): Path to the script
+            venv_path (str): Path to virtual environment
+            
+        Returns:
+            dict: Result of the operation
+        """
+        if not os.path.exists(script_path):
+            return {
+                "success": False,
+                "message": f"Script not found: {script_path}"
+            }
+        
+        if not os.path.exists(venv_path):
+            return {
+                "success": False,
+                "message": f"Virtual environment not found: {venv_path}"
+            }
+        
+        # Get path to Python in the virtual environment
+        if sys.platform == "win32":
+            python_path = os.path.join(venv_path, "Scripts", "python.exe")
+        else:
+            python_path = os.path.join(venv_path, "bin", "python")
+        
+        if not os.path.exists(python_path):
+            return {
+                "success": False,
+                "message": f"Python not found in virtual environment: {python_path}"
+            }
+        
+        try:
+            result = subprocess.run(
+                [python_path, script_path],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True
+            )
+            
+            return {
+                "success": result.returncode == 0,
+                "exit_code": result.returncode,
+                "stdout": result.stdout,
+                "stderr": result.stderr
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "message": f"Error running script: {str(e)}"
+            }

utils/uv_manager.py

@@ -0,0 +1,64 @@
+import os
+import subprocess
+import sys
+import json
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+class UVManager:
+    """Manager for UV Python package installer and environment manager"""
+    
+    def __init__(self, env_dir=None):
+        """
+        Initialize UV manager
+        
+        Args:
+            env_dir (str, optional): Directory to store environments
+        """
+        self.uv_bin = self._find_uv_executable()
+        self.env_dir = Path(env_dir or Path.cwd() / "python_envs")
+        self.env_dir.mkdir(exist_ok=True, parents=True)
+    
+    def _find_uv_executable(self):
+        """Find the UV executable in the system"""
+        # Check common names and locations
+        common_names = ["uv", "uv.exe"]
+        
+        for name in common_names:
+            try:
+                # Check if we can run it with --version
+                result = subprocess.run(
+                    [name, "--version"], 
+                    stdout=subprocess.PIPE, 
+                    stderr=subprocess.PIPE, 
+                    timeout=5,
+                    text=True
+                )
+                if result.returncode == 0:
+                    return name
+            except (subprocess.SubprocessError, FileNotFoundError):
+                continue
+        
+        # If not found, try to install it using pip
+        try:
+            subprocess.run(
+                [sys.executable, "-m", "pip", "install", "uv"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                check=True
+            )
+            return "uv"  # Try the command directly after installation
+        except Exception as e:
+            logger.warning(f"Failed to install UV: {e}")
+        
+        return None
+    
+    def is_available(self):
+        """Check if UV is available"""
+        return self.uv_bin is not None
+    
+    def create_environment(self, name, python_version=None):
+        """
+