uloop-cli 0.67.5 → 0.68.1

package/dist/cli.bundle.cjs

@@ -5383,8 +5383,8 @@ var require_semver2 = __commonJS({
 });
 
 // src/cli.ts
-var import_fs7 = require("fs");
-var import_path8 = require("path");
+var import_fs8 = require("fs");
+var import_path9 = require("path");
 var import_os2 = require("os");
 var import_child_process = require("child_process");
 
@@ -5486,13 +5486,13 @@ var DirectUnityClient = class {
   requestId = 0;
   receiveBuffer = Buffer.alloc(0);
   async connect() {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       this.socket = new net.Socket();
       this.socket.on("error", (error) => {
         reject(new Error(`Connection error: ${error.message}`));
       });
       this.socket.connect(this.port, this.host, () => {
-        resolve6();
+        resolve7();
       });
     });
   }
@@ -5508,7 +5508,7 @@ var DirectUnityClient = class {
     };
     const requestJson = JSON.stringify(request);
     const framedMessage = createFrame(requestJson);
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const socket = this.socket;
       const cleanup = () => {
         clearTimeout(timeoutId);
@@ -5545,7 +5545,7 @@ var DirectUnityClient = class {
           reject(new Error(`Unity error: ${response.error.message}`));
           return;
         }
-        resolve6(response.result);
+        resolve7(response.result);
       };
       const onError = (error) => {
         cleanup();
@@ -5824,7 +5824,7 @@ var import_path3 = require("path");
 
 // src/default-tools.json
 var default_tools_default = {
-  version: "0.67.5",
+  version: "0.68.1",
   tools: [
     {
       name: "compile",
@@ -6168,8 +6168,8 @@ var default_tools_default = {
       }
     },
     {
-      name: "capture-window",
-      description: "Capture Unity EditorWindow and save as PNG",
+      name: "screenshot",
+      description: "Take a screenshot of Unity EditorWindow and save as PNG",
       inputSchema: {
         type: "object",
         properties: {
@@ -6192,6 +6192,11 @@ var default_tools_default = {
               "contains"
             ],
             default: "exact"
+          },
+          OutputDirectory: {
+            type: "string",
+            description: "Output directory path for saving screenshots. When empty, uses default path (.uloop/outputs/Screenshots/). Accepts absolute paths.",
+            default: ""
           }
         }
       }
@@ -6217,33 +6222,6 @@ var default_tools_default = {
         }
       }
     },
-    {
-      name: "get-provider-details",
-      description: "Get Unity Search provider details",
-      inputSchema: {
-        type: "object",
-        properties: {
-          ProviderId: {
-            type: "string",
-            description: "Specific provider ID"
-          },
-          ActiveOnly: {
-            type: "boolean",
-            description: "Only active providers"
-          },
-          IncludeDescriptions: {
-            type: "boolean",
-            description: "Include descriptions",
-            default: true
-          },
-          SortByPriority: {
-            type: "boolean",
-            description: "Sort by priority",
-            default: true
-          }
-        }
-      }
-    },
     {
       name: "get-project-info",
       description: "Get Unity project information",
@@ -6340,7 +6318,7 @@ function getCachedServerVersion() {
 }
 
 // src/version.ts
-var VERSION = "0.67.5";
+var VERSION = "0.68.1";
 
 // src/spinner.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -6476,11 +6454,11 @@ function tryReadCompileResult(projectRoot, requestId) {
   }
 }
 function canSendRequestToUnity(port) {
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const socket = new net2.Socket();
     const timer = setTimeout(() => {
       socket.destroy();
-      resolve6(false);
+      resolve7(false);
     }, READINESS_CHECK_TIMEOUT_MS);
     const cleanup = () => {
       clearTimeout(timer);
@@ -6503,21 +6481,21 @@ function canSendRequestToUnity(port) {
       const sepIndex = buffer.indexOf(HEADER_SEPARATOR2);
       if (sepIndex !== -1) {
         cleanup();
-        resolve6(true);
+        resolve7(true);
       }
     });
     socket.on("error", () => {
       cleanup();
-      resolve6(false);
+      resolve7(false);
     });
     socket.on("close", () => {
       clearTimeout(timer);
-      resolve6(false);
+      resolve7(false);
     });
   });
 }
 function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
 }
 async function waitForCompileCompletion(options) {
   const startTime = Date.now();
@@ -6929,16 +6907,65 @@ function pascalToKebabCase(pascal) {
 }
 
 // src/skills/skills-manager.ts
-var import_fs6 = require("fs");
-var import_path6 = require("path");
+var import_fs7 = require("fs");
+var import_path7 = require("path");
 var import_os = require("os");
 
 // src/skills/deprecated-skills.ts
 var DEPRECATED_SKILLS = [
-  "uloop-capture-window"
+  "uloop-capture-window",
   // renamed to uloop-screenshot in v0.54.0
+  "uloop-get-provider-details"
+  // internal development-only tool, not for end users
 ];
 
+// src/tool-settings-loader.ts
+var import_fs6 = require("fs");
+var import_path6 = require("path");
+var ULOOP_DIR = ".uloop";
+var TOOL_SETTINGS_FILE = "settings.tools.json";
+function loadDisabledTools(projectPath) {
+  const projectRoot = projectPath !== void 0 ? (0, import_path6.resolve)(projectPath) : findUnityProjectRoot();
+  if (projectRoot === null) {
+    return [];
+  }
+  const settingsPath = (0, import_path6.join)(projectRoot, ULOOP_DIR, TOOL_SETTINGS_FILE);
+  let content;
+  try {
+    content = (0, import_fs6.readFileSync)(settingsPath, "utf-8");
+  } catch {
+    return [];
+  }
+  if (!content.trim()) {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return [];
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return [];
+  }
+  const data = parsed;
+  if (!Array.isArray(data.disabledTools)) {
+    return [];
+  }
+  return data.disabledTools;
+}
+function isToolEnabled(toolName, projectPath) {
+  const disabledTools = loadDisabledTools(projectPath);
+  return !disabledTools.includes(toolName);
+}
+function filterEnabledTools(tools, projectPath) {
+  const disabledTools = loadDisabledTools(projectPath);
+  if (disabledTools.length === 0) {
+    return tools;
+  }
+  return tools.filter((tool) => !disabledTools.includes(tool.name));
+}
+
 // src/skills/skills-manager.ts
 var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set([
   "node_modules",
@@ -6977,7 +7004,7 @@ var SkillsPathConstants = class _SkillsPathConstants {
   ];
 };
 function getGlobalSkillsDir(target) {
-  return (0, import_path6.join)((0, import_os.homedir)(), target.projectDir, "skills");
+  return (0, import_path7.join)((0, import_os.homedir)(), target.projectDir, "skills");
 }
 function getProjectSkillsDir(target) {
   const status = getUnityProjectStatus();
@@ -6992,35 +7019,35 @@ function getProjectSkillsDir(target) {
 Please install uLoopMCP package first, then run this command again.`
     );
   }
-  return (0, import_path6.join)(status.path, target.projectDir, "skills");
+  return (0, import_path7.join)(status.path, target.projectDir, "skills");
 }
 function getSkillPath(skillDirName, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  return (0, import_path6.join)(baseDir, skillDirName, target.skillFileName);
+  return (0, import_path7.join)(baseDir, skillDirName, target.skillFileName);
 }
 function isSkillInstalled(skill, target, global) {
   const skillPath = getSkillPath(skill.dirName, target, global);
-  return (0, import_fs6.existsSync)(skillPath);
+  return (0, import_fs7.existsSync)(skillPath);
 }
 function isSkillOutdated(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  const skillDir = (0, import_path6.join)(baseDir, skill.dirName);
-  const skillPath = (0, import_path6.join)(skillDir, target.skillFileName);
-  if (!(0, import_fs6.existsSync)(skillPath)) {
+  const skillDir = (0, import_path7.join)(baseDir, skill.dirName);
+  const skillPath = (0, import_path7.join)(skillDir, target.skillFileName);
+  if (!(0, import_fs7.existsSync)(skillPath)) {
     return false;
   }
-  const installedContent = (0, import_fs6.readFileSync)(skillPath, "utf-8");
+  const installedContent = (0, import_fs7.readFileSync)(skillPath, "utf-8");
   if (installedContent !== skill.content) {
     return true;
   }
   if ("additionalFiles" in skill && skill.additionalFiles) {
     const additionalFiles = skill.additionalFiles;
     for (const [relativePath, expectedContent] of Object.entries(additionalFiles)) {
-      const filePath = (0, import_path6.join)(skillDir, relativePath);
-      if (!(0, import_fs6.existsSync)(filePath)) {
+      const filePath = (0, import_path7.join)(skillDir, relativePath);
+      if (!(0, import_fs7.existsSync)(filePath)) {
         return true;
       }
-      const installedFileContent = (0, import_fs6.readFileSync)(filePath);
+      const installedFileContent = (0, import_fs7.readFileSync)(filePath);
       if (!installedFileContent.equals(expectedContent)) {
         return true;
       }
@@ -7038,12 +7065,12 @@ function getSkillStatus(skill, target, global) {
   return "installed";
 }
 function parseFrontmatter(content) {
-  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
   if (!frontmatterMatch) {
     return {};
   }
   const frontmatterMap = /* @__PURE__ */ new Map();
-  const lines = frontmatterMatch[1].split("\n");
+  const lines = frontmatterMatch[1].split(/\r?\n/);
   for (const line of lines) {
     const colonIndex = line.indexOf(":");
     if (colonIndex === -1) {
@@ -7084,32 +7111,34 @@ function warnLegacySkillStructure(toolPath, legacySkillMdPath) {
   console.error("");
 }
 function scanEditorFolderForSkills(editorPath, skills, sourceType, warnLegacy = true) {
-  if (!(0, import_fs6.existsSync)(editorPath)) {
+  if (!(0, import_fs7.existsSync)(editorPath)) {
     return;
   }
-  const entries = (0, import_fs6.readdirSync)(editorPath, { withFileTypes: true });
+  const entries = (0, import_fs7.readdirSync)(editorPath, { withFileTypes: true });
   for (const entry of entries) {
     if (EXCLUDED_DIRS2.has(entry.name)) {
       continue;
     }
-    const fullPath = (0, import_path6.join)(editorPath, entry.name);
+    const fullPath = (0, import_path7.join)(editorPath, entry.name);
     if (entry.isDirectory()) {
-      const skillDir = (0, import_path6.join)(fullPath, SkillsPathConstants.SKILL_DIR);
-      const skillMdPath = (0, import_path6.join)(skillDir, SkillsPathConstants.SKILL_FILE);
-      const legacySkillMdPath = (0, import_path6.join)(fullPath, SkillsPathConstants.SKILL_FILE);
-      if (warnLegacy && !(0, import_fs6.existsSync)(skillMdPath) && (0, import_fs6.existsSync)(legacySkillMdPath)) {
+      const skillDir = (0, import_path7.join)(fullPath, SkillsPathConstants.SKILL_DIR);
+      const skillMdPath = (0, import_path7.join)(skillDir, SkillsPathConstants.SKILL_FILE);
+      const legacySkillMdPath = (0, import_path7.join)(fullPath, SkillsPathConstants.SKILL_FILE);
+      if (warnLegacy && !(0, import_fs7.existsSync)(skillMdPath) && (0, import_fs7.existsSync)(legacySkillMdPath)) {
         warnLegacySkillStructure(fullPath, legacySkillMdPath);
       }
-      if ((0, import_fs6.existsSync)(skillMdPath)) {
-        const content = (0, import_fs6.readFileSync)(skillMdPath, "utf-8");
+      if ((0, import_fs7.existsSync)(skillMdPath)) {
+        const content = (0, import_fs7.readFileSync)(skillMdPath, "utf-8");
         const frontmatter = parseFrontmatter(content);
         if (frontmatter.internal === true) {
           continue;
         }
         const name = typeof frontmatter.name === "string" ? frontmatter.name : entry.name;
+        const toolName = typeof frontmatter.toolName === "string" ? frontmatter.toolName : void 0;
         const additionalFiles = collectSkillFolderFiles(skillDir);
         skills.push({
           name,
+          toolName,
           dirName: name,
           content,
           sourcePath: skillMdPath,
@@ -7124,15 +7153,15 @@ function scanEditorFolderForSkills(editorPath, skills, sourceType, warnLegacy =
 function findEditorFolders(basePath, maxDepth = 2) {
   const editorFolders = [];
   function scan(currentPath, depth) {
-    if (depth > maxDepth || !(0, import_fs6.existsSync)(currentPath)) {
+    if (depth > maxDepth || !(0, import_fs7.existsSync)(currentPath)) {
       return;
     }
-    const entries = (0, import_fs6.readdirSync)(currentPath, { withFileTypes: true });
+    const entries = (0, import_fs7.readdirSync)(currentPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || EXCLUDED_DIRS2.has(entry.name)) {
         continue;
       }
-      const fullPath = (0, import_path6.join)(currentPath, entry.name);
+      const fullPath = (0, import_path7.join)(currentPath, entry.name);
       if (entry.name === "Editor") {
         editorFolders.push(fullPath);
       } else {
@@ -7151,12 +7180,12 @@ function collectProjectSkills(excludedRoots = []) {
   const skills = [];
   const seenNames = /* @__PURE__ */ new Set();
   const searchPaths = [
-    (0, import_path6.join)(projectRoot, SkillsPathConstants.ASSETS_DIR),
-    (0, import_path6.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR),
-    (0, import_path6.join)(projectRoot, SkillsPathConstants.LIBRARY_DIR, SkillsPathConstants.PACKAGE_CACHE_DIR)
+    (0, import_path7.join)(projectRoot, SkillsPathConstants.ASSETS_DIR),
+    (0, import_path7.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR),
+    (0, import_path7.join)(projectRoot, SkillsPathConstants.LIBRARY_DIR, SkillsPathConstants.PACKAGE_CACHE_DIR)
   ];
   for (const searchPath of searchPaths) {
-    if (!(0, import_fs6.existsSync)(searchPath)) {
+    if (!(0, import_fs7.existsSync)(searchPath)) {
       continue;
     }
     const editorFolders = findEditorFolders(searchPath, 3);
@@ -7187,26 +7216,26 @@ function getAllSkillStatuses(target, global) {
 }
 function installSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  const skillDir = (0, import_path6.join)(baseDir, skill.dirName);
-  const skillPath = (0, import_path6.join)(skillDir, target.skillFileName);
-  (0, import_fs6.mkdirSync)(skillDir, { recursive: true });
-  (0, import_fs6.writeFileSync)(skillPath, skill.content, "utf-8");
+  const skillDir = (0, import_path7.join)(baseDir, skill.dirName);
+  const skillPath = (0, import_path7.join)(skillDir, target.skillFileName);
+  (0, import_fs7.mkdirSync)(skillDir, { recursive: true });
+  (0, import_fs7.writeFileSync)(skillPath, skill.content, "utf-8");
   if ("additionalFiles" in skill && skill.additionalFiles) {
     const additionalFiles = skill.additionalFiles;
     for (const [relativePath, content] of Object.entries(additionalFiles)) {
-      const fullPath = (0, import_path6.join)(skillDir, relativePath);
-      (0, import_fs6.mkdirSync)((0, import_path6.dirname)(fullPath), { recursive: true });
-      (0, import_fs6.writeFileSync)(fullPath, content);
+      const fullPath = (0, import_path7.join)(skillDir, relativePath);
+      (0, import_fs7.mkdirSync)((0, import_path7.dirname)(fullPath), { recursive: true });
+      (0, import_fs7.writeFileSync)(fullPath, content);
     }
   }
 }
 function uninstallSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  const skillDir = (0, import_path6.join)(baseDir, skill.dirName);
-  if (!(0, import_fs6.existsSync)(skillDir)) {
+  const skillDir = (0, import_path7.join)(baseDir, skill.dirName);
+  if (!(0, import_fs7.existsSync)(skillDir)) {
     return false;
   }
-  (0, import_fs6.rmSync)(skillDir, { recursive: true, force: true });
+  (0, import_fs7.rmSync)(skillDir, { recursive: true, force: true });
   return true;
 }
 function installAllSkills(target, global) {
@@ -7220,16 +7249,21 @@ function installAllSkills(target, global) {
   };
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   for (const deprecatedName of DEPRECATED_SKILLS) {
-    const deprecatedDir = (0, import_path6.join)(baseDir, deprecatedName);
-    if ((0, import_fs6.existsSync)(deprecatedDir)) {
-      (0, import_fs6.rmSync)(deprecatedDir, { recursive: true, force: true });
+    const deprecatedDir = (0, import_path7.join)(baseDir, deprecatedName);
+    if ((0, import_fs7.existsSync)(deprecatedDir)) {
+      (0, import_fs7.rmSync)(deprecatedDir, { recursive: true, force: true });
       result.deprecatedRemoved++;
     }
   }
+  const disabledTools = global ? [] : loadDisabledTools();
   const allSkills = collectAllSkills();
   const projectSkills = allSkills.filter((skill) => skill.sourceType === "project");
   const nonProjectSkills = allSkills.filter((skill) => skill.sourceType !== "project");
   for (const skill of allSkills) {
+    if (isSkillDisabledByToolSettings(skill, disabledTools)) {
+      uninstallSkill(skill, target, global);
+      continue;
+    }
     const status = getSkillStatus(skill, target, global);
     if (status === "not_installed") {
       installSkill(skill, target, global);
@@ -7245,13 +7279,23 @@ function installAllSkills(target, global) {
   result.projectCount = projectSkills.length;
   return result;
 }
+function isSkillDisabledByToolSettings(skill, disabledTools) {
+  if (disabledTools.length === 0) {
+    return false;
+  }
+  const toolName = skill.toolName ?? (skill.name.startsWith("uloop-") ? skill.name.slice("uloop-".length) : null);
+  if (toolName === null) {
+    return false;
+  }
+  return disabledTools.includes(toolName);
+}
 function uninstallAllSkills(target, global) {
   const result = { removed: 0, notFound: 0 };
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   for (const deprecatedName of DEPRECATED_SKILLS) {
-    const deprecatedDir = (0, import_path6.join)(baseDir, deprecatedName);
-    if ((0, import_fs6.existsSync)(deprecatedDir)) {
-      (0, import_fs6.rmSync)(deprecatedDir, { recursive: true, force: true });
+    const deprecatedDir = (0, import_path7.join)(baseDir, deprecatedName);
+    if ((0, import_fs7.existsSync)(deprecatedDir)) {
+      (0, import_fs7.rmSync)(deprecatedDir, { recursive: true, force: true });
       result.removed++;
     }
   }
@@ -7280,13 +7324,13 @@ function collectAllSkills() {
   return dedupeSkillsByName([packageSkills, cliOnlySkills, projectSkills]);
 }
 function collectPackageSkillsFromRoot(packageRoot) {
-  const mcpToolsRoot = (0, import_path6.join)(
+  const mcpToolsRoot = (0, import_path7.join)(
     packageRoot,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if (!(0, import_fs6.existsSync)(mcpToolsRoot)) {
+  if (!(0, import_fs7.existsSync)(mcpToolsRoot)) {
     return [];
   }
   const skills = [];
@@ -7294,7 +7338,7 @@ function collectPackageSkillsFromRoot(packageRoot) {
   return skills;
 }
 function collectCliOnlySkills() {
-  const cliOnlyRoot = (0, import_path6.resolve)(
+  const cliOnlyRoot = (0, import_path7.resolve)(
     __dirname,
     SkillsPathConstants.DIST_PARENT_DIR,
     SkillsPathConstants.SRC_DIR,
@@ -7302,7 +7346,7 @@ function collectCliOnlySkills() {
     SkillsPathConstants.CLI_ONLY_DIR,
     SkillsPathConstants.CLI_ONLY_SUBDIR
   );
-  if (!(0, import_fs6.existsSync)(cliOnlyRoot)) {
+  if (!(0, import_fs7.existsSync)(cliOnlyRoot)) {
     return [];
   }
   const skills = [];
@@ -7321,12 +7365,12 @@ function isExcludedFile(fileName) {
   return false;
 }
 function collectSkillFolderFilesRecursive(baseDir, currentDir, additionalFiles) {
-  const entries = (0, import_fs6.readdirSync)(currentDir, { withFileTypes: true });
+  const entries = (0, import_fs7.readdirSync)(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (isExcludedFile(entry.name)) {
       continue;
     }
-    const fullPath = (0, import_path6.join)(currentDir, entry.name);
+    const fullPath = (0, import_path7.join)(currentDir, entry.name);
     const relativePath = fullPath.slice(baseDir.length + 1);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS2.has(entry.name)) {
@@ -7337,12 +7381,12 @@ function collectSkillFolderFilesRecursive(baseDir, currentDir, additionalFiles)
       if (entry.name === SkillsPathConstants.SKILL_FILE) {
         continue;
       }
-      additionalFiles[relativePath] = (0, import_fs6.readFileSync)(fullPath);
+      additionalFiles[relativePath] = (0, import_fs7.readFileSync)(fullPath);
     }
   }
 }
 function collectSkillFolderFiles(skillDir) {
-  if (!(0, import_fs6.existsSync)(skillDir)) {
+  if (!(0, import_fs7.existsSync)(skillDir)) {
     return void 0;
   }
   const additionalFiles = {};
@@ -7365,13 +7409,13 @@ function dedupeSkillsByName(skillGroups) {
 }
 function resolvePackageRoot(projectRoot) {
   const candidates = [];
-  candidates.push((0, import_path6.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR));
+  candidates.push((0, import_path7.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR));
   const manifestPaths = resolveManifestPackagePaths(projectRoot);
   for (const manifestPath of manifestPaths) {
     candidates.push(manifestPath);
   }
   for (const packageName of SkillsPathConstants.PACKAGE_NAMES) {
-    candidates.push((0, import_path6.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, packageName));
+    candidates.push((0, import_path7.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, packageName));
   }
   const directRoot = resolveFirstPackageRoot(candidates);
   if (directRoot) {
@@ -7380,15 +7424,15 @@ function resolvePackageRoot(projectRoot) {
   return resolvePackageCacheRoot(projectRoot);
 }
 function resolveManifestPackagePaths(projectRoot) {
-  const manifestPath = (0, import_path6.join)(
+  const manifestPath = (0, import_path7.join)(
     projectRoot,
     SkillsPathConstants.PACKAGES_DIR,
     SkillsPathConstants.MANIFEST_FILE
   );
-  if (!(0, import_fs6.existsSync)(manifestPath)) {
+  if (!(0, import_fs7.existsSync)(manifestPath)) {
     return [];
   }
-  const manifestContent = (0, import_fs6.readFileSync)(manifestPath, "utf-8");
+  const manifestContent = (0, import_fs7.readFileSync)(manifestPath, "utf-8");
   let manifestJson;
   try {
     manifestJson = JSON.parse(manifestContent);
@@ -7432,10 +7476,10 @@ function resolveDependencyPath(rawPath, projectRoot) {
   if (normalizedPath.startsWith("//")) {
     normalizedPath = normalizedPath.slice(2);
   }
-  if ((0, import_path6.isAbsolute)(normalizedPath)) {
+  if ((0, import_path7.isAbsolute)(normalizedPath)) {
     return normalizedPath;
   }
-  return (0, import_path6.resolve)(projectRoot, normalizedPath);
+  return (0, import_path7.resolve)(projectRoot, normalizedPath);
 }
 function resolveFirstPackageRoot(candidates) {
   for (const candidate of candidates) {
@@ -7447,15 +7491,15 @@ function resolveFirstPackageRoot(candidates) {
   return null;
 }
 function resolvePackageCacheRoot(projectRoot) {
-  const packageCacheDir = (0, import_path6.join)(
+  const packageCacheDir = (0, import_path7.join)(
     projectRoot,
     SkillsPathConstants.LIBRARY_DIR,
     SkillsPathConstants.PACKAGE_CACHE_DIR
   );
-  if (!(0, import_fs6.existsSync)(packageCacheDir)) {
+  if (!(0, import_fs7.existsSync)(packageCacheDir)) {
     return null;
   }
-  const entries = (0, import_fs6.readdirSync)(packageCacheDir, { withFileTypes: true });
+  const entries = (0, import_fs7.readdirSync)(packageCacheDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
@@ -7463,7 +7507,7 @@ function resolvePackageCacheRoot(projectRoot) {
     if (!isTargetPackageCacheDir(entry.name)) {
       continue;
     }
-    const candidate = (0, import_path6.join)(packageCacheDir, entry.name);
+    const candidate = (0, import_path7.join)(packageCacheDir, entry.name);
     const resolvedRoot = resolvePackageRootCandidate(candidate);
     if (resolvedRoot) {
       return resolvedRoot;
@@ -7472,26 +7516,26 @@ function resolvePackageCacheRoot(projectRoot) {
   return null;
 }
 function resolvePackageRootCandidate(candidate) {
-  if (!(0, import_fs6.existsSync)(candidate)) {
+  if (!(0, import_fs7.existsSync)(candidate)) {
     return null;
   }
-  const directToolsPath = (0, import_path6.join)(
+  const directToolsPath = (0, import_path7.join)(
     candidate,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if ((0, import_fs6.existsSync)(directToolsPath)) {
+  if ((0, import_fs7.existsSync)(directToolsPath)) {
     return candidate;
   }
-  const nestedRoot = (0, import_path6.join)(candidate, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR);
-  const nestedToolsPath = (0, import_path6.join)(
+  const nestedRoot = (0, import_path7.join)(candidate, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR);
+  const nestedToolsPath = (0, import_path7.join)(
     nestedRoot,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if ((0, import_fs6.existsSync)(nestedToolsPath)) {
+  if ((0, import_fs7.existsSync)(nestedToolsPath)) {
     return nestedRoot;
   }
   return null;
@@ -7517,12 +7561,12 @@ function isUnderExcludedRoots(targetPath, excludedRoots) {
   return false;
 }
 function isPathUnder(childPath, parentPath) {
-  const resolvedChild = (0, import_path6.resolve)(childPath);
-  const resolvedParent = (0, import_path6.resolve)(parentPath);
+  const resolvedChild = (0, import_path7.resolve)(childPath);
+  const resolvedParent = (0, import_path7.resolve)(parentPath);
   if (resolvedChild === resolvedParent) {
     return true;
   }
-  return resolvedChild.startsWith(resolvedParent + import_path6.sep);
+  return resolvedChild.startsWith(resolvedParent + import_path7.sep);
 }
 
 // src/skills/target-config.ts
@@ -7707,7 +7751,7 @@ Uninstalling uloop skills (${location})...`);
 }
 
 // src/commands/launch.ts
-var import_path7 = require("path");
+var import_path8 = require("path");
 
 // node_modules/launch-unity/dist/lib.js
 var import_node_child_process = require("node:child_process");
@@ -8335,7 +8379,7 @@ async function waitForProcessExit(pid, timeoutMs) {
     if (!isProcessAlive(pid)) {
       return true;
     }
-    await new Promise((resolve6) => setTimeout(resolve6, KILL_POLL_INTERVAL_MS));
+    await new Promise((resolve7) => setTimeout(resolve7, KILL_POLL_INTERVAL_MS));
   }
   return false;
 }
@@ -8504,7 +8548,7 @@ async function waitForLockfile(projectPath) {
     if ((0, import_node_fs2.existsSync)(lockfilePath)) {
       return;
     }
-    await new Promise((resolve6) => setTimeout(resolve6, LOCKFILE_POLL_INTERVAL_MS));
+    await new Promise((resolve7) => setTimeout(resolve7, LOCKFILE_POLL_INTERVAL_MS));
   }
   console.warn("Unity launched, but UnityLockfile was not detected within 5s.");
 }
