@mseep/anklebreaker-unity-mcp 2.30.0

package/src/tools/hub-tools.js

@@ -0,0 +1,96 @@
+// AnkleBreaker Unity MCP — Tool definitions for Unity Hub operations
+import * as hub from "../unity-hub.js";
+
+export const hubTools = [
+  {
+    name: "unity_hub_list_editors",
+    description: "List all Unity Editor versions currently installed via Unity Hub, including their installation paths.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+    handler: async () => {
+      const result = await hub.listInstalledEditors();
+      return JSON.stringify(result, null, 2);
+    },
+  },
+  {
+    name: "unity_hub_available_releases",
+    description: "List Unity Editor versions available for download from Unity Hub.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+    handler: async () => {
+      const result = await hub.listAvailableReleases();
+      return JSON.stringify(result, null, 2);
+    },
+  },
+  {
+    name: "unity_hub_install_editor",
+    description: "Install a specific Unity Editor version. Optionally include platform modules (android, ios, webgl, linux, macos, windows-il2cpp).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        version: { type: "string", description: "Unity version to install (e.g. '2022.3.20f1', '6000.3.7f1')" },
+        modules: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional modules to install: android, android-sdk-ndk-tools, android-open-jdk, ios, webgl, linux-il2cpp, mac-il2cpp, windows-il2cpp, etc.",
+        },
+      },
+      required: ["version"],
+    },
+    handler: async ({ version, modules }) => {
+      const result = await hub.installEditor(version, modules || []);
+      return JSON.stringify(result, null, 2);
+    },
+  },
+  {
+    name: "unity_hub_install_modules",
+    description: "Install additional platform modules to an already-installed Unity Editor version.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        version: { type: "string", description: "Target Unity version" },
+        modules: {
+          type: "array",
+          items: { type: "string" },
+          description: "Modules to add: android, ios, webgl, etc.",
+        },
+      },
+      required: ["version", "modules"],
+    },
+    handler: async ({ version, modules }) => {
+      const result = await hub.installModules(version, modules);
+      return JSON.stringify(result, null, 2);
+    },
+  },
+  {
+    name: "unity_hub_get_install_path",
+    description: "Get the current default installation path for Unity Editors.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+    },
+    handler: async () => {
+      const result = await hub.getInstallPath();
+      return JSON.stringify(result, null, 2);
+    },
+  },
+  {
+    name: "unity_hub_set_install_path",
+    description: "Set the default installation directory for Unity Editors.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "New installation directory path" },
+      },
+      required: ["path"],
+    },
+    handler: async ({ path }) => {
+      const result = await hub.setInstallPath(path);
+      return JSON.stringify(result, null, 2);
+    },
+  },
+];

package/src/tools/instance-tools.js

@@ -0,0 +1,114 @@
+// AnkleBreaker Unity MCP — Tool definitions for Multi-Instance Management
+// These tools let agents discover, list, and select which Unity Editor instance to work with.
+
+import {
+  discoverInstances,
+  selectInstance,
+  getSelectedInstance,
+  autoSelectInstance,
+} from "../instance-discovery.js";
+
+export const instanceTools = [
+  {
+    name: "unity_list_instances",
+    description:
+      "List all running Unity Editor instances that the MCP can connect to. " +
+      "Returns each instance's project name, port, Unity version, and whether it's a ParrelSync clone. " +
+      "Use this to see which Unity projects are currently open before selecting one to work with. " +
+      "IMPORTANT: When multiple instances are detected, always call this first and then use " +
+      "unity_select_instance to choose which project to target.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        refresh: {
+          type: "boolean",
+          description:
+            "Force a fresh discovery scan (default: true). Set to false to use cached results.",
+        },
+      },
+    },
+    handler: async ({ refresh = true } = {}) => {
+      const instances = await discoverInstances();
+      const selected = getSelectedInstance();
+
+      const result = {
+        instances: instances.map((inst) => ({
+          port: inst.port,
+          projectName: inst.projectName,
+          projectPath: inst.projectPath,
+          unityVersion: inst.unityVersion,
+          isClone: inst.isClone,
+          cloneIndex: inst.cloneIndex,
+          source: inst.source,
+          isSelected: selected ? selected.port === inst.port : false,
+        })),
+        totalCount: instances.length,
+        selectedPort: selected?.port || null,
+        selectedProject: selected?.projectName || null,
+      };
+
+      if (instances.length === 0) {
+        result.message =
+          "No Unity Editor instances found. Make sure Unity is running with the MCP plugin enabled.";
+      } else if (!selected) {
+        result.message = `Found ${instances.length} Unity instance(s). Use unity_select_instance to choose which project to work with.`;
+      } else {
+        result.message = `Found ${instances.length} Unity instance(s). Currently targeting: ${selected.projectName} (port ${selected.port})`;
+      }
+
+      return JSON.stringify(result, null, 2);
+    },
+  },
+
+  {
+    name: "unity_select_instance",
+    description:
+      "Select which Unity Editor instance to work with for this session. " +
+      "All subsequent unity_* commands will be routed to the selected instance. " +
+      "You must provide the port number of the instance (get it from unity_list_instances). " +
+      "IMPORTANT: Call unity_list_instances first to see available instances and their ports. " +
+      "PARALLEL SAFETY: After selecting, include 'port: <number>' as a parameter in ALL " +
+      "subsequent unity_* tool calls to guarantee routing to this instance even when " +
+      "multiple agents share the same MCP process.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        port: {
+          type: "number",
+          description:
+            "The port number of the Unity instance to select (from unity_list_instances output).",
+        },
+      },
+      required: ["port"],
+    },
+    handler: async ({ port }) => {
+      if (!port || typeof port !== "number") {
+        return JSON.stringify(
+          {
+            success: false,
+            error:
+              "Port number is required. Use unity_list_instances to see available instances.",
+          },
+          null,
+          2
+        );
+      }
+
+      const result = await selectInstance(port);
+
+      // Enhance successful responses with parallel-safe routing instructions
+      if (result.success) {
+        result.routing = {
+          port: port,
+          instruction:
+            `IMPORTANT — PARALLEL SAFETY: To guarantee your commands reach "${result.instance?.projectName || "this instance"}" ` +
+            `(port ${port}), you MUST include  port: ${port}  as a parameter in ALL subsequent unity_* tool calls. ` +
+            `This prevents cross-agent routing issues when multiple tasks run in parallel. ` +
+            `Example: unity_execute_code({ code: "...", port: ${port} })`,
+        };
+      }
+
+      return JSON.stringify(result, null, 2);
+    },
+  },
+];