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

package/dist/esm/unityHub.js

@@ -1,25 +1,47 @@
 import fs from "fs-extra";
 import os from "os";
+import path from "path";
 import { EditorArchitecture, } from "./types/unity.js";
 import { executeCommand } from "./utils/commandExecutor.js";
 import { getUnityChangeset } from "unity-changeset";
 import { UnityHubInstallerEvent } from "./events/hubEventEmitter.js";
-import { UnityConfig } from "./configs/unityConfig.js";
+import { ok, err, UnityHubNotFoundError, UnityCommandError, UnityInstallationError, UnityProjectError, InvalidArgumentError, } from "./errors/index.js";
 class UnityHub {
-    static unityConfig = UnityConfig.getPlatformConfig();
+    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 platform = os.platform();
+    static hubPath = this.getUnityHubPath();
     static getUnityHubPath() {
-        return this.unityConfig.hub.hubDir;
+        const envPath = process.env.UNITY_HUB_PATH ?? "";
+        if (envPath && fs.existsSync(envPath)) {
+            return envPath;
+        }
+        return UnityHub.CONFIG_PATHS[this.platform].hub || "";
     }
     static getProjectsPath() {
-        return this.unityConfig.hub.projects;
+        return UnityHub.CONFIG_PATHS[this.platform].projects || "";
     }
     static getProjectDirPath() {
-        return this.unityConfig.hub.projectDir;
+        return UnityHub.CONFIG_PATHS[this.platform].projectDir || "";
     }
     static async isUnityHubAvailable() {
         try {
-            const hubPath = this.getUnityHubPath();
-            return !!hubPath && fs.existsSync(hubPath);
+            return !!this.hubPath && fs.existsSync(this.hubPath);
         }
         catch (error) {
             console.error("Error checking Unity Hub availability:", error);
@@ -30,122 +52,124 @@ class UnityHub {
         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.unityConfig.platform !== "linux" ? "--" : "", "--headless", ...args].filter(Boolean);
-            console.debug(`Executing Unity Hub command: ${this.getUnityHubPath()} ${hubArgs.join(" ")}`);
-            return await executeCommand(this.unityConfig.hub.hubDir, hubArgs, options);
-        }
-        catch (error) {
-            console.error("Error executing Unity Hub command:", error);
-            return {
-                success: false,
-                stdout: "",
-                stderr: String(error),
-                exitCode: -1,
-            };
+            return err(new UnityHubNotFoundError("Unity Hub is not available", { hubPath: this.hubPath }));
         }
+        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);
     }
     static async getInstallPath() {
-        const { stdout, stderr } = await this.execUnityHubCommand(["install-path", "-g"], {
+        const result = await this.execUnityHubCommand(["install-path", "-g"], {
             reject: false,
         });
-        if (stderr) {
-            throw new Error(`Error getting install path: ${stderr}`);
+        if (!result.success) {
+            return result;
+        }
+        if (result.value.stderr) {
+            return err(new UnityCommandError(`Error getting install path: ${result.value.stderr}`, result.value.stdout, result.value.stderr, result.value.exitCode));
         }
-        return stdout;
+        return ok(result.value.stdout.trim());
     }
     static async setInstallPath(path) {
-        const { stdout, stderr } = await this.execUnityHubCommand(["install-path", "-s", path], {
+        const result = await this.execUnityHubCommand(["install-path", "-s", path], {
             reject: false,
         });
-        if (stderr) {
-            throw new Error(`Error setting install path: ${stderr}`);
+        if (!result.success) {
+            return result;
+        }
+        if (result.value.stderr) {
+            return err(new UnityCommandError(`Error setting install path: ${result.value.stderr}`, result.value.stdout, result.value.stderr, result.value.exitCode));
         }
-        console.debug(`Install path set to: ${stdout}`);
+        console.debug(`Install path set to: ${result.value.stdout}`);
+        return ok(undefined);
     }
     static async getUnityInstallations(filter = "i") {
         if (!["i", "a", "r"].includes(filter)) {
-            throw new Error(`Invalid filter "${filter}". Use "i" for installed, "a" for all, or "r" for available releases.`);
+            return err(new InvalidArgumentError(`Invalid filter "${filter}". Use "i" for installed, "a" for all, or "r" for available releases.`, { filter, validFilters: ["i", "a", "r"] }));
         }
-        const { stdout, stderr } = await this.execUnityHubCommand(["editors", `-${filter}`], {
+        const result = await this.execUnityHubCommand(["editors", `-${filter}`], {
             reject: false,
         });
+        if (!result.success) {
+            return result;
+        }
+        const { stdout, stderr } = result.value;
         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.`);
+        if (stderr) {
+            return err(new UnityCommandError(`Get installations command warning/error: ${stderr}`, stdout, stderr, result.value.exitCode));
+        }
+        if (!isSuccess) {
+            return err(new UnityInstallationError("No Unity installations found. Consider installing a Unity version using Unity Hub.", {
+                filter,
+            }));
+        }
         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 (version && unityPath) {
+                installations[version] = unityPath;
+            }
         });
-        if (Object.keys(installations).length <= 0)
-            throw new Error("No unity installations found.");
-        return installations;
+        if (Object.keys(installations).length <= 0) {
+            return err(new UnityInstallationError("No Unity installations found.", { filter }));
+        }
+        return ok(installations);
     }
     static async addModule(editorVersion, modules, childModules = true) {
-        try {
-            console.debug(`Adding module ${modules} to Unity ${editorVersion}`);
-            const args = ["install-modules", "-v", editorVersion];
-            if (modules.length > 0) {
-                args.push(...["--module", modules.join(" ")]);
-                if (childModules) {
-                    args.push("--child-modules");
-                }
-            }
-            else {
-                throw new Error("No module IDs provided.");
-            }
-            const installerEmitter = new UnityHubInstallerEvent();
-            this.execUnityHubCommand(args, {
-                reject: false,
-                onStdout: (data) => installerEmitter.Progress(data),
-            }).catch((error) => {
-                console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, error);
-            });
-            return installerEmitter;
+        if (modules.length === 0) {
+            return err(new InvalidArgumentError("No module IDs provided.", { editorVersion, modules }));
         }
-        catch (error) {
-            console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, error);
-            throw error;
+        console.debug(`Adding module ${modules} to Unity ${editorVersion}`);
+        const args = ["install-modules", "-v", editorVersion, "--module", modules.join(" ")];
+        if (childModules) {
+            args.push("--child-modules");
         }
+        const installerEmitter = new UnityHubInstallerEvent();
+        this.execUnityHubCommand(args, {
+            reject: false,
+            onStdout: (data) => installerEmitter.Progress(data),
+        })
+            .then((result) => {
+            if (!result.success) {
+                console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, result.error);
+            }
+        })
+            .catch((error) => {
+            console.error(`Error adding module ${modules} to Unity ${editorVersion}:`, error);
+        });
+        return ok(installerEmitter);
     }
     static async addEditor(version, modules = [], architecture) {
         try {
             const data = await getUnityChangeset(version);
-            const args = ["install", "-v", version];
-            args.push("--changeset", data.changeset);
+            const args = ["install", "-v", version, "--changeset", data.changeset];
             if (modules.length > 0) {
-                args.push("--module");
-                args.push(modules.join(" "));
+                args.push("--module", modules.join(" "));
             }
             if (!architecture) {
                 const arch = os.arch() || process.arch;
-                const defaultArchitecture = arch === "arm64" || arch === "arm" ? EditorArchitecture.arm64 : EditorArchitecture.x86_64;
-                architecture = defaultArchitecture;
+                architecture = arch === "arm64" || arch === "arm" ? EditorArchitecture.arm64 : EditorArchitecture.x86_64;
             }
             args.push("--architecture", architecture);
             const installerEmitter = new UnityHubInstallerEvent();
             this.execUnityHubCommand(args, {
                 reject: false,
                 onStdout: (data) => installerEmitter.Progress(data),
-            }).catch((error) => {
+            })
+                .then((result) => {
+                if (!result.success) {
+                    console.error(`Error installing Unity ${version}:`, result.error);
+                }
+            })
+                .catch((error) => {
                 console.error(`Error installing Unity ${version}:`, error);
             });
-            return installerEmitter;
+            return ok(installerEmitter);
         }
         catch (error) {
             console.error(error);
-            throw error;
+            return err(new UnityInstallationError(`Failed to install Unity ${version}: ${String(error)}`, { version, modules, architecture }));
         }
     }
     static async getProjects() {
@@ -153,19 +177,20 @@ class UnityHub {
             const projectsPath = this.getProjectsPath();
             if (!projectsPath || !fs.existsSync(projectsPath)) {
                 console.debug(`Projects file not found at: ${projectsPath}`);
-                return [];
+                return err(new UnityProjectError(`Projects file not found at: ${projectsPath}`, { projectsPath }));
             }
             const projectsData = await fs.readJson(projectsPath);
             const projects = Object.values(projectsData.data);
-            return projects.map((project) => ({
+            const mappedProjects = projects.map((project) => ({
                 name: project.title,
                 path: project.path,
                 version: project.version,
             }));
+            return ok(mappedProjects);
         }
         catch (error) {
             console.error("Error getting recent projects:", error);
-            return [];
+            return err(new UnityProjectError(`Failed to get projects: ${String(error)}`));
         }
     }
     static async getDefaultProjectsDirectory() {
@@ -173,14 +198,14 @@ class UnityHub {
             const projectDirPath = this.getProjectDirPath();
             if (!projectDirPath || !fs.existsSync(projectDirPath)) {
                 console.debug(`Project directory file not found at: ${projectDirPath}`);
-                return null;
+                return ok(null);
             }
             const projectDirData = await fs.readJson(projectDirPath);
-            return projectDirData.directoryPath ?? null;
+            return ok(projectDirData.directoryPath ?? null);
         }
         catch (error) {
             console.error("Error getting default project directory:", error);
-            return null;
+            return err(new UnityProjectError(`Failed to get default project directory: ${String(error)}`));
         }
     }
 }

package/dist/esm/utils/commandExecutor.d.ts

@@ -1,4 +1,6 @@
 import { Options } from "execa";
+import { Result } from "../errors/index.js";
+import { UnityCommandError } from "../errors/index.js";
 export interface CommandOptions extends Options {
     reject?: boolean;
     timeout?: number;
@@ -7,10 +9,9 @@ export interface CommandOptions extends Options {
     env?: Record<string, string>;
     cwd?: string;
 }
-export interface CommandResult {
-    success: boolean;
+export interface CommandOutput {
     stdout: string;
     stderr: string;
     exitCode?: number;
 }
-export declare function executeCommand(executable: string, args: string[], options?: CommandOptions): Promise<CommandResult>;
+export declare function executeCommand(executable: string, args: string[], options?: CommandOptions): Promise<Result<CommandOutput, UnityCommandError>>;

package/dist/esm/utils/commandExecutor.js

@@ -1,4 +1,6 @@
 import { execa } from "execa";
+import { ok, err } from "../errors/index.js";
+import { UnityCommandError } from "../errors/index.js";
 export async function executeCommand(executable, args, options = {}) {
     try {
         const streamOutput = options.onStdout || options.onStderr;
@@ -37,19 +39,16 @@ export async function executeCommand(executable, args, options = {}) {
             }
         }
         const { stdout, stderr, exitCode } = await subprocess;
-        return {
-            success: true,
+        return ok({
             stdout,
             stderr,
             exitCode,
-        };
+        });
     }
     catch (error) {
-        return {
-            success: false,
-            stdout: error.stdout ?? "",
-            stderr: error.stderr ?? String(error),
-            exitCode: error.exitCode,
-        };
+        const stdout = error.stdout ?? "";
+        const stderr = error.stderr ?? String(error);
+        const exitCode = error.exitCode;
+        return err(new UnityCommandError(`Command execution failed: ${executable} ${args.join(" ")}`, stdout, stderr, exitCode, { executable, args }));
     }
 }

package/package.json

@@ -1,70 +1,70 @@
-{
-  "name": "@notask/unity-cli-tools",
-  "version": "1.2.0-rc.1",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "dist/esm/index.d.ts",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js",
-      "types": "./dist/esm/index.d.ts"
-    }
-  },
-  "private": false,
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/NoTaskStudios/unity-cli-tools.git"
-  },
-  "scripts": {
-    "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",
-    "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",
-    "unity-changeset": "2.5.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"
-  }
-}
+{
+  "name": "@notask/unity-cli-tools",
+  "version": "2.0.0",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/esm/index.d.ts"
+    }
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/NoTaskStudios/unity-cli-tools.git"
+  },
+  "scripts": {
+    "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",
+    "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",
+    "unity-changeset": "3.1.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/sandbox/index.js

@@ -0,0 +1,51 @@
+import { UnityEditor, UnityHub, InstallerEventType, UnityModules, isOk, isErr } from "@notask/unity-cli-tools";
+
+// Check if Unity Hub is available
+const isAvailable = await UnityHub.isUnityHubAvailable();
+
+if (!isAvailable) {
+  console.error("Unity Hub is not available on this system.");
+  process.exit(1);
+} else {
+  console.log("Unity Hub is available.");
+}
+
+// Get projects from Unity Hub
+const result = await UnityHub.getProjects();
+
+if (isOk(result)) {
+  const projects = result.value;
+  // Returns: [{ name: 'ProjectName', path: '/path/to/project', version: '2022.3.60f1' }, ...]
+  console.log("Projects:", projects);
+}
+
+// Get default projects directory
+const dirResult = await UnityHub.getDefaultProjectsDirectory();
+
+if (isOk(dirResult)) {
+  const defaultDir = dirResult.value; // string | null
+  console.log("Default directory:", defaultDir);
+}
+
+const addModuleEvent = await UnityHub.addModule("6000.3.2f1", UnityModules.WebGLBuildSupport);
+
+if (!isOk(addModuleEvent)) {
+  console.error("Failed to start installation:", addModuleEvent.error);
+}
+
+const installer = addModuleEvent.value;
+// Listen to progress events
+installer.on(InstallerEventType.Progress, (events) => {
+  console.log(
+    "Progress:",
+    events.map((e) => `${e.module}: ${e.status} ${e.progress || 0}%`)
+  );
+});
+
+installer.on(InstallerEventType.Error, (errorEvents) => {
+  console.error("Installation error:", errorEvents);
+});
+
+installer.on(InstallerEventType.Completed, (events) => {
+  console.log("Installation completed!");
+});