@notask/unity-cli-tools 1.2.0-rc.1 → 2.0.0

package/dist/cjs/unityEditor.js

@@ -3,20 +3,32 @@ 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");
 const security_js_1 = require("./utils/security.js");
-const unityConfig_ts_1 = require("./configs/unityConfig.js");
+const index_js_1 = require("./errors/index.js");
 class UnityEditor {
-    static unityConfig = unityConfig_ts_1.UnityConfig.getPlatformConfig().editor;
+    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 unityPath = path_1.default.join(this.unityConfig.base, version, this.unityConfig.executable);
-        return unityPath;
-    }
-    static getUnityTemplatesPath(version) {
-        const unityPath = path_1.default.join(this.unityConfig.base, version, this.unityConfig.projectTemplates);
+        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) {
@@ -30,276 +42,216 @@ class UnityEditor {
         }
     }
     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 = (0, security_js_1.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,
-            };
+        const unityPath = this.getUnityExecutablePath(editorInfo.version);
+        if (!fs_extra_1.default.existsSync(unityPath)) {
+            return (0, index_js_1.err)(new index_js_1.UnityEditorNotFoundError(editorInfo.version, unityPath));
         }
+        const editorArgs = [...args];
+        const redactedArgs = (0, security_js_1.redactSensitiveArgs)(editorArgs);
+        console.debug(`Executing Unity Editor command: ${unityPath} ${redactedArgs.join(" ")}`);
+        return await (0, commandExecutor_js_1.executeCommand)(unityPath, editorArgs, options);
     }
     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 {
-                    success: false,
-                    stdout: "",
-                    stderr: stderr,
-                    exitCode: -1,
-                };
-            }
-            return {
-                success: true,
-                stdout: stdout,
-                stderr: "",
-                exitCode: 0,
-            };
+        console.debug(`Executing method ${method} in Unity Editor`);
+        const unityPath = this.getUnityExecutablePath(projectInfo.editorVersion);
+        const editorArgs = ["-projectPath", projectInfo.projectPath, "-executeMethod", method, ...args];
+        const result = await this.execUnityEditorCommand({ version: projectInfo.editorVersion, path: unityPath }, editorArgs, options);
+        if (!result.success) {
+            console.error(`Error executing method: ${result.error.message}`);
+            return result;
         }
-        catch (error) {
-            console.error("Error executing method:", error);
-            return {
-                success: false,
-                stdout: "",
-                stderr: String(error),
-                exitCode: -1,
-            };
+        if (result.value.stderr) {
+            console.error(`Error executing method: ${result.value.stderr}`);
+            return (0, index_js_1.err)(new index_js_1.UnityCommandError(`Error executing method ${method}: ${result.value.stderr}`, result.value.stdout, result.value.stderr, result.value.exitCode, { method, projectInfo }));
         }
+        return result;
     }
     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,
-            };
+        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);
         }
-        catch (error) {
-            console.error("Error running tests:", error);
-            return {
-                success: false,
-                output: String(error),
-            };
+        const editorInfo = { version: projectInfo.editorVersion };
+        const result = await this.execUnityEditorCommand(editorInfo, args, {
+            reject: false,
+        });
+        if (!result.success) {
+            return result;
+        }
+        const { stdout, stderr } = result.value;
+        const testsFailed = stdout.includes("Some tests failed") || stdout.includes("Test run failed") || stderr.includes("Test run failed");
+        if (testsFailed) {
+            return (0, index_js_1.err)(new index_js_1.UnityTestError("Some tests failed", stdout, {
+                projectInfo,
+                testPlatform,
+                testCategory,
+            }));
         }
+        return (0, index_js_1.ok)(stdout);
     }
     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.debug(`Successfully activated license for Unity ${projectInfo.editorVersion}`);
-                return true;
-            }
-            else {
-                console.error(`Failed to activate license: ${stderr || stdout}`);
-                return false;
-            }
+        console.debug(`Activating Unity license for version ${projectInfo.editorVersion}`);
+        const args = ["-quit", "-serial", serial, "-username", username, "-password", password];
+        const editorInfo = { version: projectInfo.editorVersion };
+        const result = await this.execUnityEditorCommand(editorInfo, args, {
+            reject: false,
+        });
+        if (!result.success) {
+            return result;
         }
