@notask/unity-cli-tools 1.1.2 → 2.0.0

package/dist/esm/index.js

@@ -2,3 +2,4 @@ export { default as UnityHub } from "./unityHub.js";
 export { default as UnityEditor } from "./unityEditor.js";
 export { UnityHubInstallerEvent } from "./events/hubEventEmitter.js";
 export * from "./types/unity.js";
+export * from "./errors/index.js";

package/dist/esm/unityEditor.d.ts

@@ -1,19 +1,17 @@
 import { ProjectInfo, TestMode, UnityBuildTarget, UnityEditorInfo } from "./types/unity.js";
-import { CommandOptions, CommandResult } from "./utils/commandExecutor.js";
+import { CommandOptions, CommandOutput } from "./utils/commandExecutor.js";
+import { Result, UnityEditorNotFoundError, UnityCommandError, UnityTestError, UnityLicenseError, UnityPackageError, UnityProjectError } from "./errors/index.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<CommandResult>;
-    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, useHub?: boolean, batchmode?: boolean, waitForExit?: boolean): Promise<boolean>;
+    static execUnityEditorCommand(editorInfo: UnityEditorInfo, args: string[], options?: CommandOptions): Promise<Result<CommandOutput, UnityEditorNotFoundError | UnityCommandError>>;
+    static executeMethod(projectInfo: ProjectInfo, method: string, args?: string[], options?: CommandOptions): Promise<Result<CommandOutput, UnityEditorNotFoundError | UnityCommandError>>;
+    static runTests(projectInfo: ProjectInfo, testPlatform?: TestMode | UnityBuildTarget, testCategory?: string): Promise<Result<string, UnityEditorNotFoundError | UnityCommandError | UnityTestError>>;
+    static activateLicense(projectInfo: ProjectInfo, serial: string, username: string, password: string): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityLicenseError>>;
+    static returnLicense(projectInfo: ProjectInfo): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityLicenseError>>;
+    static exportPackage(projectInfo: ProjectInfo, assetPaths: string[], outputPath: string): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityPackageError>>;
+    static importPackage(projectInfo: ProjectInfo, packagePath: string): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityPackageError>>;
+    static createProject(projectInfo: ProjectInfo, waitForExit?: boolean): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityProjectError>>;
+    static openProject(projectInfo: ProjectInfo, useHub?: boolean, batchmode?: boolean, waitForExit?: boolean): Promise<Result<void, UnityEditorNotFoundError | UnityCommandError | UnityProjectError>>;
 }
 export default UnityEditor;

package/dist/esm/unityEditor.js

@@ -4,6 +4,7 @@ import path from "path";
 import { TestMode } from "./types/unity.js";
 import { executeCommand } from "./utils/commandExecutor.js";
 import { redactSensitiveArgs } from "./utils/security.js";
+import { ok, err, UnityEditorNotFoundError, UnityCommandError, UnityTestError, UnityLicenseError, UnityPackageError, UnityProjectError, } from "./errors/index.js";
 class UnityEditor {
     static UNITY_PATHS = {
         win32: {
@@ -36,195 +37,158 @@ class UnityEditor {
         }
     }
     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,
-            };
-        }
+        const unityPath = this.getUnityExecutablePath(editorInfo.version);
+        if (!fs.existsSync(unityPath)) {
+            return err(new UnityEditorNotFoundError(editorInfo.version, unityPath));
+        }
+        const editorArgs = [...args];
+        const redactedArgs = redactSensitiveArgs(editorArgs);
+        console.debug(`Executing Unity Editor command: ${unityPath} ${redactedArgs.join(" ")}`);
+        return await 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,
-            };
-        }
-        catch (error) {
-            console.error("Error executing method:", error);
-            return {
-                success: false,
-                stdout: "",
-                stderr: String(error),
-                exitCode: -1,
-            };
-        }
+        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;
+        }
+        if (result.value.stderr) {
+            console.error(`Error executing method: ${result.value.stderr}`);
+            return err(new 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 = TestMode.EditMode, testCategory) {
-        try {
-            console.debug(`Running ${testPlatform} tests for project ${testCategory ? ` in category ${testCategory}` : ""}`);
-            const args = [
-                "-batchmode",
-                "-quit",
-                "-projectPath",
-                projectInfo.projectPath,
-                "-runTests",
-                "-testPlatform",
+        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 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 err(new UnityTestError("Some tests failed", stdout, {
+                projectInfo,
                 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),
-            };
+                testCategory,
+            }));
         }
+        return 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;
-            }
-        }
-        catch (error) {
-            console.error("Error activating license:", error);
-            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;
+        }
+        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 ok(undefined);
+        }
+        return err(new 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;
-            }
-        }
-        catch (error) {
-            console.error("Error returning license:", error);
-            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;
+        }
+        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 ok(undefined);
+        }
+        return err(new 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;
-            }
-        }
-        catch (error) {
-            console.error("Error exporting package:", error);
-            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;
+        }
+        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 ok(undefined);
+        }
+        return err(new 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;
-            }
-        }
-        catch (error) {
-            console.error("Error importing package:", error);
-            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;
+        }
+        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 ok(undefined);
+        }
+        return err(new UnityPackageError(`Failed to import package: ${stderr || stdout}`, {
+            projectInfo,
+            packagePath,
+            stderr,
+            stdout,
+        }));
     }
     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.dirname(projectInfo.projectPath);
             await fs.ensureDir(parentDir);
             const args = ["-createProject", projectInfo.projectPath];
