@notask/unity-cli-tools 1.0.0

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": false,
+  "printWidth": 120,
+  "tabWidth": 2,
+  "endOfLine": "lf"
+}

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# 1.0.0 (2025-04-22)
+
+
+### Bug Fixes
+
+* **Hub:** Renaming the 'moduleId' parameter to 'modules' ([50384f4](https://github.com/NoTaskStudios/unity-cli-tools/commit/50384f41a2c58a18e2da135ffa5ae357a6e20ca7))
+
+
+### Features
+
+* **Command:** Add a command executor on top execa ([8c25801](https://github.com/NoTaskStudios/unity-cli-tools/commit/8c25801f9a866a92bc95ebed9aa556c8a5574ede))
+* **Hub:** Add unity hub command line by code ([bffbdba](https://github.com/NoTaskStudios/unity-cli-tools/commit/bffbdbaf24bb505482ab51d47214f1e9c5e7942c))
+* **Types:** Add unity types for hub and editor ([23a7b41](https://github.com/NoTaskStudios/unity-cli-tools/commit/23a7b4172f5d3b80876aaf043b961759cbe4274c))
+
+# 1.0.0-rc.1 (2025-04-22)
+
+
+### Bug Fixes
+
+* **Hub:** Renaming the 'moduleId' parameter to 'modules' ([50384f4](https://github.com/NoTaskStudios/unity-cli-tools/commit/50384f41a2c58a18e2da135ffa5ae357a6e20ca7))
+
+
+### Features
+
+* **Command:** Add a command executor on top execa ([8c25801](https://github.com/NoTaskStudios/unity-cli-tools/commit/8c25801f9a866a92bc95ebed9aa556c8a5574ede))
+* **Hub:** Add unity hub command line by code ([bffbdba](https://github.com/NoTaskStudios/unity-cli-tools/commit/bffbdbaf24bb505482ab51d47214f1e9c5e7942c))
+* **Types:** Add unity types for hub and editor ([23a7b41](https://github.com/NoTaskStudios/unity-cli-tools/commit/23a7b4172f5d3b80876aaf043b961759cbe4274c))
+
+# Changelog
+
+All notable changes to this project will be documented in this file.

package/LICENSE

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2022-2025 NoTask Studios, LTD.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the
+Software), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED AS
+IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,194 @@
+# Unity Command line Tools
+
+A TypeScript library for programmatically interacting with Unity Hub and Unity Editor command line interfaces.
+
+## Installation
+
+```bash
+npm install unity-cli-tools
+```
+
+## Dual Module Support
+
+This package publishes separate builds for both ES Modules (ESM) and CommonJS (CJS). You can consume it either way:
+
+**ESM** (Node and bundlers):
+```ts
+import { UnityHub } from "@notask/unity-cli-tools";
+```
+
+**CJS**:
+```js
+const { UnityHub } = require("@notask/unity-cli-tools");
+```
+
+## Requirements
+
+- Node.js 20+
+- Unity Hub installed
+- Unity Editor (for editor operations)
+
+## Core Concepts
+
+Unity CLI Tools provides two main modules:
+
+- `UnityHub` - For interacting with Unity Hub
+- `UnityEditor` - For interacting with Unity Editor (documentation coming soon)
+
+## UnityHub API Reference
+
+### Checking Availability
+
+```typescript
+import { UnityHub } from "unity-cli-tools";
+
+// Check if Unity Hub is available
+const isAvailable = await UnityHub.isUnityHubAvailable();
+```
+
+### Finding Unity Installations
+
+```typescript
+// Get all installed Unity versions
+const installations = await UnityHub.getUnityInstallations();
+// Returns: { '2022.3.60f1': 'C:/Program Files/Unity/Hub/Editor/2022.3.60f1', ... }
+```
+
+### Managing Unity Versions
+
+```typescript
+import { UnityHub, UnityModules } from "unity-cli-tools";
+
+// Install a new Unity version
+await UnityHub.addEditor("2022.3.60f1");
+
+// Install with specific modules
+await UnityHub.addEditor("2022.3.60f1", undefined, [UnityModules.AndroidBuildSupport, UnityModules.WebGLBuildSupport]);
+
+// Add modules to existing installation
+await UnityHub.addModule("2022.3.60f1", [UnityModules.IOSBuildSupport]);
+```
+
+### Projects Management
+
+```typescript
+// Get projects from Unity Hub
+const projects = await UnityHub.getProjects();
+// Returns: [{ name: 'ProjectName', path: '/path/to/project', version: '2022.3.60f1' }, ...]
+
+// Get default projects directory
+const defaultDir = await UnityHub.getDefaultProjectsDirectory();
+```
+
+### Custom Commands
+
+```typescript
+// Execute any Hub command directly
+const result = await UnityHub.execUnityHubCommand(["editors", "-r"]);
+console.log(result.stdout);
+```
+
+## Available Constants
+
+### UnityModules
+
+| Constant                   | Description               |
+| -------------------------- | ------------------------- |
+| `Documentation`            | Unity documentation       |
+| `AndroidBuildSupport`      | Android platform support  |
+| `AndroidSDKNDKTools`       | Android SDK/NDK tools     |
+| `OpenJDK`                  | Java Development Kit      |
+| `IOSBuildSupport`          | iOS platform support      |
+| `TvOSBuildSupport`         | tvOS platform support     |
+| `LinuxBuildSupportMono`    | Linux Mono support        |
+| `LinuxBuildSupportIL2CPP`  | Linux IL2CPP support      |
+| `WebGLBuildSupport`        | WebGL platform support    |
+| `WindowsBuildSupport`      | Windows platform support  |
+| `VuforiaAR`                | Vuforia AR support        |
+| `WindowsBuildSupportMono`  | Windows Mono support      |
+| `LuminBuildSupport`        | Magic Leap support        |
+| `VisualStudioCommunity`    | Visual Studio integration |
+| `MacBuildSupportMono`      | macOS Mono support        |
+| `MacBuildSupportIL2CPP`    | macOS IL2CPP support      |
+| `UniversalWindowsPlatform` | UWP support               |
+| `UWPBuildSupportIL2CPP`    | UWP IL2CPP support        |
+| `UWPBuildSupportDotNet`    | UWP .NET support          |
+
+### UnityLanguages
+
+| Constant             | Description                       |
+| -------------------- | --------------------------------- |
+| `Japanese`           | Japanese language pack            |
+| `Korean`             | Korean language pack              |
+| `ChineseSimplified`  | Simplified Chinese language pack  |
+| `ChineseTraditional` | Traditional Chinese language pack |
+| `Chinese`            | Chinese language pack (legacy)    |
+
+
+## Configuration
+
+### Environment Variables
+
+- `UNITY_HUB_PATH` - Custom path to Unity Hub executable
+
+### Platform Detection
+
+The library automatically detects and uses the correct paths for:
+
+- Windows
+- macOS
+- Linux
+
+## Examples
+
+### Complete Unity Hub Workflow
+
+```typescript
+import { UnityHub, UnityModules } from "unity-cli-tools";
+
+async function manageUnityInstallation() {
+  try {
+    // Check if hub is available
+    const isAvailable = await UnityHub.isUnityHubAvailable();
+    if (!isAvailable) {
+      console.error("Unity Hub not found");
+      return;
+    }
+
+    // List installations
+    const installations = await UnityHub.getUnityInstallations();
+    console.log("Installed versions:", Object.keys(installations));
+
+    // Install WebGL support for specific version
+    if (installations["2022.3.60f1"]) {
+      await UnityHub.addModule("2022.3.60f1", [UnityModules.WebGLBuildSupport]);
+      console.log("WebGL support added");
+    }
+
+    // Get recent projects
+    const projects = await UnityHub.getProjects();
+    console.log(
+      "Recent projects:",
+      projects.map((p) => p.name)
+    );
+  } catch (error) {
+    console.error("Error in Unity workflow:", error);
+  }
+}
+```
+
+## Advanced Usage
+
+### Custom Command Execution
+
+```typescript
+// List all editors with detailed output
+const result = await UnityHub.execUnityHubCommand(["editors", "-a"], {
+  reject: true, // Throw error on failure
+  timeout: 30000, // 30 second timeout
+  env: { UNITY_HUB_VERBOSE: "1" }, // Custom environment variables
+});
+
+// Process output
+const editorList = result.stdout.split("\n").filter((line) => line.includes("Unity Version"));
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { default as UnityHub } from "./unityHub.ts";
+export * from "./types/unity.ts";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { default as UnityHub } from "./unityHub.js";
+export * from "./types/unity.js";

package/dist/types/unity.d.ts

@@ -0,0 +1,91 @@
+export type UnityEditorInfo = Record<string, string>;
+export interface UnityHubProject {
+    title: string;
+    lastModified: number;
+    isCustomEditor: boolean;
+    path: string;
+    containingFolderPath: string;
+    version: string;
+    architecture: string;
+    changeset: string;
+    isFavorite: boolean;
+    localProjectId: string;
+    cloudEnabled: boolean;
+}
+export interface UnityHubProjectsList {
+    data: UnityHubProject[];
+}
+export declare enum UnityModules {
+    Documentation = "documentation",
+    AndroidBuildSupport = "android",
+    AndroidSDKNDKTools = "android-sdk-ndk-tools",
+    OpenJDK = "android-open-jdk",
+    IOSBuildSupport = "ios",
+    TvOSBuildSupport = "appletv",
+    LinuxBuildSupportMono = "linux-mono",
+    LinuxBuildSupportIL2CPP = "linux-il2cpp",
+    WebGLBuildSupport = "webgl",
+    WindowsBuildSupport = "windows",
+    VuforiaAR = "vuforia-ar",
+    WindowsBuildSupportMono = "windows-mono",
+    LuminBuildSupport = "lumin",
+    VisualStudioCommunity = "visualstudio",
+    MacBuildSupportMono = "mac-mono",
+    MacBuildSupportIL2CPP = "mac-il2cpp",
+    UniversalWindowsPlatform = "universal-windows-platform",
+    UWPBuildSupportIL2CPP = "uwp-il2cpp",
+    UWPBuildSupportDotNet = "uwp-.net"
+}
+export declare enum UnityLanguages {
+    Japanese = "language-ja",
+    Korean = "language-ko",
+    ChineseSimplified = "language-zh-hans",
+    ChineseTraditional = "language-zh-hant",
+    Chinese = "language-zh-cn"
+}
+export declare enum EditorArchitecture {
+    x86_64 = "x86_64",
+    arm64 = "arm64"
+}
+export type ModuleId = UnityModules | UnityLanguages;
+export type UnityInstallations = Record<string, string>;
+export interface ProjectInfo {
+    path: string;
+    editorVersion: string;
+    projectName: string;
+    scenes?: string[];
+}
+export interface ProjectSettings {
+    companyName?: string;
+    productName?: string;
+    bundleVersion?: string;
+}
+export declare enum TestMode {
+    EditMode = "editmode",
+    PlayMode = "playmode"
+}
+export declare enum UnityBuildTarget {
+    StandaloneOSX = "StandaloneOSX",
+    StandaloneWindows = "StandaloneWindows",
+    iOS = "iOS",
+    Android = "Android",
+    StandaloneWindows64 = "StandaloneWindows64",
+    WebGL = "WebGL",
+    WSAPlayer = "WSAPlayer",
+    StandaloneLinux64 = "StandaloneLinux64",
+    PS4 = "PS4",
+    XboxOne = "XboxOne",
+    tvOS = "tvOS",
+    Switch = "Switch",
+    LinuxHeadlessSimulation = "LinuxHeadlessSimulation",
+    PS5 = "PS5",
+    VisionOS = "VisionOS"
+}
+export interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    type: string;
+    revision: number;
+    original: string;
+}

package/dist/types/unity.js

@@ -0,0 +1,58 @@
+export var UnityModules;
+(function (UnityModules) {
+    UnityModules["Documentation"] = "documentation";
+    UnityModules["AndroidBuildSupport"] = "android";
+    UnityModules["AndroidSDKNDKTools"] = "android-sdk-ndk-tools";
+    UnityModules["OpenJDK"] = "android-open-jdk";
+    UnityModules["IOSBuildSupport"] = "ios";
+    UnityModules["TvOSBuildSupport"] = "appletv";
+    UnityModules["LinuxBuildSupportMono"] = "linux-mono";
+    UnityModules["LinuxBuildSupportIL2CPP"] = "linux-il2cpp";
+    UnityModules["WebGLBuildSupport"] = "webgl";
+    UnityModules["WindowsBuildSupport"] = "windows";
+    UnityModules["VuforiaAR"] = "vuforia-ar";
+    UnityModules["WindowsBuildSupportMono"] = "windows-mono";
+    UnityModules["LuminBuildSupport"] = "lumin";
+    UnityModules["VisualStudioCommunity"] = "visualstudio";
+    UnityModules["MacBuildSupportMono"] = "mac-mono";
+    UnityModules["MacBuildSupportIL2CPP"] = "mac-il2cpp";
+    UnityModules["UniversalWindowsPlatform"] = "universal-windows-platform";
+    UnityModules["UWPBuildSupportIL2CPP"] = "uwp-il2cpp";
+    UnityModules["UWPBuildSupportDotNet"] = "uwp-.net";
+})(UnityModules || (UnityModules = {}));
+export var UnityLanguages;
+(function (UnityLanguages) {
+    UnityLanguages["Japanese"] = "language-ja";
+    UnityLanguages["Korean"] = "language-ko";
+    UnityLanguages["ChineseSimplified"] = "language-zh-hans";
+    UnityLanguages["ChineseTraditional"] = "language-zh-hant";
+    UnityLanguages["Chinese"] = "language-zh-cn";
+})(UnityLanguages || (UnityLanguages = {}));
+export var EditorArchitecture;
+(function (EditorArchitecture) {
+    EditorArchitecture["x86_64"] = "x86_64";
+    EditorArchitecture["arm64"] = "arm64";
+})(EditorArchitecture || (EditorArchitecture = {}));
+export var TestMode;
+(function (TestMode) {
+    TestMode["EditMode"] = "editmode";
+    TestMode["PlayMode"] = "playmode";
+})(TestMode || (TestMode = {}));
+export var UnityBuildTarget;
+(function (UnityBuildTarget) {
+    UnityBuildTarget["StandaloneOSX"] = "StandaloneOSX";
+    UnityBuildTarget["StandaloneWindows"] = "StandaloneWindows";
+    UnityBuildTarget["iOS"] = "iOS";
+    UnityBuildTarget["Android"] = "Android";
+    UnityBuildTarget["StandaloneWindows64"] = "StandaloneWindows64";
+    UnityBuildTarget["WebGL"] = "WebGL";
+    UnityBuildTarget["WSAPlayer"] = "WSAPlayer";
+    UnityBuildTarget["StandaloneLinux64"] = "StandaloneLinux64";
+    UnityBuildTarget["PS4"] = "PS4";
+    UnityBuildTarget["XboxOne"] = "XboxOne";
+    UnityBuildTarget["tvOS"] = "tvOS";
+    UnityBuildTarget["Switch"] = "Switch";
+    UnityBuildTarget["LinuxHeadlessSimulation"] = "LinuxHeadlessSimulation";
+    UnityBuildTarget["PS5"] = "PS5";
+    UnityBuildTarget["VisionOS"] = "VisionOS";
+})(UnityBuildTarget || (UnityBuildTarget = {}));

package/dist/unityHub.d.ts

@@ -0,0 +1,26 @@
+import { EditorArchitecture, ModuleId, UnityInstallations, UnityLanguages, UnityModules } from "./types/unity.js";
+import { CommandOptions, CommandResult } from "./utils/commandExecutor.js";
+declare class UnityHub {
+    private static CONFIG_PATHS;
+    static readonly Modules: typeof UnityModules;
+    static readonly Languages: typeof UnityLanguages;
+    private static platform;
+    private static hubPath;
+    private static getUnityHubPath;
+    private static getProjectsPath;
+    private static getProjectDirPath;
+    static isUnityHubAvailable(): Promise<boolean>;
+    static execUnityHubCommand(args: string[], options?: CommandOptions): Promise<CommandResult>;
+    static getInstallPath(): Promise<string>;
+    static setInstallPath(path: string): Promise<void>;
+    static getUnityInstallations(): Promise<UnityInstallations>;
+    static addModule(editorVersion: string, modules: ModuleId[], childModules?: boolean): Promise<void>;
+    static addEditor(version: string, changeset?: string, modules?: ModuleId[], architecture?: EditorArchitecture): Promise<void>;
+    static getProjects(): Promise<{
+        name: string;
+        path: string;
+        version: string;
+    }[]>;
+    static getDefaultProjectsDirectory(): Promise<string | null>;
+}
+export default UnityHub;

package/dist/unityHub.js

@@ -0,0 +1,208 @@
+import fs from "fs-extra";
+import os from "os";
+import path from "path";
+import { EditorArchitecture, UnityLanguages, UnityModules, } from "./types/unity.js";
+import { executeCommand } from "./utils/commandExecutor.js";
+class UnityHub {
+    static CONFIG_PATHS = {
+        win32: {
+            hub: "C:\\Program Files\\Unity Hub\\Unity Hub.exe",
+            projects: path.join(os.homedir(), "AppData", "Roaming", "UnityHub", "projects-v1.json"),
+            projectDir: path.join(os.homedir(), "AppData", "Roaming", "UnityHub", "projectDir.json"),
+        },
+        darwin: {
+            hub: "/Applications/Unity Hub.app/Contents/MacOS/Unity Hub",
+            projects: path.join(os.homedir(), "Library", "Application Support", "UnityHub", "projects-v1.json"),
+            projectDir: path.join(os.homedir(), "Library", "Application Support", "UnityHub", "projectDir.json"),
+        },
+        linux: {
+            hub: "/opt/UnityHub/UnityHub",
+            projects: path.join(os.homedir(), ".config", "UnityHub", "projects-v1.json"),
+            projectDir: path.join(os.homedir(), ".config", "UnityHub", "projectDir.json"),
+        },
+    };
+    static Modules = UnityModules;
+    static Languages = UnityLanguages;
+    static platform = os.platform();
+    static hubPath = this.getUnityHubPath();
+    static getUnityHubPath() {
+        const envPath = process.env.UNITY_HUB_PATH ?? "";
+        if (envPath && fs.existsSync(envPath)) {
+            return envPath;
+        }
+        return UnityHub.CONFIG_PATHS[this.platform].hub || "";
+    }
+    static getProjectsPath() {
+        return UnityHub.CONFIG_PATHS[this.platform].projects || "";
+    }
+    static getProjectDirPath() {
+        return UnityHub.CONFIG_PATHS[this.platform].projectDir || "";
+    }
+    static async isUnityHubAvailable() {
+        try {
+            if (!this.hubPath || !fs.existsSync(this.hubPath)) {
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+        catch (error) {
+            console.error("Error checking Unity Hub availability:", error);
+            return false;
+        }
+    }
+    static async execUnityHubCommand(args, options = {}) {
+        const isAvailable = await UnityHub.isUnityHubAvailable();
+        if (!isAvailable) {
+            console.error("Unity Hub is not available.");
+            return {
+                success: false,
+                stdout: "",
+                stderr: "Unity Hub is not available.",
+                exitCode: -1,
+            };
+        }
+        try {
+            const hubArgs = [this.platform !== "linux" ? "--" : "", "--headless", ...args].filter(Boolean);
+            console.debug(`Executing Unity Hub command: ${this.hubPath} ${hubArgs.join(" ")}`);
+            return await executeCommand(this.hubPath, hubArgs, options);
+        }
+        catch (error) {
+            console.error("Error executing Unity Hub command:", error);
+            return {
+                success: false,
+                stdout: "",
+                stderr: String(error),
+                exitCode: -1,
+            };
+        }
+    }
+    static async getInstallPath() {
+        const { stdout, stderr } = await this.execUnityHubCommand(["install-path", "-g"], {
+            reject: false,
+        });
+        if (stderr) {
+            throw new Error(`Error getting install path: ${stderr}`);
+        }
+        return stdout;
+    }
+    static async setInstallPath(path) {
+        const { stdout, stderr } = await this.execUnityHubCommand(["install-path", "-s", path], {
+            reject: false,
+        });
+        if (stderr) {
+            throw new Error(`Error setting install path: ${stderr}`);
+        }
+        console.debug(`Install path set to: ${stdout}`);
+    }
+    static async getUnityInstallations() {
+        const { stdout, stderr } = await this.execUnityHubCommand(["editors", "-i"], {
+            reject: false,
+        });
+        const isSuccess = stdout.includes(", installed at");
+        if (stderr)
+            throw new Error(`Get installations command warning/error: ${stderr}`);
+        if (!isSuccess)
+            throw new Error(`Consider install a Unity version using Unity Hub.`);
+        const lines = stdout.split(/\r\n|\n/);
+        const installations = {};
+        lines.forEach((line) => {
+            const [version, unityPath] = line.split(", installed at").map((entry) => entry.trim());
+            installations[version] = unityPath;
+        });
+        if (Object.keys(installations).length <= 0)
+            throw new Error("No unity installations found.");
+        return installations;
+    }
+    static async addModule(editorVersion, modules, childModules = false) {
+        try {
+            console.debug(`Adding module ${modules} to Unity ${editorVersion}`);
+            const args = ["install-modules", "-v", editorVersion];
+            if (modules.length > 0) {
+                args.push("--module");
+                args.push(modules.join(" "));
+            }
+            else {
+                throw new Error("No module IDs provided.");
+            }
+            if (childModules) {
+                args.push("--child-modules");
+            }
+            const { stdout, stderr } = await this.execUnityHubCommand(args, {
+                reject: false,
+            });
+            console.debug(`Add module command output: ${stdout}`);
+            if (stderr) {
+                console.warn(`Add module command warning/error: ${stderr}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, error);
+            throw error;
+        }
+    }
+    static async addEditor(version, changeset, modules = [], architecture = EditorArchitecture.x86_64) {
+        try {
+            console.debug(`Installing Unity ${version} ${(changeset ?? "") ? `(changeset: ${changeset})` : ""}`);
+            const args = ["install", "-v", version];
+            if (changeset) {
+                args.push("--changeset", changeset);
+            }
+            if (modules.length > 0) {
+                args.push("--module");
+                args.push(modules.join(" "));
+            }
+            if (this.platform === "darwin") {
+                args.push("--architecture", architecture);
+            }
+            const { stdout, stderr } = await this.execUnityHubCommand(args, {
+                reject: false,
+            });
+            if (stderr) {
+                throw new Error(`Error installing Unity ${version}: ${stderr}`);
+            }
+            console.log(`Unity ${version}. ${stdout}`);
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+    }
+    static async getProjects() {
+        try {
+            const projectsPath = this.getProjectsPath();
+            if (!projectsPath || !fs.existsSync(projectsPath)) {
+                console.debug(`Projects file not found at: ${projectsPath}`);
+                return [];
+            }
+            const projectsData = await fs.readJson(projectsPath);
+            const projects = Object.values(projectsData.data);
+            return projects.map((project) => ({
+                name: project.title,
+                path: project.path,
+                version: project.version,
+            }));
+        }
+        catch (error) {
+            console.error("Error getting recent projects:", error);
+            return [];
+        }
+    }
+    static async getDefaultProjectsDirectory() {
+        try {
+            const projectDirPath = this.getProjectDirPath();
+            if (!projectDirPath || !fs.existsSync(projectDirPath)) {
+                console.debug(`Project directory file not found at: ${projectDirPath}`);
+                return null;
+            }
+            const projectDirData = await fs.readJson(projectDirPath);
+            return projectDirData.directoryPath ?? null;
+        }
+        catch (error) {
+            console.error("Error getting default project directory:", error);
+            return null;
+        }
+    }
+}
+export default UnityHub;

package/dist/utils/commandExecutor.d.ts

@@ -0,0 +1,14 @@
+import { Options } from "execa";
+export interface CommandOptions extends Options {
+    reject?: boolean;
+    timeout?: number;
+    env?: Record<string, string>;
+    cwd?: string;
+}
+export interface CommandResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode?: number;
+}
+export declare function executeCommand(executable: string, args: string[], options?: CommandOptions): Promise<CommandResult>;

package/dist/utils/commandExecutor.js

@@ -0,0 +1,27 @@
+import { execa } from "execa";
+export async function executeCommand(executable, args, options = {}) {
+    try {
+        const subprocess = execa(executable, args, {
+            reject: options.reject ?? false,
+            timeout: options.timeout,
+            env: options.env,
+            cwd: options.cwd,
+            encoding: "utf8",
+        });
+        const { stdout, stderr, exitCode } = await subprocess;
+        return {
+            success: true,
+            stdout,
+            stderr,
+            exitCode,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            stdout: error.stdout ?? "",
+            stderr: error.stderr ?? String(error),
+            exitCode: error.exitCode,
+        };
+    }
+}

package/dist-cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnityHub = void 0;
+var unityHub_ts_1 = require("./unityHub.js");
+Object.defineProperty(exports, "UnityHub", { enumerable: true, get: function () { return __importDefault(unityHub_ts_1).default; } });
+__exportStar(require("./types/unity.js"), exports);

package/dist-cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist-cjs/types/unity.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnityBuildTarget = exports.TestMode = exports.EditorArchitecture = exports.UnityLanguages = exports.UnityModules = void 0;
+var UnityModules;
+(function (UnityModules) {
+    UnityModules["Documentation"] = "documentation";
+    UnityModules["AndroidBuildSupport"] = "android";
+    UnityModules["AndroidSDKNDKTools"] = "android-sdk-ndk-tools";
+    UnityModules["OpenJDK"] = "android-open-jdk";
+    UnityModules["IOSBuildSupport"] = "ios";
+    UnityModules["TvOSBuildSupport"] = "appletv";
+    UnityModules["LinuxBuildSupportMono"] = "linux-mono";
+    UnityModules["LinuxBuildSupportIL2CPP"] = "linux-il2cpp";
+    UnityModules["WebGLBuildSupport"] = "webgl";
+    UnityModules["WindowsBuildSupport"] = "windows";
+    UnityModules["VuforiaAR"] = "vuforia-ar";
+    UnityModules["WindowsBuildSupportMono"] = "windows-mono";
+    UnityModules["LuminBuildSupport"] = "lumin";
+    UnityModules["VisualStudioCommunity"] = "visualstudio";
+    UnityModules["MacBuildSupportMono"] = "mac-mono";
+    UnityModules["MacBuildSupportIL2CPP"] = "mac-il2cpp";
+    UnityModules["UniversalWindowsPlatform"] = "universal-windows-platform";
+    UnityModules["UWPBuildSupportIL2CPP"] = "uwp-il2cpp";
+    UnityModules["UWPBuildSupportDotNet"] = "uwp-.net";
+})(UnityModules || (exports.UnityModules = UnityModules = {}));
+var UnityLanguages;
+(function (UnityLanguages) {
+    UnityLanguages["Japanese"] = "language-ja";
+    UnityLanguages["Korean"] = "language-ko";
+    UnityLanguages["ChineseSimplified"] = "language-zh-hans";
+    UnityLanguages["ChineseTraditional"] = "language-zh-hant";
+    UnityLanguages["Chinese"] = "language-zh-cn";
+})(UnityLanguages || (exports.UnityLanguages = UnityLanguages = {}));
+var EditorArchitecture;
+(function (EditorArchitecture) {
+    EditorArchitecture["x86_64"] = "x86_64";
+    EditorArchitecture["arm64"] = "arm64";
+})(EditorArchitecture || (exports.EditorArchitecture = EditorArchitecture = {}));
+var TestMode;
+(function (TestMode) {
+    TestMode["EditMode"] = "editmode";
+    TestMode["PlayMode"] = "playmode";
+})(TestMode || (exports.TestMode = TestMode = {}));
+var UnityBuildTarget;
+(function (UnityBuildTarget) {
+    UnityBuildTarget["StandaloneOSX"] = "StandaloneOSX";
+    UnityBuildTarget["StandaloneWindows"] = "StandaloneWindows";
+    UnityBuildTarget["iOS"] = "iOS";
+    UnityBuildTarget["Android"] = "Android";
+    UnityBuildTarget["StandaloneWindows64"] = "StandaloneWindows64";
+    UnityBuildTarget["WebGL"] = "WebGL";
+    UnityBuildTarget["WSAPlayer"] = "WSAPlayer";
+    UnityBuildTarget["StandaloneLinux64"] = "StandaloneLinux64";
+    UnityBuildTarget["PS4"] = "PS4";
+    UnityBuildTarget["XboxOne"] = "XboxOne";
+    UnityBuildTarget["tvOS"] = "tvOS";
+    UnityBuildTarget["Switch"] = "Switch";
+    UnityBuildTarget["LinuxHeadlessSimulation"] = "LinuxHeadlessSimulation";
+    UnityBuildTarget["PS5"] = "PS5";
+    UnityBuildTarget["VisionOS"] = "VisionOS";
+})(UnityBuildTarget || (exports.UnityBuildTarget = UnityBuildTarget = {}));

package/dist-cjs/unityHub.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const unity_js_1 = require("./types/unity.js");
+const commandExecutor_js_1 = require("./utils/commandExecutor.js");
+class UnityHub {
+    static CONFIG_PATHS = {
+        win32: {
+            hub: "C:\\Program Files\\Unity Hub\\Unity Hub.exe",
+            projects: path_1.default.join(os_1.default.homedir(), "AppData", "Roaming", "UnityHub", "projects-v1.json"),
+            projectDir: path_1.default.join(os_1.default.homedir(), "AppData", "Roaming", "UnityHub", "projectDir.json"),
+        },
+        darwin: {
+            hub: "/Applications/Unity Hub.app/Contents/MacOS/Unity Hub",
+            projects: path_1.default.join(os_1.default.homedir(), "Library", "Application Support", "UnityHub", "projects-v1.json"),
+            projectDir: path_1.default.join(os_1.default.homedir(), "Library", "Application Support", "UnityHub", "projectDir.json"),
+        },
+        linux: {
+            hub: "/opt/UnityHub/UnityHub",
+            projects: path_1.default.join(os_1.default.homedir(), ".config", "UnityHub", "projects-v1.json"),
+            projectDir: path_1.default.join(os_1.default.homedir(), ".config", "UnityHub", "projectDir.json"),
+        },
+    };
+    static Modules = unity_js_1.UnityModules;
+    static Languages = unity_js_1.UnityLanguages;
+    static platform = os_1.default.platform();
+    static hubPath = this.getUnityHubPath();
+    static getUnityHubPath() {
+        const envPath = process.env.UNITY_HUB_PATH ?? "";
+        if (envPath && fs_extra_1.default.existsSync(envPath)) {
+            return envPath;
+        }
+        return UnityHub.CONFIG_PATHS[this.platform].hub || "";
+    }
+    static getProjectsPath() {
+        return UnityHub.CONFIG_PATHS[this.platform].projects || "";
+    }
+    static getProjectDirPath() {
+        return UnityHub.CONFIG_PATHS[this.platform].projectDir || "";
+    }
+    static async isUnityHubAvailable() {
+        try {
+            if (!this.hubPath || !fs_extra_1.default.existsSync(this.hubPath)) {
+                return false;
+            }
+            else {
+                return true;
+            }
+        }
+        catch (error) {
+            console.error("Error checking Unity Hub availability:", error);
+            return false;
+        }
+    }
+    static async execUnityHubCommand(args, options = {}) {
+        const isAvailable = await UnityHub.isUnityHubAvailable();
+        if (!isAvailable) {
+            console.error("Unity Hub is not available.");
+            return {
+                success: false,
+                stdout: "",
+                stderr: "Unity Hub is not available.",
+                exitCode: -1,
+            };
+        }
+        try {
+            const hubArgs = [this.platform !== "linux" ? "--" : "", "--headless", ...args].filter(Boolean);
+            console.debug(`Executing Unity Hub command: ${this.hubPath} ${hubArgs.join(" ")}`);
+            return await (0, commandExecutor_js_1.executeCommand)(this.hubPath, hubArgs, options);
+        }
+        catch (error) {
+            console.error("Error executing Unity Hub command:", error);
+            return {
+                success: false,
+                stdout: "",
+                stderr: String(error),
+                exitCode: -1,
+            };
+        }
+    }
+    static async getInstallPath() {
+        const { stdout, stderr } = await this.execUnityHubCommand(["install-path", "-g"], {
+            reject: false,
+        });
+        if (stderr) {
+            throw new Error(`Error getting install path: ${stderr}`);
+        }
+        return stdout;
+    }
+    static async setInstallPath(path) {
+        const { stdout, stderr } = await this.execUnityHubCommand(["install-path", "-s", path], {
+            reject: false,
+        });
+        if (stderr) {
+            throw new Error(`Error setting install path: ${stderr}`);
+        }
+        console.debug(`Install path set to: ${stdout}`);
+    }
+    static async getUnityInstallations() {
+        const { stdout, stderr } = await this.execUnityHubCommand(["editors", "-i"], {
+            reject: false,
+        });
+        const isSuccess = stdout.includes(", installed at");
+        if (stderr)
+            throw new Error(`Get installations command warning/error: ${stderr}`);
+        if (!isSuccess)
+            throw new Error(`Consider install a Unity version using Unity Hub.`);
+        const lines = stdout.split(/\r\n|\n/);
+        const installations = {};
+        lines.forEach((line) => {
+            const [version, unityPath] = line.split(", installed at").map((entry) => entry.trim());
+            installations[version] = unityPath;
+        });
+        if (Object.keys(installations).length <= 0)
+            throw new Error("No unity installations found.");
+        return installations;
+    }
+    static async addModule(editorVersion, modules, childModules = false) {
+        try {
+            console.debug(`Adding module ${modules} to Unity ${editorVersion}`);
+            const args = ["install-modules", "-v", editorVersion];
+            if (modules.length > 0) {
+                args.push("--module");
+                args.push(modules.join(" "));
+            }
+            else {
+                throw new Error("No module IDs provided.");
+            }
+            if (childModules) {
+                args.push("--child-modules");
+            }
+            const { stdout, stderr } = await this.execUnityHubCommand(args, {
+                reject: false,
+            });
+            console.debug(`Add module command output: ${stdout}`);
+            if (stderr) {
+                console.warn(`Add module command warning/error: ${stderr}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, error);
+            throw error;
+        }
+    }
+    static async addEditor(version, changeset, modules = [], architecture = unity_js_1.EditorArchitecture.x86_64) {
+        try {
+            console.debug(`Installing Unity ${version} ${(changeset ?? "") ? `(changeset: ${changeset})` : ""}`);
+            const args = ["install", "-v", version];
+            if (changeset) {
+                args.push("--changeset", changeset);
+            }
+            if (modules.length > 0) {
+                args.push("--module");
+                args.push(modules.join(" "));
+            }
+            if (this.platform === "darwin") {
+                args.push("--architecture", architecture);
+            }
+            const { stdout, stderr } = await this.execUnityHubCommand(args, {
+                reject: false,
+            });
+            if (stderr) {
+                throw new Error(`Error installing Unity ${version}: ${stderr}`);
+            }
+            console.log(`Unity ${version}. ${stdout}`);
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+    }
+    static async getProjects() {
+        try {
+            const projectsPath = this.getProjectsPath();
+            if (!projectsPath || !fs_extra_1.default.existsSync(projectsPath)) {
+                console.debug(`Projects file not found at: ${projectsPath}`);
+                return [];
+            }
+            const projectsData = await fs_extra_1.default.readJson(projectsPath);
+            const projects = Object.values(projectsData.data);
+            return projects.map((project) => ({
+                name: project.title,
+                path: project.path,
+                version: project.version,
+            }));
+        }
+        catch (error) {
+            console.error("Error getting recent projects:", error);
+            return [];
+        }
+    }
+    static async getDefaultProjectsDirectory() {
+        try {
+            const projectDirPath = this.getProjectDirPath();
+            if (!projectDirPath || !fs_extra_1.default.existsSync(projectDirPath)) {
+                console.debug(`Project directory file not found at: ${projectDirPath}`);
+                return null;
+            }
+            const projectDirData = await fs_extra_1.default.readJson(projectDirPath);
+            return projectDirData.directoryPath ?? null;
+        }
+        catch (error) {
+            console.error("Error getting default project directory:", error);
+            return null;
+        }
+    }
+}
+exports.default = UnityHub;

package/dist-cjs/utils/commandExecutor.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = executeCommand;
+const execa_1 = require("execa");
+async function executeCommand(executable, args, options = {}) {
+    try {
+        const subprocess = (0, execa_1.execa)(executable, args, {
+            reject: options.reject ?? false,
+            timeout: options.timeout,
+            env: options.env,
+            cwd: options.cwd,
+            encoding: "utf8",
+        });
+        const { stdout, stderr, exitCode } = await subprocess;
+        return {
+            success: true,
+            stdout,
+            stderr,
+            exitCode,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            stdout: error.stdout ?? "",
+            stderr: error.stderr ?? String(error),
+            exitCode: error.exitCode,
+        };
+    }
+}

package/eslint.config.js

@@ -0,0 +1,60 @@
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  {
+    files: ["**/*.{js,mjs,cjs,ts}"],
+    plugins: { js },
+    extends: ["js/recommended"],
+  },
+  {
+    files: ["**/*.{js,mjs,cjs,ts}"],
+  },
+  ...tseslint.configs.recommended,
+  {
+    files: ["**/*.ts"],
+    languageOptions: {
+      parser: tseslint.parser,
+      parserOptions: {
+        project: "./tsconfig.json",
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tseslint.plugin,
+    },
+    rules: {
+      // Disable JS rule and enable TS equivalent
+      "no-unused-vars": "off",
+      "@typescript-eslint/no-unused-vars": "warn",
+
+      // Typed linting rules
+      "@typescript-eslint/explicit-function-return-type": "error",
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/strict-boolean-expressions": "off",
+      "@typescript-eslint/no-floating-promises": "error",
+      "@typescript-eslint/prefer-nullish-coalescing": "error",
+      "@typescript-eslint/prefer-optional-chain": "error",
+      "@typescript-eslint/no-unnecessary-type-assertion": "error",
+      "@typescript-eslint/no-unnecessary-condition": "warn",
+      "@typescript-eslint/prefer-ts-expect-error": "error",
+      "@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": "allow-with-description" }],
+
+      // Code style
+      "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
+      "@typescript-eslint/consistent-type-assertions": "error",
+      "@typescript-eslint/explicit-member-accessibility": ["error", { accessibility: "explicit" }],
+      "@typescript-eslint/no-non-null-assertion": "error",
+    },
+  },
+  {
+    files: ["eslint.config.js"],
+    rules: {
+      "@typescript-eslint/explicit-function-return-type": "off",
+      "@typescript-eslint/strict-boolean-expressions": "off",
+    },
+  },
+  {
+    ignores: ["node_modules", "dist", "dist-cjs", "**/*.cjs"],
+  },
+]);

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@notask/unity-cli-tools",
+  "version": "1.0.0",
+  "main": "dist-cjs/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist-cjs/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NoTaskStudios/unity-cli-tools.git"
+  },
+  "scripts": {
+    "clean": "rimraf dist dist-cjs",
+    "build": "npm run clean && npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc --project tsconfig.json",
+    "build:cjs": "tsc --project tsconfig.cjs.json && node scripts/write-cjs-package.cjs",
+    "test": "jest --passWithNoTests",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "semantic-release": "semantic-release"
+  },
+  "keywords": [
+    "unity",
+    "cli",
+    "tools",
+    "command line"
+  ],
+  "author": "NoTask Team",
+  "license": "MIT",
+  "description": "A tools for Unity command line development.",
+  "dependencies": {
+    "execa": "^9.5.2",
+    "fs-extra": "^11.3.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.24.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^12.0.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.13.14",
+    "@typescript-eslint/eslint-plugin": "^8.30.1",
+    "@typescript-eslint/parser": "^8.30.1",
+    "eslint": "9.24.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.5.3",
+    "rimraf": "6.0.1",
+    "semantic-release": "^24.2.3",
+    "ts-jest": "^29.3.1",
+    "tsx": "4.19.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "8.30.1"
+  }
+}

package/scripts/write-cjs-package.cjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+const fs = require("fs");
+const path = require("path");
+
+const outDir = path.resolve(__dirname, "..", "dist-cjs");
+fs.mkdirSync(outDir, { recursive: true });
+
+const pkg = { type: "commonjs" };
+fs.writeFileSync(path.join(outDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");