uloop-cli 0.60.0 → 0.61.0

package/dist/cli.bundle.cjs

@@ -5763,7 +5763,7 @@ var import_path3 = require("path");
 
 // src/default-tools.json
 var default_tools_default = {
-  version: "0.60.0",
+  version: "0.61.0",
   tools: [
     {
       name: "compile",
@@ -6207,7 +6207,7 @@ function getCachedServerVersion() {
 }
 
 // src/version.ts
-var VERSION = "0.60.0";
+var VERSION = "0.61.0";
 
 // src/spinner.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -7464,6 +7464,24 @@ var parseCliArgs = (cliArgsString) => {
   }
   return tokens;
 };
+var groupCliArgs = (args) => {
+  const groups = [];
+  let current = "";
+  for (const arg of args) {
+    if (arg.startsWith("-") && current.length > 0) {
+      groups.push(current);
+      current = arg;
+    } else if (current.length === 0) {
+      current = arg;
+    } else {
+      current += ` ${arg}`;
+    }
+  }
+  if (current.length > 0) {
+    groups.push(current);
+  }
+  return groups;
+};
 var getProjectCliArgs = async (projectPath) => {
   (0, import_node_assert.default)(projectPath !== null && projectPath !== void 0, "projectPath must not be null");
   const infoFilePath = resolveUnityHubProjectsInfoFile();
@@ -7769,9 +7787,11 @@ async function handleStaleLockfile(projectPath) {
     const message = error instanceof Error ? error.message : String(error);
     console.warn(`Failed to delete UnityLockfile: ${message}`);
   }
+  console.log();
 }
 var KILL_POLL_INTERVAL_MS = 100;
 var KILL_TIMEOUT_MS = 1e4;
+var GRACEFUL_QUIT_TIMEOUT_MS = 1e4;
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -7786,9 +7806,9 @@ function killProcess(pid) {
   } catch {
   }
 }
