Add personal license support

Author: kuler90

.github/workflows/test-personal.yml

@@ -0,0 +1,36 @@
+name: test personal license
+on:
+  push:
+    branches:
+      - "**"
+    paths-ignore:
+      - "**.md"
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-18.04
+          - ubuntu-20.04
+          - macos-10.15
+          - macos-11.0
+          - windows-2019
+        unity-version:
+          - 2018.4.1f1
+          - 2019.4.1f1
+          - 2020.1.0f1
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+      - name: Setup unity
+        uses: kuler90/setup-unity@v1
+        with:
+          unity-version: ${{ matrix.unity-version }}
+      - name: Activate unity
+        uses: ./
+        with:
+          unity-username: ${{ secrets.UNITY_USERNAME }}
+          unity-password: ${{ secrets.UNITY_PASSWORD }}
+          unity-authenticator-key: ${{ secrets.UNITY_AUTHENTICATOR_KEY }}

README.md

@@ -1,6 +1,10 @@
 # activate-unity
 
-GitHub Action to activate Unity license. License will be automatically returned when the job finishes.
+<p align="left">
+  <a href="https://github.com/kuler90/activate-unity/actions"><img alt="GitHub Actions status" src="https://github.com/kuler90/activate-unity/workflows/test%20personal%20license/badge.svg?branch=master"></a>
+</p>
+
+GitHub Action to activate personal or professional Unity license. License will be automatically returned at the end of a job.
 
 Works on Linux, macOS and Windows.
 
@@ -12,15 +16,27 @@ Path to Unity executable. `UNITY_PATH` env will be used if not provided.
 
 ### `unity-username`
 
-Unity activation username.
+**Required** Unity account username.
 
 ### `unity-password`
 
