@luoluo123/unity-mcp-server 0.6.2

package/LICENSE

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

package/README.md

@@ -0,0 +1,69 @@
+# @luoluo123/unity-mcp-server
+
+这是 Unity MCP 的 MCP stdio server，负责把 MCP tool 调用转发到 Unity Editor Bridge。
+
+## 使用
+
+MCP 客户端推荐通过 `npx` 启动：
+
+```bash
+npx -y @luoluo123/unity-mcp-server@0.6.2
+```
+
+默认会自动探测本机 `127.0.0.1:8765-8775` 范围内的 Unity Bridge。
+
+运行 server 前，需要先在目标 Unity 工程中通过 UPM Git 安装并启动 `com.yys.unity-mcp-bridge`。
+
+## MCP 配置示例
+
+```json
+{
+  "type": "stdio",
+  "command": "npx",
+  "args": [
+    "-y",
+    "@luoluo123/unity-mcp-server@0.6.2"
+  ],
+  "env": {
+    "UNITY_MCP_AUTO_DETECT": "true",
+    "UNITY_MCP_DETECT_HOST": "127.0.0.1",
+    "UNITY_MCP_DETECT_PORT_START": "8765",
+    "UNITY_MCP_DETECT_PORT_END": "8775",
+    "UNITY_MCP_TIMEOUT_MS": "30000"
+  },
+  "enabled": true
+}
+```
+
+## 本地开发
+
+```bash
+npm install
+npm run typecheck
+npm run build
+```
+
+本地运行：
+
+```bash
+node dist/index.js
+```
+
+发布前检查 npm 包内容：
+
+```bash
+npm pack --dry-run
+```
+
+## 环境变量
+
+```text
+UNITY_MCP_BRIDGE_URL=http://127.0.0.1:8765
+UNITY_MCP_TIMEOUT_MS=30000
+UNITY_MCP_AUTO_DETECT=true
+UNITY_MCP_DETECT_HOST=127.0.0.1
+UNITY_MCP_DETECT_PORT_START=8765
+UNITY_MCP_DETECT_PORT_END=8775
+UNITY_MCP_PROJECT_PATH=
+UNITY_MCP_PROJECT_NAME=
+```

package/dist/config.js

