dsh-unity-mcp 0.0.5 → 0.0.6

package/README.md

@@ -6,7 +6,7 @@
 
 ## 能做什么
 
-**不依赖已连接的 Unity MCP：** 在 Windows 上按工程版本匹配并打开编辑器、等待工程就绪、准备 CoderGamester 安装、保存已加载场景和修改资源、先保存再安全关闭编辑器，以及保存 DSH 的工程连接配置。保存、关闭和就绪检查会向工程加入一个小型 Editor 桥接，仍需编辑器正常编译并运行。
+**不依赖已连接的 Unity MCP：** 在 Windows 上查看已打开的工程及 DSH 配置的连接目标，按工程版本匹配并打开编辑器、等待工程就绪、准备 CoderGamester 安装、保存已加载场景和修改资源、先保存再安全关闭编辑器，以及保存 DSH 的工程连接配置。保存、关闭和就绪检查会向工程加入一个小型 Editor 桥接，仍需编辑器正常编译并运行。
 
 **依赖引擎端 CoderGamester MCP：** 查询和编辑场景、GameObject、组件、材质与资源，查看控制台，以及调用上游提供的编辑器和测试功能。具体能力随上游版本变化；有工具清单不代表编辑器已经连通。
 
@@ -28,9 +28,11 @@ dsh-unity-mcp
 
 可以直接说：“打开 `C:/Projects/MyGame`，准备 CoderGamester，再连接这个工程。”
 
-Agent 加载工具后，会匹配工程要求的编辑器版本并打开工程，等待编辑器就绪，再准备包依赖和自动启动。工程处于关闭状态时，也可以先离线准备安装，再打开编辑器。包依赖固定在已核验的上游 commit，已有不同的 CoderGamester 依赖时不会擅自替换；其他包会保留。
+Agent 加载工具后，先用 `unity_project` 的 `list` 查看打开的工程和 DSH 配置的连接目标，再对明确的工程路径执行 `status`、`open`、`save` 或 `close`。`list` 只读，不会写入桥接或启动工程；工程路径无法读取的编辑器进程也会列出，并标为未知。`status` 会检查就绪但不启动编辑器，`open` 则在需要时按版本匹配并启动。
 
-**打开工程需要时间。** 工具会等待编辑器完成当前导入、编译并回应新鲜握手：返回 `editor_ready` / `editorReady: true` 才代表这次编辑器就绪检查通过。`editor_loading` 表示仍未确认就绪，应再次调用打开工具继续等待，不要重复启动或直接假设工程已经加载完成。运行或启动中的工程，安装工具也会在修改依赖前执行就绪检查；等待失败不会改写依赖。关闭工程的离线安装只代表文件准备完成，不代表工程已打开。
+安装 CoderGamester 和保存 DSH 连接分别由独立工具处理，避免把打开工程、修改包和切换所有会话的连接混为一次操作。工程处于关闭状态时，也可以先离线准备安装，再打开编辑器。包依赖固定在已核验的上游 commit，已有不同的 CoderGamester 依赖时不会擅自替换；其他包会保留。
+
+**打开工程需要时间。** 工具会等待编辑器完成当前导入、编译并回应新鲜握手：返回 `editor_ready` / `editorReady: true` 才代表这次编辑器就绪检查通过。`list` 中的 `running_not_verified` 只表示发现了进程。`status` 返回 `readiness_unconfirmed` 或 `open` 返回 `editor_loading` 时，应继续检查或等待，不要重复启动或假设工程已经加载完成。运行或启动中的工程，安装工具也会在修改依赖前执行就绪检查；等待失败不会改写依赖。关闭工程的离线安装只代表文件准备完成，不代表工程已打开。
 
 编辑器就绪仍不等于 MCP 连通。Package Manager 还需下载和编译引擎包，服务需要成功启动；Node 服务器缺少构建文件时，还需在其 `Server~` 目录执行 `npm install` 和 `npm run build`。安装工具不会代为下载或构建 Node 服务器，也不自动改变 DSH 连接。
 

package/index.mjs

@@ -2,8 +2,7 @@ import z from '@deepseek-ai/schemastery';
 import * as mcp from '@deepseek-ai/dsh-mcp-client';
 import { connectionConfig } from './lib/connection.mjs';
 import { installLazyTools } from './lib/lazy-tools.mjs';
-import { openProjectTool } from './lib/open-project.mjs';
-import { lifecycleTools } from './lib/project-lifecycle.mjs';
+import { projectTool } from './lib/project.mjs';
 import { installationTool } from './lib/install-codergamester.mjs';
 import { configurationTool } from './lib/configure-project.mjs';
 export const name = 'dsh-unity-mcp';
