react-native-update-cli 2.9.3 → 2.9.5

package/src/diff.ts

@@ -6,9 +6,54 @@ import type { CommandContext } from './types';
 import { translateOptions } from './utils';
 import { isPPKBundleFileName, scriptName, tempDir } from './utils/constants';
 import { t } from './utils/i18n';
-import { enumZipEntries, readEntry } from './utils/zip-entries';
+import {
+  enumZipEntries,
+  readEntry,
+  readEntryPrefix,
+} from './utils/zip-entries';
+import {
+  ZIP_ENTRY_SNIFF_BYTES,
+  zipOptionsForManifestEntry,
+  zipOptionsForPatchEntry,
+  zipOptionsForPayloadEntry,
+} from './utils/zip-options';
 
 type Diff = (oldSource?: Buffer, newSource?: Buffer) => Buffer;
+type HpatchCover = {
+  oldPos: number | string | bigint;
+  newPos: number | string | bigint;
+  len: number | string | bigint;
+};
+type HpatchCompatiblePlan = {
+  covers?: HpatchCover[];
+};
+type HdiffWithCoversOptions = {
+  mode?: 'replace' | 'merge' | 'native-coalesce';
+};
+type HdiffModule = {
+  diff?: Diff;
+  diffWithCovers?: (
+    oldSource: Buffer,
+    newSource: Buffer,
+    covers: HpatchCover[],
+    options?: HdiffWithCoversOptions,
+  ) => { diff?: Buffer };
+};
+type BsdiffModule = {
+  diff?: Diff;
+};
+type ChiffModule = {
+  hpatchCompatiblePlanResult?: (
+    oldSource: Buffer,
+    newSource: Buffer,
+  ) => HpatchCompatiblePlan;
+  hpatchApproximatePlanResult?: (
+    oldSource: Buffer,
+    newSource: Buffer,
+  ) => HpatchCompatiblePlan;
+};
+type ChiffHpatchPolicy = 'off' | 'costed';
+type ChiffHpatchExactPolicy = 'off' | 'on';
 type EntryMap = Record<string, { crc32: number; fileName: string }>;
 type CrcMap = Record<number, string>;
 type CopyMap = Record<string, string>;
