launch-unity 0.11.0 → 0.13.0

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * launch-unity library entry point.
+ * Exports core functions for programmatic usage.
+ * Uses lib.ts which has no CLI side effects.
+ */
+export { LaunchOptions, LaunchResolvedOptions, UnityProcessInfo, parseArgs, findUnityProjectBfs, getUnityVersion, launch, findRunningUnityProcess, focusUnityProcess, killRunningUnity, handleStaleLockfile, ensureProjectEntryAndUpdate, updateLastModifiedIfExists, } from './lib.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEL,aAAa,EACb,qBAAqB,EACrB,gBAAgB,EAEhB,SAAS,EACT,mBAAmB,EACnB,eAAe,EACf,MAAM,EACN,uBAAuB,EACvB,iBAAiB,EACjB,gBAAgB,EAChB,mBAAmB,EACnB,2BAA2B,EAC3B,0BAA0B,GAC3B,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+/**
+ * launch-unity library entry point.
+ * Exports core functions for programmatic usage.
+ * Uses lib.ts which has no CLI side effects.
+ */
+export { 
+// Functions
+parseArgs, findUnityProjectBfs, getUnityVersion, launch, findRunningUnityProcess, focusUnityProcess, killRunningUnity, handleStaleLockfile, ensureProjectEntryAndUpdate, updateLastModifiedIfExists, } from './lib.js';

package/dist/launch.d.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+export type LaunchOptions = {
+    subcommand?: "update";
+    projectPath?: string;
+    platform?: string | undefined;
+    unityArgs: string[];
+    searchMaxDepth: number;
+    restart: boolean;
+    addUnityHub: boolean;
+    favoriteUnityHub: boolean;
+};
+export type LaunchResolvedOptions = {
+    projectPath: string;
+    platform?: string | undefined;
+    unityArgs: string[];
+    unityVersion: string;
+};
+export type UnityProcessInfo = {
+    pid: number;
+    projectPath: string;
+};
+export declare function parseArgs(argv: string[]): LaunchOptions;
+export declare function getUnityVersion(projectPath: string): string;
+export declare function findRunningUnityProcess(projectPath: string): Promise<UnityProcessInfo | undefined>;
+export declare function focusUnityProcess(pid: number): Promise<void>;
+export declare function handleStaleLockfile(projectPath: string): Promise<void>;
+export declare function killRunningUnity(projectPath: string): Promise<void>;
+export declare function findUnityProjectBfs(rootDir: string, maxDepth: number): string | undefined;
+export declare function launch(opts: LaunchResolvedOptions): Promise<void>;
+//# sourceMappingURL=launch.d.ts.map

package/dist/launch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"launch.d.ts","sourceRoot":"","sources":["../src/launch.ts"],"names":[],"mappings":";AAeA,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,CAAC,EAAE,QAAQ,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAyJF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAqHvD;AAyCD,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAe3D;AA2ND,wBAAsB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAIxG;AAED,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQlE;AA4CD,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB5E;AAiCD,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBzE;AAgDD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAqDzF;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiCvE"}

package/dist/launch.js

@@ -7,9 +7,9 @@ import { execFile, spawn } from "node:child_process";
 import { existsSync, readFileSync, readdirSync, lstatSync, realpathSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { promisify } from "node:util";
-import { ensureProjectEntryAndUpdate, updateLastModifiedIfExists } from "./unityHub.js";
+import { ensureProjectEntryAndUpdate, updateLastModifiedIfExists, getProjectCliArgs } 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;
@@ -130,7 +130,7 @@ const compareSemverTriplet = (left, right) => {
     }
     return 0;
 };
