react-native-update-cli 2.9.3 → 2.9.5

package/lib/utils/zip-options.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ZIP_ENTRY_SNIFF_BYTES: function() {
+        return ZIP_ENTRY_SNIFF_BYTES;
+    },
+    zipOptionsForManifestEntry: function() {
+        return zipOptionsForManifestEntry;
+    },
+    zipOptionsForPatchEntry: function() {
+        return zipOptionsForPatchEntry;
+    },
+    zipOptionsForPayloadEntry: function() {
+        return zipOptionsForPayloadEntry;
+    },
+    zipOptionsForPayloadFile: function() {
+        return zipOptionsForPayloadFile;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+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, signature) {
+    return bytes.length >= signature.length && bytes.subarray(0, signature.length).equals(signature);
+}
+function hasHermesBytecodeMagic(bytes) {
+    return startsWith(bytes, HERMES_MAGIC) || startsWith(bytes, HERMES_DELTA_MAGIC);
+}
+function hasAlreadyCompressedMagic(bytes) {
+    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) {
+    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);
+    }
+}
+function zipOptionsForPatchEntry() {
+    return {
+        compress: false
+    };
+}
+function zipOptionsForManifestEntry() {
+    return {
+        compress: false
+    };
+}
+function zipOptionsForPayloadEntry(fileName, prefix) {
+    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.default.extname(fileName).toLowerCase();
+    if (alreadyCompressedExtensions.has(extension)) {
+        return {
+            compress: false
+        };
+    }
+    return {
+        compress: true,
+        compressionLevel: 9
+    };
+}
+function zipOptionsForPayloadFile(filePath, entryName = filePath) {
+    return zipOptionsForPayloadEntry(entryName, readFilePrefix(filePath));
+}

package/lib/versions.js

