@algocare/react-native-code-push 12.6.3 → 13.0.0-rc.0

package/cli/functions/runHermesEmitBinaryCommand.ts

@@ -0,0 +1,203 @@
+/**
+ * code based on appcenter-cli
+ */
+
+import childProcess from "child_process";
+import fs from "fs";
+import path from "path";
+import shell from "shelljs";
+
+/**
+ * Run Hermes compile CLI command
+ *
+ * @param bundleName {string} JS bundle file name
+ * @param outputPath {string} Path to output .hbc file
+ * @param sourcemapOutput {string} Path to output sourcemap file (Warning: if sourcemapOutput points to the outputPath, the sourcemap will be included in the CodePush bundle and increase the deployment size)
+ * @param extraHermesFlags {string[]} Additional options to pass to `hermesc` command
+ * @return {Promise<void>}
+ */
+export async function runHermesEmitBinaryCommand(
+    bundleName: string,
+    outputPath: string,
+    sourcemapOutput: string,
+    extraHermesFlags: string[] = [],
+): Promise<void> {
+    const hermesArgs: string[] = [
+        '-emit-binary',
+        '-out',
+        path.join(outputPath, bundleName + '.hbc'),
+        path.join(outputPath, bundleName),
+        ...extraHermesFlags,
+    ];
+    if (sourcemapOutput) {
+        hermesArgs.push('-output-source-map');
+    }
+
+    console.log('Converting JS bundle to byte code via Hermes, running command:\n');
+
+    return new Promise<void>((resolve, reject) => {
+        try {
+            const hermesCommand = getHermesCommand();
+
+            const disableAllWarningsArg = '-w';
+            shell.exec(`${hermesCommand} ${hermesArgs.join(' ')} ${disableAllWarningsArg}`);
+
+            // Copy HBC bundle to overwrite JS bundle
+            const source = path.join(outputPath, bundleName + '.hbc');
+            const destination = path.join(outputPath, bundleName);
+            shell.cp(source, destination);
+            shell.rm(source);
+            resolve();
+        } catch (e) {
+            reject(e);
+        }
+    }).then(() => {
+        if (!sourcemapOutput) {
+            // skip source map compose if source map is not enabled
+            return;
+        }
+
+        // compose-source-maps.js file path
+        const composeSourceMapsPath = getComposeSourceMapsPath();
+        if (composeSourceMapsPath === null) {
+            throw new Error('react-native compose-source-maps.js scripts is not found');
+        }
+
+        const jsCompilerSourceMapFile = path.join(outputPath, 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,
+            ];
+            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 != null) {
+                        console.error(err);
+                        reject(err);
+                    }
+
+                    resolve();
+                });
+            });
+        });
+    });
+}
+
+function getHermesCommand(): string {
+    const fileExists = (file: string): boolean => {
+        try {
+            return fs.statSync(file).isFile();
+        } catch (e) {
+            return false;
+        }
+    };
+
+    const hermescExecutable = path.join(getHermesCompilerPath(), getHermesOSBin(), getHermesOSExe());
+    if (fileExists(hermescExecutable)) {
+        return hermescExecutable;
+    }
+    throw new Error('Hermes engine binary not found. Please upgrade to react-native 0.69 or later');
+}
+
+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(): string {
+    const hermesExecutableName = 'hermesc';
+    switch (process.platform) {
+        case 'win32':
+            return hermesExecutableName + '.exe';
+        default:
+            return hermesExecutableName;
+    }
+}
+
+function getComposeSourceMapsPath(): string | null {
+    // 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');
+}
+
+function getHermescDirPathInHermesCompilerPackage() {
+    const result = childProcess.spawnSync('node', [
+        '--print',
+        "require.resolve('hermes-compiler/package.json')",
+    ]);
+    const packagePath = path.dirname(result.stdout.toString());
+    const hermescDirPath = path.join(packagePath, 'hermesc');
+    if (result.status === 0 && directoryExistsSync(hermescDirPath)) {
+        return hermescDirPath;
+    }
+    return null;
+}
+
+function getHermesCompilerPath() {
+    const hermescDirPath = getHermescDirPathInHermesCompilerPackage();
+    if (hermescDirPath) {
+        // Since react-native 0.83, Hermes compiler executables are in 'hermes-compiler' package
+        return hermescDirPath
+    } else {
+        return path.join(getReactNativePackagePath(), 'sdks', 'hermesc');
+    }
+}
+
+function directoryExistsSync(dirname: string): boolean {
+    try {
+        return fs.statSync(dirname).isDirectory();
+    } catch (err: unknown) {
+        if ((err as any).code !== 'ENOENT') {
+            throw err;
+        }
+    }
+    return false;
+}

