react-native-update-cli 2.8.5 → 2.9.1

package/src/diff.ts

@@ -2,12 +2,29 @@ import path from 'path';
 import * as fs from 'fs-extra';
 import { npm, yarn } from 'global-dirs';
 import { ZipFile as YazlZipFile } from 'yazl';
+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';
 
 type Diff = (oldSource?: Buffer, newSource?: Buffer) => Buffer;
+type EntryMap = Record<string, { crc32: number; fileName: string }>;
+type CrcMap = Record<number, string>;
+type CopyMap = Record<string, string>;
+type PackagePathTransform = (v: string) => string | undefined;
+type DiffTarget =
+  | { kind: 'ppk' }
+  | {
+      kind: 'package';
+      originBundleName: string;
+      transformPackagePath?: PackagePathTransform;
+    };
+type DiffCommandConfig = {
+  diffFnName: string;
+  useHdiff: boolean;
+  target: DiffTarget;
+};
 
 export { enumZipEntries, readEntry };
 
@@ -25,26 +42,28 @@ const loadDiffModule = (pkgName: string): Diff | undefined => {
   return undefined;
 };
 
-let hdiff: Diff | undefined;
-hdiff = (loadDiffModule('node-hdiffpatch') as any)?.diff;
-let bsdiff: Diff | undefined;
-let diff: Diff;
-bsdiff = loadDiffModule('node-bsdiff');
+const hdiff = loadDiffModule('node-hdiffpatch');
+const bsdiff = loadDiffModule('node-bsdiff');
 
