react-native-update-cli 2.4.1 → 2.5.0

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

@@ -0,0 +1,326 @@
+const Zip = require('./zip');
+const yazl = require('yazl');
+const fs = require('fs-extra');
+const path = require('path');
+const { open: openZipFile } = require('yauzl');
+const os = require('os');
+
+class AabParser extends Zip {
+  /**
+   * parser for parsing .aab 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 AabParser)) {
+      return new AabParser(file);
+    }
+  }
+
+  /**
+   * 从 AAB 提取通用 APK
+   * 这个方法会合并 base/ 和所有 split/ 目录的内容
+   *
+   * @param {String} outputPath - 输出 APK 文件路径
+   * @param {Object} options - 选项
+   * @param {Boolean} options.includeAllSplits - 是否包含所有 split APK（默认 false，只提取 base）
+   * @param {Array<String>} options.splits - 指定要包含的 split APK 名称（如果指定，则只包含这些）
+   * @returns {Promise<String>} 返回输出文件路径
+   */
+  async extractApk(outputPath, options = {}) {
+    const { includeAllSplits = false, splits = null } = options;
+
+    return new Promise((resolve, reject) => {
+      if (typeof this.file !== 'string') {
+        return reject(
+          new Error('AAB file path must be a string in Node.js environment'),
+        );
+      }
+
+      openZipFile(this.file, { lazyEntries: true }, async (err, zipfile) => {
+        if (err) {
+          return reject(err);
+        }
+
+        try {
+          // 1. 收集所有条目及其数据
+          const baseEntries = [];
+          const splitEntries = [];
+          const metaInfEntries = [];
+          let pendingReads = 0;
+          let hasError = false;
+
+          const processEntry = (entry, fileName) => {
+            return new Promise((resolve, reject) => {
+              zipfile.openReadStream(entry, (err, readStream) => {
+                if (err) {
+                  return reject(err);
+                }
+
+                const chunks = [];
+                readStream.on('data', (chunk) => chunks.push(chunk));
+                readStream.on('end', () => {
+                  const buffer = Buffer.concat(chunks);
+                  resolve(buffer);
+                });
+                readStream.on('error', reject);
+              });
+            });
+          };
+
+          zipfile.on('entry', async (entry) => {
+            const fileName = entry.fileName;
+
+            // 跳过目录
+            if (fileName.endsWith('/')) {
+              zipfile.readEntry();
+              return;
+            }
+
+            pendingReads++;
+            try {
+              const buffer = await processEntry(entry, fileName);
+
+              if (fileName.startsWith('base/')) {
+                // 将 base/manifest/AndroidManifest.xml 转换为 androidmanifest.xml（APK 中通常是小写）
+                // 将 base/resources.arsc 转换为 resources.arsc
+                let apkPath = fileName.replace(/^base\//, '');
+                if (apkPath === 'manifest/AndroidManifest.xml') {
+                  apkPath = 'androidmanifest.xml';
+                }
+
+                baseEntries.push({
+                  buffer,
+                  zipPath: fileName,
+                  apkPath,
+                });
+              } else if (fileName.startsWith('split/')) {
+                splitEntries.push({
+                  buffer,
+                  zipPath: fileName,
+                });
+              } else if (fileName.startsWith('META-INF/')) {
+                metaInfEntries.push({
+                  buffer,
+                  zipPath: fileName,
+                  apkPath: fileName,
+                });
+              }
+              // BundleConfig.pb 和其他文件不需要包含在 APK 中
+
+              pendingReads--;
+              zipfile.readEntry();
+            } catch (error) {
+              pendingReads--;
+              if (!hasError) {
+                hasError = true;
+                reject(error);
+              }
+              zipfile.readEntry();
+            }
+          });
+
+          zipfile.on('end', async () => {
+            // 等待所有读取完成
+            while (pendingReads > 0) {
+              await new Promise((resolve) => setTimeout(resolve, 10));
+            }
+
+            if (hasError) {
+              return;
+            }
+
+            try {
+              // 2. 创建新的 APK 文件
+              const zipFile = new yazl.ZipFile();
+
+              // 3. 添加 base 目录的所有文件
+              for (const { buffer, apkPath } of baseEntries) {
+                zipFile.addBuffer(buffer, apkPath);
+              }
+
+              // 4. 添加 split APK 的内容（如果需要）
+              if (includeAllSplits || splits) {
+                const splitsToInclude = splits
+                  ? splitEntries.filter((se) =>
+                      splits.some((s) => se.zipPath.includes(s)),
+                    )
+                  : splitEntries;
+
+                await this.mergeSplitApksFromBuffers(zipFile, splitsToInclude);
+              }
+
+              // 5. 添加 META-INF（签名信息，虽然可能无效，但保留结构）
+              for (const { buffer, apkPath } of metaInfEntries) {
+                zipFile.addBuffer(buffer, apkPath);
+              }
+
+              // 6. 写入文件
+              zipFile.outputStream
+                .pipe(fs.createWriteStream(outputPath))
+                .on('close', () => {
+                  resolve(outputPath);
+                })
+                .on('error', (err) => {
+                  reject(err);
+                });
+
+              zipFile.end();
+            } catch (error) {
+              reject(error);
+            }
+          });
+
+          zipfile.on('error', reject);
+          zipfile.readEntry();
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+  }
+
+  /**
+   * 合并 split APK 的内容（从已读取的 buffer）
+   */
+  async mergeSplitApksFromBuffers(zipFile, splitEntries) {
+    for (const { buffer: splitBuffer } of splitEntries) {
+      if (splitBuffer) {
+        // 创建一个临时的 ZIP 文件来读取 split APK
+        const tempSplitPath = path.join(
+          os.tmpdir(),
+          `split_${Date.now()}_${Math.random().toString(36).substr(2, 9)}.apk`,
+        );
+
+        try {
+          await fs.writeFile(tempSplitPath, splitBuffer);
+
+          await new Promise((resolve, reject) => {
+            openZipFile(
+              tempSplitPath,
+              { lazyEntries: true },
+              async (err, splitZipfile) => {
+                if (err) {
+                  return reject(err);
+                }
+
+                splitZipfile.on('entry', (splitEntry) => {
+                  // 跳过 META-INF，因为签名信息不需要合并
+                  if (splitEntry.fileName.startsWith('META-INF/')) {
+                    splitZipfile.readEntry();
+                    return;
+                  }
+
+                  splitZipfile.openReadStream(splitEntry, (err, readStream) => {
+                    if (err) {
+                      splitZipfile.readEntry();
+                      return;
+                    }
+
+                    const chunks = [];
+                    readStream.on('data', (chunk) => chunks.push(chunk));
+                    readStream.on('end', () => {
+                      const buffer = Buffer.concat(chunks);
+                      // 注意：如果文件已存在（在 base 中），split 中的会覆盖 base 中的
+                      zipFile.addBuffer(buffer, splitEntry.fileName);
+                      splitZipfile.readEntry();
+                    });
+                    readStream.on('error', () => {
+                      splitZipfile.readEntry();
+                    });
+                  });
+                });
+
+                splitZipfile.on('end', resolve);
+                splitZipfile.on('error', reject);
+                splitZipfile.readEntry();
+              },
+            );
+          });
+        } finally {
+          // 清理临时文件
+          await fs.remove(tempSplitPath).catch(() => {});
+        }
+      }
+    }
+  }
+
+  /**
+   * 解析 AAB 文件信息（类似 APK parser 的 parse 方法）
+   * 注意：AAB 中的 AndroidManifest.xml 在 base/manifest/AndroidManifest.xml
+   */
+  async parse() {
+    // 尝试从 base/manifest/AndroidManifest.xml 读取 manifest
+    // 但 AAB 中的 manifest 可能是二进制格式，需要特殊处理
+    const manifestPath = 'base/manifest/AndroidManifest.xml';
+    const ResourceName = /^base\/resources\.arsc$/;
+
+    try {
+      const manifestBuffer = await this.getEntry(
+        new RegExp(`^${manifestPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`),
+      );
+
+      if (!manifestBuffer) {
+        throw new Error(
+          "AndroidManifest.xml can't be found in AAB base/manifest/",
+        );
+      }
+
+      let apkInfo = this._parseManifest(manifestBuffer);
+
+      // 尝试解析 resources.arsc
+      try {
+        const resourceBuffer = await this.getEntry(ResourceName);
+        if (resourceBuffer) {
+          const resourceMap = this._parseResourceMap(resourceBuffer);
+          const { mapInfoResource } = require('./utils');
+          apkInfo = mapInfoResource(apkInfo, resourceMap);
+        }
+      } catch (e) {
+        // resources.arsc 解析失败不影响基本信息
+        console.warn('[Warning] Failed to parse resources.arsc:', e.message);
+      }
+
+      return apkInfo;
+    } catch (error) {
+      throw new Error(`Failed to parse AAB: ${error.message}`);
+    }
+  }
+
+  /**
+   * Parse manifest
+   * @param {Buffer} buffer // manifest file's buffer
+   */
+  _parseManifest(buffer) {
+    try {
+      const ManifestXmlParser = require('./xml-parser/manifest');
+      const parser = new ManifestXmlParser(buffer, {
+        ignore: [
+          'application.activity',
+          'application.service',
+          'application.receiver',
+          'application.provider',
+          'permission-group',
+        ],
+      });
+      return parser.parse();
+    } catch (e) {
+      throw new Error('Parse AndroidManifest.xml error: ' + e.message);
+    }
+  }
+
+  /**
+   * Parse resourceMap
+   * @param {Buffer} buffer // resourceMap file's buffer
+   */
+  _parseResourceMap(buffer) {
+    try {
+      const ResourceFinder = require('./resource-finder');
+      return new ResourceFinder().processResourceTable(buffer);
+    } catch (e) {
+      throw new Error('Parser resources.arsc error: ' + e.message);
+    }
+  }
+}
+
+module.exports = AabParser;

package/src/utils/app-info-parser/apk.js

@@ -81,7 +81,7 @@ class ApkParser extends Zip {
       });
       return parser.parse();
     } catch (e) {
-      throw new Error('Parse AndroidManifest.xml error: ', e);
+      throw new Error('Parse AndroidManifest.xml error: ' + (e.message || e));
     }
   }
   /**

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'];
+const AabParser = require('./aab');
+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/index.ts

@@ -149,6 +149,160 @@ export async function getIpaInfo(fn: string) {
   return { versionName, buildTime, ...appCredential };
 }
 
+export async function getAabInfo(fn: string) {
+  const protobuf = require('protobufjs');
+  const root = await protobuf.load(
+    path.join(__dirname, '../../proto/Resources.proto'),
+  );
+  const XmlNode = root.lookupType('aapt.pb.XmlNode');
+
+  const buffer = await readZipEntry(fn, 'base/manifest/AndroidManifest.xml');
+
+  const message = XmlNode.decode(buffer);
+  const object = XmlNode.toObject(message, {
+    enums: String,
+    longs: String,
+    bytes: String,
+    defaults: true,
+    arrays: true,
+  });
+
+  const manifestElement = object.element;
+  if (manifestElement.name !== 'manifest') {
+    throw new Error('Invalid manifest');
+  }
+
+  let versionName = '';
+  for (const attr of manifestElement.attribute) {
+    if (attr.name === 'versionName') {
+      versionName = attr.value;
+    }
+  }
+
+  let buildTime = 0;
+  const appCredential = {};
+
+  // Find application node
+  const applicationNode = manifestElement.child.find(
+    (c: any) => c.element && c.element.name === 'application',
+  );
+  if (applicationNode) {
+    const metaDataNodes = applicationNode.element.child.filter(
+      (c: any) => c.element && c.element.name === 'meta-data',
+    );
+    for (const meta of metaDataNodes) {
+      let name = '';
+      let value = '';
+      let resourceId = 0;
+
+      for (const attr of meta.element.attribute) {
+        if (attr.name === 'name') {
+          name = attr.value;
+        }
+        if (attr.name === 'value') {
+          value = attr.value;
+          if (attr.compiledItem?.ref?.id) {
+            resourceId = attr.compiledItem.ref.id;
+          } else if (attr.compiledItem?.prim?.intDecimalValue) {
+            value = attr.compiledItem.prim.intDecimalValue.toString();
+          }
+        }
+      }
+
+      if (name === 'pushy_build_time') {
+        if (resourceId > 0) {
+          const resolvedValue = await resolveResource(fn, resourceId, root);
+          if (resolvedValue) {
+            value = resolvedValue;
+          }
+        }
+        buildTime = Number(value);
+      }
+    }
+  }
+
+  if (buildTime === 0) {
+    throw new Error(t('buildTimeNotFound'));
+  }
+
+  return { versionName, buildTime, ...appCredential };
+}
+
+async function readZipEntry(fn: string, entryName: string): Promise<Buffer> {
+  const yauzl = require('yauzl');
+  return new Promise((resolve, reject) => {
+    yauzl.open(fn, { lazyEntries: true }, (err: any, zipfile: any) => {
+      if (err) return reject(err);
+      let found = false;
+      zipfile.readEntry();
+      zipfile.on('entry', (entry: any) => {
+        if (entry.fileName === entryName) {
+          found = true;
+          zipfile.openReadStream(entry, (err: any, readStream: any) => {
+            if (err) return reject(err);
+            const chunks: any[] = [];
+            readStream.on('data', (chunk: any) => chunks.push(chunk));
+            readStream.on('end', () => resolve(Buffer.concat(chunks)));
+            readStream.on('error', reject);
+          });
+        } else {
+          zipfile.readEntry();
+        }
+      });
+      zipfile.on('end', () => {
+        if (!found) reject(new Error(`${entryName} not found in AAB`));
+      });
+      zipfile.on('error', reject);
+    });
+  });
+}
+
+async function resolveResource(
+  fn: string,
+  resourceId: number,
+  root: any,
+): Promise<string | null> {
+  const pkgId = (resourceId >> 24) & 0xff;
+  const typeId = (resourceId >> 16) & 0xff;
+  const entryId = resourceId & 0xffff;
+
+  try {
+    const buffer = await readZipEntry(fn, 'base/resources.pb');
+    const ResourceTable = root.lookupType('aapt.pb.ResourceTable');
+    const message = ResourceTable.decode(buffer);
+    const object = ResourceTable.toObject(message, {
+      enums: String,
+      longs: String,
+      bytes: String,
+      defaults: true,
+      arrays: true,
+    });
+
+    // Find package
+    const pkg = object.package.find((p: any) => p.packageId === pkgId);
+    if (!pkg) return null;
+
+    // Find type
+    const type = pkg.type.find((t: any) => t.typeId === typeId);
+    if (!type) return null;
+
+    // Find entry
+    const entry = type.entry.find((e: any) => e.entryId === entryId);
+    if (!entry) return null;
+
+    // Get value from configValue
+    if (entry.configValue && entry.configValue.length > 0) {
+      const val = entry.configValue[0].value;
+      if (val.item?.str) {
+        return val.item.str.value;
+      }
+    }
+  } catch (e) {
+    console.warn('Failed to resolve resource:', e);
+  }
+  return null;
+}
+
 const localDir = path.resolve(os.homedir(), tempDir);
 fs.ensureDirSync(localDir);
 export function saveToLocal(originPath: string, destName: string) {

package/src/versions.ts

@@ -1,4 +1,4 @@
-import { get, getAllPackages, post, put, uploadFile } from './api';
+import { get, getAllPackages, post, put, uploadFile, doDelete } from './api';
 import { question, saveToLocal } from './utils';
 import { t } from './utils/i18n';
 
@@ -343,4 +343,29 @@ export const versionCommands = {
     await put(`/app/${appId}/version/${versionId}`, updateParams);
     console.log(t('operationSuccess'));
   },
+  deleteVersion: async ({
+    options,
+  }: {
+    options: VersionCommandOptions;
+  }) => {
+    let appId = options.appId;
+    if (!appId) {
+      const platform = await getPlatform(options.platform);
+      appId = (await getSelectedApp(platform)).appId;
+    }
+
+    let versionId = options.versionId;
+    if (!versionId) {
+      versionId = (await chooseVersion(appId as string)).id;
+    }
+
+    try {
+      await doDelete(`/app/${appId}/version/${versionId}`);
+      console.log(t('deleteVersionSuccess', { versionId }));
+    } catch (error: any) {
+      throw new Error(
+        t('deleteVersionError', { versionId, error: error.message }),
+      );
+    }
+  },
 };