-async function waitForProcessExit(pid) {
+async function waitForProcessExit(pid, timeoutMs) {
   const start = Date.now();
-  while (Date.now() - start < KILL_TIMEOUT_MS) {
+  while (Date.now() - start < timeoutMs) {
     if (!isProcessAlive(pid)) {
       return true;
     }
@@ -7800,16 +7820,73 @@ async function killRunningUnity(projectPath) {
   const processInfo = await findRunningUnityProcess(projectPath);
   if (!processInfo) {
     console.log("No running Unity process found for this project.");
+    console.log();
     return;
   }
   const pid = processInfo.pid;
   console.log(`Killing Unity (PID: ${pid})...`);
   killProcess(pid);
-  const exited = await waitForProcessExit(pid);
+  const exited = await waitForProcessExit(pid, KILL_TIMEOUT_MS);
   if (!exited) {
     throw new Error(`Failed to kill Unity (PID: ${pid}) within ${KILL_TIMEOUT_MS / 1e3}s.`);
   }
   console.log("Unity killed.");
+  console.log();
+}
+async function sendGracefulQuitMac(pid) {
+  const script = [
+    'tell application "System Events"',
+    `  set frontmost of (first process whose unix id is ${pid}) to true`,
+    '  keystroke "q" using {command down}',
+    "end tell"
+  ].join("\n");
+  try {
+    await execFileAsync("osascript", ["-e", script]);
+  } catch {
+  }
+}
+async function sendGracefulQuitWindows(pid) {
+  const scriptLines = [
+    "$ErrorActionPreference = 'Stop'",
+    `try { $proc = Get-Process -Id ${pid} -ErrorAction Stop; $proc.CloseMainWindow() | Out-Null } catch { }`
+  ];
+  try {
+    await execFileAsync(WINDOWS_POWERSHELL, ["-NoProfile", "-Command", scriptLines.join("\n")]);
+  } catch {
+  }
+}
+async function sendGracefulQuit(pid) {
+  if (process.platform === "darwin") {
+    await sendGracefulQuitMac(pid);
+    return;
+  }
+  if (process.platform === "win32") {
+    await sendGracefulQuitWindows(pid);
+    return;
+  }
+}
+async function quitRunningUnity(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(`Quitting Unity (PID: ${pid})...`);
+  await sendGracefulQuit(pid);
+  console.log(`Sent graceful quit signal. Waiting up to ${GRACEFUL_QUIT_TIMEOUT_MS / 1e3}s...`);
+  const exitedGracefully = await waitForProcessExit(pid, GRACEFUL_QUIT_TIMEOUT_MS);
+  if (exitedGracefully) {
+    console.log("Unity quit gracefully.");
+    return;
+  }
+  console.log("Unity did not respond to graceful quit. Force killing...");
+  killProcess(pid);
+  const exitedAfterKill = await waitForProcessExit(pid, KILL_TIMEOUT_MS);
+  if (!exitedAfterKill) {
+    throw new Error(`Failed to kill Unity (PID: ${pid}) within ${KILL_TIMEOUT_MS / 1e3}s.`);
+  }
+  console.log("Unity force killed.");
 }
 function hasBuildTargetArg(unityArgs) {
   for (const arg of unityArgs) {
@@ -7900,12 +7977,12 @@ function findUnityProjectBfs(rootDir, maxDepth) {
 async 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}`);
+  console.log(`Detected Unity version: ${unityVersion}`);
   const args = ["-projectPath", projectPath];
   const unityArgsContainBuildTarget = hasBuildTargetArg(unityArgs);
   if (platform && platform.length > 0 && !unityArgsContainBuildTarget) {
@@ -7913,86 +7990,133 @@ async function launch(opts) {
   }
   const hubCliArgs = await getProjectCliArgs(projectPath);
   if (hubCliArgs.length > 0) {
+    console.log("Unity Hub launch options:");
+    for (const line of groupCliArgs(hubCliArgs)) {
+      console.log(`  ${line}`);
+    }
     args.push(...hubCliArgs);
+  } else {
+    console.log("Unity Hub launch options: none");
   }
   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);
+  return new Promise((resolve5, reject) => {
+    const child = (0, import_node_child_process.spawn)(unityPath, args, {
+      stdio: "ignore",
+      detached: true,
+      // Git Bash (MSYS) がWindows パスをUnix 形式に自動変換するのを防ぐ
+      env: {
+        ...process.env,
+        MSYS_NO_PATHCONV: "1"
+      }
+    });
+    const handleError = (error) => {
+      child.removeListener("spawn", handleSpawn);
+      reject(new Error(`Failed to launch Unity: ${error.message}`));
+    };
+    const handleSpawn = () => {
+      child.removeListener("error", handleError);
+      child.unref();
+      resolve5();
+    };
+    child.once("error", handleError);
+    child.once("spawn", handleSpawn);
   });
 }
-function parseMaxDepth(value) {
-  if (value === void 0) {
-    return 3;
+async function orchestrateLaunch(options) {
+  if (options.quit && options.restart) {
+    throw new Error("--quit and --restart cannot be used together.");
   }
-  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;
+  let resolvedProjectPath = options.projectPath;
   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);
+    const depthInfo = options.searchMaxDepth === -1 ? "unlimited" : String(options.searchMaxDepth);
+    console.log(`Searching for Unity project under ${options.searchRoot} (max-depth: ${depthInfo})...`);
+    const found = findUnityProjectBfs(options.searchRoot, options.searchMaxDepth);
     if (!found) {
-      console.error(`Error: Unity project not found under ${searchRoot}.`);
-      process.exit(1);
+      throw new Error(`Unity project not found under ${options.searchRoot}.`);
     }
-    console.log(`Selected project: ${found}`);
+    console.log();
     resolvedProjectPath = found;
   }
+  if (!(0, import_node_fs2.existsSync)(resolvedProjectPath)) {
+    throw new Error(`Project directory not found: ${resolvedProjectPath}`);
+  }
   const unityVersion = getUnityVersion(resolvedProjectPath);
-  const unityHubOnlyMode = options.addUnityHub === true || options.favorite === true;
-  if (unityHubOnlyMode) {
+  if (options.addUnityHub || options.favoriteUnityHub) {
     console.log(`Detected Unity version: ${unityVersion}`);
     console.log(`Project Path: ${resolvedProjectPath}`);
     const now2 = /* @__PURE__ */ new Date();
-    await ensureProjectEntryAndUpdate(
-      resolvedProjectPath,
-      unityVersion,
-      now2,
-      options.favorite === true
-    );
+    await ensureProjectEntryAndUpdate(resolvedProjectPath, unityVersion, now2, options.favoriteUnityHub);
     console.log("Unity Hub entry updated.");
-    return;
+    return { action: "hub-updated", projectPath: resolvedProjectPath, unityVersion };
+  }
+  if (options.quit) {
+    await quitRunningUnity(resolvedProjectPath);
+    return { action: "quit", projectPath: resolvedProjectPath };
   }
-  if (options.restart === true) {
+  const isRestart = options.restart;
+  if (isRestart) {
     await killRunningUnity(resolvedProjectPath);
   } else {
     const runningProcess = await findRunningUnityProcess(resolvedProjectPath);
     if (runningProcess) {
-      console.log(
-        `Unity process already running for project: ${resolvedProjectPath} (PID: ${runningProcess.pid})`
-      );
+      console.log(`Unity process already running for project: ${resolvedProjectPath} (PID: ${runningProcess.pid})`);
       await focusUnityProcess(runningProcess.pid);
-      return;
+      return { action: "focused", projectPath: resolvedProjectPath, pid: runningProcess.pid };
     }
   }
   await handleStaleLockfile(resolvedProjectPath);
   const resolved = {
     projectPath: resolvedProjectPath,
     platform: options.platform,
-    unityArgs: [],
+    unityArgs: options.unityArgs,
     unityVersion
   };
   await launch(resolved);
   const now = /* @__PURE__ */ new Date();
-  await updateLastModifiedIfExists(resolvedProjectPath, now);
+  try {
+    await updateLastModifiedIfExists(resolvedProjectPath, now);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to update Unity Hub lastModified: ${message}`);
+  }
+  const action = isRestart ? "killed-and-launched" : "launched";
+  return { action, projectPath: resolvedProjectPath, unityVersion };
+}
+
+// src/commands/launch.ts
+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) => {
+    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);
+  await orchestrateLaunch({
+    projectPath: projectPath ? (0, import_path6.resolve)(projectPath) : void 0,
+    searchRoot: process.cwd(),
+    searchMaxDepth: maxDepth,
+    platform: options.platform,
+    unityArgs: [],
+    restart: options.restart === true,
+    quit: options.quit === true,
+    addUnityHub: options.addUnityHub === true,
+    favoriteUnityHub: options.favorite === true
+  });
 }
 
 // src/commands/focus-window.ts