react-native-update-cli 2.4.2 → 2.6.0

package/src/package.ts

@@ -1,17 +1,25 @@
-import { get, getAllPackages, post, uploadFile, doDelete } from './api';
-import { question, saveToLocal } from './utils';
-import { t } from './utils/i18n';
-
-import { getPlatform, getSelectedApp } from './app';
-
+import os from 'os';
+import path from 'path';
+import fs from 'fs-extra';
 import Table from 'tty-table';
+import { doDelete, getAllPackages, post, uploadFile } from './api';
+import { getPlatform, getSelectedApp } from './app';
 import type { Platform } from './types';
-import { getApkInfo, getAppInfo, getIpaInfo } from './utils';
+import {
+  getAabInfo,
+  getApkInfo,
+  getAppInfo,
+  getIpaInfo,
+  question,
+  saveToLocal,
+} from './utils';
+import { AabParser } from './utils/app-info-parser/aab';
 import { depVersions } from './utils/dep-versions';
 import { getCommitInfo } from './utils/git';
+import { t } from './utils/i18n';
 
 export async function listPackage(appId: string) {
-  const allPkgs = await getAllPackages(appId);
+  const allPkgs = (await getAllPackages(appId)) || [];
 
   const header = [
     { value: t('nativePackageId') },
@@ -49,7 +57,7 @@ export async function choosePackage(appId: string) {
 
   while (true) {
     const id = await question(t('enterNativePackageId'));
-    const app = list.find((v) => v.id.toString() === id);
+    const app = list?.find((v) => v.id.toString() === id);
     if (app) {
       return app;
     }
@@ -143,6 +151,48 @@ export const packageCommands = {
     saveToLocal(fn, `${appId}/package/${id}.apk`);
     console.log(t('apkUploadSuccess', { id, version: versionName, buildTime }));
   },
+  uploadAab: async ({
+    args,
+    options,
+  }: {
+    args: string[];
+    options: Record<string, any>;
+  }) => {
+    const source = args[0];
+    if (!source || !source.endsWith('.aab')) {
+      throw new Error(t('usageUploadAab'));
+    }
+
+    const output = path.join(
+      os.tmpdir(),
+      `${path.basename(source, path.extname(source))}-${Date.now()}.apk`,
+    );
+
+    const includeAllSplits =
+      options.includeAllSplits === true || options.includeAllSplits === 'true';
+    const splits = options.splits
+      ? String(options.splits)
+          .split(',')
+          .map((item) => item.trim())
+          .filter(Boolean)
+      : null;
+
+    const parser = new AabParser(source);
+    try {
+      await parser.extractApk(output, {
+        includeAllSplits,
+        splits,
+      });
+      await packageCommands.uploadApk({
+        args: [output],
+        options,
+      });
+    } finally {
+      if (await fs.pathExists(output)) {
+        await fs.remove(output);
+      }
+    }
+  },
   uploadApp: async ({
     args,
     options,
@@ -207,6 +257,49 @@ export const packageCommands = {
     }
     console.log(await getApkInfo(fn));
   },
+  parseAab: async ({ args }: { args: string[] }) => {
+    const fn = args[0];
+    if (!fn || !fn.endsWith('.aab')) {
+      throw new Error(t('usageParseAab'));
+    }
+    console.log(await getAabInfo(fn));
+  },
+  extractApk: async ({
+    args,
+    options,
+  }: {
+    args: string[];
+    options: Record<string, any>;
+  }) => {
+    const source = args[0];
+    if (!source || !source.endsWith('.aab')) {
+      throw new Error(t('usageExtractApk'));
+    }
+
+    const output =
+      options.output ||
+      path.join(
+        path.dirname(source),
+        `${path.basename(source, path.extname(source))}.apk`,
+      );
+
+    const includeAllSplits =
+      options.includeAllSplits === true || options.includeAllSplits === 'true';
+    const splits = options.splits
+      ? String(options.splits)
+          .split(',')
+          .map((item) => item.trim())
+          .filter(Boolean)
+      : null;
+
+    const parser = new AabParser(source);
+    await parser.extractApk(output, {
+      includeAllSplits,
+      splits,
+    });
+
+    console.log(t('apkExtracted', { output }));
+  },
   packages: async ({ options }: { options: { platform: Platform } }) => {
     const platform = await getPlatform(options.platform);
     const { appId } = await getSelectedApp(platform);
@@ -217,12 +310,17 @@ export const packageCommands = {
     options,
   }: {
     args: string[];
-    options: { appId?: string, packageId?: string, packageVersion?: string };
+    options: {
+      appId?: string;
+      packageId?: string;
+      packageVersion?: string;
+      platform?: Platform;
+    };
   }) => {
     let { appId, packageId, packageVersion } = options;
 
     if (!appId) {
-      const platform = await getPlatform();
+      const platform = await getPlatform(options.platform);
       appId = (await getSelectedApp(platform)).appId as string;
     }
 
@@ -232,7 +330,9 @@ export const packageCommands = {
       if (!allPkgs) {
         throw new Error(t('noPackagesFound', { appId }));
       }
-      const selectedPackage = allPkgs.find((pkg) => pkg.name === packageVersion);
+      const selectedPackage = allPkgs.find(
+        (pkg) => pkg.name === packageVersion,
+      );
       if (!selectedPackage) {
         throw new Error(t('packageNotFound', { packageVersion }));
       }

package/src/provider.ts

@@ -122,6 +122,9 @@ export class CLIProviderImpl implements CLIProvider {
         case 'apk':
           await packageCommands.uploadApk(context);
           break;
+        case 'aab':
+          await packageCommands.uploadAab(context);
+          break;
         case 'app':
           await packageCommands.uploadApp(context);
           break;

package/src/utils/app-info-parser/aab.ts

@@ -0,0 +1,240 @@
+import { spawn } from 'child_process';
+import os from 'os';
+import path from 'path';
+import fs from 'fs-extra';
+import { open as openZipFile } from 'yauzl';
+import { t } from '../i18n';
+import { ResourceFinder } from './resource-finder';
+import { mapInfoResource } from './utils';
+import { ManifestParser } from './xml-parser/manifest';
+import { Zip } from './zip';
+
+export class AabParser extends Zip {
+  file: string | File;
+
+  constructor(file: string | File) {
+    super(file);
+    this.file = file;
+  }
+
+  async extractApk(
+    outputPath: string,
+    {
+      includeAllSplits,
+      splits,
+    }: { includeAllSplits?: boolean; splits?: string[] | null },
+  ) {
+    const normalizedSplits = Array.isArray(splits)
+      ? splits.map((item) => item.trim()).filter(Boolean)
+      : [];
+    const modules = includeAllSplits
+      ? null
+      : Array.from(new Set(['base', ...normalizedSplits]));
+    const modulesArgs = modules ? [`--modules=${modules.join(',')}`] : [];
+
+    const runCommand = (
+      command: string,
+      args: string[],
+      options: { stdio?: 'inherit'; env?: NodeJS.ProcessEnv } = {},
+    ) =>
+      new Promise<void>((resolve, reject) => {
+        const inheritStdio = options.stdio === 'inherit';
+        const child = spawn(command, args, {
+          stdio: inheritStdio ? 'inherit' : ['ignore', 'pipe', 'pipe'],
+          env: options.env,
+        });
+        let stderr = '';
+        if (!inheritStdio) {
+          child.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+          });
+        }
+        child.on('error', reject);
+        child.on('close', (code) => {
+          if (code === 0) {
+            resolve();
+            return;
+          }
+          reject(
+            new Error(
+              stderr.trim() || `Command failed: ${command} (code ${code})`,
+            ),
+          );
+        });
+      });
+
+    // Create a temp file for the .apks output
+    const tempDir = os.tmpdir();
+    const tempApksPath = path.join(tempDir, `temp-${Date.now()}.apks`);
+
+    const needsNpxDownload = async () => {
+      try {
+        await runCommand('npx', [
+          '--no-install',
+          'node-bundletool',
+          '--version',
+        ]);
+        return false;
+      } catch {
+        return true;
+      }
+    };
+
+    try {
+      // 1. Build APKS (universal mode)
+      // We assume bundletool is in the path.
+      // User might need keystore to sign it properly but for simple extraction we stick to default debug key if possible or unsigned?
+      // actually bundletool build-apks signs with debug key by default if no keystore provided.
+
+      try {
+        await runCommand('bundletool', [
+          'build-apks',
+          '--mode=universal',
+          `--bundle=${this.file}`,
+          `--output=${tempApksPath}`,
+          '--overwrite',
+          ...modulesArgs,
+        ]);
+      } catch (e) {
+        // Fallback to npx node-bundletool if bundletool is not in PATH
+        // We use -y to avoid interactive prompt for installation
+        if (await needsNpxDownload()) {
+          console.log(t('aabBundletoolDownloadHint'));
+        }
+        await runCommand(
+          'npx',
+          [
+            '-y',
+            'node-bundletool',
+            'build-apks',
+            '--mode=universal',
+            `--bundle=${this.file}`,
+            `--output=${tempApksPath}`,
+            '--overwrite',
+            ...modulesArgs,
+          ],
+          {
+            stdio: 'inherit',
+            env: {
+              ...process.env,
+              npm_config_progress: 'true',
+            },
+          },
+        );
+      }
+
+      // 2. Extract universal.apk from the .apks (zip) file
+      await new Promise<void>((resolve, reject) => {
+        openZipFile(tempApksPath, { lazyEntries: true }, (err, zipfile) => {
+          if (err || !zipfile) {
+            reject(err || new Error(t('aabOpenApksFailed')));
+            return;
+          }
+
+          let found = false;
+          zipfile.readEntry();
+          zipfile.on('entry', (entry) => {
+            if (entry.fileName === 'universal.apk') {
+              found = true;
+              zipfile.openReadStream(entry, (err, readStream) => {
+                if (err || !readStream) {
+                  reject(err || new Error(t('aabReadUniversalApkFailed')));
+                  return;
+                }
+                const writeStream = fs.createWriteStream(outputPath);
+                readStream.pipe(writeStream);
+                writeStream.on('close', () => {
+                  zipfile.close();
+                  resolve();
+                });
+                writeStream.on('error', reject);
+              });
+            } else {
+              zipfile.readEntry();
+            }
+          });
+
+          zipfile.on('end', () => {
+            if (!found) reject(new Error(t('aabUniversalApkNotFound')));
+          });
+          zipfile.on('error', reject);
+        });
+      });
+    } finally {
+      // Cleanup
+      if (await fs.pathExists(tempApksPath)) {
+        await fs.remove(tempApksPath);
+      }
+    }
+  }
+
+  /**
+   * 解析 AAB 文件信息（类似 APK parser 的 parse 方法）
+   * 注意：AAB 中的 AndroidManifest.xml 在 base/manifest/AndroidManifest.xml
+   */
+  async parse() {
+    const manifestPath = 'base/manifest/AndroidManifest.xml';
+    const ResourceName = /^base\/resources\.arsc$/;
+
+    try {
+      const manifestBuffer = await this.getEntry(
+        new RegExp(`^${escapeRegExp(manifestPath)}$`),
+      );
+
+      if (!manifestBuffer) {
+        throw new Error(t('aabManifestNotFound'));
+      }
+
+      let apkInfo = this._parseManifest(manifestBuffer as Buffer);
+
+      try {
+        const resourceBuffer = await this.getEntry(ResourceName);
+        if (resourceBuffer) {
+          const resourceMap = this._parseResourceMap(resourceBuffer as Buffer);
+          apkInfo = mapInfoResource(apkInfo, resourceMap);
+        }
+      } catch (e: any) {
+        console.warn(t('aabParseResourcesWarning', { error: e?.message ?? e }));
+      }
+
+      return apkInfo;
+    } catch (error: any) {
+      throw new Error(t('aabParseFailed', { error: error.message ?? error }));
+    }
+  }
+  /**
+   * Parse manifest
+   * @param {Buffer} buffer // manifest file's buffer
+   */
+  private _parseManifest(buffer: Buffer) {
+    try {
+      const parser = new ManifestParser(buffer, {
+        ignore: [
+          'application.activity',
+          'application.service',
+          'application.receiver',
+          'application.provider',
+          'permission-group',
+        ],
+      });
+      return parser.parse();
+    } catch (e: any) {
+      throw new Error(t('aabParseManifestError', { error: e?.message ?? e }));
+    }
+  }
+
+  /**
+   * Parse resourceMap
+   * @param {Buffer} buffer // resourceMap file's buffer
+   */
+  private _parseResourceMap(buffer: Buffer) {
+    try {
+      return new ResourceFinder().processResourceTable(buffer);
+    } catch (e: any) {
+      throw new Error(t('aabParseResourcesError', { error: e?.message ?? e }));
+    }
+  }
+}
+
+const escapeRegExp = (value: string) =>
+  value.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&');

package/src/utils/app-info-parser/{apk.js → apk.ts}

@@ -1,54 +1,43 @@
-const Zip = require('./zip');
-const {
-  mapInfoResource,
-  findApkIconPath,
-  getBase64FromBuffer,
-} = require('./utils');
+import { ResourceFinder } from './resource-finder';
+import { findApkIconPath, getBase64FromBuffer, mapInfoResource } from './utils';
+import { ManifestParser } from './xml-parser/manifest';
+import { Zip } from './zip';
+
 const ManifestName = /^androidmanifest\.xml$/;
 const ResourceName = /^resources\.arsc$/;
 
-const ManifestXmlParser = require('./xml-parser/manifest');
-const ResourceFinder = require('./resource-finder');
-
-class ApkParser extends Zip {
-  /**
-   * parser for parsing .apk file
-   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
-   */
-  constructor(file) {
-    super(file);
-    if (!(this instanceof ApkParser)) {
-      return new ApkParser(file);
-    }
-  }
-  parse() {
+export class ApkParser extends Zip {
+  parse(): Promise<any> {
     return new Promise((resolve, reject) => {
       this.getEntries([ManifestName, ResourceName])
-        .then((buffers) => {
-          if (!buffers[ManifestName]) {
+        .then((buffers: any) => {
+          const manifestBuffer = buffers[ManifestName];
+          if (!manifestBuffer) {
             throw new Error("AndroidManifest.xml can't be found.");
           }
-          let apkInfo = this._parseManifest(buffers[ManifestName]);
-          let resourceMap;
+          let apkInfo: any;
+          let resourceMap: any;
+
+          apkInfo = this._parseManifest(manifestBuffer as Buffer);
+
           if (!buffers[ResourceName]) {
             resolve(apkInfo);
           } else {
-            // parse resourceMap
-            resourceMap = this._parseResourceMap(buffers[ResourceName]);
-            // update apkInfo with resourceMap
+            resourceMap = this._parseResourceMap(
+              buffers[ResourceName] as Buffer,
+            );
             apkInfo = mapInfoResource(apkInfo, resourceMap);
 
-            // find icon path and parse icon
             const iconPath = findApkIconPath(apkInfo);
             if (iconPath) {
               this.getEntry(iconPath)
-                .then((iconBuffer) => {
+                .then((iconBuffer: Buffer | null) => {
                   apkInfo.icon = iconBuffer
                     ? getBase64FromBuffer(iconBuffer)
                     : null;
                   resolve(apkInfo);
                 })
-                .catch((e) => {
+                .catch((e: any) => {
                   apkInfo.icon = null;
                   resolve(apkInfo);
                   console.warn('[Warning] failed to parse icon: ', e);
@@ -59,18 +48,19 @@ class ApkParser extends Zip {
             }
           }
         })
-        .catch((e) => {
+        .catch((e: any) => {
           reject(e);
         });
     });
   }
+
   /**
    * Parse manifest
    * @param {Buffer} buffer // manifest file's buffer
    */
-  _parseManifest(buffer) {
+  private _parseManifest(buffer: Buffer) {
     try {
-      const parser = new ManifestXmlParser(buffer, {
+      const parser = new ManifestParser(buffer, {
         ignore: [
           'application.activity',
           'application.service',
@@ -80,21 +70,20 @@ class ApkParser extends Zip {
         ],
       });
       return parser.parse();
-    } catch (e) {
-      throw new Error('Parse AndroidManifest.xml error: ', e);
+    } catch (e: any) {
+      throw new Error(`Parse AndroidManifest.xml error: ${e.message || e}`);
     }
   }
+
   /**
    * Parse resourceMap
    * @param {Buffer} buffer // resourceMap file's buffer
    */
-  _parseResourceMap(buffer) {
+  private _parseResourceMap(buffer: Buffer) {
     try {
       return new ResourceFinder().processResourceTable(buffer);
-    } catch (e) {
-      throw new Error('Parser resources.arsc error: ' + e);
+    } catch (e: any) {
+      throw new Error(`Parser resources.arsc error: ${e}`);
     }
   }
 }
-
-module.exports = ApkParser;

package/src/utils/app-info-parser/app.ts

@@ -0,0 +1,3 @@
+import { Zip } from './zip';
+
+export class AppParser extends Zip {}

package/src/utils/app-info-parser/index.ts

@@ -1,7 +1,8 @@
-const ApkParser = require('./apk');
-const IpaParser = require('./ipa');
-const AppParser = require('./app');
-const supportFileTypes = ['ipa', 'apk', 'app'];
+import { AabParser } from './aab';
+import { ApkParser } from './apk';
+import { AppParser } from './app';
+import { IpaParser } from './ipa';
+const supportFileTypes = ['ipa', 'apk', 'app', 'aab'];
 
 class AppInfoParser {
   file: string | File;
@@ -20,7 +21,7 @@ class AppInfoParser {
     const fileType = splits[splits.length - 1].toLowerCase();
     if (!supportFileTypes.includes(fileType)) {
       throw new Error(
-        'Unsupported file type, only support .ipa or .apk or .app file.',
+        'Unsupported file type, only support .ipa, .apk, .app, or .aab file.',
       );
     }
     this.file = file;
@@ -35,6 +36,9 @@ class AppInfoParser {
       case 'app':
         this.parser = new AppParser(this.file);
         break;
+      case 'aab':
+        this.parser = new AabParser(this.file);
+        break;
     }
   }
   parse() {

package/src/utils/app-info-parser/{ipa.js → ipa.ts}

@@ -2,49 +2,37 @@ const parsePlist = require('plist').parse;
 const parseBplist = require('bplist-parser').parseBuffer;
 const cgbiToPng = require('cgbi-to-png');
 
-const Zip = require('./zip');
-const { findIpaIconPath, getBase64FromBuffer, isBrowser } = require('./utils');
+import { findIpaIconPath, getBase64FromBuffer, isBrowser } from './utils';
+import { Zip } from './zip';
 
 const PlistName = /payload\/[^\/]+?.app\/info.plist$/i;
 const ProvisionName = /payload\/.+?\.app\/embedded.mobileprovision/;
 
-class IpaParser extends Zip {
-  /**
-   * parser for parsing .ipa file
-   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
-   */
-  constructor(file) {
-    super(file);
-    if (!(this instanceof IpaParser)) {
-      return new IpaParser(file);
-    }
-  }
-  parse() {
+export class IpaParser extends Zip {
+  parse(): Promise<any> {
     return new Promise((resolve, reject) => {
       this.getEntries([PlistName, ProvisionName])
-        .then((buffers) => {
-          if (!buffers[PlistName]) {
+        .then((buffers: any) => {
+          if (!buffers[PlistName as any]) {
             throw new Error("Info.plist can't be found.");
           }
-          const plistInfo = this._parsePlist(buffers[PlistName]);
-          // parse mobile provision
-          const provisionInfo = this._parseProvision(buffers[ProvisionName]);
+          const plistInfo = this._parsePlist(buffers[PlistName as any]);
+          const provisionInfo = this._parseProvision(
+            buffers[ProvisionName as any],
+          );
           plistInfo.mobileProvision = provisionInfo;
 
-          // find icon path and parse icon
           const iconRegex = new RegExp(
             findIpaIconPath(plistInfo).toLowerCase(),
           );
           this.getEntry(iconRegex)
-            .then((iconBuffer) => {
+            .then((iconBuffer: any) => {
               try {
-                // In general, the ipa file's icon has been specially processed, should be converted
                 plistInfo.icon = iconBuffer
                   ? getBase64FromBuffer(cgbiToPng.revert(iconBuffer))
                   : null;
               } catch (err) {
                 if (isBrowser()) {
-                  // Normal conversion in other cases
                   plistInfo.icon = iconBuffer
                     ? getBase64FromBuffer(
                         window.btoa(String.fromCharCode(...iconBuffer)),
@@ -57,11 +45,11 @@ class IpaParser extends Zip {
               }
               resolve(plistInfo);
             })
-            .catch((e) => {
+            .catch((e: any) => {
               reject(e);
             });
         })
-        .catch((e) => {
+        .catch((e: any) => {
           reject(e);
         });
     });
@@ -70,8 +58,8 @@ class IpaParser extends Zip {
    * Parse plist
    * @param {Buffer} buffer // plist file's buffer
    */
-  _parsePlist(buffer) {
-    let result;
+  private _parsePlist(buffer: Buffer) {
+    let result: any;
     const bufferType = buffer[0];
     if (bufferType === 60 || bufferType === '<' || bufferType === 239) {
       result = parsePlist(buffer.toString());
@@ -86,8 +74,8 @@ class IpaParser extends Zip {
    * parse provision
    * @param {Buffer} buffer // provision file's buffer
    */
-  _parseProvision(buffer) {
-    let info = {};
+  private _parseProvision(buffer: Buffer | undefined) {
+    let info: Record<string, any> = {};
     if (buffer) {
       let content = buffer.toString('utf-8');
       const firstIndex = content.indexOf('<?xml');
@@ -100,5 +88,3 @@ class IpaParser extends Zip {
     return info;
   }
 }
-
-module.exports = IpaParser;