@revopush/code-push-cli 0.0.1

package/script/react-native-utils.ts

@@ -0,0 +1,283 @@
+import * as fs from "fs";
+import * as chalk from "chalk";
+import * as path from "path";
+import * as childProcess from "child_process";
+import { coerce, compare, valid } from "semver";
+import { fileDoesNotExistOrIsDirectory } from "./utils/file-utils";
+
+const g2js = require("gradle-to-js/lib/parser");
+
+export function isValidVersion(version: string): boolean {
+  return !!valid(version) || /^\d+\.\d+$/.test(version);
+}
+
+export async function runHermesEmitBinaryCommand(
+    bundleName: string,
+    outputFolder: string,
+    sourcemapOutput: string,
+    extraHermesFlags: string[],
+    gradleFile: string
+): Promise<void> {
+  const hermesArgs: string[] = [];
+  const envNodeArgs: string = 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<void>((resolve, reject) => {
+    hermesProcess.stdout.on("data", (data: Buffer) => {
+      console.log(data.toString().trim());
+    });
+
+    hermesProcess.stderr.on("data", (data: Buffer) => {
+      console.error(data.toString().trim());
+    });
+
+    hermesProcess.on("close", (exitCode: number, signal: string) => {
+      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 as void);
+        });
+      });
+    });
+  }).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: Buffer) => {
+        console.log(data.toString().trim());
+      });
+
+      composeSourceMapsProcess.stderr.on("data", (data: Buffer) => {
+        console.error(data.toString().trim());
+      });
+
+      composeSourceMapsProcess.on("close", (exitCode: number, signal: string) => {
+        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);
+        });
+      });
+    });
+  });
+}
+
+function parseBuildGradleFile(gradleFile: string) {
+  let buildGradlePath: string = path.join("android", "app");
+  if (gradleFile) {
+    buildGradlePath = gradleFile;
+  }
+  if (fs.lstatSync(buildGradlePath).isDirectory()) {
+    buildGradlePath = path.join(buildGradlePath, "build.gradle");
+  }
+
+  if (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: string): Promise<string> {
+  const buildGradle: any = await parseBuildGradleFile(gradleFile);
+  const hermesCommandProperty: any = Array.from(buildGradle["project.ext.react"] || []).find((prop: string) =>
+    prop.trim().startsWith("hermesCommand:")
+  );
+  if (hermesCommandProperty) {
+    return hermesCommandProperty.replace("hermesCommand:", "").trim().slice(1, -1);
+  } else {
+    return "";
+  }
+}
+
+export function getAndroidHermesEnabled(gradleFile: string): boolean {
+  return parseBuildGradleFile(gradleFile).then((buildGradle: any) => {
+    return Array.from(buildGradle["project.ext.react"] || []).some((line: string) => /^enableHermes\s{0,}:\s{0,}true/.test(line));
+  });
+}
+
+export function getiOSHermesEnabled(podFile: string): boolean {
+  let podPath = path.join("ios", "Podfile");
+  if (podFile) {
+    podPath = podFile;
+  }
+  if (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;
+  }
+}
+
+function getHermesOSBin(): string {
+  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(): string {
+  const react63orAbove = compare(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: string): Promise<string> {
+  const fileExists = (file: string): boolean => {
+    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(): string {
+  // 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(): string {
+  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");
+}
+
+export function directoryExistsSync(dirname: string): boolean {
+  try {
+    return fs.statSync(dirname).isDirectory();
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      throw err;
+    }
+  }
+  return false;
+}
+
+export function getReactNativeVersion(): string {
+  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: string = 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"])
+  );
+}

package/script/sign.ts

@@ -0,0 +1,80 @@
+import * as fs from "fs/promises";
+import * as hashUtils from "./hash-utils";
+import * as path from "path";
+import * as jwt from "jsonwebtoken";
+import { copyFileToTmpDir, isDirectory } from "./utils/file-utils";
+
+const CURRENT_CLAIM_VERSION: string = "1.0.0";
+const METADATA_FILE_NAME: string = ".codepushrelease";
+
+interface CodeSigningClaims {
+  claimVersion: string;
+  contentHash: string;
+}
+
+export default async function sign(privateKeyPath: string, updateContentsPath: string): Promise<void> {
+  if (!privateKeyPath) {
+    return Promise.resolve<void>(null);
+  }
+
+  let privateKey: Buffer;
+
+  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 (!isDirectory(updateContentsPath)) {
+      updateContentsPath = copyFileToTmpDir(updateContentsPath);
+    }
+  } catch (error) {
+    Promise.reject(error);
+  }
+
+  const signatureFilePath: string = 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<void>(
+        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: string = await hashUtils.generatePackageHashFromDirectory(updateContentsPath, path.join(updateContentsPath, ".."));
+  const claims: CodeSigningClaims = {
+    claimVersion: CURRENT_CLAIM_VERSION,
+    contentHash: hash,
+  };
+
+  return new Promise<void>((resolve, reject) => {
+    jwt.sign(claims, privateKey, { algorithm: "RS256" }, async (err: Error, signedJwt: string) => {
+      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);
+      }
+    });
+  });
+}

package/script/types/cli.ts

@@ -0,0 +1,232 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+import AccountManager = require("../management-sdk");
+
+export enum CommandType {
+  accessKeyAdd,
+  accessKeyPatch,
+  accessKeyList,
+  accessKeyRemove,
+  appAdd,
+  appList,
+  appRemove,
+  appRename,
+  appTransfer,
+  collaboratorAdd,
+  collaboratorList,
+  collaboratorRemove,
+  debug,
+  deploymentAdd,
+  deploymentHistory,
+  deploymentHistoryClear,
+  deploymentList,
+  deploymentMetrics,
+  deploymentRemove,
+  deploymentRename,
+  link,
+  login,
+  logout,
+  patch,
+  promote,
+  register,
+  release,
+  releaseReact,
+  rollback,
+  sessionList,
+  sessionRemove,
+  whoami,
+}
+
+export interface ICommand {
+  type: CommandType;
+}
+
+export interface IAccessKeyAddCommand extends ICommand {
+  name: string;
+  ttl?: number;
+}
+
+export interface IAccessKeyPatchCommand extends ICommand {
+  newName?: string;
+  oldName: string;
+  ttl?: number;
+}
+
+export interface IAccessKeyListCommand extends ICommand {
+  format: string;
+}
+
+export interface IAccessKeyRemoveCommand extends ICommand {
+  accessKey: string;
+}
+
+export interface IAppAddCommand extends ICommand {
+  appName: string;
+  os: string;
+  platform: string;
+}
+
+export interface IAppListCommand extends ICommand {
+  format: string;
+}
+
+export interface IAppRemoveCommand extends ICommand {
+  appName: string;
+}
+
+export interface IAppRenameCommand extends ICommand {
+  currentAppName: string;
+  newAppName: string;
+}
+
+export interface IAppTransferCommand extends ICommand {
+  appName: string;
+  email: string;
+}
+
+export interface ICollaboratorAddCommand extends ICommand {
+  appName: string;
+  email: string;
+}
+
+export interface ICollaboratorListCommand extends ICommand {
+  appName: string;
+  format: string;
+}
+
+export interface ICollaboratorRemoveCommand extends ICommand {
+  appName: string;
+  email: string;
+}
+
+export interface IDebugCommand extends ICommand {
+  platform: string;
+}
+
+export interface IDeploymentAddCommand extends ICommand {
+  appName: string;
+  deploymentName: string;
+  default: boolean;
+}
+
+export interface IDeploymentHistoryClearCommand extends ICommand {
+  appName: string;
+  deploymentName: string;
+}
+
+export interface IDeploymentHistoryCommand extends ICommand {
+  appName: string;
+  deploymentName: string;
+  format: string;
+  displayAuthor: boolean;
+}
+
+export interface IDeploymentListCommand extends ICommand {
+  appName: string;
+  format: string;
+  displayKeys: boolean;
+}
+
+export interface IDeploymentRemoveCommand extends ICommand {
+  appName: string;
+  deploymentName: string;
+}
+
+export interface IDeploymentRenameCommand extends ICommand {
+  appName: string;
+  currentDeploymentName: string;
+  newDeploymentName: string;
+}
+
+export interface ILinkCommand extends ICommand {
+  serverUrl?: string;
+}
+
+export interface ILoginCommand extends ICommand {
+  serverUrl?: string;
+  accessKey: string;
+}
+
+export interface IPackageInfo {
+  description?: string;
+  label?: string;
+  disabled?: boolean;
+  mandatory?: boolean;
+  rollout?: number;
+}
+
+export interface IPatchCommand extends ICommand, IPackageInfo {
+  appName: string;
+  appStoreVersion?: string;
+  deploymentName: string;
+  label: string;
+}
+
+export interface IPromoteCommand extends ICommand, IPackageInfo {
+  appName: string;
+  appStoreVersion?: string;
+  sourceDeploymentName: string;
+  destDeploymentName: string;
+  noDuplicateReleaseError?: boolean;
+}
+
+export interface IRegisterCommand extends ICommand {
+  serverUrl?: string;
+}
+
+export interface IReleaseBaseCommand extends ICommand, IPackageInfo {
+  appName: string;
+  appStoreVersion: string;
+  deploymentName: string;
+  noDuplicateReleaseError?: boolean;
+  privateKeyPath?: string;
+}
+
+export interface IReleaseCommand extends IReleaseBaseCommand {
+  package: string;
+}
+
+export interface IReleaseReactCommand extends IReleaseBaseCommand {
+  bundleName?: string;
+  development?: boolean;
+  entryFile?: string;
+  gradleFile?: string;
+  platform: string;
+  plistFile?: string;
+  plistFilePrefix?: string;
+  sourcemapOutput?: string;
+  outputDir?: string;
+  config?: string;
+  useHermes?: boolean;
+  extraHermesFlags?: string[];
+  podFile?: string;
+  xcodeProjectFile?: string;
+  xcodeTargetName?: string;
+  buildConfigurationName?: string;
+}
+
+export interface IRollbackCommand extends ICommand {
+  appName: string;
+  deploymentName: string;
+  targetRelease: string;
+}
+
+export interface ISessionListCommand extends ICommand {
+  format: string;
+}
+
+export interface ISessionRemoveCommand extends ICommand {
+  machineName: string;
+}
+
+export type ReleaseHook = (
+  currentCommand: IReleaseCommand,
+  originalCommand: IReleaseCommand,
+  sdk: AccountManager
+) => Q.Promise<IReleaseCommand | void>;
+
+export interface ReleaseFile {
+  sourceLocation: string; // The current location of the file on disk
+  targetLocation: string; // The desired location of the file within the zip
+}