-Unity activation password.
+**Required** Unity account password.
+
+### `unity-authenticator-key`
+
+Unity account [authenticator key](#How-to-obtain-authenticator-key) for Authenticator App (Two Factor Authentication). Used for account verification during Personal license activation.
 
 ### `unity-serial`
 
-Unity activation serial key.
+Unity license serial key. Used for Plus/Professional license activation.
+
+## How to obtain authenticator key
+
+1. Login to Unity account
+2. Go to account settings
+3. Activate Two Factor Authentication through Authenticator App
+4. On page with QR code click "Can't scan the barcode?" and save key
+5. Finish activation
 
 ## Example usage
 
@@ -30,11 +46,19 @@ Unity activation serial key.
 
 - name: Setup Unity
   uses: kuler90/setup-unity@v1
+  with:
+    unity-modules: android
 
 - name: Activate Unity
   uses: kuler90/activate-unity@v1
   with:
     unity-username: ${{ secrets.UNITY_USERNAME }}
     unity-password: ${{ secrets.UNITY_PASSWORD }}
-    unity-serial: ${{ secrets.UNITY_SERIAL }}
+    unity-authenticator-key: ${{ secrets.UNITY_AUTHENTICATOR_KEY }}
+
+- name: Build Unity
+  uses: kuler90/build-unity@v1
+  with:
+    build-target: Android
+    build-path: ./build.apk
 ```

action.yml

@@ -1,22 +1,26 @@
 name: Activate Unity
-description: Activate Unity license and return it after job finish
+description: Activate Unity license and return it at the end of a job
 inputs:
   unity-path:
     description: Path to Unity executable. UNITY_PATH env will be used if not provided
     required: false
   unity-username:
-    description: Unity activation username
+    description: Unity account username
     required: false
   unity-password:
-    description: Unity activation password
+    description: Unity account password
+    required: false
+  unity-authenticator-key:
+    description: Unity account authenticator key for Authenticator App (Two Factor Authentication). Used for account verification during Personal license activation
     required: false
   unity-serial:
-    description: Unity activation serial key
+    description: Unity license serial key. Used for Plus/Professional license activation
     required: false
 runs:
   using: node12
   main: src/activate-license.js
   post: src/return-license.js
+  post-if: inputs.unity-serial != ''
 branding:
   icon: unlock
   color: gray-dark

src/activate-license.js

@@ -1,4 +1,6 @@
 const core = require('@actions/core');
+const exec = require('@actions/exec');
+const path = require('path');
 const unity = require('./unity');
 
 async function run() {
@@ -7,17 +9,19 @@ async function run() {
         if (!unityPath) {
             throw new Error('unity path not found');
         }
-        const unityUsername = core.getInput('unity-username');
-        const unityPassword = core.getInput('unity-password');
+        const unityUsername = core.getInput('unity-username', { required: true });
+        const unityPassword = core.getInput('unity-password', { required: true });
+        const unityAuthenticatorKey = core.getInput('unity-authenticator-key');
         const unitySerial = core.getInput('unity-serial');
-        const unityManualLicense = core.getInput('unity-manual-license');
 
-        if (unityUsername && unityPassword && unitySerial) {
-            await unity.activateLicense(unityPath, unityUsername, unityPassword, unitySerial);
-        } else if (unityManualLicense) {
-            await unity.activateManualLicense(unityPath, unityManualLicense);
+        if (unitySerial) {
+            await unity.activateSerialLicense(unityPath, unityUsername, unityPassword, unitySerial);
         } else {
-            throw new Error('Empty (unity-username and unity-password and unity-serial) or unity-manual-license inputs');
+            await exec.exec('npm install puppeteer@"^5.x"', [], { cwd: path.join(__dirname, '..') }); // install puppeteer for current platform
+            const licenseRobot = require('./license-robot');
+            const licenseRequestFile = await unity.createManualActivationFile(unityPath);
+            const licenseData = await licenseRobot.getPersonalLicense(licenseRequestFile, unityUsername, unityPassword, unityAuthenticatorKey);
+            await unity.activateManualLicense(unityPath, licenseData);
         }
     } catch (error) {
         core.setFailed(error.message);

src/license-robot.js

@@ -0,0 +1,145 @@
+const puppeteer = require('puppeteer');
+const otplib = require('otplib');
+const fs = require('fs');
+
+module.exports = { getPersonalLicense };
+
+let RETRY_COUNT = 2;
+let BROWSER_HEADLESS = true;
+
+async function getPersonalLicense(licenseRequestFile, username, password, authenticatorKey) {
+    const licenseRequestData = fs.readFileSync(licenseRequestFile, 'utf8');
+    const licenseData = await retry(() => browser_getPersonalLicense(licenseRequestData, username, password, authenticatorKey), RETRY_COUNT);
+    return licenseData;
+}
+
+async function browser_getPersonalLicense(licenseRequestData, username, password, authenticatorKey) {
+    const browser = await puppeteer.launch({ headless: BROWSER_HEADLESS });
+    try {
+        const page = await browser.newPage();
+        await page.goto('https://license.unity3d.com/manual');
+        await licensePage_login(page, username, password, authenticatorKey);
+        try {
+            await licensePage_attachFileData(page, licenseRequestData);
+        } catch {
+            // https://forum.unity.com/threads/i-cant-create-a-unity-license.1001648/
+            await licensePage_attachFileData(page, convertToUtf16(licenseRequestData));
+        }
+        await licensePage_selectType(page);
+        const licenseData = await licensePage_downloadLicense(page);
+        return licenseData;
+    } finally {
+        await browser.close();
+    }
+}
+
+/**
+ * @param {import("puppeteer").Page} page
+ */
+async function licensePage_login(page, username, password, authenticatorKey) {
+    await page.waitForSelector('#conversations_create_session_form_email');
+    await page.type('#conversations_create_session_form_email', username);
+    await page.type('#conversations_create_session_form_password', password);
+    await page.click('input[name=commit]');
+    await page.waitForNavigation();
+    await page.waitForTimeout(1000);
+
+    const verifyCodeInput = await page.$('#conversations_tfa_required_form_verify_code');
+    if (verifyCodeInput) {
+        if (!authenticatorKey) {
+            throw new Error('account verification requested but authenticator key is not provided');
+        }
+        const otpTimeRemaining = otplib.authenticator.timeRemaining();
+        if (otpTimeRemaining < 5) {
+            await page.waitForTimeout((otpTimeRemaining + 2) * 1000); // wait for new code
+        }
+        const otpCode = otplib.authenticator.generate(authenticatorKey.replace(/ /g, ''));
+        await verifyCodeInput.type(otpCode);
+        await page.click('input[name="conversations_tfa_required_form[submit_verify_code]"]');
+        await page.waitForNavigation();
+        await page.waitForTimeout(1000);
+    }
+}
+
+/**
+ * @param {import("puppeteer").Page} page
+ */
+async function licensePage_attachFileData(page, licenseRequestData) {
+    await page.waitForTimeout(2000);
+    await page.setRequestInterception(true);
+    page.once("request", interceptedRequest => {
+        interceptedRequest.continue({
+            method: "POST",
+            postData: licenseRequestData,
+            headers: { "Content-Type": "text/xml" }
+        });
+    });
+    const response = await page.goto('https://license.unity3d.com/genesis/activation/create-transaction');
+    if (!response.ok()) {
+        console.log(await response.text());
+        throw new Error(response.statusText());
+    }
+}
+
+/**
+ * @param {import("puppeteer").Page} page
+ */
+async function licensePage_selectType(page) {
+    await page.waitForTimeout(1000);
+    page.once("request", interceptedRequest => {
+        interceptedRequest.continue({
+            method: "PUT",
+            postData: JSON.stringify({ transaction: { serial: { type: "personal" } } }),
+            headers: { "Content-Type": "application/json" }
+        });
+    });
+    const response = await page.goto('https://license.unity3d.com/genesis/activation/update-transaction');
+    if (!response.ok()) {
+        console.log(await response.text());
+        throw new Error(response.statusText());
+    }
+}
+
+/**
+ * @param {import("puppeteer").Page} page
+ */
+async function licensePage_downloadLicense(page) {
+    await page.waitForTimeout(1000);
+    page.once("request", interceptedRequest => {
+        interceptedRequest.continue({
+            method: "POST",
+            postData: JSON.stringify({}),
+            headers: { "Content-Type": "application/json" }
+        });
+    });
+    const response = await page.goto('https://license.unity3d.com/genesis/activation/download-license');
+    if (response.ok()) {
+        const json = await response.json();
+        return json['xml'];
+    } else {
+        console.log(await response.text());
+        throw new Error(response.statusText());
+    }
+}
+
+async function retry(func, retryCount) {
+    while (true) {
+        try {
+            return await func();
+        } catch (error) {
+            if (retryCount > 0)
+                retryCount--;
+            else
+                throw error;
+        }
+    }
+}
+
+function convertToUtf16(str) {
+    var buf = new ArrayBuffer(str.length * 2);
+    var bufView = new Uint16Array(buf);
+    for (var i = 0, strLen = str.length; i < strLen; i++) {
+        bufView[i] = str.charCodeAt(i);
+    }
+    return String.fromCharCode.apply(null, new Uint8Array(buf));
+}

src/return-license.js

@@ -7,7 +7,7 @@ async function run() {
         if (!unityPath) {
             throw new Error('unity path not found');
         }
-        unity.returnLicense(unityPath);
+        await unity.returnLicense(unityPath);
     } catch (error) {
         core.setFailed(error.message);
     }

src/unity.js

@@ -1,55 +1,46 @@
 const exec = require('@actions/exec');
 const fs = require('fs');
 
-module.exports = { activateLicense, activateManualLicense, returnLicense }
+module.exports = { createManualActivationFile, activateManualLicense, activateSerialLicense, returnLicense };
 
-async function activateLicense(unityPath, username, password, serial) {
-    await prepareForActivation();
-    const stdout = await execute(`${unityCmd(unityPath)} -batchmode -nographics -quit -logFile -projectPath ? -username "${username}" -password "${password}" -serial "${serial}"`, true);
+async function activateSerialLicense(unityPath, username, password, serial) {
+    // use '-projectPath ?' for skipping project indexing
+    const stdout = await executeUnity(unityPath, `-batchmode -nographics -quit -logFile "-" -projectPath "?" -username "${username}" -password "${password}" -serial "${serial}"`);
     if (!stdout.includes('Next license update check is after')) {
         throw new Error('Activation failed');
     }
 }
 
-async function activateManualLicense(unityPath, manualLicense) {
-    fs.writeFileSync('license.ulf', manualLicense);
-    await prepareForActivation();
-    const stdout = await execute(`${unityCmd(unityPath)} -batchmode -nographics -quit -logFile -projectPath ? -manualLicenseFile license.ulf`);
+async function createManualActivationFile(unityPath) {
+    await executeUnity(unityPath, '-batchmode -nographics -quit -logFile "-" -createManualActivationFile');
+    return fs.readdirSync('./').find(path => path.endsWith('.alf'));
+}
+
+async function activateManualLicense(unityPath, licenseData) {
+    fs.writeFileSync('license.ulf', licenseData);
+    const stdout = await executeUnity(unityPath, `-batchmode -nographics -quit -logFile "-" -manualLicenseFile license.ulf`);
     if (!stdout.includes('Next license update check is after')) {
         throw new Error('Activation failed');
     }
 }
 
 async function returnLicense(unityPath) {
-    await execute(`${unityCmd(unityPath)} -batchmode -nographics -quit -logFile -returnlicense`);
-}
-
-async function prepareForActivation() {
-    if (process.platform === 'darwin') {
-        await execute('sudo mkdir -p "/Library/Application Support/Unity"');
-        await execute(`sudo chown -R ${process.env.USER} "/Library/Application Support/Unity"`);
-    }
+    await executeUnity(unityPath, '-batchmode -nographics -quit -logFile "-" -returnlicense');
 }
 
-function unityCmd(unityPath) {
-    let unityCmd = '';
+async function executeUnity(unityPath, args) {
     if (process.platform === 'linux') {
-        unityCmd = `xvfb-run --auto-servernum "${unityPath}"`;
-    } else if (process.platform === 'darwin') {
-        unityCmd = `"${unityPath}"`;
-    } else if (process.platform === 'win32') {
-        unityCmd = `"${unityPath}"`;
+        return await execute(`xvfb-run --auto-servernum "${unityPath}" ${args}`, true);
+    } else {
+        return await execute(`"${unityPath}" ${args}`, true);
     }
-    return unityCmd;
 }
 
 async function execute(command, ignoreReturnCode) {
     let stdout = '';
     await exec.exec(command, [], {
         ignoreReturnCode: ignoreReturnCode,
-        listeners: {
-            stdout: buffer => stdout += buffer.toString()
-        }
+        listeners: { stdout: buffer => stdout += buffer.toString() }
     });
     return stdout;
 }