@@ -8535,7 +8579,7 @@ async function launch(opts) {
   if (unityArgs.length > 0) {
     args.push(...unityArgs);
   }
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const child = (0, import_node_child_process.spawn)(unityPath, args, {
       stdio: "ignore",
       detached: true,
@@ -8552,7 +8596,7 @@ async function launch(opts) {
     const handleSpawn = () => {
       child.removeListener("error", handleError);
       child.unref();
-      resolve6();
+      resolve7();
     };
     child.once("error", handleError);
     child.once("spawn", handleSpawn);
@@ -8645,7 +8689,7 @@ function parseMaxDepth(value) {
 async function runLaunchCommand(projectPath, options) {
   const maxDepth = parseMaxDepth(options.maxDepth);
   await orchestrateLaunch({
-    projectPath: projectPath ? (0, import_path7.resolve)(projectPath) : void 0,
+    projectPath: projectPath ? (0, import_path8.resolve)(projectPath) : void 0,
     searchRoot: process.cwd(),
     searchMaxDepth: maxDepth,
     platform: options.platform,
@@ -8888,6 +8932,10 @@ function extractGlobalOptions(options) {
 function isConnectionError(message) {
   return message.includes("ECONNREFUSED") || message.includes("EADDRNOTAVAIL");
 }
+function printToolDisabledError(cmdName) {
+  console.error(`\x1B[33mTool '${cmdName}' is disabled.\x1B[0m`);
+  console.error("You can enable it in Unity: Window > uLoop > Tool Settings");
+}
 function printConnectionError() {
   console.error("\x1B[31mError: Cannot connect to Unity.\x1B[0m");
   console.error("Make sure Unity Editor is open and uLoopMCP server is running.");
@@ -8966,7 +9014,7 @@ async function runWithErrorHandling(fn) {
 }
 function detectShell() {
   const shell = process.env["SHELL"] || "";
-  const shellName = (0, import_path8.basename)(shell).replace(/\.exe$/i, "");
+  const shellName = (0, import_path9.basename)(shell).replace(/\.exe$/i, "");
   if (shellName === "zsh") {
     return "zsh";
   }
@@ -8981,12 +9029,12 @@ function detectShell() {
 function getShellConfigPath(shell) {
   const home = (0, import_os2.homedir)();
   if (shell === "zsh") {
-    return (0, import_path8.join)(home, ".zshrc");
+    return (0, import_path9.join)(home, ".zshrc");
   }
   if (shell === "powershell") {
-    return (0, import_path8.join)(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+    return (0, import_path9.join)(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
   }
-  return (0, import_path8.join)(home, ".bashrc");
+  return (0, import_path9.join)(home, ".bashrc");
 }
 function getCompletionScript(shell) {
   if (shell === "bash") {
@@ -9123,12 +9171,12 @@ function cleanupLockFiles(projectPath) {
     console.error("Could not find Unity project root.");
     process.exit(1);
   }
-  const tempDir = (0, import_path8.join)(projectRoot, "Temp");
+  const tempDir = (0, import_path9.join)(projectRoot, "Temp");
   let cleaned = 0;
   for (const lockFile of LOCK_FILES) {
-    const lockPath = (0, import_path8.join)(tempDir, lockFile);
-    if ((0, import_fs7.existsSync)(lockPath)) {
-      (0, import_fs7.unlinkSync)(lockPath);
+    const lockPath = (0, import_path9.join)(tempDir, lockFile);
+    if ((0, import_fs8.existsSync)(lockPath)) {
+      (0, import_fs8.unlinkSync)(lockPath);
       console.log(`Removed: ${lockFile}`);
       cleaned++;
     }
@@ -9163,13 +9211,13 @@ function handleCompletion(install, shellOverride) {
     return;
   }
   const configPath = getShellConfigPath(shell);
-  const configDir = (0, import_path8.dirname)(configPath);
-  if (!(0, import_fs7.existsSync)(configDir)) {
-    (0, import_fs7.mkdirSync)(configDir, { recursive: true });
+  const configDir = (0, import_path9.dirname)(configPath);
+  if (!(0, import_fs8.existsSync)(configDir)) {
+    (0, import_fs8.mkdirSync)(configDir, { recursive: true });
   }
   let content = "";
-  if ((0, import_fs7.existsSync)(configPath)) {
-    content = (0, import_fs7.readFileSync)(configPath, "utf-8");
+  if ((0, import_fs8.existsSync)(configPath)) {
+    content = (0, import_fs8.readFileSync)(configPath, "utf-8");
     content = content.replace(
       /\n?# >>> uloop completion >>>[\s\S]*?# <<< uloop completion <<<\n?/g,
       ""
@@ -9183,7 +9231,7 @@ ${startMarker}
 ${script}
 ${endMarker}
 `;
-    (0, import_fs7.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs8.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   } else {
     const evalLine = `eval "$(uloop completion --shell ${shell})"`;
     const lineToAdd = `
@@ -9191,7 +9239,7 @@ ${startMarker}
 ${evalLine}
 ${endMarker}
 `;
-    (0, import_fs7.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs8.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   }
   console.log(`Completion installed to ${configPath}`);
   if (shell === "powershell") {
@@ -9202,26 +9250,28 @@ ${endMarker}
 }
 function handleCompletionOptions() {
   const args = process.argv.slice(2);
+  const projectPath = extractSyncGlobalOptions(args).projectPath;
   if (args.includes("--list-commands")) {
     const tools = loadToolsCache();
-    const allCommands = [...BUILTIN_COMMANDS, ...tools.tools.map((t) => t.name)];
+    const enabledTools = projectPath !== void 0 ? filterEnabledTools(tools.tools, projectPath) : tools.tools;
+    const allCommands = [...BUILTIN_COMMANDS, ...enabledTools.map((t) => t.name)];
     console.log(allCommands.join("\n"));
     return true;
   }
   const listOptionsIdx = args.indexOf("--list-options");
   if (listOptionsIdx !== -1 && args[listOptionsIdx + 1]) {
     const cmdName = args[listOptionsIdx + 1];
-    listOptionsForCommand(cmdName);
+    listOptionsForCommand(cmdName, projectPath);
     return true;
   }
   return false;
 }
-function listOptionsForCommand(cmdName) {
+function listOptionsForCommand(cmdName, projectPath) {
   if (BUILTIN_COMMANDS.includes(cmdName)) {
     return;
   }
   const tools = loadToolsCache();
-  const tool = tools.tools.find((t) => t.name === cmdName);
+  const tool = projectPath !== void 0 ? filterEnabledTools(tools.tools, projectPath).find((t) => t.name === cmdName) : tools.tools.find((t) => t.name === cmdName);
   if (!tool) {
     return;
   }
@@ -9232,12 +9282,12 @@ function listOptionsForCommand(cmdName) {
   }
   console.log(options.join("\n"));
 }
-function commandExists(cmdName) {
+function commandExists(cmdName, projectPath) {
   if (BUILTIN_COMMANDS.includes(cmdName)) {
     return true;
   }
   const tools = loadToolsCache();
-  return tools.tools.some((t) => t.name === cmdName);
+  return filterEnabledTools(tools.tools, projectPath).some((t) => t.name === cmdName);
 }
 function shouldSkipAutoSync(cmdName, args) {
   if (cmdName === LAUNCH_COMMAND || cmdName === UPDATE_COMMAND) {
@@ -9285,7 +9335,8 @@ async function main() {
   const skipProjectDetection = cmdName === void 0 || NO_PROJECT_COMMANDS.includes(cmdName);
   if (skipProjectDetection) {
     const defaultTools = getDefaultTools();
-    for (const tool of defaultTools.tools) {
+    const tools = syncGlobalOptions.projectPath !== void 0 ? filterEnabledTools(defaultTools.tools, syncGlobalOptions.projectPath) : defaultTools.tools;
+    for (const tool of tools) {
       registerToolCommand(tool);
     }
     program2.parse();
@@ -9314,15 +9365,20 @@ async function main() {
     }
   }
   const toolsCache = loadToolsCache();
-  for (const tool of toolsCache.tools) {
+  const projectPath = syncGlobalOptions.projectPath;
+  for (const tool of filterEnabledTools(toolsCache.tools, projectPath)) {
     registerToolCommand(tool);
   }
-  if (cmdName && !commandExists(cmdName)) {
+  if (cmdName && !commandExists(cmdName, projectPath)) {
+    if (!isToolEnabled(cmdName, projectPath)) {
+      printToolDisabledError(cmdName);
+      process.exit(1);
+    }
     console.log(`\x1B[33mUnknown command '${cmdName}'. Syncing tools from Unity...\x1B[0m`);
     try {
       await syncTools(syncGlobalOptions);
       const newCache = loadToolsCache();
-      const tool = newCache.tools.find((t) => t.name === cmdName);
+      const tool = filterEnabledTools(newCache.tools, projectPath).find((t) => t.name === cmdName);
       if (tool) {
         registerToolCommand(tool);
         console.log(`\x1B[32m\u2713 Found '${cmdName}' after sync.\x1B[0m