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

coplay_mcp_server/__init__.py

@@ -0,0 +1,3 @@
+"""Coplay MCP Server - Unity Editor integration via MCP protocol."""
+
+__version__ = "1.2.1"

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,228 @@
+"""Main entry point for Coplay MCP Server using FastMCP."""
+
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from .process_discovery import discover_unity_project_roots
+from mcp.server.fastmcp import Context, FastMCP
+from mcp import ServerSession
+
+from .unity_client import UnityRpcClient
+
+
+def setup_logging() -> None:
+    """Set up logging configuration."""
+
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        handlers=[
+            # Log errors to stderr (visible to MCP client)
+            logging.StreamHandler(sys.stderr),
+        ]
+    )
+    
+    # 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,
+    ctx: Context[ServerSession, None]
+) -> 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(ctx: Context[ServerSession, None]) -> 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 execute_script(
+    file_path: str,
+    method_name: str = "Execute",
+    arguments: Optional[Dict[str, Any]] = None,
+    ctx: Context[ServerSession, None] = None
+) -> Any:
+    """Execute arbitrary C# code inside of the Unity Editor. The supplied code file must contain a class with a public static method that can be specified via method_name parameter (defaults to 'Execute'). This static method can return an object which will be serialized to JSON."""
+    try:
+        logger.info(f"Executing script: {file_path}, method: {method_name}")
+        
+        params = {
+            "filePath": file_path,
+            "methodName": method_name
+        }
+        if arguments:
+            params["arguments"] = arguments
+            
+        return await unity_client.execute_request("executeScript", params)
+    except Exception as e:
+        logger.error(f"Failed to execute script: {e}")
+        raise
+
+
+@mcp.tool()
+async def get_unity_logs(
+    skip: int,
+    limit: int,
+    show_logs: bool = True,
+    show_warnings: bool = True,
+    show_errors: bool = True,
+    search_term: Optional[str] = None,
+    ctx: Context[ServerSession, None] = None
+) -> Any:
+    """Gets logs sorted from newest to oldest, applying filtering and pagination."""
+    try:
+        logger.debug(f"Getting Unity logs: skip={skip}, limit={limit}")
+        
+        params = {
+            "skip": skip,
+            "limit": limit,
+            "showLogs": show_logs,
+            "showWarnings": show_warnings,
+            "showErrors": show_errors
+        }
+        if search_term:
+            params["searchTerm"] = search_term
+            
+        return await unity_client.execute_request("getUnityLogs", params)
+    except Exception as e:
+        logger.error(f"Failed to get Unity logs: {e}")
+        raise
+
+
+@mcp.tool()
+async def get_unity_editor_state(ctx: Context[ServerSession, None]) -> Any:
+    """Retrieve the current state of the Unity Editor, excluding scene hierarchy."""
+    try:
+        logger.info("Getting Unity Editor state...")
+        
+        result = await unity_client.execute_request("getUnityEditorState", {})
+        return result
+        
+    except Exception as e:
+        logger.error(f"Failed to get Unity Editor state: {e}")
+        raise
+
+
+@mcp.tool()
+async def list_game_objects_in_hierarchy(
+    reference_object_path: Optional[str] = None,
+    name_filter: Optional[str] = None,
+    tag_filter: Optional[str] = None,
+    component_filter: Optional[str] = None,
+    include_inactive: Optional[bool] = None,
+    limit: Optional[int] = None,
+    skip: Optional[int] = None,
+    only_paths: Optional[bool] = None,
+    ctx: Context[ServerSession, None] = None
+) -> Any:
+    """List game objects in the hierarchy with optional filtering capabilities. Uses breadth-first traversal to prioritize objects closer to the root. Results are truncated if they exceed the limit, with a message indicating the truncation."""
+    try:
+        logger.debug("Listing game objects in hierarchy...")
+        
+        params = {}
+        if reference_object_path is not None:
+            params["referenceObjectPath"] = reference_object_path
+        if name_filter is not None:
+            params["nameFilter"] = name_filter
+        if tag_filter is not None:
+            params["tagFilter"] = tag_filter
+        if component_filter is not None:
+            params["componentFilter"] = component_filter
+        if include_inactive is not None:
+            params["includeInactive"] = include_inactive
+        if limit is not None:
+            params["limit"] = limit
+        if skip is not None:
+            params["skip"] = skip
+        if only_paths is not None:
+            params["onlyPaths"] = only_paths
+            
+        return await unity_client.execute_request("listGameObjectsInHierarchy", params)
+    except Exception as e:
+        logger.error(f"Failed to list game objects: {e}")
+        raise
+
+
+@mcp.tool()
+async def create_coplay_task(
+    prompt: str,
+    file_paths: Optional[str] = None,
+    model: Optional[str] = None,
+    ctx: Context[ServerSession, None] = None
+) -> Any:
+    """Creates a new task in the Unity Editor with the specified prompt and optional file attachments. This will start a new chat thread and submit the prompt for processing."""
+    try:
+        logger.info(f"Creating task with prompt: {prompt[:100]}...")
+        
+        params = {"prompt": prompt}
+        if file_paths:
+            params["file_paths"] = file_paths
+        if model:
+            params["model"] = model
+            
+        result = await unity_client.execute_request("createTask", params)
+        return result
+    except Exception as e:
+        logger.error(f"Failed to create task: {e}")
+        raise
+
+
+def main():
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

