coplay-mcp-server 1.4.1__py3-none-any.whl

coplay_mcp_server/image_utils.py

@@ -0,0 +1,96 @@
+"""Utility functions for image processing in MCP server."""
+
+import base64
+import logging
+import mimetypes
+from pathlib import Path
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+def convert_image_to_base64_url(image_path: str) -> Optional[str]:
+    """Convert local image path to base64 data URL for MCP compatibility.
+
+    Args:
+        image_path: Local file path to the image
+
+    Returns:
+        Base64 data URL string (e.g., 'data:image/jpeg;base64,/9j/4AAQ...') or None if conversion fails
+    """
+    try:
+        path = Path(image_path)
+        if not path.exists():
+            logger.warning(f"Image file not found: {image_path}")
+            return None
+
+        if not path.is_file():
+            logger.warning(f"Path is not a file: {image_path}")
+            return None
+
+        # Determine MIME type from file extension
+        mime_type, _ = mimetypes.guess_type(str(path))
+        if not mime_type or not mime_type.startswith("image/"):
+            # Default to JPEG for unknown image types
+            mime_type = "image/jpeg"
+            logger.debug(
+                f"Unknown MIME type for {image_path}, defaulting to {mime_type}"
+            )
+
+        # Read and encode image to base64
+        with open(path, "rb") as f:
+            image_data = base64.b64encode(f.read()).decode("utf-8")
+
+        data_url = f"data:{mime_type};base64,{image_data}"
+        logger.debug(
+            f"Successfully converted {image_path} to base64 data URL ({len(data_url)} chars)"
+        )
+        return data_url
+
+    except Exception as e:
+        logger.error(f"Failed to convert image to base64: {e}")
+        return None
+
+
+def is_image_file(file_path: str) -> bool:
+    """Check if a file path points to an image file.
+
+    Args:
+        file_path: Path to check
+
+    Returns:
+        True if the file appears to be an image based on extension
+    """
+    try:
+        mime_type, _ = mimetypes.guess_type(file_path)
+        return mime_type is not None and mime_type.startswith("image/")
+    except Exception:
+        return False
+
+
+def get_image_info(image_path: str) -> Optional[dict]:
+    """Get basic information about an image file.
+
+    Args:
+        image_path: Path to the image file
+
+    Returns:
+        Dictionary with image info or None if file cannot be read
+    """
+    try:
+        path = Path(image_path)
+        if not path.exists():
+            return None
+
+        stat = path.stat()
+        mime_type, _ = mimetypes.guess_type(str(path))
+
+        return {
+            "path": str(path),
+            "size_bytes": stat.st_size,
+            "mime_type": mime_type,
+            "is_image": is_image_file(str(path)),
+        }
+    except Exception as e:
+        logger.error(f"Failed to get image info for {image_path}: {e}")
+        return None

coplay_mcp_server/process_discovery.py