@@ -232,53 +196,57 @@ class UnityEditor {
                 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 ok(undefined);
             }
+            return err(new UnityProjectError(`Failed to create project: ${stderr || stdout}`, {
+                projectInfo,
+                stderr,
+                stdout,
+            }));
         }
         catch (error) {
             console.error("Error creating project:", error);
-            return false;
+            return err(new UnityProjectError(`Error creating project: ${String(error)}`, { projectInfo }));
         }
     }
     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;
-        }
-        catch (error) {
-            console.error("Error opening project:", error);
-            return false;
-        }
+        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 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 ok(undefined);
+        }
+        return err(new UnityProjectError(`Failed to open project: ${stderr || stdout}`, {
+            projectInfo,
+            stderr,
+            stdout,
+        }));
     }
 }
 export default UnityEditor;

package/dist/esm/unityHub.d.ts

@@ -1,21 +1,22 @@
 import { EditorArchitecture, ModuleId, UnityInstallations } from "./types/unity.js";
-import { CommandOptions, CommandResult } from "./utils/commandExecutor.js";
-import { UnityHubInstallerEvent } from "./events/hubEventEmitter.ts";
+import { CommandOptions, CommandOutput } from "./utils/commandExecutor.js";
+import { UnityHubInstallerEvent } from "./events/hubEventEmitter.js";
+import { Result, UnityHubNotFoundError, UnityCommandError, UnityInstallationError, UnityProjectError, InvalidArgumentError } from "./errors/index.js";
 declare class UnityHub {
     private static CONFIG_PATHS;
     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<UnityHubInstallerEvent>;
-    static addEditor(version: string, modules?: ModuleId[], architecture?: EditorArchitecture): Promise<UnityHubInstallerEvent>;
-    static getProjects(): Promise<{
+    static execUnityHubCommand(args: string[], options?: CommandOptions): Promise<Result<CommandOutput, UnityHubNotFoundError | UnityCommandError>>;
+    static getInstallPath(): Promise<Result<string, UnityHubNotFoundError | UnityCommandError>>;
+    static setInstallPath(path: string): Promise<Result<void, UnityHubNotFoundError | UnityCommandError>>;
+    static getUnityInstallations(filter?: string): Promise<Result<UnityInstallations, InvalidArgumentError | UnityHubNotFoundError | UnityCommandError | UnityInstallationError>>;
+    static addModule(editorVersion: string, modules: ModuleId[], childModules?: boolean): Promise<Result<UnityHubInstallerEvent, InvalidArgumentError>>;
+    static addEditor(version: string, modules?: ModuleId[], architecture?: EditorArchitecture): Promise<Result<UnityHubInstallerEvent, UnityInstallationError>>;
+    static getProjects(): Promise<Result<{
         name: string;
         path: string;
         version: string;
-    }[]>;
-    static getDefaultProjectsDirectory(): Promise<string | null>;
+    }[], UnityProjectError>>;
+    static getDefaultProjectsDirectory(): Promise<Result<string | null, UnityProjectError>>;
 }
 export default UnityHub;