launch-unity 0.6.0 → 0.6.2

package/README.ja.md

@@ -18,7 +18,7 @@ npx launch-unity
 ## 使用例
 ```bash
 # NPX（推奨 / インストール不要）
-npx launch-unity                    # カレントディレクトリを開く（ビルドターゲット未指定時はプロジェクトの現在のビルドターゲットを使用）
+npx launch-unity                    # カレントディレクトリから3階層下までUnityプロジェクトを探索して開く
 npx launch-unity /path/to/Proj      # プロジェクトを指定
 npx launch-unity /path Android      # ビルドターゲットを指定
 npx -y launch-unity                 # npx の「Ok to proceed?」確認をスキップ
@@ -31,11 +31,6 @@ npx launch-unity /path Android -- -executeMethod My.Build.Entry
 launch-unity
 launch-unity /path/to/MyUnityProject Android
 launch-unity . -- -buildTarget iOS -projectPath . # 上書きも可能
-
-# プロジェクトを開いている Unity を終了
-quit-unity                 # カレントディレクトリのプロジェクトの Unity を終了
-quit-unity /path/to/Proj   # 指定プロジェクトの Unity を終了
-quit-unity . --timeout 20000 --force
 ```
 
 指定した Unity プロジェクトの `ProjectSettings/ProjectVersion.txt` から必要な Unity Editor のバージョンを読み取り、
@@ -61,17 +56,6 @@ Unity Hub でインストール済みの該当バージョンを起動する mac
 - macOS / Windows: Unity Hub のデフォルトインストールパスを前提にサポート。
 - Linux: 未対応です。対応 PR を歓迎します。
 
-## quit-unity 使い方（詳細）
-```bash
-# 基本構文
-quit-unity [PROJECT_PATH] [--timeout <ms>] [--force]
-
-# フラグ
-# -t, --timeout <ms>  正常終了を待つ時間（既定: 15000ms）
-# -f, --force         タイムアウト後に強制終了
-# -h, --help          ヘルプ
-```
-
 ## セキュリティ
 
 このプロジェクトはサプライチェーン攻撃対策を実施しています：

package/README.md

@@ -18,7 +18,7 @@ npx launch-unity
 ## Usage Examples
 ```bash
 # NPX (recommended, zero install)
-npx launch-unity                   # Open the current directory (if PLATFORM is omitted, uses the project's current build target)
+npx launch-unity                   # Search up to 3 levels deep for a Unity project and open it
 npx launch-unity /path/to/Proj     # Open a specific project
 npx launch-unity /path Android     # Specify build target
 npx -y launch-unity                # Skip npx "Ok to proceed?" prompt
@@ -31,11 +31,6 @@ npx launch-unity /path Android -- -executeMethod My.Build.Entry
 launch-unity
 launch-unity /path/to/MyUnityProject Android
 launch-unity . -- -buildTarget iOS -projectPath . # You can override
-
-# Quit the Unity instance holding a project open
-quit-unity                 # Quit Unity for current directory project
-quit-unity /path/to/Proj   # Quit Unity for a specific project
-quit-unity . --timeout 20000 --force
 ```
 
 A TypeScript CLI for macOS and Windows that reads the required Unity Editor version from
@@ -63,14 +58,6 @@ launch-unity [PROJECT_PATH] [PLATFORM]
 
 # Flags
 # -h, --help  Show help
