dsh-unity-mcp 0.0.2 → 0.0.4

package/README.md

@@ -4,7 +4,7 @@
 
 把 [CoderGamester/mcp-unity](https://github.com/CoderGamester/mcp-unity) 的 Unity / 团结引擎编辑器工具接入 DSH，默认按 Agent 懒加载。
 
-**必须先在 Unity 或 Tuanjie（团结引擎）项目中安装 CoderGamester 的 MCP Unity Server，并启动引擎端服务。只安装本 npm 插件无法控制编辑器。** 本项目是 DSH 适配插件；引擎端与实际编辑器工具由上游提供。上游项目、安装说明及许可证见 [CoderGamester/mcp-unity](https://github.com/CoderGamester/mcp-unity)。
+**控制编辑器前，必须在 Unity 或 Tuanjie（团结引擎）项目中安装 CoderGamester 的 MCP Unity Server，并启动引擎端服务。** 0.0.4 起可让 Agent 用 `unity_install_codergamester` 准备安装，也可手动安装。本项目是 DSH 适配插件；上游编辑器工具由 [CoderGamester/mcp-unity](https://github.com/CoderGamester/mcp-unity) 提供，保存与关闭使用本插件附带的独立 Editor 桥接。
 
 ## 安装与连接
 
@@ -14,7 +14,7 @@
    ```text
    https://github.com/CoderGamester/mcp-unity.git
    ```
-2. 打开 **Tools → MCP Unity → Server Window**，按照上游说明启动服务。找到该项目安装的 `Server~/build/index.js`。如果没有构建文件，在对应的 `Server~` 目录运行 `npm install` 和 `npm run build`。DSH 插件不会自动下载、安装或构建引擎包。
+2. 打开 **Tools → MCP Unity → Server Window**，按照上游说明启动服务。找到该项目安装的 `Server~/build/index.js`。如果没有构建文件，在对应的 `Server~` 目录运行 `npm install` 和 `npm run build`。需要自动准备引擎依赖时，使用下文的安装工具；它仍不会下载或构建 Node 服务器。
 3. 在 DSH 插件管理中安装 npm 包：
    ```text
    dsh-unity-mcp
@@ -42,9 +42,31 @@
 
 工具不会安装引擎包、构建服务器或启动编辑器。也可以继续在插件配置中手工设置路径。
 
+## 打开工程（0.0.3 起，Windows）
+
+调用 `unity_load_tools` 后可使用 `unity_open_project`，传入 `projectPath`。不依赖引擎端 MCP 在线，也不要求工程已经安装 MCP 包。
+
+工具读取 `ProjectSettings/ProjectVersion.txt`，在标准 Unity / Tuanjie Hub 安装目录中寻找 ProductVersion 完全匹配的编辑器（允许版本后的 `_revision`）。自定义安装位置或多个匹配时，需传入 `editorPath`，指向对应的 `Unity.exe` / `Tuanjie.exe`。不自动安装编辑器，不允许用不同版本升级工程。当前不支持 macOS / Linux。
+
+已检测到该工程的编辑器进程时返回 `already_open`。存在工程锁但无法确认进程时拒绝启动，不删除锁；同一进程内的并发请求和 60 秒内重复启动也会被拦截。其他 DSH 进程或外部程序同时启动时，仍需依靠编辑器自己的工程锁。
+
+**打开工程可能触发资源导入和工程内编辑器脚本。请只打开可信工程。** 返回 `launch_requested` 仅表示系统接受启动请求，不表示编辑器已加载完成或 MCP 已连接。此工具不修改 DSH 连接配置；随后仍需用 `unity_configure_project` 配置连接，确认引擎服务启动后做只读查询。
+
+## 保存、关闭与安装（0.0.4 起，Windows）
+
+这些工具都不要求已有 MCP 连接。首次调用会在目标工程的 `Assets/Editor/DshUnityMcp/ProjectBridge.cs` 写入本插件的 Editor 桥接，可能触发编译；同路径已有不同内容时拒绝覆盖。请只在可信且已备份的工程中操作。
+
+- `unity_save_project`：保存所有已加载且有路径的场景及修改过的资源。Play Mode、Prefab Mode、未命名场景会阻止操作；未命名场景需先在编辑器中选择保存路径。工具不替用户命名或另存。
+- `unity_close_project`：先执行上述保存，成功后请求编辑器正常退出，并检查指定工程的进程已退出。保存失败不关闭；不强杀、不提供丢弃修改选项。超时不代表已经关闭，重试前检查编辑器。
+- `unity_install_codergamester`：向 `Packages/manifest.json` 加入固定到上游 commit `382a43a30f4dab4c7f02d770b4ec7d084813bbe4` 的依赖，设置 `AutoStartServer` 并通过桥接请求启动。修改前保留 `.dsh-backup`，保留其他依赖；已有不同的 CoderGamester 依赖时拒绝替换。它不打开或关闭编辑器，不更改 DSH 连接，也不下载或构建 Node 服务器。
+
+安装工具返回的 `pending_editor_start`、`start_requested` 只描述准备和启动请求；`ready` 始终为 `false`，不能当作已连接。随后打开或刷新编辑器，等待 Package Manager 解析、编译，构建缺失的 `Server~`，再用 `unity_configure_project` 配置连接并做只读查询。网络、Git、包解析或编译失败需在编辑器中处理；工具不会自动移除其他 MCP 包。
+
+独立团结测试工程已验证场景修改写入磁盘、保存后正常关闭。安装依赖与实际引擎服务连接分开验收；其他 Unity / Tuanjie 版本仍需自行验证。
+
 ## 工具懒加载
 
-每个 Agent 初始只看到 `unity_load_tools`。调用后先获得 `unity_configure_project`，并加载当前服务器提供的 `mcp__unity__*` 工具；未连接时只有配置工具。其他 Agent 仍保持未加载。场景、GameObject、组件、材质、资源、控制台和测试等工具的参数与结果沿用上游，插件不维护另一套工具清单。
+每个 Agent 初始只看到 `unity_load_tools`。调用后获得 `unity_configure_project`、`unity_open_project`、`unity_save_project`、`unity_close_project`、`unity_install_codergamester`，并加载当前服务器提供的 `mcp__unity__*` 工具；未连接时也有这五个本地工具。其他 Agent 仍保持未加载。场景、GameObject、组件、材质、资源、控制台和测试等工具的参数与结果沿用上游，插件不维护另一套工具清单。
 
 加载动作不会修改工程。**加载后的编辑器操作可能创建、删除资源，修改场景、执行菜单或安装包。请先提交或备份工程，并检查每次调用的范围。** 如需立即暴露全部工具，把 `lazyTools` 设为 `false`。实际工具数量随上游版本变化。
 

package/engine/Editor/ProjectBridge.cs

@@ -0,0 +1,66 @@
+using System;
+using System.IO;
+using System.Reflection;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace DshUnityMcp {
+[InitializeOnLoad]
+public static class ProjectBridge {
+    [Serializable] class Request { public string id; public string action; public long expires; }
+    [Serializable] class Reply { public string id; public bool success; public string message; public int pid; }
+    static readonly string Root = Path.GetFullPath(Path.Combine(Application.dataPath, "../Library/DshUnityMcp"));
+    static double next;
+    static ProjectBridge() { EditorApplication.update += Update; }
+    static void Update() {
+        if (EditorApplication.timeSinceStartup < next || EditorApplication.isCompiling || EditorApplication.isUpdating) return;
+        next = EditorApplication.timeSinceStartup + .25;
+        if (!Directory.Exists(Root)) return;
+        foreach (var file in Directory.GetFiles(Root, "*.request.json")) {
+            Request request = null;
+            try {
+                request = JsonUtility.FromJson<Request>(File.ReadAllText(file));
+                File.Delete(file);
+                if (request == null || !Guid.TryParseExact(request.id, "N", out _) || Path.GetFileName(file) != request.id + ".request.json") continue;
+                if (request.expires < DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()) continue;
+                bool close = request.action == "close";
+                if (request.action == "save" || close) {
+                    if (EditorApplication.isPlayingOrWillChangePlaymode) throw new Exception("Stop Play mode before saving or closing.");
+                    for (int i = 0; i < EditorSceneManager.sceneCount; i++) {
+                        var scene = EditorSceneManager.GetSceneAt(i);
+                        if (scene.isLoaded && string.IsNullOrEmpty(scene.path)) throw new Exception("Unnamed scene: save it to an explicit path in the editor first.");
+                    }
+                    if (PrefabStageUtility.GetCurrentPrefabStage() != null) throw new Exception("Exit Prefab Mode before saving or closing.");
+                    if (!EditorSceneManager.SaveOpenScenes()) throw new Exception("Saving scenes failed; editor remains open.");
+                    AssetDatabase.SaveAssets();
+                    foreach (var asset in Resources.FindObjectsOfTypeAll<UnityEngine.Object>())
+                        if (asset != null && EditorUtility.IsPersistent(asset) && EditorUtility.IsDirty(asset) && AssetDatabase.GetAssetPath(asset).StartsWith("Assets/", StringComparison.Ordinal)) throw new Exception("An asset remains dirty: " + AssetDatabase.GetAssetPath(asset) + " (" + asset.name + "); editor remains open.");
+                    for (int i = 0; i < EditorSceneManager.sceneCount; i++) if (EditorSceneManager.GetSceneAt(i).isDirty) throw new Exception("A scene remains dirty; editor remains open.");
+                } else if (request.action == "enable") {
+                    Type server = null;
+                    foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies()) { server = assembly.GetType("McpUnity.Unity.McpUnityServer"); if (server != null) break; }
+                    if (server == null) throw new Exception("CoderGamester is not compiled yet.");
+                    var settings = server.Assembly.GetType("McpUnity.Unity.McpUnitySettings");
+                    var settingsInstance = settings.GetProperty("Instance").GetValue(null);
+                    settings.GetMethod("LoadSettings").Invoke(settingsInstance, null);
+                    var instance = server.GetProperty("Instance").GetValue(null);
+                    server.GetMethod("StartServer").Invoke(instance, null);
+                } else throw new Exception("Unsupported request.");
+                Write(request.id, true, close ? "Saved; normal exit requested." : "Operation completed.");
+                if (close) { EditorApplication.delayCall += () => {
+                    if (EditorApplication.isPlayingOrWillChangePlaymode || EditorApplication.isCompiling) return;
+                    for (int i = 0; i < EditorSceneManager.sceneCount; i++) if (EditorSceneManager.GetSceneAt(i).isDirty) return;
+                    AssetDatabase.SaveAssets();
+                    EditorApplication.Exit(0);
+                }; return; }
+            } catch (Exception error) { if (request != null && Guid.TryParseExact(request.id, "N", out _)) Write(request.id, false, error.Message); }
+        }
+    }
+    static void Write(string id, bool success, string message) {
+        var target = Path.Combine(Root, id + ".response.json");
+        File.WriteAllText(target + ".tmp", JsonUtility.ToJson(new Reply { id = id, success = success, message = message, pid = System.Diagnostics.Process.GetCurrentProcess().Id }));
+        File.Move(target + ".tmp", target);
+    }
+}
+}

package/index.mjs

@@ -2,6 +2,9 @@ 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 { installationTool } from './lib/install-codergamester.mjs';
 import { configurationTool } from './lib/configure-project.mjs';
 export const name = 'dsh-unity-mcp';
 export const inject = ['tools', 'agents', 'configEditor'];
@@ -16,10 +19,13 @@ 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)]);
+  installLazyTools(ctx, config.lazyTools, [configurationTool(ctx), openProjectTool(), ...lifecycleTools(), installationTool()]);
   if (!config.projectPath && !config.serverPath) {
     ctx.logger.info('Unity MCP: configure projectPath or serverPath to connect CoderGamester/mcp-unity.');
     return;
   }
-  await mcp.apply(ctx, mcp.Config(await connectionConfig(config)));
+  let connection;
+  try { connection = await connectionConfig(config); }
+  catch (error) { ctx.logger.warn('Unity MCP connection needs configuration: ' + error.message); return; }
+  await mcp.apply(ctx, mcp.Config(connection));
 }

package/lib/install-codergamester.mjs

@@ -0,0 +1,49 @@
+import path from 'node:path';
+import { readFile, writeFile, mkdir, copyFile, realpath } from 'node:fs/promises';
+import { projectRoot, ensureBridge, matchingProcess, requestProject } from './project-lifecycle.mjs';
+import { resolveServer } from './connection.mjs';
+const PACKAGE = 'com.gamelovers.mcp-unity';
+export const UPSTREAM = 'https://github.com/CoderGamester/mcp-unity.git#382a43a30f4dab4c7f02d770b4ec7d084813bbe4';
+const installing = new Set();
+export async function installCoderGamester(input, deps = {}) {
+  if ((deps.platform ?? process.platform) !== 'win32') throw Error('Installation tool currently supports Windows only.');
+  const root = await projectRoot(input.projectPath);
+  if (installing.has(root)) throw Error('Installation is in progress for this project.');
+  installing.add(root);
+  try {
+    const manifest = path.join(root, 'Packages/manifest.json');
+    const original = await readFile(manifest, 'utf8');
+    const parsed = JSON.parse(original);
+    if (!parsed.dependencies || typeof parsed.dependencies !== 'object' || Array.isArray(parsed.dependencies)) throw Error('Invalid package manifest dependencies.');
+    const current = parsed.dependencies[PACKAGE];
+    if (current && current !== UPSTREAM) throw Error('CoderGamester already has a different dependency. Refusing to replace it: ' + current);
+    await ensureBridge(root);
+    const settings = path.join(root, 'ProjectSettings/McpUnitySettings.json');
+    let text; try { text = await readFile(settings, 'utf8'); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+    const config = text ? JSON.parse(text) : {};
+    config.AutoStartServer = true;
+    if (text && JSON.parse(text).AutoStartServer !== true) await copyFile(settings, settings + '.dsh-backup', 1);
+    if (!current) {
+      const backup = manifest + '.dsh-backup';
+      await copyFile(manifest, backup, 1);
+      if (await readFile(manifest, 'utf8') !== original) throw Error('Manifest changed during preparation; retry.');
+      parsed.dependencies[PACKAGE] = UPSTREAM;
+      await writeFile(manifest, JSON.stringify(parsed, null, 2) + '\n');
+    }
+    await writeFile(settings, JSON.stringify(config, null, 2) + '\n');
+    let enableStatus = 'pending_editor_start';
+    if (await matchingProcess(root, deps.processes)) {
+      try { await (deps.request ?? requestProject)({ projectPath: root, timeoutMs: input.timeoutMs ?? 120000 }, 'enable', deps); enableStatus = 'start_requested'; }
+      catch (error) { enableStatus = 'pending: ' + error.message; }
+    }
+    let serverPath = '';
+    try { serverPath = await resolveServer({ projectPath: root }); } catch {}
+    return { projectPath: root, dependency: UPSTREAM, dependencyAdded: !current, enableStatus, serverPath, ready: false,
+      message: 'Dependency and Editor bridge prepared; package resolution, compilation and service connectivity are separate. Open/refresh the editor to resolve the pinned package. If serverPath is empty, build its Server~ with npm install and npm run build. Then configure the DSH connection and verify a read-only editor call. No other MCP packages were removed.' };
+  } finally { installing.delete(root); }
+}
+export function installationTool() {
+  return { name: 'unity_install_codergamester', description: 'Install pinned CoderGamester/mcp-unity dependency and DSH Editor bridge into a Windows Unity/Tuanjie project without an existing MCP connection; enable auto-start and request start if open. Changes Packages/manifest.json, project settings and Assets/Editor; editor package resolution executes third-party code. Preserves other packages; refuses replacing a different existing CoderGamester dependency. Does not download/build the Node server, launch/close editors or change DSH connection. Returns pending states, not proof of connectivity.',
+    parameters: { type: 'object', properties: { projectPath: { type: 'string', description: 'Absolute project directory with Packages/manifest.json.' }, timeoutMs: { type: 'integer', minimum: 1000, maximum: 180000, description: 'Wait for compilation/start request, default 120000 ms.' } }, required: ['projectPath'], additionalProperties: false },
+    output: { schema: { type: 'object', properties: { projectPath: { type: 'string' }, dependency: { type: 'string' }, dependencyAdded: { type: 'boolean' }, enableStatus: { type: 'string' }, serverPath: { type: 'string' }, ready: { type: 'boolean' }, message: { type: 'string' } }, required: ['projectPath', 'dependency', 'dependencyAdded', 'enableStatus', 'serverPath', 'ready', 'message'], additionalProperties: false }, render: (_, value) => [{ type: 'text', text: JSON.stringify(value) }] }, execute: input => installCoderGamester(input) };
+}

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 project connection setup 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, 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.',
       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

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import { readFile, stat, realpath, readdir } from 'node:fs/promises';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+const pending = new Set();
+const recentLaunches = new Map();
+async function powershell(script) {
+  const { stdout } = await exec('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')], { windowsHide: true, timeout: 15000, maxBuffer: 1024 * 1024 });
+  return JSON.parse(stdout.replace(/^\uFEFF/, '').trim() || 'null');
+}
+export function projectFromCommandLine(command = '') {
+  return /(?:^|\s)-projectpath\s+(?:"([^"]+)"|([^\s]+))/i.exec(command)?.slice(1).find(Boolean);
+}
+export async function windowsProcesses() {
+  return await powershell("@(Get-CimInstance Win32_Process -Filter \"Name='Unity.exe' OR Name='Tuanjie.exe'\" | Select-Object ProcessId,ExecutablePath,CommandLine) | ConvertTo-Json -Compress") ?? [];
+}
+async function editorVersion(file) {
+  const quoted = file.replaceAll("'", "''");
+  return powershell(`(Get-Item -LiteralPath '${quoted}').VersionInfo.ProductVersion | ConvertTo-Json -Compress`);
+}
+async function discoverEditors() {
+  const roots = [path.join(process.env.ProgramFiles || 'C:/Program Files', 'Unity/Hub/Editor'), path.join(process.env.ProgramFiles || 'C:/Program Files', 'Tuanjie/Hub/Editor')];
+  const candidates = [];
+  for (const root of roots) {
+    let entries; try { entries = await readdir(root); } catch (e) { if (e.code === 'ENOENT') continue; throw e; }
+    for (const entry of entries) for (const name of ['Unity.exe', 'Tuanjie.exe']) candidates.push(path.join(root, entry, 'Editor', name));
+    for (const name of ['Unity.exe', 'Tuanjie.exe']) candidates.push(path.join(root, name));
+  }
+  return candidates;
+}
+export async function openProject(input, deps = {}) {
+  const { platform = process.platform, processes = windowsProcesses, versionOf = editorVersion, discover = discoverEditors, launch = launchEditor } = deps;
+  if (platform !== 'win32') throw Error('unity_open_project currently supports Windows only.');
+  if (!path.isAbsolute(input.projectPath || '')) throw Error('projectPath must be absolute.');
+  const projectPath = await realpath(input.projectPath);
+  for (const dir of ['Assets', 'ProjectSettings']) if (!(await stat(path.join(projectPath, dir))).isDirectory()) throw Error('Not a Unity/Tuanjie project: ' + dir);
+  const text = await readFile(path.join(projectPath, 'ProjectSettings/ProjectVersion.txt'), 'utf8');
+  const version = /^m_EditorVersion:\s*(\S+)/m.exec(text)?.[1];
+  if (!version || !/^\d+\.\d+\.\d+[a-z]\d+$/i.test(version)) throw Error('Cannot determine exact editor version from ProjectVersion.txt.');
+  const key = projectPath.toLowerCase();
+  if (pending.has(key)) throw Error('An open request for this project is already in progress.');
+  pending.add(key);
+  try {
+    const rows = await processes();
+    for (const row of Array.isArray(rows) ? rows : [rows]) {
+      const target = projectFromCommandLine(row.CommandLine);
+      if (target && await realpath(target).then(p => p.toLowerCase() === key, () => false)) return { status: 'already_open', projectPath, editorPath: row.ExecutablePath || '', version, pid: row.ProcessId };
+    }
+    if (Date.now() - (recentLaunches.get(key) ?? 0) < 60000) throw Error('A launch was requested within the last 60 seconds; wait for the editor before retrying.');
+    const lock = await stat(path.join(projectPath, 'Temp/UnityLockfile')).catch(e => { if (e.code !== 'ENOENT') throw e; });
+    if (lock) throw Error('UnityLockfile exists but no matching editor could be confirmed. Refusing duplicate launch; check the editor/lock manually.');
+    const explicit = input.editorPath;
+    if (explicit && !path.isAbsolute(explicit)) throw Error('editorPath must be absolute.');
+    const matches = [];
+    for (const candidate of explicit ? [explicit] : await discover()) {
+      if (!/^(Unity|Tuanjie)\.exe$/i.test(path.basename(candidate))) continue;
+      let info; try { info = await stat(candidate); } catch (e) { if (e.code === 'ENOENT') continue; throw e; }
+      if (!info.isFile()) continue;
+      const actual = await versionOf(candidate);
+      if (typeof actual === 'string' && (actual === version || actual.startsWith(version + '_'))) matches.push(candidate);
+    }
+    if (matches.length !== 1) throw Error(`Expected one editor matching ${version}; found ${matches.length}. Provide editorPath to the matching Unity.exe/Tuanjie.exe. No version upgrade is allowed.`);
+    const pid = await launch(matches[0], projectPath);
+    for (const [name, time] of recentLaunches) if (Date.now() - time >= 60000) recentLaunches.delete(name);
+    recentLaunches.set(key, Date.now());
+    return { status: 'launch_requested', projectPath, editorPath: matches[0], version, pid };
+  } finally { pending.delete(key); }
+}
+async function launchEditor(editor, project) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(editor, ['-projectPath', project], { detached: true, stdio: 'ignore', shell: false });
+    child.once('error', reject);
+    child.once('spawn', () => { child.unref(); resolve(child.pid); });
+  });
+}
+export function openProjectTool() {
+  return { name: 'unity_open_project', description: 'Open a local Unity/Tuanjie project in its exact matching Windows editor, or report already open. Launching may import assets and execute project editor scripts. Does not save MCP configuration or prove MCP readiness.',
+    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.' } }, required: ['projectPath'], additionalProperties: false },
+    output: { schema: { type: 'object', properties: { status: { type: 'string' }, projectPath: { type: 'string' }, editorPath: { type: 'string' }, version: { type: 'string' }, pid: { type: 'integer' } }, required: ['status', 'projectPath', 'editorPath', 'version', 'pid'], additionalProperties: false }, render: (_, value) => [{ type: 'text', text: JSON.stringify(value) }] }, execute: input => openProject(input) };
+}

package/lib/project-lifecycle.mjs

@@ -0,0 +1,78 @@
+import path from 'node:path';
+import { readFile, writeFile, mkdir, stat, realpath, rename, unlink } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+import { windowsProcesses, projectFromCommandLine } from './open-project.mjs';
+const pending = new Set();
+export async function projectRoot(value) {
+  if (!path.isAbsolute(value || '')) throw Error('projectPath must be absolute.');
+  const root = await realpath(value);
+  for (const dir of ['Assets', 'ProjectSettings']) if (!(await stat(path.join(root, dir))).isDirectory()) throw Error('Not a Unity/Tuanjie project: ' + dir);
+  return root;
+}
+export async function matchingProcess(root, processes = windowsProcesses) {
+  const rows = await processes();
+  const matches = [];
+  for (const row of Array.isArray(rows) ? rows : [rows]) {
+    const target = projectFromCommandLine(row?.CommandLine);
+    if (target && await realpath(target).then(p => p.toLowerCase() === root.toLowerCase(), () => false)) matches.push(row);
+  }
+  if (matches.length > 1) throw Error('Multiple editor processes match this project.');
+  return matches[0];
+}
+export async function ensureBridge(root) {
+  const source = await readFile(new URL('../engine/Editor/ProjectBridge.cs', import.meta.url), 'utf8');
+  const directory = path.join(root, 'Assets/Editor/DshUnityMcp');
+  await mkdir(directory, { recursive: true });
+  const target = path.join(directory, 'ProjectBridge.cs');
+  let current; try { current = await readFile(target, 'utf8'); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+  if (current && current !== source) throw Error('Existing DSH bridge differs. Review/remove it explicitly before installing this version.');
+  if (current !== source) await writeFile(target, source, { flag: 'wx' });
+}
+export async function requestProject(input, action, deps = {}) {
+  if ((deps.platform ?? process.platform) !== 'win32') throw Error('Project lifecycle tools currently support Windows only.');
+  const root = await projectRoot(input.projectPath);
+  if (pending.has(root)) throw Error('A lifecycle request for this project is in progress.');
+  pending.add(root);
+  const processes = deps.processes ?? windowsProcesses;
+  let request;
+  try {
+    const editor = await matchingProcess(root, processes);
+    if (!editor) throw Error('No running editor for the requested project.');
+    await ensureBridge(root);
+    const directory = path.join(root, 'Library/DshUnityMcp'); await mkdir(directory, { recursive: true });
+    const id = randomUUID().replaceAll('-', ''), timeout = input.timeoutMs ?? 60000;
+    request = path.join(directory, id + '.request.json');
+    const response = path.join(directory, id + '.response.json');
+    await writeFile(request + '.tmp', JSON.stringify({ id, action, expires: Date.now() + timeout }));
+    await rename(request + '.tmp', request);
+    const deadline = Date.now() + timeout;
+    while (Date.now() < deadline) {
+      let reply;
+      try { reply = JSON.parse(await readFile(response, 'utf8')); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+      if (reply) {
+        await unlink(response);
+        if (reply.id !== id || reply.pid !== editor.ProcessId) throw Error('Editor response identity mismatch.');
+        if (!reply.success) throw Error(reply.message);
+        if (action === 'close') {
+          while (Date.now() < deadline) {
+            const active = await matchingProcess(root, processes);
+            if (!active) return { status: 'closed', projectPath: root, pid: editor.ProcessId };
+            if (active.ProcessId !== editor.ProcessId) throw Error('Project reopened in a different process; not closing it.');
+            await delay(500);
+          }
+          throw Error('Save acknowledged but normal exit not confirmed. No force kill was attempted.');
+        }
+        return { status: action === 'save' ? 'saved' : 'enable_requested', projectPath: root, pid: editor.ProcessId };
+      }
+      await delay(250);
+    }
+    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-unity-mcp",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Unity and Tuanjie editor tools for DSH, powered by CoderGamester/mcp-unity with per-agent lazy loading.",
   "type": "module",
   "license": "MIT",
@@ -25,6 +25,7 @@
   "files": [
     "index.mjs",
     "lib",
+    "engine",
     "cordis.patch.yml",
     "assets",
     "locale",
@@ -38,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",
+    "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",
     "test": "node --test test/*.test.mjs",
     "build": "npm run check",
     "pack:check": "npm pack --dry-run --json"