uloop-cli 0.56.0 → 0.57.0

package/dist/cli.bundle.cjs

@@ -5384,7 +5384,7 @@ var require_semver2 = __commonJS({
 
 // src/cli.ts
 var import_fs6 = require("fs");
-var import_path6 = require("path");
+var import_path7 = 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((resolve2, reject) => {
+    return new Promise((resolve5, 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, () => {
-        resolve2();
+        resolve5();
       });
     });
   }
@@ -5508,7 +5508,7 @@ var DirectUnityClient = class {
     };
     const requestJson = JSON.stringify(request);
     const framedMessage = createFrame(requestJson);
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve5, reject) => {
       const socket = this.socket;
       const timeoutId = setTimeout(() => {
         reject(
@@ -5539,7 +5539,7 @@ var DirectUnityClient = class {
           reject(new Error(`Unity error: ${response.error.message}`));
           return;
         }
-        resolve2(response.result);
+        resolve5(response.result);
       };
       socket.on("data", onData);
       socket.write(framedMessage);
@@ -5763,7 +5763,7 @@ var import_path3 = require("path");
 
 // src/default-tools.json
 var default_tools_default = {
-  version: "0.56.0",
+  version: "0.57.0",
   tools: [
     {
       name: "compile",
@@ -6215,7 +6215,7 @@ function getCachedServerVersion() {
 }
 
 // src/version.ts
-var VERSION = "0.56.0";
+var VERSION = "0.57.0";
 
 // src/spinner.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -6278,7 +6278,7 @@ function suppressStdinEcho() {
 var RETRY_DELAY_MS = 500;
 var MAX_RETRIES = 3;
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
 }
 function isRetryableError(error) {
   if (!(error instanceof Error)) {
@@ -7250,8 +7250,671 @@ Uninstalling uloop skills (${location})...`);
   }
 }
 
+// src/commands/launch.ts
+var import_path6 = require("path");
+
+// node_modules/launch-unity/dist/lib.js
+var import_node_child_process = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var import_promises3 = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+var import_node_util = require("node:util");
+
+// node_modules/launch-unity/dist/unityHub.js
+var import_promises2 = require("node:fs/promises");
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+var resolveUnityHubProjectFiles = () => {
+  if (process.platform === "darwin") {
+    const home = process.env.HOME;
+    if (!home) {
+      return [];
+    }
+    const base = (0, import_node_path.join)(home, "Library", "Application Support", "UnityHub");
+    return [(0, import_node_path.join)(base, "projects-v1.json"), (0, import_node_path.join)(base, "projects.json")];
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA;
+    if (!appData) {
+      return [];
+    }
+    const base = (0, import_node_path.join)(appData, "UnityHub");
+    return [(0, import_node_path.join)(base, "projects-v1.json"), (0, import_node_path.join)(base, "projects.json")];
+  }
+  return [];
+};
+var removeTrailingSeparators = (target) => {
+  let trimmed = target;
+  while (trimmed.length > 1 && (trimmed.endsWith("/") || trimmed.endsWith("\\"))) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
+};
+var normalizePath = (target) => {
+  const resolvedPath = (0, import_node_path.resolve)(target);
+  return removeTrailingSeparators(resolvedPath);
+};
+var resolvePathWithActualCase = (target) => {
+  try {
+    return removeTrailingSeparators(import_node_fs.realpathSync.native(target));
+  } catch {
+    return normalizePath(target);
+  }
+};
+var toComparablePath = (value) => {
+  return value.replace(/\\/g, "/").toLocaleLowerCase();
+};
+var pathsEqual = (left, right) => {
+  return toComparablePath(normalizePath(left)) === toComparablePath(normalizePath(right));
+};
+var safeParseProjectsJson = (content) => {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+};
+var logDebug = (message) => {
+  if (process.env["LAUNCH_UNITY_DEBUG"] === "1") {
+    console.log(`[unityHub] ${message}`);
+  }
+};
+var ensureProjectEntryAndUpdate = async (projectPath, version, when, setFavorite = false) => {
+  const canonicalProjectPath = resolvePathWithActualCase(projectPath);
+  const projectTitle = (0, import_node_path.basename)(canonicalProjectPath);
+  const containingFolderPath = (0, import_node_path.dirname)(canonicalProjectPath);
+  const candidates = resolveUnityHubProjectFiles();
+  if (candidates.length === 0) {
+    logDebug("No Unity Hub project files found.");
+    return;
+  }
+  for (const path of candidates) {
+    logDebug(`Trying Unity Hub file: ${path}`);
+    const content = await (0, import_promises2.readFile)(path, "utf8").catch(() => void 0);
+    if (!content) {
+      logDebug("Read failed or empty content, skipping.");
+      continue;
+    }
+    const json = safeParseProjectsJson(content);
+    if (!json) {
+      logDebug("Parse failed, skipping.");
+      continue;
+    }
+    const data = { ...json.data ?? {} };
+    const existingKey = Object.keys(data).find((key) => {
+      const entryPath = data[key]?.path;
+      return entryPath ? pathsEqual(entryPath, projectPath) : false;
+    });
+    const targetKey = existingKey ?? canonicalProjectPath;
+    const existingEntry = existingKey ? data[existingKey] : void 0;
+    logDebug(existingKey ? `Found existing entry for project (key=${existingKey}). Updating lastModified.` : `No existing entry. Adding new entry (key=${targetKey}).`);
+    const updatedEntry = {
+      ...existingEntry,
+      path: existingEntry?.path ?? canonicalProjectPath,
+      containingFolderPath: existingEntry?.containingFolderPath ?? containingFolderPath,
+      version: existingEntry?.version ?? version,
+      title: existingEntry?.title ?? projectTitle,
+      lastModified: when.getTime(),
+      isFavorite: setFavorite ? true : existingEntry?.isFavorite ?? false
+    };
+    const updatedJson = {
+      ...json,
+      data: {
+        ...data,
+        [targetKey]: updatedEntry
+      }
+    };
+    try {
+      await (0, import_promises2.writeFile)(path, JSON.stringify(updatedJson, void 0, 2), "utf8");
+      logDebug("Write succeeded.");
+    } catch (error) {
+      logDebug(`Write failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return;
+  }
+};
+var updateLastModifiedIfExists = async (projectPath, when) => {
+  const candidates = resolveUnityHubProjectFiles();
+  if (candidates.length === 0) {
+    return;
+  }
+  for (const path of candidates) {
+    let content;
+    let json;
+    try {
+      content = await (0, import_promises2.readFile)(path, "utf8");
+    } catch {
+      continue;
+    }
+    try {
+      json = JSON.parse(content);
+    } catch {
+      continue;
+    }
+    if (!json.data) {
+      return;
+    }
+    const projectKey = Object.keys(json.data).find((key) => {
+      const entryPath = json.data?.[key]?.path;
+      return entryPath ? pathsEqual(entryPath, projectPath) : false;
+    });
+    if (!projectKey) {
+      return;
+    }
+    const original = json.data[projectKey];
+    if (!original) {
+      return;
+    }
+    json.data[projectKey] = {
+      ...original,
+      lastModified: when.getTime()
+    };
+    try {
+      await (0, import_promises2.writeFile)(path, JSON.stringify(json, void 0, 2), "utf8");
+    } catch {
+    }
+    return;
+  }
+};
+
+// node_modules/launch-unity/dist/lib.js
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var UNITY_EXECUTABLE_PATTERN_MAC = /Unity\.app\/Contents\/MacOS\/Unity/i;
+var UNITY_EXECUTABLE_PATTERN_WINDOWS = /Unity\.exe/i;
+var PROJECT_PATH_PATTERN = /-(?:projectPath|projectpath)(?:=|\s+)("[^"]+"|'[^']+'|[^\s"']+)/i;
+var PROCESS_LIST_COMMAND_MAC = "ps";
+var PROCESS_LIST_ARGS_MAC = ["-axo", "pid=,command=", "-ww"];
+var WINDOWS_POWERSHELL = "powershell";
+var UNITY_LOCKFILE_NAME = "UnityLockfile";
+var TEMP_DIRECTORY_NAME = "Temp";
+function getUnityVersion(projectPath) {
+  const versionFile = (0, import_node_path2.join)(projectPath, "ProjectSettings", "ProjectVersion.txt");
+  if (!(0, import_node_fs2.existsSync)(versionFile)) {
+    throw new Error(`ProjectVersion.txt not found at ${versionFile}. This does not appear to be a Unity project.`);
+  }
+  const content = (0, import_node_fs2.readFileSync)(versionFile, "utf8");
+  const version = content.match(/m_EditorVersion:\s*([^\s\n]+)/)?.[1];
+  if (!version) {
+    throw new Error(`Could not extract Unity version from ${versionFile}`);
+  }
+  return version;
+}
+function getUnityPathWindows(version) {
+  const candidates = [];
+  const programFiles = process.env["PROGRAMFILES"];
+  const programFilesX86 = process.env["PROGRAMFILES(X86)"];
+  const localAppData = process.env["LOCALAPPDATA"];
+  const addCandidate = (base) => {
+    if (!base) {
+      return;
+    }
+    candidates.push((0, import_node_path2.join)(base, "Unity", "Hub", "Editor", version, "Editor", "Unity.exe"));
+  };
+  addCandidate(programFiles);
+  addCandidate(programFilesX86);
+  addCandidate(localAppData);
+  candidates.push((0, import_node_path2.join)("C:\\", "Program Files", "Unity", "Hub", "Editor", version, "Editor", "Unity.exe"));
+  for (const candidate of candidates) {
+    if ((0, import_node_fs2.existsSync)(candidate)) {
+      return candidate;
+    }
+  }
+  return candidates[0] ?? (0, import_node_path2.join)("C:\\", "Program Files", "Unity", "Hub", "Editor", version, "Editor", "Unity.exe");
+}
+function getUnityPath(version) {
+  if (process.platform === "darwin") {
+    return `/Applications/Unity/Hub/Editor/${version}/Unity.app/Contents/MacOS/Unity`;
+  }
+  if (process.platform === "win32") {
+    return getUnityPathWindows(version);
+  }
+  return `/Applications/Unity/Hub/Editor/${version}/Unity.app/Contents/MacOS/Unity`;
+}
+var removeTrailingSeparators2 = (target) => {
+  let trimmed = target;
+  while (trimmed.length > 1 && (trimmed.endsWith("/") || trimmed.endsWith("\\"))) {
+    trimmed = trimmed.slice(0, -1);
+  }
+  return trimmed;
+};
+var normalizePath2 = (target) => {
+  const resolvedPath = (0, import_node_path2.resolve)(target);
+  const trimmed = removeTrailingSeparators2(resolvedPath);
+  return trimmed;
+};
+var toComparablePath2 = (value) => {
+  return value.replace(/\\/g, "/").toLocaleLowerCase();
+};
+var pathsEqual2 = (left, right) => {
+  return toComparablePath2(normalizePath2(left)) === toComparablePath2(normalizePath2(right));
+};
+function extractProjectPath(command) {
+  const match = command.match(PROJECT_PATH_PATTERN);
+  if (!match) {
+    return void 0;
+  }
+  const raw = match[1];
+  if (!raw) {
+    return void 0;
+  }
+  const trimmed = raw.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1);
+  }
+  if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+var isUnityAuxiliaryProcess = (command) => {
+  const normalizedCommand = command.toLowerCase();
+  if (normalizedCommand.includes("-batchmode")) {
+    return true;
+  }
+  return normalizedCommand.includes("assetimportworker");
+};
+async function listUnityProcessesMac() {
+  let stdout = "";
+  try {
+    const result = await execFileAsync(PROCESS_LIST_COMMAND_MAC, PROCESS_LIST_ARGS_MAC);
+    stdout = result.stdout;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to retrieve Unity process list: ${message}`);
+    return [];
+  }
+  const lines = stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const processes = [];
+  for (const line of lines) {
+    const match = line.match(/^(\d+)\s+(.*)$/);
+    if (!match) {
+      continue;
+    }
+    const pidValue = Number.parseInt(match[1] ?? "", 10);
+    if (!Number.isFinite(pidValue)) {
+      continue;
+    }
+    const command = match[2] ?? "";
+    if (!UNITY_EXECUTABLE_PATTERN_MAC.test(command)) {
+      continue;
+    }
+    if (isUnityAuxiliaryProcess(command)) {
+      continue;
+    }
+    const projectArgument = extractProjectPath(command);
+    if (!projectArgument) {
+      continue;
+    }
+    processes.push({
+      pid: pidValue,
+      projectPath: normalizePath2(projectArgument)
+    });
+  }
+  return processes;
+}
+async function listUnityProcessesWindows() {
+  const scriptLines = [
+    "$ErrorActionPreference = 'Stop'",
+    `$processes = Get-CimInstance Win32_Process -Filter "Name = 'Unity.exe'" | Where-Object { $_.CommandLine }`,
+    "foreach ($process in $processes) {",
+    `  $commandLine = $process.CommandLine -replace "\`r", ' ' -replace "\`n", ' '`,
+    '  Write-Output ("{0}|{1}" -f $process.ProcessId, $commandLine)',
+    "}"
+  ];
+  let stdout = "";
+  try {
+    const result = await execFileAsync(WINDOWS_POWERSHELL, ["-NoProfile", "-Command", scriptLines.join("\n")]);
+    stdout = result.stdout ?? "";
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to retrieve Unity process list on Windows: ${message}`);
+    return [];
+  }
+  const lines = stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const processes = [];
+  for (const line of lines) {
+    const delimiterIndex = line.indexOf("|");
+    if (delimiterIndex < 0) {
+      continue;
+    }
+    const pidText = line.slice(0, delimiterIndex).trim();
+    const command = line.slice(delimiterIndex + 1).trim();
+    const pidValue = Number.parseInt(pidText, 10);
+    if (!Number.isFinite(pidValue)) {
+      continue;
+    }
+    if (!UNITY_EXECUTABLE_PATTERN_WINDOWS.test(command)) {
+      continue;
+    }
+    if (isUnityAuxiliaryProcess(command)) {
+      continue;
+    }
+    const projectArgument = extractProjectPath(command);
+    if (!projectArgument) {
+      continue;
+    }
+    processes.push({
+      pid: pidValue,
+      projectPath: normalizePath2(projectArgument)
+    });
+  }
+  return processes;
+}
+async function listUnityProcesses() {
+  if (process.platform === "darwin") {
+    return await listUnityProcessesMac();
+  }
+  if (process.platform === "win32") {
+    return await listUnityProcessesWindows();
+  }
+  return [];
+}
+async function findRunningUnityProcess(projectPath) {
+  const normalizedTarget = normalizePath2(projectPath);
+  const processes = await listUnityProcesses();
+  return processes.find((candidate) => pathsEqual2(candidate.projectPath, normalizedTarget));
+}
+async function focusUnityProcess(pid) {
+  if (process.platform === "darwin") {
+    await focusUnityProcessMac(pid);
+    return;
+  }
+  if (process.platform === "win32") {
+    await focusUnityProcessWindows(pid);
+  }
+}
+async function focusUnityProcessMac(pid) {
+  const script = `tell application "System Events" to set frontmost of (first process whose unix id is ${pid}) to true`;
+  try {
+    await execFileAsync("osascript", ["-e", script]);
+    console.log("Brought existing Unity to the front.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to bring Unity to front: ${message}`);
+  }
+}
+async function focusUnityProcessWindows(pid) {
+  const addTypeLines = [
+    'Add-Type -TypeDefinition @"',
+    "using System;",
+    "using System.Runtime.InteropServices;",
+    "public static class Win32Interop {",
+    '  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr hWnd);',
+    '  [DllImport("user32.dll")] public static extern bool ShowWindowAsync(IntPtr hWnd, int nCmdShow);',
+    "}",
+    '"@'
+  ];
+  const scriptLines = [
+    "$ErrorActionPreference = 'Stop'",
+    ...addTypeLines,
+    `try { $process = Get-Process -Id ${pid} -ErrorAction Stop } catch { return }`,
+    "$handle = $process.MainWindowHandle",
+    "if ($handle -eq 0) { return }",
+    "[Win32Interop]::ShowWindowAsync($handle, 9) | Out-Null",
+    "[Win32Interop]::SetForegroundWindow($handle) | Out-Null"
+  ];
+  try {
+    await execFileAsync(WINDOWS_POWERSHELL, ["-NoProfile", "-Command", scriptLines.join("\n")]);
+    console.log("Brought existing Unity to the front.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to bring Unity to front on Windows: ${message}`);
+  }
+}
+async function handleStaleLockfile(projectPath) {
+  const tempDirectoryPath = (0, import_node_path2.join)(projectPath, TEMP_DIRECTORY_NAME);
+  const lockfilePath = (0, import_node_path2.join)(tempDirectoryPath, UNITY_LOCKFILE_NAME);
+  if (!(0, import_node_fs2.existsSync)(lockfilePath)) {
+    return;
+  }
+  console.log(`UnityLockfile found without active Unity process: ${lockfilePath}`);
+  console.log("Assuming previous crash. Cleaning Temp directory and continuing launch.");
+  try {
+    await (0, import_promises3.rm)(tempDirectoryPath, { recursive: true, force: true });
+    console.log("Deleted Temp directory.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to delete Temp directory: ${message}`);
+  }
+  try {
+    await (0, import_promises3.rm)(lockfilePath, { force: true });
+    console.log("Deleted UnityLockfile.");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to delete UnityLockfile: ${message}`);
+  }
+}
+var KILL_POLL_INTERVAL_MS = 100;
+var KILL_TIMEOUT_MS = 1e4;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProcess(pid) {
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+  }
+}
+async function waitForProcessExit(pid) {
+  const start = Date.now();
+  while (Date.now() - start < KILL_TIMEOUT_MS) {
+    if (!isProcessAlive(pid)) {
+      return true;
+    }
+    await new Promise((resolve5) => setTimeout(resolve5, KILL_POLL_INTERVAL_MS));
+  }
+  return false;
+}
+async function killRunningUnity(projectPath) {
+  const processInfo = await findRunningUnityProcess(projectPath);
+  if (!processInfo) {
+    console.log("No running Unity process found for this project.");
+    return;
+  }
+  const pid = processInfo.pid;
+  console.log(`Killing Unity (PID: ${pid})...`);
+  killProcess(pid);
+  const exited = await waitForProcessExit(pid);
+  if (!exited) {
+    throw new Error(`Failed to kill Unity (PID: ${pid}) within ${KILL_TIMEOUT_MS / 1e3}s.`);
+  }
+  console.log("Unity killed.");
+}
+function hasBuildTargetArg(unityArgs) {
+  for (const arg of unityArgs) {
+    if (arg === "-buildTarget") {
+      return true;
+    }
+    if (arg.startsWith("-buildTarget=")) {
+      return true;
+    }
+  }
+  return false;
+}
+var EXCLUDED_DIR_NAMES = /* @__PURE__ */ new Set([
+  "library",
+  "temp",
+  "logs",
+  "obj",
+  ".git",
+  "node_modules",
+  ".idea",
+  ".vscode",
+  ".vs"
+]);
+function isUnityProjectRoot(candidateDir) {
+  const versionFile = (0, import_node_path2.join)(candidateDir, "ProjectSettings", "ProjectVersion.txt");
+  return (0, import_node_fs2.existsSync)(versionFile);
+}
+function listSubdirectoriesSorted(dir) {
+  let entries = [];
+  try {
+    const dirents = (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true });
+    const subdirs = dirents.filter((d) => d.isDirectory()).map((d) => d.name).filter((name) => !EXCLUDED_DIR_NAMES.has(name.toLocaleLowerCase()));
+    subdirs.sort((a, b) => a.localeCompare(b));
+    entries = subdirs.map((name) => (0, import_node_path2.join)(dir, name));
+  } catch {
+    entries = [];
+  }
+  return entries;
+}
+function findUnityProjectBfs(rootDir, maxDepth) {
+  const queue = [];
+  let rootCanonical;
+  try {
+    rootCanonical = (0, import_node_fs2.realpathSync)(rootDir);
+  } catch {
+    rootCanonical = rootDir;
+  }
+  queue.push({ dir: rootCanonical, depth: 0 });
+  const visited = /* @__PURE__ */ new Set([toComparablePath2(normalizePath2(rootCanonical))]);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      continue;
+    }
+    const { dir, depth } = current;
+    if (isUnityProjectRoot(dir)) {
+      return normalizePath2(dir);
+    }
+    const canDescend = maxDepth === -1 || depth < maxDepth;
+    if (!canDescend) {
+      continue;
+    }
+    const children = listSubdirectoriesSorted(dir);
+    for (const child of children) {
+      let childCanonical = child;
+      try {
+        const stat = (0, import_node_fs2.lstatSync)(child);
+        if (stat.isSymbolicLink()) {
+          try {
+            childCanonical = (0, import_node_fs2.realpathSync)(child);
+          } catch {
+            continue;
+          }
+        }
+      } catch {
+        continue;
+      }
+      const key = toComparablePath2(normalizePath2(childCanonical));
+      if (visited.has(key)) {
+        continue;
+      }
+      visited.add(key);
+      queue.push({ dir: childCanonical, depth: depth + 1 });
+    }
+  }
+  return void 0;
+}
+function launch(opts) {
+  const { projectPath, platform, unityArgs, unityVersion } = opts;
+  const unityPath = getUnityPath(unityVersion);
+  console.log(`Detected Unity version: ${unityVersion}`);
+  if (!(0, import_node_fs2.existsSync)(unityPath)) {
+    throw new Error(`Unity ${unityVersion} not found at ${unityPath}. Please install Unity through Unity Hub.`);
+  }
+  console.log("Opening Unity...");
+  console.log(`Project Path: ${projectPath}`);
+  const args = ["-projectPath", projectPath];
+  const unityArgsContainBuildTarget = hasBuildTargetArg(unityArgs);
+  if (platform && platform.length > 0 && !unityArgsContainBuildTarget) {
+    args.push("-buildTarget", platform);
+  }
+  if (unityArgs.length > 0) {
+    args.push(...unityArgs);
+  }
+  const child = (0, import_node_child_process.spawn)(unityPath, args, { stdio: "ignore", detached: true });
+  child.unref();
+}
+
+// src/commands/launch.ts
+function registerLaunchCommand(program3) {
+  program3.command("launch").description("Launch Unity project with matching Editor version").argument("[project-path]", "Path to Unity project").option("-r, --restart", "Kill running Unity and restart").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);
+  });
+}
+function parseMaxDepth(value) {
+  if (value === void 0) {
+    return 3;
+  }
+  const parsed = parseInt(value, 10);
+  if (Number.isNaN(parsed)) {
+    console.error(`Error: Invalid --max-depth value: "${value}". Must be an integer.`);
+    process.exit(1);
+  }
+  return parsed;
+}
+async function runLaunchCommand(projectPath, options) {
+  const maxDepth = parseMaxDepth(options.maxDepth);
+  let resolvedProjectPath = projectPath ? (0, import_path6.resolve)(projectPath) : void 0;
+  if (!resolvedProjectPath) {
+    const searchRoot = process.cwd();
+    const depthInfo = maxDepth === -1 ? "unlimited" : String(maxDepth);
+    console.log(
+      `No project-path provided. Searching under ${searchRoot} (max-depth: ${depthInfo})...`
+    );
+    const found = findUnityProjectBfs(searchRoot, maxDepth);
+    if (!found) {
+      console.error(`Error: Unity project not found under ${searchRoot}.`);
+      process.exit(1);
+    }
+    console.log(`Selected project: ${found}`);
+    resolvedProjectPath = found;
+  }
+  const unityVersion = getUnityVersion(resolvedProjectPath);
+  const unityHubOnlyMode = options.addUnityHub === true || options.favorite === true;
+  if (unityHubOnlyMode) {
+    console.log(`Detected Unity version: ${unityVersion}`);
+    console.log(`Project Path: ${resolvedProjectPath}`);
+    const now2 = /* @__PURE__ */ new Date();
+    await ensureProjectEntryAndUpdate(
+      resolvedProjectPath,
+      unityVersion,
+      now2,
+      options.favorite === true
+    );
+    console.log("Unity Hub entry updated.");
+    return;
+  }
+  if (options.restart === true) {
+    await killRunningUnity(resolvedProjectPath);
+  } else {
+    const runningProcess = await findRunningUnityProcess(resolvedProjectPath);
+    if (runningProcess) {
+      console.log(
+        `Unity process already running for project: ${resolvedProjectPath} (PID: ${runningProcess.pid})`
+      );
+      await focusUnityProcess(runningProcess.pid);
+      return;
+    }
+  }
+  await handleStaleLockfile(resolvedProjectPath);
+  const resolved = {
+    projectPath: resolvedProjectPath,
+    platform: options.platform,
+    unityArgs: [],
+    unityVersion
+  };
+  launch(resolved);
+  const now = /* @__PURE__ */ new Date();
+  await updateLastModifiedIfExists(resolvedProjectPath, now);
+}
+
 // src/cli.ts
-var BUILTIN_COMMANDS = ["list", "sync", "completion", "update", "fix", "skills"];
+var BUILTIN_COMMANDS = [
+  "list",
+  "sync",
+  "completion",
+  "update",
+  "fix",
+  "skills",
+  "launch"
+];
 var program2 = new Command();
 program2.name("uloop").description("Unity MCP CLI - Direct communication with Unity Editor").version(VERSION, "-v, --version", "Output the version number");
 program2.option("--list-commands", "List all command names (for shell completion)");
@@ -7272,6 +7935,7 @@ program2.command("fix").description("Clean up stale lock files that may prevent
   cleanupLockFiles();
 });
 registerSkillsCommand(program2);
+registerLaunchCommand(program2);
 function registerToolCommand(tool) {
   const cmd = program2.command(tool.name).description(tool.description);
   const properties = tool.inputSchema.properties;
@@ -7471,7 +8135,7 @@ async function runWithErrorHandling(fn) {
 }
 function detectShell() {
   const shell = process.env["SHELL"] || "";
-  const shellName = (0, import_path6.basename)(shell).replace(/\.exe$/i, "");
+  const shellName = (0, import_path7.basename)(shell).replace(/\.exe$/i, "");
   if (shellName === "zsh") {
     return "zsh";
   }
@@ -7486,12 +8150,12 @@ function detectShell() {
 function getShellConfigPath(shell) {
   const home = (0, import_os2.homedir)();
   if (shell === "zsh") {
-    return (0, import_path6.join)(home, ".zshrc");
+    return (0, import_path7.join)(home, ".zshrc");
   }
   if (shell === "powershell") {
-    return (0, import_path6.join)(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+    return (0, import_path7.join)(home, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
   }
-  return (0, import_path6.join)(home, ".bashrc");
+  return (0, import_path7.join)(home, ".bashrc");
 }
 function getCompletionScript(shell) {
   if (shell === "bash") {
@@ -7628,10 +8292,10 @@ function cleanupLockFiles() {
     console.error("Could not find Unity project root.");
     process.exit(1);
   }
-  const tempDir = (0, import_path6.join)(projectRoot, "Temp");
+  const tempDir = (0, import_path7.join)(projectRoot, "Temp");
   let cleaned = 0;
   for (const lockFile of LOCK_FILES) {
-    const lockPath = (0, import_path6.join)(tempDir, lockFile);
+    const lockPath = (0, import_path7.join)(tempDir, lockFile);
     if ((0, import_fs6.existsSync)(lockPath)) {
       (0, import_fs6.unlinkSync)(lockPath);
       console.log(`Removed: ${lockFile}`);
@@ -7668,7 +8332,7 @@ function handleCompletion(install, shellOverride) {
     return;
   }
   const configPath = getShellConfigPath(shell);
-  const configDir = (0, import_path6.dirname)(configPath);
+  const configDir = (0, import_path7.dirname)(configPath);
   if (!(0, import_fs6.existsSync)(configDir)) {
     (0, import_fs6.mkdirSync)(configDir, { recursive: true });
   }