@@ -0,0 +1,168 @@
+"""Unity process discovery utilities."""
+
+import logging
+import platform
+from pathlib import Path
+from typing import List, Optional
+
+import psutil
+
+logger = logging.getLogger(__name__)
+
+
+def find_unity_processes() -> List[psutil.Process]:
+    """Find all running Unity Editor processes."""
+    unity_processes = []
+    
+    try:
+        for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
+            try:
+                proc_info = proc.info
+                if not proc_info['name']:
+                    continue
+                    
+                name = proc_info['name'].lower()
+                
+                # Check for Unity process names across platforms
+                if any(unity_name in name for unity_name in [
+                    'unity', 'unity.exe', 'unity editor', 'unity hub'
+                ]):
+                    # Skip Unity Hub, we only want Editor instances
+                    if 'hub' not in name:
+                        unity_processes.append(proc)
+                        
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+                
+    except Exception as e:
+        logger.error(f"Error finding Unity processes: {e}")
+        
+    return unity_processes
+
+
+def extract_project_path_from_cmdline(cmdline: List[str]) -> Optional[str]:
+    """Extract Unity project path from command line arguments."""
+    if not cmdline:
+        return None
+        
+    try:
+        # Look for -projectPath argument
+        for i, arg in enumerate(cmdline):
+            if arg.lower() == "-projectpath" and i + 1 < len(cmdline):
+                project_path = cmdline[i + 1]
+                # Remove quotes if present
+                project_path = project_path.strip('"\'')
+                return project_path
+                
+    except Exception as e:
+        logger.debug(f"Error extracting project path from cmdline: {e}")
+        
+    return None
+
+
+def verify_unity_project(project_path: str) -> bool:
+    """Verify that a path is a valid Unity project."""
+    try:
+        project_dir = Path(project_path)
+        if not project_dir.exists() or not project_dir.is_dir():
+            return False
+            
+        # Check for Assets folder (required for Unity projects)
+        assets_dir = project_dir / "Assets"
+        if not assets_dir.exists() or not assets_dir.is_dir():
+            return False
+            
+        return True
+        
+    except Exception as e:
+        logger.debug(f"Error verifying Unity project at {project_path}: {e}")
+        return False
+
+
+def _discover_from_temp_dirs() -> List[str]:
+    """Discover Unity projects from MCP request directories in temp locations."""
+    project_roots = []
+    
+    try:
+        # Common temp directory locations
+        temp_paths = []
+        
+        if platform.system() == "Windows":
+            import tempfile
+            temp_paths.append(Path(tempfile.gettempdir()))
+            # Also check AppData/Local
+            try:
+                appdata_local = Path.home() / "AppData" / "Local"
+                if appdata_local.exists():
+                    temp_paths.append(appdata_local)
+            except Exception:
+                pass
+        else:
+            # Unix-like systems
+            temp_paths.extend([
+                Path("/tmp"),
+                Path.home() / ".cache",
+                Path("/var/tmp")
+            ])
+        
+        for temp_path in temp_paths:
+            if not temp_path.exists():
+                continue
+                
+            try:
+                # Look for Coplay MCP request directories
+                for path in temp_path.rglob("**/Temp/Coplay/MCPRequests"):
+                    if path.is_dir():
+                        # Try to infer project root from temp path structure
+                        temp_index = None
+                        parts = path.parts
+                        
+                        for i, part in enumerate(parts):
+                            if part.lower() == "temp":
+                                temp_index = i
+                                break
+                                
+                        if temp_index and temp_index > 0:
+                            project_path = str(Path(*parts[:temp_index]))
+                            if verify_unity_project(project_path):
+                                project_roots.append(project_path)
+                                
+            except Exception as e:
+                logger.debug(f"Error searching temp path {temp_path}: {e}")
+                
+    except Exception as e:
+        logger.debug(f"Error discovering from temp directories: {e}")
+        
+    return project_roots
+
+
+def discover_unity_project_roots() -> List[str]:
+    """Discover all Unity project roots from running processes."""
+    project_roots = []
+    
+    try:
+        unity_processes = find_unity_processes()
+        logger.info(f"Found {len(unity_processes)} Unity processes")
+        
+        for proc in unity_processes:
+            try:
+                cmdline = proc.cmdline()
+                project_path = extract_project_path_from_cmdline(cmdline)
+                
+                if project_path and verify_unity_project(project_path):
+                    if project_path not in project_roots:
+                        project_roots.append(project_path)
+                        logger.info(f"Found Unity project: {project_path}")
+                        
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                continue
+            except Exception as e:
+                logger.debug(f"Error processing Unity process {proc.pid}: {e}")
+                
+    except Exception as e:
+        logger.error(f"Error discovering Unity project roots: {e}")
+        
+    # Also check for MCP request directories in temp locations
+    project_roots.extend(_discover_from_temp_dirs())
+    
+    return list(set(project_roots))  # Remove duplicates

coplay_mcp_server/server.py

