@appcircle/codepush-cli 0.0.1-alpha.1

package/bin/script/react-native-utils.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReactNativeVersion = exports.directoryExistsSync = exports.getiOSHermesEnabled = exports.getAndroidHermesEnabled = exports.runHermesEmitBinaryCommand = exports.isValidVersion = void 0;
+const fs = require("fs");
+const chalk = require("chalk");
+const path = require("path");
+const childProcess = require("child_process");
+const semver_1 = require("semver");
+const file_utils_1 = require("./utils/file-utils");
+const g2js = require("gradle-to-js/lib/parser");
+function isValidVersion(version) {
+    return !!(0, semver_1.valid)(version) || /^\d+\.\d+$/.test(version);
+}
+exports.isValidVersion = isValidVersion;
+async function runHermesEmitBinaryCommand(bundleName, outputFolder, sourcemapOutput, extraHermesFlags, gradleFile) {
+    const hermesArgs = [];
+    const envNodeArgs = process.env.CODE_PUSH_NODE_ARGS;
+    if (typeof envNodeArgs !== "undefined") {
+        Array.prototype.push.apply(hermesArgs, envNodeArgs.trim().split(/\s+/));
+    }
+    Array.prototype.push.apply(hermesArgs, [
+        "-emit-binary",
+        "-out",
+        path.join(outputFolder, bundleName + ".hbc"),
+        path.join(outputFolder, bundleName),
+        ...extraHermesFlags,
+    ]);
+    if (sourcemapOutput) {
+        hermesArgs.push("-output-source-map");
+    }
+    console.log(chalk.cyan("Converting JS bundle to byte code via Hermes, running command:\n"));
+    const hermesCommand = await getHermesCommand(gradleFile);
+    const hermesProcess = childProcess.spawn(hermesCommand, hermesArgs);
+    console.log(`${hermesCommand} ${hermesArgs.join(" ")}`);
+    return new Promise((resolve, reject) => {
+        hermesProcess.stdout.on("data", (data) => {
+            console.log(data.toString().trim());
+        });
+        hermesProcess.stderr.on("data", (data) => {
+            console.error(data.toString().trim());
+        });
+        hermesProcess.on("close", (exitCode, signal) => {
+            if (exitCode !== 0) {
+                reject(new Error(`"hermes" command failed (exitCode=${exitCode}, signal=${signal}).`));
+            }
+            // Copy HBC bundle to overwrite JS bundle
+            const source = path.join(outputFolder, bundleName + ".hbc");
+            const destination = path.join(outputFolder, bundleName);
+            fs.copyFile(source, destination, (err) => {
+                if (err) {
+                    console.error(err);
+                    reject(new Error(`Copying file ${source} to ${destination} failed. "hermes" previously exited with code ${exitCode}.`));
+                }
+                fs.unlink(source, (err) => {
+                    if (err) {
+                        console.error(err);
+                        reject(err);
+                    }
+                    resolve(null);
+                });
+            });
+        });
+    }).then(() => {
+        if (!sourcemapOutput) {
+            // skip source map compose if source map is not enabled
+            return;
+        }
+        const composeSourceMapsPath = getComposeSourceMapsPath();
+        if (!composeSourceMapsPath) {
+            throw new Error("react-native compose-source-maps.js scripts is not found");
+        }
+        const jsCompilerSourceMapFile = path.join(outputFolder, bundleName + ".hbc" + ".map");
+        if (!fs.existsSync(jsCompilerSourceMapFile)) {
+            throw new Error(`sourcemap file ${jsCompilerSourceMapFile} is not found`);
+        }
+        return new Promise((resolve, reject) => {
+            const composeSourceMapsArgs = [composeSourceMapsPath, sourcemapOutput, jsCompilerSourceMapFile, "-o", sourcemapOutput];
+            // https://github.com/facebook/react-native/blob/master/react.gradle#L211
+            // https://github.com/facebook/react-native/blob/master/scripts/react-native-xcode.sh#L178
+            // packager.sourcemap.map + hbc.sourcemap.map = sourcemap.map
+            const composeSourceMapsProcess = childProcess.spawn("node", composeSourceMapsArgs);
+            console.log(`${composeSourceMapsPath} ${composeSourceMapsArgs.join(" ")}`);
+            composeSourceMapsProcess.stdout.on("data", (data) => {
+                console.log(data.toString().trim());
+            });
+            composeSourceMapsProcess.stderr.on("data", (data) => {
+                console.error(data.toString().trim());
+            });
+            composeSourceMapsProcess.on("close", (exitCode, signal) => {
+                if (exitCode !== 0) {
+                    reject(new Error(`"compose-source-maps" command failed (exitCode=${exitCode}, signal=${signal}).`));
+                }
+                // Delete the HBC sourceMap, otherwise it will be included in 'code-push' bundle as well
+                fs.unlink(jsCompilerSourceMapFile, (err) => {
+                    if (err) {
+                        console.error(err);
+                        reject(err);
+                    }
+                    resolve(null);
+                });
+            });
+        });
+    });
+}
+exports.runHermesEmitBinaryCommand = runHermesEmitBinaryCommand;
+function parseBuildGradleFile(gradleFile) {
+    let buildGradlePath = path.join("android", "app");
+    if (gradleFile) {
+        buildGradlePath = gradleFile;
+    }
+    if (fs.lstatSync(buildGradlePath).isDirectory()) {
+        buildGradlePath = path.join(buildGradlePath, "build.gradle");
+    }
+    if ((0, file_utils_1.fileDoesNotExistOrIsDirectory)(buildGradlePath)) {
+        throw new Error(`Unable to find gradle file "${buildGradlePath}".`);
+    }
+    return g2js.parseFile(buildGradlePath).catch(() => {
+        throw new Error(`Unable to parse the "${buildGradlePath}" file. Please ensure it is a well-formed Gradle file.`);
+    });
+}
+async function getHermesCommandFromGradle(gradleFile) {
+    const buildGradle = await parseBuildGradleFile(gradleFile);
+    const hermesCommandProperty = Array.from(buildGradle["project.ext.react"] || []).find((prop) => prop.trim().startsWith("hermesCommand:"));
+    if (hermesCommandProperty) {
+        return hermesCommandProperty.replace("hermesCommand:", "").trim().slice(1, -1);
+    }
+    else {
+        return "";
+    }
+}
+function getAndroidHermesEnabled(gradleFile) {
+    return parseBuildGradleFile(gradleFile).then((buildGradle) => {
+        return Array.from(buildGradle["project.ext.react"] || []).some((line) => /^enableHermes\s{0,}:\s{0,}true/.test(line));
+    });
+}
+exports.getAndroidHermesEnabled = getAndroidHermesEnabled;
+function getiOSHermesEnabled(podFile) {
+    let podPath = path.join("ios", "Podfile");
+    if (podFile) {
+        podPath = podFile;
+    }
+    if ((0, file_utils_1.fileDoesNotExistOrIsDirectory)(podPath)) {
+        throw new Error(`Unable to find Podfile file "${podPath}".`);
+    }
+    try {
+        const podFileContents = fs.readFileSync(podPath).toString();
+        return /([^#\n]*:?hermes_enabled(\s+|\n+)?(=>|:)(\s+|\n+)?true)/.test(podFileContents);
+    }
+    catch (error) {
+        throw error;
+    }
+}
+exports.getiOSHermesEnabled = getiOSHermesEnabled;
+function getHermesOSBin() {
+    switch (process.platform) {
+        case "win32":
+            return "win64-bin";
+        case "darwin":
+            return "osx-bin";
+        case "freebsd":
+        case "linux":
+        case "sunos":
+        default:
+            return "linux64-bin";
+    }
+}
+function getHermesOSExe() {
+    const react63orAbove = (0, semver_1.compare)((0, semver_1.coerce)(getReactNativeVersion()).version, "0.63.0") !== -1;
+    const hermesExecutableName = react63orAbove ? "hermesc" : "hermes";
+    switch (process.platform) {
+        case "win32":
+            return hermesExecutableName + ".exe";
+        default:
+            return hermesExecutableName;
+    }
+}
+async function getHermesCommand(gradleFile) {
+    const fileExists = (file) => {
+        try {
+            return fs.statSync(file).isFile();
+        }
+        catch (e) {
+            return false;
+        }
+    };
+    // Hermes is bundled with react-native since 0.69
+    const bundledHermesEngine = path.join(getReactNativePackagePath(), "sdks", "hermesc", getHermesOSBin(), getHermesOSExe());
+    if (fileExists(bundledHermesEngine)) {
+        return bundledHermesEngine;
+    }
+    const gradleHermesCommand = await getHermesCommandFromGradle(gradleFile);
+    if (gradleHermesCommand) {
+        return path.join("android", "app", gradleHermesCommand.replace("%OS-BIN%", getHermesOSBin()));
+    }
+    else {
+        // assume if hermes-engine exists it should be used instead of hermesvm
+        const hermesEngine = path.join("node_modules", "hermes-engine", getHermesOSBin(), getHermesOSExe());
+        if (fileExists(hermesEngine)) {
+            return hermesEngine;
+        }
+        return path.join("node_modules", "hermesvm", getHermesOSBin(), "hermes");
+    }
+}
+function getComposeSourceMapsPath() {
+    // detect if compose-source-maps.js script exists
+    const composeSourceMaps = path.join(getReactNativePackagePath(), "scripts", "compose-source-maps.js");
+    if (fs.existsSync(composeSourceMaps)) {
+        return composeSourceMaps;
+    }
+    return null;
+}
+function getReactNativePackagePath() {
+    const result = childProcess.spawnSync("node", ["--print", "require.resolve('react-native/package.json')"]);
+    const packagePath = path.dirname(result.stdout.toString());
+    if (result.status === 0 && directoryExistsSync(packagePath)) {
+        return packagePath;
+    }
+    return path.join("node_modules", "react-native");
+}
+function directoryExistsSync(dirname) {
+    try {
+        return fs.statSync(dirname).isDirectory();
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            throw err;
+        }
+    }
+    return false;
+}
+exports.directoryExistsSync = directoryExistsSync;
+function getReactNativeVersion() {
+    let packageJsonFilename;
+    let projectPackageJson;
+    try {
+        packageJsonFilename = path.join(process.cwd(), "package.json");
+        projectPackageJson = JSON.parse(fs.readFileSync(packageJsonFilename, "utf-8"));
+    }
+    catch (error) {
+        throw new Error(`Unable to find or read "package.json" in the CWD. The "release-react" command must be executed in a React Native project folder.`);
+    }
+    const projectName = projectPackageJson.name;
+    if (!projectName) {
+        throw new Error(`The "package.json" file in the CWD does not have the "name" field set.`);
+    }
+    return ((projectPackageJson.dependencies && projectPackageJson.dependencies["react-native"]) ||
+        (projectPackageJson.devDependencies && projectPackageJson.devDependencies["react-native"]));
+}
+exports.getReactNativeVersion = getReactNativeVersion;

package/bin/script/sign.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs/promises");
+const hashUtils = require("./hash-utils");
+const path = require("path");
+const jwt = require("jsonwebtoken");
+const file_utils_1 = require("./utils/file-utils");
+const CURRENT_CLAIM_VERSION = "1.0.0";
+const METADATA_FILE_NAME = ".codepushrelease";
+async function sign(privateKeyPath, updateContentsPath) {
+    if (!privateKeyPath) {
+        return Promise.resolve(null);
+    }
+    let privateKey;
+    try {
+        privateKey = await fs.readFile(privateKeyPath);
+    }
+    catch (err) {
+        return Promise.reject(new Error(`The path specified for the signing key ("${privateKeyPath}") was not valid.`));
+    }
+    // If releasing a single file, copy the file to a temporary 'CodePush' directory in which to publish the release
+    try {
+        if (!(0, file_utils_1.isDirectory)(updateContentsPath)) {
+            updateContentsPath = (0, file_utils_1.copyFileToTmpDir)(updateContentsPath);
+        }
+    }
+    catch (error) {
+        Promise.reject(error);
+    }
+    const signatureFilePath = path.join(updateContentsPath, METADATA_FILE_NAME);
+    let prevSignatureExists = true;
+    try {
+        await fs.access(signatureFilePath, fs.constants.F_OK);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            prevSignatureExists = false;
+        }
+        else {
+            return Promise.reject(new Error(`Could not delete previous release signature at ${signatureFilePath}.
+                Please, check your access rights.`));
+        }
+    }
+    if (prevSignatureExists) {
+        console.log(`Deleting previous release signature at ${signatureFilePath}`);
+        await fs.rmdir(signatureFilePath);
+    }
+    const hash = await hashUtils.generatePackageHashFromDirectory(updateContentsPath, path.join(updateContentsPath, ".."));
+    const claims = {
+        claimVersion: CURRENT_CLAIM_VERSION,
+        contentHash: hash,
+    };
+    return new Promise((resolve, reject) => {
+        jwt.sign(claims, privateKey, { algorithm: "RS256" }, async (err, signedJwt) => {
+            if (err) {
+                reject(new Error("The specified signing key file was not valid"));
+            }
+            try {
+                await fs.writeFile(signatureFilePath, signedJwt);
+                console.log(`Generated a release signature and wrote it to ${signatureFilePath}`);
+                resolve(null);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+}
+exports.default = sign;

package/bin/script/types/cli.js

@@ -0,0 +1,40 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandType = void 0;
+var CommandType;
+(function (CommandType) {
+    CommandType[CommandType["accessKeyAdd"] = 0] = "accessKeyAdd";
+    CommandType[CommandType["accessKeyPatch"] = 1] = "accessKeyPatch";
+    CommandType[CommandType["accessKeyList"] = 2] = "accessKeyList";
+    CommandType[CommandType["accessKeyRemove"] = 3] = "accessKeyRemove";
+    CommandType[CommandType["appAdd"] = 4] = "appAdd";
+    CommandType[CommandType["appList"] = 5] = "appList";
+    CommandType[CommandType["appRemove"] = 6] = "appRemove";
+    CommandType[CommandType["appRename"] = 7] = "appRename";
+    CommandType[CommandType["appTransfer"] = 8] = "appTransfer";
+    CommandType[CommandType["collaboratorAdd"] = 9] = "collaboratorAdd";
+    CommandType[CommandType["collaboratorList"] = 10] = "collaboratorList";
+    CommandType[CommandType["collaboratorRemove"] = 11] = "collaboratorRemove";
+    CommandType[CommandType["debug"] = 12] = "debug";
+    CommandType[CommandType["deploymentAdd"] = 13] = "deploymentAdd";
+    CommandType[CommandType["deploymentHistory"] = 14] = "deploymentHistory";
+    CommandType[CommandType["deploymentHistoryClear"] = 15] = "deploymentHistoryClear";
+    CommandType[CommandType["deploymentList"] = 16] = "deploymentList";
+    CommandType[CommandType["deploymentMetrics"] = 17] = "deploymentMetrics";
+    CommandType[CommandType["deploymentRemove"] = 18] = "deploymentRemove";
+    CommandType[CommandType["deploymentRename"] = 19] = "deploymentRename";
+    CommandType[CommandType["link"] = 20] = "link";
+    CommandType[CommandType["login"] = 21] = "login";
+    CommandType[CommandType["logout"] = 22] = "logout";
+    CommandType[CommandType["patch"] = 23] = "patch";
+    CommandType[CommandType["promote"] = 24] = "promote";
+    CommandType[CommandType["register"] = 25] = "register";
+    CommandType[CommandType["release"] = 26] = "release";
+    CommandType[CommandType["releaseReact"] = 27] = "releaseReact";
+    CommandType[CommandType["rollback"] = 28] = "rollback";
+    CommandType[CommandType["sessionList"] = 29] = "sessionList";
+    CommandType[CommandType["sessionRemove"] = 30] = "sessionRemove";
+    CommandType[CommandType["whoami"] = 31] = "whoami";
+})(CommandType || (exports.CommandType = CommandType = {}));

package/bin/script/types/rest-definitions.js

@@ -0,0 +1,19 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./rest-definitions"), exports);

package/bin/script/types.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/script/utils/file-utils.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = exports.fileDoesNotExistOrIsDirectory = exports.copyFileToTmpDir = exports.fileExists = exports.isDirectory = exports.isBinaryOrZip = void 0;
+const fs = require("fs");
+const path = require("path");
+const rimraf = require("rimraf");
+const temp = require("temp");
+function isBinaryOrZip(path) {
+    return path.search(/\.zip$/i) !== -1 || path.search(/\.apk$/i) !== -1 || path.search(/\.ipa$/i) !== -1;
+}
+exports.isBinaryOrZip = isBinaryOrZip;
+function isDirectory(path) {
+    return fs.statSync(path).isDirectory();
+}
+exports.isDirectory = isDirectory;
+function fileExists(file) {
+    try {
+        return fs.statSync(file).isFile();
+    }
+    catch (e) {
+        return false;
+    }
+}
+exports.fileExists = fileExists;
+;
+function copyFileToTmpDir(filePath) {
+    if (!isDirectory(filePath)) {
+        const outputFolderPath = temp.mkdirSync("code-push");
+        rimraf.sync(outputFolderPath);
+        fs.mkdirSync(outputFolderPath);
+        const outputFilePath = path.join(outputFolderPath, path.basename(filePath));
+        fs.writeFileSync(outputFilePath, fs.readFileSync(filePath));
+        return outputFolderPath;
+    }
+}
+exports.copyFileToTmpDir = copyFileToTmpDir;
+function fileDoesNotExistOrIsDirectory(path) {
+    try {
+        return isDirectory(path);
+    }
+    catch (error) {
+        return true;
+    }
+}
+exports.fileDoesNotExistOrIsDirectory = fileDoesNotExistOrIsDirectory;
+function normalizePath(filePath) {
+    //replace all backslashes coming from cli running on windows machines by slashes
+    return filePath.replace(/\\/g, "/");
+}
+exports.normalizePath = normalizePath;

package/bin/test/acquisition-rest-mock.js

@@ -0,0 +1,108 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomResponseHttpRequester = exports.HttpRequester = exports.serverUrl = exports.latestPackage = exports.validDeploymentKey = void 0;
+const querystring = require("querystring");
+exports.validDeploymentKey = "asdfasdfawerqw";
+exports.latestPackage = {
+    downloadURL: "http://www.windowsazure.com/blobs/awperoiuqpweru",
+    description: "Angry flappy birds",
+    appVersion: "1.5.0",
+    label: "2.4.0",
+    isMandatory: false,
+    isAvailable: true,
+    updateAppVersion: false,
+    packageHash: "hash240",
+    packageSize: 1024,
+};
+exports.serverUrl = "http://myurl.com";
+var reportStatusDeployUrl = exports.serverUrl + "/reportStatus/deploy";
+var reportStatusDownloadUrl = exports.serverUrl + "/reportStatus/download";
+var updateCheckUrl = exports.serverUrl + "/updateCheck?";
+class HttpRequester {
+    request(verb, url, requestBodyOrCallback, callback) {
+        if (!callback && typeof requestBodyOrCallback === "function") {
+            callback = requestBodyOrCallback;
+        }
+        if (verb === 0 /* acquisitionSdk.Http.Verb.GET */ && url.indexOf(updateCheckUrl) === 0) {
+            var params = querystring.parse(url.substring(updateCheckUrl.length));
+            Server.onUpdateCheck(params, callback);
+        }
+        else if (verb === 2 /* acquisitionSdk.Http.Verb.POST */ && url === reportStatusDeployUrl) {
+            Server.onReportStatus(callback);
+        }
+        else if (verb === 2 /* acquisitionSdk.Http.Verb.POST */ && url === reportStatusDownloadUrl) {
+            Server.onReportStatus(callback);
+        }
+        else {
+            throw new Error("Unexpected call");
+        }
+    }
+}
+exports.HttpRequester = HttpRequester;
+class CustomResponseHttpRequester {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    request(verb, url, requestBodyOrCallback, callback) {
+        if (typeof requestBodyOrCallback !== "function") {
+            throw new Error("Unexpected request body");
+        }
+        callback = requestBodyOrCallback;
+        callback(null, this.response);
+    }
+}
+exports.CustomResponseHttpRequester = CustomResponseHttpRequester;
+class Server {
+    static onAcquire(params, callback) {
+        if (params.deploymentKey !== exports.validDeploymentKey) {
+            callback(/*error=*/ null, {
+                statusCode: 200,
+                body: JSON.stringify({ updateInfo: { isAvailable: false } }),
+            });
+        }
+        else {
+            callback(/*error=*/ null, {
+                statusCode: 200,
+                body: JSON.stringify({ updateInfo: exports.latestPackage }),
+            });
+        }
+    }
+    static onUpdateCheck(params, callback) {
+        var updateRequest = {
+            deploymentKey: params.deploymentKey,
+            appVersion: params.appVersion,
+            packageHash: params.packageHash,
+            isCompanion: !!params.isCompanion,
+            label: params.label,
+        };
+        if (!updateRequest.deploymentKey || !updateRequest.appVersion) {
+            callback(/*error=*/ null, { statusCode: 400 });
+        }
+        else {
+            var updateInfo = { isAvailable: false };
+            if (updateRequest.deploymentKey === exports.validDeploymentKey) {
+                if (updateRequest.isCompanion || updateRequest.appVersion === exports.latestPackage.appVersion) {
+                    if (updateRequest.packageHash !== exports.latestPackage.packageHash) {
+                        updateInfo = exports.latestPackage;
+                    }
+                }
+                else if (updateRequest.appVersion < exports.latestPackage.appVersion) {
+                    updateInfo = {
+                        updateAppVersion: true,
+                        appVersion: exports.latestPackage.appVersion,
+                    };
+                }
+            }
+            callback(/*error=*/ null, {
+                statusCode: 200,
+                body: JSON.stringify({ updateInfo: updateInfo }),
+            });
+        }
+    }
+    static onReportStatus(callback) {
+        callback(/*error*/ null, /*response*/ { statusCode: 200 });
+    }
+}