@@ -28,22 +73,134 @@ type DiffCommandConfig = {
 
 export { enumZipEntries, readEntry };
 
-const loadDiffModule = (pkgName: string): Diff | undefined => {
+const loadModule = <T>(pkgName: string): T | undefined => {
   const resolvePaths = ['.', npm.packages, yarn.packages];
 
   try {
     const resolved = require.resolve(pkgName, { paths: resolvePaths });
-    const mod = require(resolved);
-    if (mod?.diff) {
-      return mod.diff as Diff;
-    }
+    return require(resolved) as T;
   } catch {}
 
   return undefined;
 };
 
-const hdiff = loadDiffModule('node-hdiffpatch');
-const bsdiff = loadDiffModule('node-bsdiff');
+const hdiff = loadModule<HdiffModule>('node-hdiffpatch');
+const bsdiff = loadModule<BsdiffModule>('node-bsdiff');
+const chiff = loadModule<ChiffModule>('@chiff/node');
+
+// Structured covers are experimental and can be expensive on real Hermes input.
+// Keep native hdiff as the default unless the server explicitly opts in.
+function resolveChiffHpatchPolicy(policy?: unknown): ChiffHpatchPolicy {
+  const value = String(
+    policy ?? process.env.RNU_CHIFF_HPATCH_POLICY ?? 'off',
+  ).toLowerCase();
+  if (
+    value === 'costed' ||
+    value === 'on' ||
+    value === 'true' ||
+    value === '1'
+  ) {
+    return 'costed';
+  }
+  return 'off';
+}
+
+function resolveChiffHpatchMinNativeBytes(value?: unknown): number {
+  const raw = value ?? process.env.RNU_CHIFF_HPATCH_MIN_NATIVE_BYTES ?? 4096;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return 4096;
+  }
+  return Math.floor(parsed);
+}
+
+function resolveChiffHpatchExactPolicy(policy?: unknown): ChiffHpatchExactPolicy {
+  const value = String(
+    policy ?? process.env.RNU_CHIFF_HPATCH_EXACT_COVERS ?? 'off',
+  ).toLowerCase();
+  if (value === 'on' || value === 'true' || value === '1') {
+    return 'on';
+  }
+  return 'off';
+}
+
+function createChiffAwareHdiff(
+  hdiffModule: HdiffModule,
+  chiffModule: ChiffModule | undefined,
+  policy: ChiffHpatchPolicy,
+  minNativeBytes: number,
+  exactPolicy: ChiffHpatchExactPolicy,
+): Diff {
+  const baseDiff = hdiffModule.diff;
+  if (!baseDiff) {
+    throw new Error(t('nodeHdiffpatchRequired', { scriptName }));
+  }
+
+  if (policy === 'off') {
+    return baseDiff;
+  }
+
+  return (oldSource?: Buffer, newSource?: Buffer) => {
+    const nativeDiff = baseDiff(oldSource, newSource);
+    if (!oldSource || !newSource || !hdiffModule.diffWithCovers) {
+      return nativeDiff;
+    }
+
+    let bestDiff = nativeDiff;
+    const tryDiffWithCovers = (
+      covers: HpatchCover[],
+      mode: 'replace' | 'merge' | 'native-coalesce',
+    ) => {
+      try {
+        const result = hdiffModule.diffWithCovers?.(
+          oldSource,
+          newSource,
+          covers,
+          { mode },
+        );
+        if (
+          Buffer.isBuffer(result?.diff) &&
+          result.diff.length < bestDiff.length
+        ) {
+          bestDiff = result.diff;
+        }
+      } catch {}
+    };
+
+    tryDiffWithCovers([], 'native-coalesce');
+
+    if (nativeDiff.length < minNativeBytes) {
+      return bestDiff;
+    }
+
+    try {
+      const approximatePlan = chiffModule?.hpatchApproximatePlanResult?.(
+        oldSource,
+        newSource,
+      );
+      if (Array.isArray(approximatePlan?.covers)) {
+        tryDiffWithCovers(approximatePlan.covers, 'merge');
+      }
+    } catch {}
+
+    if (
+      exactPolicy === 'off' ||
+      !chiffModule?.hpatchCompatiblePlanResult
+    ) {
+      return bestDiff;
+    }
+
+    try {
+      const plan = chiffModule.hpatchCompatiblePlanResult(oldSource, newSource);
+      if (Array.isArray(plan.covers)) {
+        tryDiffWithCovers(plan.covers, 'replace');
+        tryDiffWithCovers(plan.covers, 'merge');
+      }
+    } catch {}
+
+    return bestDiff;
+  };
+}
 
 function basename(fn: string): string | undefined {
   const m = /^(.+\/)[^\/]+\/?$/.exec(fn);
@@ -123,6 +280,7 @@ async function diffFromPPK(
       zipfile.addBuffer(
         diffFn(originSource, newSource),
         `${entry.fileName}.patch`,
+        zipOptionsForPatchEntry(),
       );
       //console.log('End diff');
     } else {
@@ -150,6 +308,11 @@ async function diffFromPPK(
         addEntry(basePath);
       }
 
+      const entryPrefix = await readEntryPrefix(
+        entry,
+        nextZipfile,
+        ZIP_ENTRY_SNIFF_BYTES,
+      );
       await new Promise<void>((resolve, reject) => {
         nextZipfile.openReadStream(entry, (err, readStream) => {
           if (err) {
@@ -160,7 +323,11 @@ async function diffFromPPK(
               new Error(`Unable to read zip entry: ${entry.fileName}`),
             );
           }
-          zipfile.addReadStream(readStream, entry.fileName);
+          zipfile.addReadStream(
+            readStream,
+            entry.fileName,
+            zipOptionsForPayloadEntry(entry.fileName, entryPrefix),
+          );
           readStream.on('end', () => {
             //console.log('add finished');
             resolve(void 0);
@@ -183,6 +350,7 @@ async function diffFromPPK(
   zipfile.addBuffer(
     Buffer.from(JSON.stringify({ copies, deletes })),
     '__diff.json',
+    zipOptionsForManifestEntry(),
   );
   zipfile.end();
   await writePromise;
@@ -248,6 +416,7 @@ async function diffFromPackage(
       zipfile.addBuffer(
         diffFn(originSource, newSource),
         `${entry.fileName}.patch`,
+        zipOptionsForPatchEntry(),
       );
       //console.log('End diff');
     } else {
@@ -263,6 +432,11 @@ async function diffFromPackage(
         return;
       }
 
+      const entryPrefix = await readEntryPrefix(
+        entry,
+        nextZipfile,
+        ZIP_ENTRY_SNIFF_BYTES,
+      );
       await new Promise<void>((resolve, reject) => {
         nextZipfile.openReadStream(entry, (err, readStream) => {
           if (err) {
@@ -273,7 +447,11 @@ async function diffFromPackage(
               new Error(`Unable to read zip entry: ${entry.fileName}`),
             );
           }
-          zipfile.addReadStream(readStream, entry.fileName);
+          zipfile.addReadStream(
+            readStream,
+            entry.fileName,
+            zipOptionsForPayloadEntry(entry.fileName, entryPrefix),
+          );
           readStream.on('end', () => {
             //console.log('add finished');
             resolve(void 0);
@@ -283,13 +461,22 @@ async function diffFromPackage(
     }
   });
 
-  zipfile.addBuffer(Buffer.from(JSON.stringify({ copies })), '__diff.json');
+  zipfile.addBuffer(
+    Buffer.from(JSON.stringify({ copies })),
+    '__diff.json',
+    zipOptionsForManifestEntry(),
+  );
   zipfile.end();
   await writePromise;
 }
 
 type DiffCommandOptions = {
   customDiff?: Diff;
+  customHdiffModule?: HdiffModule;
+  customChiffModule?: ChiffModule;
+  chiffHpatchPolicy?: ChiffHpatchPolicy;
+  chiffHpatchMinNativeBytes?: number | string;
+  chiffHpatchExactCovers?: ChiffHpatchExactPolicy | boolean | string | number;
   [key: string]: any;
 };
 
@@ -302,16 +489,23 @@ function resolveDiffImplementation(
   }
 
   if (useHdiff) {
-    if (!hdiff) {
+    const hdiffModule = options.customHdiffModule ?? hdiff;
+    if (!hdiffModule?.diff) {
       throw new Error(t('nodeHdiffpatchRequired', { scriptName }));
     }
-    return hdiff;
+    return createChiffAwareHdiff(
+      hdiffModule,
+      options.customChiffModule ?? chiff,
+      resolveChiffHpatchPolicy(options.chiffHpatchPolicy),
+      resolveChiffHpatchMinNativeBytes(options.chiffHpatchMinNativeBytes),
+      resolveChiffHpatchExactPolicy(options.chiffHpatchExactCovers),
+    );
   }
 
-  if (!bsdiff) {
+  if (!bsdiff?.diff) {
     throw new Error(t('nodeBsdiffRequired', { scriptName }));
   }
-  return bsdiff;
+  return bsdiff.diff;
 }
 
 function diffArgsCheck(

package/src/module-manager.ts

@@ -40,10 +40,6 @@ export class ModuleManager {
     if (module.init) {
       module.init(this.provider);
     }
-
-    // console.log(
-    //   `Module '${module.name}' (v${module.version}) registered successfully`,
-    // );
   }
 
   unregisterModule(moduleName: string): void {

package/src/package.ts

@@ -99,7 +99,7 @@ async function uploadNativePackage(
   const { appId: appIdInPkg, appKey: appKeyInPkg } = info;
   const { appId, appKey } = await getSelectedApp(config.platform);
 
-  if (appIdInPkg && appIdInPkg != appId) {
+  if (appIdInPkg && String(appIdInPkg) !== appId) {
     throw new Error(t(config.appIdMismatchKey, { appIdInPkg, appId }));
   }
 
@@ -175,10 +175,11 @@ export async function listPackage(appId: string) {
 
 export async function choosePackage(appId: string) {
   const list = await listPackage(appId);
+  const packageMap = new Map(list?.map((v) => [v.id.toString(), v]));
 
   while (true) {
     const id = await question(t('enterNativePackageId'));
-    const app = list?.find((v) => v.id.toString() === id);
+    const app = packageMap.get(id);
     if (app) {
       return app;
     }
@@ -329,7 +330,7 @@ export const packageCommands = {
   packages: async ({ options }: { options: { platform: Platform } }) => {
     const platform = await getPlatform(options.platform);
     const { appId } = await getSelectedApp(platform);
-    await listPackage(appId);
+    await listPackage(String(appId));
   },
   deletePackage: async ({
     args,
@@ -347,7 +348,7 @@ export const packageCommands = {
 
     if (!appId) {
       const platform = await getPlatform(options.platform);
-      appId = (await getSelectedApp(platform)).appId as string;
+      appId = (await getSelectedApp(platform)).appId;
     }
 
     // If no packageId provided as argument, let user choose from list

package/src/utils/http-helper.ts

@@ -48,7 +48,7 @@ export const ping = async (url: string) => {
         if (!pingFinished) {
           // console.log('ping timeout', url);
         }
-      }, 2000),
+      }, 5000),
     ),
   ]) as Promise<string | null>;
 };

package/src/utils/zip-entries.ts

@@ -28,6 +28,75 @@ export function readEntry(
   });
 }
 
+export function readEntryPrefix(
+  entry: Entry,
+  zipFile: YauzlZipFile,
+  maxBytes: number,
+): Promise<Buffer> {
+  if (maxBytes <= 0) {
+    return Promise.resolve(Buffer.alloc(0));
+  }
+
+  const buffers: Buffer[] = [];
+  let length = 0;
+
+  return new Promise((resolve, reject) => {
+    zipFile.openReadStream(entry, (err, stream) => {
+      if (err) {
+        return reject(err);
+      }
+      if (!stream) {
+        return reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
+      }
+
+      let settled = false;
+      const cleanup = () => {
+        stream.off('data', onData);
+        stream.off('end', onEnd);
+        stream.off('error', onError);
+      };
+      const finish = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve(Buffer.concat(buffers, length));
+      };
+      const onData = (chunk: Buffer) => {
+        const remaining = maxBytes - length;
+        if (remaining <= 0) {
+          finish();
+          stream.destroy();
+          return;
+        }
+
+        const slice =
+          chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
+        buffers.push(slice);
+        length += slice.length;
+        if (length >= maxBytes) {
+          finish();
+          stream.destroy();
+        }
+      };
+      const onEnd = () => finish();
+      const onError = (error: Error) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        cleanup();
+        reject(error);
+      };
+
+      stream.on('data', onData);
+      stream.once('end', onEnd);
+      stream.once('error', onError);
+    });
+  });
+}
+
 export async function enumZipEntries(
   zipFn: string,
   callback: (

package/src/utils/zip-options.ts

@@ -0,0 +1,173 @@
+import path from 'path';
+import * as fs from 'fs';
+
+export type ZipEntryOptions = {
+  compress?: boolean;
+  compressionLevel?: number;
+};
+
+export const ZIP_ENTRY_SNIFF_BYTES = 64;
+
+const alreadyCompressedExtensions = new Set([
+  '.7z',
+  '.aab',
+  '.apk',
+  '.br',
+  '.bz2',
+  '.gif',
+  '.gz',
+  '.heic',
+  '.jpeg',
+  '.jpg',
+  '.lzma',
+  '.mp3',
+  '.mp4',
+  '.ogg',
+  '.png',
+  '.webm',
+  '.webp',
+  '.woff',
+  '.woff2',
+  '.xz',
+  '.zip',
+  '.zst',
+]);
+
+const HERMES_MAGIC = Buffer.from([
+  0xc6, 0x1f, 0xbc, 0x03, 0xc1, 0x03, 0x19, 0x1f,
+]);
+const HERMES_DELTA_MAGIC = Buffer.from([
+  0x39, 0xe0, 0x43, 0xfc, 0x3e, 0xfc, 0xe6, 0xe0,
+]);
+
+function startsWith(bytes: Buffer, signature: Buffer): boolean {
+  return (
+    bytes.length >= signature.length &&
+    bytes.subarray(0, signature.length).equals(signature)
+  );
+}
+
+function hasHermesBytecodeMagic(bytes: Buffer): boolean {
+  return (
+    startsWith(bytes, HERMES_MAGIC) || startsWith(bytes, HERMES_DELTA_MAGIC)
+  );
+}
+
+function hasAlreadyCompressedMagic(bytes: Buffer): boolean {
+  if (bytes.length < 2) {
+    return false;
+  }
+
+  if (startsWith(bytes, Buffer.from([0x89, 0x50, 0x4e, 0x47]))) {
+    return true;
+  }
+  if (startsWith(bytes, Buffer.from([0xff, 0xd8, 0xff]))) {
+    return true;
+  }
+  if (
+    startsWith(bytes, Buffer.from('GIF87a', 'ascii')) ||
+    startsWith(bytes, Buffer.from('GIF89a', 'ascii'))
+  ) {
+    return true;
+  }
+  if (
+    bytes.length >= 12 &&
+    bytes.subarray(0, 4).equals(Buffer.from('RIFF', 'ascii')) &&
+    bytes.subarray(8, 12).equals(Buffer.from('WEBP', 'ascii'))
+  ) {
+    return true;
+  }
+  if (
+    startsWith(bytes, Buffer.from([0x50, 0x4b, 0x03, 0x04])) ||
+    startsWith(bytes, Buffer.from([0x50, 0x4b, 0x05, 0x06])) ||
+    startsWith(bytes, Buffer.from([0x50, 0x4b, 0x07, 0x08]))
+  ) {
+    return true;
+  }
+  if (startsWith(bytes, Buffer.from([0x1f, 0x8b]))) {
+    return true;
+  }
+  if (startsWith(bytes, Buffer.from('BZh', 'ascii'))) {
+    return true;
+  }
+  if (startsWith(bytes, Buffer.from([0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00]))) {
+    return true;
+  }
+  if (startsWith(bytes, Buffer.from([0x37, 0x7a, 0xbc, 0xaf, 0x27, 0x1c]))) {
+    return true;
+  }
+  if (startsWith(bytes, Buffer.from([0x28, 0xb5, 0x2f, 0xfd]))) {
+    return true;
+  }
+  if (bytes.length >= 12 && bytes.subarray(4, 8).equals(Buffer.from('ftyp'))) {
+    return true;
+  }
+  if (startsWith(bytes, Buffer.from('OggS', 'ascii'))) {
+    return true;
+  }
+  if (startsWith(bytes, Buffer.from('ID3', 'ascii'))) {
+    return true;
+  }
+  if (
+    bytes[0] === 0xff &&
+    bytes.length >= 2 &&
+    (bytes[1] & 0xe0) === 0xe0
+  ) {
+    return true;
+  }
+  if (
+    startsWith(bytes, Buffer.from('wOFF', 'ascii')) ||
+    startsWith(bytes, Buffer.from('wOF2', 'ascii'))
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function readFilePrefix(filePath: string): Buffer {
+  const buffer = Buffer.alloc(ZIP_ENTRY_SNIFF_BYTES);
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    return buffer.subarray(0, bytesRead);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+export function zipOptionsForPatchEntry(): ZipEntryOptions {
+  return { compress: false };
+}
+
+export function zipOptionsForManifestEntry(): ZipEntryOptions {
+  return { compress: false };
+}
+
+export function zipOptionsForPayloadEntry(
+  fileName: string,
+  prefix?: Buffer,
+): ZipEntryOptions {
+  if (prefix && prefix.length > 0) {
+    if (hasHermesBytecodeMagic(prefix)) {
+      // Hermes bytecode is binary, but still benefits significantly from zip deflate.
+      return { compress: true, compressionLevel: 9 };
+    }
+    if (hasAlreadyCompressedMagic(prefix)) {
+      return { compress: false };
+    }
+  }
+
+  const extension = path.extname(fileName).toLowerCase();
+  if (alreadyCompressedExtensions.has(extension)) {
+    return { compress: false };
+  }
+  return { compress: true, compressionLevel: 9 };
+}
+
+export function zipOptionsForPayloadFile(
+  filePath: string,
+  entryName = filePath,
+): ZipEntryOptions {
+  return zipOptionsForPayloadEntry(entryName, readFilePrefix(filePath));
+}