unity-cli@v1.6.7 (#55)

- refactored license client resolver and order of operations when setting config json

Author: StephenHodgson

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rage-against-the-pixel/unity-cli",
-  "version": "1.6.6",
+  "version": "1.6.7",
   "description": "A command line utility for the Unity Game Engine.",
   "author": "RageAgainstThePixel",
   "license": "MIT",

src/license-client.ts

@@ -4,7 +4,10 @@ import * as path from 'path';
 import { spawn } from 'child_process';
 import { Logger } from './logging';
 import { UnityHub } from './unity-hub';
-import { ResolveGlobToPath } from './utilities';
+import {
+    ResolveGlobToPath,
+    tryParseJson
+} from './utilities';
 
 export enum LicenseType {
     personal = 'personal',
@@ -119,45 +122,59 @@ export class LicensingClient {
         return path.join(servicesConfigDirectory, 'services-config.json');
     }
 
-    private tryParseJson(content: string | undefined): string | undefined {
-        if (!content) {
-            return undefined;
-        }
-
-        try {
-            JSON.parse(content);
-            return content;
-        } catch {
-            return undefined;
-        }
-    }
-
     private resolveServicesConfigContent(input: string): string {
         const trimmedInput = input.trim();
 
         if (trimmedInput.length === 0) {
             throw new Error('Services config value is empty. Provide a file path, JSON, or base64 encoded JSON string.');
         }
 
-        const directJson = this.tryParseJson(trimmedInput);
+        const rawJson = tryParseJson(trimmedInput);
 
-        if (directJson) {
-            return directJson;
+        if (rawJson) {
+            return rawJson;
         }
 
-        const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
-        if (base64Regex.test(trimmedInput)) {
-            const decoded = Buffer.from(trimmedInput, 'base64').toString('utf-8').trim();
-            const decodedJson = this.tryParseJson(decoded);
+        try {
+            const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
+
+            if (base64Regex.test(trimmedInput)) {
+                const decoded = Buffer.from(trimmedInput, 'base64').toString('utf-8').trim();
+                const decodedJson = tryParseJson(decoded);
 
-            if (decodedJson) {
-                return decodedJson;
+                if (decodedJson) {
+                    return decodedJson;
+                }
+            } else {
+                throw new Error('Input does not match base64 format.');
             }
         }
+        catch (error) {
+            throw new Error(`Failed to decode services config as base64: ${error}`);
+        }
 
         throw new Error('Services config value is not a valid JSON string or base64 encoded JSON string.');
     }
 
+    private async setupServicesConfig(configSource: string): Promise<string> {
+        const servicesConfigPath = this.servicesConfigPath();
+
+        if (fs.existsSync(configSource)) {
+            fs.copyFileSync(configSource, servicesConfigPath);
+        }
+        else {
+            const configContent = this.resolveServicesConfigContent(configSource);
+            fs.writeFileSync(servicesConfigPath, configContent, { encoding: 'utf-8' });
+        }
+
+        if (process.platform !== 'win32') {
+            fs.chmodSync(servicesConfigPath, 0o644);
+        }
+
+        fs.accessSync(servicesConfigPath, fs.constants.R_OK);
+        return servicesConfigPath;
+    }
+
     /**
      * Gets the path to the Unity Licensing Client log file.
      * @see https://docs.unity.com/en-us/licensing-server/troubleshooting-client#logs
@@ -459,8 +476,19 @@ export class LicensingClient {
      * @throws Error if activation fails or required parameters are missing.
      */
     public async Activate(options: ActivateOptions, skipEntitlementCheck: boolean = false): Promise<string | undefined> {
+        let servicesConfigPath: string | undefined;
+
+        if (options.licenseType === LicenseType.floating) {
+            if (!options.servicesConfig) {
+                throw new Error('Services config path is required for floating license activation');
+            }
+
+            servicesConfigPath = await this.setupServicesConfig(options.servicesConfig);
+            this.logger.debug(`Using services config at: ${servicesConfigPath}`);
+        }
+
         if (!skipEntitlementCheck) {
-            let activeLicenses = await this.GetActiveEntitlements();
+            const activeLicenses = await this.GetActiveEntitlements();
 
             if (activeLicenses.includes(options.licenseType)) {
                 this.logger.info(`License of type '${options.licenseType}' is already active, skipping activation`);
@@ -470,27 +498,6 @@ export class LicensingClient {
 
         switch (options.licenseType) {
             case LicenseType.floating: {
-                if (!options.servicesConfig) {
-                    throw new Error('Services config path is required for floating license activation');
-                }
-
-                const servicesConfigPath = this.servicesConfigPath();
-
-                if (fs.existsSync(options.servicesConfig)) {
-                    fs.copyFileSync(options.servicesConfig, servicesConfigPath);
-                }
-                else {
-                    const configContent = this.resolveServicesConfigContent(options.servicesConfig);
-                    fs.writeFileSync(servicesConfigPath, configContent, { encoding: 'utf-8' });
-                }
-
-                if (process.platform !== 'win32') {
-                    fs.chmodSync(servicesConfigPath, 0o644);
-                }
-
-                fs.accessSync(servicesConfigPath, fs.constants.R_OK);
-                this.logger.debug(`Using services config at: ${servicesConfigPath}`);
-
                 const output = await this.exec([`--acquire-floating`], true);
                 const tokenMatch = output.match(/with token:\s*"(?<token>[\w-]+)"/);
 

src/utilities.ts

@@ -505,4 +505,17 @@ export async function isProcessElevated(): Promise<boolean> {
         "(New-Object Security.Principal.WindowsPrincipal([Security.Principal.WindowsIdentity]::GetCurrent())).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)"
     ], { silent: true, showCommand: false });
     return output.trim().toLowerCase() === 'true';
+}
+
+export function tryParseJson(content: string | undefined): string | undefined {
+    if (!content) {
+        return undefined;
+    }
+
+    try {
+        JSON.parse(content);
+        return content;
+    } catch {
+        return undefined;
+    }
 }

tests/license-client.test.ts

@@ -1,4 +1,8 @@
-import { LicensingClient } from '../src/license-client';
+import { LicensingClient, LicenseType } from '../src/license-client';
+
+afterEach(() => {
+    jest.restoreAllMocks();
+});
 
 describe('LicensingClient services config handling', () => {
     const invokeResolver = (input: string) => {
@@ -17,11 +21,34 @@ describe('LicensingClient services config handling', () => {
         expect(invokeResolver(encoded)).toBe(json);
     });
 
-    it('rejects invalid inline config', () => {
-        expect(() => invokeResolver('not-a-valid-config')).toThrow('Services config value is not a valid JSON string or base64 encoded JSON string.');
+    it('rejects invalid inline config even if it looks like base64', () => {
+        // "YWJjZA==" decodes to "abcd", which is not valid JSON
+        expect(() => invokeResolver('YWJjZA==')).toThrow('Services config value is not a valid JSON string or base64 encoded JSON string.');
+    });
+
+    it('throws when inline config does not match base64 format', () => {
+        expect(() => invokeResolver('not-a-valid-config')).toThrow(/Input does not match base64 format/);
     });
 
     it('rejects empty inline config', () => {
         expect(() => invokeResolver('   ')).toThrow('Services config value is empty. Provide a file path, JSON, or base64 encoded JSON string.');
     });
 });
+
+describe('LicensingClient floating activation order', () => {
+    it('prepares services config before checking entitlements', async () => {
+        const client = new LicensingClient();
+        const setupSpy = jest.spyOn(client as any, 'setupServicesConfig').mockResolvedValue('/tmp/services-config.json');
+        const entitlementsSpy = jest.spyOn(client, 'GetActiveEntitlements').mockResolvedValue([]);
+        jest.spyOn(client as any, 'exec').mockResolvedValue('Successfully acquired with token: "token-123"');
+
+        await client.Activate({
+            licenseType: LicenseType.floating,
+            servicesConfig: '{"floatingServer":"https://example.com"}'
+        });
+
+        expect(setupSpy).toHaveBeenCalledTimes(1);
+        expect(entitlementsSpy).toHaveBeenCalledTimes(1);
+        expect(entitlementsSpy.mock.invocationCallOrder[0]).toBeGreaterThan(setupSpy.mock.invocationCallOrder[0]);
+    });
+});