coplay_mcp_server/unity_client.py

@@ -0,0 +1,224 @@
+"""Unity RPC client for file-based communication with Unity Editor."""
+
+import asyncio
+import json
+import logging
+import uuid
+from pathlib import Path
+from typing import Any, Dict, Optional
+import concurrent.futures
+
+import aiofiles
+from watchdog.events import FileSystemEventHandler
+from watchdog.observers import Observer
+
+logger = logging.getLogger(__name__)
+
+
+class UnityRpcClient:
+    """Client for communicating with Unity Editor via file-based RPC."""
+
+    def __init__(self) -> None:
+        self._unity_project_root: Optional[str] = None
+        self._pending_requests: Dict[str, concurrent.futures.Future[Any]] = {}
+        self._observer: Optional[Observer] = None
+        self._response_handler: Optional[ResponseFileHandler] = None
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+
+    def set_unity_project_root(self, project_root: str) -> None:
+        """Set the Unity project root and start watching for responses."""
+        if self._unity_project_root == project_root:
+            return
+
+        # Stop existing watcher if any
+        self._stop_file_watcher()
+
+        self._unity_project_root = project_root
+        self._start_file_watcher()
+        logger.info(f"Unity project root set to: {project_root}")
+
+    def _start_file_watcher(self) -> None:
+        """Start watching for response files."""
+        if not self._unity_project_root:
+            return
+
+        requests_dir = Path(self._unity_project_root) / "Temp" / "Coplay" / "MCPRequests"
+        if not requests_dir.exists():
+            logger.warning(f"Unity requests directory does not exist: {requests_dir}")
+            return
+
+        # Store the current event loop for thread-safe communication
+        try:
+            self._loop = asyncio.get_running_loop()
+        except RuntimeError:
+            logger.warning("No running event loop found, file watching may not work properly")
+            return
+
+        self._response_handler = ResponseFileHandler(self._handle_response_file_sync, self._loop)
+        self._observer = Observer()
+        self._observer.schedule(
+            self._response_handler,
+            str(requests_dir),
+            recursive=False
+        )
+        self._observer.start()
+        logger.info(f"Started watching for responses in: {requests_dir}")
+
+    def _stop_file_watcher(self) -> None:
+        """Stop watching for response files."""
+        if self._observer:
+            self._observer.stop()
+            self._observer.join()
+            self._observer = None
+            self._response_handler = None
+
+    def _handle_response_file_sync(self, file_path: Path) -> None:
+        """Handle a response file from Unity (synchronous version for thread safety)."""
+        try:
+            logger.info(f"Handling file change: {file_path}")
+
+            if not file_path.name.startswith("response_") or not file_path.name.endswith(".json"):
+                return
+
+            # Read response file synchronously
+            try:
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    response_json = f.read()
+            except Exception as e:
+                logger.error(f"Failed to read response file {file_path}: {e}")
+                return
+
+            response_data = json.loads(response_json)
+            request_id = response_data.get('id')
+            if request_id not in self._pending_requests:
+                logger.warning(f"No pending request found for ID: {request_id}")
+                return
+
+            future = self._pending_requests.pop(request_id)
+
+            if "error" in response_data and response_data["error"]:
+                error_msg = response_data["error"]
+                if isinstance(error_msg, dict):
+                    error_msg = error_msg.get("message", str(error_msg))
+                future.set_exception(Exception(str(error_msg)))
+            else:
+                future.set_result(response_data.get("result"))
+
+            # Clean up response file
+            try:
+                file_path.unlink()
+                logger.debug(f"Deleted response file: {file_path}")
+            except Exception as e:
+                logger.warning(f"Failed to delete response file {file_path}: {e}")
+
+        except Exception as e:
+            logger.error(f"Error handling response file {file_path}: {e}")
+
+    async def execute_request(
+        self,
+        method: str,
+        params: Optional[Dict[str, Any]] = None,
+        timeout: float = 60.0
+    ) -> Any:
+        """Execute an RPC request to Unity Editor."""
+        if not self._unity_project_root:
+            raise RuntimeError("Unity project root is not set. Call set_unity_project_root first.")
+
+        requests_dir = Path(self._unity_project_root) / "Temp" / "Coplay" / "MCPRequests"
+        if not requests_dir.exists():
+            raise RuntimeError("Unity Editor is not running at the specified project root")
+
+        request_id = str(uuid.uuid4())
+        request_file = requests_dir / f"req_{request_id}.json"
+
+        # Create request data
+        request_data = {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "method": method,
+            "params": params or {}
+        }
+
+        # Create concurrent.futures.Future for thread-safe completion
+        future: concurrent.futures.Future[Any] = concurrent.futures.Future()
+        self._pending_requests[request_id] = future
+
+        try:
+            # Write request file
+            async with aiofiles.open(request_file, 'w', encoding='utf-8') as f:
+                await f.write(json.dumps(request_data, indent=2))
+
+            logger.debug(f"Created request file: {request_file}")
+
+            # Wait for response with timeout using asyncio.wrap_future
+            try:
+                wrapped_future = asyncio.wrap_future(future)
+                result = await asyncio.wait_for(wrapped_future, timeout=timeout)
+                return result
+            except asyncio.TimeoutError:
+                raise TimeoutError(f"Request {method} timed out after {timeout} seconds")
+
+        except Exception as e:
+            # Clean up on error
+            self._pending_requests.pop(request_id, None)
+            try:
+                if request_file.exists():
+                    request_file.unlink()
+            except Exception:
+                pass
+            raise e
+
+    def close(self) -> None:
+        """Close the Unity RPC client and clean up resources."""
+        self._stop_file_watcher()
+        
+        # Cancel any pending requests
+        for future in self._pending_requests.values():
+            if not future.done():
+                future.cancel()
+        self._pending_requests.clear()
+
+
+class ResponseFileHandler(FileSystemEventHandler):
+    """File system event handler for Unity response files."""
+
+    def __init__(self, callback, loop: Optional[asyncio.AbstractEventLoop] = None) -> None:
+        super().__init__()
+        self._callback = callback
+        self._loop = loop
+        self._processed_files: set[str] = set()
+        self._executor = concurrent.futures.ThreadPoolExecutor(max_workers=2)
+
+    def on_created(self, event) -> None:
+        """Handle file creation events."""
+        if event.is_directory:
+            return
+
+        file_path = Path(event.src_path)
+        if file_path.name.startswith("response_") and file_path.name.endswith(".json"):
+            self._process_file_threadsafe(file_path)
+
+    def on_modified(self, event) -> None:
+        """Handle file modification events."""
+        if event.is_directory:
+            return
+
+        file_path = Path(event.src_path)
+        if file_path.name.startswith("response_") and file_path.name.endswith(".json"):
+            # Avoid processing the same file multiple times
+            if str(file_path) not in self._processed_files:
+                self._processed_files.add(str(file_path))
+                self._process_file_threadsafe(file_path)
+
+    def _process_file_threadsafe(self, file_path: Path) -> None:
+        """Process a response file in a thread-safe manner."""
+        def process_with_delay():
+            # Small delay to ensure file is fully written
+            import time
+            time.sleep(0.1)
+            
+            if file_path.exists():
+                self._callback(file_path)
+        
+        # Submit to thread pool to avoid blocking the file watcher
+        self._executor.submit(process_with_delay)