-function parseArgs(argv) {
+export function parseArgs(argv) {
     const args = argv.slice(2);
     const doubleDashIndex = args.indexOf("--");
     let cliArgs = doubleDashIndex >= 0 ? args.slice(0, doubleDashIndex) : args;
@@ -277,7 +277,7 @@ Commands:
 `;
     process.stdout.write(help);
 }
-function getUnityVersion(projectPath) {
+export function getUnityVersion(projectPath) {
     const versionFile = join(projectPath, "ProjectSettings", "ProjectVersion.txt");
     if (!existsSync(versionFile)) {
         console.error(`Error: ProjectVersion.txt not found at ${versionFile}`);
@@ -476,12 +476,12 @@ async function listUnityProcesses() {
     }
     return [];
 }
-async function findRunningUnityProcess(projectPath) {
+export async function findRunningUnityProcess(projectPath) {
     const normalizedTarget = normalizePath(projectPath);
     const processes = await listUnityProcesses();
     return processes.find((candidate) => pathsEqual(candidate.projectPath, normalizedTarget));
 }
-async function focusUnityProcess(pid) {
+export async function focusUnityProcess(pid) {
     if (process.platform === "darwin") {
         await focusUnityProcessMac(pid);
         return;
@@ -530,7 +530,7 @@ async function focusUnityProcessWindows(pid) {
         console.warn(`Failed to bring Unity to front on Windows: ${message}`);
     }
 }
-async function handleStaleLockfile(projectPath) {
+export async function handleStaleLockfile(projectPath) {
     const tempDirectoryPath = join(projectPath, TEMP_DIRECTORY_NAME);
     const lockfilePath = join(tempDirectoryPath, UNITY_LOCKFILE_NAME);
     if (!existsSync(lockfilePath)) {
@@ -584,7 +584,7 @@ async function waitForProcessExit(pid) {
     }
     return false;
 }
-async function killRunningUnity(projectPath) {
+export async function killRunningUnity(projectPath) {
     const processInfo = await findRunningUnityProcess(projectPath);
     if (!processInfo) {
         console.log("No running Unity process found for this project.");
@@ -643,7 +643,7 @@ function listSubdirectoriesSorted(dir) {
     }
     return entries;
 }
-function findUnityProjectBfs(rootDir, maxDepth) {
+export function findUnityProjectBfs(rootDir, maxDepth) {
     const queue = [];
     let rootCanonical;
     try {
@@ -695,7 +695,7 @@ function findUnityProjectBfs(rootDir, maxDepth) {
     }
     return undefined;
 }
-function launch(opts) {
+export async function launch(opts) {
     const { projectPath, platform, unityArgs, unityVersion } = opts;
     const unityPath = getUnityPath(unityVersion);
     console.log(`Detected Unity version: ${unityVersion}`);
@@ -711,6 +711,10 @@ function launch(opts) {
     if (platform && platform.length > 0 && !unityArgsContainBuildTarget) {
         args.push("-buildTarget", platform);
     }
+    const hubCliArgs = await getProjectCliArgs(projectPath);
+    if (hubCliArgs.length > 0) {
+        args.push(...hubCliArgs);
+    }
     if (unityArgs.length > 0) {
         args.push(...unityArgs);
     }
@@ -774,7 +778,7 @@ async function main() {
         unityArgs: options.unityArgs,
         unityVersion,
     };
-    launch(resolved);
+    await launch(resolved);
     // Best-effort update of Unity Hub's lastModified timestamp.
     const now = new Date();
     try {
@@ -838,7 +842,20 @@ async function runSelfUpdate() {
     }
     process.exit(1);
 }
-main().catch((error) => {
-    console.error(error);
-    process.exit(1);
-});
+// Only run main() when this file is executed directly (not when imported as a library)
+let isDirectExecution = false;
+if (typeof process.argv[1] === "string") {
+    try {
+        isDirectExecution =
+            import.meta.url === pathToFileURL(realpathSync(process.argv[1])).href;
+    }
+    catch {
+        isDirectExecution = false;
+    }
+}
+if (isDirectExecution) {
+    main().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/dist/lib.d.ts

@@ -0,0 +1,35 @@
+/**
+ * launch-unity core library functions.
+ * Pure library code without CLI entry point or side effects.
+ */
+import { ensureProjectEntryAndUpdate, updateLastModifiedIfExists, getProjectCliArgs, parseCliArgs } from "./unityHub.js";
+export type LaunchOptions = {
+    subcommand?: "update";
+    projectPath?: string;
+    platform?: string | undefined;
+    unityArgs: string[];
+    searchMaxDepth: number;
+    restart: boolean;
+    addUnityHub: boolean;
+    favoriteUnityHub: boolean;
+};
+export type LaunchResolvedOptions = {
+    projectPath: string;
+    platform?: string | undefined;
+    unityArgs: string[];
+    unityVersion: string;
+};
+export type UnityProcessInfo = {
+    pid: number;
+    projectPath: string;
+};
+export declare function parseArgs(argv: string[]): LaunchOptions;
+export declare function getUnityVersion(projectPath: string): string;
+export declare function findRunningUnityProcess(projectPath: string): Promise<UnityProcessInfo | undefined>;
+export declare function focusUnityProcess(pid: number): Promise<void>;
+export declare function handleStaleLockfile(projectPath: string): Promise<void>;
+export declare function killRunningUnity(projectPath: string): Promise<void>;
+export declare function findUnityProjectBfs(rootDir: string, maxDepth: number): string | undefined;
+export declare function launch(opts: LaunchResolvedOptions): Promise<void>;
+export { ensureProjectEntryAndUpdate, updateLastModifiedIfExists, getProjectCliArgs, parseCliArgs };
+//# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAEzH,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,CAAC,EAAE,QAAQ,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAYF,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAmHvD;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAc3D;AAoND,wBAAsB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAIxG;AAED,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQlE;AA4CD,wBAAsB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB5E;AAiCD,wBAAsB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBzE;AAgDD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAqDzF;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiCvE;AAGD,OAAO,EAAE,2BAA2B,EAAE,0BAA0B,EAAE,iBAAiB,EAAE,YAAY,EAAE,CAAC"}

package/dist/lib.js

@@ -0,0 +1,561 @@
+/**
+ * launch-unity core library functions.
+ * Pure library code without CLI entry point or side effects.
+ */
+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 { ensureProjectEntryAndUpdate, updateLastModifiedIfExists, getProjectCliArgs, parseCliArgs } 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";
+export function parseArgs(argv) {
+    const args = argv.slice(2);
+    const doubleDashIndex = args.indexOf("--");
+    let cliArgs = doubleDashIndex >= 0 ? args.slice(0, doubleDashIndex) : args;
+    const unityArgs = doubleDashIndex >= 0 ? args.slice(doubleDashIndex + 1) : [];
+    let subcommand;
+    const firstToken = cliArgs[0];
+    if (firstToken === "update") {
+        subcommand = "update";
+        cliArgs = cliArgs.slice(1);
+    }
+    const positionals = [];
+    let maxDepth = 3; // default 3; -1 means unlimited
+    let restart = false;
+    let addUnityHub = false;
+    let favoriteUnityHub = false;
+    let platform;
+    for (let i = 0; i < cliArgs.length; i++) {
+        const arg = cliArgs[i] ?? "";
+        if (arg === "--help" || arg === "-h") {
+            continue; // Skip help flag - caller should handle
+        }
+        if (arg === "--version" || arg === "-v") {
+            continue; // Skip version flag - caller should handle
+        }
+        if (arg === "-r" || arg === "--restart") {
+            restart = true;
+            continue;
+        }
+        if (arg === "-u" ||
+            arg === "-a" ||
+            arg === "--unity-hub-entry" ||
+            arg === "--add-unity-hub") {
+            addUnityHub = true;
+            continue;
+        }
+        if (arg === "-f" || arg === "--favorite") {
+            favoriteUnityHub = true;
+            continue;
+        }
+        if (arg === "-p" || arg === "--platform") {
+            const next = cliArgs[i + 1];
+            if (typeof next === "string" && !next.startsWith("-")) {
+                platform = next;
+                i += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith("--platform=")) {
+            const value = arg.slice("--platform=".length);
+            if (value.length > 0) {
+                platform = value;
+            }
+            continue;
+        }
+        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("-")) {
+            console.warn(`Warning: Unknown option ignored: ${arg}`);
+            continue;
+        }
+        positionals.push(arg);
+    }
+    let projectPath;
+    if (positionals.length > 0) {
+        projectPath = resolve(positionals[0] ?? "");
+    }
+    if (positionals.length > 1) {
+        const ignored = positionals.slice(1).join(", ");
+        console.warn(`Warning: Extra arguments ignored: ${ignored}`);
+        console.warn("  Use -p option for platform: launch-unity -p <platform>");
+    }
+    const options = {
+        unityArgs,
+        searchMaxDepth: maxDepth,
+        restart,
+        addUnityHub,
+        favoriteUnityHub,
+    };
+    if (subcommand) {
+        options.subcommand = subcommand;
+    }
+    if (projectPath !== undefined) {
+        options.projectPath = projectPath;
+    }
+    if (platform !== undefined) {
+        options.platform = platform;
+    }
+    return options;
+}
+export function getUnityVersion(projectPath) {
+    const versionFile = join(projectPath, "ProjectSettings", "ProjectVersion.txt");
+    if (!existsSync(versionFile)) {
+        throw new Error(`ProjectVersion.txt not found at ${versionFile}. This does not appear to be a Unity project.`);
+    }
+    const content = readFileSync(versionFile, "utf8");
+    const version = content.match(/m_EditorVersion:\s*([^\s\n]+)/)?.[1];
+    if (!version) {
+        throw new Error(`Could not extract Unity version from ${versionFile}`);
+    }
+    return version;
+}
+function getUnityPathWindows(version) {
+    const candidates = [];
+    const programFiles = process.env["PROGRAMFILES"];
+    const programFilesX86 = process.env["PROGRAMFILES(X86)"];
+    const localAppData = process.env["LOCALAPPDATA"];
+    const addCandidate = (base) => {
+        if (!base) {
+            return;
+        }
+        candidates.push(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`;
+}
+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 [];
+}
+export async function findRunningUnityProcess(projectPath) {
+    const normalizedTarget = normalizePath(projectPath);
+    const processes = await listUnityProcesses();
+    return processes.find((candidate) => pathsEqual(candidate.projectPath, normalizedTarget));
+}
+export 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}`);
+    }
+}
+export 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}`);
+    }
+}
+const KILL_POLL_INTERVAL_MS = 100;
+const KILL_TIMEOUT_MS = 10000;
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function killProcess(pid) {
+    try {
+        process.kill(pid, "SIGKILL");
+    }
+    catch {
+        // Process already exited
+    }
+}
+async function waitForProcessExit(pid) {
+    const start = Date.now();
+    while (Date.now() - start < KILL_TIMEOUT_MS) {
+        if (!isProcessAlive(pid)) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, KILL_POLL_INTERVAL_MS));
+    }
+    return false;
+}
+export async function killRunningUnity(projectPath) {
+    const processInfo = await findRunningUnityProcess(projectPath);
+    if (!processInfo) {
+        console.log("No running Unity process found for this project.");
+        return;
+    }
+    const pid = processInfo.pid;
+    console.log(`Killing Unity (PID: ${pid})...`);
+    killProcess(pid);
+    const exited = await waitForProcessExit(pid);
+    if (!exited) {
+        throw new Error(`Failed to kill Unity (PID: ${pid}) within ${KILL_TIMEOUT_MS / 1000}s.`);
+    }
+    console.log("Unity killed.");
+}
+function hasBuildTargetArg(unityArgs) {
+    for (const arg of unityArgs) {
+        if (arg === "-buildTarget") {
+            return true;
+        }
+        if (arg.startsWith("-buildTarget=")) {
+            return true;
+        }
+    }
+    return false;
+}
+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");
+    return existsSync(versionFile);
+}
+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;
+}
+export 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;
+}
+export async function launch(opts) {
+    const { projectPath, platform, unityArgs, unityVersion } = opts;
+    const unityPath = getUnityPath(unityVersion);
+    console.log(`Detected Unity version: ${unityVersion}`);
+    if (!existsSync(unityPath)) {
+        throw new Error(`Unity ${unityVersion} not found at ${unityPath}. Please install Unity through Unity Hub.`);
+    }
+    console.log("Opening Unity...");
+    console.log(`Project Path: ${projectPath}`);
+    const args = ["-projectPath", projectPath];
+    const unityArgsContainBuildTarget = hasBuildTargetArg(unityArgs);
+    if (platform && platform.length > 0 && !unityArgsContainBuildTarget) {
+        args.push("-buildTarget", platform);
+    }
+    const hubCliArgs = await getProjectCliArgs(projectPath);
+    if (hubCliArgs.length > 0) {
+        args.push(...hubCliArgs);
+    }
+    if (unityArgs.length > 0) {
+        args.push(...unityArgs);
+    }
+    const child = spawn(unityPath, args, { stdio: "ignore", detached: true });
+    child.unref();
+}
+// Re-export Unity Hub functions
+export { ensureProjectEntryAndUpdate, updateLastModifiedIfExists, getProjectCliArgs, parseCliArgs };

