launch-unity 0.2.1 → 0.3.0

package/dist/launch.js

@@ -3,33 +3,88 @@
   launch-unity: Open a Unity project with the matching Editor version.
   Platforms: macOS, Windows
 */
-import { spawn } from "node:child_process";
-import { existsSync, readFileSync, rmSync, createReadStream, createWriteStream } from "node:fs";
+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 readline from "node:readline";
+import { promisify } from "node:util";
+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 defaultProjectPath = process.cwd();
     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 = [];
-    for (const arg of cliArgs) {
+    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);
         }
-        else if (arg.startsWith("-")) {
-            // Unknown flags are ignored to keep CLI permissive
+        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 {
-            positionals.push(arg);
+            // Treat as platform when path does not exist
+            projectPath = undefined; // trigger search
+            platform = String(first);
         }
     }
-    const projectPath = positionals[0] ? resolve(positionals[0]) : defaultProjectPath;
-    const platform = positionals[1] ? String(positionals[1]) : undefined;
-    const options = { projectPath, platform, unityArgs };
+    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() {
@@ -47,7 +102,8 @@ Forwarding:
   If UNITY_ARGS includes -buildTarget, the PLATFORM argument is ignored.
 
 Flags:
-  -h, --help    Show this help message
+  -h, --help          Show this help message
+  --max-depth <N>     Search depth when PROJECT_PATH is omitted (default 3, -1 unlimited)
 `;
     process.stdout.write(help);
 }
@@ -72,8 +128,9 @@ function getUnityPathWindows(version) {
     const programFilesX86 = process.env["PROGRAMFILES(X86)"];
     const localAppData = process.env["LOCALAPPDATA"];
     const addCandidate = (base) => {
-        if (!base)
+        if (!base) {
             return;
+        }
         candidates.push(join(base, "Unity", "Hub", "Editor", version, "Editor", "Unity.exe"));
     };
     addCandidate(programFiles);
@@ -81,8 +138,9 @@ function getUnityPathWindows(version) {
     addCandidate(localAppData);
     candidates.push(join("C:\\", "Program Files", "Unity", "Hub", "Editor", version, "Editor", "Unity.exe"));
     for (const candidate of candidates) {
-        if (existsSync(candidate))
+        if (existsSync(candidate)) {
             return candidate;
+        }
     }
     return candidates[0] ?? join("C:\\", "Program Files", "Unity", "Hub", "Editor", version, "Editor", "Unity.exe");
 }
@@ -101,140 +159,319 @@ function ensureProjectPath(projectPath) {
         process.exit(1);
     }
 }
-function createPromptInterface() {
-    if (process.stdin.isTTY && process.stdout.isTTY) {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        const close = () => rl.close();
-        return { rl, close };
+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;
+}
+async function listUnityProcessesMac() {
+    let stdout = "";
     try {
-        if (process.platform === "win32") {
-            const inCandidates = ["\\\\.\\CONIN$", "CONIN$"];
-            const outCandidates = ["\\\\.\\CONOUT$", "CONOUT$"];
-            for (const inPath of inCandidates) {
-                for (const outPath of outCandidates) {
-                    try {
-                        const input = createReadStream(inPath);
-                        const output = createWriteStream(outPath);
-                        const rl = readline.createInterface({ input, output });
-                        const close = () => {
-                            rl.close();
-                            input.destroy();
-                            output.end();
-                        };
-                        return { rl, close };
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-            }
+        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;
         }
-        else {
-            const input = createReadStream("/dev/tty");
-            const output = createWriteStream("/dev/tty");
-            const rl = readline.createInterface({ input, output });
-            const close = () => {
-                rl.close();
-                input.destroy();
-                output.end();
-            };
-            return { rl, close };
+        const pidValue = Number.parseInt(match[1] ?? "", 10);
+        if (!Number.isFinite(pidValue)) {
+            continue;
         }
+        const command = match[2] ?? "";
+        if (!UNITY_EXECUTABLE_PATTERN_MAC.test(command)) {
+            continue;
+        }
+        const projectArgument = extractProjectPath(command);
+        if (!projectArgument) {
+            continue;
+        }
+        processes.push({
+            pid: pidValue,
+            projectPath: normalizePath(projectArgument),
+        });
     }
-    catch {
-        // fallthrough
-    }
-    return null;
+    return processes;
 }
-async function handleUnityLockfilePrompt(lockfilePath) {
-    // Prefer single-key confirmation when a real TTY is available
-    if (process.stdin.isTTY && process.stdout.isTTY && typeof process.stdin.setRawMode === "function") {
-        const confirmedByKey = await promptYesNoSingleKey("Delete UnityLockfile and continue? Type 'y' to continue; anything else aborts: ");
-        if (!confirmedByKey) {
-            console.log("Aborted by user.");
-            return false;
-        }
-        rmSync(lockfilePath, { force: true });
-        console.log("Deleted UnityLockfile. Continuing launch.");
-        return true;
-    }
-    // Fallback to line-based prompt through OS console handles
-    const prompt = createPromptInterface();
-    if (!prompt) {
-        console.error("UnityLockfile exists. No interactive console available for confirmation.");
-        return false;
+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 ?? "";
     }
-    const confirmed = await new Promise((resolve) => {
-        prompt.rl.question("Delete UnityLockfile and continue? Type 'y' to continue; anything else aborts: ", (answer) => {
-            resolve(answer.trim() === "y");
+    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;
+        }
+        const projectArgument = extractProjectPath(command);
+        if (!projectArgument) {
+            continue;
+        }
+        processes.push({
+            pid: pidValue,
+            projectPath: normalizePath(projectArgument),
         });
-    });
-    prompt.close();
-    if (!confirmed) {
-        console.log("Aborted by user.");
-        return false;
     }
-    rmSync(lockfilePath, { force: true });
-    console.log("Deleted UnityLockfile. Continuing launch.");
-    return true;
+    return processes;
 }
-function stdinSupportsRawMode() {
-    const stdin = process.stdin;
-    return Boolean(stdin && stdin.isTTY && typeof stdin.setRawMode === "function" && process.stdout.isTTY);
+async function listUnityProcesses() {
+    if (process.platform === "darwin") {
+        return await listUnityProcessesMac();
+    }
+    if (process.platform === "win32") {
+        return await listUnityProcessesWindows();
+    }
+    return [];
 }
-async function promptYesNoSingleKey(message) {
-    if (!stdinSupportsRawMode())
-        return false;
-    const stdin = process.stdin;
-    return await new Promise((resolve) => {
-        const handleData = (data) => {
-            const firstByte = data[0] ?? 0;
-            const char = data.toString();
-            let result = false;
-            if (char === "y") {
-                result = true;
-            }
-            else if (firstByte === 3 /* Ctrl+C */ || firstByte === 27 /* ESC */ || char === "n" || char === "N" || firstByte === 13 /* Enter */) {
-                result = false;
-            }
-            else {
-                result = false;
-            }
-            process.stdout.write("\n");
-            cleanup();
-            resolve(result);
-        };
-        const cleanup = () => {
-            if (typeof stdin.setRawMode === "function")
-                stdin.setRawMode(false);
-            stdin.pause();
-            stdin.removeListener("data", handleData);
-        };
-        process.stdout.write(message);
-        if (typeof stdin.setRawMode === "function")
-            stdin.setRawMode(true);
-        stdin.resume();
-        stdin.once("data", handleData);
-    });
+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 checkUnityRunning(projectPath) {
-    const lockfile = join(projectPath, "Temp", "UnityLockfile");
-    if (!existsSync(lockfile))
-        return true;
-    console.log(`UnityLockfile found: ${lockfile}`);
-    console.log("Another Unity process may be using this project.");
-    return await handleUnityLockfilePrompt(lockfile);
+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")
+        if (arg === "-buildTarget") {
             return true;
-        if (arg.startsWith("-buildTarget="))
+        }
+        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 (_err) {
+        // Ignore directories we cannot read
+        entries = [];
+    }
+    return entries;
+}
+function findUnityProjectBfs(rootDir, maxDepth) {
+    const queue = [];
+    let rootCanonical;
+    try {
+        rootCanonical = realpathSync(rootDir);
+    }
+    catch (_err) {
+        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 (_e) {
+                        // Broken symlink: skip
+                        continue;
+                    }
+                }
+            }
+            catch (_err) {
+                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);
@@ -260,13 +497,35 @@ function launch(opts) {
 }
 async function main() {
     const options = parseArgs(process.argv);
-    ensureProjectPath(options.projectPath);
-    const ok = await checkUnityRunning(options.projectPath);
-    if (!ok) {
+    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;
     }
-    launch(options);
+    await handleStaleLockfile(resolvedProjectPath);
+    const resolved = {
+        projectPath: resolvedProjectPath,
+        platform: options.platform,
+        unityArgs: options.unityArgs,
+    };
+    launch(resolved);
 }
 main().catch((error) => {
     console.error(error);

package/dist/quit.js

@@ -4,13 +4,17 @@
   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 = 15000;
-    let force = false;
+    let timeoutMs = defaultTimeoutMs;
+    let force = defaultForce;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i] ?? "";
         if (arg === "--help" || arg === "-h") {
@@ -27,7 +31,8 @@ function parseArgs(argv) {
                 console.error("Error: --timeout requires a millisecond value");
                 process.exit(1);
             }
-            const parsed = Number(value);
+            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);
@@ -106,7 +111,8 @@ function isProcessAlive(pid) {
 }
 async function waitForExit(pid, timeoutMs) {
     const start = Date.now();
-    const stepMs = 200;
+    const stepIntervalMs = 200;
+    const stepMs = stepIntervalMs;
     while (Date.now() - start < timeoutMs) {
         if (!isProcessAlive(pid))
             return true;
@@ -119,7 +125,7 @@ async function quitByPid(pid, force, timeoutMs) {
     try {
         process.kill(pid, "SIGTERM");
     }
-    catch (error) {
+    catch {
         // If process already exited, consider it success
         if (!isProcessAlive(pid))
             return true;
@@ -142,6 +148,19 @@ async function quitByPid(pid, force, timeoutMs) {
     // 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);
@@ -159,6 +178,7 @@ async function main() {
         return;
     }
     console.log("Unity has exited.");
+    await removeTempDirectory(options.projectPath);
 }
 main().catch((error) => {
     console.error(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "launch-unity",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Open a Unity project with the matching Editor version (macOS/Windows)",
   "type": "module",
   "main": "dist/launch.js",