launch-unity 0.6.0 → 0.6.1

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/quit.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+/*
+  quit-unity: Quit the Unity Editor instance that has the specified project open.
+  Platforms: macOS, Windows
+*/
+import { existsSync, readFileSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+const TEMP_DIRECTORY_NAME = "Temp";
+function parseArgs(argv) {
+    const defaultProjectPath = process.cwd();
+    const defaultTimeoutMs = 15000;
+    const defaultForce = false;
+    const args = argv.slice(2);
+    let projectPath = defaultProjectPath;
+    let timeoutMs = defaultTimeoutMs;
+    let force = defaultForce;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] ?? "";
+        if (arg === "--help" || arg === "-h") {
+            printHelp();
+            process.exit(0);
+        }
+        if (arg === "--force" || arg === "-f") {
+            force = true;
+            continue;
+        }
+        if (arg === "--timeout" || arg === "-t") {
+            const value = args[i + 1];
+            if (!value || value.startsWith("-")) {
+                console.error("Error: --timeout requires a millisecond value");
+                process.exit(1);
+            }
+            const parsedValue = Number(value);
+            const parsed = parsedValue;
+            if (!Number.isFinite(parsed) || parsed < 0) {
+                console.error("Error: --timeout must be a non-negative number (milliseconds)");
+                process.exit(1);
+            }
+            timeoutMs = parsed;
+            i++;
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            // Unknown flags are ignored to keep CLI permissive
+            continue;
+        }
+        // First positional = project path
+        projectPath = resolve(arg);
+    }
+    return { projectPath, timeoutMs, force };
+}
+function printHelp() {
+    const help = `
+Usage: quit-unity [PROJECT_PATH] [--timeout <ms>] [--force]
+
+Quit the Unity Editor instance that has PROJECT_PATH open.
+
+Arguments:
+  PROJECT_PATH        Optional. Defaults to current directory
+
+Flags:
+  -t, --timeout <ms>  Time to wait for graceful quit (default: 15000)
+  -f, --force         Force kill if not exited within timeout
+  -h, --help          Show this help message
+`;
+    process.stdout.write(help);
+}
+function ensureProjectPath(projectPath) {
+    if (!existsSync(projectPath)) {
+        console.error(`Error: Project directory not found: ${projectPath}`);
+        process.exit(1);
+    }
+}
+function readPidFromEditorInstance(projectPath) {
+    const editorInstancePath = join(projectPath, "Library", "EditorInstance.json");
+    if (!existsSync(editorInstancePath))
+        return null;
+    try {
+        const content = readFileSync(editorInstancePath, "utf8");
+        const data = JSON.parse(content);
+        const candidateKeys = [
+            "process_id",
+            "processId",
+            "processID",
+            "pid",
+            "PID",
+        ];
+        for (const key of candidateKeys) {
+            const value = data[key];
+            if (typeof value === "number" && Number.isFinite(value))
+                return value;
+            if (typeof value === "string" && /^\d+$/.test(value))
+                return Number(value);
+        }
+    }
+    catch {
+        // fallthrough
+    }
+    return null;
+}
+function isProcessAlive(pid) {
+    try {
+        // signal 0: does not actually send a signal, just tests for existence/permissions
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForExit(pid, timeoutMs) {
+    const start = Date.now();
+    const stepIntervalMs = 200;
+    const stepMs = stepIntervalMs;
+    while (Date.now() - start < timeoutMs) {
+        if (!isProcessAlive(pid))
+            return true;
+        await new Promise((r) => setTimeout(r, stepMs));
+    }
+    return !isProcessAlive(pid);
+}
+async function quitByPid(pid, force, timeoutMs) {
+    // Try graceful first
+    try {
+        process.kill(pid, "SIGTERM");
+    }
+    catch {
+        // If process already exited, consider it success
+        if (!isProcessAlive(pid))
+            return true;
+        // If we cannot send the signal and the process is alive, escalate when force is true
+        if (!force)
+            return false;
+    }
+    const graceful = await waitForExit(pid, timeoutMs);
+    if (graceful)
+        return true;
+    if (!force)
+        return false;
+    // Force kill
+    try {
+        process.kill(pid, "SIGKILL");
+    }
+    catch {
+        // ignore
+    }
+    // Give a short moment after force
+    return await waitForExit(pid, 2000);
+}
+async function removeTempDirectory(projectPath) {
+    const tempDirectoryPath = join(projectPath, TEMP_DIRECTORY_NAME);
+    if (!existsSync(tempDirectoryPath))
+        return;
+    try {
+        await rm(tempDirectoryPath, { recursive: true, force: true });
+        console.log(`Deleted Temp directory: ${tempDirectoryPath}`);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`Failed to delete Temp directory: ${message}`);
+    }
+}
+async function main() {
+    const options = parseArgs(process.argv);
+    ensureProjectPath(options.projectPath);
+    const pid = readPidFromEditorInstance(options.projectPath);
+    if (pid === null) {
+        console.error("Error: Could not find Unity PID. Is this project currently open in Unity? (Missing Library/EditorInstance.json)");
+        process.exit(1);
+        return;
+    }
+    console.log(`Attempting to quit Unity (pid: ${pid}) for project: ${options.projectPath}`);
+    const ok = await quitByPid(pid, options.force, options.timeoutMs);
+    if (!ok) {
+        console.error(`Failed to quit Unity (pid: ${pid}) within ${options.timeoutMs}ms.${options.force ? "" : " Try --force."}`);
+        process.exit(1);
+        return;
+    }
+    console.log("Unity has exited.");
+    await removeTempDirectory(options.projectPath);
+}
+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,6 +1,6 @@
 {
   "name": "launch-unity",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Open a Unity project with the matching Editor version (macOS/Windows)",
   "type": "module",
   "main": "dist/launch.js",