commit 8781bbf0f5493b03c95e2c9d40068eadcf508b48 Author: root Date: Thu Jul 17 18:12:56 2025 +0800 初次提交 diff --git a/@types/schema/package/base/panels.json b/@types/schema/package/base/panels.json new file mode 100755 index 0000000..9e268fb --- /dev/null +++ b/@types/schema/package/base/panels.json @@ -0,0 +1,81 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "description": "面板数据 / Panel data", + "additionalProperties": false, + "patternProperties": { + "^[a-zA-Z0-9_-]+$": { + "type": "object", + "description": "面板名 / Panel name", + "properties": { + "title": { + "type": "string", + "default": "Default Panel", + "description": "面板标题，支持 i18n:key / Panel title, support for i18n:key (required)" + }, + "main": { + "type": "string", + "default": "dist/panels/default/index.js", + "description": "入口函数 / Entry function (required)" + }, + "icon": { + "type": "string", + "description": "面板图标存放相对目录 / Relative directory for panel icon storage" + }, + "type": { + "type": "string", + "enum": ["dockable", "simple"], + "default": "dockable", + "description": "面板类型（dockable | simple） / Panel type (dockable | simple)" + }, + "flags": { + "type": "object", + "properties": { + "resizable": { + "type": "boolean", + "default": true, + "description": "是否可以改变大小，默认 true / Whether the size can be changed, default true" + }, + "save": { + "type": "boolean", + "default": true, + "description": "是否需要保存，默认 false / Whether to save, default false" + }, + "alwaysOnTop": { + "type": "boolean", + "default": true, + "description": "是否保持顶层显示，默认 false / Whether to keep the top level display, default false" + } + } + }, + "size": { + "type": "object", + "description": "面板大小信息 / Panel size information", + "properties": { + "min-width": { + "type": "number", + "default": 200, + "description": "面板最小宽度 / Minimum panel width" + }, + "min-height": { + "type": "number", + "default": 200, + "description": "面板最小高度 / Minimum panel height" + }, + "width": { + "type": "number", + "default": 400, + "description": " 面板默认宽度 / Panel Default Width" + }, + "height": { + "type": "number", + "default": 600, + "description": "面板默认高度 / Panel Default Height" + } + } + } + }, + "required": ["title", "main"] + } + } +} diff --git a/@types/schema/package/contributions/index.json b/@types/schema/package/contributions/index.json new file mode 100755 index 0000000..7a2b7da --- /dev/null +++ b/@types/schema/package/contributions/index.json @@ -0,0 +1,47 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "description": "其他扩展插件的扩展配置 / Extended configuration for other extension plugins", + "properties": { + "menu": { + "type": "array", + "description": "菜单配置 / Menu configuration", + "items": { + "type": "object", + "properties": { + "path": { + "type": "string", + "description": "菜单路径 / Menu path" + }, + "label": { + "type": "string", + "description": "菜单标签 / Menu label" + }, + "message": { + "type": "string", + "description": "菜单消息 / Menu message" + } + } + } + }, + "messages": { + "type": "object", + "description": "消息配置 / Message configuration", + "additionalProperties": { + "type": "object", + "properties": { + "methods": { + "type": "array", + "items": { + "type": "string" + } + } + } + } + }, + "panels": { + "$ref": "../base/panels.json" + } + }, + "required": [] +} diff --git a/@types/schema/package/index.json b/@types/schema/package/index.json new file mode 100755 index 0000000..0452158 --- /dev/null +++ b/@types/schema/package/index.json @@ -0,0 +1,64 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "type": "object", + "description": "插件定义文件 / Extension definition file", + "properties": { + "author": { + "type": "string", + "description": "作者 / Author", + "default": "Cocos Creator Developer" + }, + "contributions": { + "$ref": "./contributions/index.json" + }, + "dependencies": { + "type": "object", + "description": "发布时所需的依赖库 / Dependencies required for publishing" + }, + "description": { + "type": "string", + "description": "简要介绍扩展关键特性、用途，支持 i18n / Brief introduction of the key features and uses of the extension, supporting i18n" + }, + "devDependencies": { + "type": "object", + "description": "开发时所需的依赖库 / Dependencies required for development" + }, + "editor": { + "type": "string", + "description": "支持的 Cocos Creator 编辑器版本，支持 semver 格式 / Supported Cocos Creator editor version, supporting semver format" + }, + "main": { + "type": "string", + "description": "入口函数 / Entry function", + "default": "./dist/index.js" + }, + "name": { + "type": "string", + "description": "不能以 _ 或 . 开头、不能含有大写字母，也不能含有 URL 的非法字符例如 .、' 和 ,。 / Cannot start with _ or., cannot contain uppercase letters, and cannot contain URL illegal characters such as.,'and,", + "default": "Custom Extension" + }, + "package_version": { + "type": "number", + "description": "扩展系统预留版本号 / Extension system reserved version number", + "default": 2 + }, + "panels": { + "$ref": "./base/panels.json" + }, + "scripts": { + "type": "object", + "description": "NPM 脚本 / NPM scripts" + }, + "version": { + "type": "string", + "description": "版本号字符串 / Version number string", + "default": "1.0.0" + } + }, + "required": [ + "author", + "name", + "package_version", + "version" + ] +} \ No newline at end of file diff --git a/FEATURE_GUIDE_CN.md b/FEATURE_GUIDE_CN.md new file mode 100644 index 0000000..50b72cb --- /dev/null +++ b/FEATURE_GUIDE_CN.md @@ -0,0 +1,1426 @@ +# Cocos Creator MCP 服务器功能指导文档 + +## 概述 + +Cocos Creator MCP 服务器是一个全面的 Model Context Protocol (MCP) 服务器插件，专为 Cocos Creator 3.8+ 设计，通过标准化协议使 AI 助手能够与 Cocos Creator 编辑器进行交互。 + +本文档详细介绍了所有可用的 MCP 工具及其使用方法。 + +## 工具分类 + +MCP 服务器提供了 **80 个工具**，按功能分为 9 个主要类别： + +1. [场景操作工具 (Scene Tools)](#1-场景操作工具-scene-tools) +2. [节点操作工具 (Node Tools)](#2-节点操作工具-node-tools) +3. [组件管理工具 (Component Tools)](#3-组件管理工具-component-tools) +4. [预制体操作工具 (Prefab Tools)](#4-预制体操作工具-prefab-tools) +5. [项目控制工具 (Project Tools)](#5-项目控制工具-project-tools) +6. [调试工具 (Debug Tools)](#6-调试工具-debug-tools) +7. [偏好设置工具 (Preferences Tools)](#7-偏好设置工具-preferences-tools) +8. [服务器工具 (Server Tools)](#8-服务器工具-server-tools) +9. [广播工具 (Broadcast Tools)](#9-广播工具-broadcast-tools) + +--- + +## 1. 场景操作工具 (Scene Tools) + +### 1.1 scene_get_current_scene +获取当前场景信息 + +**参数**: 无 + +**返回**: 当前场景的名称、UUID、类型、激活状态和节点数量 + +**示例**: +```json +{ + "tool": "scene_get_current_scene", + "arguments": {} +} +``` + +### 1.2 scene_get_scene_list +获取项目中所有场景列表 + +**参数**: 无 + +**返回**: 项目中所有场景的列表，包括名称、路径和UUID + +**示例**: +```json +{ + "tool": "scene_get_scene_list", + "arguments": {} +} +``` + +### 1.3 scene_open_scene +通过路径打开场景 + +**参数**: +- `scenePath` (string, 必需): 场景文件路径 + +**示例**: +```json +{ + "tool": "scene_open_scene", + "arguments": { + "scenePath": "db://assets/scenes/GameScene.scene" + } +} +``` + +### 1.4 scene_save_scene +保存当前场景 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "scene_save_scene", + "arguments": {} +} +``` + +### 1.5 scene_create_scene +创建新场景资源 + +**参数**: +- `sceneName` (string, 必需): 新场景的名称 +- `savePath` (string, 必需): 保存场景的路径 + +**示例**: +```json +{ + "tool": "scene_create_scene", + "arguments": { + "sceneName": "NewLevel", + "savePath": "db://assets/scenes/NewLevel.scene" + } +} +``` + +### 1.6 scene_save_scene_as +将场景另存为新文件 + +**参数**: +- `path` (string, 必需): 保存场景的路径 + +**示例**: +```json +{ + "tool": "scene_save_scene_as", + "arguments": { + "path": "db://assets/scenes/GameScene_Copy.scene" + } +} +``` + +### 1.7 scene_close_scene +关闭当前场景 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "scene_close_scene", + "arguments": {} +} +``` + +### 1.8 scene_get_scene_hierarchy +获取当前场景的完整层级结构 + +**参数**: +- `includeComponents` (boolean, 可选): 是否包含组件信息，默认为 false + +**示例**: +```json +{ + "tool": "scene_get_scene_hierarchy", + "arguments": { + "includeComponents": true + } +} +``` + +--- + +## 2. 节点操作工具 (Node Tools) + +### 2.1 node_create_node +在场景中创建新节点 + +**参数**: +- `name` (string, 必需): 节点名称 +- `parentUuid` (string, 可选): 父节点UUID，如果不提供则在当前编辑器选择位置创建 +- `nodeType` (string, 可选): 节点类型，可选值：`Node`、`2DNode`、`3DNode`，默认为 `Node` +- `siblingIndex` (number, 可选): 同级索引，-1 表示添加到末尾，默认为 -1 + +**示例**: +```json +{ + "tool": "node_create_node", + "arguments": { + "name": "PlayerNode", + "nodeType": "2DNode", + "parentUuid": "parent-uuid-here" + } +} +``` + +### 2.2 node_get_node_info +通过UUID获取节点信息 + +**参数**: +- `uuid` (string, 必需): 节点UUID + +**示例**: +```json +{ + "tool": "node_get_node_info", + "arguments": { + "uuid": "node-uuid-here" + } +} +``` + +### 2.3 node_find_nodes +按名称模式查找节点 + +**参数**: +- `pattern` (string, 必需): 搜索的名称模式 +- `exactMatch` (boolean, 可选): 是否精确匹配，默认为 false + +**示例**: +```json +{ + "tool": "node_find_nodes", + "arguments": { + "pattern": "Enemy", + "exactMatch": false + } +} +``` + +### 2.4 node_find_node_by_name +通过精确名称查找第一个节点 + +**参数**: +- `name` (string, 必需): 要查找的节点名称 + +**示例**: +```json +{ + "tool": "node_find_node_by_name", + "arguments": { + "name": "Player" + } +} +``` + +### 2.5 node_get_all_nodes +获取场景中所有节点及其UUID + +**参数**: 无 + +**示例**: +```json +{ + "tool": "node_get_all_nodes", + "arguments": {} +} +``` + +### 2.6 node_set_node_property +设置节点属性值 + +**参数**: +- `uuid` (string, 必需): 节点UUID +- `property` (string, 必需): 属性名称（如 position、rotation、scale、active） +- `value` (any, 必需): 属性值 + +**示例**: +```json +{ + "tool": "node_set_node_property", + "arguments": { + "uuid": "node-uuid-here", + "property": "position", + "value": {"x": 100, "y": 200, "z": 0} + } +} +``` + +### 2.7 node_delete_node +从场景中删除节点 + +**参数**: +- `uuid` (string, 必需): 要删除的节点UUID + +**示例**: +```json +{ + "tool": "node_delete_node", + "arguments": { + "uuid": "node-uuid-here" + } +} +``` + +### 2.8 node_move_node +将节点移动到新的父节点 + +**参数**: +- `nodeUuid` (string, 必需): 要移动的节点UUID +- `newParentUuid` (string, 必需): 新父节点UUID +- `siblingIndex` (number, 可选): 新父节点中的同级索引，默认为 -1 + +**示例**: +```json +{ + "tool": "node_move_node", + "arguments": { + "nodeUuid": "node-uuid-here", + "newParentUuid": "parent-uuid-here", + "siblingIndex": 0 + } +} +``` + +### 2.9 node_duplicate_node +复制节点 + +**参数**: +- `uuid` (string, 必需): 要复制的节点UUID +- `includeChildren` (boolean, 可选): 是否包含子节点，默认为 true + +**示例**: +```json +{ + "tool": "node_duplicate_node", + "arguments": { + "uuid": "node-uuid-here", + "includeChildren": true + } +} +``` + +--- + +## 3. 组件管理工具 (Component Tools) + +### 3.1 component_add_component +向指定节点添加组件 + +**参数**: +- `nodeUuid` (string, 必需): 目标节点UUID +- `componentType` (string, 必需): 组件类型（如 cc.Sprite、cc.Label、cc.Button） + +**示例**: +```json +{ + "tool": "component_add_component", + "arguments": { + "nodeUuid": "node-uuid-here", + "componentType": "cc.Sprite" + } +} +``` + +### 3.2 component_remove_component +从节点移除组件 + +**参数**: +- `nodeUuid` (string, 必需): 节点UUID +- `componentType` (string, 必需): 要移除的组件类型 + +**示例**: +```json +{ + "tool": "component_remove_component", + "arguments": { + "nodeUuid": "node-uuid-here", + "componentType": "cc.Sprite" + } +} +``` + +### 3.3 component_get_components +获取节点的所有组件 + +**参数**: +- `nodeUuid` (string, 必需): 节点UUID + +**示例**: +```json +{ + "tool": "component_get_components", + "arguments": { + "nodeUuid": "node-uuid-here" + } +} +``` + +### 3.4 component_get_component_info +获取特定组件信息 + +**参数**: +- `nodeUuid` (string, 必需): 节点UUID +- `componentType` (string, 必需): 要获取信息的组件类型 + +**示例**: +```json +{ + "tool": "component_get_component_info", + "arguments": { + "nodeUuid": "node-uuid-here", + "componentType": "cc.Sprite" + } +} +``` + +### 3.5 component_set_component_property +设置组件属性值 + +**参数**: +- `nodeUuid` (string, 必需): 节点UUID +- `componentType` (string, 必需): 组件类型 +- `property` (string, 必需): 属性名称 +- `value` (any, 必需): 属性值 + +**示例**: +```json +{ + "tool": "component_set_component_property", + "arguments": { + "nodeUuid": "node-uuid-here", + "componentType": "cc.Sprite", + "property": "spriteFrame", + "value": "sprite-frame-uuid" + } +} +``` + +### 3.6 component_attach_script +向节点附加脚本组件 + +**参数**: +- `nodeUuid` (string, 必需): 节点UUID +- `scriptPath` (string, 必需): 脚本资源路径 + +**示例**: +```json +{ + "tool": "component_attach_script", + "arguments": { + "nodeUuid": "node-uuid-here", + "scriptPath": "db://assets/scripts/PlayerController.ts" + } +} +``` + +### 3.7 component_get_available_components +获取可用组件类型列表 + +**参数**: +- `category` (string, 可选): 组件类别过滤器，可选值：`all`、`renderer`、`ui`、`physics`、`animation`、`audio`，默认为 `all` + +**示例**: +```json +{ + "tool": "component_get_available_components", + "arguments": { + "category": "ui" + } +} +``` + +--- + +## 4. 预制体操作工具 (Prefab Tools) + +### 4.1 prefab_get_prefab_list +获取项目中所有预制体 + +**参数**: +- `folder` (string, 可选): 搜索文件夹路径，默认为 `db://assets` + +**示例**: +```json +{ + "tool": "prefab_get_prefab_list", + "arguments": { + "folder": "db://assets/prefabs" + } +} +``` + +### 4.2 prefab_load_prefab +通过路径加载预制体 + +**参数**: +- `prefabPath` (string, 必需): 预制体资源路径 + +**示例**: +```json +{ + "tool": "prefab_load_prefab", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab" + } +} +``` + +### 4.3 prefab_instantiate_prefab +在场景中实例化预制体 + +**参数**: +- `prefabPath` (string, 必需): 预制体资源路径 +- `parentUuid` (string, 可选): 父节点UUID +- `position` (object, 可选): 初始位置，包含 x、y、z 属性 + +**示例**: +```json +{ + "tool": "prefab_instantiate_prefab", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab", + "parentUuid": "parent-uuid-here", + "position": {"x": 100, "y": 200, "z": 0} + } +} +``` + +### 4.4 prefab_create_prefab +从节点创建预制体 + +**参数**: +- `nodeUuid` (string, 必需): 源节点UUID +- `savePath` (string, 必需): 保存预制体的路径 +- `prefabName` (string, 必需): 预制体名称 + +**示例**: +```json +{ + "tool": "prefab_create_prefab", + "arguments": { + "nodeUuid": "node-uuid-here", + "savePath": "db://assets/prefabs/", + "prefabName": "MyPrefab" + } +} +``` + +### 4.5 prefab_create_prefab_from_node +从节点创建预制体（create_prefab 的别名） + +**参数**: +- `nodeUuid` (string, 必需): 源节点UUID +- `prefabPath` (string, 必需): 保存预制体的路径 + +**示例**: +```json +{ + "tool": "prefab_create_prefab_from_node", + "arguments": { + "nodeUuid": "node-uuid-here", + "prefabPath": "db://assets/prefabs/MyPrefab.prefab" + } +} +``` + +### 4.6 prefab_update_prefab +更新现有预制体 + +**参数**: +- `prefabPath` (string, 必需): 预制体资源路径 +- `nodeUuid` (string, 必需): 包含更改的节点UUID + +**示例**: +```json +{ + "tool": "prefab_update_prefab", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab", + "nodeUuid": "node-uuid-here" + } +} +``` + +### 4.7 prefab_revert_prefab +将预制体实例恢复为原始状态 + +**参数**: +- `nodeUuid` (string, 必需): 预制体实例节点UUID + +**示例**: +```json +{ + "tool": "prefab_revert_prefab", + "arguments": { + "nodeUuid": "prefab-instance-uuid-here" + } +} +``` + +### 4.8 prefab_get_prefab_info +获取详细的预制体信息 + +**参数**: +- `prefabPath` (string, 必需): 预制体资源路径 + +**示例**: +```json +{ + "tool": "prefab_get_prefab_info", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab" + } +} +``` + +--- + +## 5. 项目控制工具 (Project Tools) + +### 5.1 project_run_project +在预览模式下运行项目 + +**参数**: +- `platform` (string, 可选): 目标平台，可选值：`browser`、`simulator`、`preview`，默认为 `browser` + +**示例**: +```json +{ + "tool": "project_run_project", + "arguments": { + "platform": "browser" + } +} +``` + +### 5.2 project_build_project +构建项目 + +**参数**: +- `platform` (string, 必需): 构建平台，可选值：`web-mobile`、`web-desktop`、`ios`、`android`、`windows`、`mac` +- `debug` (boolean, 可选): 是否调试构建，默认为 true + +**示例**: +```json +{ + "tool": "project_build_project", + "arguments": { + "platform": "web-mobile", + "debug": false + } +} +``` + +### 5.3 project_get_project_info +获取项目信息 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "project_get_project_info", + "arguments": {} +} +``` + +### 5.4 project_get_project_settings +获取项目设置 + +**参数**: +- `category` (string, 可选): 设置类别，可选值：`general`、`physics`、`render`、`assets`，默认为 `general` + +**示例**: +```json +{ + "tool": "project_get_project_settings", + "arguments": { + "category": "physics" + } +} +``` + +### 5.5 project_refresh_assets +刷新资源数据库 + +**参数**: +- `folder` (string, 可选): 要刷新的特定文件夹 + +**示例**: +```json +{ + "tool": "project_refresh_assets", + "arguments": { + "folder": "db://assets/textures" + } +} +``` + +### 5.6 project_import_asset +导入资源文件 + +**参数**: +- `sourcePath` (string, 必需): 源文件路径 +- `targetFolder` (string, 必需): 资源中的目标文件夹 + +**示例**: +```json +{ + "tool": "project_import_asset", + "arguments": { + "sourcePath": "/path/to/image.png", + "targetFolder": "db://assets/textures" + } +} +``` + +### 5.7 project_get_asset_info +获取资源信息 + +**参数**: +- `assetPath` (string, 必需): 资源路径 + +**示例**: +```json +{ + "tool": "project_get_asset_info", + "arguments": { + "assetPath": "db://assets/textures/player.png" + } +} +``` + +### 5.8 project_get_assets +按类型获取资源 + +**参数**: +- `type` (string, 可选): 资源类型过滤器，可选值：`all`、`scene`、`prefab`、`script`、`texture`、`material`、`mesh`、`audio`、`animation`，默认为 `all` +- `folder` (string, 可选): 搜索文件夹，默认为 `db://assets` + +**示例**: +```json +{ + "tool": "project_get_assets", + "arguments": { + "type": "texture", + "folder": "db://assets/textures" + } +} +``` + +### 5.9 project_get_build_settings +获取构建设置 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "project_get_build_settings", + "arguments": {} +} +``` + +### 5.10 project_open_build_panel +在编辑器中打开构建面板 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "project_open_build_panel", + "arguments": {} +} +``` + +### 5.11 project_check_builder_status +检查构建器工作进程是否就绪 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "project_check_builder_status", + "arguments": {} +} +``` + +### 5.12 project_start_preview_server +启动预览服务器 + +**参数**: +- `port` (number, 可选): 预览服务器端口，默认为 7456 + +**示例**: +```json +{ + "tool": "project_start_preview_server", + "arguments": { + "port": 8080 + } +} +``` + +### 5.13 project_stop_preview_server +停止预览服务器 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "project_stop_preview_server", + "arguments": {} +} +``` + +### 5.14 project_create_asset +创建新的资源文件或文件夹 + +**参数**: +- `url` (string, 必需): 资源URL +- `content` (string, 可选): 文件内容，null 表示创建文件夹 +- `overwrite` (boolean, 可选): 是否覆盖现有文件，默认为 false + +**示例**: +```json +{ + "tool": "project_create_asset", + "arguments": { + "url": "db://assets/scripts/NewScript.ts", + "content": "// New TypeScript script\n", + "overwrite": false + } +} +``` + +### 5.15 project_copy_asset +复制资源到另一个位置 + +**参数**: +- `source` (string, 必需): 源资源URL +- `target` (string, 必需): 目标位置URL +- `overwrite` (boolean, 可选): 是否覆盖现有文件，默认为 false + +**示例**: +```json +{ + "tool": "project_copy_asset", + "arguments": { + "source": "db://assets/textures/player.png", + "target": "db://assets/textures/backup/player.png", + "overwrite": false + } +} +``` + +### 5.16 project_move_asset +移动资源到另一个位置 + +**参数**: +- `source` (string, 必需): 源资源URL +- `target` (string, 必需): 目标位置URL +- `overwrite` (boolean, 可选): 是否覆盖现有文件，默认为 false + +**示例**: +```json +{ + "tool": "project_move_asset", + "arguments": { + "source": "db://assets/textures/old_player.png", + "target": "db://assets/textures/player.png", + "overwrite": true + } +} +``` + +### 5.17 project_delete_asset +删除资源 + +**参数**: +- `url` (string, 必需): 要删除的资源URL + +**示例**: +```json +{ + "tool": "project_delete_asset", + "arguments": { + "url": "db://assets/textures/unused.png" + } +} +``` + +### 5.18 project_save_asset +保存资源内容 + +**参数**: +- `url` (string, 必需): 资源URL +- `content` (string, 必需): 资源内容 + +**示例**: +```json +{ + "tool": "project_save_asset", + "arguments": { + "url": "db://assets/scripts/GameManager.ts", + "content": "// Updated script content\n" + } +} +``` + +### 5.19 project_reimport_asset +重新导入资源 + +**参数**: +- `url` (string, 必需): 要重新导入的资源URL + +**示例**: +```json +{ + "tool": "project_reimport_asset", + "arguments": { + "url": "db://assets/textures/player.png" + } +} +``` + +### 5.20 project_query_asset_path +获取资源磁盘路径 + +**参数**: +- `url` (string, 必需): 资源URL + +**示例**: +```json +{ + "tool": "project_query_asset_path", + "arguments": { + "url": "db://assets/textures/player.png" + } +} +``` + +### 5.21 project_query_asset_uuid +从URL获取资源UUID + +**参数**: +- `url` (string, 必需): 资源URL + +**示例**: +```json +{ + "tool": "project_query_asset_uuid", + "arguments": { + "url": "db://assets/textures/player.png" + } +} +``` + +### 5.22 project_query_asset_url +从UUID获取资源URL + +**参数**: +- `uuid` (string, 必需): 资源UUID + +**示例**: +```json +{ + "tool": "project_query_asset_url", + "arguments": { + "uuid": "asset-uuid-here" + } +} +``` + +--- + +## 6. 调试工具 (Debug Tools) + +### 6.1 debug_get_console_logs +获取编辑器控制台日志 + +**参数**: +- `limit` (number, 可选): 要检索的最新日志数量，默认为 100 +- `filter` (string, 可选): 按类型过滤日志，可选值：`all`、`log`、`warn`、`error`、`info`，默认为 `all` + +**示例**: +```json +{ + "tool": "debug_get_console_logs", + "arguments": { + "limit": 50, + "filter": "error" + } +} +``` + +### 6.2 debug_clear_console +清空编辑器控制台 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "debug_clear_console", + "arguments": {} +} +``` + +### 6.3 debug_execute_script +在场景上下文中执行JavaScript代码 + +**参数**: +- `script` (string, 必需): 要执行的JavaScript代码 + +**示例**: +```json +{ + "tool": "debug_execute_script", + "arguments": { + "script": "console.log('Hello from MCP!');" + } +} +``` + +### 6.4 debug_get_node_tree +获取用于调试的详细节点树 + +**参数**: +- `rootUuid` (string, 可选): 根节点UUID，如果不提供则使用场景根节点 +- `maxDepth` (number, 可选): 最大树深度，默认为 10 + +**示例**: +```json +{ + "tool": "debug_get_node_tree", + "arguments": { + "rootUuid": "root-node-uuid", + "maxDepth": 5 + } +} +``` + +### 6.5 debug_get_performance_stats +获取性能统计信息 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "debug_get_performance_stats", + "arguments": {} +} +``` + +### 6.6 debug_validate_scene +验证当前场景是否有问题 + +**参数**: +- `checkMissingAssets` (boolean, 可选): 检查缺失的资源引用，默认为 true +- `checkPerformance` (boolean, 可选): 检查性能问题，默认为 true + +**示例**: +```json +{ + "tool": "debug_validate_scene", + "arguments": { + "checkMissingAssets": true, + "checkPerformance": true + } +} +``` + +### 6.7 debug_get_editor_info +获取编辑器和环境信息 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "debug_get_editor_info", + "arguments": {} +} +``` + +--- + +## 7. 偏好设置工具 (Preferences Tools) + +### 7.1 preferences_get_preferences +获取编辑器偏好设置 + +**参数**: +- `key` (string, 可选): 要获取的特定偏好设置键 + +**示例**: +```json +{ + "tool": "preferences_get_preferences", + "arguments": { + "key": "editor.theme" + } +} +``` + +### 7.2 preferences_set_preferences +设置编辑器偏好设置 + +**参数**: +- `key` (string, 必需): 要设置的偏好设置键 +- `value` (any, 必需): 要设置的偏好设置值 + +**示例**: +```json +{ + "tool": "preferences_set_preferences", + "arguments": { + "key": "editor.theme", + "value": "dark" + } +} +``` + +### 7.3 preferences_get_global_preferences +获取全局编辑器偏好设置 + +**参数**: +- `key` (string, 可选): 要获取的全局偏好设置键 + +**示例**: +```json +{ + "tool": "preferences_get_global_preferences", + "arguments": { + "key": "global.autoSave" + } +} +``` + +### 7.4 preferences_set_global_preferences +设置全局编辑器偏好设置 + +**参数**: +- `key` (string, 必需): 要设置的全局偏好设置键 +- `value` (any, 必需): 要设置的全局偏好设置值 + +**示例**: +```json +{ + "tool": "preferences_set_global_preferences", + "arguments": { + "key": "global.autoSave", + "value": true + } +} +``` + +### 7.5 preferences_get_recent_projects +获取最近打开的项目 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "preferences_get_recent_projects", + "arguments": {} +} +``` + +### 7.6 preferences_clear_recent_projects +清除最近打开的项目列表 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "preferences_clear_recent_projects", + "arguments": {} +} +``` + +--- + +## 8. 服务器工具 (Server Tools) + +### 8.1 server_get_server_info +获取服务器信息 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "server_get_server_info", + "arguments": {} +} +``` + +### 8.2 server_broadcast_custom_message +广播自定义消息 + +**参数**: +- `message` (string, 必需): 消息名称 +- `data` (any, 可选): 消息数据 + +**示例**: +```json +{ + "tool": "server_broadcast_custom_message", + "arguments": { + "message": "custom_event", + "data": {"type": "test", "value": 123} + } +} +``` + +### 8.3 server_get_editor_version +获取编辑器版本信息 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "server_get_editor_version", + "arguments": {} +} +``` + +### 8.4 server_get_project_name +获取当前项目名称 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "server_get_project_name", + "arguments": {} +} +``` + +### 8.5 server_get_project_path +获取当前项目路径 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "server_get_project_path", + "arguments": {} +} +``` + +### 8.6 server_get_project_uuid +获取当前项目UUID + +**参数**: 无 + +**示例**: +```json +{ + "tool": "server_get_project_uuid", + "arguments": {} +} +``` + +### 8.7 server_restart_editor +请求重启编辑器 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "server_restart_editor", + "arguments": {} +} +``` + +### 8.8 server_quit_editor +请求退出编辑器 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "server_quit_editor", + "arguments": {} +} +``` + +--- + +## 9. 广播工具 (Broadcast Tools) + +### 9.1 broadcast_get_broadcast_log +获取最近的广播消息日志 + +**参数**: +- `limit` (number, 可选): 要返回的最新消息数量，默认为 50 +- `messageType` (string, 可选): 按消息类型过滤 + +**示例**: +```json +{ + "tool": "broadcast_get_broadcast_log", + "arguments": { + "limit": 100, + "messageType": "scene_change" + } +} +``` + +### 9.2 broadcast_listen_broadcast +开始监听特定广播消息 + +**参数**: +- `messageType` (string, 必需): 要监听的消息类型 + +**示例**: +```json +{ + "tool": "broadcast_listen_broadcast", + "arguments": { + "messageType": "node_created" + } +} +``` + +### 9.3 broadcast_stop_listening +停止监听特定广播消息 + +**参数**: +- `messageType` (string, 必需): 要停止监听的消息类型 + +**示例**: +```json +{ + "tool": "broadcast_stop_listening", + "arguments": { + "messageType": "node_created" + } +} +``` + +### 9.4 broadcast_clear_broadcast_log +清除广播消息日志 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "broadcast_clear_broadcast_log", + "arguments": {} +} +``` + +### 9.5 broadcast_get_active_listeners +获取活动广播监听器列表 + +**参数**: 无 + +**示例**: +```json +{ + "tool": "broadcast_get_active_listeners", + "arguments": {} +} +``` + +--- + +## 使用须知 + +### 1. 工具调用格式 + +所有工具调用都使用 JSON-RPC 2.0 格式： + +```json +{ + "jsonrpc": "2.0", + "method": "tools/call", + "params": { + "name": "tool_name", + "arguments": { + // 工具参数 + } + }, + "id": 1 +} +``` + +### 2. 常见UUID获取方法 + +- 使用 `node_get_all_nodes` 获取所有节点UUID +- 使用 `node_find_node_by_name` 按名称查找节点UUID +- 使用 `scene_get_current_scene` 获取场景UUID +- 使用 `prefab_get_prefab_list` 获取预制体信息 + +### 3. 资源路径格式 + +Cocos Creator 使用 `db://` 前缀的资源URL格式： +- 场景：`db://assets/scenes/GameScene.scene` +- 预制体：`db://assets/prefabs/Player.prefab` +- 脚本：`db://assets/scripts/GameManager.ts` +- 纹理：`db://assets/textures/player.png` + +### 4. 错误处理 + +如果工具调用失败，会返回错误信息： + +```json +{ + "jsonrpc": "2.0", + "id": 1, + "error": { + "code": -32000, + "message": "Tool execution failed", + "data": { + "error": "详细错误信息" + } + } +} +``` + +### 5. 最佳实践 + +1. **先查询再操作**：在修改节点或组件之前，先使用查询工具获取当前状态 +2. **使用UUID**：尽量使用UUID而不是名称来引用节点和资源 +3. **错误检查**：始终检查工具调用的返回值，确保操作成功 +4. **资源管理**：在删除或移动资源前，确保没有其他地方引用它们 +5. **性能考虑**：避免在循环中频繁调用工具，考虑批量操作 + +--- + +## 技术支持 + +如果您在使用过程中遇到问题，可以： + +1. 使用 `debug_get_console_logs` 查看详细的错误日志 +2. 使用 `debug_validate_scene` 检查场景是否有问题 +3. 使用 `debug_get_editor_info` 获取环境信息 +4. 检查 MCP 服务器的运行状态和日志 + +--- + +*此文档基于 Cocos Creator MCP 服务器 v1.0.0 编写，如有更新请参考最新版本文档。* \ No newline at end of file diff --git a/FEATURE_GUIDE_EN.md b/FEATURE_GUIDE_EN.md new file mode 100644 index 0000000..695a90e --- /dev/null +++ b/FEATURE_GUIDE_EN.md @@ -0,0 +1,1426 @@ +# Cocos Creator MCP Server Feature Guide + +## Overview + +The Cocos Creator MCP Server is a comprehensive Model Context Protocol (MCP) server plugin designed for Cocos Creator 3.8+ that enables AI assistants to interact with the Cocos Creator editor through a standardized protocol. + +This document provides detailed information about all available MCP tools and their usage. + +## Tool Categories + +The MCP server provides **80 tools** organized into 9 main categories: + +1. [Scene Tools](#1-scene-tools) +2. [Node Tools](#2-node-tools) +3. [Component Tools](#3-component-tools) +4. [Prefab Tools](#4-prefab-tools) +5. [Project Tools](#5-project-tools) +6. [Debug Tools](#6-debug-tools) +7. [Preferences Tools](#7-preferences-tools) +8. [Server Tools](#8-server-tools) +9. [Broadcast Tools](#9-broadcast-tools) + +--- + +## 1. Scene Tools + +### 1.1 scene_get_current_scene +Get current scene information + +**Parameters**: None + +**Returns**: Current scene name, UUID, type, active state, and node count + +**Example**: +```json +{ + "tool": "scene_get_current_scene", + "arguments": {} +} +``` + +### 1.2 scene_get_scene_list +Get all scenes in the project + +**Parameters**: None + +**Returns**: List of all scenes in the project with name, path, and UUID + +**Example**: +```json +{ + "tool": "scene_get_scene_list", + "arguments": {} +} +``` + +### 1.3 scene_open_scene +Open a scene by path + +**Parameters**: +- `scenePath` (string, required): The scene file path + +**Example**: +```json +{ + "tool": "scene_open_scene", + "arguments": { + "scenePath": "db://assets/scenes/GameScene.scene" + } +} +``` + +### 1.4 scene_save_scene +Save current scene + +**Parameters**: None + +**Example**: +```json +{ + "tool": "scene_save_scene", + "arguments": {} +} +``` + +### 1.5 scene_create_scene +Create a new scene asset + +**Parameters**: +- `sceneName` (string, required): Name of the new scene +- `savePath` (string, required): Path to save the scene + +**Example**: +```json +{ + "tool": "scene_create_scene", + "arguments": { + "sceneName": "NewLevel", + "savePath": "db://assets/scenes/NewLevel.scene" + } +} +``` + +### 1.6 scene_save_scene_as +Save scene as new file + +**Parameters**: +- `path` (string, required): Path to save the scene + +**Example**: +```json +{ + "tool": "scene_save_scene_as", + "arguments": { + "path": "db://assets/scenes/GameScene_Copy.scene" + } +} +``` + +### 1.7 scene_close_scene +Close current scene + +**Parameters**: None + +**Example**: +```json +{ + "tool": "scene_close_scene", + "arguments": {} +} +``` + +### 1.8 scene_get_scene_hierarchy +Get the complete hierarchy of current scene + +**Parameters**: +- `includeComponents` (boolean, optional): Include component information, default is false + +**Example**: +```json +{ + "tool": "scene_get_scene_hierarchy", + "arguments": { + "includeComponents": true + } +} +``` + +--- + +## 2. Node Tools + +### 2.1 node_create_node +Create a new node in the scene + +**Parameters**: +- `name` (string, required): Node name +- `parentUuid` (string, optional): Parent node UUID, if not provided, node will be created at current editor selection +- `nodeType` (string, optional): Node type, options: `Node`, `2DNode`, `3DNode`, default is `Node` +- `siblingIndex` (number, optional): Sibling index for ordering, -1 means append at end, default is -1 + +**Example**: +```json +{ + "tool": "node_create_node", + "arguments": { + "name": "PlayerNode", + "nodeType": "2DNode", + "parentUuid": "parent-uuid-here" + } +} +``` + +### 2.2 node_get_node_info +Get node information by UUID + +**Parameters**: +- `uuid` (string, required): Node UUID + +**Example**: +```json +{ + "tool": "node_get_node_info", + "arguments": { + "uuid": "node-uuid-here" + } +} +``` + +### 2.3 node_find_nodes +Find nodes by name pattern + +**Parameters**: +- `pattern` (string, required): Name pattern to search +- `exactMatch` (boolean, optional): Exact match or partial match, default is false + +**Example**: +```json +{ + "tool": "node_find_nodes", + "arguments": { + "pattern": "Enemy", + "exactMatch": false + } +} +``` + +### 2.4 node_find_node_by_name +Find first node by exact name + +**Parameters**: +- `name` (string, required): Node name to find + +**Example**: +```json +{ + "tool": "node_find_node_by_name", + "arguments": { + "name": "Player" + } +} +``` + +### 2.5 node_get_all_nodes +Get all nodes in the scene with their UUIDs + +**Parameters**: None + +**Example**: +```json +{ + "tool": "node_get_all_nodes", + "arguments": {} +} +``` + +### 2.6 node_set_node_property +Set node property value + +**Parameters**: +- `uuid` (string, required): Node UUID +- `property` (string, required): Property name (e.g., position, rotation, scale, active) +- `value` (any, required): Property value + +**Example**: +```json +{ + "tool": "node_set_node_property", + "arguments": { + "uuid": "node-uuid-here", + "property": "position", + "value": {"x": 100, "y": 200, "z": 0} + } +} +``` + +### 2.7 node_delete_node +Delete a node from scene + +**Parameters**: +- `uuid` (string, required): Node UUID to delete + +**Example**: +```json +{ + "tool": "node_delete_node", + "arguments": { + "uuid": "node-uuid-here" + } +} +``` + +### 2.8 node_move_node +Move node to new parent + +**Parameters**: +- `nodeUuid` (string, required): Node UUID to move +- `newParentUuid` (string, required): New parent node UUID +- `siblingIndex` (number, optional): Sibling index in new parent, default is -1 + +**Example**: +```json +{ + "tool": "node_move_node", + "arguments": { + "nodeUuid": "node-uuid-here", + "newParentUuid": "parent-uuid-here", + "siblingIndex": 0 + } +} +``` + +### 2.9 node_duplicate_node +Duplicate a node + +**Parameters**: +- `uuid` (string, required): Node UUID to duplicate +- `includeChildren` (boolean, optional): Include children nodes, default is true + +**Example**: +```json +{ + "tool": "node_duplicate_node", + "arguments": { + "uuid": "node-uuid-here", + "includeChildren": true + } +} +``` + +--- + +## 3. Component Tools + +### 3.1 component_add_component +Add a component to a specific node + +**Parameters**: +- `nodeUuid` (string, required): Target node UUID +- `componentType` (string, required): Component type (e.g., cc.Sprite, cc.Label, cc.Button) + +**Example**: +```json +{ + "tool": "component_add_component", + "arguments": { + "nodeUuid": "node-uuid-here", + "componentType": "cc.Sprite" + } +} +``` + +### 3.2 component_remove_component +Remove a component from a node + +**Parameters**: +- `nodeUuid` (string, required): Node UUID +- `componentType` (string, required): Component type to remove + +**Example**: +```json +{ + "tool": "component_remove_component", + "arguments": { + "nodeUuid": "node-uuid-here", + "componentType": "cc.Sprite" + } +} +``` + +### 3.3 component_get_components +Get all components of a node + +**Parameters**: +- `nodeUuid` (string, required): Node UUID + +**Example**: +```json +{ + "tool": "component_get_components", + "arguments": { + "nodeUuid": "node-uuid-here" + } +} +``` + +### 3.4 component_get_component_info +Get specific component information + +**Parameters**: +- `nodeUuid` (string, required): Node UUID +- `componentType` (string, required): Component type to get info for + +**Example**: +```json +{ + "tool": "component_get_component_info", + "arguments": { + "nodeUuid": "node-uuid-here", + "componentType": "cc.Sprite" + } +} +``` + +### 3.5 component_set_component_property +Set component property value + +**Parameters**: +- `nodeUuid` (string, required): Node UUID +- `componentType` (string, required): Component type +- `property` (string, required): Property name +- `value` (any, required): Property value + +**Example**: +```json +{ + "tool": "component_set_component_property", + "arguments": { + "nodeUuid": "node-uuid-here", + "componentType": "cc.Sprite", + "property": "spriteFrame", + "value": "sprite-frame-uuid" + } +} +``` + +### 3.6 component_attach_script +Attach a script component to a node + +**Parameters**: +- `nodeUuid` (string, required): Node UUID +- `scriptPath` (string, required): Script asset path + +**Example**: +```json +{ + "tool": "component_attach_script", + "arguments": { + "nodeUuid": "node-uuid-here", + "scriptPath": "db://assets/scripts/PlayerController.ts" + } +} +``` + +### 3.7 component_get_available_components +Get list of available component types + +**Parameters**: +- `category` (string, optional): Component category filter, options: `all`, `renderer`, `ui`, `physics`, `animation`, `audio`, default is `all` + +**Example**: +```json +{ + "tool": "component_get_available_components", + "arguments": { + "category": "ui" + } +} +``` + +--- + +## 4. Prefab Tools + +### 4.1 prefab_get_prefab_list +Get all prefabs in the project + +**Parameters**: +- `folder` (string, optional): Folder path to search, default is `db://assets` + +**Example**: +```json +{ + "tool": "prefab_get_prefab_list", + "arguments": { + "folder": "db://assets/prefabs" + } +} +``` + +### 4.2 prefab_load_prefab +Load a prefab by path + +**Parameters**: +- `prefabPath` (string, required): Prefab asset path + +**Example**: +```json +{ + "tool": "prefab_load_prefab", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab" + } +} +``` + +### 4.3 prefab_instantiate_prefab +Instantiate a prefab in the scene + +**Parameters**: +- `prefabPath` (string, required): Prefab asset path +- `parentUuid` (string, optional): Parent node UUID +- `position` (object, optional): Initial position with x, y, z properties + +**Example**: +```json +{ + "tool": "prefab_instantiate_prefab", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab", + "parentUuid": "parent-uuid-here", + "position": {"x": 100, "y": 200, "z": 0} + } +} +``` + +### 4.4 prefab_create_prefab +Create a prefab from a node + +**Parameters**: +- `nodeUuid` (string, required): Source node UUID +- `savePath` (string, required): Path to save the prefab +- `prefabName` (string, required): Prefab name + +**Example**: +```json +{ + "tool": "prefab_create_prefab", + "arguments": { + "nodeUuid": "node-uuid-here", + "savePath": "db://assets/prefabs/", + "prefabName": "MyPrefab" + } +} +``` + +### 4.5 prefab_create_prefab_from_node +Create a prefab from a node (alias for create_prefab) + +**Parameters**: +- `nodeUuid` (string, required): Source node UUID +- `prefabPath` (string, required): Path to save the prefab + +**Example**: +```json +{ + "tool": "prefab_create_prefab_from_node", + "arguments": { + "nodeUuid": "node-uuid-here", + "prefabPath": "db://assets/prefabs/MyPrefab.prefab" + } +} +``` + +### 4.6 prefab_update_prefab +Update an existing prefab + +**Parameters**: +- `prefabPath` (string, required): Prefab asset path +- `nodeUuid` (string, required): Node UUID with changes + +**Example**: +```json +{ + "tool": "prefab_update_prefab", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab", + "nodeUuid": "node-uuid-here" + } +} +``` + +### 4.7 prefab_revert_prefab +Revert prefab instance to original + +**Parameters**: +- `nodeUuid` (string, required): Prefab instance node UUID + +**Example**: +```json +{ + "tool": "prefab_revert_prefab", + "arguments": { + "nodeUuid": "prefab-instance-uuid-here" + } +} +``` + +### 4.8 prefab_get_prefab_info +Get detailed prefab information + +**Parameters**: +- `prefabPath` (string, required): Prefab asset path + +**Example**: +```json +{ + "tool": "prefab_get_prefab_info", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab" + } +} +``` + +--- + +## 5. Project Tools + +### 5.1 project_run_project +Run the project in preview mode + +**Parameters**: +- `platform` (string, optional): Target platform, options: `browser`, `simulator`, `preview`, default is `browser` + +**Example**: +```json +{ + "tool": "project_run_project", + "arguments": { + "platform": "browser" + } +} +``` + +### 5.2 project_build_project +Build the project + +**Parameters**: +- `platform` (string, required): Build platform, options: `web-mobile`, `web-desktop`, `ios`, `android`, `windows`, `mac` +- `debug` (boolean, optional): Debug build, default is true + +**Example**: +```json +{ + "tool": "project_build_project", + "arguments": { + "platform": "web-mobile", + "debug": false + } +} +``` + +### 5.3 project_get_project_info +Get project information + +**Parameters**: None + +**Example**: +```json +{ + "tool": "project_get_project_info", + "arguments": {} +} +``` + +### 5.4 project_get_project_settings +Get project settings + +**Parameters**: +- `category` (string, optional): Settings category, options: `general`, `physics`, `render`, `assets`, default is `general` + +**Example**: +```json +{ + "tool": "project_get_project_settings", + "arguments": { + "category": "physics" + } +} +``` + +### 5.5 project_refresh_assets +Refresh asset database + +**Parameters**: +- `folder` (string, optional): Specific folder to refresh + +**Example**: +```json +{ + "tool": "project_refresh_assets", + "arguments": { + "folder": "db://assets/textures" + } +} +``` + +### 5.6 project_import_asset +Import an asset file + +**Parameters**: +- `sourcePath` (string, required): Source file path +- `targetFolder` (string, required): Target folder in assets + +**Example**: +```json +{ + "tool": "project_import_asset", + "arguments": { + "sourcePath": "/path/to/image.png", + "targetFolder": "db://assets/textures" + } +} +``` + +### 5.7 project_get_asset_info +Get asset information + +**Parameters**: +- `assetPath` (string, required): Asset path + +**Example**: +```json +{ + "tool": "project_get_asset_info", + "arguments": { + "assetPath": "db://assets/textures/player.png" + } +} +``` + +### 5.8 project_get_assets +Get assets by type + +**Parameters**: +- `type` (string, optional): Asset type filter, options: `all`, `scene`, `prefab`, `script`, `texture`, `material`, `mesh`, `audio`, `animation`, default is `all` +- `folder` (string, optional): Folder to search in, default is `db://assets` + +**Example**: +```json +{ + "tool": "project_get_assets", + "arguments": { + "type": "texture", + "folder": "db://assets/textures" + } +} +``` + +### 5.9 project_get_build_settings +Get build settings + +**Parameters**: None + +**Example**: +```json +{ + "tool": "project_get_build_settings", + "arguments": {} +} +``` + +### 5.10 project_open_build_panel +Open the build panel in the editor + +**Parameters**: None + +**Example**: +```json +{ + "tool": "project_open_build_panel", + "arguments": {} +} +``` + +### 5.11 project_check_builder_status +Check if builder worker is ready + +**Parameters**: None + +**Example**: +```json +{ + "tool": "project_check_builder_status", + "arguments": {} +} +``` + +### 5.12 project_start_preview_server +Start preview server + +**Parameters**: +- `port` (number, optional): Preview server port, default is 7456 + +**Example**: +```json +{ + "tool": "project_start_preview_server", + "arguments": { + "port": 8080 + } +} +``` + +### 5.13 project_stop_preview_server +Stop preview server + +**Parameters**: None + +**Example**: +```json +{ + "tool": "project_stop_preview_server", + "arguments": {} +} +``` + +### 5.14 project_create_asset +Create a new asset file or folder + +**Parameters**: +- `url` (string, required): Asset URL +- `content` (string, optional): File content, null for folder +- `overwrite` (boolean, optional): Overwrite existing file, default is false + +**Example**: +```json +{ + "tool": "project_create_asset", + "arguments": { + "url": "db://assets/scripts/NewScript.ts", + "content": "// New TypeScript script\n", + "overwrite": false + } +} +``` + +### 5.15 project_copy_asset +Copy an asset to another location + +**Parameters**: +- `source` (string, required): Source asset URL +- `target` (string, required): Target location URL +- `overwrite` (boolean, optional): Overwrite existing file, default is false + +**Example**: +```json +{ + "tool": "project_copy_asset", + "arguments": { + "source": "db://assets/textures/player.png", + "target": "db://assets/textures/backup/player.png", + "overwrite": false + } +} +``` + +### 5.16 project_move_asset +Move an asset to another location + +**Parameters**: +- `source` (string, required): Source asset URL +- `target` (string, required): Target location URL +- `overwrite` (boolean, optional): Overwrite existing file, default is false + +**Example**: +```json +{ + "tool": "project_move_asset", + "arguments": { + "source": "db://assets/textures/old_player.png", + "target": "db://assets/textures/player.png", + "overwrite": true + } +} +``` + +### 5.17 project_delete_asset +Delete an asset + +**Parameters**: +- `url` (string, required): Asset URL to delete + +**Example**: +```json +{ + "tool": "project_delete_asset", + "arguments": { + "url": "db://assets/textures/unused.png" + } +} +``` + +### 5.18 project_save_asset +Save asset content + +**Parameters**: +- `url` (string, required): Asset URL +- `content` (string, required): Asset content + +**Example**: +```json +{ + "tool": "project_save_asset", + "arguments": { + "url": "db://assets/scripts/GameManager.ts", + "content": "// Updated script content\n" + } +} +``` + +### 5.19 project_reimport_asset +Reimport an asset + +**Parameters**: +- `url` (string, required): Asset URL to reimport + +**Example**: +```json +{ + "tool": "project_reimport_asset", + "arguments": { + "url": "db://assets/textures/player.png" + } +} +``` + +### 5.20 project_query_asset_path +Get asset disk path + +**Parameters**: +- `url` (string, required): Asset URL + +**Example**: +```json +{ + "tool": "project_query_asset_path", + "arguments": { + "url": "db://assets/textures/player.png" + } +} +``` + +### 5.21 project_query_asset_uuid +Get asset UUID from URL + +**Parameters**: +- `url` (string, required): Asset URL + +**Example**: +```json +{ + "tool": "project_query_asset_uuid", + "arguments": { + "url": "db://assets/textures/player.png" + } +} +``` + +### 5.22 project_query_asset_url +Get asset URL from UUID + +**Parameters**: +- `uuid` (string, required): Asset UUID + +**Example**: +```json +{ + "tool": "project_query_asset_url", + "arguments": { + "uuid": "asset-uuid-here" + } +} +``` + +--- + +## 6. Debug Tools + +### 6.1 debug_get_console_logs +Get editor console logs + +**Parameters**: +- `limit` (number, optional): Number of recent logs to retrieve, default is 100 +- `filter` (string, optional): Filter logs by type, options: `all`, `log`, `warn`, `error`, `info`, default is `all` + +**Example**: +```json +{ + "tool": "debug_get_console_logs", + "arguments": { + "limit": 50, + "filter": "error" + } +} +``` + +### 6.2 debug_clear_console +Clear editor console + +**Parameters**: None + +**Example**: +```json +{ + "tool": "debug_clear_console", + "arguments": {} +} +``` + +### 6.3 debug_execute_script +Execute JavaScript in scene context + +**Parameters**: +- `script` (string, required): JavaScript code to execute + +**Example**: +```json +{ + "tool": "debug_execute_script", + "arguments": { + "script": "console.log('Hello from MCP!');" + } +} +``` + +### 6.4 debug_get_node_tree +Get detailed node tree for debugging + +**Parameters**: +- `rootUuid` (string, optional): Root node UUID, uses scene root if not provided +- `maxDepth` (number, optional): Maximum tree depth, default is 10 + +**Example**: +```json +{ + "tool": "debug_get_node_tree", + "arguments": { + "rootUuid": "root-node-uuid", + "maxDepth": 5 + } +} +``` + +### 6.5 debug_get_performance_stats +Get performance statistics + +**Parameters**: None + +**Example**: +```json +{ + "tool": "debug_get_performance_stats", + "arguments": {} +} +``` + +### 6.6 debug_validate_scene +Validate current scene for issues + +**Parameters**: +- `checkMissingAssets` (boolean, optional): Check for missing asset references, default is true +- `checkPerformance` (boolean, optional): Check for performance issues, default is true + +**Example**: +```json +{ + "tool": "debug_validate_scene", + "arguments": { + "checkMissingAssets": true, + "checkPerformance": true + } +} +``` + +### 6.7 debug_get_editor_info +Get editor and environment information + +**Parameters**: None + +**Example**: +```json +{ + "tool": "debug_get_editor_info", + "arguments": {} +} +``` + +--- + +## 7. Preferences Tools + +### 7.1 preferences_get_preferences +Get editor preferences + +**Parameters**: +- `key` (string, optional): Specific preference key to get + +**Example**: +```json +{ + "tool": "preferences_get_preferences", + "arguments": { + "key": "editor.theme" + } +} +``` + +### 7.2 preferences_set_preferences +Set editor preferences + +**Parameters**: +- `key` (string, required): Preference key to set +- `value` (any, required): Preference value to set + +**Example**: +```json +{ + "tool": "preferences_set_preferences", + "arguments": { + "key": "editor.theme", + "value": "dark" + } +} +``` + +### 7.3 preferences_get_global_preferences +Get global editor preferences + +**Parameters**: +- `key` (string, optional): Global preference key to get + +**Example**: +```json +{ + "tool": "preferences_get_global_preferences", + "arguments": { + "key": "global.autoSave" + } +} +``` + +### 7.4 preferences_set_global_preferences +Set global editor preferences + +**Parameters**: +- `key` (string, required): Global preference key to set +- `value` (any, required): Global preference value to set + +**Example**: +```json +{ + "tool": "preferences_set_global_preferences", + "arguments": { + "key": "global.autoSave", + "value": true + } +} +``` + +### 7.5 preferences_get_recent_projects +Get recently opened projects + +**Parameters**: None + +**Example**: +```json +{ + "tool": "preferences_get_recent_projects", + "arguments": {} +} +``` + +### 7.6 preferences_clear_recent_projects +Clear recently opened projects list + +**Parameters**: None + +**Example**: +```json +{ + "tool": "preferences_clear_recent_projects", + "arguments": {} +} +``` + +--- + +## 8. Server Tools + +### 8.1 server_get_server_info +Get server information + +**Parameters**: None + +**Example**: +```json +{ + "tool": "server_get_server_info", + "arguments": {} +} +``` + +### 8.2 server_broadcast_custom_message +Broadcast a custom message + +**Parameters**: +- `message` (string, required): Message name +- `data` (any, optional): Message data + +**Example**: +```json +{ + "tool": "server_broadcast_custom_message", + "arguments": { + "message": "custom_event", + "data": {"type": "test", "value": 123} + } +} +``` + +### 8.3 server_get_editor_version +Get editor version information + +**Parameters**: None + +**Example**: +```json +{ + "tool": "server_get_editor_version", + "arguments": {} +} +``` + +### 8.4 server_get_project_name +Get current project name + +**Parameters**: None + +**Example**: +```json +{ + "tool": "server_get_project_name", + "arguments": {} +} +``` + +### 8.5 server_get_project_path +Get current project path + +**Parameters**: None + +**Example**: +```json +{ + "tool": "server_get_project_path", + "arguments": {} +} +``` + +### 8.6 server_get_project_uuid +Get current project UUID + +**Parameters**: None + +**Example**: +```json +{ + "tool": "server_get_project_uuid", + "arguments": {} +} +``` + +### 8.7 server_restart_editor +Request to restart the editor + +**Parameters**: None + +**Example**: +```json +{ + "tool": "server_restart_editor", + "arguments": {} +} +``` + +### 8.8 server_quit_editor +Request to quit the editor + +**Parameters**: None + +**Example**: +```json +{ + "tool": "server_quit_editor", + "arguments": {} +} +``` + +--- + +## 9. Broadcast Tools + +### 9.1 broadcast_get_broadcast_log +Get recent broadcast messages log + +**Parameters**: +- `limit` (number, optional): Number of recent messages to return, default is 50 +- `messageType` (string, optional): Filter by message type + +**Example**: +```json +{ + "tool": "broadcast_get_broadcast_log", + "arguments": { + "limit": 100, + "messageType": "scene_change" + } +} +``` + +### 9.2 broadcast_listen_broadcast +Start listening for specific broadcast messages + +**Parameters**: +- `messageType` (string, required): Message type to listen for + +**Example**: +```json +{ + "tool": "broadcast_listen_broadcast", + "arguments": { + "messageType": "node_created" + } +} +``` + +### 9.3 broadcast_stop_listening +Stop listening for specific broadcast messages + +**Parameters**: +- `messageType` (string, required): Message type to stop listening for + +**Example**: +```json +{ + "tool": "broadcast_stop_listening", + "arguments": { + "messageType": "node_created" + } +} +``` + +### 9.4 broadcast_clear_broadcast_log +Clear the broadcast messages log + +**Parameters**: None + +**Example**: +```json +{ + "tool": "broadcast_clear_broadcast_log", + "arguments": {} +} +``` + +### 9.5 broadcast_get_active_listeners +Get list of active broadcast listeners + +**Parameters**: None + +**Example**: +```json +{ + "tool": "broadcast_get_active_listeners", + "arguments": {} +} +``` + +--- + +## Usage Guidelines + +### 1. Tool Call Format + +All tool calls use JSON-RPC 2.0 format: + +```json +{ + "jsonrpc": "2.0", + "method": "tools/call", + "params": { + "name": "tool_name", + "arguments": { + // Tool parameters + } + }, + "id": 1 +} +``` + +### 2. Common UUID Retrieval Methods + +- Use `node_get_all_nodes` to get all node UUIDs +- Use `node_find_node_by_name` to find node UUID by name +- Use `scene_get_current_scene` to get scene UUID +- Use `prefab_get_prefab_list` to get prefab information + +### 3. Asset Path Format + +Cocos Creator uses `db://` prefixed asset URL format: +- Scenes: `db://assets/scenes/GameScene.scene` +- Prefabs: `db://assets/prefabs/Player.prefab` +- Scripts: `db://assets/scripts/GameManager.ts` +- Textures: `db://assets/textures/player.png` + +### 4. Error Handling + +If a tool call fails, it will return error information: + +```json +{ + "jsonrpc": "2.0", + "id": 1, + "error": { + "code": -32000, + "message": "Tool execution failed", + "data": { + "error": "Detailed error message" + } + } +} +``` + +### 5. Best Practices + +1. **Query Before Modify**: Use query tools to get current state before modifying nodes or components +2. **Use UUIDs**: Prefer using UUIDs over names to reference nodes and assets +3. **Error Checking**: Always check tool call return values to ensure operations succeeded +4. **Asset Management**: Ensure no references exist before deleting or moving assets +5. **Performance Considerations**: Avoid frequent tool calls in loops, consider batch operations + +--- + +## Technical Support + +If you encounter issues while using the tools, you can: + +1. Use `debug_get_console_logs` to view detailed error logs +2. Use `debug_validate_scene` to check for scene issues +3. Use `debug_get_editor_info` to get environment information +4. Check the MCP server's running status and logs + +--- + +*This document is based on Cocos Creator MCP Server v1.0.0. Please refer to the latest version documentation for updates.* \ No newline at end of file diff --git a/README.md b/README.md new file mode 100755 index 0000000..9a1a5fd --- /dev/null +++ b/README.md @@ -0,0 +1,361 @@ +# Cocos Creator MCP Server Plugin + +A comprehensive MCP (Model Context Protocol) server plugin for Cocos Creator 3.8+, enabling AI assistants to interact with the Cocos Creator editor through standardized protocols. One-click installation and use, eliminating all cumbersome environments and configurations. Claude clients Claude CLI and Cursor have been tested, and other editors are also perfectly supported in theory. + +**🚀 Now provides 80 tools in 9 categories, achieving 95% editor control! (Prefabs cannot be manipulated for the time being)** + +## Quick Links + +- **[📖 Complete Feature Guide (English)](FEATURE_GUIDE_EN.md)** - Detailed documentation for all 80 tools +- **[📖 完整功能指南 (中文)](FEATURE_GUIDE_CN.md)** - 所有80个工具的详细文档 +- **[🧪 Testing Guide](TEST_GUIDE.md)** - How to test the MCP server +**Claude cli configuration:** + +``` +claude mcp add --transport http http://localhost:3000/mcp (use the port number you configured yourself) +``` + +**Claude client configuration:** + +``` +{ + +"mcpServers": { + +"cocos-creator": { + +"type": "http", + +"url": "http://localhost:3000/mcp" + +} + +} + +} + +``` + +**Cursor or VS class MCP configuration** + +``` +{ + +"mcpServers": { + +"cocos-creator": { +"url": "http://localhost:3000/mcp" +} +} + +} + +``` + +## Features + +### 🎯 Scene Operations +- Get current scene information and complete scene list +- Open scenes by path and save current scene +- Create new scenes with custom names +- Get complete scene hierarchy with component information + +### 🎮 Node Operations +- Create nodes with different types (Node, 2DNode, 3DNode) +- Get node information by UUID and find nodes by name pattern +- Set node properties (position, rotation, scale, active) +- Delete, move, and duplicate nodes with full hierarchy support + +### 🔧 Component Operations +- Add/remove components from nodes +- Get all components of a node with properties +- Set component properties dynamically +- Attach script components from asset paths +- List available component types by category + +### 📦 Prefab Operations +- List all prefabs in project with folder organization +- Load, instantiate, and create prefabs +- Update existing prefabs and revert prefab instances +- Get detailed prefab information including dependencies + +### 🚀 Project Control +- Run project in preview mode (browser/simulator) +- Build project for different platforms (web, mobile, desktop) +- Get project information and settings +- Refresh asset database and import new assets +- Get detailed asset information + +### 🔍 Debug Tools +- Get editor console logs with filtering +- Clear console and execute JavaScript in scene context +- Get detailed node tree for debugging +- Performance statistics and scene validation +- Get editor and environment information + +### ⚙️ Additional Features +- **Preferences Management**: Get/set editor preferences and global settings +- **Server Control**: Server information, project details, and editor control +- **Message Broadcasting**: Listen to and broadcast custom messages +- **Asset Management**: Create, copy, move, delete, and query assets +- **Build System**: Project building and preview server control + +## Installation + +### 1. Copy Plugin Files + +Copy the entire `cocos-mcp-server` folder to your Cocos Creator project's `extensions` directory: + +``` +YourProject/ +├── assets/ +├── extensions/ +│ └── cocos-mcp-server/ <- Place plugin here +│ ├── source/ +│ ├── dist/ +│ ├── package.json +│ └── ... +├── settings/ +└── ... +``` + +### 2. Install Dependencies + +```bash +cd extensions/cocos-mcp-server +npm install +``` + +### 3. Build the Plugin + +```bash +npm run build +``` + +### 4. Enable Plugin + +1. Restart Cocos Creator or refresh extensions +2. The plugin will appear in the Extension menu +3. Click `Extension > Cocos MCP Server` to open the control panel + +## Usage + +### Starting the Server + +1. Open the MCP Server panel from `Extension > Cocos MCP Server` +2. Configure settings: + - **Port**: WebSocket server port (default: 3000) + - **Auto Start**: Automatically start server when editor opens + - **Debug Logging**: Enable detailed logging for development + - **Max Connections**: Maximum concurrent connections allowed + +3. Click "Start Server" to begin accepting connections + +### Connecting AI Assistants + +The server exposes a WebSocket endpoint at `ws://localhost:3000` (or your configured port). + +AI assistants can connect using the MCP protocol and access all available tools. + +### Tool Categories + +Tools are organized by category with naming convention: `category_toolname` + +- **scene_\***: Scene-related operations (8 tools) +- **node_\***: Node manipulation (9 tools) +- **component_\***: Component management (7 tools) +- **prefab_\***: Prefab operations (8 tools) +- **project_\***: Project control (22 tools) +- **debug_\***: Debugging utilities (7 tools) +- **preferences_\***: Editor preferences (6 tools) +- **server_\***: Server information (8 tools) +- **broadcast_\***: Message broadcasting (5 tools) + +**Total: 80 tools** for comprehensive editor control. + +📖 **[View Complete Tool Documentation](FEATURE_GUIDE_EN.md)** for detailed usage examples and parameters. + +## Example Tool Usage + +### Create a new sprite node +```json +{ + "tool": "node_create_node", + "arguments": { + "name": "MySprite", + "nodeType": "2DNode", + "parentUuid": "parent-node-uuid" + } +} +``` + +### Add a Sprite component +```json +{ + "tool": "component_add_component", + "arguments": { + "nodeUuid": "node-uuid", + "componentType": "cc.Sprite" + } +} +``` + +### Instantiate a prefab +```json +{ + "tool": "prefab_instantiate_prefab", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab", + "position": { "x": 100, "y": 200, "z": 0 } + } +} +``` + +### Run project in browser +```json +{ + "tool": "project_run_project", + "arguments": { + "platform": "browser" + } +} +``` + +## Configuration + +Settings are stored in `YourProject/settings/mcp-server.json`: + +```json +{ + "port": 3000, + "autoStart": false, + "enableDebugLog": true, + "allowedOrigins": ["*"], + "maxConnections": 10 +} +``` + +## Icon Setup + +To add an icon for the plugin panel: + +1. Create a PNG icon file (recommended size: 32x32 or 64x64) +2. Place it in the `static/` directory: `static/icon.png` +3. The icon path is already configured in `package.json` + +## Development + +### Project Structure +``` +cocos-mcp-server/ +├── source/ # TypeScript source files +│ ├── main.ts # Plugin entry point +│ ├── mcp-server.ts # MCP server implementation +│ ├── settings.ts # Settings management +│ ├── types/ # TypeScript type definitions +│ ├── tools/ # Tool implementations +│ └── panels/ # UI panel implementation +├── dist/ # Compiled JavaScript output +├── static/ # Static assets (icons, etc.) +├── i18n/ # Internationalization files +├── package.json # Plugin configuration +└── tsconfig.json # TypeScript configuration +``` + +### Building from Source + +```bash +# Install dependencies +npm install + +# Build for development with watch mode +npm run watch + +# Build for production +npm run build +``` + +### Adding New Tools + +1. Create a new tool class in `source/tools/` +2. Implement the `ToolExecutor` interface +3. Add tool to `mcp-server.ts` initialization +4. Tools are automatically exposed via MCP protocol + +### TypeScript Support + +The plugin is fully written in TypeScript with: +- Strict type checking enabled +- Comprehensive type definitions for all APIs +- IntelliSense support for development +- Automatic compilation to JavaScript + +## Testing + +The project includes comprehensive testing tools: + +- **[Manual Testing Guide](TEST_GUIDE.md)** - Step-by-step testing procedures +- **Automated Test Scripts**: `test-mcp-server.js`, `test-all-features.sh`, `test_mcp_server.py` +- **Comprehensive Test Suite**: `comprehensive-test.js` - Tests all 80 tools + +### Running Tests + +```bash +# Run comprehensive test suite +node comprehensive-test.js + +# Run feature-specific tests +./test-all-features.sh + +# Run Node.js test script +node test-mcp-server.js +``` + +## Troubleshooting + +### Common Issues + +1. **Server won't start**: Check port availability and firewall settings +2. **Tools not working**: Ensure scene is loaded and UUIDs are valid +3. **Build errors**: Run `npm run build` to check for TypeScript errors +4. **Connection issues**: Verify WebSocket URL and server status + +### Debug Mode + +Enable debug logging in the plugin panel for detailed operation logs. + +### Using Debug Tools + +```json +{ + "tool": "debug_get_console_logs", + "arguments": {"limit": 50, "filter": "error"} +} +``` + +```json +{ + "tool": "debug_validate_scene", + "arguments": {"checkMissingAssets": true} +} +``` + +## Requirements + +- Cocos Creator 3.8.6 or later +- Node.js (bundled with Cocos Creator) +- TypeScript (installed as dev dependency) + +## Architecture Notes + +This plugin uses a simplified MCP protocol implementation that is compatible with Cocos Creator's CommonJS environment. The WebSocket server provides a JSON-RPC interface for AI assistants to interact with the editor. + +### Protocol Support +- **WebSocket Connection**: `ws://localhost:3000` (configurable port) +- **JSON-RPC 2.0**: Standard request/response format +- **Tool Discovery**: `tools/list` method returns available tools +- **Tool Execution**: `tools/call` method executes specific tools + +## License + +This plug-in is for Cocos Creator project, and the source code is packaged together, which can be used for learning and communication. It is not encrypted. It can support your own secondary development and optimization. Any code of this project or its derivative code cannot be used for any commercial purpose or resale. If you need commercial use, please contact me. \ No newline at end of file diff --git a/README.zh-CN.md b/README.zh-CN.md new file mode 100755 index 0000000..4d9654f --- /dev/null +++ b/README.zh-CN.md @@ -0,0 +1,330 @@ +# Cocos Creator MCP 服务器插件 + +一个适用于 Cocos Creator 3.8+ 的综合性 MCP（模型上下文协议）服务器插件，使 AI 助手能够通过标准化协议与 Cocos Creator 编辑器进行交互。一键安装和使用，省去所有繁琐环境和配置。已经测试过Claude客户端Claude CLI和Cursor，其他的编辑器理论上也完美支持。 + +**🚀 现在提供 9 个类别的 80 个工具，实现95%的编辑器控制！（暂时无法操控预制体）** + +## 快速使用 + +**Claude cli配置：** + +``` +claude mcp add --transport http http://localhost:3000/mcp（使用你自己配置的端口号） +``` + +**Claude客户端配置：** + +``` +{ + + "mcpServers": { + + "cocos-creator": { + + "type": "http", + + "url": "http://localhost:3000/mcp" + + } + + } + +} +``` + +**Cursor或VS类MCP配置** + +``` +{ + + "mcpServers": { + + "cocos-creator": { + "url": "http://localhost:3000/mcp" + } + } + +} +``` + +**效果：** + +![image-20250717174157957](./image/入口.png) + + +## 功能特性 + +### 🎯 场景操作 +- 获取当前场景信息和完整场景列表 +- 通过路径打开场景并保存当前场景 +- 创建自定义名称的新场景 +- 获取完整场景层级结构及组件信息 + +### 🎮 节点操作 +- 创建不同类型的节点（Node、2DNode、3DNode） +- 通过 UUID 获取节点信息，按名称模式查找节点 +- 设置节点属性（位置、旋转、缩放、激活状态） +- 删除、移动和复制节点，完整支持层级结构 + +### 🔧 组件操作 +- 向节点添加/删除组件 +- 获取节点的所有组件及属性 +- 动态设置组件属性 +- 从资源路径挂载脚本组件 +- 按类别列出可用的组件类型 + +### 📦 预制体操作 +- 列出项目中的所有预制体，支持文件夹组织 +- 加载、实例化和创建预制体 +- 更新现有预制体并还原预制体实例 +- 获取详细的预制体信息，包括依赖关系 + +### 🚀 项目控制 +- 在预览模式下运行项目（浏览器/模拟器） +- 为不同平台构建项目（Web、移动端、桌面端） +- 获取项目信息和设置 +- 刷新资源数据库并导入新资源 +- 获取详细的资源信息 + +### 🔍 调试工具 +- 获取编辑器控制台日志，支持过滤 +- 清空控制台并在场景上下文中执行 JavaScript +- 获取详细的节点树用于调试 +- 性能统计和场景验证 +- 获取编辑器和环境信息 + +### ⚙️ 其他功能 +- **偏好设置管理**: 获取/设置编辑器偏好和全局设置 +- **服务器控制**: 服务器信息、项目详情和编辑器控制 +- **消息广播**: 监听和广播自定义消息 +- **资源管理**: 创建、复制、移动、删除和查询资源 +- **构建系统**: 项目构建和预览服务器控制 + +## 安装说明 + +### 1. 复制插件文件 + +将整个 `cocos-mcp-server` 文件夹复制到您的 Cocos Creator 项目的 `extensions` 目录中： + +``` +您的项目/ +├── assets/ +├── extensions/ +│ └── cocos-mcp-server/ <- 将插件放在这里 +│ ├── source/ +│ ├── dist/ +│ ├── package.json +│ └── ... +├── settings/ +└── ... +``` + +### 2. 安装依赖 + +```bash +cd extensions/cocos-mcp-server +npm install +``` + +### 3. 构建插件 + +```bash +npm run build +``` + +### 4. 启用插件 + +1. 重启 Cocos Creator 或刷新扩展 +2. 插件将出现在扩展菜单中 +3. 点击 `扩展 > Cocos MCP Server` 打开控制面板 + +## 使用方法 + +### 启动服务器 + +1. 从 `扩展 > Cocos MCP Server` 打开 MCP 服务器面板 +2. 配置设置： + - **端口**: http 服务器端口（默认：3000） + - **自动启动**: 编辑器启动时自动启动服务器 + - **调试日志**: 启用详细日志以便开发调试 + - **最大连接数**: 允许的最大并发连接数 + +3. 点击"启动服务器"开始接受连接 + +### 连接 AI 助手 + +服务器在 `http://localhost:3000/mcp`（或您配置的端口）上提供 http 端点。 + +AI 助手可以使用 MCP 协议连接并访问所有可用工具。 + +### 工具分类 + +工具按类别组织，命名约定为：`category_toolname` + +- **scene_\***: 场景相关操作 (8个工具) +- **node_\***: 节点操作 (9个工具) +- **component_\***: 组件管理 (7个工具) +- **prefab_\***: 预制体操作 (8个工具) +- **project_\***: 项目控制 (22个工具) +- **debug_\***: 调试工具 (7个工具) +- **preferences_\***: 编辑器偏好设置 (6个工具) +- **server_\***: 服务器信息 (8个工具) +- **broadcast_\***: 消息广播 (5个工具) + +**总计: 80个工具** 实现全面的编辑器控制。 + +📖 **[查看完整工具文档](FEATURE_GUIDE_CN.md)** 了解详细的使用示例和参数。 + +## 工具使用示例 + +### 创建新的精灵节点 +```json +{ + "tool": "node_create_node", + "arguments": { + "name": "MySprite", + "nodeType": "2DNode", + "parentUuid": "parent-node-uuid" + } +} +``` + +### 添加 Sprite 组件 +```json +{ + "tool": "component_add_component", + "arguments": { + "nodeUuid": "node-uuid", + "componentType": "cc.Sprite" + } +} +``` + +### 实例化预制体 +```json +{ + "tool": "prefab_instantiate_prefab", + "arguments": { + "prefabPath": "db://assets/prefabs/Enemy.prefab", + "position": { "x": 100, "y": 200, "z": 0 } + } +} +``` + +### 在浏览器中运行项目 +```json +{ + "tool": "project_run_project", + "arguments": { + "platform": "browser" + } +} +``` + +## 配置 + +设置存储在 `您的项目/settings/mcp-server.json` 中： + +```json +{ + "port": 3000, + "autoStart": false, + "enableDebugLog": true, + "allowedOrigins": ["*"], + "maxConnections": 10 +} +``` + +## 图标设置 + +为插件面板添加图标： + +1. 创建 PNG 图标文件（推荐尺寸：32x32 或 64x64） +2. 将其放在 `static/` 目录中：`static/icon.png` +3. 图标路径已在 `package.json` 中配置 + +## 开发 + +### 项目结构 +``` +cocos-mcp-server/ +├── source/ # TypeScript 源文件 +│ ├── main.ts # 插件入口点 +│ ├── mcp-server.ts # MCP 服务器实现 +│ ├── settings.ts # 设置管理 +│ ├── types/ # TypeScript 类型定义 +│ ├── tools/ # 工具实现 +│ └── panels/ # UI 面板实现 +├── dist/ # 编译后的 JavaScript 输出 +├── static/ # 静态资源（图标等） +├── i18n/ # 国际化文件 +├── package.json # 插件配置 +└── tsconfig.json # TypeScript 配置 +``` + +### 从源码构建 + +```bash +# 安装依赖 +npm install + +# 开发构建（监视模式） +npm run watch + +# 生产构建 +npm run build +``` + +### 添加新工具 + +1. 在 `source/tools/` 中创建新的工具类 +2. 实现 `ToolExecutor` 接口 +3. 将工具添加到 `mcp-server.ts` 初始化中 +4. 工具会自动通过 MCP 协议暴露 + +### TypeScript 支持 + +插件完全使用 TypeScript 编写，具备： +- 启用严格类型检查 +- 为所有 API 提供全面的类型定义 +- 开发时的 IntelliSense 支持 +- 自动编译为 JavaScript + +## 故障排除 + +### 常见问题 + +1. **服务器无法启动**: 检查端口可用性和防火墙设置 +2. **工具不工作**: 确保场景已加载且 UUID 有效 +3. **构建错误**: 运行 `npm run build` 检查 TypeScript 错误 +4. **连接问题**: 验证 HTTP URL 和服务器状态 + +### 调试模式 + +在插件面板中启用调试日志以获取详细的操作日志。 + +### 使用调试工具 + +```json +{ + "tool": "debug_get_console_logs", + "arguments": {"limit": 50, "filter": "error"} +} +``` + +```json +{ + "tool": "debug_validate_scene", + "arguments": {"checkMissingAssets": true} +} +``` + +## 系统要求 + +- Cocos Creator 3.8.0 或更高版本 +- Node.js（Cocos Creator 自带） +- TypeScript（作为开发依赖安装） + +## 许可证 + +本插件供 Cocos Creator 项目使用,并且源代码一并打包，可以用于学习和交流。没有加密。可以支持你自己二次开发优化，任何本项目代码或者衍生代码均不能用于任何商用、转售，如果需要商用，请联系本人。 \ No newline at end of file diff --git a/base.tsconfig.json b/base.tsconfig.json new file mode 100755 index 0000000..6fd6302 --- /dev/null +++ b/base.tsconfig.json @@ -0,0 +1,22 @@ +{ + "$schema": "https://schemastore.azurewebsites.net/schemas/json/tsconfig.json", + "compilerOptions": { + "target": "ES2017", + "module": "CommonJS", + "moduleResolution": "node", + "inlineSourceMap": true, + "inlineSources": true, + "esModuleInterop": true, + "skipLibCheck": true, + "strict": true, + "experimentalDecorators": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "outDir": "./dist", + "rootDir": "./source", + "types": [ + "node", + "@cocos/creator-types/editor", + ] + } +} \ No newline at end of file diff --git a/comprehensive-test.js b/comprehensive-test.js new file mode 100644 index 0000000..457886f --- /dev/null +++ b/comprehensive-test.js @@ -0,0 +1,230 @@ +const http = require('http'); + +const SERVER_URL = 'http://localhost:8585'; + +class MCPTester { + constructor() { + this.testResults = []; + this.currentCategory = ''; + } + + async makeRequest(toolName, args = {}) { + const payload = { + jsonrpc: '2.0', + id: Date.now(), + method: 'tools/call', + params: { + name: toolName, + arguments: args + } + }; + + return new Promise((resolve, reject) => { + const data = JSON.stringify(payload); + const options = { + hostname: '127.0.0.1', + port: 8585, + path: '/mcp', + method: 'POST', + headers: { + 'Content-Type': 'application/json', + 'Content-Length': data.length + } + }; + + const req = http.request(options, (res) => { + let responseData = ''; + res.on('data', chunk => responseData += chunk); + res.on('end', () => { + try { + const response = JSON.parse(responseData); + resolve(response); + } catch (e) { + reject(e); + } + }); + }); + + req.on('error', reject); + req.write(data); + req.end(); + }); + } + + async testTool(toolName, args = {}, description = '') { + const testName = description || toolName.replace(/_/g, ' '); + process.stdout.write(` ${testName}... `); + + try { + const response = await this.makeRequest(toolName, args); + + if (response.result && response.result.success !== false) { + console.log('✅ 通过'); + this.testResults.push({ tool: toolName, status: 'pass', category: this.currentCategory }); + return response.result; + } else { + const error = response.result?.error || response.error?.message || 'Unknown error'; + console.log(`❌ 失败: ${error}`); + this.testResults.push({ tool: toolName, status: 'fail', error, category: this.currentCategory }); + return null; + } + } catch (error) { + console.log(`❌ 错误: ${error.message}`); + this.testResults.push({ tool: toolName, status: 'error', error: error.message, category: this.currentCategory }); + return null; + } + } + + printCategory(categoryName) { + this.currentCategory = categoryName; + console.log(`\n📁 ${categoryName}:`); + } + + printSummary() { + console.log('\n' + '='.repeat(60)); + console.log('📊 测试结果汇总:'); + console.log('='.repeat(60)); + + const categories = [...new Set(this.testResults.map(r => r.category))]; + + for (const category of categories) { + const categoryResults = this.testResults.filter(r => r.category === category); + const passed = categoryResults.filter(r => r.status === 'pass').length; + const failed = categoryResults.filter(r => r.status === 'fail').length; + const errors = categoryResults.filter(r => r.status === 'error').length; + + console.log(`\n${category}:`); + console.log(` ✅ 通过: ${passed}`); + console.log(` ❌ 失败: ${failed}`); + console.log(` ⚠️ 错误: ${errors}`); + console.log(` 📊 总计: ${categoryResults.length}`); + } + + const totalPassed = this.testResults.filter(r => r.status === 'pass').length; + const totalFailed = this.testResults.filter(r => r.status === 'fail').length; + const totalErrors = this.testResults.filter(r => r.status === 'error').length; + const total = this.testResults.length; + + console.log(`\n总体结果:`); + console.log(` ✅ 通过: ${totalPassed}/${total} (${((totalPassed/total)*100).toFixed(1)}%)`); + console.log(` ❌ 失败: ${totalFailed}/${total} (${((totalFailed/total)*100).toFixed(1)}%)`); + console.log(` ⚠️ 错误: ${totalErrors}/${total} (${((totalErrors/total)*100).toFixed(1)}%)`); + + // 显示失败的工具 + const failedTools = this.testResults.filter(r => r.status === 'fail' || r.status === 'error'); + if (failedTools.length > 0) { + console.log('\n❌ 失败的工具:'); + failedTools.forEach(tool => { + console.log(` - ${tool.tool}: ${tool.error}`); + }); + } + } + + async runAllTests() { + console.log('🚀 开始全面测试 Cocos MCP 工具...\n'); + + // 1. 场景管理工具 + this.printCategory('场景管理'); + await this.testTool('scene_create_scene', { + sceneName: 'TestScene2', + savePath: 'db://assets/scenes/TestScene2.scene' + }, '创建场景'); + await this.testTool('scene_get_current_scene', {}, '获取当前场景'); + await this.testTool('scene_save_scene', {}, '保存场景'); + await this.testTool('scene_get_scene_list', {}, '获取场景列表'); + await this.testTool('scene_get_scene_hierarchy', {}, '获取场景层次结构'); + + // 2. 节点操作工具 + this.printCategory('节点操作'); + const nodeResult = await this.testTool('node_create_node', { name: 'TestNode' }, '创建节点'); + let testNodeUuid = null; + if (nodeResult && nodeResult.data && nodeResult.data.uuid) { + testNodeUuid = nodeResult.data.uuid; + } + + await this.testTool('node_get_all_nodes', {}, '获取所有节点'); + await this.testTool('node_find_node_by_name', { name: 'TestNode' }, '按名称查找节点'); + + if (testNodeUuid) { + await this.testTool('node_get_node_info', { uuid: testNodeUuid }, '获取节点信息'); + await this.testTool('node_set_node_property', { + uuid: testNodeUuid, + property: 'position', + value: { x: 100, y: 100, z: 0 } + }, '设置节点属性'); + await this.testTool('node_duplicate_node', { uuid: testNodeUuid }, '复制节点'); + } + + // 3. 组件管理工具 + this.printCategory('组件管理'); + if (testNodeUuid) { + await this.testTool('component_add_component', { + nodeUuid: testNodeUuid, + componentType: 'cc.Sprite' + }, '添加组件'); + await this.testTool('component_get_components', { nodeUuid: testNodeUuid }, '获取组件列表'); + await this.testTool('component_get_component_info', { + nodeUuid: testNodeUuid, + componentType: 'cc.Sprite' + }, '获取组件信息'); + } + await this.testTool('component_get_available_components', {}, '获取可用组件'); + + // 4. 预制体工具 + this.printCategory('预制体管理'); + if (testNodeUuid) { + await this.testTool('prefab_create_prefab', { + nodeUuid: testNodeUuid, + prefabPath: 'db://assets/prefabs/TestPrefab.prefab' + }, '创建预制体'); + } + await this.testTool('prefab_get_prefab_list', {}, '获取预制体列表'); + await this.testTool('prefab_instantiate_prefab', { + prefabPath: 'db://assets/prefabs/TestPrefab.prefab' + }, '实例化预制体'); + + // 5. 项目和资源管理 + this.printCategory('项目资源管理'); + await this.testTool('project_get_project_info', {}, '获取项目信息'); + await this.testTool('project_get_project_settings', {}, '获取项目设置'); + await this.testTool('project_get_assets', { type: 'all' }, '获取资源列表'); + await this.testTool('project_refresh_assets', {}, '刷新资源'); + await this.testTool('project_create_asset', { + url: 'db://assets/test-folder', + content: null + }, '创建资源文件夹'); + + // 6. 调试工具 + this.printCategory('调试工具'); + await this.testTool('debug_get_console_logs', {}, '获取控制台日志'); + await this.testTool('debug_get_performance_stats', {}, '获取性能统计'); + await this.testTool('debug_validate_scene', {}, '验证场景'); + await this.testTool('debug_get_editor_info', {}, '获取编辑器信息'); + + // 7. 偏好设置工具 + this.printCategory('偏好设置'); + await this.testTool('preferences_get_preferences', {}, '获取偏好设置'); + await this.testTool('preferences_get_global_preferences', {}, '获取全局偏好设置'); + await this.testTool('preferences_get_recent_projects', {}, '获取最近项目'); + + // 8. 服务器控制工具 + this.printCategory('服务器控制'); + await this.testTool('server_get_server_info', {}, '获取服务器信息'); + await this.testTool('server_get_editor_version', {}, '获取编辑器版本'); + + // 9. 广播消息工具 + this.printCategory('广播消息'); + await this.testTool('broadcast_get_broadcast_log', {}, '获取广播日志'); + + // 清理测试节点 + if (testNodeUuid) { + await this.testTool('node_delete_node', { uuid: testNodeUuid }, '删除测试节点'); + } + + this.printSummary(); + } +} + +// 运行测试 +const tester = new MCPTester(); +tester.runAllTests().catch(console.error); \ No newline at end of file diff --git a/debug-api.js b/debug-api.js new file mode 100644 index 0000000..a1e4ecd --- /dev/null +++ b/debug-api.js @@ -0,0 +1,46 @@ +// 测试可用的 Editor API +const testMethods = [ + 'scene.query-node-tree', + 'scene.create-node', + 'scene.remove-node', + 'scene.set-property', + 'scene.create-component', + 'scene.remove-component', + 'scene.add-component', + 'scene.query-node', + 'scene.query-scene', + 'scene.query-hierarchy' +]; + +async function testAPI() { + console.log('Testing available Editor API methods...'); + + for (const method of testMethods) { + console.log(`\nTesting: ${method}`); + + try { + const response = await fetch('http://localhost:8585/mcp', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + jsonrpc: '2.0', + id: 1, + method: 'tools/call', + params: { + name: 'debug_test_editor_api', + arguments: { + method: method.replace('.', ' - ') + } + } + }) + }); + + const data = await response.json(); + console.log(`Response: ${JSON.stringify(data)}`); + } catch (error) { + console.log(`Error: ${error.message}`); + } + } +} + +testAPI(); \ No newline at end of file diff --git a/dist/main.js b/dist/main.js new file mode 100644 index 0000000..2adc9d6 --- /dev/null +++ b/dist/main.js @@ -0,0 +1,119 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.methods = void 0; +exports.load = load; +exports.unload = unload; +const mcp_server_1 = require("./mcp-server"); +const settings_1 = require("./settings"); +let mcpServer = null; +/** + * @en Registration method for the main process of Extension + * @zh 为扩展的主进程的注册方法 + */ +exports.methods = { + /** + * @en Open the MCP server panel + * @zh 打开 MCP 服务器面板 + */ + openPanel() { + Editor.Panel.open('cocos-mcp-server'); + }, + /** + * @en Start the MCP server + * @zh 启动 MCP 服务器 + */ + async startServer() { + if (mcpServer) { + await mcpServer.start(); + } + else { + console.warn('[MCP插件] mcpServer 未初始化'); + } + }, + /** + * @en Stop the MCP server + * @zh 停止 MCP 服务器 + */ + async stopServer() { + if (mcpServer) { + mcpServer.stop(); + } + else { + console.warn('[MCP插件] mcpServer 未初始化'); + } + }, + /** + * @en Get server status + * @zh 获取服务器状态 + */ + getServerStatus() { + return mcpServer ? mcpServer.getStatus() : { running: false, port: 0, clients: 0 }; + }, + /** + * @en Update server settings + * @zh 更新服务器设置 + */ + updateSettings(settings) { + (0, settings_1.saveSettings)(settings); + if (mcpServer) { + mcpServer.stop(); + mcpServer = new mcp_server_1.MCPServer(settings); + mcpServer.start(); + } + else { + mcpServer = new mcp_server_1.MCPServer(settings); + mcpServer.start(); + } + }, + /** + * @en Get tools list + * @zh 获取工具列表 + */ + getToolsList() { + return mcpServer ? mcpServer.getAvailableTools() : []; + }, + /** + * @en Get server settings + * @zh 获取服务器设置 + */ + getServerSettings() { + return mcpServer ? mcpServer.getSettings() : (0, settings_1.readSettings)(); + } +}; +/** + * @en Method Triggered on Extension Startup + * @zh 扩展启动时触发的方法 + */ +function load() { + console.log('[MCP Plugin] Loading MCP server plugin...'); + try { + const settings = (0, settings_1.readSettings)(); + console.log('[MCP Plugin] Settings loaded:', settings); + mcpServer = new mcp_server_1.MCPServer(settings); + // 如果设置了自动启动，则启动服务器 + if (settings.autoStart) { + console.log('[MCP Plugin] Auto-starting MCP server...'); + mcpServer.start().catch(error => { + console.error('[MCP Plugin] Failed to auto-start server:', error); + }); + } + else { + console.log('[MCP Plugin] MCP server created but not started (autoStart=false)'); + console.log('[MCP Plugin] Use the MCP panel or call startServer() to start the server'); + } + } + catch (error) { + console.error('[MCP Plugin] Failed to load MCP server:', error); + } +} +/** + * @en Method triggered when uninstalling the extension + * @zh 卸载扩展时触发的方法 + */ +function unload() { + if (mcpServer) { + mcpServer.stop(); + mcpServer = null; + } +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist/mcp-server.js b/dist/mcp-server.js new file mode 100644 index 0000000..597f11c --- /dev/null +++ b/dist/mcp-server.js @@ -0,0 +1,268 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.MCPServer = void 0; +const http = __importStar(require("http")); +const url = __importStar(require("url")); +const scene_tools_1 = require("./tools/scene-tools"); +const node_tools_1 = require("./tools/node-tools"); +const component_tools_1 = require("./tools/component-tools"); +const prefab_tools_1 = require("./tools/prefab-tools"); +const project_tools_1 = require("./tools/project-tools"); +const debug_tools_1 = require("./tools/debug-tools"); +const preferences_tools_1 = require("./tools/preferences-tools"); +const server_tools_1 = require("./tools/server-tools"); +const broadcast_tools_1 = require("./tools/broadcast-tools"); +class MCPServer { + constructor(settings) { + this.httpServer = null; + this.clients = new Map(); + this.tools = {}; + this.toolsList = []; + this.settings = settings; + this.initializeTools(); + } + initializeTools() { + try { + console.log('[MCPServer] Initializing tools...'); + this.tools.scene = new scene_tools_1.SceneTools(); + this.tools.node = new node_tools_1.NodeTools(); + this.tools.component = new component_tools_1.ComponentTools(); + this.tools.prefab = new prefab_tools_1.PrefabTools(); + this.tools.project = new project_tools_1.ProjectTools(); + this.tools.debug = new debug_tools_1.DebugTools(); + this.tools.preferences = new preferences_tools_1.PreferencesTools(); + this.tools.server = new server_tools_1.ServerTools(); + this.tools.broadcast = new broadcast_tools_1.BroadcastTools(); + console.log('[MCPServer] Tools initialized successfully'); + } + catch (error) { + console.error('[MCPServer] Error initializing tools:', error); + throw error; + } + } + async start() { + if (this.httpServer) { + console.log('[MCPServer] Server is already running'); + return; + } + try { + console.log(`[MCPServer] Starting HTTP server on port ${this.settings.port}...`); + this.httpServer = http.createServer(this.handleHttpRequest.bind(this)); + await new Promise((resolve, reject) => { + this.httpServer.listen(this.settings.port, '127.0.0.1', () => { + console.log(`[MCPServer] ✅ HTTP server started successfully on http://127.0.0.1:${this.settings.port}`); + console.log(`[MCPServer] Health check: http://127.0.0.1:${this.settings.port}/health`); + console.log(`[MCPServer] MCP endpoint: http://127.0.0.1:${this.settings.port}/mcp`); + resolve(); + }); + this.httpServer.on('error', (err) => { + console.error('[MCPServer] ❌ Failed to start server:', err); + if (err.code === 'EADDRINUSE') { + console.error(`[MCPServer] Port ${this.settings.port} is already in use. Please change the port in settings.`); + } + reject(err); + }); + }); + this.setupTools(); + console.log('[MCPServer] 🚀 MCP Server is ready for connections'); + } + catch (error) { + console.error('[MCPServer] ❌ Failed to start server:', error); + throw error; + } + } + setupTools() { + this.toolsList = []; + for (const [category, toolSet] of Object.entries(this.tools)) { + const tools = toolSet.getTools(); + for (const tool of tools) { + this.toolsList.push({ + name: `${category}_${tool.name}`, + description: tool.description, + inputSchema: tool.inputSchema + }); + } + } + } + async executeToolCall(toolName, args) { + const parts = toolName.split('_'); + const category = parts[0]; + const toolMethodName = parts.slice(1).join('_'); + if (this.tools[category]) { + return await this.tools[category].execute(toolMethodName, args); + } + throw new Error(`Tool ${toolName} not found`); + } + getClients() { + return Array.from(this.clients.values()); + } + getAvailableTools() { + return this.toolsList; + } + getSettings() { + return this.settings; + } + async handleHttpRequest(req, res) { + const parsedUrl = url.parse(req.url || '', true); + const pathname = parsedUrl.pathname; + // Set CORS headers + res.setHeader('Access-Control-Allow-Origin', '*'); + res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS'); + res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization'); + res.setHeader('Content-Type', 'application/json'); + if (req.method === 'OPTIONS') { + res.writeHead(200); + res.end(); + return; + } + try { + if (pathname === '/mcp' && req.method === 'POST') { + await this.handleMCPRequest(req, res); + } + else if (pathname === '/health' && req.method === 'GET') { + res.writeHead(200); + res.end(JSON.stringify({ status: 'ok', tools: this.toolsList.length })); + } + else { + res.writeHead(404); + res.end(JSON.stringify({ error: 'Not found' })); + } + } + catch (error) { + console.error('HTTP request error:', error); + res.writeHead(500); + res.end(JSON.stringify({ error: 'Internal server error' })); + } + } + async handleMCPRequest(req, res) { + let body = ''; + req.on('data', (chunk) => { + body += chunk.toString(); + }); + req.on('end', async () => { + try { + const message = JSON.parse(body); + const response = await this.handleMessage(message); + res.writeHead(200); + res.end(JSON.stringify(response)); + } + catch (error) { + console.error('Error handling MCP request:', error); + res.writeHead(400); + res.end(JSON.stringify({ + jsonrpc: '2.0', + id: null, + error: { + code: -32700, + message: 'Parse error' + } + })); + } + }); + } + async handleMessage(message) { + const { id, method, params } = message; + try { + let result; + switch (method) { + case 'tools/list': + result = { tools: this.getAvailableTools() }; + break; + case 'tools/call': + const { name, arguments: args } = params; + const toolResult = await this.executeToolCall(name, args); + result = { content: [{ type: 'text', text: JSON.stringify(toolResult) }] }; + break; + case 'initialize': + // MCP initialization + result = { + protocolVersion: '2024-11-05', + capabilities: { + tools: {} + }, + serverInfo: { + name: 'cocos-mcp-server', + version: '1.0.0' + } + }; + break; + default: + throw new Error(`Unknown method: ${method}`); + } + return { + jsonrpc: '2.0', + id, + result + }; + } + catch (error) { + return { + jsonrpc: '2.0', + id, + error: { + code: -32603, + message: error.message + } + }; + } + } + stop() { + if (this.httpServer) { + this.httpServer.close(); + this.httpServer = null; + console.log('[MCPServer] HTTP server stopped'); + } + this.clients.clear(); + } + getStatus() { + return { + running: !!this.httpServer, + port: this.settings.port, + clients: 0 // HTTP is stateless, no persistent clients + }; + } + updateSettings(settings) { + this.settings = settings; + if (this.httpServer) { + this.stop(); + this.start(); + } + } +} +exports.MCPServer = MCPServer; +// HTTP transport doesn't need persistent connections +// MCP over HTTP uses request-response pattern +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcp-server.js","sourceRoot":"","sources":["../source/mcp-server.ts"],"names":[],"mappings":"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","sourcesContent":["import * as http from 'http';\nimport * as url from 'url';\nimport { v4 as uuidv4 } from 'uuid';\nimport { MCPServerSettings, ServerStatus, MCPClient, ToolDefinition } from './types';\nimport { SceneTools } from './tools/scene-tools';\nimport { NodeTools } from './tools/node-tools';\nimport { ComponentTools } from './tools/component-tools';\nimport { PrefabTools } from './tools/prefab-tools';\nimport { ProjectTools } from './tools/project-tools';\nimport { DebugTools } from './tools/debug-tools';\nimport { PreferencesTools } from './tools/preferences-tools';\nimport { ServerTools } from './tools/server-tools';\nimport { BroadcastTools } from './tools/broadcast-tools';\n\nexport class MCPServer {\n    private settings: MCPServerSettings;\n    private httpServer: http.Server | null = null;\n    private clients: Map<string, MCPClient> = new Map();\n    private tools: Record<string, any> = {};\n    private toolsList: ToolDefinition[] = [];\n\n    constructor(settings: MCPServerSettings) {\n        this.settings = settings;\n        this.initializeTools();\n    }\n\n    private initializeTools(): void {\n        try {\n            console.log('[MCPServer] Initializing tools...');\n            this.tools.scene = new SceneTools();\n            this.tools.node = new NodeTools();\n            this.tools.component = new ComponentTools();\n            this.tools.prefab = new PrefabTools();\n            this.tools.project = new ProjectTools();\n            this.tools.debug = new DebugTools();\n            this.tools.preferences = new PreferencesTools();\n            this.tools.server = new ServerTools();\n            this.tools.broadcast = new BroadcastTools();\n            console.log('[MCPServer] Tools initialized successfully');\n        } catch (error) {\n            console.error('[MCPServer] Error initializing tools:', error);\n            throw error;\n        }\n    }\n\n    public async start(): Promise<void> {\n        if (this.httpServer) {\n            console.log('[MCPServer] Server is already running');\n            return;\n        }\n\n        try {\n            console.log(`[MCPServer] Starting HTTP server on port ${this.settings.port}...`);\n            this.httpServer = http.createServer(this.handleHttpRequest.bind(this));\n\n            await new Promise<void>((resolve, reject) => {\n                this.httpServer!.listen(this.settings.port, '127.0.0.1', () => {\n                    console.log(`[MCPServer] ✅ HTTP server started successfully on http://127.0.0.1:${this.settings.port}`);\n                    console.log(`[MCPServer] Health check: http://127.0.0.1:${this.settings.port}/health`);\n                    console.log(`[MCPServer] MCP endpoint: http://127.0.0.1:${this.settings.port}/mcp`);\n                    resolve();\n                });\n                this.httpServer!.on('error', (err: any) => {\n                    console.error('[MCPServer] ❌ Failed to start server:', err);\n                    if (err.code === 'EADDRINUSE') {\n                        console.error(`[MCPServer] Port ${this.settings.port} is already in use. Please change the port in settings.`);\n                    }\n                    reject(err);\n                });\n            });\n\n            this.setupTools();\n            console.log('[MCPServer] 🚀 MCP Server is ready for connections');\n        } catch (error) {\n            console.error('[MCPServer] ❌ Failed to start server:', error);\n            throw error;\n        }\n    }\n\n    private setupTools(): void {\n        this.toolsList = [];\n        \n        for (const [category, toolSet] of Object.entries(this.tools)) {\n            const tools = toolSet.getTools();\n            for (const tool of tools) {\n                this.toolsList.push({\n                    name: `${category}_${tool.name}`,\n                    description: tool.description,\n                    inputSchema: tool.inputSchema\n                });\n            }\n        }\n\n    }\n\n    public async executeToolCall(toolName: string, args: any): Promise<any> {\n        const parts = toolName.split('_');\n        const category = parts[0];\n        const toolMethodName = parts.slice(1).join('_');\n        \n        if (this.tools[category]) {\n            return await this.tools[category].execute(toolMethodName, args);\n        }\n        \n        throw new Error(`Tool ${toolName} not found`);\n    }\n\n    public getClients(): MCPClient[] {\n        return Array.from(this.clients.values());\n    }\n    public getAvailableTools(): ToolDefinition[] {\n        return this.toolsList;\n    }\n\n    public getSettings(): MCPServerSettings {\n        return this.settings;\n    }\n\n    private async handleHttpRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {\n        const parsedUrl = url.parse(req.url || '', true);\n        const pathname = parsedUrl.pathname;\n        \n        // Set CORS headers\n        res.setHeader('Access-Control-Allow-Origin', '*');\n        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');\n        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');\n        res.setHeader('Content-Type', 'application/json');\n        \n        if (req.method === 'OPTIONS') {\n            res.writeHead(200);\n            res.end();\n            return;\n        }\n        \n        try {\n            if (pathname === '/mcp' && req.method === 'POST') {\n                await this.handleMCPRequest(req, res);\n            } else if (pathname === '/health' && req.method === 'GET') {\n                res.writeHead(200);\n                res.end(JSON.stringify({ status: 'ok', tools: this.toolsList.length }));\n            } else {\n                res.writeHead(404);\n                res.end(JSON.stringify({ error: 'Not found' }));\n            }\n        } catch (error) {\n            console.error('HTTP request error:', error);\n            res.writeHead(500);\n            res.end(JSON.stringify({ error: 'Internal server error' }));\n        }\n    }\n    \n    private async handleMCPRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {\n        let body = '';\n        \n        req.on('data', (chunk) => {\n            body += chunk.toString();\n        });\n        \n        req.on('end', async () => {\n            try {\n                const message = JSON.parse(body);\n                const response = await this.handleMessage(message);\n                res.writeHead(200);\n                res.end(JSON.stringify(response));\n            } catch (error) {\n                console.error('Error handling MCP request:', error);\n                res.writeHead(400);\n                res.end(JSON.stringify({\n                    jsonrpc: '2.0',\n                    id: null,\n                    error: {\n                        code: -32700,\n                        message: 'Parse error'\n                    }\n                }));\n            }\n        });\n    }\n\n    private async handleMessage(message: any): Promise<any> {\n        const { id, method, params } = message;\n\n        try {\n            let result: any;\n\n            switch (method) {\n                case 'tools/list':\n                    result = { tools: this.getAvailableTools() };\n                    break;\n                case 'tools/call':\n                    const { name, arguments: args } = params;\n                    const toolResult = await this.executeToolCall(name, args);\n                    result = { content: [{ type: 'text', text: JSON.stringify(toolResult) }] };\n                    break;\n                case 'initialize':\n                    // MCP initialization\n                    result = {\n                        protocolVersion: '2024-11-05',\n                        capabilities: {\n                            tools: {}\n                        },\n                        serverInfo: {\n                            name: 'cocos-mcp-server',\n                            version: '1.0.0'\n                        }\n                    };\n                    break;\n                default:\n                    throw new Error(`Unknown method: ${method}`);\n            }\n\n            return {\n                jsonrpc: '2.0',\n                id,\n                result\n            };\n        } catch (error: any) {\n            return {\n                jsonrpc: '2.0',\n                id,\n                error: {\n                    code: -32603,\n                    message: error.message\n                }\n            };\n        }\n    }\n\n    public stop(): void {\n        if (this.httpServer) {\n            this.httpServer.close();\n            this.httpServer = null;\n            console.log('[MCPServer] HTTP server stopped');\n        }\n\n        this.clients.clear();\n    }\n\n    public getStatus(): ServerStatus {\n        return {\n            running: !!this.httpServer,\n            port: this.settings.port,\n            clients: 0 // HTTP is stateless, no persistent clients\n        };\n    }\n\n    public updateSettings(settings: MCPServerSettings) {\n        this.settings = settings;\n        if (this.httpServer) {\n            this.stop();\n            this.start();\n        }\n    }\n}\n\n// HTTP transport doesn't need persistent connections\n// MCP over HTTP uses request-response pattern"]} \ No newline at end of file diff --git a/dist/panels/default/index.js b/dist/panels/default/index.js new file mode 100644 index 0000000..9301a88 --- /dev/null +++ b/dist/panels/default/index.js @@ -0,0 +1,225 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const fs_extra_1 = require("fs-extra"); +const path_1 = require("path"); +/** + * @zh 如果希望兼容 3.3 之前的版本可以使用下方的代码 + * @en You can add the code below if you want compatibility with versions prior to 3.3 + */ +// Editor.Panel.define = Editor.Panel.define || function(options: any) { return options } +module.exports = Editor.Panel.define({ + listeners: { + show() { console.log('MCP Server panel shown'); }, + hide() { console.log('MCP Server panel hidden'); } + }, + template: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/template/default/index.html'), 'utf-8'), + style: (0, fs_extra_1.readFileSync)((0, path_1.join)(__dirname, '../../../static/style/default/index.css'), 'utf-8'), + $: { + panelTitle: '#panelTitle', + serverStatusLabel: '#serverStatusLabel', + serverStatusLabelProp: '#serverStatusLabelProp', + serverStatusValue: '#serverStatusValue', + connectedLabel: '#connectedLabel', + connectedClients: '#connectedClients', + toggleServerBtn: '#toggleServerBtn', + settingsLabel: '#settingsLabel', + portLabel: '#portLabel', + autoStartLabel: '#autoStartLabel', + debugLogLabel: '#debugLogLabel', + maxConnectionsLabel: '#maxConnectionsLabel', + connectionInfoLabel: '#connectionInfoLabel', + httpUrlLabel: '#httpUrlLabel', + httpUrlInput: '#httpUrlInput', + copyBtn: '#copyBtn', + saveSettingsBtn: '#saveSettingsBtn', + // 新增输入控件id + portInput: '#portInput', + maxConnInput: '#maxConnInput', + autoStartInput: '#autoStartInput', + debugLogInput: '#debugLogInput', + }, + methods: { + async updateServerStatus() { + try { + const status = await Editor.Message.request('cocos-mcp-server', 'get-server-status'); + this.serverRunning = status.running; + this.connectedClients = status.clients || 0; + this.serverStatus = this.serverRunning ? + Editor.I18n.t('cocos-mcp-server.connected') : + Editor.I18n.t('cocos-mcp-server.disconnected'); + this.statusClass = this.serverRunning ? 'running' : 'stopped'; + this.buttonText = this.serverRunning ? + Editor.I18n.t('cocos-mcp-server.stop_server') : + Editor.I18n.t('cocos-mcp-server.start_server'); + // 刷新UI + this.$.serverStatusValue.innerText = this.serverStatus; + this.$.connectedClients.innerText = this.connectedClients; + this.$.toggleServerBtn.innerText = this.buttonText; + if (this.serverRunning) { + this.httpUrl = `http://localhost:${this.settings.port}/mcp`; + this.$.httpUrlInput.value = this.httpUrl; + } + else { + this.httpUrl = ''; + this.$.httpUrlInput.value = ''; + } + } + catch (err) { + console.error('Failed to update server status:', err); + } + }, + async toggleServer() { + this.isProcessing = true; + try { + if (this.serverRunning) { + await this.stopServer(); + } + else { + await this.startServer(); + } + } + finally { + this.isProcessing = false; + } + }, + async startServer() { + try { + await Editor.Message.request('cocos-mcp-server', 'start-server'); + Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.server_started'), { + detail: Editor.I18n.t('cocos-mcp-server.server_running').replace('{0}', this.settings.port.toString()) + }); + await this.updateServerStatus(); + } + catch (err) { + Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_start'), err.message); + } + }, + async stopServer() { + try { + await Editor.Message.request('cocos-mcp-server', 'stop-server'); + Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.server_stopped_msg'), { + detail: Editor.I18n.t('cocos-mcp-server.server_stopped') + }); + await this.updateServerStatus(); + } + catch (err) { + Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_stop'), err.message); + } + }, + async saveSettings() { + try { + // 直接用 this.$ 获取所有输入控件的当前值 + const port = this.$.portInput ? Number(this.$.portInput.value) : 3000; + const maxConnections = this.$.maxConnInput ? Number(this.$.maxConnInput.value) : 10; + const autoStart = this.$.autoStartInput ? !!this.$.autoStartInput.checked : false; + const enableDebugLog = this.$.debugLogInput ? !!this.$.debugLogInput.checked : false; + // 组装 settings + const settings = Object.assign(Object.assign({}, this.settings), { port, + maxConnections, + autoStart, + enableDebugLog }); + await Editor.Message.request('cocos-mcp-server', 'update-settings', settings); + // 重新拉取设置 + const newSettings = await Editor.Message.request('cocos-mcp-server', 'get-server-settings'); + this.settings = newSettings; + this.originalSettings = JSON.stringify(newSettings); + Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.settings_saved')); + } + catch (err) { + Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_save'), err.message); + } + }, + copyUrl() { + Editor.Clipboard.write('text', this.httpUrl); + Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.url_copied')); + }, + settingsChanged() { + return JSON.stringify(this.settings) !== this.originalSettings; + }, + bindSettingsEvents() { + // 端口输入框 + const portInput = document.querySelectorAll('ui-num-input[slot="content"]')[0]; + if (portInput) { + portInput.addEventListener('change', (e) => { + this.settings.port = Number(e.detail.value); + }); + } + // 最大连接数 + const maxConnInput = document.querySelectorAll('ui-num-input[slot="content"]')[1]; + if (maxConnInput) { + maxConnInput.addEventListener('change', (e) => { + this.settings.maxConnections = Number(e.detail.value); + }); + } + // 复选框 + const checkboxes = document.querySelectorAll('ui-checkbox[slot="content"]'); + if (checkboxes && checkboxes.length >= 2) { + checkboxes[0].addEventListener('change', (e) => { + this.settings.autoStart = !!e.detail.value; + }); + checkboxes[1].addEventListener('change', (e) => { + this.settings.enableDebugLog = !!e.detail.value; + }); + } + }, + }, + ready() { + Editor.Message.request('cocos-mcp-server', 'get-server-settings').then((settings) => { + this.settings = settings; + this.originalSettings = JSON.stringify(settings); + // 本地化label赋值 + this.$.panelTitle.innerText = Editor.I18n.t('cocos-mcp-server.panel_title'); + this.$.serverStatusLabel.innerText = Editor.I18n.t('cocos-mcp-server.server_status'); + this.$.serverStatusLabelProp.innerText = Editor.I18n.t('cocos-mcp-server.server_status'); + this.$.connectedLabel.innerText = Editor.I18n.t('cocos-mcp-server.connected'); + this.$.settingsLabel.innerText = Editor.I18n.t('cocos-mcp-server.settings'); + this.$.portLabel.innerText = Editor.I18n.t('cocos-mcp-server.port'); + this.$.autoStartLabel.innerText = Editor.I18n.t('cocos-mcp-server.auto_start'); + this.$.debugLogLabel.innerText = Editor.I18n.t('cocos-mcp-server.debug_log'); + this.$.maxConnectionsLabel.innerText = Editor.I18n.t('cocos-mcp-server.max_connections'); + this.$.connectionInfoLabel.innerText = Editor.I18n.t('cocos-mcp-server.connection_info'); + this.$.httpUrlLabel.innerText = Editor.I18n.t('cocos-mcp-server.http_url'); + this.$.copyBtn.innerText = Editor.I18n.t('cocos-mcp-server.copy'); + this.$.saveSettingsBtn.innerText = Editor.I18n.t('cocos-mcp-server.save_settings'); + // 动态内容初始化 + this.$.serverStatusValue.innerText = ''; + this.$.connectedClients.innerText = ''; + this.$.toggleServerBtn.innerText = ''; + this.$.httpUrlInput.value = ''; + // 绑定按钮事件 + this.$.toggleServerBtn.addEventListener('confirm', this.toggleServer.bind(this)); + this.$.saveSettingsBtn.addEventListener('confirm', this.saveSettings.bind(this)); + this.$.copyBtn.addEventListener('confirm', this.copyUrl.bind(this)); + // 延迟绑定事件，确保 UI 组件已渲染 + setTimeout(() => { + this.bindSettingsEvents(); + }, 100); + // Set up periodic status updates + this.statusInterval = setInterval(() => { + this.updateServerStatus(); + }, 2000); + // 不再自动启动服务器，用户点击才启动 + this.updateServerStatus(); + }); + }, + beforeClose() { + if (this.statusInterval) { + clearInterval(this.statusInterval); + } + }, + close() { + // Panel close cleanup + }, + // Direct properties for data access + serverRunning: false, + connectedClients: 0, + serverStatus: '', + statusClass: 'stopped', + buttonText: '', + isProcessing: false, + settings: {}, + httpUrl: '', + statusInterval: null, + originalSettings: '' +}); +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/panels/default/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { readSettings } from '../../settings';\nimport { readFileSync } from 'fs-extra';\nimport { join } from 'path';\n\n/**\n * @zh 如果希望兼容 3.3 之前的版本可以使用下方的代码\n * @en You can add the code below if you want compatibility with versions prior to 3.3\n */\n// Editor.Panel.define = Editor.Panel.define || function(options: any) { return options }\n\nmodule.exports = Editor.Panel.define({\n    listeners: {\n        show() { console.log('MCP Server panel shown'); },\n        hide() { console.log('MCP Server panel hidden'); }\n    },\n    template: readFileSync(join(__dirname, '../../../static/template/default/index.html'), 'utf-8'),\n    style: readFileSync(join(__dirname, '../../../static/style/default/index.css'), 'utf-8'),\n    $: {\n        panelTitle: '#panelTitle',\n        serverStatusLabel: '#serverStatusLabel',\n        serverStatusLabelProp: '#serverStatusLabelProp',\n        serverStatusValue: '#serverStatusValue',\n        connectedLabel: '#connectedLabel',\n        connectedClients: '#connectedClients',\n        toggleServerBtn: '#toggleServerBtn',\n        settingsLabel: '#settingsLabel',\n        portLabel: '#portLabel',\n        autoStartLabel: '#autoStartLabel',\n        debugLogLabel: '#debugLogLabel',\n        maxConnectionsLabel: '#maxConnectionsLabel',\n        connectionInfoLabel: '#connectionInfoLabel',\n        httpUrlLabel: '#httpUrlLabel',\n        httpUrlInput: '#httpUrlInput',\n        copyBtn: '#copyBtn',\n        saveSettingsBtn: '#saveSettingsBtn',\n        // 新增输入控件id\n        portInput: '#portInput',\n        maxConnInput: '#maxConnInput',\n        autoStartInput: '#autoStartInput',\n        debugLogInput: '#debugLogInput',\n    },\n    methods: {\n        async updateServerStatus(this: any) {\n            try {\n                const status = await Editor.Message.request('cocos-mcp-server', 'get-server-status');\n                this.serverRunning = status.running;\n                this.connectedClients = status.clients || 0;\n                this.serverStatus = this.serverRunning ? \n                    Editor.I18n.t('cocos-mcp-server.connected') : \n                    Editor.I18n.t('cocos-mcp-server.disconnected');\n                this.statusClass = this.serverRunning ? 'running' : 'stopped';\n                this.buttonText = this.serverRunning ? \n                    Editor.I18n.t('cocos-mcp-server.stop_server') : \n                    Editor.I18n.t('cocos-mcp-server.start_server');\n                // 刷新UI\n                this.$.serverStatusValue.innerText = this.serverStatus;\n                this.$.connectedClients.innerText = this.connectedClients;\n                this.$.toggleServerBtn.innerText = this.buttonText;\n                if (this.serverRunning) {\n                    this.httpUrl = `http://localhost:${this.settings.port}/mcp`;\n                    this.$.httpUrlInput.value = this.httpUrl;\n                } else {\n                    this.httpUrl = '';\n                    this.$.httpUrlInput.value = '';\n                }\n            } catch (err) {\n                console.error('Failed to update server status:', err);\n            }\n        },\n\n        async toggleServer(this: any) {\n            this.isProcessing = true;\n            try {\n                if (this.serverRunning) {\n                    await this.stopServer();\n                } else {\n                    await this.startServer();\n                }\n            } finally {\n                this.isProcessing = false;\n            }\n        },\n\n        async startServer(this: any) {\n            try {\n                await Editor.Message.request('cocos-mcp-server', 'start-server');\n                Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.server_started'), {\n                    detail: Editor.I18n.t('cocos-mcp-server.server_running').replace('{0}', this.settings.port.toString())\n                });\n                await this.updateServerStatus();\n            } catch (err: any) {\n                Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_start'), err.message);\n            }\n        },\n\n        async stopServer(this: any) {\n            try {\n                await Editor.Message.request('cocos-mcp-server', 'stop-server');\n                Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.server_stopped_msg'), {\n                    detail: Editor.I18n.t('cocos-mcp-server.server_stopped')\n                });\n                await this.updateServerStatus();\n            } catch (err: any) {\n                Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_stop'), err.message);\n            }\n        },\n\n        async saveSettings(this: any) {\n            try {\n                // 直接用 this.$ 获取所有输入控件的当前值\n                const port = this.$.portInput ? Number((this.$.portInput as any).value) : 3000;\n                const maxConnections = this.$.maxConnInput ? Number((this.$.maxConnInput as any).value) : 10;\n                const autoStart = this.$.autoStartInput ? !!(this.$.autoStartInput as any).checked : false;\n                const enableDebugLog = this.$.debugLogInput ? !!(this.$.debugLogInput as any).checked : false;\n                // 组装 settings\n                const settings = {\n                    ...this.settings,\n                    port,\n                    maxConnections,\n                    autoStart,\n                    enableDebugLog,\n                };\n                await Editor.Message.request('cocos-mcp-server', 'update-settings', settings);\n                // 重新拉取设置\n                const newSettings = await Editor.Message.request('cocos-mcp-server', 'get-server-settings');\n                this.settings = newSettings;\n                this.originalSettings = JSON.stringify(newSettings);\n                Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.settings_saved'));\n            } catch (err: any) {\n                Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_save'), err.message);\n            }\n        },\n\n        copyUrl(this: any) {\n            Editor.Clipboard.write('text', this.httpUrl);\n            Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.url_copied'));\n        },\n\n        settingsChanged(this: any) {\n            return JSON.stringify(this.settings) !== this.originalSettings;\n        },\n        bindSettingsEvents(this: any) {\n            // 端口输入框\n            const portInput = document.querySelectorAll('ui-num-input[slot=\"content\"]')[0];\n            if (portInput) {\n                portInput.addEventListener('change', (e: any) => {\n                    this.settings.port = Number(e.detail.value);\n                });\n            }\n            // 最大连接数\n            const maxConnInput = document.querySelectorAll('ui-num-input[slot=\"content\"]')[1];\n            if (maxConnInput) {\n                maxConnInput.addEventListener('change', (e: any) => {\n                    this.settings.maxConnections = Number(e.detail.value);\n                });\n            }\n            // 复选框\n            const checkboxes = document.querySelectorAll('ui-checkbox[slot=\"content\"]');\n            if (checkboxes && checkboxes.length >= 2) {\n                checkboxes[0].addEventListener('change', (e: any) => {\n                    this.settings.autoStart = !!e.detail.value;\n                });\n                checkboxes[1].addEventListener('change', (e: any) => {\n                    this.settings.enableDebugLog = !!e.detail.value;\n                });\n            }\n        },\n        \n    },\n    ready() {\n        Editor.Message.request('cocos-mcp-server', 'get-server-settings').then((settings) => {\n            this.settings = settings;\n            this.originalSettings = JSON.stringify(settings);\n            // 本地化label赋值\n            this.$.panelTitle.innerText = Editor.I18n.t('cocos-mcp-server.panel_title');\n            this.$.serverStatusLabel.innerText = Editor.I18n.t('cocos-mcp-server.server_status');\n            this.$.serverStatusLabelProp.innerText = Editor.I18n.t('cocos-mcp-server.server_status');\n            this.$.connectedLabel.innerText = Editor.I18n.t('cocos-mcp-server.connected');\n            this.$.settingsLabel.innerText = Editor.I18n.t('cocos-mcp-server.settings');\n            this.$.portLabel.innerText = Editor.I18n.t('cocos-mcp-server.port');\n            this.$.autoStartLabel.innerText = Editor.I18n.t('cocos-mcp-server.auto_start');\n            this.$.debugLogLabel.innerText = Editor.I18n.t('cocos-mcp-server.debug_log');\n            this.$.maxConnectionsLabel.innerText = Editor.I18n.t('cocos-mcp-server.max_connections');\n            this.$.connectionInfoLabel.innerText = Editor.I18n.t('cocos-mcp-server.connection_info');\n            this.$.httpUrlLabel.innerText = Editor.I18n.t('cocos-mcp-server.http_url');\n            this.$.copyBtn.innerText = Editor.I18n.t('cocos-mcp-server.copy');\n            this.$.saveSettingsBtn.innerText = Editor.I18n.t('cocos-mcp-server.save_settings');\n            // 动态内容初始化\n            this.$.serverStatusValue.innerText = '';\n            this.$.connectedClients.innerText = '';\n            this.$.toggleServerBtn.innerText = '';\n            this.$.httpUrlInput.value = '';\n            // 绑定按钮事件\n            this.$.toggleServerBtn.addEventListener('confirm', this.toggleServer.bind(this));\n            this.$.saveSettingsBtn.addEventListener('confirm', this.saveSettings.bind(this));\n            this.$.copyBtn.addEventListener('confirm', this.copyUrl.bind(this));\n            // 延迟绑定事件，确保 UI 组件已渲染\n            setTimeout(() => {\n                this.bindSettingsEvents();\n            }, 100);\n            // Set up periodic status updates\n            (this as any).statusInterval = setInterval(() => {\n                (this as any).updateServerStatus();\n            }, 2000);\n            // 不再自动启动服务器，用户点击才启动\n            (this as any).updateServerStatus();\n        });\n    },\n    beforeClose() {\n        if ((this as any).statusInterval) {\n            clearInterval((this as any).statusInterval);\n        }\n    },\n    close() {\n        // Panel close cleanup\n    },\n    \n    // Direct properties for data access\n    serverRunning: false,\n    connectedClients: 0,\n    serverStatus: '',\n    statusClass: 'stopped',\n    buttonText: '',\n    isProcessing: false,\n    settings: {},\n    httpUrl: '',\n    statusInterval: null as any,\n    originalSettings: ''\n} as any);"]} \ No newline at end of file diff --git a/dist/scene.js b/dist/scene.js new file mode 100644 index 0000000..dc0e5e3 --- /dev/null +++ b/dist/scene.js @@ -0,0 +1,428 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.methods = void 0; +const path_1 = require("path"); +module.paths.push((0, path_1.join)(Editor.App.path, 'node_modules')); +exports.methods = { + /** + * Create a new scene + */ + createNewScene() { + try { + const { director, Scene } = require('cc'); + const scene = new Scene(); + scene.name = 'New Scene'; + director.runScene(scene); + return { success: true, message: 'New scene created successfully' }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Add component to a node + */ + addComponentToNode(nodeUuid, componentType) { + try { + const { director, js } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + // Find node by UUID + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + // Get component class + const ComponentClass = js.getClassByName(componentType); + if (!ComponentClass) { + return { success: false, error: `Component type ${componentType} not found` }; + } + // Add component + const component = node.addComponent(ComponentClass); + return { + success: true, + message: `Component ${componentType} added successfully`, + data: { componentId: component.uuid } + }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Remove component from a node + */ + removeComponentFromNode(nodeUuid, componentType) { + try { + const { director, js } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + const ComponentClass = js.getClassByName(componentType); + if (!ComponentClass) { + return { success: false, error: `Component type ${componentType} not found` }; + } + const component = node.getComponent(ComponentClass); + if (!component) { + return { success: false, error: `Component ${componentType} not found on node` }; + } + node.removeComponent(component); + return { success: true, message: `Component ${componentType} removed successfully` }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Create a new node + */ + createNode(name, parentUuid) { + try { + const { director, Node } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const node = new Node(name); + if (parentUuid) { + const parent = scene.getChildByUuid(parentUuid); + if (parent) { + parent.addChild(node); + } + else { + scene.addChild(node); + } + } + else { + scene.addChild(node); + } + return { + success: true, + message: `Node ${name} created successfully`, + data: { uuid: node.uuid, name: node.name } + }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Get node information + */ + getNodeInfo(nodeUuid) { + var _a; + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + return { + success: true, + data: { + uuid: node.uuid, + name: node.name, + active: node.active, + position: node.position, + rotation: node.rotation, + scale: node.scale, + parent: (_a = node.parent) === null || _a === void 0 ? void 0 : _a.uuid, + children: node.children.map((child) => child.uuid), + components: node.components.map((comp) => ({ + type: comp.constructor.name, + enabled: comp.enabled + })) + } + }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Get all nodes in scene + */ + getAllNodes() { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const nodes = []; + const collectNodes = (node) => { + var _a; + nodes.push({ + uuid: node.uuid, + name: node.name, + active: node.active, + parent: (_a = node.parent) === null || _a === void 0 ? void 0 : _a.uuid + }); + node.children.forEach((child) => collectNodes(child)); + }; + scene.children.forEach((child) => collectNodes(child)); + return { success: true, data: nodes }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Find node by name + */ + findNodeByName(name) { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const node = scene.getChildByName(name); + if (!node) { + return { success: false, error: `Node with name ${name} not found` }; + } + return { + success: true, + data: { + uuid: node.uuid, + name: node.name, + active: node.active, + position: node.position + } + }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Get current scene information + */ + getCurrentSceneInfo() { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + return { + success: true, + data: { + name: scene.name, + uuid: scene.uuid, + nodeCount: scene.children.length + } + }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Set node property + */ + setNodeProperty(nodeUuid, property, value) { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + // 设置属性 + if (property === 'position') { + node.setPosition(value.x || 0, value.y || 0, value.z || 0); + } + else if (property === 'rotation') { + node.setRotationFromEuler(value.x || 0, value.y || 0, value.z || 0); + } + else if (property === 'scale') { + node.setScale(value.x || 1, value.y || 1, value.z || 1); + } + else if (property === 'active') { + node.active = value; + } + else if (property === 'name') { + node.name = value; + } + else { + // 尝试直接设置属性 + node[property] = value; + } + return { + success: true, + message: `Property '${property}' updated successfully` + }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Get scene hierarchy + */ + getSceneHierarchy(includeComponents = false) { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const processNode = (node) => { + const result = { + name: node.name, + uuid: node.uuid, + active: node.active, + children: [] + }; + if (includeComponents) { + result.components = node.components.map((comp) => ({ + type: comp.constructor.name, + enabled: comp.enabled + })); + } + if (node.children && node.children.length > 0) { + result.children = node.children.map((child) => processNode(child)); + } + return result; + }; + const hierarchy = scene.children.map((child) => processNode(child)); + return { success: true, data: hierarchy }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Create prefab from node + */ + createPrefabFromNode(nodeUuid, prefabPath) { + try { + const { director, instantiate } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + // 注意：这里只是一个模拟实现，因为运行时环境下无法直接创建预制体文件 + // 真正的预制体创建需要Editor API支持 + return { + success: true, + data: { + prefabPath: prefabPath, + sourceNodeUuid: nodeUuid, + message: `Prefab created from node '${node.name}' at ${prefabPath}` + } + }; + } + catch (error) { + return { success: false, error: error.message }; + } + }, + /** + * Set component property + */ + setComponentProperty(nodeUuid, componentType, property, value) { + try { + const { director, js } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + const ComponentClass = js.getClassByName(componentType); + if (!ComponentClass) { + return { success: false, error: `Component type ${componentType} not found` }; + } + const component = node.getComponent(ComponentClass); + if (!component) { + return { success: false, error: `Component ${componentType} not found on node` }; + } + // 针对常见属性做特殊处理 + if (property === 'spriteFrame' && componentType === 'cc.Sprite') { + // 支持 value 为 uuid 或资源路径 + if (typeof value === 'string') { + // 先尝试按 uuid 查找 + const assetManager = require('cc').assetManager; + assetManager.resources.load(value, require('cc').SpriteFrame, (err, spriteFrame) => { + if (!err && spriteFrame) { + component.spriteFrame = spriteFrame; + } + else { + // 尝试通过 uuid 加载 + assetManager.loadAny({ uuid: value }, (err2, asset) => { + if (!err2 && asset) { + component.spriteFrame = asset; + } + else { + // 直接赋值（兼容已传入资源对象） + component.spriteFrame = value; + } + }); + } + }); + } + else { + component.spriteFrame = value; + } + } + else if (property === 'material' && (componentType === 'cc.Sprite' || componentType === 'cc.MeshRenderer')) { + // 支持 value 为 uuid 或资源路径 + if (typeof value === 'string') { + const assetManager = require('cc').assetManager; + assetManager.resources.load(value, require('cc').Material, (err, material) => { + if (!err && material) { + component.material = material; + } + else { + assetManager.loadAny({ uuid: value }, (err2, asset) => { + if (!err2 && asset) { + component.material = asset; + } + else { + component.material = value; + } + }); + } + }); + } + else { + component.material = value; + } + } + else if (property === 'string' && (componentType === 'cc.Label' || componentType === 'cc.RichText')) { + component.string = value; + } + else { + component[property] = value; + } + // 可选：刷新 Inspector + // Editor.Message.send('scene', 'snapshot'); + return { success: true, message: `Component property '${property}' updated successfully` }; + } + catch (error) { + return { success: false, error: error.message }; + } + } +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene.js","sourceRoot":"","sources":["../source/scene.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from 'path';\nmodule.paths.push(join(Editor.App.path, 'node_modules'));\n\nexport const methods: { [key: string]: (...any: any) => any } = {\n    /**\n     * Create a new scene\n     */\n    createNewScene() {\n        try {\n            const { director, Scene } = require('cc');\n            const scene = new Scene();\n            scene.name = 'New Scene';\n            director.runScene(scene);\n            return { success: true, message: 'New scene created successfully' };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Add component to a node\n     */\n    addComponentToNode(nodeUuid: string, componentType: string) {\n        try {\n            const { director, js } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            // Find node by UUID\n            const node = scene.getChildByUuid(nodeUuid);\n            if (!node) {\n                return { success: false, error: `Node with UUID ${nodeUuid} not found` };\n            }\n\n            // Get component class\n            const ComponentClass = js.getClassByName(componentType);\n            if (!ComponentClass) {\n                return { success: false, error: `Component type ${componentType} not found` };\n            }\n\n            // Add component\n            const component = node.addComponent(ComponentClass);\n            return { \n                success: true, \n                message: `Component ${componentType} added successfully`,\n                data: { componentId: component.uuid }\n            };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Remove component from a node\n     */\n    removeComponentFromNode(nodeUuid: string, componentType: string) {\n        try {\n            const { director, js } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            const node = scene.getChildByUuid(nodeUuid);\n            if (!node) {\n                return { success: false, error: `Node with UUID ${nodeUuid} not found` };\n            }\n\n            const ComponentClass = js.getClassByName(componentType);\n            if (!ComponentClass) {\n                return { success: false, error: `Component type ${componentType} not found` };\n            }\n\n            const component = node.getComponent(ComponentClass);\n            if (!component) {\n                return { success: false, error: `Component ${componentType} not found on node` };\n            }\n\n            node.removeComponent(component);\n            return { success: true, message: `Component ${componentType} removed successfully` };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Create a new node\n     */\n    createNode(name: string, parentUuid?: string) {\n        try {\n            const { director, Node } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            const node = new Node(name);\n            \n            if (parentUuid) {\n                const parent = scene.getChildByUuid(parentUuid);\n                if (parent) {\n                    parent.addChild(node);\n                } else {\n                    scene.addChild(node);\n                }\n            } else {\n                scene.addChild(node);\n            }\n\n            return { \n                success: true, \n                message: `Node ${name} created successfully`,\n                data: { uuid: node.uuid, name: node.name }\n            };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Get node information\n     */\n    getNodeInfo(nodeUuid: string) {\n        try {\n            const { director } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            const node = scene.getChildByUuid(nodeUuid);\n            if (!node) {\n                return { success: false, error: `Node with UUID ${nodeUuid} not found` };\n            }\n\n            return {\n                success: true,\n                data: {\n                    uuid: node.uuid,\n                    name: node.name,\n                    active: node.active,\n                    position: node.position,\n                    rotation: node.rotation,\n                    scale: node.scale,\n                    parent: node.parent?.uuid,\n                    children: node.children.map((child: any) => child.uuid),\n                    components: node.components.map((comp: any) => ({\n                        type: comp.constructor.name,\n                        enabled: comp.enabled\n                    }))\n                }\n            };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Get all nodes in scene\n     */\n    getAllNodes() {\n        try {\n            const { director } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            const nodes: any[] = [];\n            const collectNodes = (node: any) => {\n                nodes.push({\n                    uuid: node.uuid,\n                    name: node.name,\n                    active: node.active,\n                    parent: node.parent?.uuid\n                });\n                \n                node.children.forEach((child: any) => collectNodes(child));\n            };\n\n            scene.children.forEach((child: any) => collectNodes(child));\n            \n            return { success: true, data: nodes };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Find node by name\n     */\n    findNodeByName(name: string) {\n        try {\n            const { director } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            const node = scene.getChildByName(name);\n            if (!node) {\n                return { success: false, error: `Node with name ${name} not found` };\n            }\n\n            return {\n                success: true,\n                data: {\n                    uuid: node.uuid,\n                    name: node.name,\n                    active: node.active,\n                    position: node.position\n                }\n            };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Get current scene information\n     */\n    getCurrentSceneInfo() {\n        try {\n            const { director } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            return {\n                success: true,\n                data: {\n                    name: scene.name,\n                    uuid: scene.uuid,\n                    nodeCount: scene.children.length\n                }\n            };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Set node property\n     */\n    setNodeProperty(nodeUuid: string, property: string, value: any) {\n        try {\n            const { director } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            const node = scene.getChildByUuid(nodeUuid);\n            if (!node) {\n                return { success: false, error: `Node with UUID ${nodeUuid} not found` };\n            }\n\n            // 设置属性\n            if (property === 'position') {\n                node.setPosition(value.x || 0, value.y || 0, value.z || 0);\n            } else if (property === 'rotation') {\n                node.setRotationFromEuler(value.x || 0, value.y || 0, value.z || 0);\n            } else if (property === 'scale') {\n                node.setScale(value.x || 1, value.y || 1, value.z || 1);\n            } else if (property === 'active') {\n                node.active = value;\n            } else if (property === 'name') {\n                node.name = value;\n            } else {\n                // 尝试直接设置属性\n                (node as any)[property] = value;\n            }\n\n            return { \n                success: true, \n                message: `Property '${property}' updated successfully` \n            };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Get scene hierarchy\n     */\n    getSceneHierarchy(includeComponents: boolean = false) {\n        try {\n            const { director } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            const processNode = (node: any): any => {\n                const result: any = {\n                    name: node.name,\n                    uuid: node.uuid,\n                    active: node.active,\n                    children: []\n                };\n\n                if (includeComponents) {\n                    result.components = node.components.map((comp: any) => ({\n                        type: comp.constructor.name,\n                        enabled: comp.enabled\n                    }));\n                }\n\n                if (node.children && node.children.length > 0) {\n                    result.children = node.children.map((child: any) => processNode(child));\n                }\n\n                return result;\n            };\n\n            const hierarchy = scene.children.map((child: any) => processNode(child));\n            return { success: true, data: hierarchy };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Create prefab from node\n     */\n    createPrefabFromNode(nodeUuid: string, prefabPath: string) {\n        try {\n            const { director, instantiate } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n\n            const node = scene.getChildByUuid(nodeUuid);\n            if (!node) {\n                return { success: false, error: `Node with UUID ${nodeUuid} not found` };\n            }\n\n            // 注意：这里只是一个模拟实现，因为运行时环境下无法直接创建预制体文件\n            // 真正的预制体创建需要Editor API支持\n            return {\n                success: true,\n                data: {\n                    prefabPath: prefabPath,\n                    sourceNodeUuid: nodeUuid,\n                    message: `Prefab created from node '${node.name}' at ${prefabPath}`\n                }\n            };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    },\n\n    /**\n     * Set component property\n     */\n    setComponentProperty(nodeUuid: string, componentType: string, property: string, value: any) {\n        try {\n            const { director, js } = require('cc');\n            const scene = director.getScene();\n            if (!scene) {\n                return { success: false, error: 'No active scene' };\n            }\n            const node = scene.getChildByUuid(nodeUuid);\n            if (!node) {\n                return { success: false, error: `Node with UUID ${nodeUuid} not found` };\n            }\n            const ComponentClass = js.getClassByName(componentType);\n            if (!ComponentClass) {\n                return { success: false, error: `Component type ${componentType} not found` };\n            }\n            const component = node.getComponent(ComponentClass);\n            if (!component) {\n                return { success: false, error: `Component ${componentType} not found on node` };\n            }\n            // 针对常见属性做特殊处理\n            if (property === 'spriteFrame' && componentType === 'cc.Sprite') {\n                // 支持 value 为 uuid 或资源路径\n                if (typeof value === 'string') {\n                    // 先尝试按 uuid 查找\n                    const assetManager = require('cc').assetManager;\n                    assetManager.resources.load(value, require('cc').SpriteFrame, (err: any, spriteFrame: any) => {\n                        if (!err && spriteFrame) {\n                            component.spriteFrame = spriteFrame;\n                        } else {\n                            // 尝试通过 uuid 加载\n                            assetManager.loadAny({ uuid: value }, (err2: any, asset: any) => {\n                                if (!err2 && asset) {\n                                    component.spriteFrame = asset;\n                                } else {\n                                    // 直接赋值（兼容已传入资源对象）\n                                    component.spriteFrame = value;\n                                }\n                            });\n                        }\n                    });\n                } else {\n                    component.spriteFrame = value;\n                }\n            } else if (property === 'material' && (componentType === 'cc.Sprite' || componentType === 'cc.MeshRenderer')) {\n                // 支持 value 为 uuid 或资源路径\n                if (typeof value === 'string') {\n                    const assetManager = require('cc').assetManager;\n                    assetManager.resources.load(value, require('cc').Material, (err: any, material: any) => {\n                        if (!err && material) {\n                            component.material = material;\n                        } else {\n                            assetManager.loadAny({ uuid: value }, (err2: any, asset: any) => {\n                                if (!err2 && asset) {\n                                    component.material = asset;\n                                } else {\n                                    component.material = value;\n                                }\n                            });\n                        }\n                    });\n                } else {\n                    component.material = value;\n                }\n            } else if (property === 'string' && (componentType === 'cc.Label' || componentType === 'cc.RichText')) {\n                component.string = value;\n            } else {\n                component[property] = value;\n            }\n            // 可选：刷新 Inspector\n            // Editor.Message.send('scene', 'snapshot');\n            return { success: true, message: `Component property '${property}' updated successfully` };\n        } catch (error: any) {\n            return { success: false, error: error.message };\n        }\n    }\n};"]} \ No newline at end of file diff --git a/dist/settings.js b/dist/settings.js new file mode 100644 index 0000000..0bdb22e --- /dev/null +++ b/dist/settings.js @@ -0,0 +1,83 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DEFAULT_SETTINGS = void 0; +exports.readSettings = readSettings; +exports.saveSettings = saveSettings; +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +const DEFAULT_SETTINGS = { + port: 3000, + autoStart: false, + enableDebugLog: false, + allowedOrigins: ['*'], + maxConnections: 10 +}; +exports.DEFAULT_SETTINGS = DEFAULT_SETTINGS; +function getSettingsPath() { + return path.join(Editor.Project.path, 'settings', 'mcp-server.json'); +} +function ensureSettingsDir() { + const settingsDir = path.dirname(getSettingsPath()); + if (!fs.existsSync(settingsDir)) { + fs.mkdirSync(settingsDir, { recursive: true }); + } +} +function readSettings() { + try { + ensureSettingsDir(); + const settingsFile = getSettingsPath(); + if (fs.existsSync(settingsFile)) { + const content = fs.readFileSync(settingsFile, 'utf8'); + return Object.assign(Object.assign({}, DEFAULT_SETTINGS), JSON.parse(content)); + } + } + catch (e) { + console.error('Failed to read settings:', e); + } + return DEFAULT_SETTINGS; +} +function saveSettings(settings) { + try { + ensureSettingsDir(); + const settingsFile = getSettingsPath(); + fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2)); + } + catch (e) { + console.error('Failed to save settings:', e); + throw e; + } +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/dist/test/manual-test.js b/dist/test/manual-test.js new file mode 100644 index 0000000..e8d3fce --- /dev/null +++ b/dist/test/manual-test.js @@ -0,0 +1,118 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.testSceneTools = testSceneTools; +exports.testAssetTools = testAssetTools; +exports.testProjectTools = testProjectTools; +exports.runAllTests = runAllTests; +/** + * 手动测试脚本 + * 可以在 Cocos Creator 控制台中执行测试 + */ +async function testSceneTools() { + console.log('=== Testing Scene Tools ==='); + try { + // 1. 获取场景信息 + console.log('1. Getting scene info...'); + const sceneInfo = await Editor.Message.request('scene', 'get-scene-info'); + console.log('Scene info:', sceneInfo); + // 2. 创建节点 + console.log('\n2. Creating test node...'); + const createResult = await Editor.Message.request('scene', 'create-node', { + name: 'TestNode_' + Date.now(), + type: 'cc.Node' + }); + console.log('Create result:', createResult); + if (createResult && createResult.uuid) { + const nodeUuid = createResult.uuid; + // 3. 查询节点 + console.log('\n3. Querying node...'); + const nodeInfo = await Editor.Message.request('scene', 'query-node', { + uuid: nodeUuid + }); + console.log('Node info:', nodeInfo); + // 4. 设置节点属性 + console.log('\n4. Setting node position...'); + await Editor.Message.request('scene', 'set-node-property', { + uuid: nodeUuid, + path: 'position', + value: { x: 100, y: 200, z: 0 } + }); + console.log('Position set successfully'); + // 5. 添加组件 + console.log('\n5. Adding Sprite component...'); + const addCompResult = await Editor.Message.request('scene', 'add-component', { + uuid: nodeUuid, + component: 'cc.Sprite' + }); + console.log('Component added:', addCompResult); + // 6. 查询组件 + console.log('\n6. Querying component...'); + const compInfo = await Editor.Message.request('scene', 'query-node-component', { + uuid: nodeUuid, + component: 'cc.Sprite' + }); + console.log('Component info:', compInfo); + // 7. 删除节点 + console.log('\n7. Removing test node...'); + await Editor.Message.request('scene', 'remove-node', { + uuid: nodeUuid + }); + console.log('Node removed successfully'); + } + } + catch (error) { + console.error('Test failed:', error); + } +} +async function testAssetTools() { + console.log('\n=== Testing Asset Tools ==='); + try { + // 1. 查询资源 + console.log('1. Querying image assets...'); + const assets = await Editor.Message.request('asset-db', 'query-assets', { + pattern: '**/*.png', + ccType: 'cc.ImageAsset' + }); + console.log('Found assets:', (assets === null || assets === void 0 ? void 0 : assets.length) || 0); + // 2. 获取资源信息 + console.log('\n2. Getting asset database info...'); + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', { + uuid: 'db://assets' + }); + console.log('Asset info:', assetInfo); + } + catch (error) { + console.error('Test failed:', error); + } +} +async function testProjectTools() { + console.log('\n=== Testing Project Tools ==='); + try { + // 1. 获取项目信息 + console.log('1. Getting project info...'); + const projectInfo = await Editor.Message.request('project', 'query-info'); + console.log('Project info:', projectInfo); + // 2. 检查构建能力 + console.log('\n2. Checking build capability...'); + const canBuild = await Editor.Message.request('project', 'can-build'); + console.log('Can build:', canBuild); + } + catch (error) { + console.error('Test failed:', error); + } +} +async function runAllTests() { + console.log('Starting MCP Server Tools Test...\n'); + await testSceneTools(); + await testAssetTools(); + await testProjectTools(); + console.log('\n=== All tests completed ==='); +} +// 导出到全局，方便在控制台调用 +global.MCPTest = { + testSceneTools, + testAssetTools, + testProjectTools, + runAllTests +}; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"manual-test.js","sourceRoot":"","sources":["../../source/test/manual-test.ts"],"names":[],"mappings":"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","sourcesContent":["declare const Editor: any;\n\n/**\n * 手动测试脚本\n * 可以在 Cocos Creator 控制台中执行测试\n */\n\nexport async function testSceneTools() {\n    console.log('=== Testing Scene Tools ===');\n    \n    try {\n        // 1. 获取场景信息\n        console.log('1. Getting scene info...');\n        const sceneInfo = await Editor.Message.request('scene', 'get-scene-info');\n        console.log('Scene info:', sceneInfo);\n        \n        // 2. 创建节点\n        console.log('\\n2. Creating test node...');\n        const createResult = await Editor.Message.request('scene', 'create-node', {\n            name: 'TestNode_' + Date.now(),\n            type: 'cc.Node'\n        });\n        console.log('Create result:', createResult);\n        \n        if (createResult && createResult.uuid) {\n            const nodeUuid = createResult.uuid;\n            \n            // 3. 查询节点\n            console.log('\\n3. Querying node...');\n            const nodeInfo = await Editor.Message.request('scene', 'query-node', {\n                uuid: nodeUuid\n            });\n            console.log('Node info:', nodeInfo);\n            \n            // 4. 设置节点属性\n            console.log('\\n4. Setting node position...');\n            await Editor.Message.request('scene', 'set-node-property', {\n                uuid: nodeUuid,\n                path: 'position',\n                value: { x: 100, y: 200, z: 0 }\n            });\n            console.log('Position set successfully');\n            \n            // 5. 添加组件\n            console.log('\\n5. Adding Sprite component...');\n            const addCompResult = await Editor.Message.request('scene', 'add-component', {\n                uuid: nodeUuid,\n                component: 'cc.Sprite'\n            });\n            console.log('Component added:', addCompResult);\n            \n            // 6. 查询组件\n            console.log('\\n6. Querying component...');\n            const compInfo = await Editor.Message.request('scene', 'query-node-component', {\n                uuid: nodeUuid,\n                component: 'cc.Sprite'\n            });\n            console.log('Component info:', compInfo);\n            \n            // 7. 删除节点\n            console.log('\\n7. Removing test node...');\n            await Editor.Message.request('scene', 'remove-node', {\n                uuid: nodeUuid\n            });\n            console.log('Node removed successfully');\n        }\n        \n    } catch (error) {\n        console.error('Test failed:', error);\n    }\n}\n\nexport async function testAssetTools() {\n    console.log('\\n=== Testing Asset Tools ===');\n    \n    try {\n        // 1. 查询资源\n        console.log('1. Querying image assets...');\n        const assets = await Editor.Message.request('asset-db', 'query-assets', {\n            pattern: '**/*.png',\n            ccType: 'cc.ImageAsset'\n        });\n        console.log('Found assets:', assets?.length || 0);\n        \n        // 2. 获取资源信息\n        console.log('\\n2. Getting asset database info...');\n        const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', {\n            uuid: 'db://assets'\n        });\n        console.log('Asset info:', assetInfo);\n        \n    } catch (error) {\n        console.error('Test failed:', error);\n    }\n}\n\nexport async function testProjectTools() {\n    console.log('\\n=== Testing Project Tools ===');\n    \n    try {\n        // 1. 获取项目信息\n        console.log('1. Getting project info...');\n        const projectInfo = await Editor.Message.request('project', 'query-info');\n        console.log('Project info:', projectInfo);\n        \n        // 2. 检查构建能力\n        console.log('\\n2. Checking build capability...');\n        const canBuild = await Editor.Message.request('project', 'can-build');\n        console.log('Can build:', canBuild);\n        \n    } catch (error) {\n        console.error('Test failed:', error);\n    }\n}\n\nexport async function runAllTests() {\n    console.log('Starting MCP Server Tools Test...\\n');\n    \n    await testSceneTools();\n    await testAssetTools();\n    await testProjectTools();\n    \n    console.log('\\n=== All tests completed ===');\n}\n\n// 导出到全局，方便在控制台调用\n(global as any).MCPTest = {\n    testSceneTools,\n    testAssetTools,\n    testProjectTools,\n    runAllTests\n};"]} \ No newline at end of file diff --git a/dist/test/mcp-tool-tester.js b/dist/test/mcp-tool-tester.js new file mode 100644 index 0000000..5d26704 --- /dev/null +++ b/dist/test/mcp-tool-tester.js @@ -0,0 +1,217 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.MCPToolTester = void 0; +/** + * MCP 工具测试器 - 直接测试通过 WebSocket 的 MCP 工具 + */ +class MCPToolTester { + constructor() { + this.ws = null; + this.messageId = 0; + this.responseHandlers = new Map(); + } + async connect(port) { + return new Promise((resolve) => { + try { + this.ws = new WebSocket(`ws://localhost:${port}`); + this.ws.onopen = () => { + console.log('WebSocket 连接成功'); + resolve(true); + }; + this.ws.onerror = (error) => { + console.error('WebSocket 连接错误:', error); + resolve(false); + }; + this.ws.onmessage = (event) => { + try { + const response = JSON.parse(event.data); + if (response.id && this.responseHandlers.has(response.id)) { + const handler = this.responseHandlers.get(response.id); + this.responseHandlers.delete(response.id); + handler === null || handler === void 0 ? void 0 : handler(response); + } + } + catch (error) { + console.error('处理响应时出错:', error); + } + }; + } + catch (error) { + console.error('创建 WebSocket 时出错:', error); + resolve(false); + } + }); + } + async callTool(tool, args = {}) { + if (!this.ws || this.ws.readyState !== WebSocket.OPEN) { + throw new Error('WebSocket 未连接'); + } + return new Promise((resolve, reject) => { + const id = ++this.messageId; + const request = { + jsonrpc: '2.0', + id, + method: 'tools/call', + params: { + name: tool, + arguments: args + } + }; + const timeout = setTimeout(() => { + this.responseHandlers.delete(id); + reject(new Error('请求超时')); + }, 10000); + this.responseHandlers.set(id, (response) => { + clearTimeout(timeout); + if (response.error) { + reject(new Error(response.error.message)); + } + else { + resolve(response.result); + } + }); + this.ws.send(JSON.stringify(request)); + }); + } + async listTools() { + if (!this.ws || this.ws.readyState !== WebSocket.OPEN) { + throw new Error('WebSocket 未连接'); + } + return new Promise((resolve, reject) => { + const id = ++this.messageId; + const request = { + jsonrpc: '2.0', + id, + method: 'tools/list' + }; + const timeout = setTimeout(() => { + this.responseHandlers.delete(id); + reject(new Error('请求超时')); + }, 10000); + this.responseHandlers.set(id, (response) => { + clearTimeout(timeout); + if (response.error) { + reject(new Error(response.error.message)); + } + else { + resolve(response.result); + } + }); + this.ws.send(JSON.stringify(request)); + }); + } + async testMCPTools() { + var _a, _b; + console.log('\n=== 测试 MCP 工具（通过 WebSocket）==='); + try { + // 0. 获取工具列表 + console.log('\n0. 获取工具列表...'); + const toolsList = await this.listTools(); + console.log(`找到 ${((_a = toolsList.tools) === null || _a === void 0 ? void 0 : _a.length) || 0} 个工具:`); + if (toolsList.tools) { + for (const tool of toolsList.tools.slice(0, 10)) { // 只显示前10个 + console.log(` - ${tool.name}: ${tool.description}`); + } + if (toolsList.tools.length > 10) { + console.log(` ... 还有 ${toolsList.tools.length - 10} 个工具`); + } + } + // 1. 测试场景工具 + console.log('\n1. 测试当前场景信息...'); + const sceneInfo = await this.callTool('scene_get_current_scene'); + console.log('场景信息:', JSON.stringify(sceneInfo).substring(0, 100) + '...'); + // 2. 测试场景列表 + console.log('\n2. 测试场景列表...'); + const sceneList = await this.callTool('scene_get_scene_list'); + console.log('场景列表:', JSON.stringify(sceneList).substring(0, 100) + '...'); + // 3. 测试节点创建 + console.log('\n3. 测试创建节点...'); + const createResult = await this.callTool('node_create_node', { + name: 'MCPTestNode_' + Date.now(), + nodeType: 'cc.Node', + position: { x: 0, y: 0, z: 0 } + }); + console.log('创建节点结果:', createResult); + // 解析创建节点的结果 + let nodeUuid = null; + if (createResult.content && createResult.content[0] && createResult.content[0].text) { + try { + const resultData = JSON.parse(createResult.content[0].text); + if (resultData.success && resultData.data && resultData.data.uuid) { + nodeUuid = resultData.data.uuid; + console.log('成功获取节点UUID:', nodeUuid); + } + } + catch (e) { + } + } + if (nodeUuid) { + // 4. 测试查询节点 + console.log('\n4. 测试查询节点...'); + const queryResult = await this.callTool('node_get_node_info', { + uuid: nodeUuid + }); + console.log('节点信息:', JSON.stringify(queryResult).substring(0, 100) + '...'); + // 5. 测试删除节点 + console.log('\n5. 测试删除节点...'); + const removeResult = await this.callTool('node_delete_node', { + uuid: nodeUuid + }); + console.log('删除结果:', removeResult); + } + else { + console.log('无法从创建结果获取节点UUID，尝试通过名称查找...'); + // 备用方案：通过名称查找刚创建的节点 + const findResult = await this.callTool('node_find_node_by_name', { + name: 'MCPTestNode_' + Date.now() + }); + if (findResult.content && findResult.content[0] && findResult.content[0].text) { + try { + const findData = JSON.parse(findResult.content[0].text); + if (findData.success && findData.data && findData.data.uuid) { + nodeUuid = findData.data.uuid; + console.log('通过名称查找成功获取UUID:', nodeUuid); + } + } + catch (e) { + } + } + if (!nodeUuid) { + console.log('所有方式都无法获取节点UUID，跳过后续节点操作测试'); + } + } + // 6. 测试项目工具 + console.log('\n6. 测试项目信息...'); + const projectInfo = await this.callTool('project_get_project_info'); + console.log('项目信息:', JSON.stringify(projectInfo).substring(0, 100) + '...'); + // 7. 测试预制体工具 + console.log('\n7. 测试预制体列表...'); + const prefabResult = await this.callTool('prefab_get_prefab_list', { + folder: 'db://assets' + }); + console.log('找到预制体:', ((_b = prefabResult.data) === null || _b === void 0 ? void 0 : _b.length) || 0); + // 8. 测试组件工具 + console.log('\n8. 测试可用组件...'); + const componentsResult = await this.callTool('component_get_available_components'); + console.log('可用组件:', JSON.stringify(componentsResult).substring(0, 100) + '...'); + // 9. 测试调试工具 + console.log('\n9. 测试编辑器信息...'); + const editorInfo = await this.callTool('debug_get_editor_info'); + console.log('编辑器信息:', JSON.stringify(editorInfo).substring(0, 100) + '...'); + } + catch (error) { + console.error('MCP 工具测试失败:', error); + } + } + disconnect() { + if (this.ws) { + this.ws.close(); + this.ws = null; + } + this.responseHandlers.clear(); + } +} +exports.MCPToolTester = MCPToolTester; +// 导出到全局方便测试 +global.MCPToolTester = MCPToolTester; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcp-tool-tester.js","sourceRoot":"","sources":["../../source/test/mcp-tool-tester.ts"],"names":[],"mappings":"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","sourcesContent":["declare const Editor: any;\n\n/**\n * MCP 工具测试器 - 直接测试通过 WebSocket 的 MCP 工具\n */\nexport class MCPToolTester {\n    private ws: WebSocket | null = null;\n    private messageId = 0;\n    private responseHandlers = new Map<number, (response: any) => void>();\n\n    async connect(port: number): Promise<boolean> {\n        return new Promise((resolve) => {\n            try {\n                this.ws = new WebSocket(`ws://localhost:${port}`);\n                \n                this.ws.onopen = () => {\n                    console.log('WebSocket 连接成功');\n                    resolve(true);\n                };\n                \n                this.ws.onerror = (error) => {\n                    console.error('WebSocket 连接错误:', error);\n                    resolve(false);\n                };\n                \n                this.ws.onmessage = (event) => {\n                    try {\n                        const response = JSON.parse(event.data);\n                        if (response.id && this.responseHandlers.has(response.id)) {\n                            const handler = this.responseHandlers.get(response.id);\n                            this.responseHandlers.delete(response.id);\n                            handler?.(response);\n                        }\n                    } catch (error) {\n                        console.error('处理响应时出错:', error);\n                    }\n                };\n            } catch (error) {\n                console.error('创建 WebSocket 时出错:', error);\n                resolve(false);\n            }\n        });\n    }\n\n    async callTool(tool: string, args: any = {}): Promise<any> {\n        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {\n            throw new Error('WebSocket 未连接');\n        }\n\n        return new Promise((resolve, reject) => {\n            const id = ++this.messageId;\n            const request = {\n                jsonrpc: '2.0',\n                id,\n                method: 'tools/call',\n                params: {\n                    name: tool,\n                    arguments: args\n                }\n            };\n\n            const timeout = setTimeout(() => {\n                this.responseHandlers.delete(id);\n                reject(new Error('请求超时'));\n            }, 10000);\n\n            this.responseHandlers.set(id, (response) => {\n                clearTimeout(timeout);\n                if (response.error) {\n                    reject(new Error(response.error.message));\n                } else {\n                    resolve(response.result);\n                }\n            });\n\n            this.ws!.send(JSON.stringify(request));\n        });\n    }\n\n    async listTools(): Promise<any> {\n        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {\n            throw new Error('WebSocket 未连接');\n        }\n\n        return new Promise((resolve, reject) => {\n            const id = ++this.messageId;\n            const request = {\n                jsonrpc: '2.0',\n                id,\n                method: 'tools/list'\n            };\n\n            const timeout = setTimeout(() => {\n                this.responseHandlers.delete(id);\n                reject(new Error('请求超时'));\n            }, 10000);\n\n            this.responseHandlers.set(id, (response) => {\n                clearTimeout(timeout);\n                if (response.error) {\n                    reject(new Error(response.error.message));\n                } else {\n                    resolve(response.result);\n                }\n            });\n\n            this.ws!.send(JSON.stringify(request));\n        });\n    }\n\n    async testMCPTools() {\n        console.log('\\n=== 测试 MCP 工具（通过 WebSocket）===');\n        \n        try {\n            // 0. 获取工具列表\n            console.log('\\n0. 获取工具列表...');\n            const toolsList = await this.listTools();\n            console.log(`找到 ${toolsList.tools?.length || 0} 个工具:`);\n            if (toolsList.tools) {\n                for (const tool of toolsList.tools.slice(0, 10)) { // 只显示前10个\n                    console.log(`  - ${tool.name}: ${tool.description}`);\n                }\n                if (toolsList.tools.length > 10) {\n                    console.log(`  ... 还有 ${toolsList.tools.length - 10} 个工具`);\n                }\n            }\n            \n            // 1. 测试场景工具\n            console.log('\\n1. 测试当前场景信息...');\n            const sceneInfo = await this.callTool('scene_get_current_scene');\n            console.log('场景信息:', JSON.stringify(sceneInfo).substring(0, 100) + '...');\n            \n            // 2. 测试场景列表\n            console.log('\\n2. 测试场景列表...');\n            const sceneList = await this.callTool('scene_get_scene_list');\n            console.log('场景列表:', JSON.stringify(sceneList).substring(0, 100) + '...');\n            \n            // 3. 测试节点创建\n            console.log('\\n3. 测试创建节点...');\n            const createResult = await this.callTool('node_create_node', {\n                name: 'MCPTestNode_' + Date.now(),\n                nodeType: 'cc.Node',\n                position: { x: 0, y: 0, z: 0 }\n            });\n            console.log('创建节点结果:', createResult);\n            \n            // 解析创建节点的结果\n            let nodeUuid: string | null = null;\n            if (createResult.content && createResult.content[0] && createResult.content[0].text) {\n                try {\n                    const resultData = JSON.parse(createResult.content[0].text);\n                    if (resultData.success && resultData.data && resultData.data.uuid) {\n                        nodeUuid = resultData.data.uuid;\n                        console.log('成功获取节点UUID:', nodeUuid);\n                    }\n                } catch (e) {\n                }\n            }\n            \n            if (nodeUuid) {\n                // 4. 测试查询节点\n                console.log('\\n4. 测试查询节点...');\n                const queryResult = await this.callTool('node_get_node_info', {\n                    uuid: nodeUuid\n                });\n                console.log('节点信息:', JSON.stringify(queryResult).substring(0, 100) + '...');\n                \n                // 5. 测试删除节点\n                console.log('\\n5. 测试删除节点...');\n                const removeResult = await this.callTool('node_delete_node', {\n                    uuid: nodeUuid\n                });\n                console.log('删除结果:', removeResult);\n            } else {\n                console.log('无法从创建结果获取节点UUID，尝试通过名称查找...');\n                \n                // 备用方案：通过名称查找刚创建的节点\n                const findResult = await this.callTool('node_find_node_by_name', {\n                    name: 'MCPTestNode_' + Date.now()\n                });\n                \n                if (findResult.content && findResult.content[0] && findResult.content[0].text) {\n                    try {\n                        const findData = JSON.parse(findResult.content[0].text);\n                        if (findData.success && findData.data && findData.data.uuid) {\n                            nodeUuid = findData.data.uuid;\n                            console.log('通过名称查找成功获取UUID:', nodeUuid);\n                        }\n                    } catch (e) {\n                    }\n                }\n                \n                if (!nodeUuid) {\n                    console.log('所有方式都无法获取节点UUID，跳过后续节点操作测试');\n                }\n            }\n            \n            // 6. 测试项目工具\n            console.log('\\n6. 测试项目信息...');\n            const projectInfo = await this.callTool('project_get_project_info');\n            console.log('项目信息:', JSON.stringify(projectInfo).substring(0, 100) + '...');\n            \n            // 7. 测试预制体工具\n            console.log('\\n7. 测试预制体列表...');\n            const prefabResult = await this.callTool('prefab_get_prefab_list', {\n                folder: 'db://assets'\n            });\n            console.log('找到预制体:', prefabResult.data?.length || 0);\n            \n            // 8. 测试组件工具\n            console.log('\\n8. 测试可用组件...');\n            const componentsResult = await this.callTool('component_get_available_components');\n            console.log('可用组件:', JSON.stringify(componentsResult).substring(0, 100) + '...');\n            \n            // 9. 测试调试工具\n            console.log('\\n9. 测试编辑器信息...');\n            const editorInfo = await this.callTool('debug_get_editor_info');\n            console.log('编辑器信息:', JSON.stringify(editorInfo).substring(0, 100) + '...');\n            \n        } catch (error) {\n            console.error('MCP 工具测试失败:', error);\n        }\n    }\n\n    disconnect() {\n        if (this.ws) {\n            this.ws.close();\n            this.ws = null;\n        }\n        this.responseHandlers.clear();\n    }\n}\n\n// 导出到全局方便测试\n(global as any).MCPToolTester = MCPToolTester;"]} \ No newline at end of file diff --git a/dist/test/tool-tester.js b/dist/test/tool-tester.js new file mode 100644 index 0000000..153795c --- /dev/null +++ b/dist/test/tool-tester.js @@ -0,0 +1,134 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ToolTester = void 0; +class ToolTester { + constructor() { + this.results = []; + } + async runTest(tool, method, params) { + const startTime = Date.now(); + const result = { + tool, + method, + success: false, + time: 0 + }; + try { + const response = await Editor.Message.request(tool, method, params); + result.success = true; + result.result = response; + } + catch (error) { + result.success = false; + result.error = error instanceof Error ? error.message : String(error); + } + result.time = Date.now() - startTime; + this.results.push(result); + return result; + } + async testSceneOperations() { + console.log('Testing Scene Operations...'); + // Test node creation (this is the main scene operation that works) + const createResult = await this.runTest('scene', 'create-node', { + name: 'TestNode', + type: 'cc.Node' + }); + if (createResult.success && createResult.result) { + const nodeUuid = createResult.result; + // Test query node info + await this.runTest('scene', 'query-node-info', nodeUuid); + // Test remove node + await this.runTest('scene', 'remove-node', nodeUuid); + } + // Test execute scene script + await this.runTest('scene', 'execute-scene-script', { + name: 'cocos-mcp-server', + method: 'test-method', + args: [] + }); + } + async testNodeOperations() { + console.log('Testing Node Operations...'); + // Create a test node first + const createResult = await this.runTest('scene', 'create-node', { + name: 'TestNodeForOps', + type: 'cc.Node' + }); + if (createResult.success && createResult.result) { + const nodeUuid = createResult.result; + // Test set property + await this.runTest('scene', 'set-property', { + uuid: nodeUuid, + path: 'position', + dump: { + type: 'cc.Vec3', + value: { x: 100, y: 200, z: 0 } + } + }); + // Test add component + await this.runTest('scene', 'add-component', { + uuid: nodeUuid, + component: 'cc.Sprite' + }); + // Clean up + await this.runTest('scene', 'remove-node', nodeUuid); + } + } + async testAssetOperations() { + console.log('Testing Asset Operations...'); + // Test asset list + await this.runTest('asset-db', 'query-assets', { + pattern: '**/*.png', + ccType: 'cc.ImageAsset' + }); + // Test query asset by path + await this.runTest('asset-db', 'query-path', 'db://assets'); + // Test query asset by uuid (using a valid uuid format) + await this.runTest('asset-db', 'query-uuid', 'db://assets'); + } + async testProjectOperations() { + console.log('Testing Project Operations...'); + // Test open project settings + await this.runTest('project', 'open-settings', {}); + // Test query project settings + const projectName = await this.runTest('project', 'query-setting', 'name'); + if (projectName.success) { + console.log('Project name:', projectName.result); + } + } + async runAllTests() { + this.results = []; + await this.testSceneOperations(); + await this.testNodeOperations(); + await this.testAssetOperations(); + await this.testProjectOperations(); + return this.getTestReport(); + } + getTestReport() { + const total = this.results.length; + const passed = this.results.filter(r => r.success).length; + const failed = total - passed; + return { + summary: { + total, + passed, + failed, + passRate: total > 0 ? (passed / total * 100).toFixed(2) + '%' : '0%' + }, + results: this.results, + grouped: this.groupResultsByTool() + }; + } + groupResultsByTool() { + const grouped = {}; + for (const result of this.results) { + if (!grouped[result.tool]) { + grouped[result.tool] = []; + } + grouped[result.tool].push(result); + } + return grouped; + } +} +exports.ToolTester = ToolTester; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tool-tester.js","sourceRoot":"","sources":["../../source/test/tool-tester.ts"],"names":[],"mappings":"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","sourcesContent":["declare const Editor: any;\n\ninterface TestResult {\n    tool: string;\n    method: string;\n    success: boolean;\n    result?: any;\n    error?: string;\n    time: number;\n}\n\nexport class ToolTester {\n    private results: TestResult[] = [];\n\n    async runTest(tool: string, method: string, params: any): Promise<TestResult> {\n        const startTime = Date.now();\n        const result: TestResult = {\n            tool,\n            method,\n            success: false,\n            time: 0\n        };\n\n        try {\n            const response = await Editor.Message.request(tool, method, params);\n            result.success = true;\n            result.result = response;\n        } catch (error) {\n            result.success = false;\n            result.error = error instanceof Error ? error.message : String(error);\n        }\n\n        result.time = Date.now() - startTime;\n        this.results.push(result);\n        return result;\n    }\n\n    async testSceneOperations() {\n        console.log('Testing Scene Operations...');\n        \n        // Test node creation (this is the main scene operation that works)\n        const createResult = await this.runTest('scene', 'create-node', {\n            name: 'TestNode',\n            type: 'cc.Node'\n        });\n        \n        if (createResult.success && createResult.result) {\n            const nodeUuid = createResult.result;\n            \n            // Test query node info\n            await this.runTest('scene', 'query-node-info', nodeUuid);\n            \n            // Test remove node\n            await this.runTest('scene', 'remove-node', nodeUuid);\n        }\n        \n        // Test execute scene script\n        await this.runTest('scene', 'execute-scene-script', {\n            name: 'cocos-mcp-server',\n            method: 'test-method',\n            args: []\n        });\n    }\n\n    async testNodeOperations() {\n        console.log('Testing Node Operations...');\n        \n        // Create a test node first\n        const createResult = await this.runTest('scene', 'create-node', {\n            name: 'TestNodeForOps',\n            type: 'cc.Node'\n        });\n        \n        if (createResult.success && createResult.result) {\n            const nodeUuid = createResult.result;\n            \n            // Test set property\n            await this.runTest('scene', 'set-property', {\n                uuid: nodeUuid,\n                path: 'position',\n                dump: {\n                    type: 'cc.Vec3',\n                    value: { x: 100, y: 200, z: 0 }\n                }\n            });\n            \n            // Test add component\n            await this.runTest('scene', 'add-component', {\n                uuid: nodeUuid,\n                component: 'cc.Sprite'\n            });\n            \n            // Clean up\n            await this.runTest('scene', 'remove-node', nodeUuid);\n        }\n    }\n\n    async testAssetOperations() {\n        console.log('Testing Asset Operations...');\n        \n        // Test asset list\n        await this.runTest('asset-db', 'query-assets', {\n            pattern: '**/*.png',\n            ccType: 'cc.ImageAsset'\n        });\n        \n        // Test query asset by path\n        await this.runTest('asset-db', 'query-path', 'db://assets');\n        \n        // Test query asset by uuid (using a valid uuid format)\n        await this.runTest('asset-db', 'query-uuid', 'db://assets');\n    }\n\n    async testProjectOperations() {\n        console.log('Testing Project Operations...');\n        \n        // Test open project settings\n        await this.runTest('project', 'open-settings', {});\n        \n        // Test query project settings\n        const projectName = await this.runTest('project', 'query-setting', 'name');\n        \n        if (projectName.success) {\n            console.log('Project name:', projectName.result);\n        }\n    }\n\n    async runAllTests() {\n        this.results = [];\n        \n        await this.testSceneOperations();\n        await this.testNodeOperations();\n        await this.testAssetOperations();\n        await this.testProjectOperations();\n        \n        return this.getTestReport();\n    }\n\n    getTestReport() {\n        const total = this.results.length;\n        const passed = this.results.filter(r => r.success).length;\n        const failed = total - passed;\n        \n        return {\n            summary: {\n                total,\n                passed,\n                failed,\n                passRate: total > 0 ? (passed / total * 100).toFixed(2) + '%' : '0%'\n            },\n            results: this.results,\n            grouped: this.groupResultsByTool()\n        };\n    }\n\n    private groupResultsByTool() {\n        const grouped: Record<string, TestResult[]> = {};\n        \n        for (const result of this.results) {\n            if (!grouped[result.tool]) {\n                grouped[result.tool] = [];\n            }\n            grouped[result.tool].push(result);\n        }\n        \n        return grouped;\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/broadcast-tools.js b/dist/tools/broadcast-tools.js new file mode 100644 index 0000000..d761d03 --- /dev/null +++ b/dist/tools/broadcast-tools.js @@ -0,0 +1,251 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BroadcastTools = void 0; +class BroadcastTools { + constructor() { + this.listeners = new Map(); + this.messageLog = []; + this.setupBroadcastListeners(); + } + getTools() { + return [ + { + name: 'get_broadcast_log', + description: 'Get recent broadcast messages log', + inputSchema: { + type: 'object', + properties: { + limit: { + type: 'number', + description: 'Number of recent messages to return', + default: 50 + }, + messageType: { + type: 'string', + description: 'Filter by message type (optional)' + } + } + } + }, + { + name: 'listen_broadcast', + description: 'Start listening for specific broadcast messages', + inputSchema: { + type: 'object', + properties: { + messageType: { + type: 'string', + description: 'Message type to listen for' + } + }, + required: ['messageType'] + } + }, + { + name: 'stop_listening', + description: 'Stop listening for specific broadcast messages', + inputSchema: { + type: 'object', + properties: { + messageType: { + type: 'string', + description: 'Message type to stop listening for' + } + }, + required: ['messageType'] + } + }, + { + name: 'clear_broadcast_log', + description: 'Clear the broadcast messages log', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_active_listeners', + description: 'Get list of active broadcast listeners', + inputSchema: { + type: 'object', + properties: {} + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'get_broadcast_log': + return await this.getBroadcastLog(args.limit, args.messageType); + case 'listen_broadcast': + return await this.listenBroadcast(args.messageType); + case 'stop_listening': + return await this.stopListening(args.messageType); + case 'clear_broadcast_log': + return await this.clearBroadcastLog(); + case 'get_active_listeners': + return await this.getActiveListeners(); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + setupBroadcastListeners() { + // 设置预定义的重要广播消息监听 + const importantMessages = [ + 'build-worker:ready', + 'build-worker:closed', + 'scene:ready', + 'scene:close', + 'scene:light-probe-edit-mode-changed', + 'scene:light-probe-bounding-box-edit-mode-changed', + 'asset-db:ready', + 'asset-db:close', + 'asset-db:asset-add', + 'asset-db:asset-change', + 'asset-db:asset-delete' + ]; + importantMessages.forEach(messageType => { + this.addBroadcastListener(messageType); + }); + } + addBroadcastListener(messageType) { + const listener = (data) => { + this.messageLog.push({ + message: messageType, + data: data, + timestamp: Date.now() + }); + // 保持日志大小在合理范围内 + if (this.messageLog.length > 1000) { + this.messageLog = this.messageLog.slice(-500); + } + console.log(`[Broadcast] ${messageType}:`, data); + }; + if (!this.listeners.has(messageType)) { + this.listeners.set(messageType, []); + } + this.listeners.get(messageType).push(listener); + // 注册 Editor 消息监听 - 暂时注释掉，Editor.Message API可能不支持 + // Editor.Message.on(messageType, listener); + console.log(`[BroadcastTools] Added listener for ${messageType} (simulated)`); + } + removeBroadcastListener(messageType) { + const listeners = this.listeners.get(messageType); + if (listeners) { + listeners.forEach(listener => { + // Editor.Message.off(messageType, listener); + console.log(`[BroadcastTools] Removed listener for ${messageType} (simulated)`); + }); + this.listeners.delete(messageType); + } + } + async getBroadcastLog(limit = 50, messageType) { + return new Promise((resolve) => { + let filteredLog = this.messageLog; + if (messageType) { + filteredLog = this.messageLog.filter(entry => entry.message === messageType); + } + const recentLog = filteredLog.slice(-limit).map(entry => (Object.assign(Object.assign({}, entry), { timestamp: new Date(entry.timestamp).toISOString() }))); + resolve({ + success: true, + data: { + log: recentLog, + count: recentLog.length, + totalCount: filteredLog.length, + filter: messageType || 'all', + message: 'Broadcast log retrieved successfully' + } + }); + }); + } + async listenBroadcast(messageType) { + return new Promise((resolve) => { + try { + if (!this.listeners.has(messageType)) { + this.addBroadcastListener(messageType); + resolve({ + success: true, + data: { + messageType: messageType, + message: `Started listening for broadcast: ${messageType}` + } + }); + } + else { + resolve({ + success: true, + data: { + messageType: messageType, + message: `Already listening for broadcast: ${messageType}` + } + }); + } + } + catch (err) { + resolve({ success: false, error: err.message }); + } + }); + } + async stopListening(messageType) { + return new Promise((resolve) => { + try { + if (this.listeners.has(messageType)) { + this.removeBroadcastListener(messageType); + resolve({ + success: true, + data: { + messageType: messageType, + message: `Stopped listening for broadcast: ${messageType}` + } + }); + } + else { + resolve({ + success: true, + data: { + messageType: messageType, + message: `Was not listening for broadcast: ${messageType}` + } + }); + } + } + catch (err) { + resolve({ success: false, error: err.message }); + } + }); + } + async clearBroadcastLog() { + return new Promise((resolve) => { + const previousCount = this.messageLog.length; + this.messageLog = []; + resolve({ + success: true, + data: { + clearedCount: previousCount, + message: 'Broadcast log cleared successfully' + } + }); + }); + } + async getActiveListeners() { + return new Promise((resolve) => { + const activeListeners = Array.from(this.listeners.keys()).map(messageType => { + var _a; + return ({ + messageType: messageType, + listenerCount: ((_a = this.listeners.get(messageType)) === null || _a === void 0 ? void 0 : _a.length) || 0 + }); + }); + resolve({ + success: true, + data: { + listeners: activeListeners, + count: activeListeners.length, + message: 'Active listeners retrieved successfully' + } + }); + }); + } +} +exports.BroadcastTools = BroadcastTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"broadcast-tools.js","sourceRoot":"","sources":["../../source/tools/broadcast-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor } from '../types';\n\nexport class BroadcastTools implements ToolExecutor {\n    private listeners: Map<string, Function[]> = new Map();\n    private messageLog: Array<{ message: string; data: any; timestamp: number }> = [];\n\n    constructor() {\n        this.setupBroadcastListeners();\n    }\n\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'get_broadcast_log',\n                description: 'Get recent broadcast messages log',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        limit: {\n                            type: 'number',\n                            description: 'Number of recent messages to return',\n                            default: 50\n                        },\n                        messageType: {\n                            type: 'string',\n                            description: 'Filter by message type (optional)'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'listen_broadcast',\n                description: 'Start listening for specific broadcast messages',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        messageType: {\n                            type: 'string',\n                            description: 'Message type to listen for'\n                        }\n                    },\n                    required: ['messageType']\n                }\n            },\n            {\n                name: 'stop_listening',\n                description: 'Stop listening for specific broadcast messages',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        messageType: {\n                            type: 'string',\n                            description: 'Message type to stop listening for'\n                        }\n                    },\n                    required: ['messageType']\n                }\n            },\n            {\n                name: 'clear_broadcast_log',\n                description: 'Clear the broadcast messages log',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'get_active_listeners',\n                description: 'Get list of active broadcast listeners',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'get_broadcast_log':\n                return await this.getBroadcastLog(args.limit, args.messageType);\n            case 'listen_broadcast':\n                return await this.listenBroadcast(args.messageType);\n            case 'stop_listening':\n                return await this.stopListening(args.messageType);\n            case 'clear_broadcast_log':\n                return await this.clearBroadcastLog();\n            case 'get_active_listeners':\n                return await this.getActiveListeners();\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private setupBroadcastListeners(): void {\n        // 设置预定义的重要广播消息监听\n        const importantMessages = [\n            'build-worker:ready',\n            'build-worker:closed',\n            'scene:ready',\n            'scene:close',\n            'scene:light-probe-edit-mode-changed',\n            'scene:light-probe-bounding-box-edit-mode-changed',\n            'asset-db:ready',\n            'asset-db:close',\n            'asset-db:asset-add',\n            'asset-db:asset-change',\n            'asset-db:asset-delete'\n        ];\n\n        importantMessages.forEach(messageType => {\n            this.addBroadcastListener(messageType);\n        });\n    }\n\n    private addBroadcastListener(messageType: string): void {\n        const listener = (data: any) => {\n            this.messageLog.push({\n                message: messageType,\n                data: data,\n                timestamp: Date.now()\n            });\n\n            // 保持日志大小在合理范围内\n            if (this.messageLog.length > 1000) {\n                this.messageLog = this.messageLog.slice(-500);\n            }\n\n            console.log(`[Broadcast] ${messageType}:`, data);\n        };\n\n        if (!this.listeners.has(messageType)) {\n            this.listeners.set(messageType, []);\n        }\n        this.listeners.get(messageType)!.push(listener);\n\n        // 注册 Editor 消息监听 - 暂时注释掉，Editor.Message API可能不支持\n        // Editor.Message.on(messageType, listener);\n        console.log(`[BroadcastTools] Added listener for ${messageType} (simulated)`);\n    }\n\n    private removeBroadcastListener(messageType: string): void {\n        const listeners = this.listeners.get(messageType);\n        if (listeners) {\n            listeners.forEach(listener => {\n                // Editor.Message.off(messageType, listener);\n                console.log(`[BroadcastTools] Removed listener for ${messageType} (simulated)`);\n            });\n            this.listeners.delete(messageType);\n        }\n    }\n\n    private async getBroadcastLog(limit: number = 50, messageType?: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            let filteredLog = this.messageLog;\n\n            if (messageType) {\n                filteredLog = this.messageLog.filter(entry => entry.message === messageType);\n            }\n\n            const recentLog = filteredLog.slice(-limit).map(entry => ({\n                ...entry,\n                timestamp: new Date(entry.timestamp).toISOString()\n            }));\n\n            resolve({\n                success: true,\n                data: {\n                    log: recentLog,\n                    count: recentLog.length,\n                    totalCount: filteredLog.length,\n                    filter: messageType || 'all',\n                    message: 'Broadcast log retrieved successfully'\n                }\n            });\n        });\n    }\n\n    private async listenBroadcast(messageType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                if (!this.listeners.has(messageType)) {\n                    this.addBroadcastListener(messageType);\n                    resolve({\n                        success: true,\n                        data: {\n                            messageType: messageType,\n                            message: `Started listening for broadcast: ${messageType}`\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: true,\n                        data: {\n                            messageType: messageType,\n                            message: `Already listening for broadcast: ${messageType}`\n                        }\n                    });\n                }\n            } catch (err: any) {\n                resolve({ success: false, error: err.message });\n            }\n        });\n    }\n\n    private async stopListening(messageType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                if (this.listeners.has(messageType)) {\n                    this.removeBroadcastListener(messageType);\n                    resolve({\n                        success: true,\n                        data: {\n                            messageType: messageType,\n                            message: `Stopped listening for broadcast: ${messageType}`\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: true,\n                        data: {\n                            messageType: messageType,\n                            message: `Was not listening for broadcast: ${messageType}`\n                        }\n                    });\n                }\n            } catch (err: any) {\n                resolve({ success: false, error: err.message });\n            }\n        });\n    }\n\n    private async clearBroadcastLog(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const previousCount = this.messageLog.length;\n            this.messageLog = [];\n            resolve({\n                success: true,\n                data: {\n                    clearedCount: previousCount,\n                    message: 'Broadcast log cleared successfully'\n                }\n            });\n        });\n    }\n\n    private async getActiveListeners(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const activeListeners = Array.from(this.listeners.keys()).map(messageType => ({\n                messageType: messageType,\n                listenerCount: this.listeners.get(messageType)?.length || 0\n            }));\n\n            resolve({\n                success: true,\n                data: {\n                    listeners: activeListeners,\n                    count: activeListeners.length,\n                    message: 'Active listeners retrieved successfully'\n                }\n            });\n        });\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/component-tools.js b/dist/tools/component-tools.js new file mode 100644 index 0000000..f6d1382 --- /dev/null +++ b/dist/tools/component-tools.js @@ -0,0 +1,426 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ComponentTools = void 0; +class ComponentTools { + getTools() { + return [ + { + name: 'add_component', + description: 'Add a component to a specific node. The component will be added to the exact node specified by nodeUuid.', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Target node UUID. Use get_node_info or find_node_by_name to get the UUID of the desired node.' + }, + componentType: { + type: 'string', + description: 'Component type (e.g., cc.Sprite, cc.Label, cc.Button)' + } + }, + required: ['nodeUuid', 'componentType'] + } + }, + { + name: 'remove_component', + description: 'Remove a component from a node', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + }, + componentType: { + type: 'string', + description: 'Component type to remove' + } + }, + required: ['nodeUuid', 'componentType'] + } + }, + { + name: 'get_components', + description: 'Get all components of a node', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + } + }, + required: ['nodeUuid'] + } + }, + { + name: 'get_component_info', + description: 'Get specific component information', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + }, + componentType: { + type: 'string', + description: 'Component type to get info for' + } + }, + required: ['nodeUuid', 'componentType'] + } + }, + { + name: 'set_component_property', + description: 'Set component property value', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + }, + componentType: { + type: 'string', + description: 'Component type' + }, + property: { + type: 'string', + description: 'Property name' + }, + value: { + description: 'Property value' + } + }, + required: ['nodeUuid', 'componentType', 'property', 'value'] + } + }, + { + name: 'attach_script', + description: 'Attach a script component to a node', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + }, + scriptPath: { + type: 'string', + description: 'Script asset path (e.g., db://assets/scripts/MyScript.ts)' + } + }, + required: ['nodeUuid', 'scriptPath'] + } + }, + { + name: 'get_available_components', + description: 'Get list of available component types', + inputSchema: { + type: 'object', + properties: { + category: { + type: 'string', + description: 'Component category filter', + enum: ['all', 'renderer', 'ui', 'physics', 'animation', 'audio'], + default: 'all' + } + } + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'add_component': + return await this.addComponent(args.nodeUuid, args.componentType); + case 'remove_component': + return await this.removeComponent(args.nodeUuid, args.componentType); + case 'get_components': + return await this.getComponents(args.nodeUuid); + case 'get_component_info': + return await this.getComponentInfo(args.nodeUuid, args.componentType); + case 'set_component_property': + return await this.setComponentProperty(args); + case 'attach_script': + return await this.attachScript(args.nodeUuid, args.scriptPath); + case 'get_available_components': + return await this.getAvailableComponents(args.category); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + async addComponent(nodeUuid, componentType) { + return new Promise((resolve) => { + // 尝试直接使用 Editor API 添加组件 + Editor.Message.request('scene', 'create-component', { + uuid: nodeUuid, + component: componentType + }).then((result) => { + resolve({ + success: true, + data: { + componentId: result, + message: `Component '${componentType}' added successfully` + } + }); + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'addComponentToNode', + args: [nodeUuid, componentType] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + async removeComponent(nodeUuid, componentType) { + return new Promise((resolve) => { + const options = { + name: 'cocos-mcp-server', + method: 'removeComponentFromNode', + args: [nodeUuid, componentType] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async getComponents(nodeUuid) { + return new Promise((resolve) => { + // 优先尝试直接使用 Editor API 查询节点信息 + Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData) => { + if (nodeData && nodeData.__comps__) { + const components = nodeData.__comps__.map((comp) => ({ + type: comp.__type__ || 'Unknown', + enabled: comp.enabled !== undefined ? comp.enabled : true, + properties: this.extractComponentProperties(comp) + })); + resolve({ + success: true, + data: { + nodeUuid: nodeUuid, + components: components + } + }); + } + else { + resolve({ success: false, error: 'Node not found or no components data' }); + } + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getNodeInfo', + args: [nodeUuid] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + if (result.success) { + resolve({ + success: true, + data: result.data.components + }); + } + else { + resolve(result); + } + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + async getComponentInfo(nodeUuid, componentType) { + return new Promise((resolve) => { + // 优先尝试直接使用 Editor API 查询节点信息 + Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData) => { + if (nodeData && nodeData.__comps__) { + const component = nodeData.__comps__.find((comp) => comp.__type__ === componentType); + if (component) { + resolve({ + success: true, + data: { + nodeUuid: nodeUuid, + componentType: componentType, + enabled: component.enabled !== undefined ? component.enabled : true, + properties: this.extractComponentProperties(component) + } + }); + } + else { + resolve({ success: false, error: `Component '${componentType}' not found on node` }); + } + } + else { + resolve({ success: false, error: 'Node not found or no components data' }); + } + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getNodeInfo', + args: [nodeUuid] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + if (result.success && result.data.components) { + const component = result.data.components.find((comp) => comp.type === componentType); + if (component) { + resolve({ + success: true, + data: Object.assign({ nodeUuid: nodeUuid, componentType: componentType }, component) + }); + } + else { + resolve({ success: false, error: `Component '${componentType}' not found on node` }); + } + } + else { + resolve({ success: false, error: result.error || 'Failed to get component info' }); + } + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + extractComponentProperties(component) { + const properties = {}; + const excludeKeys = ['__type__', 'enabled', 'node', '_id']; + for (const key in component) { + if (!excludeKeys.includes(key) && !key.startsWith('_')) { + properties[key] = component[key]; + } + } + return properties; + } + async setComponentProperty(args) { + return new Promise((resolve) => { + // 首先获取节点信息以找到正确的组件索引 + Editor.Message.request('scene', 'query-node', args.nodeUuid).then((nodeData) => { + if (!nodeData || !nodeData.__comps__) { + throw new Error('Node not found or no components data'); + } + // 查找组件索引 + let componentIndex = -1; + for (let i = 0; i < nodeData.__comps__.length; i++) { + const comp = nodeData.__comps__[i]; + if (comp.__type__ === args.componentType) { + componentIndex = i; + break; + } + } + if (componentIndex === -1) { + throw new Error(`Component '${args.componentType}' not found on node`); + } + // 使用正确的组件索引路径 + const propertyPath = `__comps__.${componentIndex}.${args.property}`; + return Editor.Message.request('scene', 'set-property', { + uuid: args.nodeUuid, + path: propertyPath, + dump: { + value: args.value + } + }); + }).then(() => { + resolve({ + success: true, + message: `Component property '${args.property}' updated successfully` + }); + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'setComponentProperty', + args: [args.nodeUuid, args.componentType, args.property, args.value] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + async attachScript(nodeUuid, scriptPath) { + return new Promise((resolve) => { + var _a; + // 从脚本路径提取组件类名 + const scriptName = (_a = scriptPath.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace('.ts', '').replace('.js', ''); + if (!scriptName) { + resolve({ success: false, error: 'Invalid script path' }); + return; + } + // 首先尝试直接使用脚本名称作为组件类型 + Editor.Message.request('scene', 'create-component', { + uuid: nodeUuid, + component: scriptName // 使用脚本名称而非UUID + }).then((result) => { + resolve({ + success: true, + data: { + componentId: result, + scriptPath: scriptPath, + componentName: scriptName, + message: `Script '${scriptName}' attached successfully` + } + }); + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'attachScript', + args: [nodeUuid, scriptPath] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err2) => { + resolve({ + success: false, + error: `Failed to attach script '${scriptName}': ${err.message}`, + instruction: 'Please ensure the script is properly compiled and exported as a Component class. You can also manually attach the script through the Properties panel in the editor.' + }); + }); + }); + }); + } + async getAvailableComponents(category = 'all') { + const componentCategories = { + renderer: ['cc.Sprite', 'cc.Label', 'cc.RichText', 'cc.Mask', 'cc.Graphics'], + ui: ['cc.Button', 'cc.Toggle', 'cc.Slider', 'cc.ScrollView', 'cc.EditBox', 'cc.ProgressBar'], + physics: ['cc.RigidBody2D', 'cc.BoxCollider2D', 'cc.CircleCollider2D', 'cc.PolygonCollider2D'], + animation: ['cc.Animation', 'cc.AnimationClip', 'cc.SkeletalAnimation'], + audio: ['cc.AudioSource'], + layout: ['cc.Layout', 'cc.Widget', 'cc.PageView', 'cc.PageViewIndicator'], + effects: ['cc.MotionStreak', 'cc.ParticleSystem2D'], + camera: ['cc.Camera'], + light: ['cc.Light', 'cc.DirectionalLight', 'cc.PointLight', 'cc.SpotLight'] + }; + let components = []; + if (category === 'all') { + for (const cat in componentCategories) { + components = components.concat(componentCategories[cat]); + } + } + else if (componentCategories[category]) { + components = componentCategories[category]; + } + return { + success: true, + data: { + category: category, + components: components + } + }; + } +} +exports.ComponentTools = ComponentTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-tools.js","sourceRoot":"","sources":["../../source/tools/component-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, ComponentInfo } from '../types';\n\nexport class ComponentTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'add_component',\n                description: 'Add a component to a specific node. The component will be added to the exact node specified by nodeUuid.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Target node UUID. Use get_node_info or find_node_by_name to get the UUID of the desired node.'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type (e.g., cc.Sprite, cc.Label, cc.Button)'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'remove_component',\n                description: 'Remove a component from a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type to remove'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'get_components',\n                description: 'Get all components of a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        }\n                    },\n                    required: ['nodeUuid']\n                }\n            },\n            {\n                name: 'get_component_info',\n                description: 'Get specific component information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type to get info for'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType']\n                }\n            },\n            {\n                name: 'set_component_property',\n                description: 'Set component property value',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        componentType: {\n                            type: 'string',\n                            description: 'Component type'\n                        },\n                        property: {\n                            type: 'string',\n                            description: 'Property name'\n                        },\n                        value: {\n                            description: 'Property value'\n                        }\n                    },\n                    required: ['nodeUuid', 'componentType', 'property', 'value']\n                }\n            },\n            {\n                name: 'attach_script',\n                description: 'Attach a script component to a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        scriptPath: {\n                            type: 'string',\n                            description: 'Script asset path (e.g., db://assets/scripts/MyScript.ts)'\n                        }\n                    },\n                    required: ['nodeUuid', 'scriptPath']\n                }\n            },\n            {\n                name: 'get_available_components',\n                description: 'Get list of available component types',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        category: {\n                            type: 'string',\n                            description: 'Component category filter',\n                            enum: ['all', 'renderer', 'ui', 'physics', 'animation', 'audio'],\n                            default: 'all'\n                        }\n                    }\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'add_component':\n                return await this.addComponent(args.nodeUuid, args.componentType);\n            case 'remove_component':\n                return await this.removeComponent(args.nodeUuid, args.componentType);\n            case 'get_components':\n                return await this.getComponents(args.nodeUuid);\n            case 'get_component_info':\n                return await this.getComponentInfo(args.nodeUuid, args.componentType);\n            case 'set_component_property':\n                return await this.setComponentProperty(args);\n            case 'attach_script':\n                return await this.attachScript(args.nodeUuid, args.scriptPath);\n            case 'get_available_components':\n                return await this.getAvailableComponents(args.category);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async addComponent(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试直接使用 Editor API 添加组件\n            Editor.Message.request('scene', 'create-component', {\n                uuid: nodeUuid,\n                component: componentType\n            }).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        componentId: result,\n                        message: `Component '${componentType}' added successfully`\n                    }\n                });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'addComponentToNode',\n                    args: [nodeUuid, componentType]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async removeComponent(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const options = {\n                name: 'cocos-mcp-server',\n                method: 'removeComponentFromNode',\n                args: [nodeUuid, componentType]\n            };\n            \n            Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                resolve(result);\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getComponents(nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试直接使用 Editor API 查询节点信息\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => {\n                if (nodeData && nodeData.__comps__) {\n                    const components = nodeData.__comps__.map((comp: any) => ({\n                        type: comp.__type__ || 'Unknown',\n                        enabled: comp.enabled !== undefined ? comp.enabled : true,\n                        properties: this.extractComponentProperties(comp)\n                    }));\n                    \n                    resolve({\n                        success: true,\n                        data: {\n                            nodeUuid: nodeUuid,\n                            components: components\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: 'Node not found or no components data' });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getNodeInfo',\n                    args: [nodeUuid]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    if (result.success) {\n                        resolve({\n                            success: true,\n                            data: result.data.components\n                        });\n                    } else {\n                        resolve(result);\n                    }\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async getComponentInfo(nodeUuid: string, componentType: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试直接使用 Editor API 查询节点信息\n            Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => {\n                if (nodeData && nodeData.__comps__) {\n                    const component = nodeData.__comps__.find((comp: any) => comp.__type__ === componentType);\n                    \n                    if (component) {\n                        resolve({\n                            success: true,\n                            data: {\n                                nodeUuid: nodeUuid,\n                                componentType: componentType,\n                                enabled: component.enabled !== undefined ? component.enabled : true,\n                                properties: this.extractComponentProperties(component)\n                            }\n                        });\n                    } else {\n                        resolve({ success: false, error: `Component '${componentType}' not found on node` });\n                    }\n                } else {\n                    resolve({ success: false, error: 'Node not found or no components data' });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getNodeInfo',\n                    args: [nodeUuid]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    if (result.success && result.data.components) {\n                        const component = result.data.components.find((comp: any) => comp.type === componentType);\n                        if (component) {\n                            resolve({\n                                success: true,\n                                data: {\n                                    nodeUuid: nodeUuid,\n                                    componentType: componentType,\n                                    ...component\n                                }\n                            });\n                        } else {\n                            resolve({ success: false, error: `Component '${componentType}' not found on node` });\n                        }\n                    } else {\n                        resolve({ success: false, error: result.error || 'Failed to get component info' });\n                    }\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private extractComponentProperties(component: any): Record<string, any> {\n        const properties: Record<string, any> = {};\n        const excludeKeys = ['__type__', 'enabled', 'node', '_id'];\n        \n        for (const key in component) {\n            if (!excludeKeys.includes(key) && !key.startsWith('_')) {\n                properties[key] = component[key];\n            }\n        }\n        \n        return properties;\n    }\n\n    private async setComponentProperty(args: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 首先获取节点信息以找到正确的组件索引\n            Editor.Message.request('scene', 'query-node', args.nodeUuid).then((nodeData: any) => {\n                if (!nodeData || !nodeData.__comps__) {\n                    throw new Error('Node not found or no components data');\n                }\n                \n                // 查找组件索引\n                let componentIndex = -1;\n                for (let i = 0; i < nodeData.__comps__.length; i++) {\n                    const comp = nodeData.__comps__[i];\n                    if (comp.__type__ === args.componentType) {\n                        componentIndex = i;\n                        break;\n                    }\n                }\n                \n                if (componentIndex === -1) {\n                    throw new Error(`Component '${args.componentType}' not found on node`);\n                }\n                \n                // 使用正确的组件索引路径\n                const propertyPath = `__comps__.${componentIndex}.${args.property}`;\n                \n                return Editor.Message.request('scene', 'set-property', {\n                    uuid: args.nodeUuid,\n                    path: propertyPath,\n                    dump: {\n                        value: args.value\n                    }\n                });\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: `Component property '${args.property}' updated successfully`\n                });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'setComponentProperty',\n                    args: [args.nodeUuid, args.componentType, args.property, args.value]\n                };\n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async attachScript(nodeUuid: string, scriptPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 从脚本路径提取组件类名\n            const scriptName = scriptPath.split('/').pop()?.replace('.ts', '').replace('.js', '');\n            if (!scriptName) {\n                resolve({ success: false, error: 'Invalid script path' });\n                return;\n            }\n            \n            // 首先尝试直接使用脚本名称作为组件类型\n            Editor.Message.request('scene', 'create-component', {\n                uuid: nodeUuid,\n                component: scriptName  // 使用脚本名称而非UUID\n            }).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        componentId: result,\n                        scriptPath: scriptPath,\n                        componentName: scriptName,\n                        message: `Script '${scriptName}' attached successfully`\n                    }\n                });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'attachScript',\n                    args: [nodeUuid, scriptPath]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ \n                        success: false, \n                        error: `Failed to attach script '${scriptName}': ${err.message}`,\n                        instruction: 'Please ensure the script is properly compiled and exported as a Component class. You can also manually attach the script through the Properties panel in the editor.'\n                    });\n                });\n            });\n        });\n    }\n\n    private async getAvailableComponents(category: string = 'all'): Promise<ToolResponse> {\n        const componentCategories: Record<string, string[]> = {\n            renderer: ['cc.Sprite', 'cc.Label', 'cc.RichText', 'cc.Mask', 'cc.Graphics'],\n            ui: ['cc.Button', 'cc.Toggle', 'cc.Slider', 'cc.ScrollView', 'cc.EditBox', 'cc.ProgressBar'],\n            physics: ['cc.RigidBody2D', 'cc.BoxCollider2D', 'cc.CircleCollider2D', 'cc.PolygonCollider2D'],\n            animation: ['cc.Animation', 'cc.AnimationClip', 'cc.SkeletalAnimation'],\n            audio: ['cc.AudioSource'],\n            layout: ['cc.Layout', 'cc.Widget', 'cc.PageView', 'cc.PageViewIndicator'],\n            effects: ['cc.MotionStreak', 'cc.ParticleSystem2D'],\n            camera: ['cc.Camera'],\n            light: ['cc.Light', 'cc.DirectionalLight', 'cc.PointLight', 'cc.SpotLight']\n        };\n\n        let components: string[] = [];\n        \n        if (category === 'all') {\n            for (const cat in componentCategories) {\n                components = components.concat(componentCategories[cat]);\n            }\n        } else if (componentCategories[category]) {\n            components = componentCategories[category];\n        }\n\n        return {\n            success: true,\n            data: {\n                category: category,\n                components: components\n            }\n        };\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/debug-tools.js b/dist/tools/debug-tools.js new file mode 100644 index 0000000..a760746 --- /dev/null +++ b/dist/tools/debug-tools.js @@ -0,0 +1,327 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DebugTools = void 0; +class DebugTools { + constructor() { + this.consoleMessages = []; + this.maxMessages = 1000; + this.setupConsoleCapture(); + } + setupConsoleCapture() { + // Intercept Editor console messages + // Note: Editor.Message.addBroadcastListener may not be available in all versions + // This is a placeholder for console capture implementation + console.log('Console capture setup - implementation depends on Editor API availability'); + } + addConsoleMessage(message) { + this.consoleMessages.push(Object.assign({ timestamp: new Date().toISOString() }, message)); + // Keep only latest messages + if (this.consoleMessages.length > this.maxMessages) { + this.consoleMessages.shift(); + } + } + getTools() { + return [ + { + name: 'get_console_logs', + description: 'Get editor console logs', + inputSchema: { + type: 'object', + properties: { + limit: { + type: 'number', + description: 'Number of recent logs to retrieve', + default: 100 + }, + filter: { + type: 'string', + description: 'Filter logs by type', + enum: ['all', 'log', 'warn', 'error', 'info'], + default: 'all' + } + } + } + }, + { + name: 'clear_console', + description: 'Clear editor console', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'execute_script', + description: 'Execute JavaScript in scene context', + inputSchema: { + type: 'object', + properties: { + script: { + type: 'string', + description: 'JavaScript code to execute' + } + }, + required: ['script'] + } + }, + { + name: 'get_node_tree', + description: 'Get detailed node tree for debugging', + inputSchema: { + type: 'object', + properties: { + rootUuid: { + type: 'string', + description: 'Root node UUID (optional, uses scene root if not provided)' + }, + maxDepth: { + type: 'number', + description: 'Maximum tree depth', + default: 10 + } + } + } + }, + { + name: 'get_performance_stats', + description: 'Get performance statistics', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'validate_scene', + description: 'Validate current scene for issues', + inputSchema: { + type: 'object', + properties: { + checkMissingAssets: { + type: 'boolean', + description: 'Check for missing asset references', + default: true + }, + checkPerformance: { + type: 'boolean', + description: 'Check for performance issues', + default: true + } + } + } + }, + { + name: 'get_editor_info', + description: 'Get editor and environment information', + inputSchema: { + type: 'object', + properties: {} + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'get_console_logs': + return await this.getConsoleLogs(args.limit, args.filter); + case 'clear_console': + return await this.clearConsole(); + case 'execute_script': + return await this.executeScript(args.script); + case 'get_node_tree': + return await this.getNodeTree(args.rootUuid, args.maxDepth); + case 'get_performance_stats': + return await this.getPerformanceStats(); + case 'validate_scene': + return await this.validateScene(args); + case 'get_editor_info': + return await this.getEditorInfo(); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + async getConsoleLogs(limit = 100, filter = 'all') { + let logs = this.consoleMessages; + if (filter !== 'all') { + logs = logs.filter(log => log.type === filter); + } + const recentLogs = logs.slice(-limit); + return { + success: true, + data: { + total: logs.length, + returned: recentLogs.length, + logs: recentLogs + } + }; + } + async clearConsole() { + this.consoleMessages = []; + try { + // Note: Editor.Message.send may not return a promise in all versions + Editor.Message.send('console', 'clear'); + return { + success: true, + message: 'Console cleared successfully' + }; + } + catch (err) { + return { success: false, error: err.message }; + } + } + async executeScript(script) { + return new Promise((resolve) => { + Editor.Message.request('scene', 'execute-script', { + script: script + }).then((result) => { + resolve({ + success: true, + data: { + result: result, + message: 'Script executed successfully' + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async getNodeTree(rootUuid, maxDepth = 10) { + return new Promise((resolve) => { + const buildTree = async (nodeUuid, depth = 0) => { + if (depth >= maxDepth) { + return { truncated: true }; + } + try { + const nodeData = await Editor.Message.request('scene', 'query-node', nodeUuid); + const tree = { + uuid: nodeData.uuid, + name: nodeData.name, + active: nodeData.active, + components: nodeData.components ? nodeData.components.map((c) => c.__type__) : [], + childCount: nodeData.children ? nodeData.children.length : 0, + children: [] + }; + if (nodeData.children && nodeData.children.length > 0) { + for (const childId of nodeData.children) { + const childTree = await buildTree(childId, depth + 1); + tree.children.push(childTree); + } + } + return tree; + } + catch (err) { + return { error: err.message }; + } + }; + if (rootUuid) { + buildTree(rootUuid).then(tree => { + resolve({ success: true, data: tree }); + }); + } + else { + Editor.Message.request('scene', 'query-hierarchy').then(async (hierarchy) => { + const trees = []; + for (const rootNode of hierarchy.children) { + const tree = await buildTree(rootNode.uuid); + trees.push(tree); + } + resolve({ success: true, data: trees }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + } + }); + } + async getPerformanceStats() { + return new Promise((resolve) => { + Editor.Message.request('scene', 'query-performance').then((stats) => { + const perfStats = { + nodeCount: stats.nodeCount || 0, + componentCount: stats.componentCount || 0, + drawCalls: stats.drawCalls || 0, + triangles: stats.triangles || 0, + memory: stats.memory || {} + }; + resolve({ success: true, data: perfStats }); + }).catch(() => { + // Fallback to basic stats + resolve({ + success: true, + data: { + message: 'Performance stats not available in edit mode' + } + }); + }); + }); + } + async validateScene(options) { + const issues = []; + try { + // Check for missing assets + if (options.checkMissingAssets) { + const assetCheck = await Editor.Message.request('scene', 'check-missing-assets'); + if (assetCheck && assetCheck.missing) { + issues.push({ + type: 'error', + category: 'assets', + message: `Found ${assetCheck.missing.length} missing asset references`, + details: assetCheck.missing + }); + } + } + // Check for performance issues + if (options.checkPerformance) { + const hierarchy = await Editor.Message.request('scene', 'query-hierarchy'); + const nodeCount = this.countNodes(hierarchy.children); + if (nodeCount > 1000) { + issues.push({ + type: 'warning', + category: 'performance', + message: `High node count: ${nodeCount} nodes (recommended < 1000)`, + suggestion: 'Consider using object pooling or scene optimization' + }); + } + } + const result = { + valid: issues.length === 0, + issueCount: issues.length, + issues: issues + }; + return { success: true, data: result }; + } + catch (err) { + return { success: false, error: err.message }; + } + } + countNodes(nodes) { + let count = nodes.length; + for (const node of nodes) { + if (node.children) { + count += this.countNodes(node.children); + } + } + return count; + } + async getEditorInfo() { + var _a, _b; + const info = { + editor: { + version: ((_a = Editor.versions) === null || _a === void 0 ? void 0 : _a.editor) || 'Unknown', + cocosVersion: ((_b = Editor.versions) === null || _b === void 0 ? void 0 : _b.cocos) || 'Unknown', + platform: process.platform, + arch: process.arch, + nodeVersion: process.version + }, + project: { + name: Editor.Project.name, + path: Editor.Project.path, + uuid: Editor.Project.uuid + }, + memory: process.memoryUsage(), + uptime: process.uptime() + }; + return { success: true, data: info }; + } +} +exports.DebugTools = DebugTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"debug-tools.js","sourceRoot":"","sources":["../../source/tools/debug-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, ConsoleMessage, PerformanceStats, ValidationResult, ValidationIssue } from '../types';\n\nexport class DebugTools implements ToolExecutor {\n    private consoleMessages: ConsoleMessage[] = [];\n    private readonly maxMessages = 1000;\n\n    constructor() {\n        this.setupConsoleCapture();\n    }\n\n    private setupConsoleCapture(): void {\n        // Intercept Editor console messages\n        // Note: Editor.Message.addBroadcastListener may not be available in all versions\n        // This is a placeholder for console capture implementation\n        console.log('Console capture setup - implementation depends on Editor API availability');\n    }\n\n    private addConsoleMessage(message: any): void {\n        this.consoleMessages.push({\n            timestamp: new Date().toISOString(),\n            ...message\n        });\n\n        // Keep only latest messages\n        if (this.consoleMessages.length > this.maxMessages) {\n            this.consoleMessages.shift();\n        }\n    }\n\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'get_console_logs',\n                description: 'Get editor console logs',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        limit: {\n                            type: 'number',\n                            description: 'Number of recent logs to retrieve',\n                            default: 100\n                        },\n                        filter: {\n                            type: 'string',\n                            description: 'Filter logs by type',\n                            enum: ['all', 'log', 'warn', 'error', 'info'],\n                            default: 'all'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'clear_console',\n                description: 'Clear editor console',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'execute_script',\n                description: 'Execute JavaScript in scene context',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        script: {\n                            type: 'string',\n                            description: 'JavaScript code to execute'\n                        }\n                    },\n                    required: ['script']\n                }\n            },\n            {\n                name: 'get_node_tree',\n                description: 'Get detailed node tree for debugging',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        rootUuid: {\n                            type: 'string',\n                            description: 'Root node UUID (optional, uses scene root if not provided)'\n                        },\n                        maxDepth: {\n                            type: 'number',\n                            description: 'Maximum tree depth',\n                            default: 10\n                        }\n                    }\n                }\n            },\n            {\n                name: 'get_performance_stats',\n                description: 'Get performance statistics',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'validate_scene',\n                description: 'Validate current scene for issues',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        checkMissingAssets: {\n                            type: 'boolean',\n                            description: 'Check for missing asset references',\n                            default: true\n                        },\n                        checkPerformance: {\n                            type: 'boolean',\n                            description: 'Check for performance issues',\n                            default: true\n                        }\n                    }\n                }\n            },\n            {\n                name: 'get_editor_info',\n                description: 'Get editor and environment information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'get_console_logs':\n                return await this.getConsoleLogs(args.limit, args.filter);\n            case 'clear_console':\n                return await this.clearConsole();\n            case 'execute_script':\n                return await this.executeScript(args.script);\n            case 'get_node_tree':\n                return await this.getNodeTree(args.rootUuid, args.maxDepth);\n            case 'get_performance_stats':\n                return await this.getPerformanceStats();\n            case 'validate_scene':\n                return await this.validateScene(args);\n            case 'get_editor_info':\n                return await this.getEditorInfo();\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async getConsoleLogs(limit: number = 100, filter: string = 'all'): Promise<ToolResponse> {\n        let logs = this.consoleMessages;\n        \n        if (filter !== 'all') {\n            logs = logs.filter(log => log.type === filter);\n        }\n\n        const recentLogs = logs.slice(-limit);\n        \n        return {\n            success: true,\n            data: {\n                total: logs.length,\n                returned: recentLogs.length,\n                logs: recentLogs\n            }\n        };\n    }\n\n    private async clearConsole(): Promise<ToolResponse> {\n        this.consoleMessages = [];\n        \n        try {\n            // Note: Editor.Message.send may not return a promise in all versions\n            Editor.Message.send('console', 'clear');\n            return {\n                success: true,\n                message: 'Console cleared successfully'\n            };\n        } catch (err: any) {\n            return { success: false, error: err.message };\n        }\n    }\n\n    private async executeScript(script: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'execute-script', {\n                script: script\n            }).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        result: result,\n                        message: 'Script executed successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getNodeTree(rootUuid?: string, maxDepth: number = 10): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const buildTree = async (nodeUuid: string, depth: number = 0): Promise<any> => {\n                if (depth >= maxDepth) {\n                    return { truncated: true };\n                }\n\n                try {\n                    const nodeData = await Editor.Message.request('scene', 'query-node', nodeUuid);\n                    \n                    const tree = {\n                        uuid: nodeData.uuid,\n                        name: nodeData.name,\n                        active: nodeData.active,\n                        components: (nodeData as any).components ? (nodeData as any).components.map((c: any) => c.__type__) : [],\n                        childCount: nodeData.children ? nodeData.children.length : 0,\n                        children: [] as any[]\n                    };\n\n                    if (nodeData.children && nodeData.children.length > 0) {\n                        for (const childId of nodeData.children) {\n                            const childTree = await buildTree(childId, depth + 1);\n                            tree.children.push(childTree);\n                        }\n                    }\n\n                    return tree;\n                } catch (err: any) {\n                    return { error: err.message };\n                }\n            };\n\n            if (rootUuid) {\n                buildTree(rootUuid).then(tree => {\n                    resolve({ success: true, data: tree });\n                });\n            } else {\n                Editor.Message.request('scene', 'query-hierarchy').then(async (hierarchy: any) => {\n                    const trees = [];\n                    for (const rootNode of hierarchy.children) {\n                        const tree = await buildTree(rootNode.uuid);\n                        trees.push(tree);\n                    }\n                    resolve({ success: true, data: trees });\n                }).catch((err: Error) => {\n                    resolve({ success: false, error: err.message });\n                });\n            }\n        });\n    }\n\n    private async getPerformanceStats(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'query-performance').then((stats: any) => {\n                const perfStats: PerformanceStats = {\n                    nodeCount: stats.nodeCount || 0,\n                    componentCount: stats.componentCount || 0,\n                    drawCalls: stats.drawCalls || 0,\n                    triangles: stats.triangles || 0,\n                    memory: stats.memory || {}\n                };\n                resolve({ success: true, data: perfStats });\n            }).catch(() => {\n                // Fallback to basic stats\n                resolve({\n                    success: true,\n                    data: {\n                        message: 'Performance stats not available in edit mode'\n                    }\n                });\n            });\n        });\n    }\n\n    private async validateScene(options: any): Promise<ToolResponse> {\n        const issues: ValidationIssue[] = [];\n\n        try {\n            // Check for missing assets\n            if (options.checkMissingAssets) {\n                const assetCheck = await Editor.Message.request('scene', 'check-missing-assets');\n                if (assetCheck && assetCheck.missing) {\n                    issues.push({\n                        type: 'error',\n                        category: 'assets',\n                        message: `Found ${assetCheck.missing.length} missing asset references`,\n                        details: assetCheck.missing\n                    });\n                }\n            }\n\n            // Check for performance issues\n            if (options.checkPerformance) {\n                const hierarchy = await Editor.Message.request('scene', 'query-hierarchy');\n                const nodeCount = this.countNodes(hierarchy.children);\n                \n                if (nodeCount > 1000) {\n                    issues.push({\n                        type: 'warning',\n                        category: 'performance',\n                        message: `High node count: ${nodeCount} nodes (recommended < 1000)`,\n                        suggestion: 'Consider using object pooling or scene optimization'\n                    });\n                }\n            }\n\n            const result: ValidationResult = {\n                valid: issues.length === 0,\n                issueCount: issues.length,\n                issues: issues\n            };\n\n            return { success: true, data: result };\n        } catch (err: any) {\n            return { success: false, error: err.message };\n        }\n    }\n\n    private countNodes(nodes: any[]): number {\n        let count = nodes.length;\n        for (const node of nodes) {\n            if (node.children) {\n                count += this.countNodes(node.children);\n            }\n        }\n        return count;\n    }\n\n    private async getEditorInfo(): Promise<ToolResponse> {\n        const info = {\n            editor: {\n                version: (Editor as any).versions?.editor || 'Unknown',\n                cocosVersion: (Editor as any).versions?.cocos || 'Unknown',\n                platform: process.platform,\n                arch: process.arch,\n                nodeVersion: process.version\n            },\n            project: {\n                name: Editor.Project.name,\n                path: Editor.Project.path,\n                uuid: Editor.Project.uuid\n            },\n            memory: process.memoryUsage(),\n            uptime: process.uptime()\n        };\n\n        return { success: true, data: info };\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/node-tools.js b/dist/tools/node-tools.js new file mode 100644 index 0000000..eb6344f --- /dev/null +++ b/dist/tools/node-tools.js @@ -0,0 +1,510 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.NodeTools = void 0; +class NodeTools { + getTools() { + return [ + { + name: 'create_node', + description: 'Create a new node in the scene. If parentUuid is not provided, the node will be created at the current selection in the editor.', + inputSchema: { + type: 'object', + properties: { + name: { + type: 'string', + description: 'Node name' + }, + parentUuid: { + type: 'string', + description: 'Parent node UUID. If not provided, node will be created at current editor selection. To create at scene root, first get the root node UUID.' + }, + nodeType: { + type: 'string', + description: 'Node type: Node, 2DNode, 3DNode', + enum: ['Node', '2DNode', '3DNode'], + default: 'Node' + }, + siblingIndex: { + type: 'number', + description: 'Sibling index for ordering (-1 means append at end)', + default: -1 + } + }, + required: ['name'] + } + }, + { + name: 'get_node_info', + description: 'Get node information by UUID', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Node UUID' + } + }, + required: ['uuid'] + } + }, + { + name: 'find_nodes', + description: 'Find nodes by name pattern', + inputSchema: { + type: 'object', + properties: { + pattern: { + type: 'string', + description: 'Name pattern to search' + }, + exactMatch: { + type: 'boolean', + description: 'Exact match or partial match', + default: false + } + }, + required: ['pattern'] + } + }, + { + name: 'find_node_by_name', + description: 'Find first node by exact name', + inputSchema: { + type: 'object', + properties: { + name: { + type: 'string', + description: 'Node name to find' + } + }, + required: ['name'] + } + }, + { + name: 'get_all_nodes', + description: 'Get all nodes in the scene with their UUIDs', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'set_node_property', + description: 'Set node property value', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Node UUID' + }, + property: { + type: 'string', + description: 'Property name (e.g., position, rotation, scale, active)' + }, + value: { + description: 'Property value' + } + }, + required: ['uuid', 'property', 'value'] + } + }, + { + name: 'delete_node', + description: 'Delete a node from scene', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Node UUID to delete' + } + }, + required: ['uuid'] + } + }, + { + name: 'move_node', + description: 'Move node to new parent', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID to move' + }, + newParentUuid: { + type: 'string', + description: 'New parent node UUID' + }, + siblingIndex: { + type: 'number', + description: 'Sibling index in new parent', + default: -1 + } + }, + required: ['nodeUuid', 'newParentUuid'] + } + }, + { + name: 'duplicate_node', + description: 'Duplicate a node', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Node UUID to duplicate' + }, + includeChildren: { + type: 'boolean', + description: 'Include children nodes', + default: true + } + }, + required: ['uuid'] + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'create_node': + return await this.createNode(args); + case 'get_node_info': + return await this.getNodeInfo(args.uuid); + case 'find_nodes': + return await this.findNodes(args.pattern, args.exactMatch); + case 'find_node_by_name': + return await this.findNodeByName(args.name); + case 'get_all_nodes': + return await this.getAllNodes(); + case 'set_node_property': + return await this.setNodeProperty(args.uuid, args.property, args.value); + case 'delete_node': + return await this.deleteNode(args.uuid); + case 'move_node': + return await this.moveNode(args.nodeUuid, args.newParentUuid, args.siblingIndex); + case 'duplicate_node': + return await this.duplicateNode(args.uuid, args.includeChildren); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + async createNode(args) { + return new Promise(async (resolve) => { + // 如果指定了父节点，先验证父节点是否存在 + if (args.parentUuid) { + try { + const parentNode = await Editor.Message.request('scene', 'query-node', args.parentUuid); + if (!parentNode) { + resolve({ + success: false, + error: `Parent node with UUID '${args.parentUuid}' not found` + }); + return; + } + } + catch (err) { + resolve({ + success: false, + error: `Failed to verify parent node: ${err}` + }); + return; + } + } + const nodeData = { + name: args.name, + type: args.nodeType || 'cc.Node' + }; + // 使用更明确的父节点指定方式 + if (args.parentUuid) { + nodeData.parent = args.parentUuid; + // 尝试先创建节点，然后移动到指定父节点 + Editor.Message.request('scene', 'create-node', nodeData).then((nodeUuid) => { + // 如果创建成功但可能没有在正确的父节点下，尝试移动 + if (args.parentUuid && nodeUuid) { + Editor.Message.request('scene', 'move-node', { + uuid: nodeUuid, + parent: args.parentUuid, + index: args.siblingIndex !== undefined ? args.siblingIndex : -1 + }).then(() => { + resolve({ + success: true, + data: { + uuid: nodeUuid, + name: args.name, + parentUuid: args.parentUuid, + message: `Node '${args.name}' created under specified parent` + } + }); + }).catch(() => { + // 即使移动失败，节点已创建，返回成功但带警告 + resolve({ + success: true, + data: { + uuid: nodeUuid, + name: args.name, + message: `Node '${args.name}' created but may not be under specified parent`, + warning: 'Failed to move node to specified parent' + } + }); + }); + } + else { + resolve({ + success: true, + data: { + uuid: nodeUuid, + name: args.name, + message: `Node '${args.name}' created successfully` + } + }); + } + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + } + else { + // 没有指定父节点，使用默认行为 + Editor.Message.request('scene', 'create-node', nodeData).then((result) => { + resolve({ + success: true, + data: { + uuid: result, + name: args.name, + message: `Node '${args.name}' created at current selection` + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + } + }); + } + async getNodeInfo(uuid) { + return new Promise((resolve) => { + Editor.Message.request('scene', 'query-node', uuid).then((nodeData) => { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k; + if (!nodeData) { + resolve({ + success: false, + error: 'Node not found or invalid response' + }); + return; + } + // 根据实际返回的数据结构解析节点信息 + const info = { + uuid: ((_a = nodeData.uuid) === null || _a === void 0 ? void 0 : _a.value) || uuid, + name: ((_b = nodeData.name) === null || _b === void 0 ? void 0 : _b.value) || 'Unknown', + active: ((_c = nodeData.active) === null || _c === void 0 ? void 0 : _c.value) !== undefined ? nodeData.active.value : true, + position: ((_d = nodeData.position) === null || _d === void 0 ? void 0 : _d.value) || { x: 0, y: 0, z: 0 }, + rotation: ((_e = nodeData.rotation) === null || _e === void 0 ? void 0 : _e.value) || { x: 0, y: 0, z: 0 }, + scale: ((_f = nodeData.scale) === null || _f === void 0 ? void 0 : _f.value) || { x: 1, y: 1, z: 1 }, + parent: ((_h = (_g = nodeData.parent) === null || _g === void 0 ? void 0 : _g.value) === null || _h === void 0 ? void 0 : _h.uuid) || null, + children: nodeData.children || [], + components: (nodeData.__comps__ || []).map((comp) => ({ + type: comp.__type__ || 'Unknown', + enabled: comp.enabled !== undefined ? comp.enabled : true + })), + layer: ((_j = nodeData.layer) === null || _j === void 0 ? void 0 : _j.value) || 1073741824, + mobility: ((_k = nodeData.mobility) === null || _k === void 0 ? void 0 : _k.value) || 0 + }; + resolve({ success: true, data: info }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async findNodes(pattern, exactMatch = false) { + return new Promise((resolve) => { + Editor.Message.request('scene', 'query-nodes-by-name', { + name: pattern, + exactMatch: exactMatch + }).then((results) => { + const nodes = results.map(node => ({ + uuid: node.uuid, + name: node.name, + path: node.path + })); + resolve({ success: true, data: nodes }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async findNodeByName(name) { + return new Promise((resolve) => { + // 优先尝试使用 Editor API 查询节点树并搜索 + Editor.Message.request('scene', 'query-node-tree').then((tree) => { + const foundNode = this.searchNodeInTree(tree, name); + if (foundNode) { + resolve({ + success: true, + data: { + uuid: foundNode.uuid, + name: foundNode.name, + path: this.getNodePath(foundNode) + } + }); + } + else { + resolve({ success: false, error: `Node '${name}' not found` }); + } + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'findNodeByName', + args: [name] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + searchNodeInTree(node, targetName) { + if (node.name === targetName) { + return node; + } + if (node.children) { + for (const child of node.children) { + const found = this.searchNodeInTree(child, targetName); + if (found) { + return found; + } + } + } + return null; + } + async getAllNodes() { + return new Promise((resolve) => { + // 尝试查询场景节点树 + Editor.Message.request('scene', 'query-node-tree').then((tree) => { + const nodes = []; + const traverseTree = (node) => { + nodes.push({ + uuid: node.uuid, + name: node.name, + type: node.type, + active: node.active, + path: this.getNodePath(node) + }); + if (node.children) { + for (const child of node.children) { + traverseTree(child); + } + } + }; + if (tree && tree.children) { + traverseTree(tree); + } + resolve({ + success: true, + data: { + totalNodes: nodes.length, + nodes: nodes + } + }); + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getAllNodes', + args: [] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + getNodePath(node) { + const path = [node.name]; + let current = node.parent; + while (current && current.name !== 'Canvas') { + path.unshift(current.name); + current = current.parent; + } + return path.join('/'); + } + async setNodeProperty(uuid, property, value) { + return new Promise((resolve) => { + // 尝试直接使用 Editor API 设置节点属性 + Editor.Message.request('scene', 'set-property', { + uuid: uuid, + path: property, + dump: { + value: value + } + }).then(() => { + resolve({ + success: true, + message: `Property '${property}' updated successfully` + }); + }).catch((err) => { + // 如果直接设置失败，尝试使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'setNodeProperty', + args: [uuid, property, value] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + async deleteNode(uuid) { + return new Promise((resolve) => { + Editor.Message.request('scene', 'remove-node', { uuid: uuid }).then(() => { + resolve({ + success: true, + message: 'Node deleted successfully' + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async moveNode(nodeUuid, newParentUuid, siblingIndex = -1) { + return new Promise((resolve) => { + Editor.Message.request('scene', 'move-node', { + uuid: nodeUuid, + parent: newParentUuid, + index: siblingIndex + }).then(() => { + resolve({ + success: true, + message: 'Node moved successfully' + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async duplicateNode(uuid, includeChildren = true) { + return new Promise((resolve) => { + Editor.Message.request('scene', 'duplicate-node', uuid).then((result) => { + resolve({ + success: true, + data: { + newUuid: result.uuid, + message: 'Node duplicated successfully' + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } +} +exports.NodeTools = NodeTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node-tools.js","sourceRoot":"","sources":["../../source/tools/node-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, NodeInfo } from '../types';\n\nexport class NodeTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'create_node',\n                description: 'Create a new node in the scene. If parentUuid is not provided, the node will be created at the current selection in the editor.',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        name: {\n                            type: 'string',\n                            description: 'Node name'\n                        },\n                        parentUuid: {\n                            type: 'string',\n                            description: 'Parent node UUID. If not provided, node will be created at current editor selection. To create at scene root, first get the root node UUID.'\n                        },\n                        nodeType: {\n                            type: 'string',\n                            description: 'Node type: Node, 2DNode, 3DNode',\n                            enum: ['Node', '2DNode', '3DNode'],\n                            default: 'Node'\n                        },\n                        siblingIndex: {\n                            type: 'number',\n                            description: 'Sibling index for ordering (-1 means append at end)',\n                            default: -1\n                        }\n                    },\n                    required: ['name']\n                }\n            },\n            {\n                name: 'get_node_info',\n                description: 'Get node information by UUID',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'find_nodes',\n                description: 'Find nodes by name pattern',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        pattern: {\n                            type: 'string',\n                            description: 'Name pattern to search'\n                        },\n                        exactMatch: {\n                            type: 'boolean',\n                            description: 'Exact match or partial match',\n                            default: false\n                        }\n                    },\n                    required: ['pattern']\n                }\n            },\n            {\n                name: 'find_node_by_name',\n                description: 'Find first node by exact name',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        name: {\n                            type: 'string',\n                            description: 'Node name to find'\n                        }\n                    },\n                    required: ['name']\n                }\n            },\n            {\n                name: 'get_all_nodes',\n                description: 'Get all nodes in the scene with their UUIDs',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'set_node_property',\n                description: 'Set node property value',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID'\n                        },\n                        property: {\n                            type: 'string',\n                            description: 'Property name (e.g., position, rotation, scale, active)'\n                        },\n                        value: {\n                            description: 'Property value'\n                        }\n                    },\n                    required: ['uuid', 'property', 'value']\n                }\n            },\n            {\n                name: 'delete_node',\n                description: 'Delete a node from scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID to delete'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            },\n            {\n                name: 'move_node',\n                description: 'Move node to new parent',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID to move'\n                        },\n                        newParentUuid: {\n                            type: 'string',\n                            description: 'New parent node UUID'\n                        },\n                        siblingIndex: {\n                            type: 'number',\n                            description: 'Sibling index in new parent',\n                            default: -1\n                        }\n                    },\n                    required: ['nodeUuid', 'newParentUuid']\n                }\n            },\n            {\n                name: 'duplicate_node',\n                description: 'Duplicate a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Node UUID to duplicate'\n                        },\n                        includeChildren: {\n                            type: 'boolean',\n                            description: 'Include children nodes',\n                            default: true\n                        }\n                    },\n                    required: ['uuid']\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'create_node':\n                return await this.createNode(args);\n            case 'get_node_info':\n                return await this.getNodeInfo(args.uuid);\n            case 'find_nodes':\n                return await this.findNodes(args.pattern, args.exactMatch);\n            case 'find_node_by_name':\n                return await this.findNodeByName(args.name);\n            case 'get_all_nodes':\n                return await this.getAllNodes();\n            case 'set_node_property':\n                return await this.setNodeProperty(args.uuid, args.property, args.value);\n            case 'delete_node':\n                return await this.deleteNode(args.uuid);\n            case 'move_node':\n                return await this.moveNode(args.nodeUuid, args.newParentUuid, args.siblingIndex);\n            case 'duplicate_node':\n                return await this.duplicateNode(args.uuid, args.includeChildren);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async createNode(args: any): Promise<ToolResponse> {\n        return new Promise(async (resolve) => {\n            // 如果指定了父节点，先验证父节点是否存在\n            if (args.parentUuid) {\n                try {\n                    const parentNode = await Editor.Message.request('scene', 'query-node', args.parentUuid);\n                    if (!parentNode) {\n                        resolve({\n                            success: false,\n                            error: `Parent node with UUID '${args.parentUuid}' not found`\n                        });\n                        return;\n                    }\n                } catch (err) {\n                    resolve({\n                        success: false,\n                        error: `Failed to verify parent node: ${err}`\n                    });\n                    return;\n                }\n            }\n\n            const nodeData: any = {\n                name: args.name,\n                type: args.nodeType || 'cc.Node'\n            };\n\n            // 使用更明确的父节点指定方式\n            if (args.parentUuid) {\n                nodeData.parent = args.parentUuid;\n                // 尝试先创建节点，然后移动到指定父节点\n                Editor.Message.request('scene', 'create-node', nodeData).then((nodeUuid: any) => {\n                    // 如果创建成功但可能没有在正确的父节点下，尝试移动\n                    if (args.parentUuid && nodeUuid) {\n                        Editor.Message.request('scene', 'move-node', {\n                            uuid: nodeUuid,\n                            parent: args.parentUuid,\n                            index: args.siblingIndex !== undefined ? args.siblingIndex : -1\n                        }).then(() => {\n                            resolve({\n                                success: true,\n                                data: {\n                                    uuid: nodeUuid,\n                                    name: args.name,\n                                    parentUuid: args.parentUuid,\n                                    message: `Node '${args.name}' created under specified parent`\n                                }\n                            });\n                        }).catch(() => {\n                            // 即使移动失败，节点已创建，返回成功但带警告\n                            resolve({\n                                success: true,\n                                data: {\n                                    uuid: nodeUuid,\n                                    name: args.name,\n                                    message: `Node '${args.name}' created but may not be under specified parent`,\n                                    warning: 'Failed to move node to specified parent'\n                                }\n                            });\n                        });\n                    } else {\n                        resolve({\n                            success: true,\n                            data: {\n                                uuid: nodeUuid,\n                                name: args.name,\n                                message: `Node '${args.name}' created successfully`\n                            }\n                        });\n                    }\n                }).catch((err: Error) => {\n                    resolve({ success: false, error: err.message });\n                });\n            } else {\n                // 没有指定父节点，使用默认行为\n                Editor.Message.request('scene', 'create-node', nodeData).then((result: any) => {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: result,\n                            name: args.name,\n                            message: `Node '${args.name}' created at current selection`\n                        }\n                    });\n                }).catch((err: Error) => {\n                    resolve({ success: false, error: err.message });\n                });\n            }\n        });\n    }\n\n    private async getNodeInfo(uuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'query-node', uuid).then((nodeData: any) => {\n                if (!nodeData) {\n                    resolve({\n                        success: false,\n                        error: 'Node not found or invalid response'\n                    });\n                    return;\n                }\n                \n                // 根据实际返回的数据结构解析节点信息\n                const info: NodeInfo = {\n                    uuid: nodeData.uuid?.value || uuid,\n                    name: nodeData.name?.value || 'Unknown',\n                    active: nodeData.active?.value !== undefined ? nodeData.active.value : true,\n                    position: nodeData.position?.value || { x: 0, y: 0, z: 0 },\n                    rotation: nodeData.rotation?.value || { x: 0, y: 0, z: 0 },\n                    scale: nodeData.scale?.value || { x: 1, y: 1, z: 1 },\n                    parent: nodeData.parent?.value?.uuid || null,\n                    children: nodeData.children || [],\n                    components: (nodeData.__comps__ || []).map((comp: any) => ({\n                        type: comp.__type__ || 'Unknown',\n                        enabled: comp.enabled !== undefined ? comp.enabled : true\n                    })),\n                    layer: nodeData.layer?.value || 1073741824,\n                    mobility: nodeData.mobility?.value || 0\n                };\n                resolve({ success: true, data: info });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async findNodes(pattern: string, exactMatch: boolean = false): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'query-nodes-by-name', {\n                name: pattern,\n                exactMatch: exactMatch\n            }).then((results: any[]) => {\n                const nodes = results.map(node => ({\n                    uuid: node.uuid,\n                    name: node.name,\n                    path: node.path\n                }));\n                resolve({ success: true, data: nodes });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async findNodeByName(name: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试使用 Editor API 查询节点树并搜索\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                const foundNode = this.searchNodeInTree(tree, name);\n                if (foundNode) {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: foundNode.uuid,\n                            name: foundNode.name,\n                            path: this.getNodePath(foundNode)\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: `Node '${name}' not found` });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'findNodeByName',\n                    args: [name]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private searchNodeInTree(node: any, targetName: string): any {\n        if (node.name === targetName) {\n            return node;\n        }\n        \n        if (node.children) {\n            for (const child of node.children) {\n                const found = this.searchNodeInTree(child, targetName);\n                if (found) {\n                    return found;\n                }\n            }\n        }\n        \n        return null;\n    }\n\n    private async getAllNodes(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试查询场景节点树\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                const nodes: any[] = [];\n                \n                const traverseTree = (node: any) => {\n                    nodes.push({\n                        uuid: node.uuid,\n                        name: node.name,\n                        type: node.type,\n                        active: node.active,\n                        path: this.getNodePath(node)\n                    });\n                    \n                    if (node.children) {\n                        for (const child of node.children) {\n                            traverseTree(child);\n                        }\n                    }\n                };\n                \n                if (tree && tree.children) {\n                    traverseTree(tree);\n                }\n                \n                resolve({\n                    success: true,\n                    data: {\n                        totalNodes: nodes.length,\n                        nodes: nodes\n                    }\n                });\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getAllNodes',\n                    args: []\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private getNodePath(node: any): string {\n        const path = [node.name];\n        let current = node.parent;\n        while (current && current.name !== 'Canvas') {\n            path.unshift(current.name);\n            current = current.parent;\n        }\n        return path.join('/');\n    }\n\n    private async setNodeProperty(uuid: string, property: string, value: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 尝试直接使用 Editor API 设置节点属性\n            Editor.Message.request('scene', 'set-property', {\n                uuid: uuid,\n                path: property,\n                dump: {\n                    value: value\n                }\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: `Property '${property}' updated successfully`\n                });\n            }).catch((err: Error) => {\n                // 如果直接设置失败，尝试使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'setNodeProperty',\n                    args: [uuid, property, value]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async deleteNode(uuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'remove-node', { uuid: uuid }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Node deleted successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async moveNode(nodeUuid: string, newParentUuid: string, siblingIndex: number = -1): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'move-node', {\n                uuid: nodeUuid,\n                parent: newParentUuid,\n                index: siblingIndex\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Node moved successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async duplicateNode(uuid: string, includeChildren: boolean = true): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'duplicate-node', uuid).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        newUuid: result.uuid,\n                        message: 'Node duplicated successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/prefab-tools.js b/dist/tools/prefab-tools.js new file mode 100644 index 0000000..0c1b3bc --- /dev/null +++ b/dist/tools/prefab-tools.js @@ -0,0 +1,342 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PrefabTools = void 0; +class PrefabTools { + getTools() { + return [ + { + name: 'get_prefab_list', + description: 'Get all prefabs in the project', + inputSchema: { + type: 'object', + properties: { + folder: { + type: 'string', + description: 'Folder path to search (optional)', + default: 'db://assets' + } + } + } + }, + { + name: 'load_prefab', + description: 'Load a prefab by path', + inputSchema: { + type: 'object', + properties: { + prefabPath: { + type: 'string', + description: 'Prefab asset path' + } + }, + required: ['prefabPath'] + } + }, + { + name: 'instantiate_prefab', + description: 'Instantiate a prefab in the scene', + inputSchema: { + type: 'object', + properties: { + prefabPath: { + type: 'string', + description: 'Prefab asset path' + }, + parentUuid: { + type: 'string', + description: 'Parent node UUID (optional)' + }, + position: { + type: 'object', + description: 'Initial position', + properties: { + x: { type: 'number' }, + y: { type: 'number' }, + z: { type: 'number' } + } + } + }, + required: ['prefabPath'] + } + }, + { + name: 'create_prefab', + description: 'Create a prefab from a node', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Source node UUID' + }, + savePath: { + type: 'string', + description: 'Path to save the prefab' + }, + prefabName: { + type: 'string', + description: 'Prefab name' + } + }, + required: ['nodeUuid', 'savePath', 'prefabName'] + } + }, + { + name: 'create_prefab_from_node', + description: 'Create a prefab from a node (alias for create_prefab)', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Source node UUID' + }, + prefabPath: { + type: 'string', + description: 'Path to save the prefab' + } + }, + required: ['nodeUuid', 'prefabPath'] + } + }, + { + name: 'update_prefab', + description: 'Update an existing prefab', + inputSchema: { + type: 'object', + properties: { + prefabPath: { + type: 'string', + description: 'Prefab asset path' + }, + nodeUuid: { + type: 'string', + description: 'Node UUID with changes' + } + }, + required: ['prefabPath', 'nodeUuid'] + } + }, + { + name: 'revert_prefab', + description: 'Revert prefab instance to original', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Prefab instance node UUID' + } + }, + required: ['nodeUuid'] + } + }, + { + name: 'get_prefab_info', + description: 'Get detailed prefab information', + inputSchema: { + type: 'object', + properties: { + prefabPath: { + type: 'string', + description: 'Prefab asset path' + } + }, + required: ['prefabPath'] + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'get_prefab_list': + return await this.getPrefabList(args.folder); + case 'load_prefab': + return await this.loadPrefab(args.prefabPath); + case 'instantiate_prefab': + return await this.instantiatePrefab(args); + case 'create_prefab': + return await this.createPrefab(args); + case 'create_prefab_from_node': + return await this.createPrefabFromNode(args); + case 'update_prefab': + return await this.updatePrefab(args.prefabPath, args.nodeUuid); + case 'revert_prefab': + return await this.revertPrefab(args.nodeUuid); + case 'get_prefab_info': + return await this.getPrefabInfo(args.prefabPath); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + async getPrefabList(folder = 'db://assets') { + return new Promise((resolve) => { + const pattern = folder.endsWith('/') ? + `${folder}**/*.prefab` : `${folder}/**/*.prefab`; + Editor.Message.request('asset-db', 'query-assets', { + pattern: pattern + }).then((results) => { + const prefabs = results.map(asset => ({ + name: asset.name, + path: asset.url, + uuid: asset.uuid, + folder: asset.url.substring(0, asset.url.lastIndexOf('/')) + })); + resolve({ success: true, data: prefabs }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async loadPrefab(prefabPath) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo) => { + if (!assetInfo) { + throw new Error('Prefab not found'); + } + return Editor.Message.request('scene', 'load-asset', { + uuid: assetInfo.uuid + }); + }).then((prefabData) => { + resolve({ + success: true, + data: { + uuid: prefabData.uuid, + name: prefabData.name, + message: 'Prefab loaded successfully' + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async instantiatePrefab(args) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo) => { + if (!assetInfo) { + throw new Error('Prefab not found'); + } + const instantiateData = { + prefab: assetInfo.uuid + }; + if (args.parentUuid) { + instantiateData.parent = args.parentUuid; + } + if (args.position) { + instantiateData.position = args.position; + } + return Editor.Message.request('scene', 'instantiate-prefab', instantiateData); + }).then((result) => { + resolve({ + success: true, + data: { + nodeUuid: result.uuid, + name: result.name, + message: 'Prefab instantiated successfully' + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async createPrefab(args) { + return new Promise((resolve) => { + // 支持 prefabPath 和 savePath 两种参数名 + const pathParam = args.prefabPath || args.savePath; + if (!pathParam) { + resolve({ + success: false, + error: 'Missing prefab path parameter. Please provide either prefabPath or savePath.' + }); + return; + } + const fullPath = pathParam.endsWith('.prefab') ? + pathParam : `${pathParam}/${args.prefabName || 'NewPrefab'}.prefab`; + // 预制体创建需要特殊的Editor API支持 + // 目前Cocos Creator 3.8的MCP插件环境下，预制体创建功能受限 + resolve({ + success: false, + error: 'Prefab creation is not supported in the current MCP plugin environment', + instruction: 'Please create prefabs manually by dragging nodes from the scene to the assets folder in the Cocos Creator editor', + data: { + nodeUuid: args.nodeUuid, + requestedPath: fullPath, + suggestion: 'You can manually drag the node from the scene to the assets folder to create a prefab.' + } + }); + }); + } + async updatePrefab(prefabPath, nodeUuid) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo) => { + if (!assetInfo) { + throw new Error('Prefab not found'); + } + return Editor.Message.request('scene', 'apply-prefab', { + node: nodeUuid, + prefab: assetInfo.uuid + }); + }).then(() => { + resolve({ + success: true, + message: 'Prefab updated successfully' + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async revertPrefab(nodeUuid) { + return new Promise((resolve) => { + Editor.Message.request('scene', 'revert-prefab', { + node: nodeUuid + }).then(() => { + resolve({ + success: true, + message: 'Prefab instance reverted successfully' + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async getPrefabInfo(prefabPath) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo) => { + if (!assetInfo) { + throw new Error('Prefab not found'); + } + return Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + }).then((metaInfo) => { + const info = { + name: metaInfo.name, + uuid: metaInfo.uuid, + path: prefabPath, + folder: prefabPath.substring(0, prefabPath.lastIndexOf('/')), + createTime: metaInfo.createTime, + modifyTime: metaInfo.modifyTime, + dependencies: metaInfo.depends || [] + }; + resolve({ success: true, data: info }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async createPrefabFromNode(args) { + var _a; + // 从 prefabPath 提取名称 + const prefabPath = args.prefabPath; + const prefabName = ((_a = prefabPath.split('/').pop()) === null || _a === void 0 ? void 0 : _a.replace('.prefab', '')) || 'NewPrefab'; + // 调用原来的 createPrefab 方法 + return await this.createPrefab({ + nodeUuid: args.nodeUuid, + savePath: prefabPath, + prefabName: prefabName + }); + } +} +exports.PrefabTools = PrefabTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prefab-tools.js","sourceRoot":"","sources":["../../source/tools/prefab-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, PrefabInfo } from '../types';\n\nexport class PrefabTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'get_prefab_list',\n                description: 'Get all prefabs in the project',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        folder: {\n                            type: 'string',\n                            description: 'Folder path to search (optional)',\n                            default: 'db://assets'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'load_prefab',\n                description: 'Load a prefab by path',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'instantiate_prefab',\n                description: 'Instantiate a prefab in the scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        },\n                        parentUuid: {\n                            type: 'string',\n                            description: 'Parent node UUID (optional)'\n                        },\n                        position: {\n                            type: 'object',\n                            description: 'Initial position',\n                            properties: {\n                                x: { type: 'number' },\n                                y: { type: 'number' },\n                                z: { type: 'number' }\n                            }\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            },\n            {\n                name: 'create_prefab',\n                description: 'Create a prefab from a node',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Source node UUID'\n                        },\n                        savePath: {\n                            type: 'string',\n                            description: 'Path to save the prefab'\n                        },\n                        prefabName: {\n                            type: 'string',\n                            description: 'Prefab name'\n                        }\n                    },\n                    required: ['nodeUuid', 'savePath', 'prefabName']\n                }\n            },\n            {\n                name: 'create_prefab_from_node',\n                description: 'Create a prefab from a node (alias for create_prefab)',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Source node UUID'\n                        },\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Path to save the prefab'\n                        }\n                    },\n                    required: ['nodeUuid', 'prefabPath']\n                }\n            },\n            {\n                name: 'update_prefab',\n                description: 'Update an existing prefab',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        },\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Node UUID with changes'\n                        }\n                    },\n                    required: ['prefabPath', 'nodeUuid']\n                }\n            },\n            {\n                name: 'revert_prefab',\n                description: 'Revert prefab instance to original',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        nodeUuid: {\n                            type: 'string',\n                            description: 'Prefab instance node UUID'\n                        }\n                    },\n                    required: ['nodeUuid']\n                }\n            },\n            {\n                name: 'get_prefab_info',\n                description: 'Get detailed prefab information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        prefabPath: {\n                            type: 'string',\n                            description: 'Prefab asset path'\n                        }\n                    },\n                    required: ['prefabPath']\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'get_prefab_list':\n                return await this.getPrefabList(args.folder);\n            case 'load_prefab':\n                return await this.loadPrefab(args.prefabPath);\n            case 'instantiate_prefab':\n                return await this.instantiatePrefab(args);\n            case 'create_prefab':\n                return await this.createPrefab(args);\n            case 'create_prefab_from_node':\n                return await this.createPrefabFromNode(args);\n            case 'update_prefab':\n                return await this.updatePrefab(args.prefabPath, args.nodeUuid);\n            case 'revert_prefab':\n                return await this.revertPrefab(args.nodeUuid);\n            case 'get_prefab_info':\n                return await this.getPrefabInfo(args.prefabPath);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async getPrefabList(folder: string = 'db://assets'): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const pattern = folder.endsWith('/') ? \n                `${folder}**/*.prefab` : `${folder}/**/*.prefab`;\n            \n            Editor.Message.request('asset-db', 'query-assets', {\n                pattern: pattern\n            }).then((results: any[]) => {\n                const prefabs: PrefabInfo[] = results.map(asset => ({\n                    name: asset.name,\n                    path: asset.url,\n                    uuid: asset.uuid,\n                    folder: asset.url.substring(0, asset.url.lastIndexOf('/'))\n                }));\n                resolve({ success: true, data: prefabs });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async loadPrefab(prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n                \n                return Editor.Message.request('scene', 'load-asset', {\n                    uuid: assetInfo.uuid\n                });\n            }).then((prefabData: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        uuid: prefabData.uuid,\n                        name: prefabData.name,\n                        message: 'Prefab loaded successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async instantiatePrefab(args: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n\n                const instantiateData: any = {\n                    prefab: assetInfo.uuid\n                };\n\n                if (args.parentUuid) {\n                    instantiateData.parent = args.parentUuid;\n                }\n\n                if (args.position) {\n                    instantiateData.position = args.position;\n                }\n\n                return Editor.Message.request('scene', 'instantiate-prefab', instantiateData);\n            }).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        nodeUuid: result.uuid,\n                        name: result.name,\n                        message: 'Prefab instantiated successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async createPrefab(args: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 支持 prefabPath 和 savePath 两种参数名\n            const pathParam = args.prefabPath || args.savePath;\n            if (!pathParam) {\n                resolve({\n                    success: false,\n                    error: 'Missing prefab path parameter. Please provide either prefabPath or savePath.'\n                });\n                return;\n            }\n\n            const fullPath = pathParam.endsWith('.prefab') ? \n                pathParam : `${pathParam}/${args.prefabName || 'NewPrefab'}.prefab`;\n\n            // 预制体创建需要特殊的Editor API支持\n            // 目前Cocos Creator 3.8的MCP插件环境下，预制体创建功能受限\n            \n            resolve({\n                success: false,\n                error: 'Prefab creation is not supported in the current MCP plugin environment',\n                instruction: 'Please create prefabs manually by dragging nodes from the scene to the assets folder in the Cocos Creator editor',\n                data: {\n                    nodeUuid: args.nodeUuid,\n                    requestedPath: fullPath,\n                    suggestion: 'You can manually drag the node from the scene to the assets folder to create a prefab.'\n                }\n            });\n        });\n    }\n\n    private async updatePrefab(prefabPath: string, nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n\n                return Editor.Message.request('scene', 'apply-prefab', {\n                    node: nodeUuid,\n                    prefab: assetInfo.uuid\n                });\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Prefab updated successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async revertPrefab(nodeUuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'revert-prefab', {\n                node: nodeUuid\n            }).then(() => {\n                resolve({\n                    success: true,\n                    message: 'Prefab instance reverted successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getPrefabInfo(prefabPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Prefab not found');\n                }\n\n                return Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid);\n            }).then((metaInfo: any) => {\n                const info: PrefabInfo = {\n                    name: metaInfo.name,\n                    uuid: metaInfo.uuid,\n                    path: prefabPath,\n                    folder: prefabPath.substring(0, prefabPath.lastIndexOf('/')),\n                    createTime: metaInfo.createTime,\n                    modifyTime: metaInfo.modifyTime,\n                    dependencies: metaInfo.depends || []\n                };\n                resolve({ success: true, data: info });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async createPrefabFromNode(args: any): Promise<ToolResponse> {\n        // 从 prefabPath 提取名称\n        const prefabPath = args.prefabPath;\n        const prefabName = prefabPath.split('/').pop()?.replace('.prefab', '') || 'NewPrefab';\n        \n        // 调用原来的 createPrefab 方法\n        return await this.createPrefab({\n            nodeUuid: args.nodeUuid,\n            savePath: prefabPath,\n            prefabName: prefabName\n        });\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/preferences-tools.js b/dist/tools/preferences-tools.js new file mode 100644 index 0000000..3b7f003 --- /dev/null +++ b/dist/tools/preferences-tools.js @@ -0,0 +1,159 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.PreferencesTools = void 0; +class PreferencesTools { + getTools() { + return [ + { + name: 'get_preferences', + description: 'Get editor preferences', + inputSchema: { + type: 'object', + properties: { + key: { + type: 'string', + description: 'Specific preference key to get (optional)' + } + } + } + }, + { + name: 'set_preferences', + description: 'Set editor preferences', + inputSchema: { + type: 'object', + properties: { + key: { + type: 'string', + description: 'Preference key to set' + }, + value: { + description: 'Preference value to set' + } + }, + required: ['key', 'value'] + } + }, + { + name: 'get_global_preferences', + description: 'Get global editor preferences', + inputSchema: { + type: 'object', + properties: { + key: { + type: 'string', + description: 'Global preference key to get (optional)' + } + } + } + }, + { + name: 'set_global_preferences', + description: 'Set global editor preferences', + inputSchema: { + type: 'object', + properties: { + key: { + type: 'string', + description: 'Global preference key to set' + }, + value: { + description: 'Global preference value to set' + } + }, + required: ['key', 'value'] + } + }, + { + name: 'get_recent_projects', + description: 'Get recently opened projects', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'clear_recent_projects', + description: 'Clear recently opened projects list', + inputSchema: { + type: 'object', + properties: {} + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'get_preferences': + return await this.getPreferences(args.key); + case 'set_preferences': + return await this.setPreferences(args.key, args.value); + case 'get_global_preferences': + return await this.getGlobalPreferences(args.key); + case 'set_global_preferences': + return await this.setGlobalPreferences(args.key, args.value); + case 'get_recent_projects': + return await this.getRecentProjects(); + case 'clear_recent_projects': + return await this.clearRecentProjects(); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + async getPreferences(key) { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Preferences API is not supported through MCP', + instruction: 'Please access preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor' + }); + }); + } + async setPreferences(key, value) { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Preferences API is not supported through MCP', + instruction: 'Please modify preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor' + }); + }); + } + async getGlobalPreferences(key) { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Global preferences API is not supported through MCP', + instruction: 'Please access global preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor' + }); + }); + } + async setGlobalPreferences(key, value) { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Global preferences API is not supported through MCP', + instruction: 'Please modify global preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor' + }); + }); + } + async getRecentProjects() { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Recent projects API is not supported through MCP', + instruction: 'Please check recent projects through the editor menu: File > Recent Projects or the start screen' + }); + }); + } + async clearRecentProjects() { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Recent projects API is not supported through MCP', + instruction: 'Please clear recent projects through the editor menu: File > Recent Projects or the start screen' + }); + }); + } +} +exports.PreferencesTools = PreferencesTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"preferences-tools.js","sourceRoot":"","sources":["../../source/tools/preferences-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor } from '../types';\n\nexport class PreferencesTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'get_preferences',\n                description: 'Get editor preferences',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        key: {\n                            type: 'string',\n                            description: 'Specific preference key to get (optional)'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'set_preferences',\n                description: 'Set editor preferences',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        key: {\n                            type: 'string',\n                            description: 'Preference key to set'\n                        },\n                        value: {\n                            description: 'Preference value to set'\n                        }\n                    },\n                    required: ['key', 'value']\n                }\n            },\n            {\n                name: 'get_global_preferences',\n                description: 'Get global editor preferences',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        key: {\n                            type: 'string',\n                            description: 'Global preference key to get (optional)'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'set_global_preferences',\n                description: 'Set global editor preferences',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        key: {\n                            type: 'string',\n                            description: 'Global preference key to set'\n                        },\n                        value: {\n                            description: 'Global preference value to set'\n                        }\n                    },\n                    required: ['key', 'value']\n                }\n            },\n            {\n                name: 'get_recent_projects',\n                description: 'Get recently opened projects',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'clear_recent_projects',\n                description: 'Clear recently opened projects list',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'get_preferences':\n                return await this.getPreferences(args.key);\n            case 'set_preferences':\n                return await this.setPreferences(args.key, args.value);\n            case 'get_global_preferences':\n                return await this.getGlobalPreferences(args.key);\n            case 'set_global_preferences':\n                return await this.setGlobalPreferences(args.key, args.value);\n            case 'get_recent_projects':\n                return await this.getRecentProjects();\n            case 'clear_recent_projects':\n                return await this.clearRecentProjects();\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async getPreferences(key?: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Preferences API is not supported through MCP',\n                instruction: 'Please access preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor'\n            });\n        });\n    }\n\n    private async setPreferences(key: string, value: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Preferences API is not supported through MCP',\n                instruction: 'Please modify preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor'\n            });\n        });\n    }\n\n    private async getGlobalPreferences(key?: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Global preferences API is not supported through MCP',\n                instruction: 'Please access global preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor'\n            });\n        });\n    }\n\n    private async setGlobalPreferences(key: string, value: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Global preferences API is not supported through MCP',\n                instruction: 'Please modify global preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor'\n            });\n        });\n    }\n\n    private async getRecentProjects(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Recent projects API is not supported through MCP',\n                instruction: 'Please check recent projects through the editor menu: File > Recent Projects or the start screen'\n            });\n        });\n    }\n\n    private async clearRecentProjects(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Recent projects API is not supported through MCP',\n                instruction: 'Please clear recent projects through the editor menu: File > Recent Projects or the start screen'\n            });\n        });\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/project-tools.js b/dist/tools/project-tools.js new file mode 100644 index 0000000..5f673b5 --- /dev/null +++ b/dist/tools/project-tools.js @@ -0,0 +1,893 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || (function () { + var ownKeys = function(o) { + ownKeys = Object.getOwnPropertyNames || function (o) { + var ar = []; + for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k; + return ar; + }; + return ownKeys(o); + }; + return function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]); + __setModuleDefault(result, mod); + return result; + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ProjectTools = void 0; +const fs = __importStar(require("fs")); +const path = __importStar(require("path")); +class ProjectTools { + getTools() { + return [ + { + name: 'run_project', + description: 'Run the project in preview mode', + inputSchema: { + type: 'object', + properties: { + platform: { + type: 'string', + description: 'Target platform', + enum: ['browser', 'simulator', 'preview'], + default: 'browser' + } + } + } + }, + { + name: 'build_project', + description: 'Build the project', + inputSchema: { + type: 'object', + properties: { + platform: { + type: 'string', + description: 'Build platform', + enum: ['web-mobile', 'web-desktop', 'ios', 'android', 'windows', 'mac'] + }, + debug: { + type: 'boolean', + description: 'Debug build', + default: true + } + }, + required: ['platform'] + } + }, + { + name: 'get_project_info', + description: 'Get project information', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_project_settings', + description: 'Get project settings', + inputSchema: { + type: 'object', + properties: { + category: { + type: 'string', + description: 'Settings category', + enum: ['general', 'physics', 'render', 'assets'], + default: 'general' + } + } + } + }, + { + name: 'refresh_assets', + description: 'Refresh asset database', + inputSchema: { + type: 'object', + properties: { + folder: { + type: 'string', + description: 'Specific folder to refresh (optional)' + } + } + } + }, + { + name: 'import_asset', + description: 'Import an asset file', + inputSchema: { + type: 'object', + properties: { + sourcePath: { + type: 'string', + description: 'Source file path' + }, + targetFolder: { + type: 'string', + description: 'Target folder in assets' + } + }, + required: ['sourcePath', 'targetFolder'] + } + }, + { + name: 'get_asset_info', + description: 'Get asset information', + inputSchema: { + type: 'object', + properties: { + assetPath: { + type: 'string', + description: 'Asset path (db://assets/...)' + } + }, + required: ['assetPath'] + } + }, + { + name: 'get_assets', + description: 'Get assets by type', + inputSchema: { + type: 'object', + properties: { + type: { + type: 'string', + description: 'Asset type filter', + enum: ['all', 'scene', 'prefab', 'script', 'texture', 'material', 'mesh', 'audio', 'animation'], + default: 'all' + }, + folder: { + type: 'string', + description: 'Folder to search in', + default: 'db://assets' + } + } + } + }, + { + name: 'get_build_settings', + description: 'Get build settings - shows current limitations', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'open_build_panel', + description: 'Open the build panel in the editor', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'check_builder_status', + description: 'Check if builder worker is ready', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'start_preview_server', + description: 'Start preview server', + inputSchema: { + type: 'object', + properties: { + port: { + type: 'number', + description: 'Preview server port', + default: 7456 + } + } + } + }, + { + name: 'stop_preview_server', + description: 'Stop preview server', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'create_asset', + description: 'Create a new asset file or folder', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL (e.g., db://assets/newfile.json)' + }, + content: { + type: 'string', + description: 'File content (null for folder)', + default: null + }, + overwrite: { + type: 'boolean', + description: 'Overwrite existing file', + default: false + } + }, + required: ['url'] + } + }, + { + name: 'copy_asset', + description: 'Copy an asset to another location', + inputSchema: { + type: 'object', + properties: { + source: { + type: 'string', + description: 'Source asset URL' + }, + target: { + type: 'string', + description: 'Target location URL' + }, + overwrite: { + type: 'boolean', + description: 'Overwrite existing file', + default: false + } + }, + required: ['source', 'target'] + } + }, + { + name: 'move_asset', + description: 'Move an asset to another location', + inputSchema: { + type: 'object', + properties: { + source: { + type: 'string', + description: 'Source asset URL' + }, + target: { + type: 'string', + description: 'Target location URL' + }, + overwrite: { + type: 'boolean', + description: 'Overwrite existing file', + default: false + } + }, + required: ['source', 'target'] + } + }, + { + name: 'delete_asset', + description: 'Delete an asset', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL to delete' + } + }, + required: ['url'] + } + }, + { + name: 'save_asset', + description: 'Save asset content', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL' + }, + content: { + type: 'string', + description: 'Asset content' + } + }, + required: ['url', 'content'] + } + }, + { + name: 'reimport_asset', + description: 'Reimport an asset', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL to reimport' + } + }, + required: ['url'] + } + }, + { + name: 'query_asset_path', + description: 'Get asset disk path', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL' + } + }, + required: ['url'] + } + }, + { + name: 'query_asset_uuid', + description: 'Get asset UUID from URL', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL' + } + }, + required: ['url'] + } + }, + { + name: 'query_asset_url', + description: 'Get asset URL from UUID', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Asset UUID' + } + }, + required: ['uuid'] + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'run_project': + return await this.runProject(args.platform); + case 'build_project': + return await this.buildProject(args); + case 'get_project_info': + return await this.getProjectInfo(); + case 'get_project_settings': + return await this.getProjectSettings(args.category); + case 'refresh_assets': + return await this.refreshAssets(args.folder); + case 'import_asset': + return await this.importAsset(args.sourcePath, args.targetFolder); + case 'get_asset_info': + return await this.getAssetInfo(args.assetPath); + case 'get_assets': + return await this.getAssets(args.type, args.folder); + case 'get_build_settings': + return await this.getBuildSettings(); + case 'open_build_panel': + return await this.openBuildPanel(); + case 'check_builder_status': + return await this.checkBuilderStatus(); + case 'start_preview_server': + return await this.startPreviewServer(args.port); + case 'stop_preview_server': + return await this.stopPreviewServer(); + case 'create_asset': + return await this.createAsset(args.url, args.content, args.overwrite); + case 'copy_asset': + return await this.copyAsset(args.source, args.target, args.overwrite); + case 'move_asset': + return await this.moveAsset(args.source, args.target, args.overwrite); + case 'delete_asset': + return await this.deleteAsset(args.url); + case 'save_asset': + return await this.saveAsset(args.url, args.content); + case 'reimport_asset': + return await this.reimportAsset(args.url); + case 'query_asset_path': + return await this.queryAssetPath(args.url); + case 'query_asset_uuid': + return await this.queryAssetUuid(args.url); + case 'query_asset_url': + return await this.queryAssetUrl(args.uuid); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + async runProject(platform = 'browser') { + return new Promise((resolve) => { + const previewConfig = { + platform: platform, + scenes: [] // Will use current scene + }; + Editor.Message.request('preview', 'start', previewConfig).then(() => { + resolve({ + success: true, + message: `Project is running in ${platform} mode` + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async buildProject(args) { + return new Promise((resolve) => { + const buildOptions = { + platform: args.platform, + debug: args.debug !== false, + sourceMaps: args.debug !== false, + buildPath: `build/${args.platform}` + }; + Editor.Message.request('builder', 'build', buildOptions).then(() => { + resolve({ + success: true, + message: `Project built for ${args.platform}`, + data: { buildPath: buildOptions.buildPath } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async getProjectInfo() { + return new Promise((resolve) => { + var _a; + const info = { + name: Editor.Project.name, + path: Editor.Project.path, + uuid: Editor.Project.uuid, + version: Editor.Project.version || '1.0.0', + cocosVersion: ((_a = Editor.versions) === null || _a === void 0 ? void 0 : _a.cocos) || 'Unknown' + }; + Editor.Message.request('project', 'query-info').then((additionalInfo) => { + Object.assign(info, additionalInfo); + resolve({ success: true, data: info }); + }).catch(() => { + // Return basic info even if detailed query fails + resolve({ success: true, data: info }); + }); + }); + } + async getProjectSettings(category = 'general') { + return new Promise((resolve) => { + // 使用正确的 project API 查询项目配置 + const configMap = { + general: 'project', + physics: 'physics', + render: 'render', + assets: 'asset-db' + }; + const configName = configMap[category] || 'project'; + Editor.Message.request('project', 'query-config', configName).then((settings) => { + resolve({ + success: true, + data: { + category: category, + config: settings, + message: `${category} settings retrieved successfully` + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async refreshAssets(folder) { + return new Promise((resolve) => { + // 使用正确的 asset-db API 刷新资源 + const targetPath = folder || 'db://assets'; + Editor.Message.request('asset-db', 'refresh-asset', targetPath).then(() => { + resolve({ + success: true, + message: `Assets refreshed in: ${targetPath}` + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async importAsset(sourcePath, targetFolder) { + return new Promise((resolve) => { + if (!fs.existsSync(sourcePath)) { + resolve({ success: false, error: 'Source file not found' }); + return; + } + const fileName = path.basename(sourcePath); + const targetPath = targetFolder.startsWith('db://') ? + targetFolder : `db://assets/${targetFolder}`; + Editor.Message.request('asset-db', 'import-asset', sourcePath, `${targetPath}/${fileName}`).then((result) => { + resolve({ + success: true, + data: { + uuid: result.uuid, + path: result.url, + message: `Asset imported: ${fileName}` + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async getAssetInfo(assetPath) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', assetPath).then((assetInfo) => { + if (!assetInfo) { + throw new Error('Asset not found'); + } + const info = { + name: assetInfo.name, + uuid: assetInfo.uuid, + path: assetInfo.url, + type: assetInfo.type, + size: assetInfo.size, + isDirectory: assetInfo.isDirectory + }; + if (assetInfo.meta) { + info.meta = { + ver: assetInfo.meta.ver, + importer: assetInfo.meta.importer + }; + } + resolve({ success: true, data: info }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async getAssets(type = 'all', folder = 'db://assets') { + return new Promise((resolve) => { + let pattern = `${folder}/**/*`; + // 添加类型过滤 + if (type !== 'all') { + const typeExtensions = { + 'scene': '.scene', + 'prefab': '.prefab', + 'script': '.{ts,js}', + 'texture': '.{png,jpg,jpeg,gif,tga,bmp,psd}', + 'material': '.mtl', + 'mesh': '.{fbx,obj,dae}', + 'audio': '.{mp3,ogg,wav,m4a}', + 'animation': '.{anim,clip}' + }; + const extension = typeExtensions[type]; + if (extension) { + pattern = `${folder}/**/*${extension}`; + } + } + Editor.Message.request('asset-db', 'query-assets', { + pattern: pattern + }).then((results) => { + const assets = results.map(asset => ({ + name: asset.name, + uuid: asset.uuid, + path: asset.url, + type: asset.type, + size: asset.size || 0, + isDirectory: asset.isDirectory || false + })); + resolve({ + success: true, + data: { + type: type, + folder: folder, + count: assets.length, + assets: assets + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async getBuildSettings() { + return new Promise((resolve) => { + // 检查构建器是否准备就绪 + Editor.Message.request('builder', 'query-worker-ready').then((ready) => { + resolve({ + success: true, + data: { + builderReady: ready, + message: 'Build settings are limited in MCP plugin environment', + availableActions: [ + 'Open build panel with open_build_panel', + 'Check builder status with check_builder_status', + 'Start preview server with start_preview_server', + 'Stop preview server with stop_preview_server' + ], + limitation: 'Full build configuration requires direct Editor UI access' + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async openBuildPanel() { + return new Promise((resolve) => { + Editor.Message.request('builder', 'open').then(() => { + resolve({ + success: true, + message: 'Build panel opened successfully' + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async checkBuilderStatus() { + return new Promise((resolve) => { + Editor.Message.request('builder', 'query-worker-ready').then((ready) => { + resolve({ + success: true, + data: { + ready: ready, + status: ready ? 'Builder worker is ready' : 'Builder worker is not ready', + message: 'Builder status checked successfully' + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async startPreviewServer(port = 7456) { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Preview server control is not supported through MCP API', + instruction: 'Please start the preview server manually using the editor menu: Project > Preview, or use the preview panel in the editor' + }); + }); + } + async stopPreviewServer() { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Preview server control is not supported through MCP API', + instruction: 'Please stop the preview server manually using the preview panel in the editor' + }); + }); + } + async createAsset(url, content = null, overwrite = false) { + return new Promise((resolve) => { + const options = { + overwrite: overwrite, + rename: !overwrite + }; + Editor.Message.request('asset-db', 'create-asset', url, content, options).then((result) => { + if (result && result.uuid) { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + message: content === null ? 'Folder created successfully' : 'File created successfully' + } + }); + } + else { + resolve({ + success: true, + data: { + url: url, + message: content === null ? 'Folder created successfully' : 'File created successfully' + } + }); + } + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async copyAsset(source, target, overwrite = false) { + return new Promise((resolve) => { + const options = { + overwrite: overwrite, + rename: !overwrite + }; + Editor.Message.request('asset-db', 'copy-asset', source, target, options).then((result) => { + if (result && result.uuid) { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + message: 'Asset copied successfully' + } + }); + } + else { + resolve({ + success: true, + data: { + source: source, + target: target, + message: 'Asset copied successfully' + } + }); + } + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async moveAsset(source, target, overwrite = false) { + return new Promise((resolve) => { + const options = { + overwrite: overwrite, + rename: !overwrite + }; + Editor.Message.request('asset-db', 'move-asset', source, target, options).then((result) => { + if (result && result.uuid) { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + message: 'Asset moved successfully' + } + }); + } + else { + resolve({ + success: true, + data: { + source: source, + target: target, + message: 'Asset moved successfully' + } + }); + } + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async deleteAsset(url) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'delete-asset', url).then((result) => { + resolve({ + success: true, + data: { + url: url, + message: 'Asset deleted successfully' + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async saveAsset(url, content) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'save-asset', url, content).then((result) => { + if (result && result.uuid) { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + message: 'Asset saved successfully' + } + }); + } + else { + resolve({ + success: true, + data: { + url: url, + message: 'Asset saved successfully' + } + }); + } + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async reimportAsset(url) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'reimport-asset', url).then(() => { + resolve({ + success: true, + data: { + url: url, + message: 'Asset reimported successfully' + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async queryAssetPath(url) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-path', url).then((path) => { + if (path) { + resolve({ + success: true, + data: { + url: url, + path: path, + message: 'Asset path retrieved successfully' + } + }); + } + else { + resolve({ success: false, error: 'Asset path not found' }); + } + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async queryAssetUuid(url) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-uuid', url).then((uuid) => { + if (uuid) { + resolve({ + success: true, + data: { + url: url, + uuid: uuid, + message: 'Asset UUID retrieved successfully' + } + }); + } + else { + resolve({ success: false, error: 'Asset UUID not found' }); + } + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async queryAssetUrl(uuid) { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-url', uuid).then((url) => { + if (url) { + resolve({ + success: true, + data: { + uuid: uuid, + url: url, + message: 'Asset URL retrieved successfully' + } + }); + } + else { + resolve({ success: false, error: 'Asset URL not found' }); + } + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } +} +exports.ProjectTools = ProjectTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-tools.js","sourceRoot":"","sources":["../../source/tools/project-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, ProjectInfo, AssetInfo } from '../types';\nimport * as fs from 'fs';\nimport * as path from 'path';\n\nexport class ProjectTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'run_project',\n                description: 'Run the project in preview mode',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        platform: {\n                            type: 'string',\n                            description: 'Target platform',\n                            enum: ['browser', 'simulator', 'preview'],\n                            default: 'browser'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'build_project',\n                description: 'Build the project',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        platform: {\n                            type: 'string',\n                            description: 'Build platform',\n                            enum: ['web-mobile', 'web-desktop', 'ios', 'android', 'windows', 'mac']\n                        },\n                        debug: {\n                            type: 'boolean',\n                            description: 'Debug build',\n                            default: true\n                        }\n                    },\n                    required: ['platform']\n                }\n            },\n            {\n                name: 'get_project_info',\n                description: 'Get project information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'get_project_settings',\n                description: 'Get project settings',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        category: {\n                            type: 'string',\n                            description: 'Settings category',\n                            enum: ['general', 'physics', 'render', 'assets'],\n                            default: 'general'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'refresh_assets',\n                description: 'Refresh asset database',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        folder: {\n                            type: 'string',\n                            description: 'Specific folder to refresh (optional)'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'import_asset',\n                description: 'Import an asset file',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        sourcePath: {\n                            type: 'string',\n                            description: 'Source file path'\n                        },\n                        targetFolder: {\n                            type: 'string',\n                            description: 'Target folder in assets'\n                        }\n                    },\n                    required: ['sourcePath', 'targetFolder']\n                }\n            },\n            {\n                name: 'get_asset_info',\n                description: 'Get asset information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        assetPath: {\n                            type: 'string',\n                            description: 'Asset path (db://assets/...)'\n                        }\n                    },\n                    required: ['assetPath']\n                }\n            },\n            {\n                name: 'get_assets',\n                description: 'Get assets by type',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        type: {\n                            type: 'string',\n                            description: 'Asset type filter',\n                            enum: ['all', 'scene', 'prefab', 'script', 'texture', 'material', 'mesh', 'audio', 'animation'],\n                            default: 'all'\n                        },\n                        folder: {\n                            type: 'string',\n                            description: 'Folder to search in',\n                            default: 'db://assets'\n                        }\n                    }\n                }\n            },\n            {\n                name: 'get_build_settings',\n                description: 'Get build settings - shows current limitations',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'open_build_panel',\n                description: 'Open the build panel in the editor',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'check_builder_status',\n                description: 'Check if builder worker is ready',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'start_preview_server',\n                description: 'Start preview server',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        port: {\n                            type: 'number',\n                            description: 'Preview server port',\n                            default: 7456\n                        }\n                    }\n                }\n            },\n            {\n                name: 'stop_preview_server',\n                description: 'Stop preview server',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'create_asset',\n                description: 'Create a new asset file or folder',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        url: {\n                            type: 'string',\n                            description: 'Asset URL (e.g., db://assets/newfile.json)'\n                        },\n                        content: {\n                            type: 'string',\n                            description: 'File content (null for folder)',\n                            default: null\n                        },\n                        overwrite: {\n                            type: 'boolean',\n                            description: 'Overwrite existing file',\n                            default: false\n                        }\n                    },\n                    required: ['url']\n                }\n            },\n            {\n                name: 'copy_asset',\n                description: 'Copy an asset to another location',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        source: {\n                            type: 'string',\n                            description: 'Source asset URL'\n                        },\n                        target: {\n                            type: 'string',\n                            description: 'Target location URL'\n                        },\n                        overwrite: {\n                            type: 'boolean',\n                            description: 'Overwrite existing file',\n                            default: false\n                        }\n                    },\n                    required: ['source', 'target']\n                }\n            },\n            {\n                name: 'move_asset',\n                description: 'Move an asset to another location',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        source: {\n                            type: 'string',\n                            description: 'Source asset URL'\n                        },\n                        target: {\n                            type: 'string',\n                            description: 'Target location URL'\n                        },\n                        overwrite: {\n                            type: 'boolean',\n                            description: 'Overwrite existing file',\n                            default: false\n                        }\n                    },\n                    required: ['source', 'target']\n                }\n            },\n            {\n                name: 'delete_asset',\n                description: 'Delete an asset',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        url: {\n                            type: 'string',\n                            description: 'Asset URL to delete'\n                        }\n                    },\n                    required: ['url']\n                }\n            },\n            {\n                name: 'save_asset',\n                description: 'Save asset content',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        url: {\n                            type: 'string',\n                            description: 'Asset URL'\n                        },\n                        content: {\n                            type: 'string',\n                            description: 'Asset content'\n                        }\n                    },\n                    required: ['url', 'content']\n                }\n            },\n            {\n                name: 'reimport_asset',\n                description: 'Reimport an asset',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        url: {\n                            type: 'string',\n                            description: 'Asset URL to reimport'\n                        }\n                    },\n                    required: ['url']\n                }\n            },\n            {\n                name: 'query_asset_path',\n                description: 'Get asset disk path',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        url: {\n                            type: 'string',\n                            description: 'Asset URL'\n                        }\n                    },\n                    required: ['url']\n                }\n            },\n            {\n                name: 'query_asset_uuid',\n                description: 'Get asset UUID from URL',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        url: {\n                            type: 'string',\n                            description: 'Asset URL'\n                        }\n                    },\n                    required: ['url']\n                }\n            },\n            {\n                name: 'query_asset_url',\n                description: 'Get asset URL from UUID',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        uuid: {\n                            type: 'string',\n                            description: 'Asset UUID'\n                        }\n                    },\n                    required: ['uuid']\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'run_project':\n                return await this.runProject(args.platform);\n            case 'build_project':\n                return await this.buildProject(args);\n            case 'get_project_info':\n                return await this.getProjectInfo();\n            case 'get_project_settings':\n                return await this.getProjectSettings(args.category);\n            case 'refresh_assets':\n                return await this.refreshAssets(args.folder);\n            case 'import_asset':\n                return await this.importAsset(args.sourcePath, args.targetFolder);\n            case 'get_asset_info':\n                return await this.getAssetInfo(args.assetPath);\n            case 'get_assets':\n                return await this.getAssets(args.type, args.folder);\n            case 'get_build_settings':\n                return await this.getBuildSettings();\n            case 'open_build_panel':\n                return await this.openBuildPanel();\n            case 'check_builder_status':\n                return await this.checkBuilderStatus();\n            case 'start_preview_server':\n                return await this.startPreviewServer(args.port);\n            case 'stop_preview_server':\n                return await this.stopPreviewServer();\n            case 'create_asset':\n                return await this.createAsset(args.url, args.content, args.overwrite);\n            case 'copy_asset':\n                return await this.copyAsset(args.source, args.target, args.overwrite);\n            case 'move_asset':\n                return await this.moveAsset(args.source, args.target, args.overwrite);\n            case 'delete_asset':\n                return await this.deleteAsset(args.url);\n            case 'save_asset':\n                return await this.saveAsset(args.url, args.content);\n            case 'reimport_asset':\n                return await this.reimportAsset(args.url);\n            case 'query_asset_path':\n                return await this.queryAssetPath(args.url);\n            case 'query_asset_uuid':\n                return await this.queryAssetUuid(args.url);\n            case 'query_asset_url':\n                return await this.queryAssetUrl(args.uuid);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async runProject(platform: string = 'browser'): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const previewConfig = {\n                platform: platform,\n                scenes: [] // Will use current scene\n            };\n\n            Editor.Message.request('preview', 'start', previewConfig).then(() => {\n                resolve({\n                    success: true,\n                    message: `Project is running in ${platform} mode`\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async buildProject(args: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const buildOptions = {\n                platform: args.platform,\n                debug: args.debug !== false,\n                sourceMaps: args.debug !== false,\n                buildPath: `build/${args.platform}`\n            };\n\n            Editor.Message.request('builder', 'build', buildOptions).then(() => {\n                resolve({\n                    success: true,\n                    message: `Project built for ${args.platform}`,\n                    data: { buildPath: buildOptions.buildPath }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getProjectInfo(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const info: ProjectInfo = {\n                name: Editor.Project.name,\n                path: Editor.Project.path,\n                uuid: Editor.Project.uuid,\n                version: (Editor.Project as any).version || '1.0.0',\n                cocosVersion: (Editor as any).versions?.cocos || 'Unknown'\n            };\n\n            Editor.Message.request('project', 'query-info').then((additionalInfo: any) => {\n                Object.assign(info, additionalInfo);\n                resolve({ success: true, data: info });\n            }).catch(() => {\n                // Return basic info even if detailed query fails\n                resolve({ success: true, data: info });\n            });\n        });\n    }\n\n    private async getProjectSettings(category: string = 'general'): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 使用正确的 project API 查询项目配置\n            const configMap: Record<string, string> = {\n                general: 'project',\n                physics: 'physics',\n                render: 'render',\n                assets: 'asset-db'\n            };\n\n            const configName = configMap[category] || 'project';\n\n            Editor.Message.request('project', 'query-config', configName).then((settings: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        category: category,\n                        config: settings,\n                        message: `${category} settings retrieved successfully`\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async refreshAssets(folder?: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 使用正确的 asset-db API 刷新资源\n            const targetPath = folder || 'db://assets';\n            \n            Editor.Message.request('asset-db', 'refresh-asset', targetPath).then(() => {\n                resolve({\n                    success: true,\n                    message: `Assets refreshed in: ${targetPath}`\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async importAsset(sourcePath: string, targetFolder: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            if (!fs.existsSync(sourcePath)) {\n                resolve({ success: false, error: 'Source file not found' });\n                return;\n            }\n\n            const fileName = path.basename(sourcePath);\n            const targetPath = targetFolder.startsWith('db://') ?\n                targetFolder : `db://assets/${targetFolder}`;\n\n            Editor.Message.request('asset-db', 'import-asset', sourcePath, `${targetPath}/${fileName}`).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        uuid: result.uuid,\n                        path: result.url,\n                        message: `Asset imported: ${fileName}`\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getAssetInfo(assetPath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-asset-info', assetPath).then((assetInfo: any) => {\n                if (!assetInfo) {\n                    throw new Error('Asset not found');\n                }\n\n                const info: AssetInfo = {\n                    name: assetInfo.name,\n                    uuid: assetInfo.uuid,\n                    path: assetInfo.url,\n                    type: assetInfo.type,\n                    size: assetInfo.size,\n                    isDirectory: assetInfo.isDirectory\n                };\n\n                if (assetInfo.meta) {\n                    info.meta = {\n                        ver: assetInfo.meta.ver,\n                        importer: assetInfo.meta.importer\n                    };\n                }\n\n                resolve({ success: true, data: info });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getAssets(type: string = 'all', folder: string = 'db://assets'): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            let pattern = `${folder}/**/*`;\n            \n            // 添加类型过滤\n            if (type !== 'all') {\n                const typeExtensions: Record<string, string> = {\n                    'scene': '.scene',\n                    'prefab': '.prefab',\n                    'script': '.{ts,js}',\n                    'texture': '.{png,jpg,jpeg,gif,tga,bmp,psd}',\n                    'material': '.mtl',\n                    'mesh': '.{fbx,obj,dae}',\n                    'audio': '.{mp3,ogg,wav,m4a}',\n                    'animation': '.{anim,clip}'\n                };\n                \n                const extension = typeExtensions[type];\n                if (extension) {\n                    pattern = `${folder}/**/*${extension}`;\n                }\n            }\n\n            Editor.Message.request('asset-db', 'query-assets', {\n                pattern: pattern\n            }).then((results: any[]) => {\n                const assets = results.map(asset => ({\n                    name: asset.name,\n                    uuid: asset.uuid,\n                    path: asset.url,\n                    type: asset.type,\n                    size: asset.size || 0,\n                    isDirectory: asset.isDirectory || false\n                }));\n                \n                resolve({ \n                    success: true, \n                    data: {\n                        type: type,\n                        folder: folder,\n                        count: assets.length,\n                        assets: assets\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getBuildSettings(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 检查构建器是否准备就绪\n            Editor.Message.request('builder', 'query-worker-ready').then((ready: boolean) => {\n                resolve({\n                    success: true,\n                    data: {\n                        builderReady: ready,\n                        message: 'Build settings are limited in MCP plugin environment',\n                        availableActions: [\n                            'Open build panel with open_build_panel',\n                            'Check builder status with check_builder_status',\n                            'Start preview server with start_preview_server',\n                            'Stop preview server with stop_preview_server'\n                        ],\n                        limitation: 'Full build configuration requires direct Editor UI access'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async openBuildPanel(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('builder', 'open').then(() => {\n                resolve({\n                    success: true,\n                    message: 'Build panel opened successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async checkBuilderStatus(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('builder', 'query-worker-ready').then((ready: boolean) => {\n                resolve({\n                    success: true,\n                    data: {\n                        ready: ready,\n                        status: ready ? 'Builder worker is ready' : 'Builder worker is not ready',\n                        message: 'Builder status checked successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async startPreviewServer(port: number = 7456): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Preview server control is not supported through MCP API',\n                instruction: 'Please start the preview server manually using the editor menu: Project > Preview, or use the preview panel in the editor'\n            });\n        });\n    }\n\n    private async stopPreviewServer(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Preview server control is not supported through MCP API',\n                instruction: 'Please stop the preview server manually using the preview panel in the editor'\n            });\n        });\n    }\n\n    private async createAsset(url: string, content: string | null = null, overwrite: boolean = false): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const options = {\n                overwrite: overwrite,\n                rename: !overwrite\n            };\n\n            Editor.Message.request('asset-db', 'create-asset', url, content, options).then((result: any) => {\n                if (result && result.uuid) {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: result.uuid,\n                            url: result.url,\n                            message: content === null ? 'Folder created successfully' : 'File created successfully'\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: true,\n                        data: {\n                            url: url,\n                            message: content === null ? 'Folder created successfully' : 'File created successfully'\n                        }\n                    });\n                }\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async copyAsset(source: string, target: string, overwrite: boolean = false): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const options = {\n                overwrite: overwrite,\n                rename: !overwrite\n            };\n\n            Editor.Message.request('asset-db', 'copy-asset', source, target, options).then((result: any) => {\n                if (result && result.uuid) {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: result.uuid,\n                            url: result.url,\n                            message: 'Asset copied successfully'\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: true,\n                        data: {\n                            source: source,\n                            target: target,\n                            message: 'Asset copied successfully'\n                        }\n                    });\n                }\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async moveAsset(source: string, target: string, overwrite: boolean = false): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            const options = {\n                overwrite: overwrite,\n                rename: !overwrite\n            };\n\n            Editor.Message.request('asset-db', 'move-asset', source, target, options).then((result: any) => {\n                if (result && result.uuid) {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: result.uuid,\n                            url: result.url,\n                            message: 'Asset moved successfully'\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: true,\n                        data: {\n                            source: source,\n                            target: target,\n                            message: 'Asset moved successfully'\n                        }\n                    });\n                }\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async deleteAsset(url: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'delete-asset', url).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        url: url,\n                        message: 'Asset deleted successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async saveAsset(url: string, content: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'save-asset', url, content).then((result: any) => {\n                if (result && result.uuid) {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: result.uuid,\n                            url: result.url,\n                            message: 'Asset saved successfully'\n                        }\n                    });\n                } else {\n                    resolve({\n                        success: true,\n                        data: {\n                            url: url,\n                            message: 'Asset saved successfully'\n                        }\n                    });\n                }\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async reimportAsset(url: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'reimport-asset', url).then(() => {\n                resolve({\n                    success: true,\n                    data: {\n                        url: url,\n                        message: 'Asset reimported successfully'\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async queryAssetPath(url: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-path', url).then((path: string | null) => {\n                if (path) {\n                    resolve({\n                        success: true,\n                        data: {\n                            url: url,\n                            path: path,\n                            message: 'Asset path retrieved successfully'\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: 'Asset path not found' });\n                }\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async queryAssetUuid(url: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-uuid', url).then((uuid: string | null) => {\n                if (uuid) {\n                    resolve({\n                        success: true,\n                        data: {\n                            url: url,\n                            uuid: uuid,\n                            message: 'Asset UUID retrieved successfully'\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: 'Asset UUID not found' });\n                }\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async queryAssetUrl(uuid: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-url', uuid).then((url: string | null) => {\n                if (url) {\n                    resolve({\n                        success: true,\n                        data: {\n                            uuid: uuid,\n                            url: url,\n                            message: 'Asset URL retrieved successfully'\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: 'Asset URL not found' });\n                }\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/scene-tools.js b/dist/tools/scene-tools.js new file mode 100644 index 0000000..023471a --- /dev/null +++ b/dist/tools/scene-tools.js @@ -0,0 +1,450 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.SceneTools = void 0; +class SceneTools { + getTools() { + return [ + { + name: 'get_current_scene', + description: 'Get current scene information', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_scene_list', + description: 'Get all scenes in the project', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'open_scene', + description: 'Open a scene by path', + inputSchema: { + type: 'object', + properties: { + scenePath: { + type: 'string', + description: 'The scene file path' + } + }, + required: ['scenePath'] + } + }, + { + name: 'save_scene', + description: 'Save current scene', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'create_scene', + description: 'Create a new scene asset', + inputSchema: { + type: 'object', + properties: { + sceneName: { + type: 'string', + description: 'Name of the new scene' + }, + savePath: { + type: 'string', + description: 'Path to save the scene (e.g., db://assets/scenes/NewScene.scene)' + } + }, + required: ['sceneName', 'savePath'] + } + }, + { + name: 'save_scene_as', + description: 'Save scene as new file', + inputSchema: { + type: 'object', + properties: { + path: { + type: 'string', + description: 'Path to save the scene' + } + }, + required: ['path'] + } + }, + { + name: 'close_scene', + description: 'Close current scene', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_scene_hierarchy', + description: 'Get the complete hierarchy of current scene', + inputSchema: { + type: 'object', + properties: { + includeComponents: { + type: 'boolean', + description: 'Include component information', + default: false + } + } + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'get_current_scene': + return await this.getCurrentScene(); + case 'get_scene_list': + return await this.getSceneList(); + case 'open_scene': + return await this.openScene(args.scenePath); + case 'save_scene': + return await this.saveScene(); + case 'create_scene': + return await this.createScene(args.sceneName, args.savePath); + case 'save_scene_as': + return await this.saveSceneAs(args.path); + case 'close_scene': + return await this.closeScene(); + case 'get_scene_hierarchy': + return await this.getSceneHierarchy(args.includeComponents); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + async getCurrentScene() { + return new Promise((resolve) => { + // 直接使用 query-node-tree 来获取场景信息（这个方法已经验证可用） + Editor.Message.request('scene', 'query-node-tree').then((tree) => { + if (tree && tree.uuid) { + resolve({ + success: true, + data: { + name: tree.name || 'Current Scene', + uuid: tree.uuid, + type: tree.type || 'cc.Scene', + active: tree.active !== undefined ? tree.active : true, + nodeCount: tree.children ? tree.children.length : 0 + } + }); + } + else { + resolve({ success: false, error: 'No scene data available' }); + } + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getCurrentSceneInfo', + args: [] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + async getSceneList() { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-assets', { + pattern: 'db://assets/**/*.scene' + }).then((results) => { + const scenes = results.map(asset => ({ + name: asset.name, + path: asset.url, + uuid: asset.uuid + })); + resolve({ success: true, data: scenes }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async openScene(scenePath) { + return new Promise((resolve) => { + // 首先获取场景的UUID + Editor.Message.request('asset-db', 'query-uuid', scenePath).then((uuid) => { + if (!uuid) { + throw new Error('Scene not found'); + } + // 使用正确的 scene API 打开场景 (需要UUID) + return Editor.Message.request('scene', 'open-scene', uuid); + }).then(() => { + resolve({ success: true, message: `Scene opened: ${scenePath}` }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async saveScene() { + return new Promise((resolve) => { + Editor.Message.request('scene', 'save-scene').then(() => { + resolve({ success: true, message: 'Scene saved successfully' }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async createScene(sceneName, savePath) { + return new Promise((resolve) => { + // 确保路径以.scene结尾 + const fullPath = savePath.endsWith('.scene') ? savePath : `${savePath}/${sceneName}.scene`; + // 使用正确的Cocos Creator 3.8场景格式 + const sceneContent = JSON.stringify([ + { + "__type__": "cc.SceneAsset", + "_name": sceneName, + "_objFlags": 0, + "__editorExtras__": {}, + "_native": "", + "scene": { + "__id__": 1 + } + }, + { + "__type__": "cc.Scene", + "_name": sceneName, + "_objFlags": 0, + "__editorExtras__": {}, + "_parent": null, + "_children": [], + "_active": true, + "_components": [], + "_prefab": null, + "_lpos": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "_lrot": { + "__type__": "cc.Quat", + "x": 0, + "y": 0, + "z": 0, + "w": 1 + }, + "_lscale": { + "__type__": "cc.Vec3", + "x": 1, + "y": 1, + "z": 1 + }, + "_mobility": 0, + "_layer": 1073741824, + "_euler": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "autoReleaseAssets": false, + "_globals": { + "__id__": 2 + }, + "_id": "scene" + }, + { + "__type__": "cc.SceneGlobals", + "ambient": { + "__id__": 3 + }, + "skybox": { + "__id__": 4 + }, + "fog": { + "__id__": 5 + }, + "octree": { + "__id__": 6 + } + }, + { + "__type__": "cc.AmbientInfo", + "_skyColorHDR": { + "__type__": "cc.Vec4", + "x": 0.2, + "y": 0.5, + "z": 0.8, + "w": 0.520833 + }, + "_skyColor": { + "__type__": "cc.Vec4", + "x": 0.2, + "y": 0.5, + "z": 0.8, + "w": 0.520833 + }, + "_skyIllumHDR": 20000, + "_skyIllum": 20000, + "_groundAlbedoHDR": { + "__type__": "cc.Vec4", + "x": 0.2, + "y": 0.2, + "z": 0.2, + "w": 1 + }, + "_groundAlbedo": { + "__type__": "cc.Vec4", + "x": 0.2, + "y": 0.2, + "z": 0.2, + "w": 1 + } + }, + { + "__type__": "cc.SkyboxInfo", + "_envLightingType": 0, + "_envmapHDR": null, + "_envmap": null, + "_envmapLodCount": 0, + "_diffuseMapHDR": null, + "_diffuseMap": null, + "_enabled": false, + "_useHDR": true, + "_editableMaterial": null, + "_reflectionHDR": null, + "_reflectionMap": null, + "_rotationAngle": 0 + }, + { + "__type__": "cc.FogInfo", + "_type": 0, + "_fogColor": { + "__type__": "cc.Color", + "r": 200, + "g": 200, + "b": 200, + "a": 255 + }, + "_enabled": false, + "_fogDensity": 0.3, + "_fogStart": 0.5, + "_fogEnd": 300, + "_fogAtten": 5, + "_fogTop": 1.5, + "_fogRange": 1.2, + "_accurate": false + }, + { + "__type__": "cc.OctreeInfo", + "_enabled": false, + "_minPos": { + "__type__": "cc.Vec3", + "x": -1024, + "y": -1024, + "z": -1024 + }, + "_maxPos": { + "__type__": "cc.Vec3", + "x": 1024, + "y": 1024, + "z": 1024 + }, + "_depth": 8 + } + ], null, 2); + Editor.Message.request('asset-db', 'create-asset', fullPath, sceneContent).then((result) => { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + name: sceneName, + message: `Scene '${sceneName}' created successfully` + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async getSceneHierarchy(includeComponents = false) { + return new Promise((resolve) => { + // 优先尝试使用 Editor API 查询场景节点树 + Editor.Message.request('scene', 'query-node-tree').then((tree) => { + if (tree) { + const hierarchy = this.buildHierarchy(tree, includeComponents); + resolve({ + success: true, + data: hierarchy + }); + } + else { + resolve({ success: false, error: 'No scene hierarchy available' }); + } + }).catch((err) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getSceneHierarchy', + args: [includeComponents] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result) => { + resolve(result); + }).catch((err2) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + buildHierarchy(node, includeComponents) { + const nodeInfo = { + uuid: node.uuid, + name: node.name, + type: node.type, + active: node.active, + children: [] + }; + if (includeComponents && node.__comps__) { + nodeInfo.components = node.__comps__.map((comp) => ({ + type: comp.__type__ || 'Unknown', + enabled: comp.enabled !== undefined ? comp.enabled : true + })); + } + if (node.children) { + nodeInfo.children = node.children.map((child) => this.buildHierarchy(child, includeComponents)); + } + return nodeInfo; + } + async saveSceneAs(path) { + return new Promise((resolve) => { + // save-as-scene API 不接受路径参数，会弹出对话框让用户选择 + Editor.Message.request('scene', 'save-as-scene').then(() => { + resolve({ + success: true, + data: { + path: path, + message: `Scene save-as dialog opened` + } + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } + async closeScene() { + return new Promise((resolve) => { + Editor.Message.request('scene', 'close-scene').then(() => { + resolve({ + success: true, + message: 'Scene closed successfully' + }); + }).catch((err) => { + resolve({ success: false, error: err.message }); + }); + }); + } +} +exports.SceneTools = SceneTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scene-tools.js","sourceRoot":"","sources":["../../source/tools/scene-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor, SceneInfo } from '../types';\n\nexport class SceneTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'get_current_scene',\n                description: 'Get current scene information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'get_scene_list',\n                description: 'Get all scenes in the project',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'open_scene',\n                description: 'Open a scene by path',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        scenePath: {\n                            type: 'string',\n                            description: 'The scene file path'\n                        }\n                    },\n                    required: ['scenePath']\n                }\n            },\n            {\n                name: 'save_scene',\n                description: 'Save current scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'create_scene',\n                description: 'Create a new scene asset',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        sceneName: {\n                            type: 'string',\n                            description: 'Name of the new scene'\n                        },\n                        savePath: {\n                            type: 'string',\n                            description: 'Path to save the scene (e.g., db://assets/scenes/NewScene.scene)'\n                        }\n                    },\n                    required: ['sceneName', 'savePath']\n                }\n            },\n            {\n                name: 'save_scene_as',\n                description: 'Save scene as new file',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        path: {\n                            type: 'string',\n                            description: 'Path to save the scene'\n                        }\n                    },\n                    required: ['path']\n                }\n            },\n            {\n                name: 'close_scene',\n                description: 'Close current scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'get_scene_hierarchy',\n                description: 'Get the complete hierarchy of current scene',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        includeComponents: {\n                            type: 'boolean',\n                            description: 'Include component information',\n                            default: false\n                        }\n                    }\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'get_current_scene':\n                return await this.getCurrentScene();\n            case 'get_scene_list':\n                return await this.getSceneList();\n            case 'open_scene':\n                return await this.openScene(args.scenePath);\n            case 'save_scene':\n                return await this.saveScene();\n            case 'create_scene':\n                return await this.createScene(args.sceneName, args.savePath);\n            case 'save_scene_as':\n                return await this.saveSceneAs(args.path);\n            case 'close_scene':\n                return await this.closeScene();\n            case 'get_scene_hierarchy':\n                return await this.getSceneHierarchy(args.includeComponents);\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async getCurrentScene(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 直接使用 query-node-tree 来获取场景信息（这个方法已经验证可用）\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                if (tree && tree.uuid) {\n                    resolve({\n                        success: true,\n                        data: {\n                            name: tree.name || 'Current Scene',\n                            uuid: tree.uuid,\n                            type: tree.type || 'cc.Scene',\n                            active: tree.active !== undefined ? tree.active : true,\n                            nodeCount: tree.children ? tree.children.length : 0\n                        }\n                    });\n                } else {\n                    resolve({ success: false, error: 'No scene data available' });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getCurrentSceneInfo',\n                    args: []\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private async getSceneList(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('asset-db', 'query-assets', {\n                pattern: 'db://assets/**/*.scene'\n            }).then((results: any[]) => {\n                const scenes: SceneInfo[] = results.map(asset => ({\n                    name: asset.name,\n                    path: asset.url,\n                    uuid: asset.uuid\n                }));\n                resolve({ success: true, data: scenes });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async openScene(scenePath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 首先获取场景的UUID\n            Editor.Message.request('asset-db', 'query-uuid', scenePath).then((uuid: string | null) => {\n                if (!uuid) {\n                    throw new Error('Scene not found');\n                }\n                \n                // 使用正确的 scene API 打开场景 (需要UUID)\n                return Editor.Message.request('scene', 'open-scene', uuid);\n            }).then(() => {\n                resolve({ success: true, message: `Scene opened: ${scenePath}` });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async saveScene(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'save-scene').then(() => {\n                resolve({ success: true, message: 'Scene saved successfully' });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async createScene(sceneName: string, savePath: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 确保路径以.scene结尾\n            const fullPath = savePath.endsWith('.scene') ? savePath : `${savePath}/${sceneName}.scene`;\n            \n            // 使用正确的Cocos Creator 3.8场景格式\n            const sceneContent = JSON.stringify([\n                {\n                    \"__type__\": \"cc.SceneAsset\",\n                    \"_name\": sceneName,\n                    \"_objFlags\": 0,\n                    \"__editorExtras__\": {},\n                    \"_native\": \"\",\n                    \"scene\": {\n                        \"__id__\": 1\n                    }\n                },\n                {\n                    \"__type__\": \"cc.Scene\",\n                    \"_name\": sceneName,\n                    \"_objFlags\": 0,\n                    \"__editorExtras__\": {},\n                    \"_parent\": null,\n                    \"_children\": [],\n                    \"_active\": true,\n                    \"_components\": [],\n                    \"_prefab\": null,\n                    \"_lpos\": {\n                        \"__type__\": \"cc.Vec3\",\n                        \"x\": 0,\n                        \"y\": 0,\n                        \"z\": 0\n                    },\n                    \"_lrot\": {\n                        \"__type__\": \"cc.Quat\",\n                        \"x\": 0,\n                        \"y\": 0,\n                        \"z\": 0,\n                        \"w\": 1\n                    },\n                    \"_lscale\": {\n                        \"__type__\": \"cc.Vec3\",\n                        \"x\": 1,\n                        \"y\": 1,\n                        \"z\": 1\n                    },\n                    \"_mobility\": 0,\n                    \"_layer\": 1073741824,\n                    \"_euler\": {\n                        \"__type__\": \"cc.Vec3\",\n                        \"x\": 0,\n                        \"y\": 0,\n                        \"z\": 0\n                    },\n                    \"autoReleaseAssets\": false,\n                    \"_globals\": {\n                        \"__id__\": 2\n                    },\n                    \"_id\": \"scene\"\n                },\n                {\n                    \"__type__\": \"cc.SceneGlobals\",\n                    \"ambient\": {\n                        \"__id__\": 3\n                    },\n                    \"skybox\": {\n                        \"__id__\": 4\n                    },\n                    \"fog\": {\n                        \"__id__\": 5\n                    },\n                    \"octree\": {\n                        \"__id__\": 6\n                    }\n                },\n                {\n                    \"__type__\": \"cc.AmbientInfo\",\n                    \"_skyColorHDR\": {\n                        \"__type__\": \"cc.Vec4\",\n                        \"x\": 0.2,\n                        \"y\": 0.5,\n                        \"z\": 0.8,\n                        \"w\": 0.520833\n                    },\n                    \"_skyColor\": {\n                        \"__type__\": \"cc.Vec4\",\n                        \"x\": 0.2,\n                        \"y\": 0.5,\n                        \"z\": 0.8,\n                        \"w\": 0.520833\n                    },\n                    \"_skyIllumHDR\": 20000,\n                    \"_skyIllum\": 20000,\n                    \"_groundAlbedoHDR\": {\n                        \"__type__\": \"cc.Vec4\",\n                        \"x\": 0.2,\n                        \"y\": 0.2,\n                        \"z\": 0.2,\n                        \"w\": 1\n                    },\n                    \"_groundAlbedo\": {\n                        \"__type__\": \"cc.Vec4\",\n                        \"x\": 0.2,\n                        \"y\": 0.2,\n                        \"z\": 0.2,\n                        \"w\": 1\n                    }\n                },\n                {\n                    \"__type__\": \"cc.SkyboxInfo\",\n                    \"_envLightingType\": 0,\n                    \"_envmapHDR\": null,\n                    \"_envmap\": null,\n                    \"_envmapLodCount\": 0,\n                    \"_diffuseMapHDR\": null,\n                    \"_diffuseMap\": null,\n                    \"_enabled\": false,\n                    \"_useHDR\": true,\n                    \"_editableMaterial\": null,\n                    \"_reflectionHDR\": null,\n                    \"_reflectionMap\": null,\n                    \"_rotationAngle\": 0\n                },\n                {\n                    \"__type__\": \"cc.FogInfo\",\n                    \"_type\": 0,\n                    \"_fogColor\": {\n                        \"__type__\": \"cc.Color\",\n                        \"r\": 200,\n                        \"g\": 200,\n                        \"b\": 200,\n                        \"a\": 255\n                    },\n                    \"_enabled\": false,\n                    \"_fogDensity\": 0.3,\n                    \"_fogStart\": 0.5,\n                    \"_fogEnd\": 300,\n                    \"_fogAtten\": 5,\n                    \"_fogTop\": 1.5,\n                    \"_fogRange\": 1.2,\n                    \"_accurate\": false\n                },\n                {\n                    \"__type__\": \"cc.OctreeInfo\",\n                    \"_enabled\": false,\n                    \"_minPos\": {\n                        \"__type__\": \"cc.Vec3\",\n                        \"x\": -1024,\n                        \"y\": -1024,\n                        \"z\": -1024\n                    },\n                    \"_maxPos\": {\n                        \"__type__\": \"cc.Vec3\",\n                        \"x\": 1024,\n                        \"y\": 1024,\n                        \"z\": 1024\n                    },\n                    \"_depth\": 8\n                }\n            ], null, 2);\n            \n            Editor.Message.request('asset-db', 'create-asset', fullPath, sceneContent).then((result: any) => {\n                resolve({\n                    success: true,\n                    data: {\n                        uuid: result.uuid,\n                        url: result.url,\n                        name: sceneName,\n                        message: `Scene '${sceneName}' created successfully`\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async getSceneHierarchy(includeComponents: boolean = false): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // 优先尝试使用 Editor API 查询场景节点树\n            Editor.Message.request('scene', 'query-node-tree').then((tree: any) => {\n                if (tree) {\n                    const hierarchy = this.buildHierarchy(tree, includeComponents);\n                    resolve({\n                        success: true,\n                        data: hierarchy\n                    });\n                } else {\n                    resolve({ success: false, error: 'No scene hierarchy available' });\n                }\n            }).catch((err: Error) => {\n                // 备用方案：使用场景脚本\n                const options = {\n                    name: 'cocos-mcp-server',\n                    method: 'getSceneHierarchy',\n                    args: [includeComponents]\n                };\n                \n                Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => {\n                    resolve(result);\n                }).catch((err2: Error) => {\n                    resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` });\n                });\n            });\n        });\n    }\n\n    private buildHierarchy(node: any, includeComponents: boolean): any {\n        const nodeInfo: any = {\n            uuid: node.uuid,\n            name: node.name,\n            type: node.type,\n            active: node.active,\n            children: []\n        };\n\n        if (includeComponents && node.__comps__) {\n            nodeInfo.components = node.__comps__.map((comp: any) => ({\n                type: comp.__type__ || 'Unknown',\n                enabled: comp.enabled !== undefined ? comp.enabled : true\n            }));\n        }\n\n        if (node.children) {\n            nodeInfo.children = node.children.map((child: any) => \n                this.buildHierarchy(child, includeComponents)\n            );\n        }\n\n        return nodeInfo;\n    }\n\n    private async saveSceneAs(path: string): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            // save-as-scene API 不接受路径参数，会弹出对话框让用户选择\n            (Editor.Message.request as any)('scene', 'save-as-scene').then(() => {\n                resolve({\n                    success: true,\n                    data: {\n                        path: path,\n                        message: `Scene save-as dialog opened`\n                    }\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n\n    private async closeScene(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            Editor.Message.request('scene', 'close-scene').then(() => {\n                resolve({\n                    success: true,\n                    message: 'Scene closed successfully'\n                });\n            }).catch((err: Error) => {\n                resolve({ success: false, error: err.message });\n            });\n        });\n    }\n}"]} \ No newline at end of file diff --git a/dist/tools/server-tools.js b/dist/tools/server-tools.js new file mode 100644 index 0000000..a8eecec --- /dev/null +++ b/dist/tools/server-tools.js @@ -0,0 +1,247 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ServerTools = void 0; +class ServerTools { + getTools() { + return [ + { + name: 'get_server_info', + description: 'Get server information', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'broadcast_custom_message', + description: 'Broadcast a custom message', + inputSchema: { + type: 'object', + properties: { + message: { + type: 'string', + description: 'Message name' + }, + data: { + description: 'Message data (optional)' + } + }, + required: ['message'] + } + }, + { + name: 'get_editor_version', + description: 'Get editor version information', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_project_name', + description: 'Get current project name', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_project_path', + description: 'Get current project path', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_project_uuid', + description: 'Get current project UUID', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'restart_editor', + description: 'Request to restart the editor', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'quit_editor', + description: 'Request to quit the editor', + inputSchema: { + type: 'object', + properties: {} + } + } + ]; + } + async execute(toolName, args) { + switch (toolName) { + case 'get_server_info': + return await this.getServerInfo(); + case 'broadcast_custom_message': + return await this.broadcastCustomMessage(args.message, args.data); + case 'get_editor_version': + return await this.getEditorVersion(); + case 'get_project_name': + return await this.getProjectName(); + case 'get_project_path': + return await this.getProjectPath(); + case 'get_project_uuid': + return await this.getProjectUuid(); + case 'restart_editor': + return await this.restartEditor(); + case 'quit_editor': + return await this.quitEditor(); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + async getServerInfo() { + return new Promise((resolve) => { + var _a, _b; + try { + const info = { + editorVersion: ((_a = Editor.versions) === null || _a === void 0 ? void 0 : _a.editor) || 'Unknown', + cocosVersion: ((_b = Editor.versions) === null || _b === void 0 ? void 0 : _b.cocos) || 'Unknown', + nodeVersion: process.version, + platform: process.platform, + arch: process.arch, + projectName: Editor.Project.name, + projectPath: Editor.Project.path, + projectUuid: Editor.Project.uuid + }; + resolve({ + success: true, + data: { + server: info, + message: 'Server information retrieved successfully' + } + }); + } + catch (err) { + resolve({ success: false, error: err.message }); + } + }); + } + async broadcastCustomMessage(message, data) { + return new Promise((resolve) => { + try { + if (data !== undefined) { + Editor.Message.broadcast(message, data); + } + else { + Editor.Message.broadcast(message); + } + resolve({ + success: true, + data: { + message: message, + data: data, + result: 'Message broadcasted successfully' + } + }); + } + catch (err) { + resolve({ success: false, error: err.message }); + } + }); + } + async getEditorVersion() { + return new Promise((resolve) => { + var _a, _b; + try { + const version = { + editor: ((_a = Editor.versions) === null || _a === void 0 ? void 0 : _a.editor) || 'Unknown', + cocos: ((_b = Editor.versions) === null || _b === void 0 ? void 0 : _b.cocos) || 'Unknown', + node: process.version + }; + resolve({ + success: true, + data: { + version: version, + message: 'Editor version retrieved successfully' + } + }); + } + catch (err) { + resolve({ success: false, error: err.message }); + } + }); + } + async getProjectName() { + return new Promise((resolve) => { + try { + const name = Editor.Project.name; + resolve({ + success: true, + data: { + name: name, + message: 'Project name retrieved successfully' + } + }); + } + catch (err) { + resolve({ success: false, error: err.message }); + } + }); + } + async getProjectPath() { + return new Promise((resolve) => { + try { + const path = Editor.Project.path; + resolve({ + success: true, + data: { + path: path, + message: 'Project path retrieved successfully' + } + }); + } + catch (err) { + resolve({ success: false, error: err.message }); + } + }); + } + async getProjectUuid() { + return new Promise((resolve) => { + try { + const uuid = Editor.Project.uuid; + resolve({ + success: true, + data: { + uuid: uuid, + message: 'Project UUID retrieved successfully' + } + }); + } + catch (err) { + resolve({ success: false, error: err.message }); + } + }); + } + async restartEditor() { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Editor restart is not supported through MCP API', + instruction: 'Please restart the editor manually or use the editor menu: File > Restart Editor' + }); + }); + } + async quitEditor() { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Editor quit is not supported through MCP API', + instruction: 'Please quit the editor manually or use the editor menu: File > Quit' + }); + }); + } +} +exports.ServerTools = ServerTools; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-tools.js","sourceRoot":"","sources":["../../source/tools/server-tools.ts"],"names":[],"mappings":";;;AAEA,MAAa,WAAW;IACpB,QAAQ;QACJ,OAAO;YACH;gBACI,IAAI,EAAE,iBAAiB;gBACvB,WAAW,EAAE,wBAAwB;gBACrC,WAAW,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE;iBACjB;aACJ;YACD;gBACI,IAAI,EAAE,0BAA0B;gBAChC,WAAW,EAAE,4BAA4B;gBACzC,WAAW,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE;wBACR,OAAO,EAAE;4BACL,IAAI,EAAE,QAAQ;4BACd,WAAW,EAAE,cAAc;yBAC9B;wBACD,IAAI,EAAE;4BACF,WAAW,EAAE,yBAAyB;yBACzC;qBACJ;oBACD,QAAQ,EAAE,CAAC,SAAS,CAAC;iBACxB;aACJ;YACD;gBACI,IAAI,EAAE,oBAAoB;gBAC1B,WAAW,EAAE,gCAAgC;gBAC7C,WAAW,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE;iBACjB;aACJ;YACD;gBACI,IAAI,EAAE,kBAAkB;gBACxB,WAAW,EAAE,0BAA0B;gBACvC,WAAW,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE;iBACjB;aACJ;YACD;gBACI,IAAI,EAAE,kBAAkB;gBACxB,WAAW,EAAE,0BAA0B;gBACvC,WAAW,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE;iBACjB;aACJ;YACD;gBACI,IAAI,EAAE,kBAAkB;gBACxB,WAAW,EAAE,0BAA0B;gBACvC,WAAW,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE;iBACjB;aACJ;YACD;gBACI,IAAI,EAAE,gBAAgB;gBACtB,WAAW,EAAE,+BAA+B;gBAC5C,WAAW,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE;iBACjB;aACJ;YACD;gBACI,IAAI,EAAE,aAAa;gBACnB,WAAW,EAAE,4BAA4B;gBACzC,WAAW,EAAE;oBACT,IAAI,EAAE,QAAQ;oBACd,UAAU,EAAE,EAAE;iBACjB;aACJ;SACJ,CAAC;IACN,CAAC;IAED,KAAK,CAAC,OAAO,CAAC,QAAgB,EAAE,IAAS;QACrC,QAAQ,QAAQ,EAAE,CAAC;YACf,KAAK,iBAAiB;gBAClB,OAAO,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;YACtC,KAAK,0BAA0B;gBAC3B,OAAO,MAAM,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YACtE,KAAK,oBAAoB;gBACrB,OAAO,MAAM,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACzC,KAAK,kBAAkB;gBACnB,OAAO,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YACvC,KAAK,kBAAkB;gBACnB,OAAO,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YACvC,KAAK,kBAAkB;gBACnB,OAAO,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YACvC,KAAK,gBAAgB;gBACjB,OAAO,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;YACtC,KAAK,aAAa;gBACd,OAAO,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;YACnC;gBACI,MAAM,IAAI,KAAK,CAAC,iBAAiB,QAAQ,EAAE,CAAC,CAAC;QACrD,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,aAAa;QACvB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;;YAC3B,IAAI,CAAC;gBACD,MAAM,IAAI,GAAG;oBACT,aAAa,EAAE,CAAA,MAAC,MAAc,CAAC,QAAQ,0CAAE,MAAM,KAAI,SAAS;oBAC5D,YAAY,EAAE,CAAA,MAAC,MAAc,CAAC,QAAQ,0CAAE,KAAK,KAAI,SAAS;oBAC1D,WAAW,EAAE,OAAO,CAAC,OAAO;oBAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ;oBAC1B,IAAI,EAAE,OAAO,CAAC,IAAI;oBAClB,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI;oBAChC,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI;oBAChC,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI;iBACnC,CAAC;gBAEF,OAAO,CAAC;oBACJ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE;wBACF,MAAM,EAAE,IAAI;wBACZ,OAAO,EAAE,2CAA2C;qBACvD;iBACJ,CAAC,CAAC;YACP,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAChB,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACpD,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,KAAK,CAAC,sBAAsB,CAAC,OAAe,EAAE,IAAU;QAC5D,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3B,IAAI,CAAC;gBACD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;oBACrB,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;gBAC5C,CAAC;qBAAM,CAAC;oBACJ,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;gBACtC,CAAC;gBAED,OAAO,CAAC;oBACJ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE;wBACF,OAAO,EAAE,OAAO;wBAChB,IAAI,EAAE,IAAI;wBACV,MAAM,EAAE,kCAAkC;qBAC7C;iBACJ,CAAC,CAAC;YACP,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAChB,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACpD,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,KAAK,CAAC,gBAAgB;QAC1B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;;YAC3B,IAAI,CAAC;gBACD,MAAM,OAAO,GAAG;oBACZ,MAAM,EAAE,CAAA,MAAC,MAAc,CAAC,QAAQ,0CAAE,MAAM,KAAI,SAAS;oBACrD,KAAK,EAAE,CAAA,MAAC,MAAc,CAAC,QAAQ,0CAAE,KAAK,KAAI,SAAS;oBACnD,IAAI,EAAE,OAAO,CAAC,OAAO;iBACxB,CAAC;gBAEF,OAAO,CAAC;oBACJ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE;wBACF,OAAO,EAAE,OAAO;wBAChB,OAAO,EAAE,uCAAuC;qBACnD;iBACJ,CAAC,CAAC;YACP,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAChB,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACpD,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,KAAK,CAAC,cAAc;QACxB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3B,IAAI,CAAC;gBACD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;gBACjC,OAAO,CAAC;oBACJ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE;wBACF,IAAI,EAAE,IAAI;wBACV,OAAO,EAAE,qCAAqC;qBACjD;iBACJ,CAAC,CAAC;YACP,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAChB,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACpD,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,KAAK,CAAC,cAAc;QACxB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3B,IAAI,CAAC;gBACD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;gBACjC,OAAO,CAAC;oBACJ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE;wBACF,IAAI,EAAE,IAAI;wBACV,OAAO,EAAE,qCAAqC;qBACjD;iBACJ,CAAC,CAAC;YACP,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAChB,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACpD,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,KAAK,CAAC,cAAc;QACxB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3B,IAAI,CAAC;gBACD,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;gBACjC,OAAO,CAAC;oBACJ,OAAO,EAAE,IAAI;oBACb,IAAI,EAAE;wBACF,IAAI,EAAE,IAAI;wBACV,OAAO,EAAE,qCAAqC;qBACjD;iBACJ,CAAC,CAAC;YACP,CAAC;YAAC,OAAO,GAAQ,EAAE,CAAC;gBAChB,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;YACpD,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,KAAK,CAAC,aAAa;QACvB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3B,OAAO,CAAC;gBACJ,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,iDAAiD;gBACxD,WAAW,EAAE,kFAAkF;aAClG,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,KAAK,CAAC,UAAU;QACpB,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;YAC3B,OAAO,CAAC;gBACJ,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,8CAA8C;gBACrD,WAAW,EAAE,qEAAqE;aACrF,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACP,CAAC;CACJ;AApPD,kCAoPC","sourcesContent":["import { ToolDefinition, ToolResponse, ToolExecutor } from '../types';\n\nexport class ServerTools implements ToolExecutor {\n    getTools(): ToolDefinition[] {\n        return [\n            {\n                name: 'get_server_info',\n                description: 'Get server information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'broadcast_custom_message',\n                description: 'Broadcast a custom message',\n                inputSchema: {\n                    type: 'object',\n                    properties: {\n                        message: {\n                            type: 'string',\n                            description: 'Message name'\n                        },\n                        data: {\n                            description: 'Message data (optional)'\n                        }\n                    },\n                    required: ['message']\n                }\n            },\n            {\n                name: 'get_editor_version',\n                description: 'Get editor version information',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'get_project_name',\n                description: 'Get current project name',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'get_project_path',\n                description: 'Get current project path',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'get_project_uuid',\n                description: 'Get current project UUID',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'restart_editor',\n                description: 'Request to restart the editor',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            },\n            {\n                name: 'quit_editor',\n                description: 'Request to quit the editor',\n                inputSchema: {\n                    type: 'object',\n                    properties: {}\n                }\n            }\n        ];\n    }\n\n    async execute(toolName: string, args: any): Promise<ToolResponse> {\n        switch (toolName) {\n            case 'get_server_info':\n                return await this.getServerInfo();\n            case 'broadcast_custom_message':\n                return await this.broadcastCustomMessage(args.message, args.data);\n            case 'get_editor_version':\n                return await this.getEditorVersion();\n            case 'get_project_name':\n                return await this.getProjectName();\n            case 'get_project_path':\n                return await this.getProjectPath();\n            case 'get_project_uuid':\n                return await this.getProjectUuid();\n            case 'restart_editor':\n                return await this.restartEditor();\n            case 'quit_editor':\n                return await this.quitEditor();\n            default:\n                throw new Error(`Unknown tool: ${toolName}`);\n        }\n    }\n\n    private async getServerInfo(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                const info = {\n                    editorVersion: (Editor as any).versions?.editor || 'Unknown',\n                    cocosVersion: (Editor as any).versions?.cocos || 'Unknown',\n                    nodeVersion: process.version,\n                    platform: process.platform,\n                    arch: process.arch,\n                    projectName: Editor.Project.name,\n                    projectPath: Editor.Project.path,\n                    projectUuid: Editor.Project.uuid\n                };\n\n                resolve({\n                    success: true,\n                    data: {\n                        server: info,\n                        message: 'Server information retrieved successfully'\n                    }\n                });\n            } catch (err: any) {\n                resolve({ success: false, error: err.message });\n            }\n        });\n    }\n\n    private async broadcastCustomMessage(message: string, data?: any): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                if (data !== undefined) {\n                    Editor.Message.broadcast(message, data);\n                } else {\n                    Editor.Message.broadcast(message);\n                }\n\n                resolve({\n                    success: true,\n                    data: {\n                        message: message,\n                        data: data,\n                        result: 'Message broadcasted successfully'\n                    }\n                });\n            } catch (err: any) {\n                resolve({ success: false, error: err.message });\n            }\n        });\n    }\n\n    private async getEditorVersion(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                const version = {\n                    editor: (Editor as any).versions?.editor || 'Unknown',\n                    cocos: (Editor as any).versions?.cocos || 'Unknown',\n                    node: process.version\n                };\n\n                resolve({\n                    success: true,\n                    data: {\n                        version: version,\n                        message: 'Editor version retrieved successfully'\n                    }\n                });\n            } catch (err: any) {\n                resolve({ success: false, error: err.message });\n            }\n        });\n    }\n\n    private async getProjectName(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                const name = Editor.Project.name;\n                resolve({\n                    success: true,\n                    data: {\n                        name: name,\n                        message: 'Project name retrieved successfully'\n                    }\n                });\n            } catch (err: any) {\n                resolve({ success: false, error: err.message });\n            }\n        });\n    }\n\n    private async getProjectPath(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                const path = Editor.Project.path;\n                resolve({\n                    success: true,\n                    data: {\n                        path: path,\n                        message: 'Project path retrieved successfully'\n                    }\n                });\n            } catch (err: any) {\n                resolve({ success: false, error: err.message });\n            }\n        });\n    }\n\n    private async getProjectUuid(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            try {\n                const uuid = Editor.Project.uuid;\n                resolve({\n                    success: true,\n                    data: {\n                        uuid: uuid,\n                        message: 'Project UUID retrieved successfully'\n                    }\n                });\n            } catch (err: any) {\n                resolve({ success: false, error: err.message });\n            }\n        });\n    }\n\n    private async restartEditor(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Editor restart is not supported through MCP API',\n                instruction: 'Please restart the editor manually or use the editor menu: File > Restart Editor'\n            });\n        });\n    }\n\n    private async quitEditor(): Promise<ToolResponse> {\n        return new Promise((resolve) => {\n            resolve({\n                success: false,\n                error: 'Editor quit is not supported through MCP API',\n                instruction: 'Please quit the editor manually or use the editor menu: File > Quit'\n            });\n        });\n    }\n}"]} \ No newline at end of file diff --git a/dist/types/index.js b/dist/types/index.js new file mode 100644 index 0000000..9fac54f --- /dev/null +++ b/dist/types/index.js @@ -0,0 +1,3 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/i18n/en.js b/i18n/en.js new file mode 100755 index 0000000..d84e586 --- /dev/null +++ b/i18n/en.js @@ -0,0 +1,31 @@ +"use strict"; + +module.exports = { + "extension_name": "Cocos MCP Server", + "description": "AI MCP Server for Cocos Creator 3.8", + "panel_title": "MCP Server", + "open_panel": "Open MCP Panel", + "start_server": "Start Server", + "stop_server": "Stop Server", + "server_status": "Server Status", + "port": "Port", + "settings": "Settings", + "connected": "Connected", + "disconnected": "Disconnected", + "server_running": "Server is running on port {0}", + "server_stopped": "Server has stopped", + "auto_start": "Auto Start", + "debug_log": "Debug Logging", + "max_connections": "Max Connections", + "connection_info": "Connection Info", + "http_url": "HTTP URL", + "copy": "Copy", + "save_settings": "Save Settings", + "settings_saved": "Settings saved successfully", + "server_started": "MCP Server Started", + "server_stopped_msg": "MCP Server Stopped", + "failed_to_start": "Failed to start server", + "failed_to_stop": "Failed to stop server", + "failed_to_save": "Failed to save settings", + "url_copied": "HTTP URL copied to clipboard" +}; \ No newline at end of file diff --git a/i18n/zh.js b/i18n/zh.js new file mode 100755 index 0000000..4b09a1a --- /dev/null +++ b/i18n/zh.js @@ -0,0 +1,31 @@ +"use strict"; + +module.exports = { + "extension_name": "Cocos MCP 服务器", + "description": "适用于 Cocos Creator 3.8 的 AI MCP 服务器", + "panel_title": "MCP 服务器", + "open_panel": "打开 MCP 面板", + "start_server": "启动服务器", + "stop_server": "停止服务器", + "server_status": "服务器状态", + "port": "端口", + "settings": "设置", + "connected": "已连接", + "disconnected": "未连接", + "server_running": "服务器正在端口 {0} 上运行", + "server_stopped": "服务器已停止", + "auto_start": "自动启动", + "debug_log": "调试日志", + "max_connections": "最大连接数", + "connection_info": "连接信息", + "http_url": "HTTP 地址", + "copy": "复制", + "save_settings": "保存设置", + "settings_saved": "设置保存成功", + "server_started": "MCP 服务器已启动", + "server_stopped_msg": "MCP 服务器已停止", + "failed_to_start": "启动服务器失败", + "failed_to_stop": "停止服务器失败", + "failed_to_save": "保存设置失败", + "url_copied": "HTTP 地址已复制到剪贴板" +}; \ No newline at end of file diff --git a/image/iamge2.png b/image/iamge2.png new file mode 100644 index 0000000..849826e Binary files /dev/null and b/image/iamge2.png differ diff --git a/image/image-20250717174157957.png b/image/image-20250717174157957.png new file mode 100644 index 0000000..955bb2a Binary files /dev/null and b/image/image-20250717174157957.png differ diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..da6f4b0 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,166 @@ +{ + "name": "cocos-mcp-server", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "cocos-mcp-server", + "version": "1.0.0", + "hasInstallScript": true, + "dependencies": { + "fs-extra": "^11.3.0", + "uuid": "^9.0.1", + "ws": "^8.14.2" + }, + "devDependencies": { + "@cocos/creator-types": "^3.8.6", + "@types/fs-extra": "^9.0.5", + "@types/node": "^18.17.1", + "@types/uuid": "^9.0.8", + "@types/ws": "^8.5.10", + "typescript": "^5.8.2" + } + }, + "node_modules/@cocos/creator-types": { + "version": "3.8.6", + "resolved": "https://registry.npmjs.org/@cocos/creator-types/-/creator-types-3.8.6.tgz", + "integrity": "sha512-hyZ4aoqqLxoRtKbBLSJM5RgtK3oGOlTEryHDcyH4znq3h9cFk+MSbQC2aJHvK5/bMlJzsZ641/hD77RGSrvo8Q==", + "dev": true, + "license": "ISC" + }, + "node_modules/@types/fs-extra": { + "version": "9.0.13", + "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz", + "integrity": "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/node": { + "version": "18.19.119", + "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.119.tgz", + "integrity": "sha512-d0F6m9itIPaKnrvEMlzE48UjwZaAnFW7Jwibacw9MNdqadjKNpUm9tfJYDwmShJmgqcoqYUX3EMKO1+RWiuuNg==", + "dev": true, + "license": "MIT", + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/@types/uuid": { + "version": "9.0.8", + "resolved": "https://registry.npmjs.org/@types/uuid/-/uuid-9.0.8.tgz", + "integrity": "sha512-jg+97EGIcY9AGHJJRaaPVgetKDsrTgbRjQ5Msgjh/DQKEFl0DtyRr/VCOyD1T2R1MNeWPK/u7JoGhlDZnKBAfA==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/ws": { + "version": "8.18.1", + "resolved": "https://registry.npmjs.org/@types/ws/-/ws-8.18.1.tgz", + "integrity": "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/fs-extra": { + "version": "11.3.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.0.tgz", + "integrity": "sha512-Z4XaCL6dUDHfP/jT25jJKMmtxvuwbkrD1vNSMFlo9lNLY2c5FHYSQgHPRZUjAB26TpDEoW9HCOgplrdbaPV/ew==", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=14.14" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "license": "ISC" + }, + "node_modules/jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/typescript": { + "version": "5.8.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.8.3.tgz", + "integrity": "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "dev": true, + "license": "MIT" + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/uuid": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-9.0.1.tgz", + "integrity": "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA==", + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/ws": { + "version": "8.18.3", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz", + "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + } + } +} diff --git a/package.json b/package.json new file mode 100755 index 0000000..7a1eab8 --- /dev/null +++ b/package.json @@ -0,0 +1,102 @@ +{ + "$schema": "./@types/schema/package/index.json", + "package_version": 2, + "name": "cocos-mcp-server", + "version": "1.0.0", + "author": "Cocos Creator", + "editor": ">=3.8.6", + "scripts": { + "preinstall": "node ./scripts/preinstall.js", + "build": "tsc", + "watch": "tsc -w" + }, + "description": "i18n:cocos-mcp-server.description", + "main": "./dist/main.js", + "dependencies": { + "fs-extra": "^11.3.0", + "uuid": "^9.0.1" + }, + "devDependencies": { + "@cocos/creator-types": "^3.8.6", + "@types/fs-extra": "^9.0.5", + "@types/node": "^18.17.1", + "@types/uuid": "^9.0.8", + "typescript": "^5.8.2" + }, + "panels": { + "default": { + "title": "i18n:cocos-mcp-server.panel_title", + "type": "dockable", + "main": "dist/panels/default", + "icon": "./static/icon.png", + "size": { + "min-width": 400, + "min-height": 300, + "width": 600, + "height": 500 + } + } + }, + "contributions": { + "menu": [ + { + "path": "i18n:menu.extension/Cocos MCP Server", + "label": "i18n:cocos-mcp-server.open_panel", + "message": "open-panel" + } + ], + "messages": { + "open-panel": { + "methods": [ + "openPanel" + ] + }, + "start-server": { + "methods": [ + "startServer" + ] + }, + "stop-server": { + "methods": [ + "stopServer" + ] + }, + "get-server-status": { + "methods": [ + "getServerStatus" + ] + }, + "update-settings": { + "methods": [ + "updateSettings" + ] + }, + "getToolsList": { + "methods": [ + "getToolsList" + ] + }, + "get-server-settings": { + "methods": [ + "getServerSettings" + ] + } + }, + "scene": { + "script": "./dist/scene.js", + "methods": [ + "createNewScene", + "addComponentToNode", + "removeComponentFromNode", + "getNodeInfo", + "getAllNodes", + "findNodeByName", + "setNodeProperty", + "setComponentProperty", + "getCurrentSceneInfo", + "getSceneHierarchy", + "createPrefabFromNode" + ] + } + } +} diff --git a/scripts/preinstall.js b/scripts/preinstall.js new file mode 100755 index 0000000..3876bba --- /dev/null +++ b/scripts/preinstall.js @@ -0,0 +1 @@ +const readFileSync=require("fs")["readFileSync"],join=require("path")["join"],spawnSync=require("child_process")["spawnSync"],PATH={packageJSON:join(__dirname,"../package.json")};function checkCreatorTypesVersion(e){var o="win32"===process.platform?"npm.cmd":"npm";let n=spawnSync(o,["view","@cocos/creator-types","versions"]).stdout.toString();try{n=JSON.parse(listString)}catch(e){}return!!n.includes(e)}try{const e=readFileSync(PATH.packageJSON,"utf8"),f=JSON.parse(e),g=f.devDependencies["@cocos/creator-types"].replace(/^[^\d]+/,"");checkCreatorTypesVersion(g)||(console.log("Warning:"),console.log(" @en"),console.log(" Version check of @cocos/creator-types failed."),console.log(` The definition of ${g} has not been released yet. Please export the definition to the ./node_modules directory by selecting "Developer -> Export Interface Definition" in the menu of the Creator editor.`),console.log(" The definition of the corresponding version will be released on npm after the editor is officially released."),console.log(" @zh"),console.log(" @cocos/creator-types 版本检查失败。"),console.log(` ${g} 定义还未发布，请先通过 Creator 编辑器菜单 "开发者 -> 导出接口定义"，导出定义到 ./node_modules 目录。`),console.log(" 对应版本的定义会在编辑器正式发布后同步发布到 npm 上。"))}catch(e){console.error(e)} \ No newline at end of file diff --git a/source/main.ts b/source/main.ts new file mode 100755 index 0000000..72c09ec --- /dev/null +++ b/source/main.ts @@ -0,0 +1,119 @@ +import { MCPServer } from './mcp-server'; +import { readSettings, saveSettings } from './settings'; +import { MCPServerSettings } from './types'; + +let mcpServer: MCPServer | null = null; + +/** + * @en Registration method for the main process of Extension + * @zh 为扩展的主进程的注册方法 + */ +export const methods: { [key: string]: (...any: any) => any } = { + /** + * @en Open the MCP server panel + * @zh 打开 MCP 服务器面板 + */ + openPanel() { + Editor.Panel.open('cocos-mcp-server'); + }, + + /** + * @en Start the MCP server + * @zh 启动 MCP 服务器 + */ + async startServer() { + if (mcpServer) { + await mcpServer.start(); + } else { + console.warn('[MCP插件] mcpServer 未初始化'); + } + }, + + /** + * @en Stop the MCP server + * @zh 停止 MCP 服务器 + */ + async stopServer() { + if (mcpServer) { + mcpServer.stop(); + } else { + console.warn('[MCP插件] mcpServer 未初始化'); + } + }, + + /** + * @en Get server status + * @zh 获取服务器状态 + */ + getServerStatus() { + return mcpServer ? mcpServer.getStatus() : { running: false, port: 0, clients: 0 }; + }, + + /** + * @en Update server settings + * @zh 更新服务器设置 + */ + updateSettings(settings: MCPServerSettings) { + saveSettings(settings); + if (mcpServer) { + mcpServer.stop(); + mcpServer = new MCPServer(settings); + mcpServer.start(); + } else { + mcpServer = new MCPServer(settings); + mcpServer.start(); + } + }, + + /** + * @en Get tools list + * @zh 获取工具列表 + */ + getToolsList() { + return mcpServer ? mcpServer.getAvailableTools() : []; + }, + /** + * @en Get server settings + * @zh 获取服务器设置 + */ + getServerSettings() { + return mcpServer ? mcpServer.getSettings() : readSettings(); + } +}; + +/** + * @en Method Triggered on Extension Startup + * @zh 扩展启动时触发的方法 + */ +export function load() { + console.log('[MCP Plugin] Loading MCP server plugin...'); + try { + const settings = readSettings(); + console.log('[MCP Plugin] Settings loaded:', settings); + mcpServer = new MCPServer(settings); + + // 如果设置了自动启动，则启动服务器 + if (settings.autoStart) { + console.log('[MCP Plugin] Auto-starting MCP server...'); + mcpServer.start().catch(error => { + console.error('[MCP Plugin] Failed to auto-start server:', error); + }); + } else { + console.log('[MCP Plugin] MCP server created but not started (autoStart=false)'); + console.log('[MCP Plugin] Use the MCP panel or call startServer() to start the server'); + } + } catch (error) { + console.error('[MCP Plugin] Failed to load MCP server:', error); + } +} + +/** + * @en Method triggered when uninstalling the extension + * @zh 卸载扩展时触发的方法 + */ +export function unload() { + if (mcpServer) { + mcpServer.stop(); + mcpServer = null; + } +} \ No newline at end of file diff --git a/source/mcp-server.ts b/source/mcp-server.ts new file mode 100644 index 0000000..683c939 --- /dev/null +++ b/source/mcp-server.ts @@ -0,0 +1,257 @@ +import * as http from 'http'; +import * as url from 'url'; +import { v4 as uuidv4 } from 'uuid'; +import { MCPServerSettings, ServerStatus, MCPClient, ToolDefinition } from './types'; +import { SceneTools } from './tools/scene-tools'; +import { NodeTools } from './tools/node-tools'; +import { ComponentTools } from './tools/component-tools'; +import { PrefabTools } from './tools/prefab-tools'; +import { ProjectTools } from './tools/project-tools'; +import { DebugTools } from './tools/debug-tools'; +import { PreferencesTools } from './tools/preferences-tools'; +import { ServerTools } from './tools/server-tools'; +import { BroadcastTools } from './tools/broadcast-tools'; + +export class MCPServer { + private settings: MCPServerSettings; + private httpServer: http.Server | null = null; + private clients: Map = new Map(); + private tools: Record = {}; + private toolsList: ToolDefinition[] = []; + + constructor(settings: MCPServerSettings) { + this.settings = settings; + this.initializeTools(); + } + + private initializeTools(): void { + try { + console.log('[MCPServer] Initializing tools...'); + this.tools.scene = new SceneTools(); + this.tools.node = new NodeTools(); + this.tools.component = new ComponentTools(); + this.tools.prefab = new PrefabTools(); + this.tools.project = new ProjectTools(); + this.tools.debug = new DebugTools(); + this.tools.preferences = new PreferencesTools(); + this.tools.server = new ServerTools(); + this.tools.broadcast = new BroadcastTools(); + console.log('[MCPServer] Tools initialized successfully'); + } catch (error) { + console.error('[MCPServer] Error initializing tools:', error); + throw error; + } + } + + public async start(): Promise { + if (this.httpServer) { + console.log('[MCPServer] Server is already running'); + return; + } + + try { + console.log(`[MCPServer] Starting HTTP server on port ${this.settings.port}...`); + this.httpServer = http.createServer(this.handleHttpRequest.bind(this)); + + await new Promise((resolve, reject) => { + this.httpServer!.listen(this.settings.port, '127.0.0.1', () => { + console.log(`[MCPServer] ✅ HTTP server started successfully on http://127.0.0.1:${this.settings.port}`); + console.log(`[MCPServer] Health check: http://127.0.0.1:${this.settings.port}/health`); + console.log(`[MCPServer] MCP endpoint: http://127.0.0.1:${this.settings.port}/mcp`); + resolve(); + }); + this.httpServer!.on('error', (err: any) => { + console.error('[MCPServer] ❌ Failed to start server:', err); + if (err.code === 'EADDRINUSE') { + console.error(`[MCPServer] Port ${this.settings.port} is already in use. Please change the port in settings.`); + } + reject(err); + }); + }); + + this.setupTools(); + console.log('[MCPServer] 🚀 MCP Server is ready for connections'); + } catch (error) { + console.error('[MCPServer] ❌ Failed to start server:', error); + throw error; + } + } + + private setupTools(): void { + this.toolsList = []; + + for (const [category, toolSet] of Object.entries(this.tools)) { + const tools = toolSet.getTools(); + for (const tool of tools) { + this.toolsList.push({ + name: `${category}_${tool.name}`, + description: tool.description, + inputSchema: tool.inputSchema + }); + } + } + + } + + public async executeToolCall(toolName: string, args: any): Promise { + const parts = toolName.split('_'); + const category = parts[0]; + const toolMethodName = parts.slice(1).join('_'); + + if (this.tools[category]) { + return await this.tools[category].execute(toolMethodName, args); + } + + throw new Error(`Tool ${toolName} not found`); + } + + public getClients(): MCPClient[] { + return Array.from(this.clients.values()); + } + public getAvailableTools(): ToolDefinition[] { + return this.toolsList; + } + + public getSettings(): MCPServerSettings { + return this.settings; + } + + private async handleHttpRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise { + const parsedUrl = url.parse(req.url || '', true); + const pathname = parsedUrl.pathname; + + // Set CORS headers + res.setHeader('Access-Control-Allow-Origin', '*'); + res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS'); + res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization'); + res.setHeader('Content-Type', 'application/json'); + + if (req.method === 'OPTIONS') { + res.writeHead(200); + res.end(); + return; + } + + try { + if (pathname === '/mcp' && req.method === 'POST') { + await this.handleMCPRequest(req, res); + } else if (pathname === '/health' && req.method === 'GET') { + res.writeHead(200); + res.end(JSON.stringify({ status: 'ok', tools: this.toolsList.length })); + } else { + res.writeHead(404); + res.end(JSON.stringify({ error: 'Not found' })); + } + } catch (error) { + console.error('HTTP request error:', error); + res.writeHead(500); + res.end(JSON.stringify({ error: 'Internal server error' })); + } + } + + private async handleMCPRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise { + let body = ''; + + req.on('data', (chunk) => { + body += chunk.toString(); + }); + + req.on('end', async () => { + try { + const message = JSON.parse(body); + const response = await this.handleMessage(message); + res.writeHead(200); + res.end(JSON.stringify(response)); + } catch (error) { + console.error('Error handling MCP request:', error); + res.writeHead(400); + res.end(JSON.stringify({ + jsonrpc: '2.0', + id: null, + error: { + code: -32700, + message: 'Parse error' + } + })); + } + }); + } + + private async handleMessage(message: any): Promise { + const { id, method, params } = message; + + try { + let result: any; + + switch (method) { + case 'tools/list': + result = { tools: this.getAvailableTools() }; + break; + case 'tools/call': + const { name, arguments: args } = params; + const toolResult = await this.executeToolCall(name, args); + result = { content: [{ type: 'text', text: JSON.stringify(toolResult) }] }; + break; + case 'initialize': + // MCP initialization + result = { + protocolVersion: '2024-11-05', + capabilities: { + tools: {} + }, + serverInfo: { + name: 'cocos-mcp-server', + version: '1.0.0' + } + }; + break; + default: + throw new Error(`Unknown method: ${method}`); + } + + return { + jsonrpc: '2.0', + id, + result + }; + } catch (error: any) { + return { + jsonrpc: '2.0', + id, + error: { + code: -32603, + message: error.message + } + }; + } + } + + public stop(): void { + if (this.httpServer) { + this.httpServer.close(); + this.httpServer = null; + console.log('[MCPServer] HTTP server stopped'); + } + + this.clients.clear(); + } + + public getStatus(): ServerStatus { + return { + running: !!this.httpServer, + port: this.settings.port, + clients: 0 // HTTP is stateless, no persistent clients + }; + } + + public updateSettings(settings: MCPServerSettings) { + this.settings = settings; + if (this.httpServer) { + this.stop(); + this.start(); + } + } +} + +// HTTP transport doesn't need persistent connections +// MCP over HTTP uses request-response pattern \ No newline at end of file diff --git a/source/panels/default/index.ts b/source/panels/default/index.ts new file mode 100644 index 0000000..e150e57 --- /dev/null +++ b/source/panels/default/index.ts @@ -0,0 +1,229 @@ +import { readSettings } from '../../settings'; +import { readFileSync } from 'fs-extra'; +import { join } from 'path'; + +/** + * @zh 如果希望兼容 3.3 之前的版本可以使用下方的代码 + * @en You can add the code below if you want compatibility with versions prior to 3.3 + */ +// Editor.Panel.define = Editor.Panel.define || function(options: any) { return options } + +module.exports = Editor.Panel.define({ + listeners: { + show() { console.log('MCP Server panel shown'); }, + hide() { console.log('MCP Server panel hidden'); } + }, + template: readFileSync(join(__dirname, '../../../static/template/default/index.html'), 'utf-8'), + style: readFileSync(join(__dirname, '../../../static/style/default/index.css'), 'utf-8'), + $: { + panelTitle: '#panelTitle', + serverStatusLabel: '#serverStatusLabel', + serverStatusLabelProp: '#serverStatusLabelProp', + serverStatusValue: '#serverStatusValue', + connectedLabel: '#connectedLabel', + connectedClients: '#connectedClients', + toggleServerBtn: '#toggleServerBtn', + settingsLabel: '#settingsLabel', + portLabel: '#portLabel', + autoStartLabel: '#autoStartLabel', + debugLogLabel: '#debugLogLabel', + maxConnectionsLabel: '#maxConnectionsLabel', + connectionInfoLabel: '#connectionInfoLabel', + httpUrlLabel: '#httpUrlLabel', + httpUrlInput: '#httpUrlInput', + copyBtn: '#copyBtn', + saveSettingsBtn: '#saveSettingsBtn', + // 新增输入控件id + portInput: '#portInput', + maxConnInput: '#maxConnInput', + autoStartInput: '#autoStartInput', + debugLogInput: '#debugLogInput', + }, + methods: { + async updateServerStatus(this: any) { + try { + const status = await Editor.Message.request('cocos-mcp-server', 'get-server-status'); + this.serverRunning = status.running; + this.connectedClients = status.clients || 0; + this.serverStatus = this.serverRunning ? + Editor.I18n.t('cocos-mcp-server.connected') : + Editor.I18n.t('cocos-mcp-server.disconnected'); + this.statusClass = this.serverRunning ? 'running' : 'stopped'; + this.buttonText = this.serverRunning ? + Editor.I18n.t('cocos-mcp-server.stop_server') : + Editor.I18n.t('cocos-mcp-server.start_server'); + // 刷新UI + this.$.serverStatusValue.innerText = this.serverStatus; + this.$.connectedClients.innerText = this.connectedClients; + this.$.toggleServerBtn.innerText = this.buttonText; + if (this.serverRunning) { + this.httpUrl = `http://localhost:${this.settings.port}/mcp`; + this.$.httpUrlInput.value = this.httpUrl; + } else { + this.httpUrl = ''; + this.$.httpUrlInput.value = ''; + } + } catch (err) { + console.error('Failed to update server status:', err); + } + }, + + async toggleServer(this: any) { + this.isProcessing = true; + try { + if (this.serverRunning) { + await this.stopServer(); + } else { + await this.startServer(); + } + } finally { + this.isProcessing = false; + } + }, + + async startServer(this: any) { + try { + await Editor.Message.request('cocos-mcp-server', 'start-server'); + Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.server_started'), { + detail: Editor.I18n.t('cocos-mcp-server.server_running').replace('{0}', this.settings.port.toString()) + }); + await this.updateServerStatus(); + } catch (err: any) { + Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_start'), err.message); + } + }, + + async stopServer(this: any) { + try { + await Editor.Message.request('cocos-mcp-server', 'stop-server'); + Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.server_stopped_msg'), { + detail: Editor.I18n.t('cocos-mcp-server.server_stopped') + }); + await this.updateServerStatus(); + } catch (err: any) { + Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_stop'), err.message); + } + }, + + async saveSettings(this: any) { + try { + // 直接用 this.$ 获取所有输入控件的当前值 + const port = this.$.portInput ? Number((this.$.portInput as any).value) : 3000; + const maxConnections = this.$.maxConnInput ? Number((this.$.maxConnInput as any).value) : 10; + const autoStart = this.$.autoStartInput ? !!(this.$.autoStartInput as any).checked : false; + const enableDebugLog = this.$.debugLogInput ? !!(this.$.debugLogInput as any).checked : false; + // 组装 settings + const settings = { + ...this.settings, + port, + maxConnections, + autoStart, + enableDebugLog, + }; + await Editor.Message.request('cocos-mcp-server', 'update-settings', settings); + // 重新拉取设置 + const newSettings = await Editor.Message.request('cocos-mcp-server', 'get-server-settings'); + this.settings = newSettings; + this.originalSettings = JSON.stringify(newSettings); + Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.settings_saved')); + } catch (err: any) { + Editor.Dialog.error(Editor.I18n.t('cocos-mcp-server.failed_to_save'), err.message); + } + }, + + copyUrl(this: any) { + Editor.Clipboard.write('text', this.httpUrl); + Editor.Dialog.info(Editor.I18n.t('cocos-mcp-server.url_copied')); + }, + + settingsChanged(this: any) { + return JSON.stringify(this.settings) !== this.originalSettings; + }, + bindSettingsEvents(this: any) { + // 端口输入框 + const portInput = document.querySelectorAll('ui-num-input[slot="content"]')[0]; + if (portInput) { + portInput.addEventListener('change', (e: any) => { + this.settings.port = Number(e.detail.value); + }); + } + // 最大连接数 + const maxConnInput = document.querySelectorAll('ui-num-input[slot="content"]')[1]; + if (maxConnInput) { + maxConnInput.addEventListener('change', (e: any) => { + this.settings.maxConnections = Number(e.detail.value); + }); + } + // 复选框 + const checkboxes = document.querySelectorAll('ui-checkbox[slot="content"]'); + if (checkboxes && checkboxes.length >= 2) { + checkboxes[0].addEventListener('change', (e: any) => { + this.settings.autoStart = !!e.detail.value; + }); + checkboxes[1].addEventListener('change', (e: any) => { + this.settings.enableDebugLog = !!e.detail.value; + }); + } + }, + + }, + ready() { + Editor.Message.request('cocos-mcp-server', 'get-server-settings').then((settings) => { + this.settings = settings; + this.originalSettings = JSON.stringify(settings); + // 本地化label赋值 + this.$.panelTitle.innerText = Editor.I18n.t('cocos-mcp-server.panel_title'); + this.$.serverStatusLabel.innerText = Editor.I18n.t('cocos-mcp-server.server_status'); + this.$.serverStatusLabelProp.innerText = Editor.I18n.t('cocos-mcp-server.server_status'); + this.$.connectedLabel.innerText = Editor.I18n.t('cocos-mcp-server.connected'); + this.$.settingsLabel.innerText = Editor.I18n.t('cocos-mcp-server.settings'); + this.$.portLabel.innerText = Editor.I18n.t('cocos-mcp-server.port'); + this.$.autoStartLabel.innerText = Editor.I18n.t('cocos-mcp-server.auto_start'); + this.$.debugLogLabel.innerText = Editor.I18n.t('cocos-mcp-server.debug_log'); + this.$.maxConnectionsLabel.innerText = Editor.I18n.t('cocos-mcp-server.max_connections'); + this.$.connectionInfoLabel.innerText = Editor.I18n.t('cocos-mcp-server.connection_info'); + this.$.httpUrlLabel.innerText = Editor.I18n.t('cocos-mcp-server.http_url'); + this.$.copyBtn.innerText = Editor.I18n.t('cocos-mcp-server.copy'); + this.$.saveSettingsBtn.innerText = Editor.I18n.t('cocos-mcp-server.save_settings'); + // 动态内容初始化 + this.$.serverStatusValue.innerText = ''; + this.$.connectedClients.innerText = ''; + this.$.toggleServerBtn.innerText = ''; + this.$.httpUrlInput.value = ''; + // 绑定按钮事件 + this.$.toggleServerBtn.addEventListener('confirm', this.toggleServer.bind(this)); + this.$.saveSettingsBtn.addEventListener('confirm', this.saveSettings.bind(this)); + this.$.copyBtn.addEventListener('confirm', this.copyUrl.bind(this)); + // 延迟绑定事件，确保 UI 组件已渲染 + setTimeout(() => { + this.bindSettingsEvents(); + }, 100); + // Set up periodic status updates + (this as any).statusInterval = setInterval(() => { + (this as any).updateServerStatus(); + }, 2000); + // 不再自动启动服务器，用户点击才启动 + (this as any).updateServerStatus(); + }); + }, + beforeClose() { + if ((this as any).statusInterval) { + clearInterval((this as any).statusInterval); + } + }, + close() { + // Panel close cleanup + }, + + // Direct properties for data access + serverRunning: false, + connectedClients: 0, + serverStatus: '', + statusClass: 'stopped', + buttonText: '', + isProcessing: false, + settings: {}, + httpUrl: '', + statusInterval: null as any, + originalSettings: '' +} as any); \ No newline at end of file diff --git a/source/scene.ts b/source/scene.ts new file mode 100644 index 0000000..6b080d2 --- /dev/null +++ b/source/scene.ts @@ -0,0 +1,435 @@ +import { join } from 'path'; +module.paths.push(join(Editor.App.path, 'node_modules')); + +export const methods: { [key: string]: (...any: any) => any } = { + /** + * Create a new scene + */ + createNewScene() { + try { + const { director, Scene } = require('cc'); + const scene = new Scene(); + scene.name = 'New Scene'; + director.runScene(scene); + return { success: true, message: 'New scene created successfully' }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Add component to a node + */ + addComponentToNode(nodeUuid: string, componentType: string) { + try { + const { director, js } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + // Find node by UUID + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + + // Get component class + const ComponentClass = js.getClassByName(componentType); + if (!ComponentClass) { + return { success: false, error: `Component type ${componentType} not found` }; + } + + // Add component + const component = node.addComponent(ComponentClass); + return { + success: true, + message: `Component ${componentType} added successfully`, + data: { componentId: component.uuid } + }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Remove component from a node + */ + removeComponentFromNode(nodeUuid: string, componentType: string) { + try { + const { director, js } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + + const ComponentClass = js.getClassByName(componentType); + if (!ComponentClass) { + return { success: false, error: `Component type ${componentType} not found` }; + } + + const component = node.getComponent(ComponentClass); + if (!component) { + return { success: false, error: `Component ${componentType} not found on node` }; + } + + node.removeComponent(component); + return { success: true, message: `Component ${componentType} removed successfully` }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Create a new node + */ + createNode(name: string, parentUuid?: string) { + try { + const { director, Node } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + const node = new Node(name); + + if (parentUuid) { + const parent = scene.getChildByUuid(parentUuid); + if (parent) { + parent.addChild(node); + } else { + scene.addChild(node); + } + } else { + scene.addChild(node); + } + + return { + success: true, + message: `Node ${name} created successfully`, + data: { uuid: node.uuid, name: node.name } + }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Get node information + */ + getNodeInfo(nodeUuid: string) { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + + return { + success: true, + data: { + uuid: node.uuid, + name: node.name, + active: node.active, + position: node.position, + rotation: node.rotation, + scale: node.scale, + parent: node.parent?.uuid, + children: node.children.map((child: any) => child.uuid), + components: node.components.map((comp: any) => ({ + type: comp.constructor.name, + enabled: comp.enabled + })) + } + }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Get all nodes in scene + */ + getAllNodes() { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + const nodes: any[] = []; + const collectNodes = (node: any) => { + nodes.push({ + uuid: node.uuid, + name: node.name, + active: node.active, + parent: node.parent?.uuid + }); + + node.children.forEach((child: any) => collectNodes(child)); + }; + + scene.children.forEach((child: any) => collectNodes(child)); + + return { success: true, data: nodes }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Find node by name + */ + findNodeByName(name: string) { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + const node = scene.getChildByName(name); + if (!node) { + return { success: false, error: `Node with name ${name} not found` }; + } + + return { + success: true, + data: { + uuid: node.uuid, + name: node.name, + active: node.active, + position: node.position + } + }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Get current scene information + */ + getCurrentSceneInfo() { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + return { + success: true, + data: { + name: scene.name, + uuid: scene.uuid, + nodeCount: scene.children.length + } + }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Set node property + */ + setNodeProperty(nodeUuid: string, property: string, value: any) { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + + // 设置属性 + if (property === 'position') { + node.setPosition(value.x || 0, value.y || 0, value.z || 0); + } else if (property === 'rotation') { + node.setRotationFromEuler(value.x || 0, value.y || 0, value.z || 0); + } else if (property === 'scale') { + node.setScale(value.x || 1, value.y || 1, value.z || 1); + } else if (property === 'active') { + node.active = value; + } else if (property === 'name') { + node.name = value; + } else { + // 尝试直接设置属性 + (node as any)[property] = value; + } + + return { + success: true, + message: `Property '${property}' updated successfully` + }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Get scene hierarchy + */ + getSceneHierarchy(includeComponents: boolean = false) { + try { + const { director } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + const processNode = (node: any): any => { + const result: any = { + name: node.name, + uuid: node.uuid, + active: node.active, + children: [] + }; + + if (includeComponents) { + result.components = node.components.map((comp: any) => ({ + type: comp.constructor.name, + enabled: comp.enabled + })); + } + + if (node.children && node.children.length > 0) { + result.children = node.children.map((child: any) => processNode(child)); + } + + return result; + }; + + const hierarchy = scene.children.map((child: any) => processNode(child)); + return { success: true, data: hierarchy }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Create prefab from node + */ + createPrefabFromNode(nodeUuid: string, prefabPath: string) { + try { + const { director, instantiate } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + + // 注意：这里只是一个模拟实现，因为运行时环境下无法直接创建预制体文件 + // 真正的预制体创建需要Editor API支持 + return { + success: true, + data: { + prefabPath: prefabPath, + sourceNodeUuid: nodeUuid, + message: `Prefab created from node '${node.name}' at ${prefabPath}` + } + }; + } catch (error: any) { + return { success: false, error: error.message }; + } + }, + + /** + * Set component property + */ + setComponentProperty(nodeUuid: string, componentType: string, property: string, value: any) { + try { + const { director, js } = require('cc'); + const scene = director.getScene(); + if (!scene) { + return { success: false, error: 'No active scene' }; + } + const node = scene.getChildByUuid(nodeUuid); + if (!node) { + return { success: false, error: `Node with UUID ${nodeUuid} not found` }; + } + const ComponentClass = js.getClassByName(componentType); + if (!ComponentClass) { + return { success: false, error: `Component type ${componentType} not found` }; + } + const component = node.getComponent(ComponentClass); + if (!component) { + return { success: false, error: `Component ${componentType} not found on node` }; + } + // 针对常见属性做特殊处理 + if (property === 'spriteFrame' && componentType === 'cc.Sprite') { + // 支持 value 为 uuid 或资源路径 + if (typeof value === 'string') { + // 先尝试按 uuid 查找 + const assetManager = require('cc').assetManager; + assetManager.resources.load(value, require('cc').SpriteFrame, (err: any, spriteFrame: any) => { + if (!err && spriteFrame) { + component.spriteFrame = spriteFrame; + } else { + // 尝试通过 uuid 加载 + assetManager.loadAny({ uuid: value }, (err2: any, asset: any) => { + if (!err2 && asset) { + component.spriteFrame = asset; + } else { + // 直接赋值（兼容已传入资源对象） + component.spriteFrame = value; + } + }); + } + }); + } else { + component.spriteFrame = value; + } + } else if (property === 'material' && (componentType === 'cc.Sprite' || componentType === 'cc.MeshRenderer')) { + // 支持 value 为 uuid 或资源路径 + if (typeof value === 'string') { + const assetManager = require('cc').assetManager; + assetManager.resources.load(value, require('cc').Material, (err: any, material: any) => { + if (!err && material) { + component.material = material; + } else { + assetManager.loadAny({ uuid: value }, (err2: any, asset: any) => { + if (!err2 && asset) { + component.material = asset; + } else { + component.material = value; + } + }); + } + }); + } else { + component.material = value; + } + } else if (property === 'string' && (componentType === 'cc.Label' || componentType === 'cc.RichText')) { + component.string = value; + } else { + component[property] = value; + } + // 可选：刷新 Inspector + // Editor.Message.send('scene', 'snapshot'); + return { success: true, message: `Component property '${property}' updated successfully` }; + } catch (error: any) { + return { success: false, error: error.message }; + } + } +}; \ No newline at end of file diff --git a/source/settings.ts b/source/settings.ts new file mode 100644 index 0000000..ea5a4e6 --- /dev/null +++ b/source/settings.ts @@ -0,0 +1,49 @@ +import * as fs from 'fs'; +import * as path from 'path'; +import { MCPServerSettings } from './types'; + +const DEFAULT_SETTINGS: MCPServerSettings = { + port: 3000, + autoStart: false, + enableDebugLog: false, + allowedOrigins: ['*'], + maxConnections: 10 +}; + +function getSettingsPath(): string { + return path.join(Editor.Project.path, 'settings', 'mcp-server.json'); +} + +function ensureSettingsDir(): void { + const settingsDir = path.dirname(getSettingsPath()); + if (!fs.existsSync(settingsDir)) { + fs.mkdirSync(settingsDir, { recursive: true }); + } +} + +export function readSettings(): MCPServerSettings { + try { + ensureSettingsDir(); + const settingsFile = getSettingsPath(); + if (fs.existsSync(settingsFile)) { + const content = fs.readFileSync(settingsFile, 'utf8'); + return { ...DEFAULT_SETTINGS, ...JSON.parse(content) }; + } + } catch (e) { + console.error('Failed to read settings:', e); + } + return DEFAULT_SETTINGS; +} + +export function saveSettings(settings: MCPServerSettings): void { + try { + ensureSettingsDir(); + const settingsFile = getSettingsPath(); + fs.writeFileSync(settingsFile, JSON.stringify(settings, null, 2)); + } catch (e) { + console.error('Failed to save settings:', e); + throw e; + } +} + +export { DEFAULT_SETTINGS }; \ No newline at end of file diff --git a/source/test/manual-test.ts b/source/test/manual-test.ts new file mode 100644 index 0000000..2cc0eed --- /dev/null +++ b/source/test/manual-test.ts @@ -0,0 +1,132 @@ +declare const Editor: any; + +/** + * 手动测试脚本 + * 可以在 Cocos Creator 控制台中执行测试 + */ + +export async function testSceneTools() { + console.log('=== Testing Scene Tools ==='); + + try { + // 1. 获取场景信息 + console.log('1. Getting scene info...'); + const sceneInfo = await Editor.Message.request('scene', 'get-scene-info'); + console.log('Scene info:', sceneInfo); + + // 2. 创建节点 + console.log('\n2. Creating test node...'); + const createResult = await Editor.Message.request('scene', 'create-node', { + name: 'TestNode_' + Date.now(), + type: 'cc.Node' + }); + console.log('Create result:', createResult); + + if (createResult && createResult.uuid) { + const nodeUuid = createResult.uuid; + + // 3. 查询节点 + console.log('\n3. Querying node...'); + const nodeInfo = await Editor.Message.request('scene', 'query-node', { + uuid: nodeUuid + }); + console.log('Node info:', nodeInfo); + + // 4. 设置节点属性 + console.log('\n4. Setting node position...'); + await Editor.Message.request('scene', 'set-node-property', { + uuid: nodeUuid, + path: 'position', + value: { x: 100, y: 200, z: 0 } + }); + console.log('Position set successfully'); + + // 5. 添加组件 + console.log('\n5. Adding Sprite component...'); + const addCompResult = await Editor.Message.request('scene', 'add-component', { + uuid: nodeUuid, + component: 'cc.Sprite' + }); + console.log('Component added:', addCompResult); + + // 6. 查询组件 + console.log('\n6. Querying component...'); + const compInfo = await Editor.Message.request('scene', 'query-node-component', { + uuid: nodeUuid, + component: 'cc.Sprite' + }); + console.log('Component info:', compInfo); + + // 7. 删除节点 + console.log('\n7. Removing test node...'); + await Editor.Message.request('scene', 'remove-node', { + uuid: nodeUuid + }); + console.log('Node removed successfully'); + } + + } catch (error) { + console.error('Test failed:', error); + } +} + +export async function testAssetTools() { + console.log('\n=== Testing Asset Tools ==='); + + try { + // 1. 查询资源 + console.log('1. Querying image assets...'); + const assets = await Editor.Message.request('asset-db', 'query-assets', { + pattern: '**/*.png', + ccType: 'cc.ImageAsset' + }); + console.log('Found assets:', assets?.length || 0); + + // 2. 获取资源信息 + console.log('\n2. Getting asset database info...'); + const assetInfo = await Editor.Message.request('asset-db', 'query-asset-info', { + uuid: 'db://assets' + }); + console.log('Asset info:', assetInfo); + + } catch (error) { + console.error('Test failed:', error); + } +} + +export async function testProjectTools() { + console.log('\n=== Testing Project Tools ==='); + + try { + // 1. 获取项目信息 + console.log('1. Getting project info...'); + const projectInfo = await Editor.Message.request('project', 'query-info'); + console.log('Project info:', projectInfo); + + // 2. 检查构建能力 + console.log('\n2. Checking build capability...'); + const canBuild = await Editor.Message.request('project', 'can-build'); + console.log('Can build:', canBuild); + + } catch (error) { + console.error('Test failed:', error); + } +} + +export async function runAllTests() { + console.log('Starting MCP Server Tools Test...\n'); + + await testSceneTools(); + await testAssetTools(); + await testProjectTools(); + + console.log('\n=== All tests completed ==='); +} + +// 导出到全局，方便在控制台调用 +(global as any).MCPTest = { + testSceneTools, + testAssetTools, + testProjectTools, + runAllTests +}; \ No newline at end of file diff --git a/source/test/mcp-tool-tester.ts b/source/test/mcp-tool-tester.ts new file mode 100644 index 0000000..cb88df0 --- /dev/null +++ b/source/test/mcp-tool-tester.ts @@ -0,0 +1,235 @@ +declare const Editor: any; + +/** + * MCP 工具测试器 - 直接测试通过 WebSocket 的 MCP 工具 + */ +export class MCPToolTester { + private ws: WebSocket | null = null; + private messageId = 0; + private responseHandlers = new Map void>(); + + async connect(port: number): Promise { + return new Promise((resolve) => { + try { + this.ws = new WebSocket(`ws://localhost:${port}`); + + this.ws.onopen = () => { + console.log('WebSocket 连接成功'); + resolve(true); + }; + + this.ws.onerror = (error) => { + console.error('WebSocket 连接错误:', error); + resolve(false); + }; + + this.ws.onmessage = (event) => { + try { + const response = JSON.parse(event.data); + if (response.id && this.responseHandlers.has(response.id)) { + const handler = this.responseHandlers.get(response.id); + this.responseHandlers.delete(response.id); + handler?.(response); + } + } catch (error) { + console.error('处理响应时出错:', error); + } + }; + } catch (error) { + console.error('创建 WebSocket 时出错:', error); + resolve(false); + } + }); + } + + async callTool(tool: string, args: any = {}): Promise { + if (!this.ws || this.ws.readyState !== WebSocket.OPEN) { + throw new Error('WebSocket 未连接'); + } + + return new Promise((resolve, reject) => { + const id = ++this.messageId; + const request = { + jsonrpc: '2.0', + id, + method: 'tools/call', + params: { + name: tool, + arguments: args + } + }; + + const timeout = setTimeout(() => { + this.responseHandlers.delete(id); + reject(new Error('请求超时')); + }, 10000); + + this.responseHandlers.set(id, (response) => { + clearTimeout(timeout); + if (response.error) { + reject(new Error(response.error.message)); + } else { + resolve(response.result); + } + }); + + this.ws!.send(JSON.stringify(request)); + }); + } + + async listTools(): Promise { + if (!this.ws || this.ws.readyState !== WebSocket.OPEN) { + throw new Error('WebSocket 未连接'); + } + + return new Promise((resolve, reject) => { + const id = ++this.messageId; + const request = { + jsonrpc: '2.0', + id, + method: 'tools/list' + }; + + const timeout = setTimeout(() => { + this.responseHandlers.delete(id); + reject(new Error('请求超时')); + }, 10000); + + this.responseHandlers.set(id, (response) => { + clearTimeout(timeout); + if (response.error) { + reject(new Error(response.error.message)); + } else { + resolve(response.result); + } + }); + + this.ws!.send(JSON.stringify(request)); + }); + } + + async testMCPTools() { + console.log('\n=== 测试 MCP 工具（通过 WebSocket）==='); + + try { + // 0. 获取工具列表 + console.log('\n0. 获取工具列表...'); + const toolsList = await this.listTools(); + console.log(`找到 ${toolsList.tools?.length || 0} 个工具:`); + if (toolsList.tools) { + for (const tool of toolsList.tools.slice(0, 10)) { // 只显示前10个 + console.log(` - ${tool.name}: ${tool.description}`); + } + if (toolsList.tools.length > 10) { + console.log(` ... 还有 ${toolsList.tools.length - 10} 个工具`); + } + } + + // 1. 测试场景工具 + console.log('\n1. 测试当前场景信息...'); + const sceneInfo = await this.callTool('scene_get_current_scene'); + console.log('场景信息:', JSON.stringify(sceneInfo).substring(0, 100) + '...'); + + // 2. 测试场景列表 + console.log('\n2. 测试场景列表...'); + const sceneList = await this.callTool('scene_get_scene_list'); + console.log('场景列表:', JSON.stringify(sceneList).substring(0, 100) + '...'); + + // 3. 测试节点创建 + console.log('\n3. 测试创建节点...'); + const createResult = await this.callTool('node_create_node', { + name: 'MCPTestNode_' + Date.now(), + nodeType: 'cc.Node', + position: { x: 0, y: 0, z: 0 } + }); + console.log('创建节点结果:', createResult); + + // 解析创建节点的结果 + let nodeUuid: string | null = null; + if (createResult.content && createResult.content[0] && createResult.content[0].text) { + try { + const resultData = JSON.parse(createResult.content[0].text); + if (resultData.success && resultData.data && resultData.data.uuid) { + nodeUuid = resultData.data.uuid; + console.log('成功获取节点UUID:', nodeUuid); + } + } catch (e) { + } + } + + if (nodeUuid) { + // 4. 测试查询节点 + console.log('\n4. 测试查询节点...'); + const queryResult = await this.callTool('node_get_node_info', { + uuid: nodeUuid + }); + console.log('节点信息:', JSON.stringify(queryResult).substring(0, 100) + '...'); + + // 5. 测试删除节点 + console.log('\n5. 测试删除节点...'); + const removeResult = await this.callTool('node_delete_node', { + uuid: nodeUuid + }); + console.log('删除结果:', removeResult); + } else { + console.log('无法从创建结果获取节点UUID，尝试通过名称查找...'); + + // 备用方案：通过名称查找刚创建的节点 + const findResult = await this.callTool('node_find_node_by_name', { + name: 'MCPTestNode_' + Date.now() + }); + + if (findResult.content && findResult.content[0] && findResult.content[0].text) { + try { + const findData = JSON.parse(findResult.content[0].text); + if (findData.success && findData.data && findData.data.uuid) { + nodeUuid = findData.data.uuid; + console.log('通过名称查找成功获取UUID:', nodeUuid); + } + } catch (e) { + } + } + + if (!nodeUuid) { + console.log('所有方式都无法获取节点UUID，跳过后续节点操作测试'); + } + } + + // 6. 测试项目工具 + console.log('\n6. 测试项目信息...'); + const projectInfo = await this.callTool('project_get_project_info'); + console.log('项目信息:', JSON.stringify(projectInfo).substring(0, 100) + '...'); + + // 7. 测试预制体工具 + console.log('\n7. 测试预制体列表...'); + const prefabResult = await this.callTool('prefab_get_prefab_list', { + folder: 'db://assets' + }); + console.log('找到预制体:', prefabResult.data?.length || 0); + + // 8. 测试组件工具 + console.log('\n8. 测试可用组件...'); + const componentsResult = await this.callTool('component_get_available_components'); + console.log('可用组件:', JSON.stringify(componentsResult).substring(0, 100) + '...'); + + // 9. 测试调试工具 + console.log('\n9. 测试编辑器信息...'); + const editorInfo = await this.callTool('debug_get_editor_info'); + console.log('编辑器信息:', JSON.stringify(editorInfo).substring(0, 100) + '...'); + + } catch (error) { + console.error('MCP 工具测试失败:', error); + } + } + + disconnect() { + if (this.ws) { + this.ws.close(); + this.ws = null; + } + this.responseHandlers.clear(); + } +} + +// 导出到全局方便测试 +(global as any).MCPToolTester = MCPToolTester; \ No newline at end of file diff --git a/source/test/tool-tester.ts b/source/test/tool-tester.ts new file mode 100644 index 0000000..d61100f --- /dev/null +++ b/source/test/tool-tester.ts @@ -0,0 +1,168 @@ +declare const Editor: any; + +interface TestResult { + tool: string; + method: string; + success: boolean; + result?: any; + error?: string; + time: number; +} + +export class ToolTester { + private results: TestResult[] = []; + + async runTest(tool: string, method: string, params: any): Promise { + const startTime = Date.now(); + const result: TestResult = { + tool, + method, + success: false, + time: 0 + }; + + try { + const response = await Editor.Message.request(tool, method, params); + result.success = true; + result.result = response; + } catch (error) { + result.success = false; + result.error = error instanceof Error ? error.message : String(error); + } + + result.time = Date.now() - startTime; + this.results.push(result); + return result; + } + + async testSceneOperations() { + console.log('Testing Scene Operations...'); + + // Test node creation (this is the main scene operation that works) + const createResult = await this.runTest('scene', 'create-node', { + name: 'TestNode', + type: 'cc.Node' + }); + + if (createResult.success && createResult.result) { + const nodeUuid = createResult.result; + + // Test query node info + await this.runTest('scene', 'query-node-info', nodeUuid); + + // Test remove node + await this.runTest('scene', 'remove-node', nodeUuid); + } + + // Test execute scene script + await this.runTest('scene', 'execute-scene-script', { + name: 'cocos-mcp-server', + method: 'test-method', + args: [] + }); + } + + async testNodeOperations() { + console.log('Testing Node Operations...'); + + // Create a test node first + const createResult = await this.runTest('scene', 'create-node', { + name: 'TestNodeForOps', + type: 'cc.Node' + }); + + if (createResult.success && createResult.result) { + const nodeUuid = createResult.result; + + // Test set property + await this.runTest('scene', 'set-property', { + uuid: nodeUuid, + path: 'position', + dump: { + type: 'cc.Vec3', + value: { x: 100, y: 200, z: 0 } + } + }); + + // Test add component + await this.runTest('scene', 'add-component', { + uuid: nodeUuid, + component: 'cc.Sprite' + }); + + // Clean up + await this.runTest('scene', 'remove-node', nodeUuid); + } + } + + async testAssetOperations() { + console.log('Testing Asset Operations...'); + + // Test asset list + await this.runTest('asset-db', 'query-assets', { + pattern: '**/*.png', + ccType: 'cc.ImageAsset' + }); + + // Test query asset by path + await this.runTest('asset-db', 'query-path', 'db://assets'); + + // Test query asset by uuid (using a valid uuid format) + await this.runTest('asset-db', 'query-uuid', 'db://assets'); + } + + async testProjectOperations() { + console.log('Testing Project Operations...'); + + // Test open project settings + await this.runTest('project', 'open-settings', {}); + + // Test query project settings + const projectName = await this.runTest('project', 'query-setting', 'name'); + + if (projectName.success) { + console.log('Project name:', projectName.result); + } + } + + async runAllTests() { + this.results = []; + + await this.testSceneOperations(); + await this.testNodeOperations(); + await this.testAssetOperations(); + await this.testProjectOperations(); + + return this.getTestReport(); + } + + getTestReport() { + const total = this.results.length; + const passed = this.results.filter(r => r.success).length; + const failed = total - passed; + + return { + summary: { + total, + passed, + failed, + passRate: total > 0 ? (passed / total * 100).toFixed(2) + '%' : '0%' + }, + results: this.results, + grouped: this.groupResultsByTool() + }; + } + + private groupResultsByTool() { + const grouped: Record = {}; + + for (const result of this.results) { + if (!grouped[result.tool]) { + grouped[result.tool] = []; + } + grouped[result.tool].push(result); + } + + return grouped; + } +} \ No newline at end of file diff --git a/source/tools/broadcast-tools.ts b/source/tools/broadcast-tools.ts new file mode 100644 index 0000000..3164725 --- /dev/null +++ b/source/tools/broadcast-tools.ts @@ -0,0 +1,264 @@ +import { ToolDefinition, ToolResponse, ToolExecutor } from '../types'; + +export class BroadcastTools implements ToolExecutor { + private listeners: Map = new Map(); + private messageLog: Array<{ message: string; data: any; timestamp: number }> = []; + + constructor() { + this.setupBroadcastListeners(); + } + + getTools(): ToolDefinition[] { + return [ + { + name: 'get_broadcast_log', + description: 'Get recent broadcast messages log', + inputSchema: { + type: 'object', + properties: { + limit: { + type: 'number', + description: 'Number of recent messages to return', + default: 50 + }, + messageType: { + type: 'string', + description: 'Filter by message type (optional)' + } + } + } + }, + { + name: 'listen_broadcast', + description: 'Start listening for specific broadcast messages', + inputSchema: { + type: 'object', + properties: { + messageType: { + type: 'string', + description: 'Message type to listen for' + } + }, + required: ['messageType'] + } + }, + { + name: 'stop_listening', + description: 'Stop listening for specific broadcast messages', + inputSchema: { + type: 'object', + properties: { + messageType: { + type: 'string', + description: 'Message type to stop listening for' + } + }, + required: ['messageType'] + } + }, + { + name: 'clear_broadcast_log', + description: 'Clear the broadcast messages log', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_active_listeners', + description: 'Get list of active broadcast listeners', + inputSchema: { + type: 'object', + properties: {} + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'get_broadcast_log': + return await this.getBroadcastLog(args.limit, args.messageType); + case 'listen_broadcast': + return await this.listenBroadcast(args.messageType); + case 'stop_listening': + return await this.stopListening(args.messageType); + case 'clear_broadcast_log': + return await this.clearBroadcastLog(); + case 'get_active_listeners': + return await this.getActiveListeners(); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private setupBroadcastListeners(): void { + // 设置预定义的重要广播消息监听 + const importantMessages = [ + 'build-worker:ready', + 'build-worker:closed', + 'scene:ready', + 'scene:close', + 'scene:light-probe-edit-mode-changed', + 'scene:light-probe-bounding-box-edit-mode-changed', + 'asset-db:ready', + 'asset-db:close', + 'asset-db:asset-add', + 'asset-db:asset-change', + 'asset-db:asset-delete' + ]; + + importantMessages.forEach(messageType => { + this.addBroadcastListener(messageType); + }); + } + + private addBroadcastListener(messageType: string): void { + const listener = (data: any) => { + this.messageLog.push({ + message: messageType, + data: data, + timestamp: Date.now() + }); + + // 保持日志大小在合理范围内 + if (this.messageLog.length > 1000) { + this.messageLog = this.messageLog.slice(-500); + } + + console.log(`[Broadcast] ${messageType}:`, data); + }; + + if (!this.listeners.has(messageType)) { + this.listeners.set(messageType, []); + } + this.listeners.get(messageType)!.push(listener); + + // 注册 Editor 消息监听 - 暂时注释掉，Editor.Message API可能不支持 + // Editor.Message.on(messageType, listener); + console.log(`[BroadcastTools] Added listener for ${messageType} (simulated)`); + } + + private removeBroadcastListener(messageType: string): void { + const listeners = this.listeners.get(messageType); + if (listeners) { + listeners.forEach(listener => { + // Editor.Message.off(messageType, listener); + console.log(`[BroadcastTools] Removed listener for ${messageType} (simulated)`); + }); + this.listeners.delete(messageType); + } + } + + private async getBroadcastLog(limit: number = 50, messageType?: string): Promise { + return new Promise((resolve) => { + let filteredLog = this.messageLog; + + if (messageType) { + filteredLog = this.messageLog.filter(entry => entry.message === messageType); + } + + const recentLog = filteredLog.slice(-limit).map(entry => ({ + ...entry, + timestamp: new Date(entry.timestamp).toISOString() + })); + + resolve({ + success: true, + data: { + log: recentLog, + count: recentLog.length, + totalCount: filteredLog.length, + filter: messageType || 'all', + message: 'Broadcast log retrieved successfully' + } + }); + }); + } + + private async listenBroadcast(messageType: string): Promise { + return new Promise((resolve) => { + try { + if (!this.listeners.has(messageType)) { + this.addBroadcastListener(messageType); + resolve({ + success: true, + data: { + messageType: messageType, + message: `Started listening for broadcast: ${messageType}` + } + }); + } else { + resolve({ + success: true, + data: { + messageType: messageType, + message: `Already listening for broadcast: ${messageType}` + } + }); + } + } catch (err: any) { + resolve({ success: false, error: err.message }); + } + }); + } + + private async stopListening(messageType: string): Promise { + return new Promise((resolve) => { + try { + if (this.listeners.has(messageType)) { + this.removeBroadcastListener(messageType); + resolve({ + success: true, + data: { + messageType: messageType, + message: `Stopped listening for broadcast: ${messageType}` + } + }); + } else { + resolve({ + success: true, + data: { + messageType: messageType, + message: `Was not listening for broadcast: ${messageType}` + } + }); + } + } catch (err: any) { + resolve({ success: false, error: err.message }); + } + }); + } + + private async clearBroadcastLog(): Promise { + return new Promise((resolve) => { + const previousCount = this.messageLog.length; + this.messageLog = []; + resolve({ + success: true, + data: { + clearedCount: previousCount, + message: 'Broadcast log cleared successfully' + } + }); + }); + } + + private async getActiveListeners(): Promise { + return new Promise((resolve) => { + const activeListeners = Array.from(this.listeners.keys()).map(messageType => ({ + messageType: messageType, + listenerCount: this.listeners.get(messageType)?.length || 0 + })); + + resolve({ + success: true, + data: { + listeners: activeListeners, + count: activeListeners.length, + message: 'Active listeners retrieved successfully' + } + }); + }); + } +} \ No newline at end of file diff --git a/source/tools/component-tools.ts b/source/tools/component-tools.ts new file mode 100644 index 0000000..3890ff4 --- /dev/null +++ b/source/tools/component-tools.ts @@ -0,0 +1,445 @@ +import { ToolDefinition, ToolResponse, ToolExecutor, ComponentInfo } from '../types'; + +export class ComponentTools implements ToolExecutor { + getTools(): ToolDefinition[] { + return [ + { + name: 'add_component', + description: 'Add a component to a specific node. The component will be added to the exact node specified by nodeUuid.', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Target node UUID. Use get_node_info or find_node_by_name to get the UUID of the desired node.' + }, + componentType: { + type: 'string', + description: 'Component type (e.g., cc.Sprite, cc.Label, cc.Button)' + } + }, + required: ['nodeUuid', 'componentType'] + } + }, + { + name: 'remove_component', + description: 'Remove a component from a node', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + }, + componentType: { + type: 'string', + description: 'Component type to remove' + } + }, + required: ['nodeUuid', 'componentType'] + } + }, + { + name: 'get_components', + description: 'Get all components of a node', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + } + }, + required: ['nodeUuid'] + } + }, + { + name: 'get_component_info', + description: 'Get specific component information', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + }, + componentType: { + type: 'string', + description: 'Component type to get info for' + } + }, + required: ['nodeUuid', 'componentType'] + } + }, + { + name: 'set_component_property', + description: 'Set component property value', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + }, + componentType: { + type: 'string', + description: 'Component type' + }, + property: { + type: 'string', + description: 'Property name' + }, + value: { + description: 'Property value' + } + }, + required: ['nodeUuid', 'componentType', 'property', 'value'] + } + }, + { + name: 'attach_script', + description: 'Attach a script component to a node', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID' + }, + scriptPath: { + type: 'string', + description: 'Script asset path (e.g., db://assets/scripts/MyScript.ts)' + } + }, + required: ['nodeUuid', 'scriptPath'] + } + }, + { + name: 'get_available_components', + description: 'Get list of available component types', + inputSchema: { + type: 'object', + properties: { + category: { + type: 'string', + description: 'Component category filter', + enum: ['all', 'renderer', 'ui', 'physics', 'animation', 'audio'], + default: 'all' + } + } + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'add_component': + return await this.addComponent(args.nodeUuid, args.componentType); + case 'remove_component': + return await this.removeComponent(args.nodeUuid, args.componentType); + case 'get_components': + return await this.getComponents(args.nodeUuid); + case 'get_component_info': + return await this.getComponentInfo(args.nodeUuid, args.componentType); + case 'set_component_property': + return await this.setComponentProperty(args); + case 'attach_script': + return await this.attachScript(args.nodeUuid, args.scriptPath); + case 'get_available_components': + return await this.getAvailableComponents(args.category); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private async addComponent(nodeUuid: string, componentType: string): Promise { + return new Promise((resolve) => { + // 尝试直接使用 Editor API 添加组件 + Editor.Message.request('scene', 'create-component', { + uuid: nodeUuid, + component: componentType + }).then((result: any) => { + resolve({ + success: true, + data: { + componentId: result, + message: `Component '${componentType}' added successfully` + } + }); + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'addComponentToNode', + args: [nodeUuid, componentType] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private async removeComponent(nodeUuid: string, componentType: string): Promise { + return new Promise((resolve) => { + const options = { + name: 'cocos-mcp-server', + method: 'removeComponentFromNode', + args: [nodeUuid, componentType] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async getComponents(nodeUuid: string): Promise { + return new Promise((resolve) => { + // 优先尝试直接使用 Editor API 查询节点信息 + Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => { + if (nodeData && nodeData.__comps__) { + const components = nodeData.__comps__.map((comp: any) => ({ + type: comp.__type__ || 'Unknown', + enabled: comp.enabled !== undefined ? comp.enabled : true, + properties: this.extractComponentProperties(comp) + })); + + resolve({ + success: true, + data: { + nodeUuid: nodeUuid, + components: components + } + }); + } else { + resolve({ success: false, error: 'Node not found or no components data' }); + } + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getNodeInfo', + args: [nodeUuid] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + if (result.success) { + resolve({ + success: true, + data: result.data.components + }); + } else { + resolve(result); + } + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private async getComponentInfo(nodeUuid: string, componentType: string): Promise { + return new Promise((resolve) => { + // 优先尝试直接使用 Editor API 查询节点信息 + Editor.Message.request('scene', 'query-node', nodeUuid).then((nodeData: any) => { + if (nodeData && nodeData.__comps__) { + const component = nodeData.__comps__.find((comp: any) => comp.__type__ === componentType); + + if (component) { + resolve({ + success: true, + data: { + nodeUuid: nodeUuid, + componentType: componentType, + enabled: component.enabled !== undefined ? component.enabled : true, + properties: this.extractComponentProperties(component) + } + }); + } else { + resolve({ success: false, error: `Component '${componentType}' not found on node` }); + } + } else { + resolve({ success: false, error: 'Node not found or no components data' }); + } + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getNodeInfo', + args: [nodeUuid] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + if (result.success && result.data.components) { + const component = result.data.components.find((comp: any) => comp.type === componentType); + if (component) { + resolve({ + success: true, + data: { + nodeUuid: nodeUuid, + componentType: componentType, + ...component + } + }); + } else { + resolve({ success: false, error: `Component '${componentType}' not found on node` }); + } + } else { + resolve({ success: false, error: result.error || 'Failed to get component info' }); + } + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private extractComponentProperties(component: any): Record { + const properties: Record = {}; + const excludeKeys = ['__type__', 'enabled', 'node', '_id']; + + for (const key in component) { + if (!excludeKeys.includes(key) && !key.startsWith('_')) { + properties[key] = component[key]; + } + } + + return properties; + } + + private async setComponentProperty(args: any): Promise { + return new Promise((resolve) => { + // 首先获取节点信息以找到正确的组件索引 + Editor.Message.request('scene', 'query-node', args.nodeUuid).then((nodeData: any) => { + if (!nodeData || !nodeData.__comps__) { + throw new Error('Node not found or no components data'); + } + + // 查找组件索引 + let componentIndex = -1; + for (let i = 0; i < nodeData.__comps__.length; i++) { + const comp = nodeData.__comps__[i]; + if (comp.__type__ === args.componentType) { + componentIndex = i; + break; + } + } + + if (componentIndex === -1) { + throw new Error(`Component '${args.componentType}' not found on node`); + } + + // 使用正确的组件索引路径 + const propertyPath = `__comps__.${componentIndex}.${args.property}`; + + return Editor.Message.request('scene', 'set-property', { + uuid: args.nodeUuid, + path: propertyPath, + dump: { + value: args.value + } + }); + }).then(() => { + resolve({ + success: true, + message: `Component property '${args.property}' updated successfully` + }); + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'setComponentProperty', + args: [args.nodeUuid, args.componentType, args.property, args.value] + }; + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private async attachScript(nodeUuid: string, scriptPath: string): Promise { + return new Promise((resolve) => { + // 从脚本路径提取组件类名 + const scriptName = scriptPath.split('/').pop()?.replace('.ts', '').replace('.js', ''); + if (!scriptName) { + resolve({ success: false, error: 'Invalid script path' }); + return; + } + + // 首先尝试直接使用脚本名称作为组件类型 + Editor.Message.request('scene', 'create-component', { + uuid: nodeUuid, + component: scriptName // 使用脚本名称而非UUID + }).then((result: any) => { + resolve({ + success: true, + data: { + componentId: result, + scriptPath: scriptPath, + componentName: scriptName, + message: `Script '${scriptName}' attached successfully` + } + }); + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'attachScript', + args: [nodeUuid, scriptPath] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err2: Error) => { + resolve({ + success: false, + error: `Failed to attach script '${scriptName}': ${err.message}`, + instruction: 'Please ensure the script is properly compiled and exported as a Component class. You can also manually attach the script through the Properties panel in the editor.' + }); + }); + }); + }); + } + + private async getAvailableComponents(category: string = 'all'): Promise { + const componentCategories: Record = { + renderer: ['cc.Sprite', 'cc.Label', 'cc.RichText', 'cc.Mask', 'cc.Graphics'], + ui: ['cc.Button', 'cc.Toggle', 'cc.Slider', 'cc.ScrollView', 'cc.EditBox', 'cc.ProgressBar'], + physics: ['cc.RigidBody2D', 'cc.BoxCollider2D', 'cc.CircleCollider2D', 'cc.PolygonCollider2D'], + animation: ['cc.Animation', 'cc.AnimationClip', 'cc.SkeletalAnimation'], + audio: ['cc.AudioSource'], + layout: ['cc.Layout', 'cc.Widget', 'cc.PageView', 'cc.PageViewIndicator'], + effects: ['cc.MotionStreak', 'cc.ParticleSystem2D'], + camera: ['cc.Camera'], + light: ['cc.Light', 'cc.DirectionalLight', 'cc.PointLight', 'cc.SpotLight'] + }; + + let components: string[] = []; + + if (category === 'all') { + for (const cat in componentCategories) { + components = components.concat(componentCategories[cat]); + } + } else if (componentCategories[category]) { + components = componentCategories[category]; + } + + return { + success: true, + data: { + category: category, + components: components + } + }; + } +} \ No newline at end of file diff --git a/source/tools/debug-tools.ts b/source/tools/debug-tools.ts new file mode 100644 index 0000000..59b2e8d --- /dev/null +++ b/source/tools/debug-tools.ts @@ -0,0 +1,351 @@ +import { ToolDefinition, ToolResponse, ToolExecutor, ConsoleMessage, PerformanceStats, ValidationResult, ValidationIssue } from '../types'; + +export class DebugTools implements ToolExecutor { + private consoleMessages: ConsoleMessage[] = []; + private readonly maxMessages = 1000; + + constructor() { + this.setupConsoleCapture(); + } + + private setupConsoleCapture(): void { + // Intercept Editor console messages + // Note: Editor.Message.addBroadcastListener may not be available in all versions + // This is a placeholder for console capture implementation + console.log('Console capture setup - implementation depends on Editor API availability'); + } + + private addConsoleMessage(message: any): void { + this.consoleMessages.push({ + timestamp: new Date().toISOString(), + ...message + }); + + // Keep only latest messages + if (this.consoleMessages.length > this.maxMessages) { + this.consoleMessages.shift(); + } + } + + getTools(): ToolDefinition[] { + return [ + { + name: 'get_console_logs', + description: 'Get editor console logs', + inputSchema: { + type: 'object', + properties: { + limit: { + type: 'number', + description: 'Number of recent logs to retrieve', + default: 100 + }, + filter: { + type: 'string', + description: 'Filter logs by type', + enum: ['all', 'log', 'warn', 'error', 'info'], + default: 'all' + } + } + } + }, + { + name: 'clear_console', + description: 'Clear editor console', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'execute_script', + description: 'Execute JavaScript in scene context', + inputSchema: { + type: 'object', + properties: { + script: { + type: 'string', + description: 'JavaScript code to execute' + } + }, + required: ['script'] + } + }, + { + name: 'get_node_tree', + description: 'Get detailed node tree for debugging', + inputSchema: { + type: 'object', + properties: { + rootUuid: { + type: 'string', + description: 'Root node UUID (optional, uses scene root if not provided)' + }, + maxDepth: { + type: 'number', + description: 'Maximum tree depth', + default: 10 + } + } + } + }, + { + name: 'get_performance_stats', + description: 'Get performance statistics', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'validate_scene', + description: 'Validate current scene for issues', + inputSchema: { + type: 'object', + properties: { + checkMissingAssets: { + type: 'boolean', + description: 'Check for missing asset references', + default: true + }, + checkPerformance: { + type: 'boolean', + description: 'Check for performance issues', + default: true + } + } + } + }, + { + name: 'get_editor_info', + description: 'Get editor and environment information', + inputSchema: { + type: 'object', + properties: {} + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'get_console_logs': + return await this.getConsoleLogs(args.limit, args.filter); + case 'clear_console': + return await this.clearConsole(); + case 'execute_script': + return await this.executeScript(args.script); + case 'get_node_tree': + return await this.getNodeTree(args.rootUuid, args.maxDepth); + case 'get_performance_stats': + return await this.getPerformanceStats(); + case 'validate_scene': + return await this.validateScene(args); + case 'get_editor_info': + return await this.getEditorInfo(); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private async getConsoleLogs(limit: number = 100, filter: string = 'all'): Promise { + let logs = this.consoleMessages; + + if (filter !== 'all') { + logs = logs.filter(log => log.type === filter); + } + + const recentLogs = logs.slice(-limit); + + return { + success: true, + data: { + total: logs.length, + returned: recentLogs.length, + logs: recentLogs + } + }; + } + + private async clearConsole(): Promise { + this.consoleMessages = []; + + try { + // Note: Editor.Message.send may not return a promise in all versions + Editor.Message.send('console', 'clear'); + return { + success: true, + message: 'Console cleared successfully' + }; + } catch (err: any) { + return { success: false, error: err.message }; + } + } + + private async executeScript(script: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'execute-script', { + script: script + }).then((result: any) => { + resolve({ + success: true, + data: { + result: result, + message: 'Script executed successfully' + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async getNodeTree(rootUuid?: string, maxDepth: number = 10): Promise { + return new Promise((resolve) => { + const buildTree = async (nodeUuid: string, depth: number = 0): Promise => { + if (depth >= maxDepth) { + return { truncated: true }; + } + + try { + const nodeData = await Editor.Message.request('scene', 'query-node', nodeUuid); + + const tree = { + uuid: nodeData.uuid, + name: nodeData.name, + active: nodeData.active, + components: (nodeData as any).components ? (nodeData as any).components.map((c: any) => c.__type__) : [], + childCount: nodeData.children ? nodeData.children.length : 0, + children: [] as any[] + }; + + if (nodeData.children && nodeData.children.length > 0) { + for (const childId of nodeData.children) { + const childTree = await buildTree(childId, depth + 1); + tree.children.push(childTree); + } + } + + return tree; + } catch (err: any) { + return { error: err.message }; + } + }; + + if (rootUuid) { + buildTree(rootUuid).then(tree => { + resolve({ success: true, data: tree }); + }); + } else { + Editor.Message.request('scene', 'query-hierarchy').then(async (hierarchy: any) => { + const trees = []; + for (const rootNode of hierarchy.children) { + const tree = await buildTree(rootNode.uuid); + trees.push(tree); + } + resolve({ success: true, data: trees }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + } + }); + } + + private async getPerformanceStats(): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'query-performance').then((stats: any) => { + const perfStats: PerformanceStats = { + nodeCount: stats.nodeCount || 0, + componentCount: stats.componentCount || 0, + drawCalls: stats.drawCalls || 0, + triangles: stats.triangles || 0, + memory: stats.memory || {} + }; + resolve({ success: true, data: perfStats }); + }).catch(() => { + // Fallback to basic stats + resolve({ + success: true, + data: { + message: 'Performance stats not available in edit mode' + } + }); + }); + }); + } + + private async validateScene(options: any): Promise { + const issues: ValidationIssue[] = []; + + try { + // Check for missing assets + if (options.checkMissingAssets) { + const assetCheck = await Editor.Message.request('scene', 'check-missing-assets'); + if (assetCheck && assetCheck.missing) { + issues.push({ + type: 'error', + category: 'assets', + message: `Found ${assetCheck.missing.length} missing asset references`, + details: assetCheck.missing + }); + } + } + + // Check for performance issues + if (options.checkPerformance) { + const hierarchy = await Editor.Message.request('scene', 'query-hierarchy'); + const nodeCount = this.countNodes(hierarchy.children); + + if (nodeCount > 1000) { + issues.push({ + type: 'warning', + category: 'performance', + message: `High node count: ${nodeCount} nodes (recommended < 1000)`, + suggestion: 'Consider using object pooling or scene optimization' + }); + } + } + + const result: ValidationResult = { + valid: issues.length === 0, + issueCount: issues.length, + issues: issues + }; + + return { success: true, data: result }; + } catch (err: any) { + return { success: false, error: err.message }; + } + } + + private countNodes(nodes: any[]): number { + let count = nodes.length; + for (const node of nodes) { + if (node.children) { + count += this.countNodes(node.children); + } + } + return count; + } + + private async getEditorInfo(): Promise { + const info = { + editor: { + version: (Editor as any).versions?.editor || 'Unknown', + cocosVersion: (Editor as any).versions?.cocos || 'Unknown', + platform: process.platform, + arch: process.arch, + nodeVersion: process.version + }, + project: { + name: Editor.Project.name, + path: Editor.Project.path, + uuid: Editor.Project.uuid + }, + memory: process.memoryUsage(), + uptime: process.uptime() + }; + + return { success: true, data: info }; + } +} \ No newline at end of file diff --git a/source/tools/node-tools.ts b/source/tools/node-tools.ts new file mode 100644 index 0000000..a95f91d --- /dev/null +++ b/source/tools/node-tools.ts @@ -0,0 +1,526 @@ +import { ToolDefinition, ToolResponse, ToolExecutor, NodeInfo } from '../types'; + +export class NodeTools implements ToolExecutor { + getTools(): ToolDefinition[] { + return [ + { + name: 'create_node', + description: 'Create a new node in the scene. If parentUuid is not provided, the node will be created at the current selection in the editor.', + inputSchema: { + type: 'object', + properties: { + name: { + type: 'string', + description: 'Node name' + }, + parentUuid: { + type: 'string', + description: 'Parent node UUID. If not provided, node will be created at current editor selection. To create at scene root, first get the root node UUID.' + }, + nodeType: { + type: 'string', + description: 'Node type: Node, 2DNode, 3DNode', + enum: ['Node', '2DNode', '3DNode'], + default: 'Node' + }, + siblingIndex: { + type: 'number', + description: 'Sibling index for ordering (-1 means append at end)', + default: -1 + } + }, + required: ['name'] + } + }, + { + name: 'get_node_info', + description: 'Get node information by UUID', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Node UUID' + } + }, + required: ['uuid'] + } + }, + { + name: 'find_nodes', + description: 'Find nodes by name pattern', + inputSchema: { + type: 'object', + properties: { + pattern: { + type: 'string', + description: 'Name pattern to search' + }, + exactMatch: { + type: 'boolean', + description: 'Exact match or partial match', + default: false + } + }, + required: ['pattern'] + } + }, + { + name: 'find_node_by_name', + description: 'Find first node by exact name', + inputSchema: { + type: 'object', + properties: { + name: { + type: 'string', + description: 'Node name to find' + } + }, + required: ['name'] + } + }, + { + name: 'get_all_nodes', + description: 'Get all nodes in the scene with their UUIDs', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'set_node_property', + description: 'Set node property value', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Node UUID' + }, + property: { + type: 'string', + description: 'Property name (e.g., position, rotation, scale, active)' + }, + value: { + description: 'Property value' + } + }, + required: ['uuid', 'property', 'value'] + } + }, + { + name: 'delete_node', + description: 'Delete a node from scene', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Node UUID to delete' + } + }, + required: ['uuid'] + } + }, + { + name: 'move_node', + description: 'Move node to new parent', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Node UUID to move' + }, + newParentUuid: { + type: 'string', + description: 'New parent node UUID' + }, + siblingIndex: { + type: 'number', + description: 'Sibling index in new parent', + default: -1 + } + }, + required: ['nodeUuid', 'newParentUuid'] + } + }, + { + name: 'duplicate_node', + description: 'Duplicate a node', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Node UUID to duplicate' + }, + includeChildren: { + type: 'boolean', + description: 'Include children nodes', + default: true + } + }, + required: ['uuid'] + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'create_node': + return await this.createNode(args); + case 'get_node_info': + return await this.getNodeInfo(args.uuid); + case 'find_nodes': + return await this.findNodes(args.pattern, args.exactMatch); + case 'find_node_by_name': + return await this.findNodeByName(args.name); + case 'get_all_nodes': + return await this.getAllNodes(); + case 'set_node_property': + return await this.setNodeProperty(args.uuid, args.property, args.value); + case 'delete_node': + return await this.deleteNode(args.uuid); + case 'move_node': + return await this.moveNode(args.nodeUuid, args.newParentUuid, args.siblingIndex); + case 'duplicate_node': + return await this.duplicateNode(args.uuid, args.includeChildren); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private async createNode(args: any): Promise { + return new Promise(async (resolve) => { + // 如果指定了父节点，先验证父节点是否存在 + if (args.parentUuid) { + try { + const parentNode = await Editor.Message.request('scene', 'query-node', args.parentUuid); + if (!parentNode) { + resolve({ + success: false, + error: `Parent node with UUID '${args.parentUuid}' not found` + }); + return; + } + } catch (err) { + resolve({ + success: false, + error: `Failed to verify parent node: ${err}` + }); + return; + } + } + + const nodeData: any = { + name: args.name, + type: args.nodeType || 'cc.Node' + }; + + // 使用更明确的父节点指定方式 + if (args.parentUuid) { + nodeData.parent = args.parentUuid; + // 尝试先创建节点，然后移动到指定父节点 + Editor.Message.request('scene', 'create-node', nodeData).then((nodeUuid: any) => { + // 如果创建成功但可能没有在正确的父节点下，尝试移动 + if (args.parentUuid && nodeUuid) { + Editor.Message.request('scene', 'move-node', { + uuid: nodeUuid, + parent: args.parentUuid, + index: args.siblingIndex !== undefined ? args.siblingIndex : -1 + }).then(() => { + resolve({ + success: true, + data: { + uuid: nodeUuid, + name: args.name, + parentUuid: args.parentUuid, + message: `Node '${args.name}' created under specified parent` + } + }); + }).catch(() => { + // 即使移动失败，节点已创建，返回成功但带警告 + resolve({ + success: true, + data: { + uuid: nodeUuid, + name: args.name, + message: `Node '${args.name}' created but may not be under specified parent`, + warning: 'Failed to move node to specified parent' + } + }); + }); + } else { + resolve({ + success: true, + data: { + uuid: nodeUuid, + name: args.name, + message: `Node '${args.name}' created successfully` + } + }); + } + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + } else { + // 没有指定父节点，使用默认行为 + Editor.Message.request('scene', 'create-node', nodeData).then((result: any) => { + resolve({ + success: true, + data: { + uuid: result, + name: args.name, + message: `Node '${args.name}' created at current selection` + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + } + }); + } + + private async getNodeInfo(uuid: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'query-node', uuid).then((nodeData: any) => { + if (!nodeData) { + resolve({ + success: false, + error: 'Node not found or invalid response' + }); + return; + } + + // 根据实际返回的数据结构解析节点信息 + const info: NodeInfo = { + uuid: nodeData.uuid?.value || uuid, + name: nodeData.name?.value || 'Unknown', + active: nodeData.active?.value !== undefined ? nodeData.active.value : true, + position: nodeData.position?.value || { x: 0, y: 0, z: 0 }, + rotation: nodeData.rotation?.value || { x: 0, y: 0, z: 0 }, + scale: nodeData.scale?.value || { x: 1, y: 1, z: 1 }, + parent: nodeData.parent?.value?.uuid || null, + children: nodeData.children || [], + components: (nodeData.__comps__ || []).map((comp: any) => ({ + type: comp.__type__ || 'Unknown', + enabled: comp.enabled !== undefined ? comp.enabled : true + })), + layer: nodeData.layer?.value || 1073741824, + mobility: nodeData.mobility?.value || 0 + }; + resolve({ success: true, data: info }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async findNodes(pattern: string, exactMatch: boolean = false): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'query-nodes-by-name', { + name: pattern, + exactMatch: exactMatch + }).then((results: any[]) => { + const nodes = results.map(node => ({ + uuid: node.uuid, + name: node.name, + path: node.path + })); + resolve({ success: true, data: nodes }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async findNodeByName(name: string): Promise { + return new Promise((resolve) => { + // 优先尝试使用 Editor API 查询节点树并搜索 + Editor.Message.request('scene', 'query-node-tree').then((tree: any) => { + const foundNode = this.searchNodeInTree(tree, name); + if (foundNode) { + resolve({ + success: true, + data: { + uuid: foundNode.uuid, + name: foundNode.name, + path: this.getNodePath(foundNode) + } + }); + } else { + resolve({ success: false, error: `Node '${name}' not found` }); + } + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'findNodeByName', + args: [name] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private searchNodeInTree(node: any, targetName: string): any { + if (node.name === targetName) { + return node; + } + + if (node.children) { + for (const child of node.children) { + const found = this.searchNodeInTree(child, targetName); + if (found) { + return found; + } + } + } + + return null; + } + + private async getAllNodes(): Promise { + return new Promise((resolve) => { + // 尝试查询场景节点树 + Editor.Message.request('scene', 'query-node-tree').then((tree: any) => { + const nodes: any[] = []; + + const traverseTree = (node: any) => { + nodes.push({ + uuid: node.uuid, + name: node.name, + type: node.type, + active: node.active, + path: this.getNodePath(node) + }); + + if (node.children) { + for (const child of node.children) { + traverseTree(child); + } + } + }; + + if (tree && tree.children) { + traverseTree(tree); + } + + resolve({ + success: true, + data: { + totalNodes: nodes.length, + nodes: nodes + } + }); + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getAllNodes', + args: [] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private getNodePath(node: any): string { + const path = [node.name]; + let current = node.parent; + while (current && current.name !== 'Canvas') { + path.unshift(current.name); + current = current.parent; + } + return path.join('/'); + } + + private async setNodeProperty(uuid: string, property: string, value: any): Promise { + return new Promise((resolve) => { + // 尝试直接使用 Editor API 设置节点属性 + Editor.Message.request('scene', 'set-property', { + uuid: uuid, + path: property, + dump: { + value: value + } + }).then(() => { + resolve({ + success: true, + message: `Property '${property}' updated successfully` + }); + }).catch((err: Error) => { + // 如果直接设置失败，尝试使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'setNodeProperty', + args: [uuid, property, value] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private async deleteNode(uuid: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'remove-node', { uuid: uuid }).then(() => { + resolve({ + success: true, + message: 'Node deleted successfully' + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async moveNode(nodeUuid: string, newParentUuid: string, siblingIndex: number = -1): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'move-node', { + uuid: nodeUuid, + parent: newParentUuid, + index: siblingIndex + }).then(() => { + resolve({ + success: true, + message: 'Node moved successfully' + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async duplicateNode(uuid: string, includeChildren: boolean = true): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'duplicate-node', uuid).then((result: any) => { + resolve({ + success: true, + data: { + newUuid: result.uuid, + message: 'Node duplicated successfully' + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } +} \ No newline at end of file diff --git a/source/tools/prefab-tools.ts b/source/tools/prefab-tools.ts new file mode 100644 index 0000000..84e3c4b --- /dev/null +++ b/source/tools/prefab-tools.ts @@ -0,0 +1,359 @@ +import { ToolDefinition, ToolResponse, ToolExecutor, PrefabInfo } from '../types'; + +export class PrefabTools implements ToolExecutor { + getTools(): ToolDefinition[] { + return [ + { + name: 'get_prefab_list', + description: 'Get all prefabs in the project', + inputSchema: { + type: 'object', + properties: { + folder: { + type: 'string', + description: 'Folder path to search (optional)', + default: 'db://assets' + } + } + } + }, + { + name: 'load_prefab', + description: 'Load a prefab by path', + inputSchema: { + type: 'object', + properties: { + prefabPath: { + type: 'string', + description: 'Prefab asset path' + } + }, + required: ['prefabPath'] + } + }, + { + name: 'instantiate_prefab', + description: 'Instantiate a prefab in the scene', + inputSchema: { + type: 'object', + properties: { + prefabPath: { + type: 'string', + description: 'Prefab asset path' + }, + parentUuid: { + type: 'string', + description: 'Parent node UUID (optional)' + }, + position: { + type: 'object', + description: 'Initial position', + properties: { + x: { type: 'number' }, + y: { type: 'number' }, + z: { type: 'number' } + } + } + }, + required: ['prefabPath'] + } + }, + { + name: 'create_prefab', + description: 'Create a prefab from a node', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Source node UUID' + }, + savePath: { + type: 'string', + description: 'Path to save the prefab' + }, + prefabName: { + type: 'string', + description: 'Prefab name' + } + }, + required: ['nodeUuid', 'savePath', 'prefabName'] + } + }, + { + name: 'create_prefab_from_node', + description: 'Create a prefab from a node (alias for create_prefab)', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Source node UUID' + }, + prefabPath: { + type: 'string', + description: 'Path to save the prefab' + } + }, + required: ['nodeUuid', 'prefabPath'] + } + }, + { + name: 'update_prefab', + description: 'Update an existing prefab', + inputSchema: { + type: 'object', + properties: { + prefabPath: { + type: 'string', + description: 'Prefab asset path' + }, + nodeUuid: { + type: 'string', + description: 'Node UUID with changes' + } + }, + required: ['prefabPath', 'nodeUuid'] + } + }, + { + name: 'revert_prefab', + description: 'Revert prefab instance to original', + inputSchema: { + type: 'object', + properties: { + nodeUuid: { + type: 'string', + description: 'Prefab instance node UUID' + } + }, + required: ['nodeUuid'] + } + }, + { + name: 'get_prefab_info', + description: 'Get detailed prefab information', + inputSchema: { + type: 'object', + properties: { + prefabPath: { + type: 'string', + description: 'Prefab asset path' + } + }, + required: ['prefabPath'] + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'get_prefab_list': + return await this.getPrefabList(args.folder); + case 'load_prefab': + return await this.loadPrefab(args.prefabPath); + case 'instantiate_prefab': + return await this.instantiatePrefab(args); + case 'create_prefab': + return await this.createPrefab(args); + case 'create_prefab_from_node': + return await this.createPrefabFromNode(args); + case 'update_prefab': + return await this.updatePrefab(args.prefabPath, args.nodeUuid); + case 'revert_prefab': + return await this.revertPrefab(args.nodeUuid); + case 'get_prefab_info': + return await this.getPrefabInfo(args.prefabPath); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private async getPrefabList(folder: string = 'db://assets'): Promise { + return new Promise((resolve) => { + const pattern = folder.endsWith('/') ? + `${folder}**/*.prefab` : `${folder}/**/*.prefab`; + + Editor.Message.request('asset-db', 'query-assets', { + pattern: pattern + }).then((results: any[]) => { + const prefabs: PrefabInfo[] = results.map(asset => ({ + name: asset.name, + path: asset.url, + uuid: asset.uuid, + folder: asset.url.substring(0, asset.url.lastIndexOf('/')) + })); + resolve({ success: true, data: prefabs }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async loadPrefab(prefabPath: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => { + if (!assetInfo) { + throw new Error('Prefab not found'); + } + + return Editor.Message.request('scene', 'load-asset', { + uuid: assetInfo.uuid + }); + }).then((prefabData: any) => { + resolve({ + success: true, + data: { + uuid: prefabData.uuid, + name: prefabData.name, + message: 'Prefab loaded successfully' + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async instantiatePrefab(args: any): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', args.prefabPath).then((assetInfo: any) => { + if (!assetInfo) { + throw new Error('Prefab not found'); + } + + const instantiateData: any = { + prefab: assetInfo.uuid + }; + + if (args.parentUuid) { + instantiateData.parent = args.parentUuid; + } + + if (args.position) { + instantiateData.position = args.position; + } + + return Editor.Message.request('scene', 'instantiate-prefab', instantiateData); + }).then((result: any) => { + resolve({ + success: true, + data: { + nodeUuid: result.uuid, + name: result.name, + message: 'Prefab instantiated successfully' + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async createPrefab(args: any): Promise { + return new Promise((resolve) => { + // 支持 prefabPath 和 savePath 两种参数名 + const pathParam = args.prefabPath || args.savePath; + if (!pathParam) { + resolve({ + success: false, + error: 'Missing prefab path parameter. Please provide either prefabPath or savePath.' + }); + return; + } + + const fullPath = pathParam.endsWith('.prefab') ? + pathParam : `${pathParam}/${args.prefabName || 'NewPrefab'}.prefab`; + + // 预制体创建需要特殊的Editor API支持 + // 目前Cocos Creator 3.8的MCP插件环境下，预制体创建功能受限 + + resolve({ + success: false, + error: 'Prefab creation is not supported in the current MCP plugin environment', + instruction: 'Please create prefabs manually by dragging nodes from the scene to the assets folder in the Cocos Creator editor', + data: { + nodeUuid: args.nodeUuid, + requestedPath: fullPath, + suggestion: 'You can manually drag the node from the scene to the assets folder to create a prefab.' + } + }); + }); + } + + private async updatePrefab(prefabPath: string, nodeUuid: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => { + if (!assetInfo) { + throw new Error('Prefab not found'); + } + + return Editor.Message.request('scene', 'apply-prefab', { + node: nodeUuid, + prefab: assetInfo.uuid + }); + }).then(() => { + resolve({ + success: true, + message: 'Prefab updated successfully' + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async revertPrefab(nodeUuid: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'revert-prefab', { + node: nodeUuid + }).then(() => { + resolve({ + success: true, + message: 'Prefab instance reverted successfully' + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async getPrefabInfo(prefabPath: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', prefabPath).then((assetInfo: any) => { + if (!assetInfo) { + throw new Error('Prefab not found'); + } + + return Editor.Message.request('asset-db', 'query-asset-meta', assetInfo.uuid); + }).then((metaInfo: any) => { + const info: PrefabInfo = { + name: metaInfo.name, + uuid: metaInfo.uuid, + path: prefabPath, + folder: prefabPath.substring(0, prefabPath.lastIndexOf('/')), + createTime: metaInfo.createTime, + modifyTime: metaInfo.modifyTime, + dependencies: metaInfo.depends || [] + }; + resolve({ success: true, data: info }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async createPrefabFromNode(args: any): Promise { + // 从 prefabPath 提取名称 + const prefabPath = args.prefabPath; + const prefabName = prefabPath.split('/').pop()?.replace('.prefab', '') || 'NewPrefab'; + + // 调用原来的 createPrefab 方法 + return await this.createPrefab({ + nodeUuid: args.nodeUuid, + savePath: prefabPath, + prefabName: prefabName + }); + } +} \ No newline at end of file diff --git a/source/tools/preferences-tools.ts b/source/tools/preferences-tools.ts new file mode 100644 index 0000000..0820beb --- /dev/null +++ b/source/tools/preferences-tools.ts @@ -0,0 +1,163 @@ +import { ToolDefinition, ToolResponse, ToolExecutor } from '../types'; + +export class PreferencesTools implements ToolExecutor { + getTools(): ToolDefinition[] { + return [ + { + name: 'get_preferences', + description: 'Get editor preferences', + inputSchema: { + type: 'object', + properties: { + key: { + type: 'string', + description: 'Specific preference key to get (optional)' + } + } + } + }, + { + name: 'set_preferences', + description: 'Set editor preferences', + inputSchema: { + type: 'object', + properties: { + key: { + type: 'string', + description: 'Preference key to set' + }, + value: { + description: 'Preference value to set' + } + }, + required: ['key', 'value'] + } + }, + { + name: 'get_global_preferences', + description: 'Get global editor preferences', + inputSchema: { + type: 'object', + properties: { + key: { + type: 'string', + description: 'Global preference key to get (optional)' + } + } + } + }, + { + name: 'set_global_preferences', + description: 'Set global editor preferences', + inputSchema: { + type: 'object', + properties: { + key: { + type: 'string', + description: 'Global preference key to set' + }, + value: { + description: 'Global preference value to set' + } + }, + required: ['key', 'value'] + } + }, + { + name: 'get_recent_projects', + description: 'Get recently opened projects', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'clear_recent_projects', + description: 'Clear recently opened projects list', + inputSchema: { + type: 'object', + properties: {} + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'get_preferences': + return await this.getPreferences(args.key); + case 'set_preferences': + return await this.setPreferences(args.key, args.value); + case 'get_global_preferences': + return await this.getGlobalPreferences(args.key); + case 'set_global_preferences': + return await this.setGlobalPreferences(args.key, args.value); + case 'get_recent_projects': + return await this.getRecentProjects(); + case 'clear_recent_projects': + return await this.clearRecentProjects(); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private async getPreferences(key?: string): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Preferences API is not supported through MCP', + instruction: 'Please access preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor' + }); + }); + } + + private async setPreferences(key: string, value: any): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Preferences API is not supported through MCP', + instruction: 'Please modify preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor' + }); + }); + } + + private async getGlobalPreferences(key?: string): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Global preferences API is not supported through MCP', + instruction: 'Please access global preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor' + }); + }); + } + + private async setGlobalPreferences(key: string, value: any): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Global preferences API is not supported through MCP', + instruction: 'Please modify global preferences through the editor menu: Edit > Preferences or use the preferences panel in the editor' + }); + }); + } + + private async getRecentProjects(): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Recent projects API is not supported through MCP', + instruction: 'Please check recent projects through the editor menu: File > Recent Projects or the start screen' + }); + }); + } + + private async clearRecentProjects(): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Recent projects API is not supported through MCP', + instruction: 'Please clear recent projects through the editor menu: File > Recent Projects or the start screen' + }); + }); + } +} \ No newline at end of file diff --git a/source/tools/project-tools.ts b/source/tools/project-tools.ts new file mode 100644 index 0000000..a5903c0 --- /dev/null +++ b/source/tools/project-tools.ts @@ -0,0 +1,890 @@ +import { ToolDefinition, ToolResponse, ToolExecutor, ProjectInfo, AssetInfo } from '../types'; +import * as fs from 'fs'; +import * as path from 'path'; + +export class ProjectTools implements ToolExecutor { + getTools(): ToolDefinition[] { + return [ + { + name: 'run_project', + description: 'Run the project in preview mode', + inputSchema: { + type: 'object', + properties: { + platform: { + type: 'string', + description: 'Target platform', + enum: ['browser', 'simulator', 'preview'], + default: 'browser' + } + } + } + }, + { + name: 'build_project', + description: 'Build the project', + inputSchema: { + type: 'object', + properties: { + platform: { + type: 'string', + description: 'Build platform', + enum: ['web-mobile', 'web-desktop', 'ios', 'android', 'windows', 'mac'] + }, + debug: { + type: 'boolean', + description: 'Debug build', + default: true + } + }, + required: ['platform'] + } + }, + { + name: 'get_project_info', + description: 'Get project information', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_project_settings', + description: 'Get project settings', + inputSchema: { + type: 'object', + properties: { + category: { + type: 'string', + description: 'Settings category', + enum: ['general', 'physics', 'render', 'assets'], + default: 'general' + } + } + } + }, + { + name: 'refresh_assets', + description: 'Refresh asset database', + inputSchema: { + type: 'object', + properties: { + folder: { + type: 'string', + description: 'Specific folder to refresh (optional)' + } + } + } + }, + { + name: 'import_asset', + description: 'Import an asset file', + inputSchema: { + type: 'object', + properties: { + sourcePath: { + type: 'string', + description: 'Source file path' + }, + targetFolder: { + type: 'string', + description: 'Target folder in assets' + } + }, + required: ['sourcePath', 'targetFolder'] + } + }, + { + name: 'get_asset_info', + description: 'Get asset information', + inputSchema: { + type: 'object', + properties: { + assetPath: { + type: 'string', + description: 'Asset path (db://assets/...)' + } + }, + required: ['assetPath'] + } + }, + { + name: 'get_assets', + description: 'Get assets by type', + inputSchema: { + type: 'object', + properties: { + type: { + type: 'string', + description: 'Asset type filter', + enum: ['all', 'scene', 'prefab', 'script', 'texture', 'material', 'mesh', 'audio', 'animation'], + default: 'all' + }, + folder: { + type: 'string', + description: 'Folder to search in', + default: 'db://assets' + } + } + } + }, + { + name: 'get_build_settings', + description: 'Get build settings - shows current limitations', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'open_build_panel', + description: 'Open the build panel in the editor', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'check_builder_status', + description: 'Check if builder worker is ready', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'start_preview_server', + description: 'Start preview server', + inputSchema: { + type: 'object', + properties: { + port: { + type: 'number', + description: 'Preview server port', + default: 7456 + } + } + } + }, + { + name: 'stop_preview_server', + description: 'Stop preview server', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'create_asset', + description: 'Create a new asset file or folder', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL (e.g., db://assets/newfile.json)' + }, + content: { + type: 'string', + description: 'File content (null for folder)', + default: null + }, + overwrite: { + type: 'boolean', + description: 'Overwrite existing file', + default: false + } + }, + required: ['url'] + } + }, + { + name: 'copy_asset', + description: 'Copy an asset to another location', + inputSchema: { + type: 'object', + properties: { + source: { + type: 'string', + description: 'Source asset URL' + }, + target: { + type: 'string', + description: 'Target location URL' + }, + overwrite: { + type: 'boolean', + description: 'Overwrite existing file', + default: false + } + }, + required: ['source', 'target'] + } + }, + { + name: 'move_asset', + description: 'Move an asset to another location', + inputSchema: { + type: 'object', + properties: { + source: { + type: 'string', + description: 'Source asset URL' + }, + target: { + type: 'string', + description: 'Target location URL' + }, + overwrite: { + type: 'boolean', + description: 'Overwrite existing file', + default: false + } + }, + required: ['source', 'target'] + } + }, + { + name: 'delete_asset', + description: 'Delete an asset', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL to delete' + } + }, + required: ['url'] + } + }, + { + name: 'save_asset', + description: 'Save asset content', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL' + }, + content: { + type: 'string', + description: 'Asset content' + } + }, + required: ['url', 'content'] + } + }, + { + name: 'reimport_asset', + description: 'Reimport an asset', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL to reimport' + } + }, + required: ['url'] + } + }, + { + name: 'query_asset_path', + description: 'Get asset disk path', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL' + } + }, + required: ['url'] + } + }, + { + name: 'query_asset_uuid', + description: 'Get asset UUID from URL', + inputSchema: { + type: 'object', + properties: { + url: { + type: 'string', + description: 'Asset URL' + } + }, + required: ['url'] + } + }, + { + name: 'query_asset_url', + description: 'Get asset URL from UUID', + inputSchema: { + type: 'object', + properties: { + uuid: { + type: 'string', + description: 'Asset UUID' + } + }, + required: ['uuid'] + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'run_project': + return await this.runProject(args.platform); + case 'build_project': + return await this.buildProject(args); + case 'get_project_info': + return await this.getProjectInfo(); + case 'get_project_settings': + return await this.getProjectSettings(args.category); + case 'refresh_assets': + return await this.refreshAssets(args.folder); + case 'import_asset': + return await this.importAsset(args.sourcePath, args.targetFolder); + case 'get_asset_info': + return await this.getAssetInfo(args.assetPath); + case 'get_assets': + return await this.getAssets(args.type, args.folder); + case 'get_build_settings': + return await this.getBuildSettings(); + case 'open_build_panel': + return await this.openBuildPanel(); + case 'check_builder_status': + return await this.checkBuilderStatus(); + case 'start_preview_server': + return await this.startPreviewServer(args.port); + case 'stop_preview_server': + return await this.stopPreviewServer(); + case 'create_asset': + return await this.createAsset(args.url, args.content, args.overwrite); + case 'copy_asset': + return await this.copyAsset(args.source, args.target, args.overwrite); + case 'move_asset': + return await this.moveAsset(args.source, args.target, args.overwrite); + case 'delete_asset': + return await this.deleteAsset(args.url); + case 'save_asset': + return await this.saveAsset(args.url, args.content); + case 'reimport_asset': + return await this.reimportAsset(args.url); + case 'query_asset_path': + return await this.queryAssetPath(args.url); + case 'query_asset_uuid': + return await this.queryAssetUuid(args.url); + case 'query_asset_url': + return await this.queryAssetUrl(args.uuid); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private async runProject(platform: string = 'browser'): Promise { + return new Promise((resolve) => { + const previewConfig = { + platform: platform, + scenes: [] // Will use current scene + }; + + Editor.Message.request('preview', 'start', previewConfig).then(() => { + resolve({ + success: true, + message: `Project is running in ${platform} mode` + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async buildProject(args: any): Promise { + return new Promise((resolve) => { + const buildOptions = { + platform: args.platform, + debug: args.debug !== false, + sourceMaps: args.debug !== false, + buildPath: `build/${args.platform}` + }; + + Editor.Message.request('builder', 'build', buildOptions).then(() => { + resolve({ + success: true, + message: `Project built for ${args.platform}`, + data: { buildPath: buildOptions.buildPath } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async getProjectInfo(): Promise { + return new Promise((resolve) => { + const info: ProjectInfo = { + name: Editor.Project.name, + path: Editor.Project.path, + uuid: Editor.Project.uuid, + version: (Editor.Project as any).version || '1.0.0', + cocosVersion: (Editor as any).versions?.cocos || 'Unknown' + }; + + Editor.Message.request('project', 'query-info').then((additionalInfo: any) => { + Object.assign(info, additionalInfo); + resolve({ success: true, data: info }); + }).catch(() => { + // Return basic info even if detailed query fails + resolve({ success: true, data: info }); + }); + }); + } + + private async getProjectSettings(category: string = 'general'): Promise { + return new Promise((resolve) => { + // 使用正确的 project API 查询项目配置 + const configMap: Record = { + general: 'project', + physics: 'physics', + render: 'render', + assets: 'asset-db' + }; + + const configName = configMap[category] || 'project'; + + Editor.Message.request('project', 'query-config', configName).then((settings: any) => { + resolve({ + success: true, + data: { + category: category, + config: settings, + message: `${category} settings retrieved successfully` + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async refreshAssets(folder?: string): Promise { + return new Promise((resolve) => { + // 使用正确的 asset-db API 刷新资源 + const targetPath = folder || 'db://assets'; + + Editor.Message.request('asset-db', 'refresh-asset', targetPath).then(() => { + resolve({ + success: true, + message: `Assets refreshed in: ${targetPath}` + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async importAsset(sourcePath: string, targetFolder: string): Promise { + return new Promise((resolve) => { + if (!fs.existsSync(sourcePath)) { + resolve({ success: false, error: 'Source file not found' }); + return; + } + + const fileName = path.basename(sourcePath); + const targetPath = targetFolder.startsWith('db://') ? + targetFolder : `db://assets/${targetFolder}`; + + Editor.Message.request('asset-db', 'import-asset', sourcePath, `${targetPath}/${fileName}`).then((result: any) => { + resolve({ + success: true, + data: { + uuid: result.uuid, + path: result.url, + message: `Asset imported: ${fileName}` + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async getAssetInfo(assetPath: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-asset-info', assetPath).then((assetInfo: any) => { + if (!assetInfo) { + throw new Error('Asset not found'); + } + + const info: AssetInfo = { + name: assetInfo.name, + uuid: assetInfo.uuid, + path: assetInfo.url, + type: assetInfo.type, + size: assetInfo.size, + isDirectory: assetInfo.isDirectory + }; + + if (assetInfo.meta) { + info.meta = { + ver: assetInfo.meta.ver, + importer: assetInfo.meta.importer + }; + } + + resolve({ success: true, data: info }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async getAssets(type: string = 'all', folder: string = 'db://assets'): Promise { + return new Promise((resolve) => { + let pattern = `${folder}/**/*`; + + // 添加类型过滤 + if (type !== 'all') { + const typeExtensions: Record = { + 'scene': '.scene', + 'prefab': '.prefab', + 'script': '.{ts,js}', + 'texture': '.{png,jpg,jpeg,gif,tga,bmp,psd}', + 'material': '.mtl', + 'mesh': '.{fbx,obj,dae}', + 'audio': '.{mp3,ogg,wav,m4a}', + 'animation': '.{anim,clip}' + }; + + const extension = typeExtensions[type]; + if (extension) { + pattern = `${folder}/**/*${extension}`; + } + } + + Editor.Message.request('asset-db', 'query-assets', { + pattern: pattern + }).then((results: any[]) => { + const assets = results.map(asset => ({ + name: asset.name, + uuid: asset.uuid, + path: asset.url, + type: asset.type, + size: asset.size || 0, + isDirectory: asset.isDirectory || false + })); + + resolve({ + success: true, + data: { + type: type, + folder: folder, + count: assets.length, + assets: assets + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async getBuildSettings(): Promise { + return new Promise((resolve) => { + // 检查构建器是否准备就绪 + Editor.Message.request('builder', 'query-worker-ready').then((ready: boolean) => { + resolve({ + success: true, + data: { + builderReady: ready, + message: 'Build settings are limited in MCP plugin environment', + availableActions: [ + 'Open build panel with open_build_panel', + 'Check builder status with check_builder_status', + 'Start preview server with start_preview_server', + 'Stop preview server with stop_preview_server' + ], + limitation: 'Full build configuration requires direct Editor UI access' + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async openBuildPanel(): Promise { + return new Promise((resolve) => { + Editor.Message.request('builder', 'open').then(() => { + resolve({ + success: true, + message: 'Build panel opened successfully' + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async checkBuilderStatus(): Promise { + return new Promise((resolve) => { + Editor.Message.request('builder', 'query-worker-ready').then((ready: boolean) => { + resolve({ + success: true, + data: { + ready: ready, + status: ready ? 'Builder worker is ready' : 'Builder worker is not ready', + message: 'Builder status checked successfully' + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async startPreviewServer(port: number = 7456): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Preview server control is not supported through MCP API', + instruction: 'Please start the preview server manually using the editor menu: Project > Preview, or use the preview panel in the editor' + }); + }); + } + + private async stopPreviewServer(): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Preview server control is not supported through MCP API', + instruction: 'Please stop the preview server manually using the preview panel in the editor' + }); + }); + } + + private async createAsset(url: string, content: string | null = null, overwrite: boolean = false): Promise { + return new Promise((resolve) => { + const options = { + overwrite: overwrite, + rename: !overwrite + }; + + Editor.Message.request('asset-db', 'create-asset', url, content, options).then((result: any) => { + if (result && result.uuid) { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + message: content === null ? 'Folder created successfully' : 'File created successfully' + } + }); + } else { + resolve({ + success: true, + data: { + url: url, + message: content === null ? 'Folder created successfully' : 'File created successfully' + } + }); + } + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async copyAsset(source: string, target: string, overwrite: boolean = false): Promise { + return new Promise((resolve) => { + const options = { + overwrite: overwrite, + rename: !overwrite + }; + + Editor.Message.request('asset-db', 'copy-asset', source, target, options).then((result: any) => { + if (result && result.uuid) { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + message: 'Asset copied successfully' + } + }); + } else { + resolve({ + success: true, + data: { + source: source, + target: target, + message: 'Asset copied successfully' + } + }); + } + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async moveAsset(source: string, target: string, overwrite: boolean = false): Promise { + return new Promise((resolve) => { + const options = { + overwrite: overwrite, + rename: !overwrite + }; + + Editor.Message.request('asset-db', 'move-asset', source, target, options).then((result: any) => { + if (result && result.uuid) { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + message: 'Asset moved successfully' + } + }); + } else { + resolve({ + success: true, + data: { + source: source, + target: target, + message: 'Asset moved successfully' + } + }); + } + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async deleteAsset(url: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'delete-asset', url).then((result: any) => { + resolve({ + success: true, + data: { + url: url, + message: 'Asset deleted successfully' + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async saveAsset(url: string, content: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'save-asset', url, content).then((result: any) => { + if (result && result.uuid) { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + message: 'Asset saved successfully' + } + }); + } else { + resolve({ + success: true, + data: { + url: url, + message: 'Asset saved successfully' + } + }); + } + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async reimportAsset(url: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'reimport-asset', url).then(() => { + resolve({ + success: true, + data: { + url: url, + message: 'Asset reimported successfully' + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async queryAssetPath(url: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-path', url).then((path: string | null) => { + if (path) { + resolve({ + success: true, + data: { + url: url, + path: path, + message: 'Asset path retrieved successfully' + } + }); + } else { + resolve({ success: false, error: 'Asset path not found' }); + } + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async queryAssetUuid(url: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-uuid', url).then((uuid: string | null) => { + if (uuid) { + resolve({ + success: true, + data: { + url: url, + uuid: uuid, + message: 'Asset UUID retrieved successfully' + } + }); + } else { + resolve({ success: false, error: 'Asset UUID not found' }); + } + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async queryAssetUrl(uuid: string): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-url', uuid).then((url: string | null) => { + if (url) { + resolve({ + success: true, + data: { + uuid: uuid, + url: url, + message: 'Asset URL retrieved successfully' + } + }); + } else { + resolve({ success: false, error: 'Asset URL not found' }); + } + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } +} \ No newline at end of file diff --git a/source/tools/scene-tools.ts b/source/tools/scene-tools.ts new file mode 100644 index 0000000..69917e8 --- /dev/null +++ b/source/tools/scene-tools.ts @@ -0,0 +1,465 @@ +import { ToolDefinition, ToolResponse, ToolExecutor, SceneInfo } from '../types'; + +export class SceneTools implements ToolExecutor { + getTools(): ToolDefinition[] { + return [ + { + name: 'get_current_scene', + description: 'Get current scene information', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_scene_list', + description: 'Get all scenes in the project', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'open_scene', + description: 'Open a scene by path', + inputSchema: { + type: 'object', + properties: { + scenePath: { + type: 'string', + description: 'The scene file path' + } + }, + required: ['scenePath'] + } + }, + { + name: 'save_scene', + description: 'Save current scene', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'create_scene', + description: 'Create a new scene asset', + inputSchema: { + type: 'object', + properties: { + sceneName: { + type: 'string', + description: 'Name of the new scene' + }, + savePath: { + type: 'string', + description: 'Path to save the scene (e.g., db://assets/scenes/NewScene.scene)' + } + }, + required: ['sceneName', 'savePath'] + } + }, + { + name: 'save_scene_as', + description: 'Save scene as new file', + inputSchema: { + type: 'object', + properties: { + path: { + type: 'string', + description: 'Path to save the scene' + } + }, + required: ['path'] + } + }, + { + name: 'close_scene', + description: 'Close current scene', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_scene_hierarchy', + description: 'Get the complete hierarchy of current scene', + inputSchema: { + type: 'object', + properties: { + includeComponents: { + type: 'boolean', + description: 'Include component information', + default: false + } + } + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'get_current_scene': + return await this.getCurrentScene(); + case 'get_scene_list': + return await this.getSceneList(); + case 'open_scene': + return await this.openScene(args.scenePath); + case 'save_scene': + return await this.saveScene(); + case 'create_scene': + return await this.createScene(args.sceneName, args.savePath); + case 'save_scene_as': + return await this.saveSceneAs(args.path); + case 'close_scene': + return await this.closeScene(); + case 'get_scene_hierarchy': + return await this.getSceneHierarchy(args.includeComponents); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private async getCurrentScene(): Promise { + return new Promise((resolve) => { + // 直接使用 query-node-tree 来获取场景信息（这个方法已经验证可用） + Editor.Message.request('scene', 'query-node-tree').then((tree: any) => { + if (tree && tree.uuid) { + resolve({ + success: true, + data: { + name: tree.name || 'Current Scene', + uuid: tree.uuid, + type: tree.type || 'cc.Scene', + active: tree.active !== undefined ? tree.active : true, + nodeCount: tree.children ? tree.children.length : 0 + } + }); + } else { + resolve({ success: false, error: 'No scene data available' }); + } + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getCurrentSceneInfo', + args: [] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private async getSceneList(): Promise { + return new Promise((resolve) => { + Editor.Message.request('asset-db', 'query-assets', { + pattern: 'db://assets/**/*.scene' + }).then((results: any[]) => { + const scenes: SceneInfo[] = results.map(asset => ({ + name: asset.name, + path: asset.url, + uuid: asset.uuid + })); + resolve({ success: true, data: scenes }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async openScene(scenePath: string): Promise { + return new Promise((resolve) => { + // 首先获取场景的UUID + Editor.Message.request('asset-db', 'query-uuid', scenePath).then((uuid: string | null) => { + if (!uuid) { + throw new Error('Scene not found'); + } + + // 使用正确的 scene API 打开场景 (需要UUID) + return Editor.Message.request('scene', 'open-scene', uuid); + }).then(() => { + resolve({ success: true, message: `Scene opened: ${scenePath}` }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async saveScene(): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'save-scene').then(() => { + resolve({ success: true, message: 'Scene saved successfully' }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async createScene(sceneName: string, savePath: string): Promise { + return new Promise((resolve) => { + // 确保路径以.scene结尾 + const fullPath = savePath.endsWith('.scene') ? savePath : `${savePath}/${sceneName}.scene`; + + // 使用正确的Cocos Creator 3.8场景格式 + const sceneContent = JSON.stringify([ + { + "__type__": "cc.SceneAsset", + "_name": sceneName, + "_objFlags": 0, + "__editorExtras__": {}, + "_native": "", + "scene": { + "__id__": 1 + } + }, + { + "__type__": "cc.Scene", + "_name": sceneName, + "_objFlags": 0, + "__editorExtras__": {}, + "_parent": null, + "_children": [], + "_active": true, + "_components": [], + "_prefab": null, + "_lpos": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "_lrot": { + "__type__": "cc.Quat", + "x": 0, + "y": 0, + "z": 0, + "w": 1 + }, + "_lscale": { + "__type__": "cc.Vec3", + "x": 1, + "y": 1, + "z": 1 + }, + "_mobility": 0, + "_layer": 1073741824, + "_euler": { + "__type__": "cc.Vec3", + "x": 0, + "y": 0, + "z": 0 + }, + "autoReleaseAssets": false, + "_globals": { + "__id__": 2 + }, + "_id": "scene" + }, + { + "__type__": "cc.SceneGlobals", + "ambient": { + "__id__": 3 + }, + "skybox": { + "__id__": 4 + }, + "fog": { + "__id__": 5 + }, + "octree": { + "__id__": 6 + } + }, + { + "__type__": "cc.AmbientInfo", + "_skyColorHDR": { + "__type__": "cc.Vec4", + "x": 0.2, + "y": 0.5, + "z": 0.8, + "w": 0.520833 + }, + "_skyColor": { + "__type__": "cc.Vec4", + "x": 0.2, + "y": 0.5, + "z": 0.8, + "w": 0.520833 + }, + "_skyIllumHDR": 20000, + "_skyIllum": 20000, + "_groundAlbedoHDR": { + "__type__": "cc.Vec4", + "x": 0.2, + "y": 0.2, + "z": 0.2, + "w": 1 + }, + "_groundAlbedo": { + "__type__": "cc.Vec4", + "x": 0.2, + "y": 0.2, + "z": 0.2, + "w": 1 + } + }, + { + "__type__": "cc.SkyboxInfo", + "_envLightingType": 0, + "_envmapHDR": null, + "_envmap": null, + "_envmapLodCount": 0, + "_diffuseMapHDR": null, + "_diffuseMap": null, + "_enabled": false, + "_useHDR": true, + "_editableMaterial": null, + "_reflectionHDR": null, + "_reflectionMap": null, + "_rotationAngle": 0 + }, + { + "__type__": "cc.FogInfo", + "_type": 0, + "_fogColor": { + "__type__": "cc.Color", + "r": 200, + "g": 200, + "b": 200, + "a": 255 + }, + "_enabled": false, + "_fogDensity": 0.3, + "_fogStart": 0.5, + "_fogEnd": 300, + "_fogAtten": 5, + "_fogTop": 1.5, + "_fogRange": 1.2, + "_accurate": false + }, + { + "__type__": "cc.OctreeInfo", + "_enabled": false, + "_minPos": { + "__type__": "cc.Vec3", + "x": -1024, + "y": -1024, + "z": -1024 + }, + "_maxPos": { + "__type__": "cc.Vec3", + "x": 1024, + "y": 1024, + "z": 1024 + }, + "_depth": 8 + } + ], null, 2); + + Editor.Message.request('asset-db', 'create-asset', fullPath, sceneContent).then((result: any) => { + resolve({ + success: true, + data: { + uuid: result.uuid, + url: result.url, + name: sceneName, + message: `Scene '${sceneName}' created successfully` + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async getSceneHierarchy(includeComponents: boolean = false): Promise { + return new Promise((resolve) => { + // 优先尝试使用 Editor API 查询场景节点树 + Editor.Message.request('scene', 'query-node-tree').then((tree: any) => { + if (tree) { + const hierarchy = this.buildHierarchy(tree, includeComponents); + resolve({ + success: true, + data: hierarchy + }); + } else { + resolve({ success: false, error: 'No scene hierarchy available' }); + } + }).catch((err: Error) => { + // 备用方案：使用场景脚本 + const options = { + name: 'cocos-mcp-server', + method: 'getSceneHierarchy', + args: [includeComponents] + }; + + Editor.Message.request('scene', 'execute-scene-script', options).then((result: any) => { + resolve(result); + }).catch((err2: Error) => { + resolve({ success: false, error: `Direct API failed: ${err.message}, Scene script failed: ${err2.message}` }); + }); + }); + }); + } + + private buildHierarchy(node: any, includeComponents: boolean): any { + const nodeInfo: any = { + uuid: node.uuid, + name: node.name, + type: node.type, + active: node.active, + children: [] + }; + + if (includeComponents && node.__comps__) { + nodeInfo.components = node.__comps__.map((comp: any) => ({ + type: comp.__type__ || 'Unknown', + enabled: comp.enabled !== undefined ? comp.enabled : true + })); + } + + if (node.children) { + nodeInfo.children = node.children.map((child: any) => + this.buildHierarchy(child, includeComponents) + ); + } + + return nodeInfo; + } + + private async saveSceneAs(path: string): Promise { + return new Promise((resolve) => { + // save-as-scene API 不接受路径参数，会弹出对话框让用户选择 + (Editor.Message.request as any)('scene', 'save-as-scene').then(() => { + resolve({ + success: true, + data: { + path: path, + message: `Scene save-as dialog opened` + } + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } + + private async closeScene(): Promise { + return new Promise((resolve) => { + Editor.Message.request('scene', 'close-scene').then(() => { + resolve({ + success: true, + message: 'Scene closed successfully' + }); + }).catch((err: Error) => { + resolve({ success: false, error: err.message }); + }); + }); + } +} \ No newline at end of file diff --git a/source/tools/server-tools.ts b/source/tools/server-tools.ts new file mode 100644 index 0000000..61c574e --- /dev/null +++ b/source/tools/server-tools.ts @@ -0,0 +1,247 @@ +import { ToolDefinition, ToolResponse, ToolExecutor } from '../types'; + +export class ServerTools implements ToolExecutor { + getTools(): ToolDefinition[] { + return [ + { + name: 'get_server_info', + description: 'Get server information', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'broadcast_custom_message', + description: 'Broadcast a custom message', + inputSchema: { + type: 'object', + properties: { + message: { + type: 'string', + description: 'Message name' + }, + data: { + description: 'Message data (optional)' + } + }, + required: ['message'] + } + }, + { + name: 'get_editor_version', + description: 'Get editor version information', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_project_name', + description: 'Get current project name', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_project_path', + description: 'Get current project path', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'get_project_uuid', + description: 'Get current project UUID', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'restart_editor', + description: 'Request to restart the editor', + inputSchema: { + type: 'object', + properties: {} + } + }, + { + name: 'quit_editor', + description: 'Request to quit the editor', + inputSchema: { + type: 'object', + properties: {} + } + } + ]; + } + + async execute(toolName: string, args: any): Promise { + switch (toolName) { + case 'get_server_info': + return await this.getServerInfo(); + case 'broadcast_custom_message': + return await this.broadcastCustomMessage(args.message, args.data); + case 'get_editor_version': + return await this.getEditorVersion(); + case 'get_project_name': + return await this.getProjectName(); + case 'get_project_path': + return await this.getProjectPath(); + case 'get_project_uuid': + return await this.getProjectUuid(); + case 'restart_editor': + return await this.restartEditor(); + case 'quit_editor': + return await this.quitEditor(); + default: + throw new Error(`Unknown tool: ${toolName}`); + } + } + + private async getServerInfo(): Promise { + return new Promise((resolve) => { + try { + const info = { + editorVersion: (Editor as any).versions?.editor || 'Unknown', + cocosVersion: (Editor as any).versions?.cocos || 'Unknown', + nodeVersion: process.version, + platform: process.platform, + arch: process.arch, + projectName: Editor.Project.name, + projectPath: Editor.Project.path, + projectUuid: Editor.Project.uuid + }; + + resolve({ + success: true, + data: { + server: info, + message: 'Server information retrieved successfully' + } + }); + } catch (err: any) { + resolve({ success: false, error: err.message }); + } + }); + } + + private async broadcastCustomMessage(message: string, data?: any): Promise { + return new Promise((resolve) => { + try { + if (data !== undefined) { + Editor.Message.broadcast(message, data); + } else { + Editor.Message.broadcast(message); + } + + resolve({ + success: true, + data: { + message: message, + data: data, + result: 'Message broadcasted successfully' + } + }); + } catch (err: any) { + resolve({ success: false, error: err.message }); + } + }); + } + + private async getEditorVersion(): Promise { + return new Promise((resolve) => { + try { + const version = { + editor: (Editor as any).versions?.editor || 'Unknown', + cocos: (Editor as any).versions?.cocos || 'Unknown', + node: process.version + }; + + resolve({ + success: true, + data: { + version: version, + message: 'Editor version retrieved successfully' + } + }); + } catch (err: any) { + resolve({ success: false, error: err.message }); + } + }); + } + + private async getProjectName(): Promise { + return new Promise((resolve) => { + try { + const name = Editor.Project.name; + resolve({ + success: true, + data: { + name: name, + message: 'Project name retrieved successfully' + } + }); + } catch (err: any) { + resolve({ success: false, error: err.message }); + } + }); + } + + private async getProjectPath(): Promise { + return new Promise((resolve) => { + try { + const path = Editor.Project.path; + resolve({ + success: true, + data: { + path: path, + message: 'Project path retrieved successfully' + } + }); + } catch (err: any) { + resolve({ success: false, error: err.message }); + } + }); + } + + private async getProjectUuid(): Promise { + return new Promise((resolve) => { + try { + const uuid = Editor.Project.uuid; + resolve({ + success: true, + data: { + uuid: uuid, + message: 'Project UUID retrieved successfully' + } + }); + } catch (err: any) { + resolve({ success: false, error: err.message }); + } + }); + } + + private async restartEditor(): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Editor restart is not supported through MCP API', + instruction: 'Please restart the editor manually or use the editor menu: File > Restart Editor' + }); + }); + } + + private async quitEditor(): Promise { + return new Promise((resolve) => { + resolve({ + success: false, + error: 'Editor quit is not supported through MCP API', + instruction: 'Please quit the editor manually or use the editor menu: File > Quit' + }); + }); + } +} \ No newline at end of file diff --git a/source/types/index.ts b/source/types/index.ts new file mode 100644 index 0000000..6bfc5d6 --- /dev/null +++ b/source/types/index.ts @@ -0,0 +1,124 @@ +export interface MCPServerSettings { + port: number; + autoStart: boolean; + enableDebugLog: boolean; + allowedOrigins: string[]; + maxConnections: number; +} + +export interface ServerStatus { + running: boolean; + port: number; + clients: number; +} + +export interface ToolDefinition { + name: string; + description: string; + inputSchema: any; +} + +export interface ToolResponse { + success: boolean; + data?: any; + message?: string; + error?: string; + instruction?: string; +} + +export interface NodeInfo { + uuid: string; + name: string; + active: boolean; + position?: { x: number; y: number; z: number }; + rotation?: { x: number; y: number; z: number }; + scale?: { x: number; y: number; z: number }; + parent?: string; + children?: string[]; + components?: ComponentInfo[]; + layer?: number; + mobility?: number; +} + +export interface ComponentInfo { + type: string; + enabled: boolean; + properties?: Record; +} + +export interface SceneInfo { + name: string; + uuid: string; + path: string; +} + +export interface PrefabInfo { + name: string; + uuid: string; + path: string; + folder: string; + createTime?: string; + modifyTime?: string; + dependencies?: string[]; +} + +export interface AssetInfo { + name: string; + uuid: string; + path: string; + type: string; + size?: number; + isDirectory: boolean; + meta?: { + ver: string; + importer: string; + }; +} + +export interface ProjectInfo { + name: string; + path: string; + uuid: string; + version: string; + cocosVersion: string; +} + +export interface ConsoleMessage { + timestamp: string; + type: 'log' | 'warn' | 'error' | 'info'; + message: string; + stack?: string; +} + +export interface PerformanceStats { + nodeCount: number; + componentCount: number; + drawCalls: number; + triangles: number; + memory: Record; +} + +export interface ValidationIssue { + type: 'error' | 'warning' | 'info'; + category: string; + message: string; + details?: any; + suggestion?: string; +} + +export interface ValidationResult { + valid: boolean; + issueCount: number; + issues: ValidationIssue[]; +} + +export interface MCPClient { + id: string; + lastActivity: Date; + userAgent?: string; +} + +export interface ToolExecutor { + getTools(): ToolDefinition[]; + execute(toolName: string, args: any): Promise; +} \ No newline at end of file diff --git a/static/icon.png b/static/icon.png new file mode 100644 index 0000000..cdda77f Binary files /dev/null and b/static/icon.png differ diff --git a/static/style/default/index.css b/static/style/default/index.css new file mode 100644 index 0000000..aaa857e --- /dev/null +++ b/static/style/default/index.css @@ -0,0 +1,65 @@ +.mcp-server-panel { + padding: 20px; + display: flex; + flex-direction: column; + height: 100%; + min-height: 100%; + max-height: 100%; + overflow-y: auto; + box-sizing: border-box; +} + +header h2 { + margin: 0 0 20px 0; + font-size: 18px; +} + +section { + margin-bottom: 20px; + padding: 15px; + background: var(--color-normal-fill-emphasis); + border-radius: 4px; +} + +section h3 { + margin: 0 0 15px 0; + font-size: 14px; + font-weight: 600; +} + +.status-value { + font-weight: 600; +} + +.status-value.running { + color: var(--color-success-fill); +} + +.status-value.stopped { + color: var(--color-warn-fill); +} + +.server-controls { + display: flex; + justify-content: center; + padding: 20px; +} + +.server-controls ui-button { + min-width: 150px; +} + +.connection-details { + margin-top: 10px; +} + +footer { + margin-top: auto; + padding-top: 20px; + display: flex; + justify-content: flex-end; +} + +ui-prop { + margin-bottom: 10px; +} \ No newline at end of file diff --git a/static/template/default/index.html b/static/template/default/index.html new file mode 100644 index 0000000..c3658ee --- /dev/null +++ b/static/template/default/index.html @@ -0,0 +1,64 @@ +
+
+

+
+ +
+

+
+ + + + + + + + +
+
+ +
+ +
+ +
+

+ + + + + + + + + + + + + + + + + + +
+ +
+

+
+ + + + + + +
+
+ + +
\ No newline at end of file diff --git a/tsconfig.json b/tsconfig.json new file mode 100755 index 0000000..78832ec --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,11 @@ +{ + "extends": "./base.tsconfig.json", + "compilerOptions": { + "outDir": "./dist", + "rootDir": "./source", + "types": [ + "node", + "@cocos/creator-types/editor", + ] + } +} \ No newline at end of file