-function basename(fn: string) {
+function basename(fn: string): string | undefined {
   const m = /^(.+\/)[^\/]+\/?$/.exec(fn);
   return m?.[1];
 }
 
-async function diffFromPPK(origin: string, next: string, output: string) {
+async function diffFromPPK(
+  origin: string,
+  next: string,
+  output: string,
+  diffFn: Diff,
+) {
   fs.ensureDirSync(path.dirname(output));
 
-  const originEntries = {};
-  const originMap = {};
+  const originEntries: EntryMap = {};
+  const originMap: CrcMap = {};
 
   let originSource: Buffer | undefined;
 
-  await enumZipEntries(origin, (entry, zipFile) => {
+  await enumZipEntries(origin, async (entry, zipFile) => {
     originEntries[entry.fileName] = entry;
     if (!/\/$/.test(entry.fileName)) {
       // isFile
@@ -52,7 +71,7 @@ async function diffFromPPK(origin: string, next: string, output: string) {
 
       if (isPPKBundleFileName(entry.fileName)) {
         // This is source.
-        return readEntry(entry, zipFile).then((v) => (originSource = v));
+        originSource = await readEntry(entry, zipFile);
       }
     }
   });
@@ -61,26 +80,25 @@ async function diffFromPPK(origin: string, next: string, output: string) {
     throw new Error(t('bundleFileNotFound'));
   }
 
-  const copies = {};
+  const copies: CopyMap = {};
 
   const zipfile = new YazlZipFile();
 
-  const writePromise = new Promise((resolve, reject) => {
-    zipfile.outputStream.on('error', (err) => {
-      throw err;
-    });
+  const writePromise = new Promise<void>((resolve, reject) => {
+    zipfile.outputStream.on('error', reject);
     zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
       resolve(void 0);
     });
   });
 
-  const addedEntry = {};
+  const addedEntry: Record<string, true> = {};
 
   function addEntry(fn: string) {
     //console.log(fn);
     if (!fn || addedEntry[fn]) {
       return;
     }
+    addedEntry[fn] = true;
     const base = basename(fn);
     if (base) {
       addEntry(base);
@@ -88,9 +106,9 @@ async function diffFromPPK(origin: string, next: string, output: string) {
     zipfile.addEmptyDirectory(fn);
   }
 
-  const newEntries = {};
+  const newEntries: EntryMap = {};
 
-  await enumZipEntries(next, (entry, nextZipfile) => {
+  await enumZipEntries(next, async (entry, nextZipfile) => {
     newEntries[entry.fileName] = entry;
 
     if (/\/$/.test(entry.fileName)) {
@@ -100,14 +118,13 @@ async function diffFromPPK(origin: string, next: string, output: string) {
       }
     } else if (isPPKBundleFileName(entry.fileName)) {
       //console.log('Found bundle');
-      return readEntry(entry, nextZipfile).then((newSource) => {
-        //console.log('Begin diff');
-        zipfile.addBuffer(
-          diff(originSource, newSource),
-          `${entry.fileName}.patch`,
-        );
-        //console.log('End diff');
-      });
+      const newSource = await readEntry(entry, nextZipfile);
+      //console.log('Begin diff');
+      zipfile.addBuffer(
+        diffFn(originSource, newSource),
+        `${entry.fileName}.patch`,
+      );
+      //console.log('End diff');
     } else {
       // If same file.
       const originEntry = originEntries[entry.fileName];
@@ -117,23 +134,32 @@ async function diffFromPPK(origin: string, next: string, output: string) {
       }
 
       // If moved from other place
-      if (originMap[entry.crc32]) {
+      const movedFrom = originMap[entry.crc32];
+      if (movedFrom) {
         const base = basename(entry.fileName);
-        if (!originEntries[base]) {
+        if (base && !originEntries[base]) {
           addEntry(base);
         }
-        copies[entry.fileName] = originMap[entry.crc32];
+        copies[entry.fileName] = movedFrom;
         return;
       }
 
       // New file.
-      addEntry(basename(entry.fileName));
+      const basePath = basename(entry.fileName);
+      if (basePath) {
+        addEntry(basePath);
+      }
 
-      return new Promise((resolve, reject) => {
+      await new Promise<void>((resolve, reject) => {
         nextZipfile.openReadStream(entry, (err, readStream) => {
           if (err) {
             return reject(err);
           }
+          if (!readStream) {
+            return reject(
+              new Error(`Unable to read zip entry: ${entry.fileName}`),
+            );
+          }
           zipfile.addReadStream(readStream, entry.fileName);
           readStream.on('end', () => {
             //console.log('add finished');
@@ -144,7 +170,7 @@ async function diffFromPPK(origin: string, next: string, output: string) {
     }
   });
 
-  const deletes = {};
+  const deletes: Record<string, 1> = {};
 
   for (const k in originEntries) {
     if (!newEntries[k]) {
@@ -166,17 +192,18 @@ async function diffFromPackage(
   origin: string,
   next: string,
   output: string,
+  diffFn: Diff,
   originBundleName: string,
-  transformPackagePath = (v: string) => v,
+  transformPackagePath: (v: string) => string | undefined = (v: string) => v,
 ) {
   fs.ensureDirSync(path.dirname(output));
 
-  const originEntries = {};
-  const originMap = {};
+  const originEntries: Record<string, number> = {};
+  const originMap: CrcMap = {};
 
   let originSource: Buffer | undefined;
 
-  await enumZipEntries(origin, (entry, zipFile) => {
+  await enumZipEntries(origin, async (entry, zipFile) => {
     if (!/\/$/.test(entry.fileName)) {
       const fn = transformPackagePath(entry.fileName);
       if (!fn) {
@@ -190,7 +217,7 @@ async function diffFromPackage(
 
       if (fn === originBundleName) {
         // This is source.
-        return readEntry(entry, zipFile).then((v) => (originSource = v));
+        originSource = await readEntry(entry, zipFile);
       }
     }
   });
@@ -199,33 +226,30 @@ async function diffFromPackage(
     throw new Error(t('bundleFileNotFound'));
   }
 
-  const copies = {};
+  const copies: CopyMap = {};
 
   const zipfile = new YazlZipFile();
 
-  const writePromise = new Promise((resolve, reject) => {
-    zipfile.outputStream.on('error', (err) => {
-      throw err;
-    });
+  const writePromise = new Promise<void>((resolve, reject) => {
+    zipfile.outputStream.on('error', reject);
     zipfile.outputStream.pipe(fs.createWriteStream(output)).on('close', () => {
       resolve(void 0);
     });
   });
 
-  await enumZipEntries(next, (entry, nextZipfile) => {
+  await enumZipEntries(next, async (entry, nextZipfile) => {
     if (/\/$/.test(entry.fileName)) {
       // Directory
       zipfile.addEmptyDirectory(entry.fileName);
     } else if (isPPKBundleFileName(entry.fileName)) {
       //console.log('Found bundle');
-      return readEntry(entry, nextZipfile).then((newSource) => {
-        //console.log('Begin diff');
-        zipfile.addBuffer(
-          diff(originSource, newSource),
-          `${entry.fileName}.patch`,
-        );
-        //console.log('End diff');
-      });
+      const newSource = await readEntry(entry, nextZipfile);
+      //console.log('Begin diff');
+      zipfile.addBuffer(
+        diffFn(originSource, newSource),
+        `${entry.fileName}.patch`,
+      );
+      //console.log('End diff');
     } else {
       // If same file.
       if (originEntries[entry.fileName] === entry.crc32) {
@@ -233,16 +257,22 @@ async function diffFromPackage(
         return;
       }
       // If moved from other place
-      if (originMap[entry.crc32]) {
-        copies[entry.fileName] = originMap[entry.crc32];
+      const movedFrom = originMap[entry.crc32];
+      if (movedFrom) {
+        copies[entry.fileName] = movedFrom;
         return;
       }
 
-      return new Promise((resolve, reject) => {
+      await new Promise<void>((resolve, reject) => {
         nextZipfile.openReadStream(entry, (err, readStream) => {
           if (err) {
             return reject(err);
           }
+          if (!readStream) {
+            return reject(
+              new Error(`Unable to read zip entry: ${entry.fileName}`),
+            );
+          }
           zipfile.addReadStream(readStream, entry.fileName);
           readStream.on('end', () => {
             //console.log('add finished');
@@ -258,147 +288,151 @@ async function diffFromPackage(
   await writePromise;
 }
 
-function diffArgsCheck(args: string[], options: any, diffFn: string) {
-  const [origin, next] = args;
+type DiffCommandOptions = {
+  customDiff?: Diff;
+  [key: string]: any;
+};
 
-  if (!origin || !next) {
-    console.error(t('usageDiff', { command: diffFn }));
-    process.exit(1);
+function resolveDiffImplementation(
+  useHdiff: boolean,
+  options: DiffCommandOptions,
+): Diff {
+  if (options.customDiff) {
+    return options.customDiff;
   }
-  if (options?.customDiff) {
-    diff = options.customDiff;
-  } else {
-    if (diffFn.startsWith('hdiff')) {
-      if (!hdiff) {
-        console.error(t('nodeHdiffpatchRequired', { scriptName }));
-        process.exit(1);
-      }
-      diff = hdiff;
-    } else {
-      if (!bsdiff) {
-        console.error(t('nodeBsdiffRequired', { scriptName }));
-        process.exit(1);
-      }
-      diff = bsdiff;
+
+  if (useHdiff) {
+    if (!hdiff) {
+      throw new Error(t('nodeHdiffpatchRequired', { scriptName }));
     }
+    return hdiff;
   }
 
+  if (!bsdiff) {
+    throw new Error(t('nodeBsdiffRequired', { scriptName }));
+  }
+  return bsdiff;
+}
+
+function diffArgsCheck(
+  args: string[],
+  options: DiffCommandOptions,
+  diffFnName: string,
+  useHdiff: boolean,
+) {
+  const [origin, next] = args;
+
+  if (!origin || !next) {
+    throw new Error(t('usageDiff', { command: diffFnName }));
+  }
+
+  const diffFn = resolveDiffImplementation(useHdiff, options);
   const { output } = translateOptions({
     ...options,
     tempDir,
   });
+  if (typeof output !== 'string') {
+    throw new Error('Output path is required.');
+  }
 
   return {
     origin,
     next,
+    diffFn,
     realOutput: output.replace(/\$\{time\}/g, `${Date.now()}`),
   };
 }
 
-export const diffCommands = {
-  async diff({ args, options }) {
-    const { origin, next, realOutput } = diffArgsCheck(args, options, 'diff');
-
-    await diffFromPPK(origin, next, realOutput);
-    console.log(t('diffPackageGenerated', { output: realOutput }));
-  },
-
-  async hdiff({ args, options }) {
-    const { origin, next, realOutput } = diffArgsCheck(args, options, 'hdiff');
-
-    await diffFromPPK(origin, next, realOutput);
-    console.log(t('diffPackageGenerated', { output: realOutput }));
-  },
-
-  async diffFromApk({ args, options }) {
-    const { origin, next, realOutput } = diffArgsCheck(
-      args,
-      options,
-      'diffFromApk',
-    );
-
-    await diffFromPackage(
-      origin,
-      next,
-      realOutput,
-      'assets/index.android.bundle',
-    );
-    console.log(t('diffPackageGenerated', { output: realOutput }));
-  },
-
-  async hdiffFromApk({ args, options }) {
-    const { origin, next, realOutput } = diffArgsCheck(
-      args,
-      options,
-      'hdiffFromApk',
-    );
-
-    await diffFromPackage(
-      origin,
-      next,
-      realOutput,
-      'assets/index.android.bundle',
-    );
-    console.log(t('diffPackageGenerated', { output: realOutput }));
-  },
-
-  async diffFromApp({ args, options }) {
-    const { origin, next, realOutput } = diffArgsCheck(
-      args,
-      options,
-      'diffFromApp',
-    );
-    await diffFromPackage(
-      origin,
-      next,
-      realOutput,
-      'resources/rawfile/bundle.harmony.js',
-    );
-    console.log(t('diffPackageGenerated', { output: realOutput }));
-  },
-
-  async hdiffFromApp({ args, options }) {
-    const { origin, next, realOutput } = diffArgsCheck(
-      args,
-      options,
-      'hdiffFromApp',
-    );
-    await diffFromPackage(
-      origin,
-      next,
-      realOutput,
-      'resources/rawfile/bundle.harmony.js',
-    );
-    console.log(t('diffPackageGenerated', { output: realOutput }));
-  },
+const transformIpaPackagePath: PackagePathTransform = (v) => {
+  const match = /^Payload\/[^/]+\/(.+)$/.exec(v);
+  return match?.[1];
+};
 
-  async diffFromIpa({ args, options }) {
-    const { origin, next, realOutput } = diffArgsCheck(
+const createDiffCommand =
+  ({ diffFnName, useHdiff, target }: DiffCommandConfig) =>
+  async ({ args, options }: CommandContext) => {
+    const { origin, next, realOutput, diffFn } = diffArgsCheck(
       args,
-      options,
-      'diffFromIpa',
+      options as DiffCommandOptions,
+      diffFnName,
+      useHdiff,
     );
 
-    await diffFromPackage(origin, next, realOutput, 'main.jsbundle', (v) => {
-      const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
-      return m?.[1];
-    });
+    if (target.kind === 'ppk') {
+      await diffFromPPK(origin, next, realOutput, diffFn);
+    } else {
+      await diffFromPackage(
+        origin,
+        next,
+        realOutput,
+        diffFn,
+        target.originBundleName,
+        target.transformPackagePath,
+      );
+    }
 
     console.log(t('diffPackageGenerated', { output: realOutput }));
-  },
-
-  async hdiffFromIpa({ args, options }) {
-    const { origin, next, realOutput } = diffArgsCheck(
-      args,
-      options,
-      'hdiffFromIpa',
-    );
-
-    await diffFromPackage(origin, next, realOutput, 'main.jsbundle', (v) => {
-      const m = /^Payload\/[^/]+\/(.+)$/.exec(v);
-      return m?.[1];
-    });
+  };
 
-    console.log(t('diffPackageGenerated', { output: realOutput }));
-  },
+export const diffCommands = {
+  diff: createDiffCommand({
+    diffFnName: 'diff',
+    useHdiff: false,
+    target: { kind: 'ppk' },
+  }),
+  hdiff: createDiffCommand({
+    diffFnName: 'hdiff',
+    useHdiff: true,
+    target: { kind: 'ppk' },
+  }),
+  diffFromApk: createDiffCommand({
+    diffFnName: 'diffFromApk',
+    useHdiff: false,
+    target: {
+      kind: 'package',
+      originBundleName: 'assets/index.android.bundle',
+    },
+  }),
+  hdiffFromApk: createDiffCommand({
+    diffFnName: 'hdiffFromApk',
+    useHdiff: true,
+    target: {
+      kind: 'package',
+      originBundleName: 'assets/index.android.bundle',
+    },
+  }),
+  diffFromApp: createDiffCommand({
+    diffFnName: 'diffFromApp',
+    useHdiff: false,
+    target: {
+      kind: 'package',
+      originBundleName: 'resources/rawfile/bundle.harmony.js',
+    },
+  }),
+  hdiffFromApp: createDiffCommand({
+    diffFnName: 'hdiffFromApp',
+    useHdiff: true,
+    target: {
+      kind: 'package',
+      originBundleName: 'resources/rawfile/bundle.harmony.js',
+    },
+  }),
+  diffFromIpa: createDiffCommand({
+    diffFnName: 'diffFromIpa',
+    useHdiff: false,
+    target: {
+      kind: 'package',
+      originBundleName: 'main.jsbundle',
+      transformPackagePath: transformIpaPackagePath,
+    },
+  }),
+  hdiffFromIpa: createDiffCommand({
+    diffFnName: 'hdiffFromIpa',
+    useHdiff: true,
+    target: {
+      kind: 'package',
+      originBundleName: 'main.jsbundle',
+      transformPackagePath: transformIpaPackagePath,
+    },
+  }),
 };

package/src/index.ts

@@ -14,6 +14,14 @@ import { printVersionCommand } from './utils';
 import { t } from './utils/i18n';
 import { versionCommands } from './versions';
 
+type LegacyCommandHandler = (argv: any) => Promise<unknown> | unknown;
+
+interface CliArgv {
+  command: string;
+  args: string[];
+  options: Record<string, any>;
+}
+
 function registerBuiltinModules() {
   for (const module of builtinModules) {
     try {
@@ -28,24 +36,13 @@ function printUsage() {
   console.log('React Native Update CLI');
   console.log('');
   console.log('Traditional commands:');
-
-  const legacyCommands = {
-    ...userCommands,
-    ...bundleCommands,
-    ...diffCommands,
-    ...appCommands,
-    ...packageCommands,
-    ...versionCommands,
-    ...installCommands,
-  };
-
-  for (const [name, handler] of Object.entries(legacyCommands)) {
+  for (const name of Object.keys(legacyCommands)) {
     console.log(`  ${name}: Legacy command`);
   }
 
   console.log('');
   console.log('Modular commands:');
-  const commands = moduleManager.getRegisteredCommands();
+  const commands = moduleManager.listCommands();
   for (const command of commands) {
     console.log(
       `  ${command.name}: ${command.description || 'No description'}`,
@@ -54,7 +51,7 @@ function printUsage() {
 
   console.log('');
   console.log('Available workflows:');
-  const workflows = moduleManager.getRegisteredWorkflows();
+  const workflows = moduleManager.listWorkflows();
   for (const workflow of workflows) {
     console.log(
       `  ${workflow.name}: ${workflow.description || 'No description'}`,
@@ -74,7 +71,7 @@ function printUsage() {
   process.exit(1);
 }
 
-const legacyCommands = {
+const legacyCommands: Record<string, LegacyCommandHandler> = {
   ...userCommands,
   ...bundleCommands,
   ...diffCommands,
@@ -94,7 +91,7 @@ async function run() {
   // Register builtin modules for modular functionality
   registerBuiltinModules();
 
-  const argv = require('cli-arguments').parse(require('../cli.json'));
+  const argv: CliArgv = require('cli-arguments').parse(require('../cli.json'));
   global.NO_INTERACTIVE = argv.options['no-interactive'];
   global.USE_ACC_OSS = argv.options.acc;
 
@@ -127,7 +124,8 @@ async function run() {
     }
     // Try legacy commands first for backward compatibility
     else if (legacyCommands[argv.command]) {
-      await legacyCommands[argv.command](argv);
+      const legacyHandler = legacyCommands[argv.command];
+      await legacyHandler(argv);
     }
     // Fall back to modular commands
     else {

package/src/module-manager.ts

@@ -2,7 +2,9 @@ import { CLIProviderImpl } from './provider';
 import type {
   CLIModule,
   CLIProvider,
+  CommandContext,
   CommandDefinition,
+  CommandResult,
   CustomWorkflow,
 } from './types';
 
@@ -85,19 +87,10 @@ export class ModuleManager {
     this.provider.registerWorkflow(workflow);
   }
 
-  getRegisteredCommands(): CommandDefinition[] {
-    return Array.from(this.commands.values());
-  }
-
-  getRegisteredWorkflows(): CustomWorkflow[] {
-    return Array.from(this.workflows.values());
-  }
-
-  getRegisteredModules(): CLIModule[] {
-    return Array.from(this.modules.values());
-  }
-
-  async executeCommand(commandName: string, context: any): Promise<any> {
+  async executeCommand(
+    commandName: string,
+    context: CommandContext,
+  ): Promise<CommandResult> {
     const command = this.commands.get(commandName);
     if (!command) {
       throw new Error(`Command '${commandName}' not found`);
@@ -106,7 +99,10 @@ export class ModuleManager {
     return await command.handler(context);
   }
 
-  async executeWorkflow(workflowName: string, context: any): Promise<any> {
+  async executeWorkflow(
+    workflowName: string,
+    context: CommandContext,
+  ): Promise<CommandResult> {
     return await this.provider.executeWorkflow(workflowName, context);
   }
 
@@ -114,7 +110,7 @@ export class ModuleManager {
     return this.provider;
   }
 
-  listCommands(): any[] {
+  listCommands(): CommandDefinition[] {
     return Array.from(this.commands.values());
   }
 
@@ -122,6 +118,10 @@ export class ModuleManager {
     return Array.from(this.workflows.values());
   }
 
+  listModules(): CLIModule[] {
+    return Array.from(this.modules.values());
+  }
+
   listAll(): void {
     console.log('\n=== Registered Commands ===');
     for (const command of this.commands.values()) {