@@ -361,12 +361,12 @@ const versionCommands = {
     versions: async ({ options })=>{
         const platform = await (0, _app.getPlatform)(options.platform);
         const { appId } = await (0, _app.getSelectedApp)(platform);
-        await listVersions(appId);
+        await listVersions(String(appId));
     },
     update: async ({ options })=>{
         const platform = await (0, _app.getPlatform)(options.platform);
         const appId = options.appId || (await (0, _app.getSelectedApp)(platform)).appId;
-        let versionId = options.versionId || (await chooseVersion(appId)).id;
+        let versionId = options.versionId || (await chooseVersion(String(appId))).id;
         if (versionId === 'null') {
             versionId = undefined;
         }
@@ -386,7 +386,7 @@ const versionCommands = {
                 throw new Error((0, _i18n.t)('rolloutRangeError'));
             }
         }
-        const allPkgs = await (0, _api.getAllPackages)(appId);
+        const allPkgs = await (0, _api.getAllPackages)(String(appId));
         if (!allPkgs) {
             throw new Error((0, _i18n.t)('noPackagesFound', {
                 appId
@@ -431,7 +431,7 @@ const versionCommands = {
             }
         } else {
             if (!pkgId) {
-                pkgId = (await (0, _package.choosePackage)(appId)).id;
+                pkgId = (await (0, _package.choosePackage)(String(appId))).id;
             }
             if (!pkgId) {
                 throw new Error((0, _i18n.t)('packageIdRequired'));
@@ -448,14 +448,14 @@ const versionCommands = {
             }
         }
         await printDepsChangesForPublish({
-            appId,
-            versionId,
+            appId: String(appId),
+            versionId: String(versionId),
             pkgs: pkgsToBind,
             providedVersionDeps: options.versionDeps
         });
         await bindVersionToPackages({
-            appId,
-            versionId,
+            appId: String(appId),
+            versionId: String(versionId),
             pkgs: pkgsToBind,
             rollout,
             dryRun: options.dryRun
@@ -464,12 +464,12 @@ const versionCommands = {
     updateVersionInfo: async ({ options })=>{
         const platform = await (0, _app.getPlatform)(options.platform);
         const { appId } = await (0, _app.getSelectedApp)(platform);
-        const versionId = options.versionId || (await chooseVersion(appId)).id;
+        const versionId = options.versionId || (await chooseVersion(String(appId))).id;
         const updateParams = {};
         if (options.name) updateParams.name = options.name;
         if (options.description) updateParams.description = options.description;
         if (options.metaInfo) updateParams.metaInfo = options.metaInfo;
-        await (0, _api.put)(`/app/${appId}/version/${versionId}`, updateParams);
+        await (0, _api.put)(`/app/${String(appId)}/version/${versionId}`, updateParams);
         console.log((0, _i18n.t)('operationSuccess'));
     },
     deleteVersion: async ({ options })=>{
@@ -480,10 +480,10 @@ const versionCommands = {
         }
         let versionId = options.versionId;
         if (!versionId) {
-            versionId = (await chooseVersion(appId)).id;
+            versionId = (await chooseVersion(String(appId))).id;
         }
         try {
-            await (0, _api.doDelete)(`/app/${appId}/version/${versionId}`);
+            await (0, _api.doDelete)(`/app/${String(appId)}/version/${versionId}`);
             console.log((0, _i18n.t)('deleteVersionSuccess', {
                 versionId
             }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-update-cli",
-  "version": "2.9.3",
+  "version": "2.9.5",
   "description": "command line tool for react-native-update (remote updates for react native)",
   "main": "lib/exports.js",
   "types": "lib/exports.d.ts",

package/src/api.ts

@@ -75,10 +75,25 @@ export const closeSession = () => {
   session = undefined;
 };
 
+function createRequestError(error: unknown, requestUrl: string) {
+  const message =
+    typeof error === 'string'
+      ? error
+      : error instanceof Error
+        ? error.message
+        : String(error);
+  return new Error(`${message}\nURL: ${requestUrl}`);
+}
+
 async function query(url: string, options: fetch.RequestInit) {
   const baseUrl = await getBaseUrl;
   const fullUrl = `${baseUrl}${url}`;
-  const resp = await fetch(fullUrl, options);
+  let resp: fetch.Response;
+  try {
+    resp = await fetch(fullUrl, options);
+  } catch (error) {
+    throw createRequestError(error, fullUrl);
+  }
   const text = await resp.text();
   let json: any;
   try {
@@ -86,11 +101,11 @@ async function query(url: string, options: fetch.RequestInit) {
   } catch (e) {}
 
   if (resp.status !== 200) {
-    const message = json?.message || resp.statusText;
+    const message = json?.message || resp.statusText || `HTTP ${resp.status}`;
     if (resp.status === 401) {
-      throw new Error(t('loginExpired'));
+      throw createRequestError(t('loginExpired'), fullUrl);
     }
-    throw new Error(message);
+    throw createRequestError(message, fullUrl);
   }
   return json;
 }
@@ -195,13 +210,21 @@ export async function uploadFile(fn: string, key?: string) {
   //   contentType: 'application/octet-stream',
   // });
 
-  const res = await fetch(realUrl, {
-    method: 'POST',
-    body: form,
-  });
+  let res: fetch.Response;
+  try {
+    res = await fetch(realUrl, {
+      method: 'POST',
+      body: form,
+    });
+  } catch (error) {
+    throw createRequestError(error, realUrl);
+  }
 
   if (res.status > 299) {
-    throw new Error(`${res.status}: ${res.statusText}`);
+    throw createRequestError(
+      `${res.status}: ${res.statusText || 'Upload failed'}`,
+      realUrl,
+    );
   }
 
   // const body = await response.json();

package/src/app.ts

@@ -27,17 +27,30 @@ export function assertPlatform(platform: string): Platform {
   return platform as Platform;
 }
 
-export function getSelectedApp(platform: Platform) {
+export async function getSelectedApp(
+  platform: Platform,
+): Promise<{ appId: string; appKey: string; platform: Platform }> {
   assertPlatform(platform);
 
-  if (!fs.existsSync('update.json')) {
-    throw new Error(t('appNotSelected', { platform }));
+  let updateInfo: Partial<Record<Platform, { appId: number; appKey: string }>> =
+    {};
+  try {
+    updateInfo = JSON.parse(await fs.promises.readFile('update.json', 'utf8'));
+  } catch (e: any) {
+    if (e.code === 'ENOENT') {
+      throw new Error(t('appNotSelected', { platform }));
+    }
+    throw e;
   }
-  const updateInfo = JSON.parse(fs.readFileSync('update.json', 'utf8'));
-  if (!updateInfo[platform]) {
+  const info = updateInfo[platform];
+  if (!info) {
     throw new Error(t('appNotSelected', { platform }));
   }
-  return updateInfo[platform];
+  return {
+    appId: String(info.appId),
+    appKey: info.appKey,
+    platform,
+  };
 }
 
 export async function listApp(platform: Platform | '' = '') {
@@ -125,10 +138,10 @@ export const appCommands = {
     let updateInfo: Partial<
       Record<Platform, { appId: number; appKey: string }>
     > = {};
-    if (fs.existsSync('update.json')) {
-      try {
-        updateInfo = JSON.parse(fs.readFileSync('update.json', 'utf8'));
-      } catch (e) {
+    try {
+      updateInfo = JSON.parse(await fs.promises.readFile('update.json', 'utf8'));
+    } catch (e: any) {
+      if (e.code !== 'ENOENT') {
         console.error(t('failedToParseUpdateJson'));
         throw e;
       }
@@ -138,7 +151,7 @@ export const appCommands = {
       appId: id,
       appKey,
     };
-    fs.writeFileSync(
+    await fs.promises.writeFile(
       'update.json',
       JSON.stringify(updateInfo, null, 4),
       'utf8',

package/src/bundle-pack.ts

@@ -2,6 +2,7 @@ import path from 'path';
 import * as fs from 'fs-extra';
 import { ZipFile as YazlZipFile } from 'yazl';
 import { t } from './utils/i18n';
+import { zipOptionsForPayloadFile } from './utils/zip-options';
 
 const ignorePackingFileNames = [
   '.',
@@ -32,7 +33,11 @@ export async function packBundle(dir: string, output: string): Promise<void> {
         const fullPath = path.join(root, name);
         const stat = fs.statSync(fullPath);
         if (stat.isFile()) {
-          zipfile.addFile(fullPath, rel + name);
+          zipfile.addFile(
+            fullPath,
+            rel + name,
+            zipOptionsForPayloadFile(fullPath, rel + name),
+          );
         } else if (stat.isDirectory()) {
           addDirectory(fullPath, `${rel}${name}/`);
         }