package/dist/unityHub.d.ts

@@ -0,0 +1,5 @@
+export declare const ensureProjectEntryAndUpdate: (projectPath: string, version: string, when: Date, setFavorite?: boolean) => Promise<void>;
+export declare const updateLastModifiedIfExists: (projectPath: string, when: Date) => Promise<void>;
+export declare const parseCliArgs: (cliArgsString: string) => string[];
+export declare const getProjectCliArgs: (projectPath: string) => Promise<string[]>;
+//# sourceMappingURL=unityHub.d.ts.map

package/dist/unityHub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unityHub.d.ts","sourceRoot":"","sources":["../src/unityHub.ts"],"names":[],"mappings":"AAwFA,eAAO,MAAM,2BAA2B,GACtC,aAAa,MAAM,EACnB,SAAS,MAAM,EACf,MAAM,IAAI,EACV,qBAAmB,KAClB,OAAO,CAAC,IAAI,CAgEd,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACrC,aAAa,MAAM,EACnB,MAAM,IAAI,KACT,OAAO,CAAC,IAAI,CAuDd,CAAC;AAoBF,eAAO,MAAM,YAAY,GAAI,eAAe,MAAM,KAAG,MAAM,EA6C1D,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,MAAM,EAAE,CA8C7E,CAAC"}