-
-# Quit syntax
-quit-unity [PROJECT_PATH] [--timeout <ms>] [--force]
-
-# Flags (quit-unity)
-# -t, --timeout <ms>  Time to wait for graceful quit (default: 15000)
-# -f, --force         Force kill if not exited within timeout
-# -h, --help          Show help
 ```
 
 

package/dist/launch.js

@@ -0,0 +1,555 @@
+#!/usr/bin/env node
+/*
+  launch-unity: Open a Unity project with the matching Editor version.
+  Platforms: macOS, Windows
+*/
+import { execFile, spawn } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, lstatSync, realpathSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { promisify } from "node:util";
+import { updateLastModifiedIfExists } from "./unityHub.js";
+const execFileAsync = promisify(execFile);
+const UNITY_EXECUTABLE_PATTERN_MAC = /Unity\.app\/Contents\/MacOS\/Unity/i;
+const UNITY_EXECUTABLE_PATTERN_WINDOWS = /Unity\.exe/i;
+const PROJECT_PATH_PATTERN = /-(?:projectPath|projectpath)(?:=|\s+)("[^"]+"|'[^']+'|[^\s"']+)/i;
+const PROCESS_LIST_COMMAND_MAC = "ps";
+const PROCESS_LIST_ARGS_MAC = ["-axo", "pid=,command=", "-ww"];
+const WINDOWS_POWERSHELL = "powershell";
+const UNITY_LOCKFILE_NAME = "UnityLockfile";
+const TEMP_DIRECTORY_NAME = "Temp";
+function parseArgs(argv) {
+    const args = argv.slice(2);
+    const doubleDashIndex = args.indexOf("--");
+    const cliArgs = doubleDashIndex >= 0 ? args.slice(0, doubleDashIndex) : args;
+    const unityArgs = doubleDashIndex >= 0 ? args.slice(doubleDashIndex + 1) : [];
+    const positionals = [];
+    let maxDepth = 3; // default 3; -1 means unlimited
+    for (let i = 0; i < cliArgs.length; i++) {
+        const arg = cliArgs[i] ?? "";
+        if (arg === "--help" || arg === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+        if (arg.startsWith("--max-depth")) {
+            const parts = arg.split("=");
+            if (parts.length === 2) {
+                const value = Number.parseInt(parts[1] ?? "", 10);
+                if (Number.isFinite(value)) {
+                    maxDepth = value;
+                }
+                continue;
+            }
+            const next = cliArgs[i + 1];
+            if (typeof next === "string" && !next.startsWith("-")) {
+                const value = Number.parseInt(next, 10);
+                if (Number.isFinite(value)) {
+                    maxDepth = value;
+                }
+                i += 1;
+                continue;
+            }
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            continue;
+        }
+        positionals.push(arg);
+    }
+    let projectPath;
+    let platform;
+    if (positionals.length === 0) {
+        projectPath = undefined; // trigger search
+        platform = undefined;
+    }
+    else if (positionals.length === 1) {
+        const first = positionals[0] ?? "";
+        const resolvedFirst = resolve(first);
+        if (existsSync(resolvedFirst)) {
+            projectPath = resolvedFirst;
+            platform = undefined;
+        }
+        else {
+            // Treat as platform when path does not exist
+            projectPath = undefined; // trigger search
+            platform = String(first);
+        }
+    }
+    else {
+        projectPath = resolve(positionals[0] ?? "");
+        platform = String(positionals[1] ?? "");
+    }
+    const options = { unityArgs, searchMaxDepth: maxDepth };
+    if (projectPath !== undefined) {
+        options.projectPath = projectPath;
+    }
+    if (platform !== undefined) {
+        options.platform = platform;
+    }
+    return options;
+}
+function printHelp() {
+    const help = `
+Usage: launch-unity [PROJECT_PATH] [PLATFORM] -- [UNITY_ARGS...]
+
+Open a Unity project with the matching Unity Editor version installed by Unity Hub.
+
+Arguments:
+  PROJECT_PATH  Optional. Defaults to current directory
+  PLATFORM      Optional. Passed to Unity as -buildTarget (e.g., StandaloneOSX, Android, iOS)
+
+Forwarding:
+  Everything after -- is forwarded to Unity unchanged.
+  If UNITY_ARGS includes -buildTarget, the PLATFORM argument is ignored.
+
+Flags:
+  -h, --help          Show this help message
+  --max-depth <N>     Search depth when PROJECT_PATH is omitted (default 3, -1 unlimited)
+`;
+    process.stdout.write(help);
+}
+function getUnityVersion(projectPath) {
+    const versionFile = join(projectPath, "ProjectSettings", "ProjectVersion.txt");
+    if (!existsSync(versionFile)) {
+        console.error(`Error: ProjectVersion.txt not found at ${versionFile}`);
+        console.error("This does not appear to be a Unity project.");
+        process.exit(1);
+    }
+    const content = readFileSync(versionFile, "utf8");
+    const version = content.match(/m_EditorVersion:\s*([^\s\n]+)/)?.[1];
+    if (!version) {
+        console.error(`Error: Could not extract Unity version from ${versionFile}`);
+        process.exit(1);
+    }
+    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(join(base, "Unity", "Hub", "Editor", version, "Editor", "Unity.exe"));
+    };
+    addCandidate(programFiles);
+    addCandidate(programFilesX86);
+    addCandidate(localAppData);
+    candidates.push(join("C:\\", "Program Files", "Unity", "Hub", "Editor", version, "Editor", "Unity.exe"));
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    return candidates[0] ?? 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`;
+}
+function ensureProjectPath(projectPath) {
+    if (!existsSync(projectPath)) {
+        console.error(`Error: Project directory not found: ${projectPath}`);
+        process.exit(1);
+    }
+}
+const removeTrailingSeparators = (target) => {
+    let trimmed = target;
+    while (trimmed.length > 1 && (trimmed.endsWith("/") || trimmed.endsWith("\\"))) {
+        trimmed = trimmed.slice(0, -1);
+    }
+    return trimmed;
+};
+const normalizePath = (target) => {
+    const resolvedPath = resolve(target);
+    const trimmed = removeTrailingSeparators(resolvedPath);
+    return trimmed;
+};
+const toComparablePath = (value) => {
+    return value.replace(/\\/g, "/").toLocaleLowerCase();
+};
+const pathsEqual = (left, right) => {
+    return toComparablePath(normalizePath(left)) === toComparablePath(normalizePath(right));
+};
+function extractProjectPath(command) {
+    const match = command.match(PROJECT_PATH_PATTERN);
+    if (!match) {
+        return undefined;
+    }
+    const raw = match[1];
+    if (!raw) {
+        return undefined;
+    }
+    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;
+}
+const 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: normalizePath(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: normalizePath(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 = normalizePath(projectPath);
+    const processes = await listUnityProcesses();
+    return processes.find((candidate) => pathsEqual(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 = join(projectPath, TEMP_DIRECTORY_NAME);
+    const lockfilePath = join(tempDirectoryPath, UNITY_LOCKFILE_NAME);
+    if (!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 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 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}`);
+    }
+}
+function hasBuildTargetArg(unityArgs) {
+    for (const arg of unityArgs) {
+        if (arg === "-buildTarget") {
+            return true;
+        }
+        if (arg.startsWith("-buildTarget=")) {
+            return true;
+        }
+    }
+    return false;
+}
+const EXCLUDED_DIR_NAMES = new Set([
+    "library",
+    "temp",
+    "logs",
+    "obj",
+    ".git",
+    "node_modules",
+    ".idea",
+    ".vscode",
+    ".vs",
+]);
+function isUnityProjectRoot(candidateDir) {
+    const versionFile = join(candidateDir, "ProjectSettings", "ProjectVersion.txt");
+    const hasVersion = existsSync(versionFile);
+    if (!hasVersion) {
+        return false;
+    }
+    const libraryDir = join(candidateDir, "Library");
+    return existsSync(libraryDir);
+}
+function listSubdirectoriesSorted(dir) {
+    let entries = [];
+    try {
+        const dirents = 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) => join(dir, name));
+    }
+    catch {
+        // Ignore directories we cannot read
+        entries = [];
+    }
+    return entries;
+}
+function findUnityProjectBfs(rootDir, maxDepth) {
+    const queue = [];
+    let rootCanonical;
+    try {
+        rootCanonical = realpathSync(rootDir);
+    }
+    catch {
+        rootCanonical = rootDir;
+    }
+    queue.push({ dir: rootCanonical, depth: 0 });
+    const visited = new Set([toComparablePath(normalizePath(rootCanonical))]);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current) {
+            continue;
+        }
+        const { dir, depth } = current;
+        if (isUnityProjectRoot(dir)) {
+            return normalizePath(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 = lstatSync(child);
+                if (stat.isSymbolicLink()) {
+                    try {
+                        childCanonical = realpathSync(child);
+                    }
+                    catch {
+                        // Broken symlink: skip
+                        continue;
+                    }
+                }
+            }
+            catch {
+                continue;
+            }
+            const key = toComparablePath(normalizePath(childCanonical));
+            if (visited.has(key)) {
+                continue;
+            }
+            visited.add(key);
+            queue.push({ dir: childCanonical, depth: depth + 1 });
+        }
+    }
+    return undefined;
+}
+function launch(opts) {
+    const { projectPath, platform, unityArgs } = opts;
+    const unityVersion = getUnityVersion(projectPath);
+    const unityPath = getUnityPath(unityVersion);
+    console.log(`Detected Unity version: ${unityVersion}`);
+    if (!existsSync(unityPath)) {
+        console.error(`Error: Unity ${unityVersion} not found at ${unityPath}`);
+        console.error("Please install Unity through Unity Hub.");
+        process.exit(1);
+    }
+    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 = spawn(unityPath, args, { stdio: "ignore", detached: true });
+    child.unref();
+}
+async function main() {
+    const options = parseArgs(process.argv);
+    let resolvedProjectPath = options.projectPath;
+    if (!resolvedProjectPath) {
+        const searchRoot = process.cwd();
+        const depthInfo = options.searchMaxDepth === -1 ? "unlimited" : String(options.searchMaxDepth);
+        console.log(`No PROJECT_PATH provided. Searching under ${searchRoot} (max-depth: ${depthInfo})...`);
+        const found = findUnityProjectBfs(searchRoot, options.searchMaxDepth);
+        if (!found) {
+            console.error(`Error: Unity project not found under ${searchRoot}.`);
+            process.exit(1);
+            return;
+        }
+        console.log(`Selected project: ${found}`);
+        resolvedProjectPath = found;
+    }
+    ensureProjectPath(resolvedProjectPath);
+    const runningProcess = await findRunningUnityProcess(resolvedProjectPath);
+    if (runningProcess) {
+        console.log(`Unity process already running for project: ${resolvedProjectPath} (PID: ${runningProcess.pid})`);
+        await focusUnityProcess(runningProcess.pid);
+        process.exit(0);
+        return;
+    }
+    await handleStaleLockfile(resolvedProjectPath);
+    const resolved = {
+        projectPath: resolvedProjectPath,
+        platform: options.platform,
+        unityArgs: options.unityArgs,
+    };
+    launch(resolved);
+    // Best-effort update of Unity Hub's lastModified timestamp.
+    try {
+        await updateLastModifiedIfExists(resolvedProjectPath, new Date());
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to update Unity Hub lastModified: ${message}`);
+    }
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/unityHub.js

@@ -0,0 +1,90 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const resolveUnityHubProjectFiles = () => {
+    if (process.platform === "darwin") {
+        const home = process.env.HOME;
+        if (!home) {
+            return [];
+        }
+        const base = join(home, "Library", "Application Support", "UnityHub");
+        return [join(base, "projects-v1.json"), join(base, "projects.json")];
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA;
+        if (!appData) {
+            return [];
+        }
+        const base = join(appData, "UnityHub");
+        return [join(base, "projects-v1.json"), join(base, "projects.json")];
+    }
+    return [];
+};
+const removeTrailingSeparators = (target) => {
+    let trimmed = target;
+    while (trimmed.length > 1 && (trimmed.endsWith("/") || trimmed.endsWith("\\"))) {
+        trimmed = trimmed.slice(0, -1);
+    }
+    return trimmed;
+};
+const normalizePath = (target) => {
+    const resolvedPath = resolve(target);
+    return removeTrailingSeparators(resolvedPath);
+};
+const toComparablePath = (value) => {
+    return value.replace(/\\/g, "/").toLocaleLowerCase();
+};
+const pathsEqual = (left, right) => {
+    return toComparablePath(normalizePath(left)) === toComparablePath(normalizePath(right));
+};
+export const updateLastModifiedIfExists = async (projectPath, when) => {
+    const candidates = resolveUnityHubProjectFiles();
+    if (candidates.length === 0) {
+        return;
+    }
+    // Try primary then fallback only if read/parse fails
+    for (const path of candidates) {
+        let content;
+        let json;
+        try {
+            content = await readFile(path, "utf8");
+        }
+        catch {
+            // Try next candidate on read error
+            continue;
+        }
+        try {
+            json = JSON.parse(content);
+        }
+        catch {
+            // Try next candidate on parse error
+            continue;
+        }
+        if (!json.data) {
+            // If file is readable but has no data, do not attempt fallback
+            return;
+        }
+        const projectKey = Object.keys(json.data).find((key) => {
+            const entryPath = json.data?.[key]?.path;
+            return entryPath ? pathsEqual(entryPath, projectPath) : false;
+        });
+        if (!projectKey) {
+            // Project not registered in Hub; do nothing
+            return;
+        }
+        const original = json.data[projectKey];
+        if (!original) {
+            return;
+        }
+        json.data[projectKey] = {
+            ...original,
+            lastModified: when.getTime(),
+        };
+        try {
+            await writeFile(path, JSON.stringify(json, undefined, 2), "utf8");
+        }
+        catch {
+            // Swallow write errors per requirement to not crash CLI
+        }
+        return;
+    }
+};

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "launch-unity",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Open a Unity project with the matching Editor version (macOS/Windows)",
   "type": "module",
   "main": "dist/launch.js",
   "bin": {
-    "launch-unity": "dist/launch.js",
-    "quit-unity": "dist/quit.js"
+    "launch-unity": "dist/launch.js"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",