iflow-mcp_czh2774-cocosmcp 1.0.0__py3-none-any.whl

Python/__init__.py

@@ -0,0 +1 @@
+# Cocos MCP Server Package

Python/cocos_connection.py

@@ -0,0 +1,154 @@
+import socket
+import json
+import logging
+from dataclasses import dataclass
+from typing import Dict, Any, Optional
+from config import config
+
+# Configure logging
+logging.basicConfig(
+    level=getattr(logging, config.log_level),
+    format=config.log_format,
+    filename=config.log_file,
+    filemode='a'
+)
+logger = logging.getLogger("CocosMCP")
+
+@dataclass
+class CocosConnection:
+    """Manages the socket connection to the Cocos Creator Editor."""
+    host: str = config.cocos_host
+    port: int = config.cocos_port
+    sock: Optional[socket.socket] = None
+
+    def connect(self) -> bool:
+        """Establish a connection to the Cocos Creator Editor."""
+        if self.sock:
+            return True
+        try:
+            self.sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+            self.sock.connect((self.host, self.port))
+            logger.info(f"Connected to Cocos Creator at {self.host}:{self.port}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to Cocos Creator: {str(e)}")
+            self.sock = None
+            return False
+
+    def disconnect(self):
+        """Close the connection to the Cocos Creator Editor."""
+        if self.sock:
+            try:
+                self.sock.close()
+            except Exception as e:
+                logger.error(f"Error disconnecting from Cocos Creator: {str(e)}")
+            finally:
+                self.sock = None
+
+    def receive_full_response(self, sock, buffer_size=config.buffer_size) -> bytes:
+        """Receive a complete response from Cocos Creator, handling chunked data."""
+        chunks = []
+        sock.settimeout(config.connection_timeout)  # Use timeout from config
+        try:
+            while True:
+                chunk = sock.recv(buffer_size)
+                if not chunk:
+                    if not chunks:
+                        raise Exception("Connection closed before receiving data")
+                    break
+                chunks.append(chunk)
+                
+                # Process the data received so far
+                data = b''.join(chunks)
+                decoded_data = data.decode('utf-8')
+                
+                # Check if we've received a complete response
+                try:
+                    # Special case for ping-pong
+                    if decoded_data.strip().startswith('{"status":"success","result":{"message":"pong"'):
+                        logger.debug("Received ping response")
+                        return data
+                    
+                    # Validate JSON format
+                    json.loads(decoded_data)
+                    
+                    # If we get here, we have valid JSON
+                    logger.info(f"Received complete response ({len(data)} bytes)")
+                    return data
+                except json.JSONDecodeError:
+                    # We haven't received a complete valid JSON response yet
+                    continue
+                except Exception as e:
+                    logger.warning(f"Error processing response chunk: {str(e)}")
+                    # Continue reading more chunks as this might not be the complete response
+                    continue
+        except socket.timeout:
+            logger.warning("Socket timeout during receive")
+            raise Exception("Timeout receiving Cocos Creator response")
+        except Exception as e:
+            logger.error(f"Error during receive: {str(e)}")
+            raise
+
+    def send_command(self, command_type: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        """发送命令到 Cocos Creator 并返回响应(同步版本)."""
+        if not self.sock and not self.connect():
+            raise ConnectionError("Not connected to Cocos Creator")
+        
+        # Special handling for ping command
+        if command_type == "ping":
+            try:
+                logger.debug("Sending ping to verify connection")
+                self.sock.sendall(b"ping")
+                response_data = self.receive_full_response(self.sock)
+                response = json.loads(response_data.decode('utf-8'))
+                
+                if response.get("status") != "success":
+                    logger.warning("Ping response was not successful")
+                    self.sock = None
+                    raise ConnectionError("Connection verification failed")
+                    
+                return {"message": "pong"}
+            except Exception as e:
+                logger.error(f"Ping error: {str(e)}")
+                self.sock = None
+                raise ConnectionError(f"Connection verification failed: {str(e)}")
+        
+        # Normal command handling
+        command = {"type": command_type, "params": params or {}}
+        try:
+            logger.info(f"Sending command: {command_type} with params: {params}")
+            self.sock.sendall(json.dumps(command).encode('utf-8'))
+            response_data = self.receive_full_response(self.sock)
+            response = json.loads(response_data.decode('utf-8'))
+            
+            if response.get("status") == "error":
+                error_message = response.get("error") or response.get("message", "Unknown Cocos Creator error")
+                logger.error(f"Cocos Creator error: {error_message}")
+                raise Exception(error_message)
+            
+            result = response.get("result", {})
+            logger.debug(f"Command result: {result}")
+            return result
+        except Exception as e:
+            logger.error(f"Communication error with Cocos Creator: {str(e)}")
+            self.sock = None
+            raise Exception(f"Failed to communicate with Cocos Creator: {str(e)}")
+            
+    async def send_command_async(self, command_type: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        """发送命令到 Cocos Creator 并返回响应(异步版本)."""
+        # 这里我们直接调用同步版本，因为异步处理的问题较多
+        # 在实际应用中，如果需要真正的异步，应该使用异步IO库
+        return self.send_command(command_type, params)
+
+# Global connection instance
+_connection: Optional[CocosConnection] = None
+
+def get_cocos_connection() -> CocosConnection:
+    """Get the global Cocos Creator connection instance."""
+    global _connection
+    if _connection is None:
+        _connection = CocosConnection()
+        if not _connection.connect():
+            logger.error("Failed to establish initial connection to Cocos Creator")
+    
+    return _connection 

Python/config.py

@@ -0,0 +1,30 @@
+"""
+Configuration settings for the Cocos MCP Server.
+This file contains all configurable parameters for the server.
+"""
+
+from dataclasses import dataclass
+
+@dataclass
+class ServerConfig:
+    """Main configuration class for the MCP server."""
+    
+    # Cocos Creator connection settings
+    cocos_host: str = "::1"  # 使用IPv6地址
+    cocos_port: int = 6400
+    
+    # Connection settings
+    connection_timeout: float = 5.0  # 5 seconds timeout
+    buffer_size: int = 8192  # 8KB buffer size
+    
+    # Logging settings
+    log_level: str = "INFO"
+    log_format: str = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    log_file: str = "cocos_mcp.log"
+    
+    # Server settings
+    max_retries: int = 3
+    retry_delay: float = 1.0
+
+# Create a global config instance
+config = ServerConfig() 

Python/log_client.py

@@ -0,0 +1,127 @@
+import asyncio
+import websockets
+import json
+from typing import Dict, Any, Optional, List, Callable
+
+class LogClient:
+    def __init__(self, uri=None, host='127.0.0.1', port=8765):
+        if uri:
+            self.uri = uri
+        else:
+            self.uri = f'ws://{host}:{port}/logs'
+        self.ws = None
+        self.log_callback = None
+        self.connected = False
+
+    async def connect(self):
+        """连接到日志服务器"""
+        try:
+            self.ws = await websockets.connect(self.uri)
+            self.connected = True
+            print(f"Successfully connected to {self.uri}")
+            # 启动日志监听
+            asyncio.create_task(self._listen_logs())
+            return True
+        except Exception as e:
+            print(f"Failed to connect to log server: {e}")
+            self.connected = False
+            return False
+
+    async def _listen_logs(self):
+        """监听日志消息"""
+        if not self.ws:
+            return
+            
+        while True:
+            try:
+                message = await self.ws.recv()
+                data = json.loads(message)
+                if data.get('type') == 'log' and self.log_callback:
+                    await self.log_callback(data['data'])
+            except websockets.exceptions.ConnectionClosed:
+                print("WebSocket connection closed")
+                self.connected = False
+                break
+            except Exception as e:
+                print(f"Error listening to logs: {e}")
+                break
+
+    async def query_logs(self, show_logs: bool = True, show_warnings: bool = True,
+                        show_errors: bool = True, search_term: Optional[str] = None) -> Dict[str, Any]:
+        """查询日志"""
+        if not self.ws or not self.connected:
+            return {"error": "Not connected to log server"}
+            
+        try:
+            message = {
+                'type': 'query-logs',
+                'params': {
+                    'showLogs': show_logs,
+                    'showWarnings': show_warnings,
+                    'showErrors': show_errors,
+                    'searchTerm': search_term
+                }
+            }
+            await self.ws.send(json.dumps(message))
+            response = await self.ws.recv()
+            return json.loads(response)
+        except Exception as e:
+            print(f"Error querying logs: {e}")
+            return {"error": str(e)}
+
+    async def clear_logs(self) -> Dict[str, Any]:
+        """清除日志"""
+        if not self.ws or not self.connected:
+            return {"error": "Not connected to log server"}
+            
+        try:
+            message = {
+                'type': 'clear-logs'
+            }
+            await self.ws.send(json.dumps(message))
+            response = await self.ws.recv()
+            return json.loads(response)
+        except Exception as e:
+            print(f"Error clearing logs: {e}")
+            return {"error": str(e)}
+
+    def on_log(self, callback: Callable[[Dict[str, Any]], None]):
+        """设置日志回调函数"""
+        self.log_callback = callback
+
+    async def close(self):
+        """关闭连接"""
+        if self.ws:
+            try:
+                await self.ws.close()
+                self.connected = False
+                print("Connection to log server closed")
+            except Exception as e:
+                print(f"Error closing connection: {e}")
+
+async def main():
+    # 示例用法
+    client = LogClient()
+    if await client.connect():
+        # 设置日志回调
+        async def log_callback(log_data):
+            print(f"Received log: {log_data}")
+        
+        client.on_log(log_callback)
+
+        # 查询日志示例
+        logs = await client.query_logs(search_term="error")
+        print(f"Query result: {logs}")
+
+        # 清除日志示例
+        result = await client.clear_logs()
+        print(f"Clear result: {result}")
+
+        # 保持连接一段时间以接收实时日志
+        await asyncio.sleep(60)
+        await client.close()
+    else:
+        print("Failed to connect to log server")
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

Python/requirements.txt

@@ -0,0 +1,6 @@
+# MCP协议依赖
+mcp>=0.1.0
+
+# 类型提示支持
+typing-extensions>=4.0.0
+dataclasses>=0.6

Python/server.py

@@ -0,0 +1,84 @@
+from mcp.server.fastmcp import FastMCP, Context, Image
+import logging
+from dataclasses import dataclass
+from contextlib import asynccontextmanager
+from typing import AsyncIterator, Dict, Any, List
+from config import config
+from tools import register_all_tools
+from cocos_connection import get_cocos_connection
+
+# Configure logging using settings from config
+logging.basicConfig(
+    level=getattr(logging, config.log_level),
+    format=config.log_format,
+    filename=config.log_file,
+    filemode='a'
+)
+logger = logging.getLogger("CocosMCP")
+
+@asynccontextmanager
+async def server_lifespan(server: FastMCP) -> AsyncIterator[Dict[str, Any]]:
+    """Handle server startup and shutdown."""
+    logger.info("CocosMCP server starting up")
+    try:
+        # 尝试连接到Cocos Creator
+        cocos_connection = get_cocos_connection()
+        try:
+            # 验证连接是否有效 - 使用同步方式
+            # 我们直接使用socket发送ping而不是调用异步方法
+            cocos_connection.sock.sendall(b"ping")
+            response_data = cocos_connection.receive_full_response(cocos_connection.sock)
+            logger.info("Connected to Cocos Creator on startup")
+        except Exception as e:
+            logger.warning(f"Could not verify Cocos Creator connection: {str(e)}")
+    except Exception as e:
+        logger.warning(f"Could not connect to Cocos Creator on startup: {str(e)}")
+    
+    try:
+        yield {}
+    finally:
+        # 获取连接并断开
+        try:
+            cocos_connection = get_cocos_connection()
+            cocos_connection.disconnect()
+        except:
+            pass
+        logger.info("CocosMCP server shut down")
+
+# Initialize MCP server
+mcp = FastMCP(
+    "CocosMCP",
+    lifespan=server_lifespan
+)
+
+# Add prompt to explain tool usage
+@mcp.prompt()
+def log_management_guide() -> str:
+    """Guide for managing Cocos Creator logs."""
+    return (
+        "Cocos Creator MCP Tools Guide:\n\n"
+        "1. **Querying Logs**\n"
+        "   - `query_logs(show_logs=True, show_warnings=True, show_errors=True, search_term=None)` - Read and filter Cocos Creator Console logs\n"
+        "2. **Clearing Logs**\n"
+        "   - `clear_logs()` - Clear all console logs\n"
+        "3. **Checking Connection**\n"
+        "   - `connection_status()` - Check if connected to Cocos Creator\n\n"
+        "4. **Best Practices**\n"
+        "   - Always check connection status before performing operations\n"
+        "   - Use search terms to filter console output when debugging\n"
+        "   - Clear logs before major operations to make debugging easier\n"
+        "   - Filter by log types when looking for specific issues\n"
+    )
+
+# Register all tools
+register_all_tools(mcp)
+
+def main():
+    """Main entry point for the MCP server."""
+    logger.info("Starting CocosMCP server")
+    # Use stdio transport for Cursor integration
+    mcp.run(transport='stdio')
+
+# Run the server
+if __name__ == "__main__":
+    main()

Python/start_server.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# 确保我们使用正确的 Python
+PYTHON_PATH="/opt/homebrew/bin/python3"
+
+# 检查 mcp 模块是否可用，如果不可用则安装
+$PYTHON_PATH -c "import mcp" 2>/dev/null || $PYTHON_PATH -m pip install mcp --break-system-packages
+
+# 设置 PYTHONPATH 以确保可以找到所有模块
+cd "$(dirname "$0")"
+export PYTHONPATH=$PYTHONPATH:$(pwd)
+
+# 打印一些有用的信息
+echo "Starting Cocos MCP server with Python: $PYTHON_PATH"
+echo "PYTHONPATH: $PYTHONPATH"
+echo "Current directory: $(pwd)"
+
+# 启动服务器
+$PYTHON_PATH server.py 

Python/tools/__init__.py

@@ -0,0 +1,98 @@
+from .log_tools import register_log_tools
+import sys
+import os
+# 添加父目录到路径以便导入
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from cocos_connection import get_cocos_connection
+from mcp.server.fastmcp import Context
+from typing import Dict, Any, Optional
+import logging
+
+# 尝试导入 scene_tools，如果不存在则跳过
+try:
+    from .scene_tools import SceneTools
+    HAS_SCENE_TOOLS = True
+except ImportError:
+    HAS_SCENE_TOOLS = False
+
+def register_all_tools(mcp):
+    """Register all tools with the MCP server."""
+    register_log_tools(mcp)
+    
+    # 如果场景工具可用则注册
+    if HAS_SCENE_TOOLS:
+        register_scene_tools(mcp)
+    
+def register_scene_tools(mcp):
+    """Register scene tools with the MCP server."""
+    if not HAS_SCENE_TOOLS:
+        return
+    
+    # 创建一个SceneTools实例
+    cocos_client = get_cocos_connection()
+    scene_tools = SceneTools(cocos_client)
+    
+    # 1. 打开场景工具
+    def open_scene(ctx: Context, scene_uuid: str) -> Dict[str, Any]:
+        """
+        打开指定UUID的场景
+        
+        Args:
+            scene_uuid: 场景资源的UUID
+            
+        Returns:
+            操作结果
+        """
+        logging.info(f"MCP处理open_scene请求: {scene_uuid}")
+        
+        if not scene_uuid:
+            return {"success": False, "error": "Missing scene_uuid parameter"}
+            
+        try:
+            # 直接调用SceneTools的方法并返回结果
+            result = scene_tools.open_scene(scene_uuid)
+            return result
+        except Exception as e:
+            logging.error(f"open_scene错误: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+    
+    # 2. 获取场景信息工具
+    def get_scene_info(ctx: Context) -> Dict[str, Any]:
+        """
+        获取当前场景信息
+        
+        Returns:
+            场景信息
+        """
+        logging.info("MCP处理get_scene_info请求")
+        
+        try:
+            # 调用SceneTools的方法
+            result = scene_tools.get_scene_info()
+            return result
+        except Exception as e:
+            logging.error(f"get_scene_info错误: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+    
+    # 4. 列出场景节点工具
+    def list_scene_nodes(ctx: Context) -> Dict[str, Any]:
+        """
+        列出场景中的所有节点
+        
+        Returns:
+            节点列表
+        """
+        logging.info("MCP处理list_scene_nodes请求")
+        
+        try:
+            # 调用SceneTools的方法
+            result = scene_tools.list_scene_nodes()
+            return result
+        except Exception as e:
+            logging.error(f"list_scene_nodes错误: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+    
+    # 注册工具
+    mcp.tool(name="open_scene")(open_scene)
+    mcp.tool(name="get_scene_info")(get_scene_info)
+    mcp.tool(name="list_scene_nodes")(list_scene_nodes)

Python/tools/log_tools.py

@@ -0,0 +1,117 @@
+import logging
+from typing import Dict, Any, Optional, List
+from mcp.server.fastmcp import Context
+from cocos_connection import get_cocos_connection
+
+# Get the logger
+logger = logging.getLogger("CocosMCP")
+
+async def query_logs(
+    ctx: Context,
+    show_logs: bool = True,
+    show_warnings: bool = True,
+    show_errors: bool = True,
+    search_term: Optional[str] = None,
+    module_filter: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Query Cocos Creator editor logs with optional filtering.
+    
+    Args:
+        show_logs: Include regular logs in results
+        show_warnings: Include warning logs in results
+        show_errors: Include error logs in results
+        search_term: Optional search term to filter logs
+        module_filter: Optional module name to filter logs (e.g. "Scene", "Assets")
+    
+    Returns:
+        Dictionary containing filtered logs
+    """
+    try:
+        cocos = get_cocos_connection()
+        # 保存日志请求的副本，因为我们要修改它
+        params = {
+            "show_logs": show_logs,
+            "show_warnings": show_warnings,
+            "show_errors": show_errors
+        }
+        
+        # 只有在提供了 search_term 且非空且是字符串类型时才添加
+        if search_term and isinstance(search_term, str) and search_term.strip():
+            logger.info(f"Adding search term to log query: {search_term}")
+            params["search_term"] = search_term.strip()
+            
+        # 添加模块过滤
+        if module_filter and isinstance(module_filter, str) and module_filter.strip():
+            logger.info(f"Adding module filter to log query: {module_filter}")
+            params["module_filter"] = module_filter.strip()
+            
+        result = cocos.send_command("QUERY_LOGS", params)
+        return result
+    except Exception as e:
+        logger.error(f"Error querying logs: {e}")
+        return {"error": str(e), "logs": []}
+
+async def clear_logs(ctx: Context) -> Dict[str, Any]:
+    """
+    Clear all Cocos Creator editor logs.
+    
+    Returns:
+        Success status and message
+    """
+    try:
+        cocos = get_cocos_connection()
+        result = cocos.send_command("CLEAR_LOGS", {})
+        return result
+    except Exception as e:
+        logger.error(f"Error clearing logs: {e}")
+        return {"error": str(e)}
+
+async def connection_status(ctx: Context) -> Dict[str, Any]:
+    """
+    Check the connection status to Cocos Creator.
+    
+    Returns:
+        Dictionary with connection status information
+    """
+    try:
+        cocos = get_cocos_connection()
+        # Try a ping command to verify connection
+        cocos.send_command("ping")
+        return {
+            "connected": True,
+            "host": cocos.host,
+            "port": cocos.port
+        }
+    except Exception as e:
+        logger.error(f"Connection check failed: {e}")
+        return {
+            "connected": False,
+            "error": str(e)
+        }
+
+def log_management_guide() -> str:
+    """Guide for managing Cocos Creator logs."""
+    return (
+        "Cocos Creator MCP Log Tools Guide:\n\n"
+        "1. **Querying Logs**\n"
+        "   - `query_logs(show_logs=True, show_warnings=True, show_errors=True, search_term=None, module_filter=None)` - Read and filter Cocos Creator Console logs\n"
+        "     - Use `module_filter` to filter logs by specific modules (e.g. 'Scene', 'Assets')\n"
+        "2. **Clearing Logs**\n"
+        "   - `clear_logs()` - Clear all console logs\n"
+        "3. **Checking Connection**\n"
+        "   - `connection_status()` - Check if connected to Cocos Creator\n\n"
+        "4. **Best Practices**\n"
+        "   - Always check connection status before performing operations\n"
+        "   - Use module filters to focus on specific components (e.g. 'Scene', 'Assets')\n"
+        "   - Use search terms to filter console output when debugging\n"
+        "   - Clear logs before major operations to make debugging easier\n"
+        "   - Filter by log types when looking for specific issues\n"
+    )
+
+def register_log_tools(mcp):
+    """Register all log tools with the MCP server."""
+    mcp.tool()(query_logs)
+    mcp.tool()(clear_logs)
+    mcp.tool()(connection_status)
+    mcp.prompt()(log_management_guide) 

Python/tools/scene_tools.py

@@ -0,0 +1,85 @@
+import logging
+from typing import Dict, Any, Optional, List
+
+class SceneTools:
+    """场景操作工具类"""
+    
+    def __init__(self, cocos_client) -> None:
+        """
+        初始化场景工具
+        
+        Args:
+            cocos_client: Cocos TCP 客户端实例
+        """
+        self.cocos_client = cocos_client
+        logging.info("SceneTools initialized")
+        
+    def open_scene(self, scene_uuid: str) -> Dict[str, Any]:
+        """
+        打开指定UUID的场景
+        
+        Args:
+            scene_uuid: 场景资源的UUID
+            
+        Returns:
+            操作结果
+        """
+        try:
+            logging.info(f"向Cocos Creator发送打开场景命令: {scene_uuid}")
+            
+            # 发送命令并获取响应 - 使用同步方式
+            response = self.cocos_client.send_command("OPEN_SCENE", {"sceneUuid": scene_uuid})
+            
+            # 记录响应
+            logging.info(f"Cocos Creator响应: {response}")
+            
+            # 返回结果
+            return {"success": True, "message": "Scene opened successfully"}
+                
+        except Exception as e:
+            logging.error(f"打开场景错误: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+            
+    def get_scene_info(self) -> Dict[str, Any]:
+        """
+        获取当前场景信息
+        
+        Returns:
+            场景信息
+        """
+        try:
+            logging.info("向Cocos Creator发送获取场景信息命令")
+            
+            # 发送命令并获取响应
+            response = self.cocos_client.send_command("GET_SCENE_INFO", {})
+            
+            # 记录响应
+            logging.info(f"Cocos Creator响应: {response}")
+            
+            return response
+                
+        except Exception as e:
+            logging.error(f"获取场景信息错误: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}
+            
+    def list_scene_nodes(self) -> Dict[str, Any]:
+        """
+        列出场景中的所有节点
+        
+        Returns:
+            节点列表
+        """
+        try:
+            logging.info("向Cocos Creator发送列出场景节点命令")
+            
+            # 发送命令并获取响应
+            response = self.cocos_client.send_command("LIST_SCENE_NODES", {})
+            
+            # 记录响应
+            logging.info(f"Cocos Creator响应: {response}")
+            
+            return response
+                
+        except Exception as e:
+            logging.error(f"列出场景节点错误: {e}", exc_info=True)
+            return {"success": False, "error": str(e)} 

iflow_mcp_czh2774_cocosmcp-1.0.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: iflow-mcp_czh2774-cocosmcp
+Version: 1.0.0
+Summary: Cocos Creator MCP Log Bridge
+License-File: LICENSE
+Requires-Python: >=3.7
+Requires-Dist: dataclasses>=0.6
+Requires-Dist: mcp>=0.1.0
+Requires-Dist: typing-extensions>=4.0.0
+Description-Content-Type: text/markdown
+
+# Cocos MCP Log Bridge
+
+一个强大的日志桥接工具，用于在 Cocos Creator 编辑器和 Cursor AI 之间同步日志信息，帮助开发者更有效地分析和解决问题。
+
+[![GitHub stars](https://img.shields.io/github/stars/czh2774/cocosMCP.svg)](https://github.com/czh2774/cocosMCP/stargazers)
+[![License](https://img.shields.io/github/license/czh2774/cocosMCP.svg)](https://github.com/czh2774/cocosMCP/blob/main/LICENSE)
+
+![Cocos Creator](https://img.shields.io/badge/Cocos%20Creator-3.8.0%2B-blue)
+![Cursor AI](https://img.shields.io/badge/Cursor%20AI-Compatible-green)
+
+## 🌟 功能特点
+
+- **实时日志同步**: 直接从 Cocos Creator 编辑器获取最新日志
+- **智能过滤**: 支持按类型过滤（普通日志、警告、错误）
+- **关键词搜索**: 精确定位特定问题
+- **一键清除**: 随时清空日志以减少干扰
+- **场景信息**: 获取当前场景的基本信息和节点列表
+- **场景操作**: 支持打开场景等基础操作
+- **TCP 通信桥接**: 稳定可靠的通信机制
+- **Cursor AI 集成**: 完全兼容 Cursor MCP 协议
+
+## 🚀 快速入门
+
+### 前置条件
+
+- Cocos Creator 3.8.0 或更高版本
+- Python 3.7 或更高版本
+- uv 包管理器 (推荐) 或 pip
+
+### 安装步骤
+
+1. **克隆仓库**
+   ```bash
+   git clone https://github.com/czh2774/cocosMCP.git
+   ```
+
+2. **复制到 Cocos Creator 项目**
+   
+   将克隆的 `cocosMCP` 目录复制到你的 Cocos Creator 项目的 `extensions` 目录下。
+
+3. **安装 Python 依赖**
+   ```bash
+   cd your-project/extensions/cocosMCP/Python
+   uv pip install -r requirements.txt
+   ```
+
+4. **在 Cocos Creator 中启用扩展**
+   
+   启动 Cocos Creator，进入 `扩展 -> 扩展管理器`，确保 `cocosMCP` 扩展已启用。
+
+5. **配置 Cursor AI**
+   
+   在 Cursor AI 设置中配置 MCP 服务器，指向 Python 服务器脚本。
+
+### 基本用法
+
+```python
+# 查询日志
+logs = await mcp.query_logs({
+    "show_logs": True,
+    "show_warnings": True,
+    "show_errors": True
+})
+
+# 清除日志
+await mcp.clear_logs()
+
+# 检查连接状态
+status = await mcp.connection_status()
+
+# 获取场景信息
+scene_info = await mcp.get_scene_info()
+
+# 列出场景中的所有节点
+nodes = await mcp.list_scene_nodes()
+
+# 打开指定UUID的场景
+await mcp.open_scene("scene-uuid-here")
+```
+
+## 📚 详细文档
+
+本项目包含三个详细的文档:
+
+- [用户使用指南](USAGE.md): 安装、配置和使用方法
+- [开发者指南](DEVELOPMENT.md): 代码结构、扩展功能和维护说明
+- [问题排查](TROUBLESHOOTING.md): 常见问题和解决方案
+
+## 🔧 技术架构
+
+Cocos MCP 由三个主要部分组成:
+
+1. **Cocos Creator 扩展**: TypeScript 编写的编辑器扩展
+2. **TCP 通信桥**: 连接编辑器和 Python 服务器
+3. **Python MCP 服务器**: 处理 Cursor AI 的请求
+
+![架构图](https://via.placeholder.com/800x400?text=Cocos+MCP+Architecture)
+
+## 🤝 贡献指南
+
+欢迎贡献代码、报告问题或提出新功能建议！请查看 [开发者指南](DEVELOPMENT.md) 了解详情。
+
+## 📄 许可证
+
+本项目采用 MIT 许可证 - 详情请参阅 [LICENSE](LICENSE) 文件。
+
+## 🙏 致谢
+
+- Cocos Creator 团队提供的优秀游戏引擎
+- Cursor AI 团队开发的智能编程助手
+- 所有贡献者和用户的支持和反馈
+
+---
+
+如有问题或建议，请提交 [Issues](https://github.com/czh2774/cocosMCP/issues)。 

iflow_mcp_czh2774_cocosmcp-1.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+Python/__init__.py,sha256=nTveuBUrE7ts1FtWIBCzO-sNE-3RYCv2k2PiNSFlijk,26
+Python/cocos_connection.py,sha256=isUrv2E29YxOqL00PoPmLhD0Ym-LslwhSI21_ZLMPlM,6557
+Python/config.py,sha256=Cjm1LazDH2AsveGEELu4WS7xGHjI1lzoadhH-FZT95Y,806
+Python/log_client.py,sha256=P0eWNlN_ANZvYHhL_maU5a9zRHCFUhwyeYJ0Z6VXrLg,4161
+Python/requirements.txt,sha256=ba7WfPMjLGrdgfvZZqxPpZ59Xnvj8Qz5NBT-cDCd82o,93
+Python/server.py,sha256=n8fds_vHQSeJfk2itgmXnL0uclBRU7csOE5YsPm5zYM,2969
+Python/start_server.sh,sha256=G4NJ6LMt0dEo8IPbilQEci7cMKY9EdBgGgdzIflSOz4,559
+Python/tools/__init__.py,sha256=EKi5zu2h0SuPii-sa3xQElfdW-XnO544j_wSa7_5rH0,3044
+Python/tools/log_tools.py,sha256=8K3ZTKeYxPJ1u2-iKerv5YKw4NJ6c711o6o3DqngZns,4255
+Python/tools/scene_tools.py,sha256=4ZJMPzKyUx_LMPeVc22HW1F2GH2vWKB07V_V1fTCYMw,2713
+iflow_mcp_czh2774_cocosmcp-1.0.0.dist-info/METADATA,sha256=kIFwwvy27gEaABk1l9DyAAShgYZIfkFGVat_SU45vik,3720
+iflow_mcp_czh2774_cocosmcp-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iflow_mcp_czh2774_cocosmcp-1.0.0.dist-info/entry_points.txt,sha256=fZoL109GK9mvqSK5NsdLhCyaXbPbYEM_njD6vrV4trQ,41
+iflow_mcp_czh2774_cocosmcp-1.0.0.dist-info/licenses/LICENSE,sha256=GT-xwJTlFeuxP5Z4YRZ0jn-mxGOpUPieje02erjbYNk,1064
+iflow_mcp_czh2774_cocosmcp-1.0.0.dist-info/RECORD,,

iflow_mcp_czh2774_cocosmcp-1.0.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_czh2774_cocosmcp-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cocosmcp = server:main

iflow_mcp_czh2774_cocosmcp-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 czh2774
+
+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.