add Rosetta 2 exec on mac

fix licensing docs
add support for floating license config as path AND base64 string
fix occasional race condition when starting editor process exits faster than logs can be seen

Author: StephenHodgson

README.md

@@ -61,8 +61,10 @@ unity-cli setup-unity --unity-version 2022.3.x --modules android,ios
 
 #### Activate a Unity License
 
+Supports personal, professional, and floating licenses (using a license server configuration).
+
 ```bash
-unity-cli activate-license --email <your-email> --password <your-password> --serial <your-serial>
+unity-cli activate-license --license personal --email <your-email> --password <your-password>
 ```
 
 #### Create a New Project from a Template

src/cli.ts

@@ -36,11 +36,11 @@ program.command('license-version')
 
 program.command('activate-license')
     .description('Activate a Unity license.')
+    .option('-l, --license <license>', 'License type (personal, professional, floating). Required.')
     .option('-e, --email <email>', 'Email associated with the Unity account. Required when activating a personal or professional license.')
     .option('-p, --password <password>', 'Password for the Unity account. Required when activating a personal or professional license.')
     .option('-s, --serial <serial>', 'License serial number. Required when activating a professional license.')
-    .option('-l, --license <license>', 'License type (personal, professional, floating).')
-    .option('-c, --config <config>', 'Path to the configuration file. Required when activating a floating license.')
+    .option('-c, --config <config>', 'Path to the configuration file, or base64 encoded JSON string. Required when activating a floating license.')
     .option('--verbose', 'Enable verbose logging.')
     .action(async (options) => {
         if (options.verbose) {

src/license-client.ts

@@ -354,8 +354,19 @@ export class LicensingClient {
                         throw new Error(`Unsupported platform: ${process.platform}`);
                 }
 
+                // Ensure the services directory exists
+                if (!fs.existsSync(servicesPath)) {
+                    await fs.promises.mkdir(servicesPath, { recursive: true });
+                }
+
                 const servicesConfigPath = path.join(servicesPath, 'services-config.json');
-                await fs.promises.writeFile(servicesConfigPath, Buffer.from(options.servicesConfig, 'base64'));
+
+                if (fs.existsSync(options.servicesConfig)) {
+                    await fs.promises.copyFile(options.servicesConfig, servicesConfigPath);
+                }
+                else {
+                    await fs.promises.writeFile(servicesConfigPath, Buffer.from(options.servicesConfig, 'base64'));
+                }
                 break;
             }
             default: { // personal and professional license activation

src/unity-editor.ts

@@ -151,7 +151,7 @@ export class UnityEditor {
      */
     public async Run(command: EditorCommand): Promise<void> {
         let isCancelled = false;
-        let exitCode: number = 1;
+        let exitCode: number | undefined = undefined;
         let procInfo: ProcInfo | null = null;
         let logTail: LogTailResult | null = null;
         let unityProcess: ChildProcessByStdio<null, null, null>;
@@ -196,6 +196,7 @@ export class UnityEditor {
             }
 
             const logPath: string = GetArgumentValueAsString('-logFile', command.args);
+            logTail = TailLogFile(logPath);
             const commandStr = `\x1b[34m${this.editorPath} ${command.args.join(' ')}\x1b[0m`;
             this.logger.startGroup(commandStr);
 
@@ -211,6 +212,13 @@ export class UnityEditor {
                     }
                 });
             } else {
+                if (process.platform === 'darwin') {
+                    if (this.version.architecture === 'X86_64' && process.arch === 'arm64') {
+                        // Force the Unity Editor to run under Rosetta 2 on Apple Silicon Macs if the editor is x86_64
+                        command.args.unshift('arch', '-x86_64');
+                    }
+                }
+
                 unityProcess = spawn(
                     this.editorPath,
                     command.args, {
@@ -230,14 +238,13 @@ export class UnityEditor {
             process.once('SIGTERM', onCancel);
             procInfo = { pid: unityProcess.pid, ppid: process.pid, name: this.editorPath };
             this.logger.debug(`Unity process started with pid: ${procInfo.pid}`);
-            await WaitForFileToBeCreatedAndReadable(logPath, 10_000);
-            logTail = TailLogFile(logPath);
             exitCode = await new Promise((resolve, reject) => {
                 unityProcess.on('close', (code) => {
                     logTail?.stopLogTail();
                     resolve(code === null ? 1 : code);
                 });
                 unityProcess.on('error', (error) => {
+                    this.logger.error(`Unity process error: ${error}`);
                     logTail?.stopLogTail();
                     reject(error);
                 });
@@ -258,7 +265,9 @@ export class UnityEditor {
             if (!isCancelled) {
                 await tryKillEditorProcesses();
 
-                if (exitCode !== 0) {
+                if (exitCode === undefined) {
+                    throw Error('Failed to start Unity!');
+                } else if (exitCode > 0) {
                     throw Error(`Unity failed with exit code ${exitCode}`);
                 }
             }

src/utilities.ts

@@ -390,13 +390,15 @@ export function TailLogFile(logPath: string): LogTailResult {
     const tailPromise = new Promise<void>((resolve, reject) => {
         (async () => {
             try {
+                await WaitForFileToBeCreatedAndReadable(logPath, 10_000);
+
                 while (!logEnded) {
                     await Delay(logPollingInterval);
                     await readNewLogContent();
                 }
 
                 // Final read to capture any remaining content after tailing stops
-                await WaitForFileToBeUnlocked(logPath, 10000);
+                await WaitForFileToBeUnlocked(logPath, 10_000);
                 await readNewLogContent();
 
                 try {