package/cli/functions/runReactNativeBundleCommand.ts

@@ -0,0 +1,67 @@
+/**
+ * code based on appcenter-cli
+ */
+
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import shell from "shelljs";
+
+/**
+ * Run `react-native bundle` CLI command
+ *
+ * @param bundleName {string} JS bundle file name
+ * @param entryFile {string} App code entry file name (default: index.ts)
+ * @param outputPath {string} Path to output JS bundle file and assets
+ * @param platform {string} Platform (ios | android)
+ * @param sourcemapOutput {string} Path to output sourcemap file (Warning: if sourcemapOutput points to the outputPath, the sourcemap will be included in the CodePush bundle and increase the deployment size)
+ * @param extraBundlerOptions {string[]} Additional options to pass to `react-native bundle` command
+ * @return {void}
+ */
+export function runReactNativeBundleCommand(
+    bundleName: string,
+    outputPath: string,
+    platform: string,
+    sourcemapOutput: string,
+    entryFile: string,
+    extraBundlerOptions: string[] = [],
+): void {
+    function getCliPath(): string {
+        // pnpm hoisted 레이아웃에서는 react-native가 워크스페이스 루트로 호이스트되어
+        // cwd 상대 node_modules/.bin 경로가 존재하지 않을 수 있다. 로컬 .bin을 우선
+        // 사용하고, 없으면 Node resolution(상위 디렉토리 탐색)으로 패키지 bin을 찾는다.
+        const localBin = path.join('node_modules', '.bin', 'react-native');
+        if (fs.existsSync(localBin)) {
+            return localBin;
+        }
+
+        const requireFromCwd = createRequire(path.resolve('package.json'));
+        const packageJsonPath = requireFromCwd.resolve('react-native/package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const binRelativePath = typeof packageJson.bin === 'string'
+            ? packageJson.bin
+            : packageJson.bin['react-native'];
+        return `node "${path.join(path.dirname(packageJsonPath), binRelativePath)}"`;
+    }
+
+    const reactNativeBundleArgs: string[] = [
+        'bundle',
+        '--assets-dest',
+        outputPath,
+        '--bundle-output',
+        path.join(outputPath, bundleName),
+        '--dev',
+        'false',
+        '--entry-file',
+        entryFile,
+        '--platform',
+        platform,
+        '--sourcemap-output',
+        sourcemapOutput,
+        ...extraBundlerOptions,
+    ];
+
+    console.log('Running "react-native bundle" command:\n');
+
+    shell.exec(`${getCliPath()} ${reactNativeBundleArgs.join(' ')}`);
+}

package/cli/index.ts

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import { program } from "commander";
+import shell from "shelljs";
+import { showLogo } from "./utils/showLogo.js";
+
+/**
+ * npx code-push bundle
+ */
+import "./commands/bundleCommand/index.js";
+
+/**
+ * npx code-push create-history
+ */
+import "./commands/createHistoryCommand/index.js";
+
+/**
+ * npx code-push update-history
+ */
+import "./commands/updateHistoryCommand/index.js";
+
+/**
+ * npx code-push release
+ */
+import "./commands/releaseCommand/index.js";
+
+/**
+ * npx code-push show-history
+ */
+import "./commands/showHistoryCommand/index.js";
+
+/**
+ * npx code-push init
+ */
+import "./commands/initCommand/index.js";
+
+/**
+ * npx code-push create-pr-history
+ */
+import "./commands/createPullRequestHistoryCommand/index.js";
+
+/**
+ * npx code-push create-pr-release
+ */
+import "./commands/createPullRequestReleaseCommand/index.js";
+
+/**
+ * npx code-push remove-pr-history
+ */
+import "./commands/removePullRequestHistoryCommand/index.js";
+
+/**
+ * npx code-push get-package-hash
+ */
+import "./commands/getPackageHashCommand/index.js";
+
+shell.set("-e");
+shell.set("+v");
+
+program
+    .name("npx code-push")
+    .description("Command line interface for @algocare/react-native-code-push")
+    .version("1.0.0")
+    .action(() => {
+        showLogo();
+    });
+
+program.parse();

package/cli/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@algocare/code-push-cli",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "jest"
+  },
+  "dependencies": {
+    "commander": "^12.1.0",
+    "shelljs": "^0.10.0",
+    "xcode": "^3.0.1",
+    "yazl": "^3.3.1",
+    "yauzl": "^3.2.0"
+  },
+  "peerDependencies": {
+    "ts-node": ">=10"
+  },
+  "peerDependenciesMeta": {
+    "ts-node": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/yazl": "^3.3.0",
+    "@types/yauzl": "^2.10.3"
+  }
+}