-        catch (error) {
-            console.error("Error activating license:", error);
-            return false;
+        const { stdout, stderr } = result.value;
+        const activationSuccessful = stdout.includes("successfully activated") ||
+            (!stdout.includes("License activation failed") && !stderr.includes("License activation failed"));
+        if (activationSuccessful) {
+            console.debug(`Successfully activated license for Unity ${projectInfo.editorVersion}`);
+            return (0, index_js_1.ok)(undefined);
         }
+        return (0, index_js_1.err)(new index_js_1.UnityLicenseError(`Failed to activate license: ${stderr || stdout}`, {
+            projectInfo,
+            stderr,
+            stdout,
+        }));
     }
     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.debug(`Successfully returned license for Unity ${projectInfo.editorVersion}`);
-                return true;
-            }
-            else {
-                console.error(`Failed to return license: ${stderr || stdout}`);
-                return false;
-            }
+        console.debug(`Returning Unity license for version ${projectInfo.editorVersion}`);
+        const args = ["-quit", "-returnlicense"];
+        const editorInfo = { version: projectInfo.editorVersion };
+        const result = await this.execUnityEditorCommand(editorInfo, args, {
+            reject: false,
+        });
+        if (!result.success) {
+            return result;
         }
-        catch (error) {
-            console.error("Error returning license:", error);
-            return false;
+        const { stdout, stderr } = result.value;
+        const returnSuccessful = stdout.includes("license return succeeded") ||
+            (!stdout.includes("Failed to return license") && !stderr.includes("Failed to return license"));
+        if (returnSuccessful) {
+            console.debug(`Successfully returned license for Unity ${projectInfo.editorVersion}`);
+            return (0, index_js_1.ok)(undefined);
         }
+        return (0, index_js_1.err)(new index_js_1.UnityLicenseError(`Failed to return license: ${stderr || stdout}`, {
+            projectInfo,
+            stderr,
+            stdout,
+        }));
     }
     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.debug(`Successfully exported package to ${outputPath}`);
-                return true;
-            }
-            else {
-                console.error(`Failed to export package: ${stderr || stdout}`);
-                return false;
-            }
+        console.debug(`Exporting package from project`);
+        const args = ["-projectPath", projectInfo.projectPath, "-exportPackage", ...assetPaths, outputPath, "-quit"];
+        const editorInfo = { version: projectInfo.editorVersion };
+        const result = await this.execUnityEditorCommand(editorInfo, args, {
+            reject: false,
+        });
+        if (!result.success) {
+            return result;
         }
-        catch (error) {
-            console.error("Error exporting package:", error);
-            return false;
+        const { stdout, stderr } = result.value;
+        const exportSuccessful = !stdout.includes("Failed to export package") && !stderr.includes("Failed to export package");
+        if (exportSuccessful) {
+            console.debug(`Successfully exported package to ${outputPath}`);
+            return (0, index_js_1.ok)(undefined);
         }
+        return (0, index_js_1.err)(new index_js_1.UnityPackageError(`Failed to export package: ${stderr || stdout}`, {
+            projectInfo,
+            assetPaths,
+            outputPath,
+            stderr,
+            stdout,
+        }));
     }
     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.debug(`Successfully imported package ${packagePath}`);
-                return true;
-            }
-            else {
-                console.error(`Failed to import package: ${stderr || stdout}`);
-                return false;
-            }
+        console.debug(`Importing package ${packagePath} to project`);
+        const args = ["-projectPath", projectInfo.projectPath, "-importPackage", packagePath, "-quit"];
+        const editorInfo = { version: projectInfo.editorVersion };
+        const result = await this.execUnityEditorCommand(editorInfo, args, {
+            reject: false,
+        });
+        if (!result.success) {
+            return result;
         }
-        catch (error) {
-            console.error("Error importing package:", error);
-            return false;
+        const { stdout, stderr } = result.value;
+        const importSuccessful = !stdout.includes("Failed to import package") && !stderr.includes("Failed to import package");
+        if (importSuccessful) {
+            console.debug(`Successfully imported package ${packagePath}`);
+            return (0, index_js_1.ok)(undefined);
         }
+        return (0, index_js_1.err)(new index_js_1.UnityPackageError(`Failed to import package: ${stderr || stdout}`, {
+            projectInfo,
+            packagePath,
+            stderr,
+            stdout,
+        }));
     }