@@ -0,0 +1,36 @@
+export function loadConfig() {
+    return {
+        bridgeUrl: process.env.UNITY_MCP_BRIDGE_URL ?? "http://127.0.0.1:8765",
+        bridgeUrlExplicit: typeof process.env.UNITY_MCP_BRIDGE_URL === "string" && process.env.UNITY_MCP_BRIDGE_URL.length > 0,
+        timeoutMs: numberFromEnv("UNITY_MCP_TIMEOUT_MS", 30_000),
+        autoDetect: boolFromEnv("UNITY_MCP_AUTO_DETECT", true),
+        detectHost: process.env.UNITY_MCP_DETECT_HOST ?? "127.0.0.1",
+        detectPortStart: numberFromEnv("UNITY_MCP_DETECT_PORT_START", 8765),
+        detectPortEnd: numberFromEnv("UNITY_MCP_DETECT_PORT_END", 8775),
+        projectPath: stringFromEnv("UNITY_MCP_PROJECT_PATH"),
+        projectName: stringFromEnv("UNITY_MCP_PROJECT_NAME"),
+    };
+}
+function numberFromEnv(name, fallback) {
+    const value = process.env[name];
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function boolFromEnv(name, fallback) {
+    const value = process.env[name];
+    if (!value) {
+        return fallback;
+    }
+    return value !== "0" && value.toLowerCase() !== "false";
+}
+function stringFromEnv(name) {
+    const value = process.env[name];
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}

package/dist/errors.js

@@ -0,0 +1,22 @@
+export class BridgeError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = "BridgeError";
+        this.code = code;
+        this.details = details;
+    }
+}
+export function toErrorText(error) {
+    if (error instanceof BridgeError) {
+        if (error.details === undefined || error.details === null) {
+            return `${error.code}: ${error.message}`;
+        }
+        return `${error.code}: ${error.message}\n${JSON.stringify(error.details, null, 2)}`;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}

package/dist/index.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { loadConfig } from "./config.js";
+import { BridgeRegistry } from "./unity/BridgeRegistry.js";
+import { UnityBridgeClient } from "./unity/UnityBridgeClient.js";
+import { registerTools } from "./tools/registerTools.js";
+async function main() {
+    const config = loadConfig();
+    const detectUrls = config.autoDetect ? buildDetectUrls(config.detectHost, config.detectPortStart, config.detectPortEnd) : [];
+    const cwd = process.cwd();
+    const cwdProjectPath = await findProjectFromCwd(cwd);
+    const registry = new BridgeRegistry({
+        detectUrls,
+        probeTimeoutMs: Math.min(config.timeoutMs, 1500),
+        bridgeUrl: config.bridgeUrl,
+        bridgeUrlExplicit: config.bridgeUrlExplicit,
+        projectPath: config.projectPath,
+        projectName: config.projectName,
+        cwd,
+        cwdProjectPath,
+    });
+    const bridge = new UnityBridgeClient(registry, config.timeoutMs);
+    const server = new McpServer({
+        name: "unity-mcp",
+        version: "0.6.2",
+    });
+    registerTools(server, bridge);
+    await server.connect(new StdioServerTransport());
+}
+main().catch(error => {
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+});
+function buildDetectUrls(host, start, end) {
+    const urls = [];
+    const first = Math.min(start, end);
+    const last = Math.max(start, end);
+    for (let port = first; port <= last; port += 1) {
+        urls.push(`http://${host}:${port}`);
+    }
+    return urls;
+}
+async function findProjectFromCwd(cwd) {
+    let current = path.resolve(cwd);
+    for (let i = 0; i < 16; i += 1) {
+        if (await isUnityProjectRoot(current)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+    return null;
+}
+async function isUnityProjectRoot(dir) {
+    try {
+        const [assets, projectSettings] = await Promise.all([
+            fs.stat(path.join(dir, "Assets")).then(s => s.isDirectory()).catch(() => false),
+            fs.stat(path.join(dir, "ProjectSettings")).then(s => s.isDirectory()).catch(() => false),
+        ]);
+        return assets && projectSettings;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tools/registerTools.js

@@ -0,0 +1,67 @@
+import { toErrorText } from "../errors.js";
+import { assetCreateFolderSchema, assetFindSchema, assetPathSchema, bridgeSelectSchema, componentPropertyGetSchema, componentPropertySetSchema, componentSchema, emptySchema, gameObjectCreateSchema, gameObjectRenameSchema, hierarchyListSchema, pathSchema, prefabCreateSchema, prefabInstantiateSchema, sceneNewSchema, sceneOpenSchema, scriptAttachSchema, scriptCreateSchema, transformSetSchema, } from "./schemas.js";
+export function registerTools(server, bridge) {
+    register(server, bridge, "unity_health", "Check whether the Unity Editor bridge is reachable.", emptySchema, async () => bridge.health());
+    register(server, bridge, "unity_bridge_list", "List all Unity bridges discovered on the configured port range.", emptySchema, async () => bridge.listBridges());
+    register(server, bridge, "unity_bridge_select", "Bind the current MCP session to a specific Unity bridge.", bridgeSelectSchema, async (args) => bridge.selectBridge(args));
+    register(server, bridge, "unity_bridge_current", "Get the Unity bridge currently bound to this MCP session.", emptySchema, async () => bridge.describeCurrent());
+    register(server, bridge, "unity_bridge_get_config", "Get Unity bridge safety configuration.", emptySchema, async () => bridge.command("bridge.getConfig"));
+    register(server, bridge, "unity_bridge_get_log_path", "Get Unity bridge log file path.", emptySchema, async () => bridge.command("bridge.getLogPath"));
+    register(server, bridge, "unity_project_get_info", "Get Unity version and current project information.", emptySchema, async () => bridge.command("project.getInfo"));
+    register(server, bridge, "unity_scene_get_active", "Get the active Unity scene.", emptySchema, async () => bridge.command("scene.getActive"));
+    register(server, bridge, "unity_scene_new", "Create a new Unity scene.", sceneNewSchema, async (args) => bridge.command("scene.new", args));
+    register(server, bridge, "unity_scene_open", "Open a Unity scene asset.", sceneOpenSchema, async (args) => bridge.command("scene.open", args));
+    register(server, bridge, "unity_scene_save", "Save the active Unity scene.", emptySchema, async () => bridge.command("scene.save"));
+    register(server, bridge, "unity_scene_save_as", "Save the active Unity scene to a path.", pathSchema, async (args) => bridge.command("scene.saveAs", args));
+    register(server, bridge, "unity_scene_get_dirty", "Check whether the active Unity scene has unsaved changes.", emptySchema, async () => bridge.command("scene.getDirty"));
+    register(server, bridge, "unity_hierarchy_list", "List GameObjects in the active scene hierarchy.", hierarchyListSchema, async (args) => bridge.command("hierarchy.list", args));
+    register(server, bridge, "unity_gameobject_create", "Create a GameObject in the active scene.", gameObjectCreateSchema, async (args) => bridge.command("gameObject.create", args));
+    register(server, bridge, "unity_gameobject_delete", "Delete a GameObject by hierarchy path.", pathSchema, async (args) => bridge.command("gameObject.delete", args));
+    register(server, bridge, "unity_gameobject_find", "Find a GameObject by hierarchy path.", pathSchema, async (args) => bridge.command("gameObject.find", args));
+    register(server, bridge, "unity_gameobject_rename", "Rename a GameObject by hierarchy path.", gameObjectRenameSchema, async (args) => bridge.command("gameObject.rename", args));
+    register(server, bridge, "unity_transform_get", "Get a GameObject transform.", pathSchema, async (args) => bridge.command("transform.get", args));
+    register(server, bridge, "unity_transform_set", "Set a GameObject transform.", transformSetSchema, async (args) => bridge.command("transform.set", args));
+    register(server, bridge, "unity_component_list", "List components on a GameObject.", pathSchema, async (args) => bridge.command("component.list", args));
+    register(server, bridge, "unity_component_add", "Add a component to a GameObject.", componentSchema, async (args) => bridge.command("component.add", args));
+    register(server, bridge, "unity_component_remove", "Remove a component from a GameObject.", componentSchema, async (args) => bridge.command("component.remove", args));
+    register(server, bridge, "unity_component_get", "Get a component on a GameObject.", componentSchema, async (args) => bridge.command("component.get", args));
+    register(server, bridge, "unity_component_get_property", "Get a SerializedProperty value from a component.", componentPropertyGetSchema, async (args) => bridge.command("component.getProperty", args));
+    register(server, bridge, "unity_component_set_property", "Set a SerializedProperty value on a component.", componentPropertySetSchema, async (args) => bridge.command("component.setProperty", args));
+    register(server, bridge, "unity_script_create", "Create a C# MonoBehaviour script under Assets.", scriptCreateSchema, async (args) => bridge.command("script.create", args));
+    register(server, bridge, "unity_script_attach", "Attach a compiled script component to a GameObject.", scriptAttachSchema, async (args) => bridge.command("script.attach", args));
+    register(server, bridge, "unity_asset_refresh", "Refresh the Unity AssetDatabase.", emptySchema, async () => bridge.command("asset.refresh"));
+    register(server, bridge, "unity_asset_find", "Find assets with an AssetDatabase filter.", assetFindSchema, async (args) => bridge.command("asset.find", args));
+    register(server, bridge, "unity_asset_load", "Load asset metadata by path.", assetPathSchema, async (args) => bridge.command("asset.load", args));
+    register(server, bridge, "unity_asset_create_folder", "Create a folder under Assets.", assetCreateFolderSchema, async (args) => bridge.command("asset.createFolder", args));
+    register(server, bridge, "unity_asset_delete", "Delete an asset under Assets.", assetPathSchema, async (args) => bridge.command("asset.delete", args));
+    register(server, bridge, "unity_prefab_create", "Create a prefab asset from a scene GameObject.", prefabCreateSchema, async (args) => bridge.command("prefab.create", args));
+    register(server, bridge, "unity_prefab_instantiate", "Instantiate a prefab asset into the active scene.", prefabInstantiateSchema, async (args) => bridge.command("prefab.instantiate", args));
+    register(server, bridge, "unity_prefab_apply", "Apply a prefab instance back to its prefab asset.", pathSchema, async (args) => bridge.command("prefab.apply", args));
+}
+function register(server, bridge, name, description, schema, handler) {
+    server.tool(name, description, schema, async (args) => {
+        try {
+            const result = await handler(args);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: toErrorText(error),
+                    },
+                ],
+            };
+        }
+    });
+    void bridge;
+}

package/dist/tools/schemas.js

@@ -0,0 +1,99 @@
+import { z } from "zod";
+export const emptySchema = {};
+export const pathSchema = {
+    path: z.string().min(1),
+};
+export const vector3Schema = z.object({
+    x: z.number(),
+    y: z.number(),
+    z: z.number(),
+});
+export const hierarchyListSchema = {
+    rootPath: z.string().optional(),
+    recursive: z.boolean().optional(),
+};
+export const gameObjectCreateSchema = {
+    name: z.string().optional(),
+    parentPath: z.string().optional(),
+};
+export const gameObjectRenameSchema = {
+    path: z.string().min(1),
+    name: z.string().min(1),
+};
+export const transformSetSchema = {
+    path: z.string().min(1),
+    position: vector3Schema.optional(),
+    localPosition: vector3Schema.optional(),
+    rotation: vector3Schema.optional(),
+    localRotation: vector3Schema.optional(),
+    scale: vector3Schema.optional(),
+};
+export const componentSchema = {
+    path: z.string().min(1),
+    typeName: z.string().min(1),
+};
+const propertyValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.object({ x: z.number(), y: z.number() }),
+    z.object({ x: z.number(), y: z.number(), z: z.number() }),
+    z.object({ r: z.number(), g: z.number(), b: z.number(), a: z.number().optional() }),
+]);
+export const componentPropertyGetSchema = {
+    path: z.string().min(1),
+    typeName: z.string().min(1),
+    propertyPath: z.string().min(1),
+};
+export const componentPropertySetSchema = {
+    path: z.string().min(1),
+    typeName: z.string().min(1),
+    propertyPath: z.string().min(1),
+    value: propertyValueSchema.optional(),
+    objectReferenceAssetPath: z.string().optional(),
+};
+export const scriptCreateSchema = {
+    assetPath: z.string().min(1),
+    className: z.string().optional(),
+    content: z.string().optional(),
+    overwrite: z.boolean().optional(),
+};
+export const scriptAttachSchema = {
+    path: z.string().min(1),
+    typeName: z.string().min(1),
+    compileTimeoutMs: z.number().int().positive().optional(),
+};
+export const sceneNewSchema = {
+    setup: z.enum(["DefaultGameObjects", "EmptyScene"]).optional(),
+    mode: z.enum(["Single", "Additive"]).optional(),
+};
+export const sceneOpenSchema = {
+    path: z.string().min(1),
+    mode: z.enum(["Single", "Additive"]).optional(),
+};
+export const prefabCreateSchema = {
+    path: z.string().min(1),
+    assetPath: z.string().min(1),
+};
+export const prefabInstantiateSchema = {
+    assetPath: z.string().min(1),
+    parentPath: z.string().optional(),
+};
+export const assetFindSchema = {
+    filter: z.string().min(1),
+    folders: z.array(z.string().min(1)).optional(),
+};
+export const assetPathSchema = {
+    assetPath: z.string().min(1),
+};
+export const assetCreateFolderSchema = {
+    parentPath: z.string().optional(),
+    name: z.string().min(1),
+};
+export const bridgeSelectSchema = {
+    url: z.string().min(1).optional(),
+    projectPath: z.string().min(1).optional(),
+    projectName: z.string().min(1).optional(),
+    instanceId: z.string().min(1).optional(),
+};