package/dist/unityHub.js

@@ -1,6 +1,7 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { realpathSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
+import assert from "node:assert";
 const resolveUnityHubProjectFiles = () => {
     if (process.platform === "darwin") {
         const home = process.env.HOME;
@@ -168,3 +169,99 @@ export const updateLastModifiedIfExists = async (projectPath, when) => {
         return;
     }
 };
+const resolveUnityHubProjectsInfoFile = () => {
+    if (process.platform === "darwin") {
+        const home = process.env.HOME;
+        if (!home) {
+            return undefined;
+        }
+        return join(home, "Library", "Application Support", "UnityHub", "projectsInfo.json");
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA;
+        if (!appData) {
+            return undefined;
+        }
+        return join(appData, "UnityHub", "projectsInfo.json");
+    }
+    return undefined;
+};
+export const parseCliArgs = (cliArgsString) => {
+    assert(cliArgsString !== null && cliArgsString !== undefined, "cliArgsString must not be null");
+    const trimmed = cliArgsString.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    const tokens = [];
+    let current = "";
+    let inQuote = null;
+    for (const char of trimmed) {
+        if (inQuote !== null) {
+            if (char === inQuote) {
+                tokens.push(current);
+                current = "";
+                inQuote = null;
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inQuote = char;
+            continue;
+        }
+        if (char === " ") {
+            if (current.length > 0) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current.length > 0) {
+        tokens.push(current);
+    }
+    return tokens;
+};
+export const getProjectCliArgs = async (projectPath) => {
+    assert(projectPath !== null && projectPath !== undefined, "projectPath must not be null");
+    const infoFilePath = resolveUnityHubProjectsInfoFile();
+    if (!infoFilePath) {
+        logDebug("projectsInfo.json path could not be resolved.");
+        return [];
+    }
+    logDebug(`Reading projectsInfo.json: ${infoFilePath}`);
+    let content;
+    try {
+        content = await readFile(infoFilePath, "utf8");
+    }
+    catch {
+        logDebug("projectsInfo.json not found or not readable.");
+        return [];
+    }
+    let json;
+    try {
+        json = JSON.parse(content);
+    }
+    catch {
+        logDebug("projectsInfo.json parse failed.");
+        return [];
+    }
+    const normalizedProjectPath = normalizePath(projectPath);
+    const projectKey = Object.keys(json).find((key) => pathsEqual(key, normalizedProjectPath));
+    if (!projectKey) {
+        logDebug(`No entry found for project: ${normalizedProjectPath}`);
+        return [];
+    }
+    const projectInfo = json[projectKey];
+    const cliArgsString = projectInfo?.cliArgs;
+    if (!cliArgsString || cliArgsString.trim().length === 0) {
+        logDebug("cliArgs is empty or not defined.");
+        return [];
+    }
+    const parsed = parseCliArgs(cliArgsString);
+    logDebug(`Parsed Unity Hub cliArgs: ${JSON.stringify(parsed)}`);
+    return parsed;
+};

package/package.json

@@ -1,9 +1,16 @@
 {
   "name": "launch-unity",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Open a Unity project with the matching Editor version (macOS/Windows)",
   "type": "module",
-  "main": "dist/launch.js",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "bin": {
     "launch-unity": "dist/launch.js"
   },
@@ -38,16 +45,16 @@
     "node": ">=18"
   },
   "devDependencies": {
-    "@types/node": "25.0.6",
-    "@typescript-eslint/eslint-plugin": "8.53.0",
-    "@typescript-eslint/parser": "8.53.0",
+    "@types/node": "25.2.0",
+    "@typescript-eslint/eslint-plugin": "8.54.0",
+    "@typescript-eslint/parser": "8.54.0",
     "eslint": "9.39.2",
     "eslint-config-prettier": "10.1.8",
-    "prettier": "3.7.4",
+    "prettier": "3.8.1",
     "typescript": "5.9.3"
   },
   "dependencies": {
-    "typescript-eslint": "8.53.0"
+    "typescript-eslint": "8.54.0"
   },
   "overrides": {
     "js-yaml": "4.1.1"