@notask/unity-cli-tools 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [1.0.4](https://github.com/NoTaskStudios/unity-cli-tools/compare/1.0.3...1.0.4) (2025-04-29)
+
+
+### Bug Fixes
+
+* **Hub:** get changeset for editor version installation ([ab4d9ad](https://github.com/NoTaskStudios/unity-cli-tools/commit/ab4d9adaeb3909bf44de5bdbbdde5e9c3ced297f))
+
+## [1.0.3](https://github.com/NoTaskStudios/unity-cli-tools/compare/1.0.2...1.0.3) (2025-04-28)
+
+
+### Bug Fixes
+
+* change type naming ([0e32839](https://github.com/NoTaskStudios/unity-cli-tools/commit/0e32839146eaa6072dd5f5c54e01033b9a7e1ab6))
+* **Editor:** fix logging sensitive information ([504d4b6](https://github.com/NoTaskStudios/unity-cli-tools/commit/504d4b6caaaa62278c68f13193d8a46c38bb3df1))
+
 ## [1.0.2](https://github.com/NoTaskStudios/unity-cli-tools/compare/1.0.1...1.0.2) (2025-04-23)
 
 

package/README.md

@@ -88,6 +88,107 @@ const result = await UnityHub.execUnityHubCommand(["editors", "-r"]);
 console.log(result.stdout);
 ```
 
+## UnityEditor API Reference
+
+UnityEditor provides an interface for automating tasks directly in the Unity Editor:
+
+### Installation and Availability
+```typescript
+import UnityEditor from "@notask/unity-cli-tools";
+
+// Get the executable path and verify installation
+const unityPath = UnityEditor.getUnityExecutablePath("2022.3.15f1");
+const isInstalled = await UnityEditor.isUnityVersionInstalled("2022.3.15f1");
+console.log(`Installed: ${isInstalled}`, unityPath);
+```
+
+### Executing Raw Editor Commands
+```typescript
+import { CommandResult } from "@notask/unity-cli-tools";
+
+const editorInfo = { version: "2022.3.15f1", path: unityPath };
+const result: CommandResult = await UnityEditor.execUnityEditorCommand(
+  editorInfo,
+  ["-batchmode", "-quit", "-projectPath", "/path/to/project"]
+);
+console.log(result.stdout);
+```
+
+### Creating and Opening Projects
+```typescript
+import { ProjectInfo } from "@notask/unity-cli-tools";
+
+const projectInfo: ProjectInfo = {
+  projectPath: "/path/to/new/project",
+  editorVersion: "2022.3.15f1"
+};
+
+await UnityEditor.createProject(projectInfo);
+await UnityEditor.openProject(projectInfo, true, true);
+```
+
+### Running Tests
+```typescript
+import { ProjectInfo, TestMode } from "@notask/unity-cli-tools";
+
+const projectInfo: ProjectInfo = {
+  projectPath: "/path/to/project",
+  editorVersion: "2022.3.15f1"
+};
+
+const { success, output } = await UnityEditor.runTests(projectInfo, TestMode.EditMode);
+console.log(success ? "Tests passed" : "Tests failed", output);
+```
+
+### License Management
+```typescript
+import { ProjectInfo } from "@notask/unity-cli-tools";
+
+const projectInfo: ProjectInfo = {
+  projectPath: "/path/to/project",
+  editorVersion: "2022.3.15f1"
+};
+
+await UnityEditor.activateLicense(projectInfo, "XXXX-XXXX-XXXX-XXXX-XXXX", "user@example.com", "password");
+await UnityEditor.returnLicense(projectInfo);
+```
+
+### Importing and Exporting Packages
+```typescript
+import { ProjectInfo } from "@notask/unity-cli-tools";
+
+const projectInfo: ProjectInfo = {
+  projectPath: "/path/to/project",
+  editorVersion: "2022.3.15f1"
+};
+
+await UnityEditor.exportPackage(
+  projectInfo,
+  ["Assets/UI", "Assets/Scripts"],
+  "/path/to/output/MyPackage.unitypackage"
+);
+await UnityEditor.importPackage(
+  projectInfo,
+  "/path/to/downloads/OtherPackage.unitypackage"
+);
+```
+
+### Executing Custom Editor Methods
+```typescript
+import { ProjectInfo } from "@notask/unity-cli-tools";
+
+const projectInfo: ProjectInfo = {
+  projectPath: "/path/to/project",
+  editorVersion: "2022.3.15f1"
+};
+
+const executionResult = await UnityEditor.executeMethod(
+  projectInfo,
+  "MyCompany.BuildTools.PerformBuild"
+);
+console.log(executionResult);
+```
+
 ## Available Constants
 
 ### UnityModules

package/dist/cjs/index.js

@@ -17,7 +17,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnityHub = void 0;
+exports.UnityEditor = 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; } });
+var unityEditor_ts_1 = require("./unityEditor.js");
+Object.defineProperty(exports, "UnityEditor", { enumerable: true, get: function () { return __importDefault(unityEditor_ts_1).default; } });
 __exportStar(require("./types/unity.js"), exports);

package/dist/cjs/types/unity.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnityBuildTarget = exports.TestMode = exports.EditorArchitecture = exports.UnityLanguages = exports.UnityModules = void 0;
+exports.UnityBuildTarget = exports.TestMode = exports.EditorArchitecture = exports.UnityEditorLanguages = exports.UnityModules = void 0;
 var UnityModules;
 (function (UnityModules) {
     UnityModules["Documentation"] = "documentation";
@@ -23,14 +23,14 @@ var UnityModules;
     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 UnityEditorLanguages;
+(function (UnityEditorLanguages) {
+    UnityEditorLanguages["Japanese"] = "language-ja";
+    UnityEditorLanguages["Korean"] = "language-ko";
+    UnityEditorLanguages["ChineseSimplified"] = "language-zh-hans";
+    UnityEditorLanguages["ChineseTraditional"] = "language-zh-hant";
+    UnityEditorLanguages["Chinese"] = "language-zh-cn";
+})(UnityEditorLanguages || (exports.UnityEditorLanguages = UnityEditorLanguages = {}));
 var EditorArchitecture;
 (function (EditorArchitecture) {
     EditorArchitecture["x86_64"] = "x86_64";

package/dist/cjs/unityEditor.js

@@ -0,0 +1,295 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const unity_js_1 = require("./types/unity.js");
+const commandExecutor_js_1 = require("./utils/commandExecutor.js");
+class UnityEditor {
+    static UNITY_PATHS = {
+        win32: {
+            base: "C:/Program Files/Unity/Hub/Editor",
+            executable: "Editor/Unity.exe",
+        },
+        darwin: {
+            base: "/Applications/Unity/Hub/Editor",
+            executable: "Unity.app/Contents/MacOS/Unity",
+        },
+        linux: {
+            base: "/opt/unity/editor",
+            executable: "Editor/Unity",
+        },
+    };
+    static getUnityExecutablePath(version) {
+        const platform = os_1.default.platform();
+        const unityConfig = UnityEditor.UNITY_PATHS[platform];
+        const unityPath = path_1.default.join(unityConfig.base, version, unityConfig.executable);
+        return unityPath;
+    }
+    static async isUnityVersionInstalled(version) {
+        try {
+            const unityPath = this.getUnityExecutablePath(version);
+            return fs_extra_1.default.existsSync(unityPath);
+        }
+        catch (error) {
+            console.error(error);
+            return false;
+        }
+    }
+    static async execUnityEditorCommand(editorInfo, args, options = {}) {
+        try {
+            const unityPath = this.getUnityExecutablePath(editorInfo.version);
+            if (!fs_extra_1.default.existsSync(unityPath)) {
+                return {
+                    success: false,
+                    stdout: "",
+                    stderr: `Unity executable not found at path: ${unityPath}`,
+                    exitCode: -1,
+                };
+            }
+            const editorArgs = [...args];
+            const redactedArgs = redactSensitiveArgs(editorArgs);
+            console.debug(`Executing Unity Editor command: ${unityPath} ${redactedArgs.join(" ")}`);
+            return await (0, commandExecutor_js_1.executeCommand)(unityPath, editorArgs, options);
+        }
+        catch (error) {
+            console.error("Error executing Unity Editor command:", error);
+            return {
+                success: false,
+                stdout: "",
+                stderr: String(error),
+                exitCode: -1,
+            };
+        }
+    }
+    static async executeMethod(projectInfo, method, args = [], options = {}) {
+        try {
+            console.debug(`Executing method ${method} in Unity Editor`);
+            const unityPath = this.getUnityExecutablePath(projectInfo.editorVersion);
+            const editorArgs = ["-projectPath", projectInfo.projectPath, "-executeMethod", method, ...args];
+            const { stdout, stderr } = await this.execUnityEditorCommand({ version: projectInfo.editorVersion, path: unityPath }, editorArgs, options);
+            if (stderr) {
+                console.error(`Error executing method: ${stderr}`);
+                return null;
+            }
+            return stdout;
+        }
+        catch (error) {
+            console.error("Error executing method:", error);
+            return null;
+        }
+    }
+    static async runTests(projectInfo, testPlatform = unity_js_1.TestMode.EditMode, testCategory) {
+        try {
+            console.debug(`Running ${testPlatform} tests for project ${testCategory ? ` in category ${testCategory}` : ""}`);
+            const args = [
+                "-batchmode",
+                "-quit",
+                "-projectPath",
+                projectInfo.projectPath,
+                "-runTests",
+                "-testPlatform",
+                testPlatform,
+            ];
+            if (testCategory) {
+                args.push("-testCategory", testCategory);
+            }
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const testsFailed = stdout.includes("Some tests failed") ||
+                stdout.includes("Test run failed") ||
+                stderr.includes("Test run failed");
+            return {
+                success: !testsFailed,
+                output: stdout,
+            };
+        }
+        catch (error) {
+            console.error("Error running tests:", error);
+            return {
+                success: false,
+                output: String(error),
+            };
+        }
+    }
+    static async activateLicense(projectInfo, serial, username, password) {
+        try {
+            console.debug(`Activating Unity license for version ${projectInfo.editorVersion}`);
+            const args = ["-quit", "-serial", serial, "-username", username, "-password", password];
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const activationSuccessful = stdout.includes("successfully activated") ||
+                (!stdout.includes("License activation failed") && !stderr.includes("License activation failed"));
+            if (activationSuccessful) {
+                console.info(`Successfully activated license for Unity ${projectInfo.editorVersion}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to activate license: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error activating license:", error);
+            return false;
+        }
+    }
+    static async returnLicense(projectInfo) {
+        try {
+            console.debug(`Returning Unity license for version ${projectInfo.editorVersion}`);
+            const args = ["-quit", "-returnlicense"];
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const returnSuccessful = stdout.includes("license return succeeded") ||
+                (!stdout.includes("Failed to return license") && !stderr.includes("Failed to return license"));
+            if (returnSuccessful) {
+                console.info(`Successfully returned license for Unity ${projectInfo.editorVersion}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to return license: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error returning license:", error);
+            return false;
+        }
+    }
+    static async exportPackage(projectInfo, assetPaths, outputPath) {
+        try {
+            console.debug(`Exporting package from project`);
+            const args = ["-projectPath", projectInfo.projectPath, "-exportPackage", ...assetPaths, outputPath, "-quit"];
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const exportSuccessful = !stdout.includes("Failed to export package") && !stderr.includes("Failed to export package");
+            if (exportSuccessful) {
+                console.info(`Successfully exported package to ${outputPath}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to export package: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error exporting package:", error);
+            return false;
+        }
+    }
+    static async importPackage(projectInfo, packagePath) {
+        try {
+            console.debug(`Importing package ${packagePath} to project`);
+            const args = ["-projectPath", projectInfo.projectPath, "-importPackage", packagePath, "-quit"];
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const importSuccessful = !stdout.includes("Failed to import package") && !stderr.includes("Failed to import package");
+            if (importSuccessful) {
+                console.info(`Successfully imported package ${packagePath}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to import package: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error importing package:", error);
+            return false;
+        }
+    }
+    static async createProject(projectInfo, waitForExit = true) {
+        try {
+            console.debug(`Creating new project at ${projectInfo.projectPath}`);
+            const parentDir = path_1.default.dirname(projectInfo.projectPath);
+            await fs_extra_1.default.ensureDir(parentDir);
+            const args = ["-createProject", projectInfo.projectPath];
+            if (waitForExit) {
+                args.push("-quit");
+            }
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const creationSuccessful = !stdout.includes("Failed to create project") && !stderr.includes("Failed to create project");
+            if (creationSuccessful) {
+                console.info(`Successfully created project at ${projectInfo.projectPath}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to create project: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error creating project:", error);
+            return false;
+        }
+    }
+    static async openProject(projectInfo, batchmode = false, waitForExit = true) {
+        try {
+            console.debug(`Opening project at ${projectInfo.projectPath}`);
+            const args = ["-projectPath", projectInfo.projectPath];
+            if (waitForExit) {
+                args.push("-quit");
+            }
+            if (batchmode) {
+                args.push("-batchmode");
+            }
+            const editorInfo = { version: projectInfo.editorVersion };
+            const options = { reject: false };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, options);
+            const openingSuccessful = !stdout.includes("Failed to open project") && !stderr.includes("Failed to open project");
+            if (openingSuccessful) {
+                console.info(`Successfully opened project`);
+                return true;
+            }
+            else {
+                console.error(`Failed to open project: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error opening project:", error);
+            return false;
+        }
+    }
+}
+function redactSensitiveArgs(argv, sensitiveKeys = ["password", "token", "secret"]) {
+    const redacted = [...argv];
+    for (let i = 0; i < redacted.length; i++) {
+        const arg = redacted[i];
+        if (arg.startsWith("--") || arg.startsWith("-")) {
+            const key = arg.replace(/^--?/, "");
+            if (sensitiveKeys.includes(key.toLowerCase())) {
+                if (i + 1 < redacted.length && !redacted[i + 1].startsWith("-")) {
+                    redacted[i + 1] = "[REDACTED]";
+                }
+            }
+        }
+        else {
+            const match = arg.match(/^--?([^=]+)=(.+)$/);
+            if (match) {
+                const key = match[1];
+                if (sensitiveKeys.includes(key.toLowerCase())) {
+                    redacted[i] = `--${key}=[REDACTED]`;
+                }
+            }
+        }
+    }
+    return redacted;
+}
+exports.default = UnityEditor;

package/dist/cjs/unityHub.js

@@ -8,6 +8,7 @@ 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");
+const unity_changeset_1 = require("unity-changeset");
 class UnityHub {
     static CONFIG_PATHS = {
         win32: {
@@ -27,7 +28,7 @@ class UnityHub {
         },
     };
     static Modules = unity_js_1.UnityModules;
-    static Languages = unity_js_1.UnityLanguages;
+    static Languages = unity_js_1.UnityEditorLanguages;
     static platform = os_1.default.platform();
     static hubPath = this.getUnityHubPath();
     static getUnityHubPath() {
@@ -150,12 +151,12 @@ class UnityHub {
             throw error;
         }
     }
-    static async addEditor(version, changeset, modules = [], architecture = unity_js_1.EditorArchitecture.x86_64) {
+    static async addEditor(version, modules = [], architecture = unity_js_1.EditorArchitecture.x86_64) {
         try {
-            console.debug(`Installing Unity ${version} ${(changeset ?? "") ? `(changeset: ${changeset})` : ""}`);
+            const data = await (0, unity_changeset_1.getUnityChangeset)(version);
             const args = ["install", "-v", version];
-            if (changeset) {
-                args.push("--changeset", changeset);
+            if (data) {
+                args.push("--changeset", data.changeset);
             }
             if (modules.length > 0) {
                 args.push("--module");

package/dist/esm/index.d.ts

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

package/dist/esm/index.js

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

package/dist/esm/types/unity.d.ts

@@ -36,7 +36,7 @@ export declare enum UnityModules {
     UWPBuildSupportIL2CPP = "uwp-il2cpp",
     UWPBuildSupportDotNet = "uwp-.net"
 }
-export declare enum UnityLanguages {
+export declare enum UnityEditorLanguages {
     Japanese = "language-ja",
     Korean = "language-ko",
     ChineseSimplified = "language-zh-hans",
@@ -47,19 +47,14 @@ export declare enum EditorArchitecture {
     x86_64 = "x86_64",
     arm64 = "arm64"
 }
-export type ModuleId = UnityModules | UnityLanguages;
+export type ModuleId = UnityModules | UnityEditorLanguages;
 export type UnityInstallations = Record<string, string>;
 export interface ProjectInfo {
-    path: string;
-    editorVersion: string;
     projectName: string;
+    projectPath: string;
+    editorVersion: string;
     scenes?: string[];
 }
-export interface ProjectSettings {
-    companyName?: string;
-    productName?: string;
-    bundleVersion?: string;
-}
 export declare enum TestMode {
     EditMode = "editmode",
     PlayMode = "playmode"
@@ -81,11 +76,3 @@ export declare enum UnityBuildTarget {
     PS5 = "PS5",
     VisionOS = "VisionOS"
 }
-export interface ParsedVersion {
-    major: number;
-    minor: number;
-    patch: number;
-    type: string;
-    revision: number;
-    original: string;
-}

package/dist/esm/types/unity.js

@@ -20,14 +20,14 @@ export var UnityModules;
     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 UnityEditorLanguages;
+(function (UnityEditorLanguages) {
+    UnityEditorLanguages["Japanese"] = "language-ja";
+    UnityEditorLanguages["Korean"] = "language-ko";
+    UnityEditorLanguages["ChineseSimplified"] = "language-zh-hans";
+    UnityEditorLanguages["ChineseTraditional"] = "language-zh-hant";
+    UnityEditorLanguages["Chinese"] = "language-zh-cn";
+})(UnityEditorLanguages || (UnityEditorLanguages = {}));
 export var EditorArchitecture;
 (function (EditorArchitecture) {
     EditorArchitecture["x86_64"] = "x86_64";

package/dist/esm/unityEditor.d.ts

@@ -0,0 +1,19 @@
+import { ProjectInfo, TestMode, UnityBuildTarget, UnityEditorInfo } from "./types/unity.js";
+import { CommandOptions, CommandResult } from "./utils/commandExecutor.js";
+declare class UnityEditor {
+    static getUnityExecutablePath(version: string): string;
+    static isUnityVersionInstalled(version: string): Promise<boolean>;
+    static execUnityEditorCommand(editorInfo: UnityEditorInfo, args: string[], options?: CommandOptions): Promise<CommandResult>;
+    static executeMethod(projectInfo: ProjectInfo, method: string, args?: string[], options?: CommandOptions): Promise<any>;
+    static runTests(projectInfo: ProjectInfo, testPlatform?: TestMode | UnityBuildTarget, testCategory?: string): Promise<{
+        success: boolean;
+        output: string;
+    }>;
+    static activateLicense(projectInfo: ProjectInfo, serial: string, username: string, password: string): Promise<boolean>;
+    static returnLicense(projectInfo: ProjectInfo): Promise<boolean>;
+    static exportPackage(projectInfo: ProjectInfo, assetPaths: string[], outputPath: string): Promise<boolean>;
+    static importPackage(projectInfo: ProjectInfo, packagePath: string): Promise<boolean>;
+    static createProject(projectInfo: ProjectInfo, waitForExit?: boolean): Promise<boolean>;
+    static openProject(projectInfo: ProjectInfo, batchmode?: boolean, waitForExit?: boolean): Promise<boolean>;
+}
+export default UnityEditor;

package/dist/esm/unityEditor.js

@@ -0,0 +1,290 @@
+import os from "os";
+import fs from "fs-extra";
+import path from "path";
+import { TestMode } from "./types/unity.js";
+import { executeCommand } from "./utils/commandExecutor.js";
+class UnityEditor {
+    static UNITY_PATHS = {
+        win32: {
+            base: "C:/Program Files/Unity/Hub/Editor",
+            executable: "Editor/Unity.exe",
+        },
+        darwin: {
+            base: "/Applications/Unity/Hub/Editor",
+            executable: "Unity.app/Contents/MacOS/Unity",
+        },
+        linux: {
+            base: "/opt/unity/editor",
+            executable: "Editor/Unity",
+        },
+    };
+    static getUnityExecutablePath(version) {
+        const platform = os.platform();
+        const unityConfig = UnityEditor.UNITY_PATHS[platform];
+        const unityPath = path.join(unityConfig.base, version, unityConfig.executable);
+        return unityPath;
+    }
+    static async isUnityVersionInstalled(version) {
+        try {
+            const unityPath = this.getUnityExecutablePath(version);
+            return fs.existsSync(unityPath);
+        }
+        catch (error) {
+            console.error(error);
+            return false;
+        }
+    }
+    static async execUnityEditorCommand(editorInfo, args, options = {}) {
+        try {
+            const unityPath = this.getUnityExecutablePath(editorInfo.version);
+            if (!fs.existsSync(unityPath)) {
+                return {
+                    success: false,
+                    stdout: "",
+                    stderr: `Unity executable not found at path: ${unityPath}`,
+                    exitCode: -1,
+                };
+            }
+            const editorArgs = [...args];
+            const redactedArgs = redactSensitiveArgs(editorArgs);
+            console.debug(`Executing Unity Editor command: ${unityPath} ${redactedArgs.join(" ")}`);
+            return await executeCommand(unityPath, editorArgs, options);
+        }
+        catch (error) {
+            console.error("Error executing Unity Editor command:", error);
+            return {
+                success: false,
+                stdout: "",
+                stderr: String(error),
+                exitCode: -1,
+            };
+        }
+    }
+    static async executeMethod(projectInfo, method, args = [], options = {}) {
+        try {
+            console.debug(`Executing method ${method} in Unity Editor`);
+            const unityPath = this.getUnityExecutablePath(projectInfo.editorVersion);
+            const editorArgs = ["-projectPath", projectInfo.projectPath, "-executeMethod", method, ...args];
+            const { stdout, stderr } = await this.execUnityEditorCommand({ version: projectInfo.editorVersion, path: unityPath }, editorArgs, options);
+            if (stderr) {
+                console.error(`Error executing method: ${stderr}`);
+                return null;
+            }
+            return stdout;
+        }
+        catch (error) {
+            console.error("Error executing method:", error);
+            return null;
+        }
+    }
+    static async runTests(projectInfo, testPlatform = TestMode.EditMode, testCategory) {
+        try {
+            console.debug(`Running ${testPlatform} tests for project ${testCategory ? ` in category ${testCategory}` : ""}`);
+            const args = [
+                "-batchmode",
+                "-quit",
+                "-projectPath",
+                projectInfo.projectPath,
+                "-runTests",
+                "-testPlatform",
+                testPlatform,
+            ];
+            if (testCategory) {
+                args.push("-testCategory", testCategory);
+            }
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const testsFailed = stdout.includes("Some tests failed") ||
+                stdout.includes("Test run failed") ||
+                stderr.includes("Test run failed");
+            return {
+                success: !testsFailed,
+                output: stdout,
+            };
+        }
+        catch (error) {
+            console.error("Error running tests:", error);
+            return {
+                success: false,
+                output: String(error),
+            };
+        }
+    }
+    static async activateLicense(projectInfo, serial, username, password) {
+        try {
+            console.debug(`Activating Unity license for version ${projectInfo.editorVersion}`);
+            const args = ["-quit", "-serial", serial, "-username", username, "-password", password];
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const activationSuccessful = stdout.includes("successfully activated") ||
+                (!stdout.includes("License activation failed") && !stderr.includes("License activation failed"));
+            if (activationSuccessful) {
+                console.info(`Successfully activated license for Unity ${projectInfo.editorVersion}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to activate license: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error activating license:", error);
+            return false;
+        }
+    }
+    static async returnLicense(projectInfo) {
+        try {
+            console.debug(`Returning Unity license for version ${projectInfo.editorVersion}`);
+            const args = ["-quit", "-returnlicense"];
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const returnSuccessful = stdout.includes("license return succeeded") ||
+                (!stdout.includes("Failed to return license") && !stderr.includes("Failed to return license"));
+            if (returnSuccessful) {
+                console.info(`Successfully returned license for Unity ${projectInfo.editorVersion}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to return license: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error returning license:", error);
+            return false;
+        }
+    }
+    static async exportPackage(projectInfo, assetPaths, outputPath) {
+        try {
+            console.debug(`Exporting package from project`);
+            const args = ["-projectPath", projectInfo.projectPath, "-exportPackage", ...assetPaths, outputPath, "-quit"];
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const exportSuccessful = !stdout.includes("Failed to export package") && !stderr.includes("Failed to export package");
+            if (exportSuccessful) {
+                console.info(`Successfully exported package to ${outputPath}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to export package: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error exporting package:", error);
+            return false;
+        }
+    }
+    static async importPackage(projectInfo, packagePath) {
+        try {
+            console.debug(`Importing package ${packagePath} to project`);
+            const args = ["-projectPath", projectInfo.projectPath, "-importPackage", packagePath, "-quit"];
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const importSuccessful = !stdout.includes("Failed to import package") && !stderr.includes("Failed to import package");
+            if (importSuccessful) {
+                console.info(`Successfully imported package ${packagePath}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to import package: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error importing package:", error);
+            return false;
+        }
+    }
+    static async createProject(projectInfo, waitForExit = true) {
+        try {
+            console.debug(`Creating new project at ${projectInfo.projectPath}`);
+            const parentDir = path.dirname(projectInfo.projectPath);
+            await fs.ensureDir(parentDir);
+            const args = ["-createProject", projectInfo.projectPath];
+            if (waitForExit) {
+                args.push("-quit");
+            }
+            const editorInfo = { version: projectInfo.editorVersion };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+                reject: false,
+            });
+            const creationSuccessful = !stdout.includes("Failed to create project") && !stderr.includes("Failed to create project");
+            if (creationSuccessful) {
+                console.info(`Successfully created project at ${projectInfo.projectPath}`);
+                return true;
+            }
+            else {
+                console.error(`Failed to create project: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error creating project:", error);
+            return false;
+        }
+    }
+    static async openProject(projectInfo, batchmode = false, waitForExit = true) {
+        try {
+            console.debug(`Opening project at ${projectInfo.projectPath}`);
+            const args = ["-projectPath", projectInfo.projectPath];
+            if (waitForExit) {
+                args.push("-quit");
+            }
+            if (batchmode) {
+                args.push("-batchmode");
+            }
+            const editorInfo = { version: projectInfo.editorVersion };
+            const options = { reject: false };
+            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, options);
+            const openingSuccessful = !stdout.includes("Failed to open project") && !stderr.includes("Failed to open project");
+            if (openingSuccessful) {
+                console.info(`Successfully opened project`);
+                return true;
+            }
+            else {
+                console.error(`Failed to open project: ${stderr || stdout}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("Error opening project:", error);
+            return false;
+        }
+    }
+}
+function redactSensitiveArgs(argv, sensitiveKeys = ["password", "token", "secret"]) {
+    const redacted = [...argv];
+    for (let i = 0; i < redacted.length; i++) {
+        const arg = redacted[i];
+        if (arg.startsWith("--") || arg.startsWith("-")) {
+            const key = arg.replace(/^--?/, "");
+            if (sensitiveKeys.includes(key.toLowerCase())) {
+                if (i + 1 < redacted.length && !redacted[i + 1].startsWith("-")) {
+                    redacted[i + 1] = "[REDACTED]";
+                }
+            }
+        }
+        else {
+            const match = arg.match(/^--?([^=]+)=(.+)$/);
+            if (match) {
+                const key = match[1];
+                if (sensitiveKeys.includes(key.toLowerCase())) {
+                    redacted[i] = `--${key}=[REDACTED]`;
+                }
+            }
+        }
+    }
+    return redacted;
+}
+export default UnityEditor;

package/dist/esm/unityHub.d.ts

@@ -1,21 +1,17 @@
-import { EditorArchitecture, ModuleId, UnityInstallations, UnityLanguages, UnityModules } from "./types/unity.js";
+import { EditorArchitecture, ModuleId, UnityInstallations, UnityEditorLanguages, 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 readonly Languages: typeof UnityEditorLanguages;
+    static getUnityHubPath(): string;
     static isUnityHubAvailable(): Promise<boolean>;
     static execUnityHubCommand(args: string[], options?: CommandOptions): Promise<CommandResult>;
     static getInstallPath(): Promise<string>;
     static setInstallPath(path: string): Promise<void>;
     static getUnityInstallations(filter?: string): 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 addEditor(version: string, modules?: ModuleId[], architecture?: EditorArchitecture): Promise<void>;
     static getProjects(): Promise<{
         name: string;
         path: string;

package/dist/esm/unityHub.js

@@ -1,8 +1,9 @@
 import fs from "fs-extra";
 import os from "os";
 import path from "path";
-import { EditorArchitecture, UnityLanguages, UnityModules, } from "./types/unity.js";
+import { EditorArchitecture, UnityEditorLanguages, UnityModules, } from "./types/unity.js";
 import { executeCommand } from "./utils/commandExecutor.js";
+import { getUnityChangeset } from "unity-changeset";
 class UnityHub {
     static CONFIG_PATHS = {
         win32: {
@@ -22,7 +23,7 @@ class UnityHub {
         },
     };
     static Modules = UnityModules;
-    static Languages = UnityLanguages;
+    static Languages = UnityEditorLanguages;
     static platform = os.platform();
     static hubPath = this.getUnityHubPath();
     static getUnityHubPath() {
@@ -145,12 +146,12 @@ class UnityHub {
             throw error;
         }
     }
-    static async addEditor(version, changeset, modules = [], architecture = EditorArchitecture.x86_64) {
+    static async addEditor(version, modules = [], architecture = EditorArchitecture.x86_64) {
         try {
-            console.debug(`Installing Unity ${version} ${(changeset ?? "") ? `(changeset: ${changeset})` : ""}`);
+            const data = await getUnityChangeset(version);
             const args = ["install", "-v", version];
-            if (changeset) {
-                args.push("--changeset", changeset);
+            if (data) {
+                args.push("--changeset", data.changeset);
             }
             if (modules.length > 0) {
                 args.push("--module");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@notask/unity-cli-tools",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/esm/index.d.ts",
@@ -21,7 +21,7 @@
     "url": "https://github.com/NoTaskStudios/unity-cli-tools.git"
   },
   "scripts": {
-    "clean": "rimraf dist dist-cjs",
+    "clean": "rimraf dist",
     "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",
@@ -44,7 +44,8 @@
   "description": "A tools for Unity command line development.",
   "dependencies": {
     "execa": "^9.5.2",
-    "fs-extra": "^11.3.0"
+    "fs-extra": "^11.3.0",
+    "unity-changeset": "2.5.0"
   },
   "devDependencies": {
     "@eslint/js": "9.24.0",