package/dist/unity/BridgeRegistry.js

@@ -0,0 +1,167 @@
+import { BridgeError } from "../errors.js";
+export class BridgeRegistry {
+    options;
+    probeUrls;
+    entries = [];
+    lastDiscoveredAt = 0;
+    discoverPromise = null;
+    constructor(options) {
+        this.options = options;
+        const all = new Set();
+        all.add(stripTrailingSlash(options.bridgeUrl));
+        for (const url of options.detectUrls) {
+            all.add(stripTrailingSlash(url));
+        }
+        this.probeUrls = Array.from(all);
+    }
+    async list(force = false) {
+        if (!force && this.entries.length > 0 && Date.now() - this.lastDiscoveredAt < 1500) {
+            return this.entries;
+        }
+        return this.discover();
+    }
+    async resolve(force = false) {
+        if (this.options.bridgeUrlExplicit) {
+            const url = stripTrailingSlash(this.options.bridgeUrl);
+            const entry = await this.probeOne(url);
+            return {
+                url,
+                reason: "UNITY_MCP_BRIDGE_URL is set explicitly.",
+                entry,
+            };
+        }
+        const entries = await this.list(force);
+        if (entries.length === 0) {
+            throw new BridgeError("BRIDGE_UNAVAILABLE", `No Unity bridge found in range ${this.probeRange()}. Open the Unity project and ensure the bridge is running via the Tools > Unity MCP window.`);
+        }
+        if (this.options.projectPath) {
+            const target = normalizePath(this.options.projectPath);
+            const match = entries.find(e => e.projectPath && normalizePath(e.projectPath) === target);
+            if (match) {
+                return { url: match.url, reason: `Matched UNITY_MCP_PROJECT_PATH=${this.options.projectPath}.`, entry: match };
+            }
+            throw new BridgeError("PROJECT_NOT_FOUND", `No bridge matched UNITY_MCP_PROJECT_PATH=${this.options.projectPath}. Candidates: ${describeEntries(entries)}`);
+        }
+        if (this.options.projectName) {
+            const target = this.options.projectName.toLowerCase();
+            const match = entries.find(e => e.productName && e.productName.toLowerCase() === target);
+            if (match) {
+                return { url: match.url, reason: `Matched UNITY_MCP_PROJECT_NAME=${this.options.projectName}.`, entry: match };
+            }
+            throw new BridgeError("PROJECT_NOT_FOUND", `No bridge matched UNITY_MCP_PROJECT_NAME=${this.options.projectName}. Candidates: ${describeEntries(entries)}`);
+        }
+        if (this.options.cwdProjectPath) {
+            const target = normalizePath(this.options.cwdProjectPath);
+            const match = entries.find(e => e.projectPath && normalizePath(e.projectPath) === target);
+            if (match) {
+                return { url: match.url, reason: `Matched current working directory project ${this.options.cwdProjectPath}.`, entry: match };
+            }
+        }
+        if (entries.length === 1) {
+            return { url: entries[0].url, reason: "Only one bridge online.", entry: entries[0] };
+        }
+        throw new BridgeError("BRIDGE_AMBIGUOUS", `Multiple Unity bridges online and no selector matched. Set UNITY_MCP_PROJECT_PATH or UNITY_MCP_PROJECT_NAME, or call unity_bridge_select. Candidates: ${describeEntries(entries)}`, { candidates: entries.map(toCandidateDto) });
+    }
+    async select(filter) {
+        const entries = await this.list(true);
+        const url = filter.url ? stripTrailingSlash(filter.url) : null;
+        const projectPath = filter.projectPath ? normalizePath(filter.projectPath) : null;
+        const projectName = filter.projectName ? filter.projectName.toLowerCase() : null;
+        const instanceId = filter.instanceId ?? null;
+        const match = entries.find(e => {
+            if (url && e.url !== url)
+                return false;
+            if (projectPath && (!e.projectPath || normalizePath(e.projectPath) !== projectPath))
+                return false;
+            if (projectName && (!e.productName || e.productName.toLowerCase() !== projectName))
+                return false;
+            if (instanceId && e.instanceId !== instanceId)
+                return false;
+            return true;
+        });
+        if (!match) {
+            throw new BridgeError("PROJECT_NOT_FOUND", `No bridge matches the requested selector. Candidates: ${describeEntries(entries)}`, { candidates: entries.map(toCandidateDto) });
+        }
+        return { url: match.url, reason: "Selected via unity_bridge_select.", entry: match };
+    }
+    async probeOne(url) {
+        try {
+            const health = await fetchHealth(url, this.options.probeTimeoutMs);
+            return entryFromHealth(url, health);
+        }
+        catch {
+            return null;
+        }
+    }
+    async discover() {
+        if (this.discoverPromise) {
+            return this.discoverPromise;
+        }
+        this.discoverPromise = (async () => {
+            const results = await Promise.all(this.probeUrls.map(url => this.probeOne(url)));
+            const entries = results.filter((entry) => entry !== null);
+            this.entries = entries;
+            this.lastDiscoveredAt = Date.now();
+            return entries;
+        })();
+        try {
+            return await this.discoverPromise;
+        }
+        finally {
+            this.discoverPromise = null;
+        }
+    }
+    probeRange() {
+        if (this.probeUrls.length === 0)
+            return "(none)";
+        if (this.probeUrls.length === 1)
+            return this.probeUrls[0];
+        return `${this.probeUrls[0]} .. ${this.probeUrls[this.probeUrls.length - 1]}`;
+    }
+}
+async function fetchHealth(url, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(`${url}/health`, { method: "GET", signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return (await response.json());
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function entryFromHealth(url, health) {
+    return {
+        url,
+        projectPath: typeof health.projectPath === "string" ? health.projectPath : null,
+        productName: typeof health.productName === "string" ? health.productName : null,
+        instanceId: typeof health.instanceId === "string" ? health.instanceId : null,
+        unityVersion: typeof health.unityVersion === "string" ? health.unityVersion : null,
+        rawHealth: health,
+    };
+}
+function stripTrailingSlash(url) {
+    return url.replace(/\/$/, "");
+}
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function describeEntries(entries) {
+    if (entries.length === 0)
+        return "(none)";
+    return entries
+        .map(e => `[${e.url} ${e.productName ?? "?"} (${e.projectPath ?? "?"})]`)
+        .join(", ");
+}
+export function toCandidateDto(entry) {
+    return {
+        url: entry.url,
+        projectPath: entry.projectPath,
+        productName: entry.productName,
+        instanceId: entry.instanceId,
+        unityVersion: entry.unityVersion,
+    };
+}

package/dist/unity/UnityBridgeClient.js

@@ -0,0 +1,136 @@
+import { BridgeError } from "../errors.js";
+export class UnityBridgeClient {
+    registry;
+    timeoutMs;
+    currentSelection = null;
+    resolvePromise = null;
+    constructor(registry, timeoutMs) {
+        this.registry = registry;
+        this.timeoutMs = timeoutMs;
+    }
+    async health() {
+        const selection = await this.ensureSelection();
+        const url = `${selection.url}/health`;
+        try {
+            return await this.fetchJson(url, { method: "GET" });
+        }
+        catch (error) {
+            if (error instanceof BridgeError && error.code === "BRIDGE_UNAVAILABLE") {
+                await this.refreshSelection();
+                const next = await this.ensureSelection();
+                return this.fetchJson(`${next.url}/health`, { method: "GET" });
+            }
+            throw error;
+        }
+    }
+    async command(command, params = {}) {
+        const request = {
+            id: crypto.randomUUID(),
+            command,
+            params,
+        };
+        const init = {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(request),
+        };
+        let selection = await this.ensureSelection();
+        let response;
+        try {
+            response = await this.fetchJson(`${selection.url}/command`, init);
+        }
+        catch (error) {
+            if (!(error instanceof BridgeError) || error.code !== "BRIDGE_UNAVAILABLE") {
+                throw error;
+            }
+            await this.refreshSelection();
+            selection = await this.ensureSelection();
+            response = await this.fetchJson(`${selection.url}/command`, init);
+        }
+        if (!response.ok) {
+            throw new BridgeError(response.error?.code ?? "OPERATION_FAILED", response.error?.message ?? "Unity bridge command failed.", response.error?.details);
+        }
+        return response.result;
+    }
+    async listBridges() {
+        const entries = await this.registry.list(true);
+        const current = this.currentSelection;
+        return entries.map(entry => ({
+            url: entry.url,
+            projectPath: entry.projectPath,
+            productName: entry.productName,
+            instanceId: entry.instanceId,
+            unityVersion: entry.unityVersion,
+            isCurrent: current ? current.url === entry.url : false,
+        }));
+    }
+    async selectBridge(filter) {
+        const selection = await this.registry.select(filter);
+        this.currentSelection = selection;
+        return {
+            url: selection.url,
+            reason: selection.reason,
+            projectPath: selection.entry?.projectPath ?? null,
+            productName: selection.entry?.productName ?? null,
+            instanceId: selection.entry?.instanceId ?? null,
+            unityVersion: selection.entry?.unityVersion ?? null,
+        };
+    }
+    async describeCurrent() {
+        const selection = await this.ensureSelection();
+        return {
+            url: selection.url,
+            reason: selection.reason,
+            projectPath: selection.entry?.projectPath ?? null,
+            productName: selection.entry?.productName ?? null,
+            instanceId: selection.entry?.instanceId ?? null,
+            unityVersion: selection.entry?.unityVersion ?? null,
+        };
+    }
+    async ensureSelection() {
+        if (this.currentSelection) {
+            return this.currentSelection;
+        }
+        if (!this.resolvePromise) {
+            this.resolvePromise = this.registry.resolve();
+        }
+        try {
+            this.currentSelection = await this.resolvePromise;
+            return this.currentSelection;
+        }
+        finally {
+            this.resolvePromise = null;
+        }
+    }
+    async refreshSelection() {
+        this.currentSelection = null;
+        this.resolvePromise = this.registry.resolve(true);
+        try {
+            this.currentSelection = await this.resolvePromise;
+        }
+        finally {
+            this.resolvePromise = null;
+        }
+    }
+    async fetchJson(url, init) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(url, { ...init, signal: controller.signal });
+            if (!response.ok) {
+                throw new BridgeError("BRIDGE_UNAVAILABLE", `Unity bridge returned HTTP ${response.status}.`);
+            }
+            return (await response.json());
+        }
+        catch (error) {
+            if (error instanceof BridgeError) {
+                throw error;
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new BridgeError("BRIDGE_UNAVAILABLE", `Could not reach Unity bridge at ${url}. Open the Unity project and start the bridge from the Tools > Unity MCP window. ${message}`);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}

package/dist/unity/UnityBridgeTypes.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@luoluo123/unity-mcp-server",
+  "version": "0.6.2",
+  "description": "MCP stdio server for Unity Editor MCP Bridge.",
+  "type": "module",
+  "bin": {
+    "unity-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FRZ5201314/UnityEditorMCP.git",
+    "directory": "server"
+  },
+  "homepage": "https://github.com/FRZ5201314/UnityEditorMCP#readme",
+  "bugs": {
+    "url": "https://github.com/FRZ5201314/UnityEditorMCP/issues"
+  },
+  "keywords": [
+    "mcp",
+    "unity",
+    "unity-editor",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.12.12",
+    "typescript": "^5.4.5"
+  }
+}