uloop-cli 0.52.0 → 0.53.1

package/dist/cli.bundle.cjs

@@ -5383,7 +5383,7 @@ var require_semver2 = __commonJS({
 });
 
 // src/cli.ts
-var import_fs5 = require("fs");
+var import_fs6 = require("fs");
 var import_path6 = require("path");
 var import_os2 = require("os");
 var import_child_process = require("child_process");
@@ -5407,7 +5407,7 @@ var {
 
 // src/execute-tool.ts
 var readline = __toESM(require("readline"), 1);
-var import_fs3 = require("fs");
+var import_fs4 = require("fs");
 var import_path4 = require("path");
 var semver = __toESM(require_semver2(), 1);
 
@@ -5555,19 +5555,72 @@ var DirectUnityClient = class {
 
 // src/port-resolver.ts
 var import_promises = require("fs/promises");
+var import_fs2 = require("fs");
 var import_path2 = require("path");
 
 // src/project-root.ts
 var import_fs = require("fs");
 var import_path = require("path");
-function findUnityProjectRoot(startPath = process.cwd()) {
+var CHILD_SEARCH_MAX_DEPTH = 3;
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "Temp",
+  "obj",
+  "Build",
+  "Builds",
+  "Logs",
+  "Library"
+]);
+function isUnityProjectWithUloop(dirPath) {
+  const hasAssets = (0, import_fs.existsSync)((0, import_path.join)(dirPath, "Assets"));
+  const hasProjectSettings = (0, import_fs.existsSync)((0, import_path.join)(dirPath, "ProjectSettings"));
+  const hasUloopSettings = (0, import_fs.existsSync)((0, import_path.join)(dirPath, "UserSettings/UnityMcpSettings.json"));
+  return hasAssets && hasProjectSettings && hasUloopSettings;
+}
+function findUnityProjectsInChildren(startPath, maxDepth) {
+  const projects = [];
+  function scan(currentPath, depth) {
+    if (depth > maxDepth) {
+      return;
+    }
+    if (!(0, import_fs.existsSync)(currentPath)) {
+      return;
+    }
+    if (isUnityProjectWithUloop(currentPath)) {
+      projects.push(currentPath);
+      return;
+    }
+    let entries;
+    try {
+      entries = (0, import_fs.readdirSync)(currentPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (EXCLUDED_DIRS.has(entry.name)) {
+        continue;
+      }
+      const fullPath = (0, import_path.join)(currentPath, entry.name);
+      scan(fullPath, depth + 1);
+    }
+  }
+  scan(startPath, 0);
+  return projects.sort();
+}
+function findUnityProjectInParents(startPath) {
   let currentPath = startPath;
   while (true) {
-    const hasAssets = (0, import_fs.existsSync)((0, import_path.join)(currentPath, "Assets"));
-    const hasProjectSettings = (0, import_fs.existsSync)((0, import_path.join)(currentPath, "ProjectSettings"));
-    if (hasAssets && hasProjectSettings) {
+    if (isUnityProjectWithUloop(currentPath)) {
       return currentPath;
     }
+    const isGitRoot = (0, import_fs.existsSync)((0, import_path.join)(currentPath, ".git"));
+    if (isGitRoot) {
+      return null;
+    }
     const parentPath = (0, import_path.dirname)(currentPath);
     if (parentPath === currentPath) {
       return null;
@@ -5575,6 +5628,21 @@ function findUnityProjectRoot(startPath = process.cwd()) {
     currentPath = parentPath;
   }
 }
+function findUnityProjectRoot(startPath = process.cwd()) {
+  const childProjects = findUnityProjectsInChildren(startPath, CHILD_SEARCH_MAX_DEPTH);
+  if (childProjects.length > 0) {
+    if (childProjects.length > 1) {
+      console.error("\x1B[33mWarning: Multiple Unity projects found in child directories:\x1B[0m");
+      for (const project of childProjects) {
+        console.error(`  - ${project}`);
+      }
+      console.error(`\x1B[33mUsing: ${childProjects[0]}\x1B[0m`);
+      console.error("");
+    }
+    return childProjects[0];
+  }
+  return findUnityProjectInParents(startPath);
+}
 
 // src/port-resolver.ts
 var DEFAULT_PORT = 8700;
@@ -5582,18 +5650,21 @@ async function resolveUnityPort(explicitPort) {
   if (explicitPort !== void 0) {
     return explicitPort;
   }
-  const settingsPort = await readPortFromSettings();
+  const projectRoot = findUnityProjectRoot();
+  if (projectRoot === null) {
+    throw new Error("Unity project not found. Use --port option to specify the port explicitly.");
+  }
+  const settingsPort = await readPortFromSettings(projectRoot);
   if (settingsPort !== null) {
     return settingsPort;
   }
   return DEFAULT_PORT;
 }
-async function readPortFromSettings() {
-  const projectRoot = findUnityProjectRoot();
-  if (projectRoot === null) {
+async function readPortFromSettings(projectRoot) {
+  const settingsPath = (0, import_path2.join)(projectRoot, "UserSettings/UnityMcpSettings.json");
+  if (!(0, import_fs2.existsSync)(settingsPath)) {
     return null;
   }
-  const settingsPath = (0, import_path2.join)(projectRoot, "UserSettings/UnityMcpSettings.json");
   let content;
   try {
     content = await (0, import_promises.readFile)(settingsPath, "utf-8");
@@ -5616,12 +5687,12 @@ async function readPortFromSettings() {
 }
 
 // src/tool-cache.ts
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 var import_path3 = require("path");
 
 // src/default-tools.json
 var default_tools_default = {
-  version: "0.52.0",
+  version: "0.53.1",
   tools: [
     {
       name: "compile",
@@ -6028,9 +6099,9 @@ function getDefaultTools() {
 }
 function loadToolsCache() {
   const cachePath = getCachePath();
-  if ((0, import_fs2.existsSync)(cachePath)) {
+  if ((0, import_fs3.existsSync)(cachePath)) {
     try {
-      const content = (0, import_fs2.readFileSync)(cachePath, "utf-8");
+      const content = (0, import_fs3.readFileSync)(cachePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return getDefaultTools();
@@ -6041,18 +6112,18 @@ function loadToolsCache() {
 function saveToolsCache(cache) {
   const cacheDir = getCacheDir();
   const cachePath = getCachePath();
-  if (!(0, import_fs2.existsSync)(cacheDir)) {
-    (0, import_fs2.mkdirSync)(cacheDir, { recursive: true });
+  if (!(0, import_fs3.existsSync)(cacheDir)) {
+    (0, import_fs3.mkdirSync)(cacheDir, { recursive: true });
   }
   const content = JSON.stringify(cache, null, 2);
-  (0, import_fs2.writeFileSync)(cachePath, content, "utf-8");
+  (0, import_fs3.writeFileSync)(cachePath, content, "utf-8");
 }
 function getCacheFilePath() {
   return getCachePath();
 }
 
 // src/version.ts
-var VERSION = "0.52.0";
+var VERSION = "0.53.1";
 
 // src/spinner.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -6156,15 +6227,15 @@ function checkUnityBusyState() {
     return;
   }
   const compilingLock = (0, import_path4.join)(projectRoot, "Temp", "compiling.lock");
-  if ((0, import_fs3.existsSync)(compilingLock)) {
+  if ((0, import_fs4.existsSync)(compilingLock)) {
     throw new Error("UNITY_COMPILING");
   }
   const domainReloadLock = (0, import_path4.join)(projectRoot, "Temp", "domainreload.lock");
-  if ((0, import_fs3.existsSync)(domainReloadLock)) {
+  if ((0, import_fs4.existsSync)(domainReloadLock)) {
     throw new Error("UNITY_DOMAIN_RELOAD");
   }
   const serverStartingLock = (0, import_path4.join)(projectRoot, "Temp", "serverstarting.lock");
-  if ((0, import_fs3.existsSync)(serverStartingLock)) {
+  if ((0, import_fs4.existsSync)(serverStartingLock)) {
     throw new Error("UNITY_SERVER_STARTING");
   }
 }
@@ -6339,7 +6410,7 @@ function pascalToKebabCase(pascal) {
 }
 
 // src/skills/skills-manager.ts
-var import_fs4 = require("fs");
+var import_fs5 = require("fs");
 var import_path5 = require("path");
 var import_os = require("os");
 
@@ -8674,7 +8745,7 @@ return "Changed material color (Undo available)";
 ];
 
 // src/skills/skills-manager.ts
-var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "Temp", "obj", "Build", "Builds", "Logs"]);
+var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "Temp", "obj", "Build", "Builds", "Logs"]);
 function getGlobalSkillsDir(target) {
   return (0, import_path5.join)((0, import_os.homedir)(), target.projectDir, "skills");
 }
@@ -8693,16 +8764,16 @@ function getSkillPath(skillDirName, target, global) {
 }
 function isSkillInstalled(skill, target, global) {
   const skillPath = getSkillPath(skill.dirName, target, global);
-  return (0, import_fs4.existsSync)(skillPath);
+  return (0, import_fs5.existsSync)(skillPath);
 }
 function isSkillOutdated(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
   const skillPath = (0, import_path5.join)(skillDir, target.skillFileName);
-  if (!(0, import_fs4.existsSync)(skillPath)) {
+  if (!(0, import_fs5.existsSync)(skillPath)) {
     return false;
   }
-  const installedContent = (0, import_fs4.readFileSync)(skillPath, "utf-8");
+  const installedContent = (0, import_fs5.readFileSync)(skillPath, "utf-8");
   if (installedContent !== skill.content) {
     return true;
   }
@@ -8710,10 +8781,10 @@ function isSkillOutdated(skill, target, global) {
     const additionalFiles = skill.additionalFiles;
     for (const [relativePath, expectedContent] of Object.entries(additionalFiles)) {
       const filePath = (0, import_path5.join)(skillDir, relativePath);
-      if (!(0, import_fs4.existsSync)(filePath)) {
+      if (!(0, import_fs5.existsSync)(filePath)) {
         return true;
       }
-      const installedFileContent = (0, import_fs4.readFileSync)(filePath, "utf-8");
+      const installedFileContent = (0, import_fs5.readFileSync)(filePath, "utf-8");
       if (installedFileContent !== expectedContent) {
         return true;
       }
@@ -8755,19 +8826,19 @@ function parseFrontmatter(content) {
   return frontmatter;
 }
 function scanEditorFolderForSkills(editorPath, skills) {
-  if (!(0, import_fs4.existsSync)(editorPath)) {
+  if (!(0, import_fs5.existsSync)(editorPath)) {
     return;
   }
-  const entries = (0, import_fs4.readdirSync)(editorPath, { withFileTypes: true });
+  const entries = (0, import_fs5.readdirSync)(editorPath, { withFileTypes: true });
   for (const entry of entries) {
-    if (EXCLUDED_DIRS.has(entry.name)) {
+    if (EXCLUDED_DIRS2.has(entry.name)) {
       continue;
     }
     const fullPath = (0, import_path5.join)(editorPath, entry.name);
     if (entry.isDirectory()) {
       const skillMdPath = (0, import_path5.join)(fullPath, "SKILL.md");
-      if ((0, import_fs4.existsSync)(skillMdPath)) {
-        const content = (0, import_fs4.readFileSync)(skillMdPath, "utf-8");
+      if ((0, import_fs5.existsSync)(skillMdPath)) {
+        const content = (0, import_fs5.readFileSync)(skillMdPath, "utf-8");
         const frontmatter = parseFrontmatter(content);
         if (frontmatter.internal === true) {
           continue;
@@ -8787,12 +8858,12 @@ function scanEditorFolderForSkills(editorPath, skills) {
 function findEditorFolders(basePath, maxDepth = 2) {
   const editorFolders = [];
   function scan(currentPath, depth) {
-    if (depth > maxDepth || !(0, import_fs4.existsSync)(currentPath)) {
+    if (depth > maxDepth || !(0, import_fs5.existsSync)(currentPath)) {
       return;
     }
-    const entries = (0, import_fs4.readdirSync)(currentPath, { withFileTypes: true });
+    const entries = (0, import_fs5.readdirSync)(currentPath, { withFileTypes: true });
     for (const entry of entries) {
-      if (!entry.isDirectory() || EXCLUDED_DIRS.has(entry.name)) {
+      if (!entry.isDirectory() || EXCLUDED_DIRS2.has(entry.name)) {
         continue;
       }
       const fullPath = (0, import_path5.join)(currentPath, entry.name);
@@ -8819,7 +8890,7 @@ function collectProjectSkills() {
     (0, import_path5.join)(projectRoot, "Library", "PackageCache")
   ];
   for (const searchPath of searchPaths) {
-    if (!(0, import_fs4.existsSync)(searchPath)) {
+    if (!(0, import_fs5.existsSync)(searchPath)) {
       continue;
     }
     const editorFolders = findEditorFolders(searchPath, 3);
@@ -8857,24 +8928,24 @@ function installSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
   const skillPath = (0, import_path5.join)(skillDir, target.skillFileName);
-  (0, import_fs4.mkdirSync)(skillDir, { recursive: true });
-  (0, import_fs4.writeFileSync)(skillPath, skill.content, "utf-8");
+  (0, import_fs5.mkdirSync)(skillDir, { recursive: true });
+  (0, import_fs5.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_path5.join)(skillDir, relativePath);
-      (0, import_fs4.mkdirSync)((0, import_path5.dirname)(fullPath), { recursive: true });
-      (0, import_fs4.writeFileSync)(fullPath, content, "utf-8");
+      (0, import_fs5.mkdirSync)((0, import_path5.dirname)(fullPath), { recursive: true });
+      (0, import_fs5.writeFileSync)(fullPath, content, "utf-8");
     }
   }
 }
 function uninstallSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
-  if (!(0, import_fs4.existsSync)(skillDir)) {
+  if (!(0, import_fs5.existsSync)(skillDir)) {
     return false;
   }
-  (0, import_fs4.rmSync)(skillDir, { recursive: true, force: true });
+  (0, import_fs5.rmSync)(skillDir, { recursive: true, force: true });
   return true;
 }
 function installAllSkills(target, global) {
@@ -9402,8 +9473,8 @@ function cleanupLockFiles() {
   let cleaned = 0;
   for (const lockFile of LOCK_FILES) {
     const lockPath = (0, import_path6.join)(tempDir, lockFile);
-    if ((0, import_fs5.existsSync)(lockPath)) {
-      (0, import_fs5.unlinkSync)(lockPath);
+    if ((0, import_fs6.existsSync)(lockPath)) {
+      (0, import_fs6.unlinkSync)(lockPath);
       console.log(`Removed: ${lockFile}`);
       cleaned++;
     }
@@ -9439,12 +9510,12 @@ function handleCompletion(install, shellOverride) {
   }
   const configPath = getShellConfigPath(shell);
   const configDir = (0, import_path6.dirname)(configPath);
-  if (!(0, import_fs5.existsSync)(configDir)) {
-    (0, import_fs5.mkdirSync)(configDir, { recursive: true });
+  if (!(0, import_fs6.existsSync)(configDir)) {
+    (0, import_fs6.mkdirSync)(configDir, { recursive: true });
   }
   let content = "";
-  if ((0, import_fs5.existsSync)(configPath)) {
-    content = (0, import_fs5.readFileSync)(configPath, "utf-8");
+  if ((0, import_fs6.existsSync)(configPath)) {
+    content = (0, import_fs6.readFileSync)(configPath, "utf-8");
     content = content.replace(
       /\n?# >>> uloop completion >>>[\s\S]*?# <<< uloop completion <<<\n?/g,
       ""
@@ -9458,7 +9529,7 @@ ${startMarker}
 ${script}
 ${endMarker}
 `;
-    (0, import_fs5.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs6.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   } else {
     const evalLine = `eval "$(uloop completion --shell ${shell})"`;
     const lineToAdd = `
@@ -9466,7 +9537,7 @@ ${startMarker}
 ${evalLine}
 ${endMarker}
 `;
-    (0, import_fs5.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs6.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   }
   console.log(`Completion installed to ${configPath}`);
   if (shell === "powershell") {