coplay_mcp_server-1.2.1.dist-info/METADATA

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: coplay-mcp-server
+Version: 1.2.1
+Summary: A Model Context Protocol (MCP) server for Coplay, providing Unity integration capabilities
+Project-URL: Homepage, https://coplay.dev/
+Project-URL: Repository, https://github.com/CoplayDev/coplay-unity-plugin
+Project-URL: Documentation, https://docs.coplay.dev/
+Project-URL: Issues, https://github.com/CoplayDev/coplay-unity-plugin/issues
+Author-email: Coplay Dev <dev@coplay.com>
+Maintainer-email: Coplay Dev <dev@coplay.com>
+License: MIT
+License-File: LICENSE
+Keywords: coplay,mcp,model-context-protocol,unity,unity-editor
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Requires-Dist: aiofiles>=24.1.0
+Requires-Dist: anyio>=4.10.0
+Requires-Dist: mcp[cli]>=1.12.4
+Requires-Dist: psutil>=7.0.0
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: watchdog>=6.0.0
+Description-Content-Type: text/markdown
+
+# Coplay MCP Server
+
+A Model Context Protocol (MCP) server for Coplay, providing Unity Editor integration capabilities through MCP tools.
+
+## Features
+
+- **Unity Project Discovery**: Automatically discover running Unity Editor instances and their project roots
+- **Unity Editor State**: Retrieve current Unity Editor state and scene hierarchy information
+- **Script Execution**: Execute arbitrary C# scripts within the Unity Editor
+- **Log Management**: Access and filter Unity console logs
+- **GameObject Hierarchy**: List and filter GameObjects in the scene hierarchy
+- **Task Creation**: Create new Coplay tasks directly from MCP clients
+
+## Usage
+
+### As an MCP server
+
+Add to your MCP client configuration:
+
+```json
+{
+  "mcpServers": {
+    "coplay-testpypi": {
+      "autoApprove": [],
+      "disabled": false,
+      "timeout": 60,
+      "type": "stdio",
+      "command": "uvx",
+      "args": [
+        "coplay-mcp-server@latest"
+      ]
+    }
+  }
+}
+```
+
+## Available Tools
+
+- `set_unity_project_root` - Set the Unity project root path
+- `list_unity_project_roots` - Discover all running Unity Editor instances
+- `execute_script` - Execute C# scripts in Unity Editor
+- `get_unity_logs` - Retrieve Unity console logs with filtering
+- `get_unity_editor_state` - Get current Unity Editor state
+- `list_game_objects_in_hierarchy` - List GameObjects with filtering options
+- `create_coplay_task` - Create new Coplay tasks
+
+## Development
+
+To launch the server in development mode:
+
+```bash
+uv run mcp dev coplay_mcp_server/server.py
+```
+
+### Prerequisites
+
+- Python 3.11+
+- [uv](https://docs.astral.sh/uv/) package manager
+- Unity Editor with Coplay plugin installed
+
+### Project Structure
+
+- `coplay_mcp_server/server.py` - Main MCP server implementation
+- `coplay_mcp_server/unity_client.py` - Unity RPC client for communication
+- `coplay_mcp_server/process_discovery.py` - Process discovery utilities
+- `pyproject.toml` - Project configuration and dependencies
+
+## License
+
+MIT License - see LICENSE file for details.

coplay_mcp_server-1.2.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+coplay_mcp_server/__init__.py,sha256=h8oQ4XIoeJ86DSsfvAq_1luDAHU2nHr4L6er3wCPdN8,95
+coplay_mcp_server/process_discovery.py,sha256=kcY7dlyNJUG3EjdDJKAzf_8RqqM2zgqpjK6ZJTqc4aU,6151
+coplay_mcp_server/server.py,sha256=g4EcyUvO6C-ZPT1cblixbJ1sBHndt34oihRbQxuIFuk,7792
+coplay_mcp_server/unity_client.py,sha256=bPzDv9-dsS0tXha-Q9BBedoW63L5GadFHJXQOrOXEZA,8622
+coplay_mcp_server-1.2.1.dist-info/METADATA,sha256=_KJ98ZbPtNQ55naSVXxyx-VR-d13VlQwEMeMwORU1xw,3263
+coplay_mcp_server-1.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+coplay_mcp_server-1.2.1.dist-info/entry_points.txt,sha256=FYOh7Ksh98Q-cp6pgvof0dLlgR8vyMl8VFeKhGVxgjI,68
+coplay_mcp_server-1.2.1.dist-info/licenses/LICENSE,sha256=K3xG9ipglyxcG95EQnM3rAnOAbRQ7wsB3GsQAaIo6Ho,1088
+coplay_mcp_server-1.2.1.dist-info/RECORD,,

coplay_mcp_server-1.2.1.dist-info/WHEEL

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

coplay_mcp_server-1.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+coplay-mcp-server = coplay_mcp_server.server:main

coplay_mcp_server-1.2.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Coplay Dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.