uloop-cli 0.64.0 → 0.65.0

package/dist/cli.bundle.cjs

@@ -5383,8 +5383,8 @@ var require_semver2 = __commonJS({
 });
 
 // src/cli.ts
-var import_fs6 = require("fs");
-var import_path7 = require("path");
+var import_fs7 = require("fs");
+var import_path8 = require("path");
 var import_os2 = require("os");
 var import_child_process = require("child_process");
 
@@ -5407,8 +5407,8 @@ var {
 
 // src/execute-tool.ts
 var readline = __toESM(require("readline"), 1);
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 var semver = __toESM(require_semver2(), 1);
 
 // src/direct-unity-client.ts
@@ -5510,7 +5510,14 @@ var DirectUnityClient = class {
     const framedMessage = createFrame(requestJson);
     return new Promise((resolve5, reject) => {
       const socket = this.socket;
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        socket.off("data", onData);
+        socket.off("error", onError);
+        socket.off("close", onClose);
+      };
       const timeoutId = setTimeout(() => {
+        cleanup();
         reject(
           new Error(
             `Request timed out after ${NETWORK_TIMEOUT_MS}ms. Unity may be frozen or busy. [For AI] Run 'uloop focus-window' to bring Unity to the front, then retry the tool. If the issue persists, report this to the user and ask how to proceed. Do NOT kill Unity processes without user permission.`
@@ -5531,8 +5538,7 @@ var DirectUnityClient = class {
         if (extractResult.jsonContent === null) {
           return;
         }
-        clearTimeout(timeoutId);
-        socket.off("data", onData);
+        cleanup();
         this.receiveBuffer = extractResult.remainingData;
         const response = JSON.parse(extractResult.jsonContent);
         if (response.error) {
@@ -5541,7 +5547,17 @@ var DirectUnityClient = class {
         }
         resolve5(response.result);
       };
+      const onError = (error) => {
+        cleanup();
+        reject(new Error(`Connection lost: ${error.message}`));
+      };
+      const onClose = () => {
+        cleanup();
+        reject(new Error("UNITY_NO_RESPONSE"));
+      };
       socket.on("data", onData);
+      socket.on("error", onError);
+      socket.on("close", onClose);
       socket.write(framedMessage);
     });
   }
@@ -5783,7 +5799,7 @@ var import_path3 = require("path");
 
 // src/default-tools.json
 var default_tools_default = {
-  version: "0.64.0",
+  version: "0.65.0",
   tools: [
     {
       name: "compile",
@@ -5794,6 +5810,10 @@ var default_tools_default = {
           ForceRecompile: {
             type: "boolean",
             description: "Force full recompilation"
+          },
+          WaitForDomainReload: {
+            type: "boolean",
+            description: "Wait for domain reload completion before returning"
           }
         }
       }
@@ -6227,7 +6247,7 @@ function getCachedServerVersion() {
 }
 
 // src/version.ts
-var VERSION = "0.64.0";
+var VERSION = "0.65.0";
 
 // src/spinner.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -6261,6 +6281,206 @@ function createSpinner(initialMessage) {
   };
 }
 
+// src/compile-helpers.ts
+var import_node_assert = __toESM(require("node:assert"), 1);
+var import_fs4 = require("fs");
+var net2 = __toESM(require("net"), 1);
+var import_path4 = require("path");
+var SAFE_REQUEST_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+var COMPILE_FORCE_RECOMPILE_ARG_KEYS = [
+  "ForceRecompile",
+  "forceRecompile",
+  "force_recompile",
+  "force-recompile"
+];
+var COMPILE_WAIT_FOR_DOMAIN_RELOAD_ARG_KEYS = [
+  "WaitForDomainReload",
+  "waitForDomainReload",
+  "wait_for_domain_reload",
+  "wait-for-domain-reload"
+];
+var LOCK_GRACE_PERIOD_MS = 500;
+var READINESS_CHECK_TIMEOUT_MS = 3e3;
+var DEFAULT_HOST2 = "127.0.0.1";
+var CONTENT_LENGTH_HEADER2 = "Content-Length:";
+var HEADER_SEPARATOR2 = "\r\n\r\n";
+function toBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value.toLowerCase() === "true";
+  }
+  return false;
+}
+function getCompileBooleanArg(args, keys) {
+  for (const key of keys) {
+    if (!(key in args)) {
+      continue;
+    }
+    return toBoolean(args[key]);
+  }
+  return false;
+}
+function resolveCompileExecutionOptions(args) {
+  return {
+    forceRecompile: getCompileBooleanArg(args, COMPILE_FORCE_RECOMPILE_ARG_KEYS),
+    waitForDomainReload: getCompileBooleanArg(args, COMPILE_WAIT_FOR_DOMAIN_RELOAD_ARG_KEYS)
+  };
+}
+function createCompileRequestId() {
+  const timestamp = Date.now();
+  const randomToken = Math.floor(Math.random() * 1e6).toString().padStart(6, "0");
+  return `compile_${timestamp}_${randomToken}`;
+}
+function ensureCompileRequestId(args) {
+  const existingRequestId = args["RequestId"];
+  if (typeof existingRequestId === "string" && existingRequestId.length > 0) {
+    if (SAFE_REQUEST_ID_PATTERN.test(existingRequestId)) {
+      return existingRequestId;
+    }
+  }
+  const requestId = createCompileRequestId();
+  args["RequestId"] = requestId;
+  return requestId;
+}
+function getCompileResultFilePath(projectRoot, requestId) {
+  (0, import_node_assert.default)(
+    SAFE_REQUEST_ID_PATTERN.test(requestId),
+    `requestId contains unsafe characters: '${requestId}'`
+  );
+  return (0, import_path4.join)(projectRoot, "Temp", "uLoopMCP", "compile-results", `${requestId}.json`);
+}
+function isUnityBusyByLockFiles(projectRoot) {
+  const compilingLockPath = (0, import_path4.join)(projectRoot, "Temp", "compiling.lock");
+  if ((0, import_fs4.existsSync)(compilingLockPath)) {
+    return true;
+  }
+  const domainReloadLockPath = (0, import_path4.join)(projectRoot, "Temp", "domainreload.lock");
+  if ((0, import_fs4.existsSync)(domainReloadLockPath)) {
+    return true;
+  }
+  const serverStartingLockPath = (0, import_path4.join)(projectRoot, "Temp", "serverstarting.lock");
+  return (0, import_fs4.existsSync)(serverStartingLockPath);
+}
+function stripUtf8Bom(content) {
+  if (content.charCodeAt(0) === 65279) {
+    return content.slice(1);
+  }
+  return content;
+}
+function tryReadCompileResult(projectRoot, requestId) {
+  const resultFilePath = getCompileResultFilePath(projectRoot, requestId);
+  if (!(0, import_fs4.existsSync)(resultFilePath)) {
+    return void 0;
+  }
+  try {
+    const content = (0, import_fs4.readFileSync)(resultFilePath, "utf-8");
+    const parsed = JSON.parse(stripUtf8Bom(content));
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+function canSendRequestToUnity(port) {
+  return new Promise((resolve5) => {
+    const socket = new net2.Socket();
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve5(false);
+    }, READINESS_CHECK_TIMEOUT_MS);
+    const cleanup = () => {
+      clearTimeout(timer);
+      socket.destroy();
+    };
+    socket.connect(port, DEFAULT_HOST2, () => {
+      const rpcRequest = JSON.stringify({
+        jsonrpc: "2.0",
+        method: "get-tool-details",
+        params: { IncludeDevelopmentOnly: false },
+        id: 0
+      });
+      const contentLength = Buffer.byteLength(rpcRequest, "utf8");
+      const frame = `${CONTENT_LENGTH_HEADER2} ${contentLength}${HEADER_SEPARATOR2}${rpcRequest}`;
+      socket.write(frame);
+    });
+    let buffer = Buffer.alloc(0);
+    socket.on("data", (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      const sepIndex = buffer.indexOf(HEADER_SEPARATOR2);
+      if (sepIndex !== -1) {
+        cleanup();
+        resolve5(true);
+      }
+    });
+    socket.on("error", () => {
+      cleanup();
+      resolve5(false);
+    });
+    socket.on("close", () => {
+      clearTimeout(timer);
+      resolve5(false);
+    });
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+async function waitForCompileCompletion(options) {
+  const startTime = Date.now();
+  let idleSinceTimestamp = null;
+  while (Date.now() - startTime < options.timeoutMs) {
+    const result = tryReadCompileResult(options.projectRoot, options.requestId);
+    const isBusy = isUnityBusyByLockFiles(options.projectRoot);
+    if (result !== void 0 && !isBusy) {
+      const now = Date.now();
+      if (idleSinceTimestamp === null) {
+        idleSinceTimestamp = now;
+      }
+      const idleDuration = now - idleSinceTimestamp;
+      if (idleDuration >= LOCK_GRACE_PERIOD_MS) {
+        if (options.unityPort !== void 0) {
+          const isReady = await canSendRequestToUnity(options.unityPort);
+          if (isReady) {
+            return { outcome: "completed", result };
+          }
+        } else if (options.isUnityReadyWhenIdle) {
+          const isReady = await options.isUnityReadyWhenIdle();
+          if (isReady) {
+            return { outcome: "completed", result };
+          }
+        } else {
+          return { outcome: "completed", result };
+        }
+      }
+    } else {
+      idleSinceTimestamp = null;
+    }
+    await sleep(options.pollIntervalMs);
+  }
+  const lastResult = tryReadCompileResult(options.projectRoot, options.requestId);
+  if (lastResult !== void 0 && !isUnityBusyByLockFiles(options.projectRoot)) {
+    await sleep(LOCK_GRACE_PERIOD_MS);
+    if (isUnityBusyByLockFiles(options.projectRoot)) {
+      return { outcome: "timed_out" };
+    }
+    if (options.unityPort !== void 0) {
+      const isReady = await canSendRequestToUnity(options.unityPort);
+      if (isReady) {
+        return { outcome: "completed", result: lastResult };
+      }
+    } else if (options.isUnityReadyWhenIdle) {
+      const isReady = await options.isUnityReadyWhenIdle();
+      if (isReady) {
+        return { outcome: "completed", result: lastResult };
+      }
+    } else {
+      return { outcome: "completed", result: lastResult };
+    }
+  }
+  return { outcome: "timed_out" };
+}
+
 // src/execute-tool.ts
 function suppressStdinEcho() {
   if (!process.stdin.isTTY) {
@@ -6287,10 +6507,23 @@ function suppressStdinEcho() {
     rl.close();
   };
 }
+function stripInternalFields(result) {
+  const cleaned = { ...result };
+  delete cleaned["ProjectRoot"];
+  return cleaned;
+}
 var RETRY_DELAY_MS = 500;
 var MAX_RETRIES = 3;
-function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+var COMPILE_WAIT_TIMEOUT_MS = 9e4;
+var COMPILE_WAIT_POLL_INTERVAL_MS = 100;
+function getCompileExecutionOptions(toolName, params) {
+  if (toolName !== "compile") {
+    return {
+      forceRecompile: false,
+      waitForDomainReload: false
+    };
+  }
+  return resolveCompileExecutionOptions(params);
 }
 function isRetryableError(error) {
   if (!(error instanceof Error)) {
@@ -6299,6 +6532,13 @@ function isRetryableError(error) {
   const message = error.message;
   return message.includes("ECONNREFUSED") || message.includes("EADDRNOTAVAIL") || message === "UNITY_NO_RESPONSE";
 }
+function isTransportDisconnectError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const message = error.message;
+  return message === "UNITY_NO_RESPONSE" || message.startsWith("Connection lost:");
+}
 function isVersionOlder(v1, v2) {
   const parsed1 = semver.valid(v1);
   const parsed2 = semver.valid(v2);
@@ -6330,16 +6570,16 @@ function checkUnityBusyState() {
   if (projectRoot === null) {
     return;
   }
-  const compilingLock = (0, import_path4.join)(projectRoot, "Temp", "compiling.lock");
-  if ((0, import_fs4.existsSync)(compilingLock)) {
+  const compilingLock = (0, import_path5.join)(projectRoot, "Temp", "compiling.lock");
+  if ((0, import_fs5.existsSync)(compilingLock)) {
     throw new Error("UNITY_COMPILING");
   }
-  const domainReloadLock = (0, import_path4.join)(projectRoot, "Temp", "domainreload.lock");
-  if ((0, import_fs4.existsSync)(domainReloadLock)) {
+  const domainReloadLock = (0, import_path5.join)(projectRoot, "Temp", "domainreload.lock");
+  if ((0, import_fs5.existsSync)(domainReloadLock)) {
     throw new Error("UNITY_DOMAIN_RELOAD");
   }
-  const serverStartingLock = (0, import_path4.join)(projectRoot, "Temp", "serverstarting.lock");
-  if ((0, import_fs4.existsSync)(serverStartingLock)) {
+  const serverStartingLock = (0, import_path5.join)(projectRoot, "Temp", "serverstarting.lock");
+  if ((0, import_fs5.existsSync)(serverStartingLock)) {
     throw new Error("UNITY_SERVER_STARTING");
   }
 }
@@ -6353,27 +6593,47 @@ async function executeToolCommand(toolName, params, globalOptions) {
     portNumber = parsed;
   }
   const port = await resolveUnityPort(portNumber);
+  const compileOptions = getCompileExecutionOptions(toolName, params);
+  const shouldWaitForDomainReload = compileOptions.waitForDomainReload;
+  const compileRequestId = shouldWaitForDomainReload ? ensureCompileRequestId(params) : void 0;
   const restoreStdin = suppressStdinEcho();
   const spinner = createSpinner("Connecting to Unity...");
   let lastError;
+  let immediateResult;
+  const projectRoot = findUnityProjectRoot();
+  let requestDispatched = false;
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     checkUnityBusyState();
     const client = new DirectUnityClient(port);
     try {
       await client.connect();
       spinner.update(`Executing ${toolName}...`);
+      requestDispatched = true;
       const result = await client.sendRequest(toolName, params);
       if (result === void 0 || result === null) {
         throw new Error("UNITY_NO_RESPONSE");
       }
-      spinner.stop();
-      restoreStdin();
-      checkServerVersion(result);
-      console.log(JSON.stringify(result, null, 2));
-      return;
+      immediateResult = result;
+      if (!shouldWaitForDomainReload) {
+        spinner.stop();
+        restoreStdin();
+        checkServerVersion(result);
+        console.log(JSON.stringify(stripInternalFields(result), null, 2));
+        return;
+      }
+      break;
     } catch (error) {
       lastError = error;
       client.disconnect();
+      if (requestDispatched && shouldWaitForDomainReload) {
+        if (isTransportDisconnectError(error)) {
+          spinner.update("Connection lost during compile. Waiting for result file...");
+          break;
+        }
+        spinner.stop();
+        restoreStdin();
+        throw error instanceof Error ? error : new Error(String(error));
+      }
       if (!isRetryableError(error) || attempt >= MAX_RETRIES) {
         break;
       }
@@ -6383,9 +6643,70 @@ async function executeToolCommand(toolName, params, globalOptions) {
       client.disconnect();
     }
   }
+  if (shouldWaitForDomainReload && compileRequestId) {
+    if (immediateResult === void 0 && !requestDispatched) {
+      spinner.stop();
+      restoreStdin();
+      if (lastError instanceof Error) {
+        throw lastError;
+      }
+      throw new Error(
+        "Compile request never reached Unity. Check that Unity is running and retry."
+      );
+    }
+    const projectRootFromUnity = immediateResult !== void 0 ? immediateResult["ProjectRoot"] : void 0;
+    const effectiveProjectRoot = projectRootFromUnity ?? projectRoot;
+    if (effectiveProjectRoot === null) {
+      spinner.stop();
+      restoreStdin();
+      if (immediateResult !== void 0) {
+        checkServerVersion(immediateResult);
+        console.log(JSON.stringify(stripInternalFields(immediateResult), null, 2));
+        return;
+      }
+      if (lastError instanceof Error) {
+        throw lastError;
+      }
+      throw new Error(
+        "Compile request failed and project root is unknown. Check connection and retry."
+      );
+    }
+    spinner.update("Waiting for domain reload to complete...");
+    const { outcome, result: storedResult } = await waitForCompileCompletion({
+      projectRoot: effectiveProjectRoot,
+      requestId: compileRequestId,
+      timeoutMs: COMPILE_WAIT_TIMEOUT_MS,
+      pollIntervalMs: COMPILE_WAIT_POLL_INTERVAL_MS,
+      unityPort: port
+    });
+    if (outcome === "timed_out") {
+      lastError = new Error(
+        `Compile wait timed out after ${COMPILE_WAIT_TIMEOUT_MS}ms. Run 'uloop fix' and retry.`
+      );
+    } else {
+      const finalResult = storedResult ?? immediateResult;
+      if (finalResult !== void 0) {
+        spinner.stop();
+        restoreStdin();
+        checkServerVersion(finalResult);
+        console.log(JSON.stringify(stripInternalFields(finalResult), null, 2));
+        return;
+      }
+    }
+  }
   spinner.stop();
   restoreStdin();
-  throw lastError;
+  if (lastError === void 0) {
+    throw new Error("Tool execution failed without error details.");
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  if (typeof lastError === "string") {
+    throw new Error(lastError);
+  }
+  const serializedError = JSON.stringify(lastError);
+  throw new Error(serializedError ?? "Unknown error");
 }
 async function listAvailableTools(globalOptions) {
   let portNumber;
@@ -6515,8 +6836,8 @@ function pascalToKebabCase(pascal) {
 }
 
 // src/skills/skills-manager.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs6 = require("fs");
+var import_path6 = require("path");
 var import_os = require("os");
 
 // src/skills/deprecated-skills.ts
@@ -6563,7 +6884,7 @@ var SkillsPathConstants = class _SkillsPathConstants {
   ];
 };
 function getGlobalSkillsDir(target) {
-  return (0, import_path5.join)((0, import_os.homedir)(), target.projectDir, "skills");
+  return (0, import_path6.join)((0, import_os.homedir)(), target.projectDir, "skills");
 }
 function getProjectSkillsDir(target) {
   const status = getUnityProjectStatus();
@@ -6578,35 +6899,35 @@ function getProjectSkillsDir(target) {
 Please install uLoopMCP package first, then run this command again.`
     );
   }
-  return (0, import_path5.join)(status.path, target.projectDir, "skills");
+  return (0, import_path6.join)(status.path, target.projectDir, "skills");
 }
 function getSkillPath(skillDirName, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  return (0, import_path5.join)(baseDir, skillDirName, target.skillFileName);
+  return (0, import_path6.join)(baseDir, skillDirName, target.skillFileName);
 }
 function isSkillInstalled(skill, target, global) {
   const skillPath = getSkillPath(skill.dirName, target, global);
-  return (0, import_fs5.existsSync)(skillPath);
+  return (0, import_fs6.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_fs5.existsSync)(skillPath)) {
+  const skillDir = (0, import_path6.join)(baseDir, skill.dirName);
+  const skillPath = (0, import_path6.join)(skillDir, target.skillFileName);
+  if (!(0, import_fs6.existsSync)(skillPath)) {
     return false;
   }
-  const installedContent = (0, import_fs5.readFileSync)(skillPath, "utf-8");
+  const installedContent = (0, import_fs6.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_path5.join)(skillDir, relativePath);
-      if (!(0, import_fs5.existsSync)(filePath)) {
+      const filePath = (0, import_path6.join)(skillDir, relativePath);
+      if (!(0, import_fs6.existsSync)(filePath)) {
         return true;
       }
-      const installedFileContent = (0, import_fs5.readFileSync)(filePath);
+      const installedFileContent = (0, import_fs6.readFileSync)(filePath);
       if (!installedFileContent.equals(expectedContent)) {
         return true;
       }
@@ -6670,24 +6991,24 @@ function warnLegacySkillStructure(toolPath, legacySkillMdPath) {
   console.error("");
 }
 function scanEditorFolderForSkills(editorPath, skills, sourceType, warnLegacy = true) {
-  if (!(0, import_fs5.existsSync)(editorPath)) {
+  if (!(0, import_fs6.existsSync)(editorPath)) {
     return;
   }
-  const entries = (0, import_fs5.readdirSync)(editorPath, { withFileTypes: true });
+  const entries = (0, import_fs6.readdirSync)(editorPath, { withFileTypes: true });
   for (const entry of entries) {
     if (EXCLUDED_DIRS2.has(entry.name)) {
       continue;
     }
-    const fullPath = (0, import_path5.join)(editorPath, entry.name);
+    const fullPath = (0, import_path6.join)(editorPath, entry.name);
     if (entry.isDirectory()) {
-      const skillDir = (0, import_path5.join)(fullPath, SkillsPathConstants.SKILL_DIR);
-      const skillMdPath = (0, import_path5.join)(skillDir, SkillsPathConstants.SKILL_FILE);
-      const legacySkillMdPath = (0, import_path5.join)(fullPath, SkillsPathConstants.SKILL_FILE);
-      if (warnLegacy && !(0, import_fs5.existsSync)(skillMdPath) && (0, import_fs5.existsSync)(legacySkillMdPath)) {
+      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)) {
         warnLegacySkillStructure(fullPath, legacySkillMdPath);
       }
-      if ((0, import_fs5.existsSync)(skillMdPath)) {
-        const content = (0, import_fs5.readFileSync)(skillMdPath, "utf-8");
+      if ((0, import_fs6.existsSync)(skillMdPath)) {
+        const content = (0, import_fs6.readFileSync)(skillMdPath, "utf-8");
         const frontmatter = parseFrontmatter(content);
         if (frontmatter.internal === true) {
           continue;
@@ -6710,15 +7031,15 @@ function scanEditorFolderForSkills(editorPath, skills, sourceType, warnLegacy =
 function findEditorFolders(basePath, maxDepth = 2) {
   const editorFolders = [];
   function scan(currentPath, depth) {
-    if (depth > maxDepth || !(0, import_fs5.existsSync)(currentPath)) {
+    if (depth > maxDepth || !(0, import_fs6.existsSync)(currentPath)) {
       return;
     }
-    const entries = (0, import_fs5.readdirSync)(currentPath, { withFileTypes: true });
+    const entries = (0, import_fs6.readdirSync)(currentPath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory() || EXCLUDED_DIRS2.has(entry.name)) {
         continue;
       }
-      const fullPath = (0, import_path5.join)(currentPath, entry.name);
+      const fullPath = (0, import_path6.join)(currentPath, entry.name);
       if (entry.name === "Editor") {
         editorFolders.push(fullPath);
       } else {
@@ -6737,12 +7058,12 @@ function collectProjectSkills(excludedRoots = []) {
   const skills = [];
   const seenNames = /* @__PURE__ */ new Set();
   const searchPaths = [
-    (0, import_path5.join)(projectRoot, SkillsPathConstants.ASSETS_DIR),
-    (0, import_path5.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR),
-    (0, import_path5.join)(projectRoot, SkillsPathConstants.LIBRARY_DIR, SkillsPathConstants.PACKAGE_CACHE_DIR)
+    (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)
   ];
   for (const searchPath of searchPaths) {
-    if (!(0, import_fs5.existsSync)(searchPath)) {
+    if (!(0, import_fs6.existsSync)(searchPath)) {
       continue;
     }
     const editorFolders = findEditorFolders(searchPath, 3);
@@ -6773,26 +7094,26 @@ function getAllSkillStatuses(target, global) {
 }
 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_fs5.mkdirSync)(skillDir, { recursive: true });
-  (0, import_fs5.writeFileSync)(skillPath, skill.content, "utf-8");
+  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");
   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_fs5.mkdirSync)((0, import_path5.dirname)(fullPath), { recursive: true });
-      (0, import_fs5.writeFileSync)(fullPath, content);
+      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);
     }
   }
 }
 function uninstallSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
-  if (!(0, import_fs5.existsSync)(skillDir)) {
+  const skillDir = (0, import_path6.join)(baseDir, skill.dirName);
+  if (!(0, import_fs6.existsSync)(skillDir)) {
     return false;
   }
-  (0, import_fs5.rmSync)(skillDir, { recursive: true, force: true });
+  (0, import_fs6.rmSync)(skillDir, { recursive: true, force: true });
   return true;
 }
 function installAllSkills(target, global) {
@@ -6806,9 +7127,9 @@ function installAllSkills(target, global) {
   };
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   for (const deprecatedName of DEPRECATED_SKILLS) {
-    const deprecatedDir = (0, import_path5.join)(baseDir, deprecatedName);
-    if ((0, import_fs5.existsSync)(deprecatedDir)) {
-      (0, import_fs5.rmSync)(deprecatedDir, { recursive: true, force: true });
+    const deprecatedDir = (0, import_path6.join)(baseDir, deprecatedName);
+    if ((0, import_fs6.existsSync)(deprecatedDir)) {
+      (0, import_fs6.rmSync)(deprecatedDir, { recursive: true, force: true });
       result.deprecatedRemoved++;
     }
   }
@@ -6835,9 +7156,9 @@ 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_path5.join)(baseDir, deprecatedName);
-    if ((0, import_fs5.existsSync)(deprecatedDir)) {
-      (0, import_fs5.rmSync)(deprecatedDir, { recursive: true, force: true });
+    const deprecatedDir = (0, import_path6.join)(baseDir, deprecatedName);
+    if ((0, import_fs6.existsSync)(deprecatedDir)) {
+      (0, import_fs6.rmSync)(deprecatedDir, { recursive: true, force: true });
       result.removed++;
     }
   }
@@ -6866,13 +7187,13 @@ function collectAllSkills() {
   return dedupeSkillsByName([packageSkills, cliOnlySkills, projectSkills]);
 }
 function collectPackageSkillsFromRoot(packageRoot) {
-  const mcpToolsRoot = (0, import_path5.join)(
+  const mcpToolsRoot = (0, import_path6.join)(
     packageRoot,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if (!(0, import_fs5.existsSync)(mcpToolsRoot)) {
+  if (!(0, import_fs6.existsSync)(mcpToolsRoot)) {
     return [];
   }
   const skills = [];
@@ -6880,7 +7201,7 @@ function collectPackageSkillsFromRoot(packageRoot) {
   return skills;
 }
 function collectCliOnlySkills() {
-  const cliOnlyRoot = (0, import_path5.resolve)(
+  const cliOnlyRoot = (0, import_path6.resolve)(
     __dirname,
     SkillsPathConstants.DIST_PARENT_DIR,
     SkillsPathConstants.SRC_DIR,
@@ -6888,7 +7209,7 @@ function collectCliOnlySkills() {
     SkillsPathConstants.CLI_ONLY_DIR,
     SkillsPathConstants.CLI_ONLY_SUBDIR
   );
-  if (!(0, import_fs5.existsSync)(cliOnlyRoot)) {
+  if (!(0, import_fs6.existsSync)(cliOnlyRoot)) {
     return [];
   }
   const skills = [];
@@ -6907,12 +7228,12 @@ function isExcludedFile(fileName) {
   return false;
 }
 function collectSkillFolderFilesRecursive(baseDir, currentDir, additionalFiles) {
-  const entries = (0, import_fs5.readdirSync)(currentDir, { withFileTypes: true });
+  const entries = (0, import_fs6.readdirSync)(currentDir, { withFileTypes: true });
   for (const entry of entries) {
     if (isExcludedFile(entry.name)) {
       continue;
     }
-    const fullPath = (0, import_path5.join)(currentDir, entry.name);
+    const fullPath = (0, import_path6.join)(currentDir, entry.name);
     const relativePath = fullPath.slice(baseDir.length + 1);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS2.has(entry.name)) {
@@ -6923,12 +7244,12 @@ function collectSkillFolderFilesRecursive(baseDir, currentDir, additionalFiles)
       if (entry.name === SkillsPathConstants.SKILL_FILE) {
         continue;
       }
-      additionalFiles[relativePath] = (0, import_fs5.readFileSync)(fullPath);
+      additionalFiles[relativePath] = (0, import_fs6.readFileSync)(fullPath);
     }
   }
 }
 function collectSkillFolderFiles(skillDir) {
-  if (!(0, import_fs5.existsSync)(skillDir)) {
+  if (!(0, import_fs6.existsSync)(skillDir)) {
     return void 0;
   }
   const additionalFiles = {};
@@ -6951,13 +7272,13 @@ function dedupeSkillsByName(skillGroups) {
 }
 function resolvePackageRoot(projectRoot) {
   const candidates = [];
-  candidates.push((0, import_path5.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR));
+  candidates.push((0, import_path6.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_path5.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, packageName));
+    candidates.push((0, import_path6.join)(projectRoot, SkillsPathConstants.PACKAGES_DIR, packageName));
   }
   const directRoot = resolveFirstPackageRoot(candidates);
   if (directRoot) {
@@ -6966,15 +7287,15 @@ function resolvePackageRoot(projectRoot) {
   return resolvePackageCacheRoot(projectRoot);
 }
 function resolveManifestPackagePaths(projectRoot) {
-  const manifestPath = (0, import_path5.join)(
+  const manifestPath = (0, import_path6.join)(
     projectRoot,
     SkillsPathConstants.PACKAGES_DIR,
     SkillsPathConstants.MANIFEST_FILE
   );
-  if (!(0, import_fs5.existsSync)(manifestPath)) {
+  if (!(0, import_fs6.existsSync)(manifestPath)) {
     return [];
   }
-  const manifestContent = (0, import_fs5.readFileSync)(manifestPath, "utf-8");
+  const manifestContent = (0, import_fs6.readFileSync)(manifestPath, "utf-8");
   let manifestJson;
   try {
     manifestJson = JSON.parse(manifestContent);
@@ -7018,10 +7339,10 @@ function resolveDependencyPath(rawPath, projectRoot) {
   if (normalizedPath.startsWith("//")) {
     normalizedPath = normalizedPath.slice(2);
   }
-  if ((0, import_path5.isAbsolute)(normalizedPath)) {
+  if ((0, import_path6.isAbsolute)(normalizedPath)) {
     return normalizedPath;
   }
-  return (0, import_path5.resolve)(projectRoot, normalizedPath);
+  return (0, import_path6.resolve)(projectRoot, normalizedPath);
 }
 function resolveFirstPackageRoot(candidates) {
   for (const candidate of candidates) {
@@ -7033,15 +7354,15 @@ function resolveFirstPackageRoot(candidates) {
   return null;
 }
 function resolvePackageCacheRoot(projectRoot) {
-  const packageCacheDir = (0, import_path5.join)(
+  const packageCacheDir = (0, import_path6.join)(
     projectRoot,
     SkillsPathConstants.LIBRARY_DIR,
     SkillsPathConstants.PACKAGE_CACHE_DIR
   );
-  if (!(0, import_fs5.existsSync)(packageCacheDir)) {
+  if (!(0, import_fs6.existsSync)(packageCacheDir)) {
     return null;
   }
-  const entries = (0, import_fs5.readdirSync)(packageCacheDir, { withFileTypes: true });
+  const entries = (0, import_fs6.readdirSync)(packageCacheDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) {
       continue;
@@ -7049,7 +7370,7 @@ function resolvePackageCacheRoot(projectRoot) {
     if (!isTargetPackageCacheDir(entry.name)) {
       continue;
     }
-    const candidate = (0, import_path5.join)(packageCacheDir, entry.name);
+    const candidate = (0, import_path6.join)(packageCacheDir, entry.name);
     const resolvedRoot = resolvePackageRootCandidate(candidate);
     if (resolvedRoot) {
       return resolvedRoot;
@@ -7058,26 +7379,26 @@ function resolvePackageCacheRoot(projectRoot) {
   return null;
 }
 function resolvePackageRootCandidate(candidate) {
-  if (!(0, import_fs5.existsSync)(candidate)) {
+  if (!(0, import_fs6.existsSync)(candidate)) {
     return null;
   }
-  const directToolsPath = (0, import_path5.join)(
+  const directToolsPath = (0, import_path6.join)(
     candidate,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if ((0, import_fs5.existsSync)(directToolsPath)) {
+  if ((0, import_fs6.existsSync)(directToolsPath)) {
     return candidate;
   }
-  const nestedRoot = (0, import_path5.join)(candidate, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR);
-  const nestedToolsPath = (0, import_path5.join)(
+  const nestedRoot = (0, import_path6.join)(candidate, SkillsPathConstants.PACKAGES_DIR, SkillsPathConstants.SRC_DIR);
+  const nestedToolsPath = (0, import_path6.join)(
     nestedRoot,
     SkillsPathConstants.EDITOR_DIR,
     SkillsPathConstants.API_DIR,
     SkillsPathConstants.MCP_TOOLS_DIR
   );
-  if ((0, import_fs5.existsSync)(nestedToolsPath)) {
+  if ((0, import_fs6.existsSync)(nestedToolsPath)) {
     return nestedRoot;
   }
   return null;
@@ -7103,12 +7424,12 @@ function isUnderExcludedRoots(targetPath, excludedRoots) {
   return false;
 }
 function isPathUnder(childPath, parentPath) {
-  const resolvedChild = (0, import_path5.resolve)(childPath);
-  const resolvedParent = (0, import_path5.resolve)(parentPath);
+  const resolvedChild = (0, import_path6.resolve)(childPath);
+  const resolvedParent = (0, import_path6.resolve)(parentPath);
   if (resolvedChild === resolvedParent) {
     return true;
   }
-  return resolvedChild.startsWith(resolvedParent + import_path5.sep);
+  return resolvedChild.startsWith(resolvedParent + import_path6.sep);
 }
 
 // src/skills/target-config.ts
@@ -7263,7 +7584,7 @@ Uninstalling uloop skills (${location})...`);
 }
 
 // src/commands/launch.ts
-var import_path6 = require("path");
+var import_path7 = require("path");
 
 // node_modules/launch-unity/dist/lib.js
 var import_node_child_process = require("node:child_process");
@@ -7276,7 +7597,7 @@ var import_node_util = require("node:util");
 var import_promises2 = require("node:fs/promises");
 var import_node_fs = require("node:fs");
 var import_node_path = require("node:path");
-var import_node_assert = __toESM(require("node:assert"), 1);
+var import_node_assert2 = __toESM(require("node:assert"), 1);
 var resolveUnityHubProjectFiles = () => {
   if (process.platform === "darwin") {
     const home = process.env.HOME;
@@ -7447,7 +7768,7 @@ var resolveUnityHubProjectsInfoFile = () => {
   return void 0;
 };
 var parseCliArgs = (cliArgsString) => {
-  (0, import_node_assert.default)(cliArgsString !== null && cliArgsString !== void 0, "cliArgsString must not be null");
+  (0, import_node_assert2.default)(cliArgsString !== null && cliArgsString !== void 0, "cliArgsString must not be null");
   const trimmed = cliArgsString.trim();
   if (trimmed.length === 0) {
     return [];
@@ -7503,7 +7824,7 @@ var groupCliArgs = (args) => {
   return groups;
 };
 var getProjectCliArgs = async (projectPath) => {
-  (0, import_node_assert.default)(projectPath !== null && projectPath !== void 0, "projectPath must not be null");
+  (0, import_node_assert2.default)(projectPath !== null && projectPath !== void 0, "projectPath must not be null");
   const infoFilePath = resolveUnityHubProjectsInfoFile();
   if (!infoFilePath) {
     logDebug("projectsInfo.json path could not be resolved.");
@@ -7551,6 +7872,8 @@ var PROCESS_LIST_ARGS_MAC = ["-axo", "pid=,command=", "-ww"];
 var WINDOWS_POWERSHELL = "powershell";
 var UNITY_LOCKFILE_NAME = "UnityLockfile";
 var TEMP_DIRECTORY_NAME = "Temp";
+var ASSETS_DIRECTORY_NAME = "Assets";
+var RECOVERY_DIRECTORY_NAME = "_Recovery";
 function getUnityVersion(projectPath) {
   const versionFile = (0, import_node_path2.join)(projectPath, "ProjectSettings", "ProjectVersion.txt");
   if (!(0, import_node_fs2.existsSync)(versionFile)) {
@@ -7850,6 +8173,20 @@ async function handleStaleLockfile(projectPath) {
   }
   console.log();
 }
+async function deleteRecoveryDirectory(projectPath) {
+  const recoveryPath = (0, import_node_path2.join)(projectPath, ASSETS_DIRECTORY_NAME, RECOVERY_DIRECTORY_NAME);
+  if (!(0, import_node_fs2.existsSync)(recoveryPath)) {
+    return;
+  }
+  console.log(`Deleting recovery directory: ${recoveryPath}`);
+  try {
+    await (0, import_promises3.rm)(recoveryPath, { recursive: true, force: true });
+    console.log("Deleted recovery directory.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to delete recovery directory: ${message}`);
+  }
+}
 var LOCKFILE_POLL_INTERVAL_MS = 100;
 var LOCKFILE_WAIT_TIMEOUT_MS = 5e3;
 var KILL_POLL_INTERVAL_MS = 100;
@@ -8140,6 +8477,9 @@ async function orchestrateLaunch(options) {
       return { action: "focused", projectPath: resolvedProjectPath, pid: runningProcess.pid };
     }
   }
+  if (options.deleteRecovery) {
+    await deleteRecoveryDirectory(resolvedProjectPath);
+  }
   await handleStaleLockfile(resolvedProjectPath);
   const resolved = {
     projectPath: resolvedProjectPath,
@@ -8164,7 +8504,7 @@ async function orchestrateLaunch(options) {
 function registerLaunchCommand(program3) {
   program3.command("launch").description(
     "Open a Unity project with the matching Editor version installed by Unity Hub.\nAuto-detects project path and Unity version from ProjectSettings/ProjectVersion.txt.\nRun 'uloop launch -h' for all options. Details: https://github.com/hatayama/LaunchUnityCommand"
-  ).argument("[project-path]", "Path to Unity project").option("-r, --restart", "Kill running Unity and restart").option("-q, --quit", "Gracefully quit running Unity").option("-p, --platform <platform>", "Build target (e.g., Android, iOS)").option("--max-depth <n>", "Search depth when project-path is omitted", "3").option("-a, --add-unity-hub", "Add to Unity Hub (does not launch)").option("-f, --favorite", "Add to Unity Hub as favorite (does not launch)").action(async (projectPath, options) => {
+  ).argument("[project-path]", "Path to Unity project").option("-r, --restart", "Kill running Unity and restart").option("-d, --delete-recovery", "Delete Assets/_Recovery before launch").option("-q, --quit", "Gracefully quit running Unity").option("-p, --platform <platform>", "Build target (e.g., Android, iOS)").option("--max-depth <n>", "Search depth when project-path is omitted", "3").option("-a, --add-unity-hub", "Add to Unity Hub (does not launch)").option("-f, --favorite", "Add to Unity Hub as favorite (does not launch)").action(async (projectPath, options) => {
     await runLaunchCommand(projectPath, options);
   });
 }
@@ -8182,13 +8522,14 @@ function parseMaxDepth(value) {
 async function runLaunchCommand(projectPath, options) {
   const maxDepth = parseMaxDepth(options.maxDepth);
   await orchestrateLaunch({
-    projectPath: projectPath ? (0, import_path6.resolve)(projectPath) : void 0,
+    projectPath: projectPath ? (0, import_path7.resolve)(projectPath) : void 0,
     searchRoot: process.cwd(),
     searchMaxDepth: maxDepth,
     platform: options.platform,
     unityArgs: [],
     restart: options.restart === true,
     quit: options.quit === true,
+    deleteRecovery: options.deleteRecovery === true,
     addUnityHub: options.addUnityHub === true,
     favoriteUnityHub: options.favorite === true
   });
@@ -8481,7 +8822,7 @@ async function runWithErrorHandling(fn) {
 }
 function detectShell() {
   const shell = process.env["SHELL"] || "";
-  const shellName = (0, import_path7.basename)(shell).replace(/\.exe$/i, "");
+  const shellName = (0, import_path8.basename)(shell).replace(/\.exe$/i, "");
   if (shellName === "zsh") {
     return "zsh";
   }
@@ -8496,12 +8837,12 @@ function detectShell() {
 function getShellConfigPath(shell) {
   const home = (0, import_os2.homedir)();
   if (shell === "zsh") {
-    return (0, import_path7.join)(home, ".zshrc");
+    return (0, import_path8.join)(home, ".zshrc");
   }
   if (shell === "powershell") {
-    return (0, import_path7.join)(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+    return (0, import_path8.join)(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
   }
-  return (0, import_path7.join)(home, ".bashrc");
+  return (0, import_path8.join)(home, ".bashrc");
 }
 function getCompletionScript(shell) {
   if (shell === "bash") {
@@ -8638,12 +8979,12 @@ function cleanupLockFiles() {
     console.error("Could not find Unity project root.");
     process.exit(1);
   }
-  const tempDir = (0, import_path7.join)(projectRoot, "Temp");
+  const tempDir = (0, import_path8.join)(projectRoot, "Temp");
   let cleaned = 0;
   for (const lockFile of LOCK_FILES) {
-    const lockPath = (0, import_path7.join)(tempDir, lockFile);
-    if ((0, import_fs6.existsSync)(lockPath)) {
-      (0, import_fs6.unlinkSync)(lockPath);
+    const lockPath = (0, import_path8.join)(tempDir, lockFile);
+    if ((0, import_fs7.existsSync)(lockPath)) {
+      (0, import_fs7.unlinkSync)(lockPath);
       console.log(`Removed: ${lockFile}`);
       cleaned++;
     }
@@ -8678,13 +9019,13 @@ function handleCompletion(install, shellOverride) {
     return;
   }
   const configPath = getShellConfigPath(shell);
-  const configDir = (0, import_path7.dirname)(configPath);
-  if (!(0, import_fs6.existsSync)(configDir)) {
-    (0, import_fs6.mkdirSync)(configDir, { recursive: true });
+  const configDir = (0, import_path8.dirname)(configPath);
+  if (!(0, import_fs7.existsSync)(configDir)) {
+    (0, import_fs7.mkdirSync)(configDir, { recursive: true });
   }
   let content = "";
-  if ((0, import_fs6.existsSync)(configPath)) {
-    content = (0, import_fs6.readFileSync)(configPath, "utf-8");
+  if ((0, import_fs7.existsSync)(configPath)) {
+    content = (0, import_fs7.readFileSync)(configPath, "utf-8");
     content = content.replace(
       /\n?# >>> uloop completion >>>[\s\S]*?# <<< uloop completion <<<\n?/g,
       ""
@@ -8698,7 +9039,7 @@ ${startMarker}
 ${script}
 ${endMarker}
 `;
-    (0, import_fs6.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs7.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   } else {
     const evalLine = `eval "$(uloop completion --shell ${shell})"`;
     const lineToAdd = `
@@ -8706,7 +9047,7 @@ ${startMarker}
 ${evalLine}
 ${endMarker}
 `;
-    (0, import_fs6.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs7.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   }
   console.log(`Completion installed to ${configPath}`);
   if (shell === "powershell") {
@@ -8760,12 +9101,29 @@ function shouldSkipAutoSync(cmdName, args) {
   }
   return args.some((arg) => NO_SYNC_FLAGS.includes(arg));
 }
+function extractSyncGlobalOptions(args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--port" || arg === "-p") {
+      const nextArg = args[i + 1];
+      if (nextArg !== void 0 && !nextArg.startsWith("-")) {
+        return { port: nextArg };
+      }
+      continue;
+    }
+    if (arg.startsWith("--port=")) {
+      return { port: arg.slice("--port=".length) };
+    }
+  }
+  return {};
+}
 async function main() {
   if (handleCompletionOptions()) {
     return;
   }
   const args = process.argv.slice(2);
   const cmdName = args.find((arg) => !arg.startsWith("-"));
+  const syncGlobalOptions = extractSyncGlobalOptions(args);
   if (!shouldSkipAutoSync(cmdName, args)) {
     const cachedVersion = loadToolsCache().version;
     if (hasCacheFile() && cachedVersion !== VERSION) {
@@ -8773,7 +9131,7 @@ async function main() {
         `\x1B[33mCache outdated (${cachedVersion} \u2192 ${VERSION}). Syncing tools from Unity...\x1B[0m`
       );
       try {
-        await syncTools({});
+        await syncTools(syncGlobalOptions);
         console.log("\x1B[32m\u2713 Tools synced successfully.\x1B[0m\n");
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -8795,7 +9153,7 @@ async function main() {
   if (cmdName && !commandExists(cmdName)) {
     console.log(`\x1B[33mUnknown command '${cmdName}'. Syncing tools from Unity...\x1B[0m`);
     try {
-      await syncTools({});
+      await syncTools(syncGlobalOptions);
       const newCache = loadToolsCache();
       const tool = newCache.tools.find((t) => t.name === cmdName);
       if (tool) {