-    static async createProject(projectInfo, quit = false, useHub = true) {
+    static async createProject(projectInfo, waitForExit = true) {
+        console.debug(`Creating new project at ${projectInfo.projectPath}`);
         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 (useHub)
-                args.push("-useHub", "-hubIPC");
-            if (quit)
+            if (waitForExit) {
                 args.push("-quit");
+            }
             const editorInfo = { version: projectInfo.editorVersion };
-            const { stdout, stderr } = await this.execUnityEditorCommand(editorInfo, args, {
+            const result = await this.execUnityEditorCommand(editorInfo, args, {
                 reject: false,
             });
+            if (!result.success) {
+                return result;
+            }
+            const { stdout, stderr } = result.value;
             const creationSuccessful = !stdout.includes("Failed to create project") && !stderr.includes("Failed to create project");
             if (creationSuccessful) {
                 console.debug(`Successfully created project at ${projectInfo.projectPath}`);
-                return true;
-            }
-            else {
-                console.error(`Failed to create project: ${stderr || stdout}`);
-                return false;
+                return (0, index_js_1.ok)(undefined);
             }
+            return (0, index_js_1.err)(new index_js_1.UnityProjectError(`Failed to create project: ${stderr || stdout}`, {
+                projectInfo,
+                stderr,
+                stdout,
+            }));
         }
         catch (error) {
             console.error("Error creating project:", error);
-            return false;
+            return (0, index_js_1.err)(new index_js_1.UnityProjectError(`Error creating project: ${String(error)}`, { projectInfo }));
         }
     }
-    static async createProjectFromTemplate(projectInfo, templatePath, quit = false, useHub = true) {
-        try {
-            console.debug(`Creating new project from template at ${projectInfo.projectPath}`);
-            const parentDir = path_1.default.dirname(projectInfo.projectPath);
-            await fs_extra_1.default.ensureDir(parentDir);
-            const args = ["-createProject", projectInfo.projectPath, "-cloneFromTemplate", templatePath];
-            if (quit)
-                args.push("-quit");
-            if (useHub)
-                args.push("-useHub", "-hubIPC");
-            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.debug(`Successfully created project from template at ${projectInfo.projectPath}`);
-                return true;
-            }
-            else {
-                console.error(`Failed to create project from template: ${stderr || stdout}`);
-                return false;
-            }
+    static async openProject(projectInfo, useHub = true, batchmode = false, waitForExit = true) {
+        console.debug(`Opening project at ${projectInfo.projectPath}`);
+        const args = ["-projectPath", projectInfo.projectPath];
+        if (waitForExit) {
+            args.push("-quit");
         }
-        catch (error) {
-            console.error("Error creating project from template:", error);
-            return false;
+        if (batchmode) {
+            args.push("-batchmode");
         }
-    }
-    static async openProject(projectInfo, useHub = true, 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");
-            if (useHub)
-                args.push(...["-useHub", "-hubIPC"]);
-            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.debug(`Successfully opened project`);
-            }
-            else {
-                console.error(`Failed to open project: ${stderr || stdout}`);
-            }
-            return openingSuccessful;
+        if (useHub) {
+            args.push("-useHub", "-hubIPC");
         }
-        catch (error) {
-            console.error("Error opening project:", error);
-            return false;
+        const editorInfo = { version: projectInfo.editorVersion };
+        const result = await this.execUnityEditorCommand(editorInfo, args, { reject: false });
+        if (!result.success) {
+            return result;
+        }
+        const { stdout, stderr } = result.value;
+        const openingSuccessful = !stdout.includes("Failed to open project") && !stderr.includes("Failed to open project");
+        if (openingSuccessful) {
+            console.debug(`Successfully opened project`);
+            return (0, index_js_1.ok)(undefined);
         }
+        return (0, index_js_1.err)(new index_js_1.UnityProjectError(`Failed to open project: ${stderr || stdout}`, {
+            projectInfo,
+            stderr,
+            stdout,
+        }));
     }
 }
 exports.default = UnityEditor;