react-native-update-cli 2.9.3 → 2.9.5

package/lib/api.js

@@ -114,21 +114,30 @@ const closeSession = ()=>{
     }
     session = undefined;
 };
+function createRequestError(error, requestUrl) {
+    const message = typeof error === 'string' ? error : error instanceof Error ? error.message : String(error);
+    return new Error(`${message}\nURL: ${requestUrl}`);
+}
 async function query(url, options) {
     const baseUrl = await _httphelper.getBaseUrl;
     const fullUrl = `${baseUrl}${url}`;
-    const resp = await (0, _nodefetch.default)(fullUrl, options);
+    let resp;
+    try {
+        resp = await (0, _nodefetch.default)(fullUrl, options);
+    } catch (error) {
+        throw createRequestError(error, fullUrl);
+    }
     const text = await resp.text();
     let json;
     try {
         json = JSON.parse(text);
     } catch (e) {}
     if (resp.status !== 200) {
-        const message = (json == null ? void 0 : json.message) || resp.statusText;
+        const message = (json == null ? void 0 : json.message) || resp.statusText || `HTTP ${resp.status}`;
         if (resp.status === 401) {
-            throw new Error((0, _i18n.t)('loginExpired'));
+            throw createRequestError((0, _i18n.t)('loginExpired'), fullUrl);
         }
-        throw new Error(message);
+        throw createRequestError(message, fullUrl);
     }
     return json;
 }