@@ -0,0 +1,236 @@
+"""Main entry point for Coplay MCP Server using FastMCP."""
+
+import logging
+import os
+import sys
+
+from typing import Any, Optional, Annotated
+
+from pydantic import Field
+from coplay_mcp_server.process_discovery import discover_unity_project_roots
+from fastmcp import FastMCP
+
+from coplay_mcp_server.unity_client import UnityRpcClient
+from coplay_mcp_server.generated_tools import (
+    unity_functions_tools,
+    image_tool_tools,
+    coplay_tool_tools,
+    agent_tool_tools,
+    package_tool_tools,
+    input_action_tool_tools,
+    ui_functions_tools,
+    snapping_functions_tools,
+    scene_view_functions_tools,
+    profiler_functions_tools,
+    screenshot_tool_tools,
+)
+
+# Set binary mode for stdin/stdout/stderr on Windows
+# This is necessary for proper MCP protocol communication on Windows
+if sys.platform == 'win32':
+    import msvcrt
+    msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
+    msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
+    msvcrt.setmode(sys.stderr.fileno(), os.O_BINARY)
+
+
+def setup_logging() -> None:
+    """Set up logging configuration with support for file logging and configurable log level via environment variables.
+    
+    Environment variables:
+    - COPLAY_LOG_FILE: Path to log file (if set, logs will be written to this file)
+    - COPLAY_LOG_LEVEL: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL). Defaults to WARNING.
+    """
+    
+    # Get log level from environment variable, default to WARNING
+    log_level_str = os.getenv("COPLAY_LOG_LEVEL", "WARNING").upper()
+    log_level = getattr(logging, log_level_str, logging.WARNING)
+    
+    # Get log file path from environment variable
+    log_file = os.getenv("COPLAY_LOG_FILE")
+    
+    # Create handlers list
+    handlers = [
+        # Log to stderr (visible to MCP client)
+        logging.StreamHandler(sys.stderr),
+    ]
+    
+    # Add file handler if log file is specified
+    if log_file:
+        try:
+            # Create directory if it doesn't exist
+            log_dir = os.path.dirname(log_file)
+            if log_dir and not os.path.exists(log_dir):
+                os.makedirs(log_dir, exist_ok=True)
+            
+            file_handler = logging.FileHandler(log_file, mode='a', encoding='utf-8')
+            file_handler.setFormatter(
+                logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+            )
+            handlers.append(file_handler)
+            
+            # Log to stderr that file logging is enabled
+            sys.stderr.write(f"File logging enabled: {log_file}\n")
+        except Exception as e:
+            sys.stderr.write(f"Failed to set up file logging to {log_file}: {e}\n")
+    
+    # Configure logging
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=handlers,
+    )
+
+    # Set specific log levels for noisy libraries
+    logging.getLogger("watchdog").setLevel(logging.WARNING)
+    logging.getLogger("asyncio").setLevel(logging.WARNING)
+
+
+setup_logging()
+
+
+# Initialize FastMCP server
+mcp = FastMCP(name="coplay-mcp-server")
+
+# Global Unity client instance
+unity_client = UnityRpcClient()
+
+logger = logging.getLogger(__name__)
+
+
+@mcp.tool()
+async def set_unity_project_root(
+    unity_project_root: str
+) -> str:
+    """Set the Unity project root path for the MCP server instance. This tool should be called before using any other Unity tools."""
+    try:
+        logger.info(f"Setting Unity project root to: {unity_project_root}")
+
+        if not unity_project_root or not unity_project_root.strip():
+            raise ValueError("Unity project root cannot be empty")
+
+        # Set the Unity project root in the RPC client
+        unity_client.set_unity_project_root(unity_project_root)
+
+        result = f"Unity project root set to: {unity_project_root}"
+        logger.info("Unity project root set successfully")
+        return result
+
+    except Exception as e:
+        logger.error(f"Failed to set Unity project root: {e}")
+        raise
+
+
+@mcp.tool()
+async def list_unity_project_roots() -> Any:
+    """List all project roots of currently open Unity instances. This tool discovers all running Unity Editor instances and returns their project root directories."""
+    try:
+        logger.info("Discovering Unity project roots...")
+
+        project_roots = discover_unity_project_roots()
+        return {
+            "count": len(project_roots),
+            "projectRoots": [
+                {
+                    "projectRoot": root,
+                    "projectName": root.split("/")[-1]
+                    if "/" in root
+                    else root.split("\\")[-1],
+                }
+                for root in project_roots
+            ],
+        }
+    except Exception as e:
+        logger.error(f"Failed to list Unity project roots: {e}")
+        raise
+
+
+@mcp.tool()
+async def create_coplay_task(
+    prompt: Annotated[
+        str,
+        Field(description="The task prompt to submit"),
+    ],
+    file_paths: Annotated[
+        Optional[str],
+        Field(description="Optional comma-separated file paths to attach as context"),
+    ] = None,
+    model: Annotated[
+        Optional[str],
+        Field(description="Optional AI model to use for this task"),
+    ] = None,
+) -> Any:
+    """Creates a new task in the Unity Editor with the specified prompt and optional file attachments.
+
+    Args:
+        prompt: The task prompt to submit
+        file_paths: Optional comma-separated file paths to attach as context
+        model: Optional AI model to use for this task
+    """
+    try:
+        logger.info(f"Creating task with prompt: {prompt[:10000]}...")
+
+        params = {"prompt": prompt}
+        if file_paths:
+            params["file_paths"] = file_paths
+        if model:
+            params["model"] = model
+
+        # Always wait for completion
+        params["wait_for_completion"] = "true"
+
+        # Use a longer timeout (610 seconds) to accommodate Unity's default 600-second timeout
+        result = await unity_client.execute_request(
+            "create_task", params, timeout=610.0
+        )
+        return result
+    except Exception as e:
+        logger.error(f"Failed to create task: {e}")
+        raise
+
+
+def main():
+    """Initialize MCP server with generated tools and start serving."""
+    try:
+        logger.info("Initializing Coplay MCP Server...")
+
+        # Register all generated tools
+        tool_modules = [
+            unity_functions_tools,
+            image_tool_tools,
+            coplay_tool_tools,
+            agent_tool_tools,
+            package_tool_tools,
+            input_action_tool_tools,
+            ui_functions_tools,
+            snapping_functions_tools,
+            scene_view_functions_tools,
+            profiler_functions_tools,
+            screenshot_tool_tools,
+        ]
+
+        total_tools = 0
+        for module in tool_modules:
+            module.register_tools(mcp, unity_client)
+            # Count tools by checking for functions with @mcp.tool decorator
+            module_tools = [
+                name
+                for name in dir(module)
+                if not name.startswith("_") and name != "register_tools"
+            ]
+            total_tools += len(module_tools)
+            logger.info(f"Registered tools from {module.__name__}")
+
+        logger.info(f"Total generated tools registered: {total_tools}")
+        logger.info("Coplay MCP Server initialized successfully")
+
+        # Start the MCP server
+        mcp.run()
+
+    except Exception as e:
+        logger.error(f"Failed to initialize MCP server: {e}")
+        raise
+
+
+if __name__ == "__main__":
+    main()