updating action typescript build files

lib/io-utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require('path');
+const fs = require('fs');
+function findReleaseFile(releaseDir) {
+    const releaseFiles = fs.readdirSync(releaseDir, { withFileTypes: true })
+        .filter(item => !item.isDirectory())
+        .filter(item => item.name.endsWith(".apk") || item.name.endsWith(".aab"));
+    if (releaseFiles.length > 0) {
+        return releaseFiles[0];
+    }
+}
+exports.findReleaseFile = findReleaseFile;

lib/main.js

@@ -16,16 +16,47 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core = __importStar(require("@actions/core"));
-const wait_1 = require("./wait");
+const signing_1 = require("./signing");
+const path = require('path');
+const fs = require('fs');
+const io = require('io-utils');
+const sign = require('signing');
 function run() {
     return __awaiter(this, void 0, void 0, function* () {
         try {
-            const ms = core.getInput('milliseconds');
+            const releaseDir = core.getInput('releaseDirectory');
-            console.log(`Waiting ${ms} milliseconds ...`);
+            const signingKeyBase64 = core.getInput('signingKeyBase64');
-            core.debug((new Date()).toTimeString());
+            const alias = core.getInput('alias');
-            wait_1.wait(parseInt(ms));
+            const keyStorePassword = core.getInput('keyStorePassword');
-            core.debug((new Date()).toTimeString());
+            const keyPassword = core.getInput('keyPassword');
-            core.setOutput('time', new Date().toTimeString());
+            console.log(`Preparing to sign key @ ${releaseDir} with signing key`);
+            // 1. Find release file
+            const releaseFile = io.findReleaseFile(releaseDir);
+            if (releaseFile !== undefined) {
+                core.debug(`Found release to sign: ${releaseFile.name}`);
+                // 2. Now that we have a release file, decode and save the signing key
+                const signingKey = path.join(releaseDir, 'signingKey.jks');
+                fs.writeFileSync(signingKey, signingKeyBase64, 'base64');
+                // 3. Now zipalign the release file
+                const releaseFilePath = path.join(releaseDir, releaseFile.name);
+                let signedReleaseFile = '';
+                if (releaseFile.name.endsWith('.apk')) {
+                    signedReleaseFile = yield signing_1.signApkFile(releaseFilePath, signingKey, alias, keyStorePassword, keyPassword);
+                }
+                else if (releaseFile.name.endsWith('.aab')) {
+                    signedReleaseFile = yield signing_1.signAabFile(releaseFilePath, signingKey, alias, keyStorePassword, keyPassword);
+                }
+                else {
+                    core.error('No valid release file to sign, abort.');
+                    core.setFailed('No valid release file to sign.');
+                }
+                core.exportVariable("SIGNED_RELEASE_FILE", signedReleaseFile);
+                core.setOutput('signedReleaseFile', signedReleaseFile);
+            }
+            else {
+                core.error("No release file (.apk or .aab) could be found. Abort.");
+                core.setFailed('No release file (.apk or .aab) could be found.');
+            }
         }
         catch (error) {
             core.setFailed(error.message);

lib/signing.js

@@ -0,0 +1,56 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const exec = __importStar(require("@actions/exec"));
+const core = __importStar(require("@actions/core"));
+function signApkFile(apkFile, signingKeyFile, alias, keyStorePassword, keyPassword) {
+    return __awaiter(this, void 0, void 0, function* () {
+        core.debug("Zipaligning APK file");
+        // Align the apk file
+        const alignedApkFile = apkFile.replace('.apk', '-aligned.apk');
+        yield exec.exec('zipalign', [
+            '-v', '-p 4',
+            apkFile,
+            alignedApkFile
+        ]);
+        core.debug("Signing APK file");
+        // apksigner sign --ks my-release-key.jks --out my-app-release.apk my-app-unsigned-aligned.apk
+        const signedApkFile = apkFile.replace('.apk', '-signed.apk');
+        yield exec.exec('apksigner', [
+            'sign',
+            '--ks', signingKeyFile,
+            '--out', signedApkFile,
+            alignedApkFile
+        ]);
+        return signedApkFile;
+    });
+}
+exports.signApkFile = signApkFile;
+function signAabFile(aabFile, signingKeyFile, alias, keyStorePassword, keyPassword) {
+    return __awaiter(this, void 0, void 0, function* () {
+        core.debug("Signing AAB file");
+        yield exec.exec(`jarsigner`, [
+            '-keystore', signingKeyFile,
+            '-storepass', keyStorePassword,
+            '-keypass', keyPassword,
+            aabFile,
+            alias
+        ]);
+        return aabFile;
+    });
+}
+exports.signAabFile = signAabFile;

lib/wait.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 function wait(milliseconds) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
-        if (typeof (milliseconds) !== 'number') {
+        if (isNaN(milliseconds)) {
             throw new Error('milleseconds not a number');
         }
         setTimeout(() => resolve("done!"), milliseconds);