@@ -19,7 +18,7 @@ export const Config = z.object({
 });
 export async function apply(ctx, config) {
   // Install the loader even before configuration, so discovery explains setup.
-  installLazyTools(ctx, config.lazyTools, [configurationTool(ctx), openProjectTool(), ...lifecycleTools(), installationTool()]);
+  installLazyTools(ctx, config.lazyTools, [projectTool(ctx), installationTool(), configurationTool(ctx)]);
   if (!config.projectPath && !config.serverPath) {
     ctx.logger.info('Unity MCP: configure projectPath or serverPath to connect CoderGamester/mcp-unity.');
     return;

package/lib/install-codergamester.mjs

@@ -17,7 +17,7 @@ export async function installCoderGamester(input, deps = {}) {
     const lock = await stat(path.join(root, 'Temp/UnityLockfile')).catch(e => { if (e.code !== 'ENOENT') throw e; });
     if (editor || launchPending(root) || lock) {
       try { await (deps.waitReady ?? waitForEditor)(root, Math.max(1, deadline - Date.now()), deps); }
-      catch (error) { throw Error('Editor not ready; package dependencies were not changed. Wait with unity_open_project before retrying installation. ' + error.message); }
+      catch (error) { throw Error('Editor not ready; package dependencies were not changed. Wait with unity_project action=status or open before retrying installation. ' + error.message); }
     }
     const manifest = path.join(root, 'Packages/manifest.json');
     const original = await readFile(manifest, 'utf8');

package/lib/lazy-tools.mjs

@@ -32,7 +32,7 @@ export function installLazyTools(ctx, lazy = true, setupTools = []) {
     states.set(agent, state);
     if (lazy) state.disposers.push(agent.ctx.tools.register({
       name: 'unity_load_tools',
-      description: 'Load Unity/Tuanjie tools for this agent, including opening projects and configuring connections even when disconnected. Editor tools cover scenes, GameObjects, assets and console; they require CoderGamester/mcp-unity in the engine. Loading itself changes no configuration or project.',
+      description: 'Load Unity/Tuanjie tools for this agent. Start with unity_project action=list to discover open projects and the configured DSH target; then inspect/open/save/close a chosen project. Local management and package installation work without MCP; scene/object/asset tools require CoderGamester in the selected engine. Loading changes no project or connection.',
       parameters: empty,
       output: { schema: { type: 'object', properties: { tools: { type: 'array', items: { type: 'string' } } }, required: ['tools'], additionalProperties: false }, render: (_, value) => [{ type: 'text', text: JSON.stringify(value) }] },
       execute: async () => {

package/lib/open-project.mjs

@@ -21,7 +21,7 @@ async function finishOpen(result, input, deps) {
     await (deps.waitReady ?? waitForEditor)(result.projectPath, input.timeoutMs ?? 120000, deps);
     return { ...result, status: 'editor_ready', editorReady: true, message: 'Editor responded after import/compilation settled. MCP connectivity is not verified.' };
   } catch (error) {
-    return { ...result, status: 'editor_loading', editorReady: false, message: 'Not ready: ' + error.message + ' Do not assume loading finished. Retry unity_open_project to wait again; do not relaunch or configure MCP yet.' };
+    return { ...result, status: 'editor_loading', editorReady: false, message: 'Not ready: ' + error.message + ' Do not assume loading finished. Retry unity_project action=status or open to wait again; do not relaunch or configure MCP yet.' };
   }
 }
 async function powershell(script) {
@@ -97,8 +97,3 @@ async function launchEditor(editor, project) {
     child.once('spawn', () => { child.unref(); resolve(child.pid); });
   });
 }
-export function openProjectTool() {
-  return { name: 'unity_open_project', description: 'Open a Unity/Tuanjie project in its exact matching Windows editor and wait for an Editor readiness handshake, including when already running. May import assets and run project scripts; installs/updates the DSH Editor bridge. editor_loading means not ready: retry this tool to wait again, without relaunching. Does not configure or verify MCP.',
-    parameters: { type: 'object', properties: { projectPath: { type: 'string', description: 'Absolute existing project directory.' }, editorPath: { type: 'string', description: 'Optional absolute matching Unity.exe/Tuanjie.exe; omit to search standard Hub install locations.' }, timeoutMs: { type: 'integer', minimum: 1000, maximum: 180000, description: 'Editor readiness wait budget; default 120000 ms. Timeout returns editor_loading; retry to wait longer.' } }, required: ['projectPath'], additionalProperties: false },
-    output: { schema: { type: 'object', properties: { status: { type: 'string' }, projectPath: { type: 'string' }, editorPath: { type: 'string' }, version: { type: 'string' }, pid: { type: 'integer' }, editorReady: { type: 'boolean' }, message: { type: 'string' } }, required: ['status', 'projectPath', 'editorPath', 'version', 'pid', 'editorReady', 'message'], additionalProperties: false }, render: (_, value) => [{ type: 'text', text: JSON.stringify(value) }] }, execute: input => openProject(input) };
-}

package/lib/project-lifecycle.mjs

@@ -75,9 +75,3 @@ export async function requestProject(input, action, deps = {}) {
     throw Error('Editor response timed out. Operation may have begun; inspect the editor before retrying. No force kill was attempted.');
   } finally { if (request) await unlink(request).catch(() => {}); pending.delete(root); }
 }
-export function lifecycleTools() {
-  return ['save', 'close'].map(action => ({ name: `unity_${action}_project`,
-    description: action === 'save' ? 'Save all named loaded scenes and dirty assets in a running Windows Unity/Tuanjie project. Installs a small Editor bridge in Assets/Editor/DshUnityMcp (may trigger compilation); no existing MCP connection required. Rejects Play mode, Prefab Mode and unnamed scenes.' : 'Save scenes/assets then request normal exit for the specified Windows Unity/Tuanjie project and verify process exit. Installs an Editor bridge if absent. Save failure prevents exit; never force-kills or discards changes. Timeout is not proof of exit.',
-    parameters: { type: 'object', properties: { projectPath: { type: 'string', description: 'Absolute running project directory.' }, timeoutMs: { type: 'integer', minimum: 1000, maximum: 180000, description: 'Wait budget including bridge compilation and exit; default 60000 ms.' } }, required: ['projectPath'], additionalProperties: false },
-    output: { schema: { type: 'object', properties: { status: { type: 'string' }, projectPath: { type: 'string' }, pid: { type: 'integer' } }, required: ['status', 'projectPath', 'pid'], additionalProperties: false }, render: (_, value) => [{ type: 'text', text: JSON.stringify(value) }] }, execute: input => requestProject(input, action) }));
-}

package/lib/project.mjs

@@ -0,0 +1,64 @@
+import path from 'node:path';
+import { readFile, realpath } from 'node:fs/promises';
+import { windowsProcesses, projectFromCommandLine, openProject } from './open-project.mjs';
+import { requestProject, projectRoot } from './project-lifecycle.mjs';
+
+export function connectionTarget(ctx) {
+  const rows = ctx.configEditor.configuration().filter(row => row.entry.options.name === 'dsh-unity-mcp');
+  if (rows.length !== 1) return { status: 'ambiguous', projectPath: '', serverPath: '' };
+  const config = { ...rows[0].inherited, ...rows[0].override };
+  return { status: config.projectPath || config.serverPath ? 'configured_not_verified' : 'not_configured', projectPath: config.projectPath || '', serverPath: config.serverPath || '' };
+}
+export async function listProjects(target = {}, deps = {}) {
+  if ((deps.platform ?? process.platform) !== 'win32') throw Error('Project discovery currently supports Windows only.');
+  const processes = await (deps.processes ?? windowsProcesses)();
+  const canonical = async value => value ? realpath(value).catch(() => path.resolve(value)) : '';
+  const selected = (await canonical(target.projectPath)).toLowerCase();
+  const projects = [];
+  for (const row of Array.isArray(processes) ? processes : [processes]) {
+    if (!row) continue;
+    const raw = projectFromCommandLine(row.CommandLine);
+    const projectPath = await canonical(raw);
+    let version = '';
+    if (projectPath) version = /^m_EditorVersion:\s*(\S+)/m.exec(await readFile(path.join(projectPath, 'ProjectSettings/ProjectVersion.txt'), 'utf8').catch(() => ''))?.[1] || '';
+    projects.push({ pid: row.ProcessId, projectPath, editorPath: row.ExecutablePath || '', version, state: projectPath ? 'running_not_verified' : 'project_unknown', configuredTarget: Boolean(selected && selected === projectPath.toLowerCase()) });
+  }
+  projects.sort((a, b) => a.pid - b.pid);
+  return { projects: projects.slice(0, 100), total: projects.length, truncated: projects.length > 100, connection: target, message: 'Process inventory only; readiness and MCP connectivity are not verified. Unknown project paths may reflect inaccessible process arguments. Use status for a selected project. Connection settings affect all profile sessions.' };
+}
+export async function manageProject(input, target = {}, deps = {}) {
+  if (input.action === 'list') return listProjects(target, deps);
+  if (!input.projectPath) throw Error('projectPath is required for this action. Use action=list to discover open projects.');
+  if (input.action === 'open') return (deps.open ?? openProject)(input, deps);
+  if (input.action === 'save' || input.action === 'close') return (deps.request ?? requestProject)(input, input.action, deps);
+  if (input.action === 'status') {
+    const root = await projectRoot(input.projectPath);
+    const inventory = await listProjects(target, deps);
+    if (inventory.truncated) throw Error('Editor inventory exceeds 100 processes; status cannot safely select a project.');
+    const matches = inventory.projects.filter(p => p.projectPath.toLowerCase() === root.toLowerCase());
+    if (!matches.length) return { status: 'not_running', projectPath: root, editorReady: false, connection: target, message: 'No matching editor process found; MCP connectivity is not verified.' };
+    if (matches.length !== 1) throw Error('Multiple editor processes match this project. Resolve duplicates before acting.');
+    try {
+      await (deps.request ?? requestProject)({ ...input, timeoutMs: input.timeoutMs ?? 10000 }, 'ready', deps);
+      return { ...matches[0], state: 'editor_ready', status: 'editor_ready', editorReady: true, connection: target, message: 'Editor readiness confirmed; MCP connectivity is not verified.' };
+    } catch (error) {
+      return { ...matches[0], status: 'readiness_unconfirmed', editorReady: false, connection: target, message: error.message };
+    }
+  }
+  throw Error('Unknown project action.');
+}
+export function projectTool(ctx) {
+  return { name: 'unity_project', description: 'Discover and manage Windows Unity/Tuanjie projects without MCP. list is read-only and shows all editor processes plus the configured DSH target; it does not prove readiness. status waits for readiness without launching; open launches if needed and waits. status/open/save/close may install an Editor bridge and trigger compilation. close saves first, verifies normal exit, never force-kills or discards changes. Save/close reject Play Mode, Prefab Mode and unnamed scenes. Does not switch or verify MCP connections.',
+    parameters: { type: 'object', properties: {
+      action: { type: 'string', enum: ['list', 'status', 'open', 'save', 'close'], description: 'Start with list to choose an explicit project. status checks readiness; open also starts a closed project; save saves all named loaded scenes/assets; close saves then exits.' },
+      projectPath: { type: 'string', description: 'Absolute project directory; required except for list. Never inferred from the current connection.' },
+      editorPath: { type: 'string', description: 'Only for open: optional absolute exact-version Unity.exe/Tuanjie.exe.' },
+      timeoutMs: { type: 'integer', minimum: 1000, maximum: 180000, description: 'Wait budget: status default 10000 ms, open 120000 ms, save/close 60000 ms. Retry status/open after an unconfirmed readiness result; do not assume it is ready.' }
+    }, required: ['action'], additionalProperties: false },
+    output: { schema: { type: 'object' }, render: (_, value) => [{ type: 'text', text: JSON.stringify(value) }] },
+    execute: input => {
+      if (input.action === 'list' && (input.projectPath || input.editorPath)) throw Error('list accepts no projectPath or editorPath.');
+      if (input.editorPath && input.action !== 'open') throw Error('editorPath is only used by open.');
+      return manageProject(input, connectionTarget(ctx));
+    } };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-unity-mcp",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Unity and Tuanjie editor tools for DSH, powered by CoderGamester/mcp-unity with per-agent lazy loading.",
   "type": "module",
   "license": "MIT",
@@ -39,7 +39,7 @@
     }
   },
   "scripts": {
-    "check": "node --check index.mjs && node --check lib/connection.mjs && node --check lib/lazy-tools.mjs && node --check lib/configure-project.mjs && node --check lib/open-project.mjs && node --check lib/project-lifecycle.mjs && node --check lib/install-codergamester.mjs",
+    "check": "node --check index.mjs && node --check lib/project.mjs && node --check lib/connection.mjs && node --check lib/lazy-tools.mjs && node --check lib/configure-project.mjs && node --check lib/open-project.mjs && node --check lib/project-lifecycle.mjs && node --check lib/install-codergamester.mjs",
     "test": "node --test test/*.test.mjs",
     "build": "npm run check",
     "pack:check": "npm pack --dry-run --json"