@@ -221,12 +230,17 @@ async function uploadFile(fn, key) {
     // form.append('file', fileStream, {
     //   contentType: 'application/octet-stream',
     // });
-    const res = await (0, _nodefetch.default)(realUrl, {
-        method: 'POST',
-        body: form
-    });
+    let res;
+    try {
+        res = await (0, _nodefetch.default)(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();
     return {

package/lib/app.d.ts

@@ -6,7 +6,11 @@ interface AppSummary {
 }
 export declare function getPlatform(platform?: string): Promise<Platform>;
 export declare function assertPlatform(platform: string): Platform;
-export declare function getSelectedApp(platform: Platform): any;
+export declare function getSelectedApp(platform: Platform): Promise<{
+    appId: string;
+    appKey: string;
+    platform: Platform;
+}>;
 export declare function listApp(platform?: Platform | ''): Promise<AppSummary[]>;
 export declare function chooseApp(platform: Platform): Promise<AppSummary>;
 export declare const appCommands: {

package/lib/app.js

@@ -54,20 +54,30 @@ function assertPlatform(platform) {
     }
     return platform;
 }
-function getSelectedApp(platform) {
+async function getSelectedApp(platform) {
     assertPlatform(platform);
-    if (!_fs.default.existsSync('update.json')) {
-        throw new Error((0, _i18n.t)('appNotSelected', {
-            platform
-        }));
+    let updateInfo = {};
+    try {
+        updateInfo = JSON.parse(await _fs.default.promises.readFile('update.json', 'utf8'));
+    } catch (e) {
+        if (e.code === 'ENOENT') {
+            throw new Error((0, _i18n.t)('appNotSelected', {
+                platform
+            }));
+        }
+        throw e;
     }
-    const updateInfo = JSON.parse(_fs.default.readFileSync('update.json', 'utf8'));
-    if (!updateInfo[platform]) {
+    const info = updateInfo[platform];
+    if (!info) {
         throw new Error((0, _i18n.t)('appNotSelected', {
             platform
         }));
     }
-    return updateInfo[platform];
+    return {
+        appId: String(info.appId),
+        appKey: info.appKey,
+        platform
+    };
 }
 async function listApp(platform = '') {
     const { data } = await (0, _api.get)('/app/list');
@@ -148,10 +158,10 @@ const appCommands = {
         const platform = await getPlatform(options.platform);
         const id = args[0] ? Number.parseInt(args[0]) : (await chooseApp(platform)).id;
         let updateInfo = {};
-        if (_fs.default.existsSync('update.json')) {
-            try {
-                updateInfo = JSON.parse(_fs.default.readFileSync('update.json', 'utf8'));
-            } catch (e) {
+        try {
+            updateInfo = JSON.parse(await _fs.default.promises.readFile('update.json', 'utf8'));
+        } catch (e) {
+            if (e.code !== 'ENOENT') {
                 console.error((0, _i18n.t)('failedToParseUpdateJson'));
                 throw e;
             }
@@ -161,6 +171,6 @@ const appCommands = {
             appId: id,
             appKey
         };
-        _fs.default.writeFileSync('update.json', JSON.stringify(updateInfo, null, 4), 'utf8');
+        await _fs.default.promises.writeFile('update.json', JSON.stringify(updateInfo, null, 4), 'utf8');
     }
 };

package/lib/bundle-pack.js

@@ -12,6 +12,7 @@ const _path = /*#__PURE__*/ _interop_require_default(require("path"));
 const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
 const _yazl = require("yazl");
 const _i18n = require("./utils/i18n");
+const _zipoptions = require("./utils/zip-options");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -85,7 +86,7 @@ async function packBundle(dir, output) {
                 const fullPath = _path.default.join(root, name);
                 const stat = _fsextra.statSync(fullPath);
                 if (stat.isFile()) {
-                    zipfile.addFile(fullPath, rel + name);
+                    zipfile.addFile(fullPath, rel + name, (0, _zipoptions.zipOptionsForPayloadFile)(fullPath, rel + name));
                 } else if (stat.isDirectory()) {
                     addDirectory(fullPath, `${rel}${name}/`);
                 }

package/lib/diff.js

@@ -27,6 +27,7 @@ const _utils = require("./utils");
 const _constants = require("./utils/constants");
 const _i18n = require("./utils/i18n");
 const _zipentries = require("./utils/zip-entries");
+const _zipoptions = require("./utils/zip-options");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
@@ -73,7 +74,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const loadDiffModule = (pkgName)=>{
+const loadModule = (pkgName)=>{
     const resolvePaths = [
         '.',
         _globaldirs.npm.packages,
@@ -83,15 +84,90 @@ const loadDiffModule = (pkgName)=>{
         const resolved = require.resolve(pkgName, {
             paths: resolvePaths
         });
-        const mod = require(resolved);
-        if (mod == null ? void 0 : mod.diff) {
-            return mod.diff;
-        }
+        return require(resolved);
     } catch (e) {}
     return undefined;
 };
-const hdiff = loadDiffModule('node-hdiffpatch');
-const bsdiff = loadDiffModule('node-bsdiff');
+const hdiff = loadModule('node-hdiffpatch');
+const bsdiff = loadModule('node-bsdiff');
+const chiff = loadModule('@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) {
+    var _ref;
+    const value = String((_ref = policy != null ? policy : process.env.RNU_CHIFF_HPATCH_POLICY) != null ? _ref : 'off').toLowerCase();
+    if (value === 'costed' || value === 'on' || value === 'true' || value === '1') {
+        return 'costed';
+    }
+    return 'off';
+}
+function resolveChiffHpatchMinNativeBytes(value) {
+    var _ref;
+    const raw = (_ref = value != null ? value : process.env.RNU_CHIFF_HPATCH_MIN_NATIVE_BYTES) != null ? _ref : 4096;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return 4096;
+    }
+    return Math.floor(parsed);
+}
+function resolveChiffHpatchExactPolicy(policy) {
+    var _ref;
+    const value = String((_ref = policy != null ? policy : process.env.RNU_CHIFF_HPATCH_EXACT_COVERS) != null ? _ref : 'off').toLowerCase();
+    if (value === 'on' || value === 'true' || value === '1') {
+        return 'on';
+    }
+    return 'off';
+}
+function createChiffAwareHdiff(hdiffModule, chiffModule, policy, minNativeBytes, exactPolicy) {
+    const baseDiff = hdiffModule.diff;
+    if (!baseDiff) {
+        throw new Error((0, _i18n.t)('nodeHdiffpatchRequired', {
+            scriptName: _constants.scriptName
+        }));
+    }
+    if (policy === 'off') {
+        return baseDiff;
+    }
+    return (oldSource, newSource)=>{
+        const nativeDiff = baseDiff(oldSource, newSource);
+        if (!oldSource || !newSource || !hdiffModule.diffWithCovers) {
+            return nativeDiff;
+        }
+        let bestDiff = nativeDiff;
+        const tryDiffWithCovers = (covers, mode)=>{
+            try {
+                const result = hdiffModule.diffWithCovers == null ? void 0 : hdiffModule.diffWithCovers.call(hdiffModule, oldSource, newSource, covers, {
+                    mode
+                });
+                if (Buffer.isBuffer(result == null ? void 0 : result.diff) && result.diff.length < bestDiff.length) {
+                    bestDiff = result.diff;
+                }
+            } catch (e) {}
+        };
+        tryDiffWithCovers([], 'native-coalesce');
+        if (nativeDiff.length < minNativeBytes) {
+            return bestDiff;
+        }
+        try {
+            var _chiffModule_hpatchApproximatePlanResult;
+            const approximatePlan = chiffModule == null ? void 0 : (_chiffModule_hpatchApproximatePlanResult = chiffModule.hpatchApproximatePlanResult) == null ? void 0 : _chiffModule_hpatchApproximatePlanResult.call(chiffModule, oldSource, newSource);
+            if (Array.isArray(approximatePlan == null ? void 0 : approximatePlan.covers)) {
+                tryDiffWithCovers(approximatePlan.covers, 'merge');
+            }
+        } catch (e) {}
+        if (exactPolicy === 'off' || !(chiffModule == null ? void 0 : 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 (e) {}
+        return bestDiff;
+    };
+}
 function basename(fn) {
     const m = /^(.+\/)[^\/]+\/?$/.exec(fn);
     return m == null ? void 0 : m[1];
@@ -148,7 +224,7 @@ async function diffFromPPK(origin, next, output, diffFn) {
             //console.log('Found bundle');
             const newSource = await (0, _zipentries.readEntry)(entry, nextZipfile);
             //console.log('Begin diff');
-            zipfile.addBuffer(diffFn(originSource, newSource), `${entry.fileName}.patch`);
+            zipfile.addBuffer(diffFn(originSource, newSource), `${entry.fileName}.patch`, (0, _zipoptions.zipOptionsForPatchEntry)());
         //console.log('End diff');
         } else {
             // If same file.
@@ -172,6 +248,7 @@ async function diffFromPPK(origin, next, output, diffFn) {
             if (basePath) {
                 addEntry(basePath);
             }
+            const entryPrefix = await (0, _zipentries.readEntryPrefix)(entry, nextZipfile, _zipoptions.ZIP_ENTRY_SNIFF_BYTES);
             await new Promise((resolve, reject)=>{
                 nextZipfile.openReadStream(entry, (err, readStream)=>{
                     if (err) {
@@ -180,7 +257,7 @@ async function diffFromPPK(origin, next, output, diffFn) {
                     if (!readStream) {
                         return reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
                     }
-                    zipfile.addReadStream(readStream, entry.fileName);
+                    zipfile.addReadStream(readStream, entry.fileName, (0, _zipoptions.zipOptionsForPayloadEntry)(entry.fileName, entryPrefix));
                     readStream.on('end', ()=>{
                         //console.log('add finished');
                         resolve(void 0);
@@ -202,7 +279,7 @@ async function diffFromPPK(origin, next, output, diffFn) {
     zipfile.addBuffer(Buffer.from(JSON.stringify({
         copies,
         deletes
-    })), '__diff.json');
+    })), '__diff.json', (0, _zipoptions.zipOptionsForManifestEntry)());
     zipfile.end();
     await writePromise;
 }
@@ -246,7 +323,7 @@ async function diffFromPackage(origin, next, output, diffFn, originBundleName, t
             //console.log('Found bundle');
             const newSource = await (0, _zipentries.readEntry)(entry, nextZipfile);
             //console.log('Begin diff');
-            zipfile.addBuffer(diffFn(originSource, newSource), `${entry.fileName}.patch`);
+            zipfile.addBuffer(diffFn(originSource, newSource), `${entry.fileName}.patch`, (0, _zipoptions.zipOptionsForPatchEntry)());
         //console.log('End diff');
         } else {
             // If same file.
@@ -260,6 +337,7 @@ async function diffFromPackage(origin, next, output, diffFn, originBundleName, t
                 copies[entry.fileName] = movedFrom;
                 return;
             }
+            const entryPrefix = await (0, _zipentries.readEntryPrefix)(entry, nextZipfile, _zipoptions.ZIP_ENTRY_SNIFF_BYTES);
             await new Promise((resolve, reject)=>{
                 nextZipfile.openReadStream(entry, (err, readStream)=>{
                     if (err) {
@@ -268,7 +346,7 @@ async function diffFromPackage(origin, next, output, diffFn, originBundleName, t
                     if (!readStream) {
                         return reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
                     }
-                    zipfile.addReadStream(readStream, entry.fileName);
+                    zipfile.addReadStream(readStream, entry.fileName, (0, _zipoptions.zipOptionsForPayloadEntry)(entry.fileName, entryPrefix));
                     readStream.on('end', ()=>{
                         //console.log('add finished');
                         resolve(void 0);
@@ -279,7 +357,7 @@ async function diffFromPackage(origin, next, output, diffFn, originBundleName, t
     });
     zipfile.addBuffer(Buffer.from(JSON.stringify({
         copies
-    })), '__diff.json');
+    })), '__diff.json', (0, _zipoptions.zipOptionsForManifestEntry)());
     zipfile.end();
     await writePromise;
 }
@@ -288,19 +366,22 @@ function resolveDiffImplementation(useHdiff, options) {
         return options.customDiff;
     }
     if (useHdiff) {
-        if (!hdiff) {
+        var _options_customHdiffModule;
+        const hdiffModule = (_options_customHdiffModule = options.customHdiffModule) != null ? _options_customHdiffModule : hdiff;
+        if (!(hdiffModule == null ? void 0 : hdiffModule.diff)) {
             throw new Error((0, _i18n.t)('nodeHdiffpatchRequired', {
                 scriptName: _constants.scriptName
             }));
         }
-        return hdiff;
+        var _options_customChiffModule;
+        return createChiffAwareHdiff(hdiffModule, (_options_customChiffModule = options.customChiffModule) != null ? _options_customChiffModule : chiff, resolveChiffHpatchPolicy(options.chiffHpatchPolicy), resolveChiffHpatchMinNativeBytes(options.chiffHpatchMinNativeBytes), resolveChiffHpatchExactPolicy(options.chiffHpatchExactCovers));
     }
-    if (!bsdiff) {
+    if (!(bsdiff == null ? void 0 : bsdiff.diff)) {
         throw new Error((0, _i18n.t)('nodeBsdiffRequired', {
             scriptName: _constants.scriptName
         }));
     }
-    return bsdiff;
+    return bsdiff.diff;
 }
 function diffArgsCheck(args, options, diffFnName, useHdiff) {
     const [origin, next] = args;

package/lib/module-manager.js

@@ -36,9 +36,6 @@ class ModuleManager {
         if (module.init) {
             module.init(this.provider);
         }
-    // console.log(
-    //   `Module '${module.name}' (v${module.version}) registered successfully`,
-    // );
     }
     unregisterModule(moduleName) {
         const module = this.modules.get(moduleName);

package/lib/package.js

@@ -72,7 +72,7 @@ async function uploadNativePackage(filePath, options, config) {
     const { versionName: extractedVersionName, buildTime } = info;
     const { appId: appIdInPkg, appKey: appKeyInPkg } = info;
     const { appId, appKey } = await (0, _app.getSelectedApp)(config.platform);
-    if (appIdInPkg && appIdInPkg != appId) {
+    if (appIdInPkg && String(appIdInPkg) !== appId) {
         throw new Error((0, _i18n.t)(config.appIdMismatchKey, {
             appIdInPkg,
             appId
@@ -151,9 +151,13 @@ async function listPackage(appId) {
 }
 async function choosePackage(appId) {
     const list = await listPackage(appId);
+    const packageMap = new Map(list == null ? void 0 : list.map((v)=>[
+            v.id.toString(),
+            v
+        ]));
     while(true){
         const id = await (0, _utils.question)((0, _i18n.t)('enterNativePackageId'));
-        const app = list == null ? void 0 : list.find((v)=>v.id.toString() === id);
+        const app = packageMap.get(id);
         if (app) {
             return app;
         }
@@ -262,7 +266,7 @@ const packageCommands = {
     packages: async ({ options })=>{
         const platform = await (0, _app.getPlatform)(options.platform);
         const { appId } = await (0, _app.getSelectedApp)(platform);
-        await listPackage(appId);
+        await listPackage(String(appId));
     },
     deletePackage: async ({ args, options })=>{
         let { appId, packageId, packageVersion } = options;

package/lib/utils/http-helper.js

@@ -65,7 +65,7 @@ const ping = async (url)=>{
                 if (!pingFinished) {
                 // console.log('ping timeout', url);
                 }
-            }, 2000))
+            }, 5000))
     ]);
 };
 const testUrls = async (urls)=>{

package/lib/utils/zip-entries.d.ts

@@ -1,3 +1,4 @@
 import { type Entry, type ZipFile as YauzlZipFile } from 'yauzl';
 export declare function readEntry(entry: Entry, zipFile: YauzlZipFile): Promise<Buffer>;
+export declare function readEntryPrefix(entry: Entry, zipFile: YauzlZipFile, maxBytes: number): Promise<Buffer>;
 export declare function enumZipEntries(zipFn: string, callback: (entry: Entry, zipFile: YauzlZipFile, nestedPath?: string) => Promise<any> | undefined, nestedPath?: string): Promise<unknown>;

package/lib/utils/zip-entries.js

@@ -14,6 +14,9 @@ _export(exports, {
     },
     readEntry: function() {
         return readEntry;
+    },
+    readEntryPrefix: function() {
+        return readEntryPrefix;
     }
 });
 const _os = /*#__PURE__*/ _interop_require_default(require("os"));
@@ -83,6 +86,64 @@ function readEntry(entry, zipFile) {
         });
     });
 }
+function readEntryPrefix(entry, zipFile, maxBytes) {
+    if (maxBytes <= 0) {
+        return Promise.resolve(Buffer.alloc(0));
+    }
+    const buffers = [];
+    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)=>{
+                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)=>{
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                cleanup();
+                reject(error);
+            };
+            stream.on('data', onData);
+            stream.once('end', onEnd);
+            stream.once('error', onError);
+        });
+    });
+}
 async function enumZipEntries(zipFn, callback, nestedPath = '') {
     return new Promise((resolve, reject)=>{
         (0, _yauzl.open)(zipFn, {

package/lib/utils/zip-options.d.ts

@@ -0,0 +1,9 @@
+export type ZipEntryOptions = {
+    compress?: boolean;
+    compressionLevel?: number;
+};
+export declare const ZIP_ENTRY_SNIFF_BYTES = 64;
+export declare function zipOptionsForPatchEntry(): ZipEntryOptions;
+export declare function zipOptionsForManifestEntry(): ZipEntryOptions;
+export declare function zipOptionsForPayloadEntry(fileName: string, prefix?: Buffer): ZipEntryOptions;
+export declare function zipOptionsForPayloadFile(filePath: string, entryName?: string): ZipEntryOptions;