package/cli/utils/datetime.ts

@@ -0,0 +1,19 @@
+/**
+ * Returns the current local timestamp in `YYYY-MM-DD HH:mm:ss` format.
+ * Recorded in release history entries as `createdAt` / `updatedAt`.
+ */
+export function getTimestamp(): string {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = padWithZero(date.getMonth() + 1);
+    const day = padWithZero(date.getDate());
+    const hour = padWithZero(date.getHours());
+    const minute = padWithZero(date.getMinutes());
+    const second = padWithZero(date.getSeconds());
+
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+}
+
+function padWithZero(value: number): string {
+    return value < 10 ? `0${value}` : `${value}`;
+}

package/cli/utils/{file-utils.js → file-utils.ts}

@@ -2,23 +2,13 @@
  * code based on appcenter-cli
  */
 
-const fs = require('fs');
+import fs from "fs";
 
-/**
- *
- * @param path {string}
- * @return {boolean}
- */
-function isDirectory(path) {
+export function isDirectory(path: string): boolean {
     return fs.statSync(path).isDirectory();
 }
 
-/**
- *
- * @param length {number}
- * @return {string}
- */
-function generateRandomFilename(length) {
+export function generateRandomFilename(length: number): string {
     let filename = '';
     const validChar = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
 
@@ -29,14 +19,7 @@ function generateRandomFilename(length) {
     return filename;
 }
 
-/**
- *
- * @param filePath {string}
- * @return {string}
- */
-function normalizePath(filePath) {
+export function normalizePath(filePath: string): string {
     //replace all backslashes coming from cli running on windows machines by slashes
     return filePath.replace(/\\/g, '/');
 }
-
-module.exports = { isDirectory, generateRandomFilename, normalizePath };

package/cli/utils/fsUtils.ts

@@ -0,0 +1,50 @@
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+import type { CliConfigInterface } from "../../typings/react-native-code-push.d.ts";
+
+const nodeRequire = createRequire(import.meta.url);
+
+/**
+ * allows to require a config file with .ts extension
+ */
+function requireConfig(filePath: string): CliConfigInterface {
+  const ext = path.extname(filePath);
+
+  if (ext === '.ts') {
+    try {
+      nodeRequire('ts-node/register');
+    } catch {
+      console.error('ts-node not found. Please install ts-node as a devDependency.');
+      process.exit(1);
+    }
+  } else if (ext === '.js') {
+    // do nothing
+  } else {
+    throw new Error(`Unsupported file extension: ${ext}`);
+  }
+
+  return nodeRequire(filePath) as CliConfigInterface;
+}
+
+export function findAndReadConfigFile(startDir: string, configFileName: string): CliConfigInterface {
+  // If the default `code-push.config.ts` is not found, fall back to the compiled/plain-JS
+  // `code-push.config.js`. (algocare apps ship a JS config; an explicitly passed -c option is used as-is.)
+  const candidateFileNames = configFileName === 'code-push.config.ts'
+    ? [configFileName, 'code-push.config.js']
+    : [configFileName];
+
+  for (const candidate of candidateFileNames) {
+    let dir = startDir;
+
+    while (dir !== path.parse(dir).root) {
+      const configPath = path.join(dir, candidate);
+      if (fs.existsSync(configPath)) {
+        return requireConfig(configPath);
+      }
+      dir = path.dirname(dir);
+    }
+  }
+
+  throw new Error(`${configFileName} not found.`);
+}

package/cli/utils/hash-utils.ts

@@ -0,0 +1,143 @@
+/**
+ * code based on appcenter-cli
+ */
+
+/**
+ * NOTE!!! This utility file is duplicated for use by the CodePush service (for server-driven hashing/
+ * integrity checks) and Management SDK (for end-to-end code signing), please keep them in sync.
+ */
+
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { isDirectory } from "./file-utils.js";
+import { walk } from "./promisfied-fs.js";
+
+// Do not throw an exception if either of these modules are missing, as they may not be needed by the
+// consumer of this file.
+const HASH_ALGORITHM = 'sha256';
+class PackageManifest {
+    private _map: Map<string, string>;
+
+    constructor(map?: Map<string, string>) {
+        if (map == null) {
+            map = new Map();
+        }
+        this._map = map;
+    }
+
+    toMap(): Map<string, string> {
+        return this._map;
+    }
+
+    computePackageHash(): string {
+        let entries: string[] = [];
+        this._map.forEach((hash, name) => {
+            entries.push(name + ':' + hash);
+        });
+
+        // Make sure this list is alphabetically ordered so that other clients
+        // can also compute this hash easily given the update contents.
+        entries = entries.sort();
+
+        return crypto.createHash(HASH_ALGORITHM).update(JSON.stringify(entries)).digest('hex');
+    }
+
+    serialize(): string {
+        const obj: Record<string, string> = {};
+
+        this._map.forEach(function (value, key) {
+            obj[key] = value;
+        });
+
+        return JSON.stringify(obj);
+    }
+
+    static normalizePath(filePath: string): string {
+        //replace all backslashes coming from cli running on windows machines by slashes
+        return filePath.replace(/\\/g, '/');
+    }
+
+    static isIgnored(relativeFilePath: string): boolean {
+        const __MACOSX = '__MACOSX/';
+        const DS_STORE = '.DS_Store';
+        return (
+            relativeFilePath.startsWith(__MACOSX) ||
+            relativeFilePath === DS_STORE ||
+            relativeFilePath.endsWith('/' + DS_STORE)
+        );
+    }
+}
+
+export async function generatePackageHashFromDirectory(directoryPath: string, basePath: string) {
+    try {
+        if (!isDirectory(directoryPath)) {
+            throw new Error('Not a directory. Please either create a directory, or use hashFile().');
+        }
+    } catch (error) {
+        throw new Error('Directory does not exist. Please either create a directory, or use hashFile().');
+    }
+
+    /**
+     * @type {PackageManifest}
+     */
+    const manifest = await generatePackageManifestFromDirectory(directoryPath, basePath);
+    return manifest.computePackageHash();
+}
+
+function generatePackageManifestFromDirectory(directoryPath: string, basePath: string): Promise<PackageManifest> {
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve, reject) => {
+        const fileHashesMap = new Map<string, string>();
+
+        const files: string[] = await walk(directoryPath);
+
+        if (!files || files.length === 0) {
+            reject('Error: Cannot sign the release because no files were found.');
+            return;
+        }
+
+        // Hash the files sequentially, because streaming them in parallel is not necessarily faster
+        const generateManifestPromise = files.reduce<Promise<unknown>>((soFar, filePath) => {
+            return soFar.then(() => {
+                const relativePath: string = PackageManifest.normalizePath(path.relative(basePath, filePath));
+                if (!PackageManifest.isIgnored(relativePath)) {
+                    return hashFile(filePath).then((hash) => {
+                        fileHashesMap.set(relativePath, hash);
+                    });
+                }
+            });
+        }, Promise.resolve(null));
+
+        generateManifestPromise.then(() => {
+            resolve(new PackageManifest(fileHashesMap));
+        }, reject);
+    });
+}
+
+function hashFile(filePath: string): Promise<string> {
+    const readStream: fs.ReadStream = fs.createReadStream(filePath);
+    return hashStream(readStream);
+}
+
+function hashStream(readStream: fs.ReadStream): Promise<string> {
+    return new Promise((resolve, reject) => {
+        const _hashStream = crypto.createHash(HASH_ALGORITHM)
+
+        readStream
+            .on('error', (error) => {
+                _hashStream.end();
+                reject(error);
+            })
+            .on('end', () => {
+                _hashStream.end();
+
+                const buffer = _hashStream.read();
+                const hash: string = buffer.toString('hex');
+
+                resolve(hash);
+            });
+
+        readStream.pipe(_hashStream);
+    });
+}

package/cli/utils/promisfied-fs.ts

@@ -0,0 +1,19 @@
+/**
+ * code based on appcenter-cli
+ */
+
+import { promises as fs } from "fs";
+import path from "path";
+
+export async function walk(dir: string): Promise<string[]> {
+    const stats = await fs.stat(dir);
+    if (stats.isDirectory()) {
+        let files: string[] = [];
+        for (const file of await fs.readdir(dir)) {
+            files = files.concat(await walk(path.join(dir, file)));
+        }
+        return files;
+    } else {
+        return [dir];
+    }
+}

package/cli/utils/{showLogo.js → showLogo.ts}

@@ -1,4 +1,4 @@
-function showLogo() {
+export function showLogo() {
   const logo = `
     
 +------------------------------------------------------------------+
@@ -10,14 +10,12 @@ function showLogo() {
 |           \\____/\\____/\\__,_/\\___/_/    \\__,_/____/_/ /_/         |
 |                                                                  |
 |                                                                  |
-|              🚀 @algocare/react-native-code-push              |
+|              🚀 @bravemobile/react-native-code-push              |
 +------------------------------------------------------------------+                                     
 
 Please refer to help command for more information.
 
 (interactive mode is not supported yet.)
-    `
-  console.log(logo)
+    `;
+  console.log(logo);
 }
-
-module.exports = { showLogo }