uloop-cli 0.56.0 → 0.58.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,12 +5508,12 @@ 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(
           new Error(
-            `Request timed out after ${NETWORK_TIMEOUT_MS}ms. Unity may be frozen or busy. [For AI] Please report this to the user and ask how to proceed. Do NOT kill Unity processes without user permission.`
+            `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.`
           )
         );
       }, NETWORK_TIMEOUT_MS);
@@ -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.58.0",
   tools: [
     {
       name: "compile",
@@ -6215,7 +6215,7 @@ function getCachedServerVersion() {
 }
 
 // src/version.ts
-var VERSION = "0.56.0";
+var VERSION = "0.58.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,715 @@ 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/commands/focus-window.ts
+function registerFocusWindowCommand(program3) {
+  program3.command("focus-window").description("Bring Unity Editor window to front using OS-level commands").action(async () => {
+    const projectRoot = findUnityProjectRoot();
+    if (projectRoot === null) {
+      console.error(
+        JSON.stringify({
+          Success: false,
+          Message: "Unity project not found"
+        })
+      );
+      process.exit(1);
+    }
+    const runningProcess = await findRunningUnityProcess(projectRoot);
+    if (!runningProcess) {
+      console.error(
+        JSON.stringify({
+          Success: false,
+          Message: "No running Unity process found for this project"
+        })
+      );
+      process.exit(1);
+    }
+    try {
+      await focusUnityProcess(runningProcess.pid);
+      console.log(
+        JSON.stringify({
+          Success: true,
+          Message: `Unity Editor window focused (PID: ${runningProcess.pid})`
+        })
+      );
+    } catch (error) {
+      console.error(
+        JSON.stringify({
+          Success: false,
+          Message: `Failed to focus Unity window: ${error instanceof Error ? error.message : String(error)}`
+        })
+      );
+      process.exit(1);
+    }
+  });
+}
+
 // src/cli.ts
-var BUILTIN_COMMANDS = ["list", "sync", "completion", "update", "fix", "skills"];
+var BUILTIN_COMMANDS = [
+  "list",
+  "sync",
+  "completion",
+  "update",
+  "fix",
+  "skills",
+  "launch",
+  "focus-window"
+];
 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,7 +7979,12 @@ program2.command("fix").description("Clean up stale lock files that may prevent
   cleanupLockFiles();
 });
 registerSkillsCommand(program2);
+registerLaunchCommand(program2);
+registerFocusWindowCommand(program2);
 function registerToolCommand(tool) {
+  if (BUILTIN_COMMANDS.includes(tool.name)) {
+    return;
+  }
   const cmd = program2.command(tool.name).description(tool.description);
   const properties = tool.inputSchema.properties;
   for (const [propName, propInfo] of Object.entries(properties)) {
@@ -7471,7 +8183,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 +8198,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 +8340,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 +8380,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 });
   }