react-native-update 10.53.1 → 10.54.0

package/android/src/main/java/cn/reactnative/modules/update/UpdateContext.java

@@ -8,6 +8,7 @@ import android.os.Build;
 import android.util.Log;
 import com.facebook.react.ReactInstanceManager;
 import java.io.File;
+import org.json.JSONObject;
 import java.io.IOException;
 import java.io.InputStream;
 import java.security.MessageDigest;
@@ -46,7 +47,7 @@ public class UpdateContext {
     private static final int STATE_OP_CLEAR_ROLLBACK_MARK = 5;
     private static final int STATE_OP_RESOLVE_LAUNCH = 6;
     private static final String KEY_FIRST_LOAD_MARKED = "firstLoadMarked";
-    static final String VERSION_COMPLETE_FILE = ".pushy-complete";
+    static final String VERSION_COMPLETE_FILE = InstallRecord.FILE_NAME;
     // Bumped by resetToPackagedBundle. The cold-start check runs for minutes
     // and may already hold a decision when the app resets to the packaged
     // bundle; the orchestrator samples this counter and abandons activation
@@ -367,15 +368,39 @@ public class UpdateContext {
         putNullableString(editor, "rolledBackVersion", state.rolledBackVersion);
     }
 
-    private void persistEditor(SharedPreferences.Editor editor, String reason) {
+    /**
+     * Best-effort persistence for launch-path bookkeeping (binary-version
+     * sync, first-load markers, rollback resolution): a failure is logged but
+     * must not take the app down while it is resolving which bundle to run.
+     */
+    private boolean persistEditor(SharedPreferences.Editor editor, String reason) {
         // A lost state write can mean a missed rollback or a version switch
         // that silently never happens, so this must be visible in release too.
         if (!editor.commit()) {
             Log.e(TAG, "Failed to persist update state for " + reason);
+            return false;
         }
+        return true;
     }
 
-    public void switchVersion(String hash) {
+    /**
+     * Persistence for operations whose result is promised to a caller
+     * (switchVersion / markSuccess / setLocalHashInfo / the cold-start round):
+     * a commit that did not reach disk is a failed operation, never a
+     * resolved promise whose effect silently evaporates on the next launch.
+     */
+    private void persistEditorOrThrow(SharedPreferences.Editor editor, String reason) {
+        if (!persistEditor(editor, reason)) {
+            throw new IllegalStateException("Failed to persist update state for " + reason);
+        }
+    }
+
+    /**
+     * Validates that {@code hash} is a switchable version and computes the
+     * resulting state without persisting it, so callers can fold the switch
+     * into a larger single-commit transaction.
+     */
+    private StateCoreResult computeSwitchVersion(String hash) {
         if (!isSafePathComponent(hash)) {
             throw new IllegalArgumentException("Invalid hash: " + hash);
         }
@@ -387,31 +412,42 @@ public class UpdateContext {
         StateCoreResult currentState = getStateSnapshot();
         boolean isLegacyActivatedVersion = hash.equals(currentState.currentVersion)
             || hash.equals(currentState.lastVersion);
-        if (!new File(versionDir, VERSION_COMPLETE_FILE).isFile()
-            && !isLegacyActivatedVersion) {
+        if (!InstallRecord.isComplete(versionDir, hash) && !isLegacyActivatedVersion) {
             // Versions activated before completion markers were introduced are
             // explicitly grandfathered through current/last state. An arbitrary
             // markerless directory may be a crash-left partial install.
             throw new IllegalStateException("Bundle version " + hash + " is incomplete.");
         }
-        StateCoreResult nextState = runStateCore(
+        if (!isLegacyActivatedVersion) {
+            // The record's bundle digest must match the bytes on disk before
+            // the next launch is pointed at them.
+            try {
+                InstallRecord.verifyForActivation(versionDir, hash, bundleFile);
+            } catch (IOException e) {
+                throw new IllegalStateException(e.getMessage(), e);
+            }
+        }
+        return runStateCore(
             STATE_OP_SWITCH_VERSION,
             currentState,
-            hash
-            ,
+            hash,
             false,
             false
         );
+    }
+
+    public void switchVersion(String hash) {
+        StateCoreResult nextState = computeSwitchVersion(hash);
         SharedPreferences.Editor editor = sp.edit();
         applyState(editor, nextState);
-        persistEditor(editor, "switch version");
+        persistEditorOrThrow(editor, "switch version");
         ignoreRollback = false;
     }
 
     public void setKv(String key, String value) {
         SharedPreferences.Editor editor = sp.edit();
         editor.putString(key, value);
-        persistEditor(editor, "set key " + key);
+        persistEditorOrThrow(editor, "set key " + key);
     }
 
     public String getKv(String key) {
@@ -421,7 +457,7 @@ public class UpdateContext {
     void removeKv(String key) {
         SharedPreferences.Editor editor = sp.edit();
         editor.remove(key);
-        persistEditor(editor, "remove key " + key);
+        persistEditorOrThrow(editor, "remove key " + key);
     }
 
     public String getCurrentVersion() {
@@ -461,7 +497,7 @@ public class UpdateContext {
             if (nextState.staleVersionToDelete != null) {
                 editor.remove("hash_" + nextState.staleVersionToDelete);
             }
-            persistEditor(editor, "mark success");
+            persistEditorOrThrow(editor, "mark success");
 
             this.cleanUp();
         }
@@ -479,7 +515,7 @@ public class UpdateContext {
         SharedPreferences.Editor editor = sp.edit();
         applyState(editor, nextState);
         editor.remove(KEY_FIRST_LOAD_MARKED);
-        persistEditor(editor, "clear first time");
+        persistEditorOrThrow(editor, "clear first time");
 
         this.cleanUp();
     }
@@ -515,7 +551,7 @@ public class UpdateContext {
         if (uuid != null) {
             editor.putString("uuid", uuid);
         }
-        persistEditor(editor, "reset to packaged bundle");
+        persistEditorOrThrow(editor, "reset to packaged bundle");
         ignoreRollback = false;
         // editor.clear() above already dropped the cached check response; it
         // still advertised the version this reset removed.
@@ -543,6 +579,7 @@ public class UpdateContext {
         );
         SharedPreferences.Editor editor = sp.edit();
         applyState(editor, nextState);
+        // Runs from getConstants on the launch path: best-effort only.
         persistEditor(editor, "clear rollback mark");
 
         this.cleanUp();
@@ -676,26 +713,49 @@ public class UpdateContext {
             if (resetGeneration.get() != expectedGeneration) {
                 return false;
             }
+            // One editor, one commit: the version info, the activation and
+            // the response cache land together or not at all. Three separate
+            // commits under the same lock only prevented interleaving, not a
+            // half-written round after a failed or interrupted write.
+            SharedPreferences.Editor editor = sp.edit();
             if (hash != null && hashInfoJson != null) {
-                setKv("hash_" + hash, hashInfoJson);
+                editor.putString("hash_" + hash, hashInfoJson);
             }
-            if (activate && hash != null) {
-                switchVersion(hash);
+            boolean switching = activate && hash != null;
+            if (switching) {
+                applyState(editor, computeSwitchVersion(hash));
             }
             if (responseCacheJson != null) {
-                setKv(NativeCheckOrchestrator.KEY_RESP_CACHE, responseCacheJson);
+                editor.putString(NativeCheckOrchestrator.KEY_RESP_CACHE, responseCacheJson);
+            }
+            persistEditorOrThrow(editor, "commit native check result");
+            if (switching) {
+                ignoreRollback = false;
             }
             return true;
         }
     }
 
+    /**
+     * bundleSha256 from the running version's install record (see
+     * InstallRecord); "" for the embedded bundle, a legacy install or an
+     * unreadable record. Exposed to JS for crash-report attribution.
+     */
+    String currentBundleSha256(String hash) {
+        if (hash == null || hash.isEmpty() || !isSafePathComponent(hash)) {
+            return "";
+        }
+        JSONObject record = InstallRecord.read(new File(rootDir, hash));
+        return record == null ? "" : record.optString("bundleSha256", "");
+    }
+
     boolean hasCompletedVersion(String hash) {
         if (!isSafePathComponent(hash)) {
             return false;
         }
         File versionDir = new File(rootDir, hash);
         return new File(versionDir, "index.bundlejs").isFile()
-            && new File(versionDir, VERSION_COMPLETE_FILE).isFile();
+            && InstallRecord.isComplete(versionDir, hash);
     }
 
     private String rollBack() {

package/android/src/main/java/cn/reactnative/modules/update/UpdateFileUtils.java

@@ -43,6 +43,27 @@ final class UpdateFileUtils {
         }
     }
 
+    /** Streaming SHA-256 of a file, lowercase hex. */
+    static String sha256Hex(File file) throws IOException {
+        try (InputStream in = new FileInputStream(file)) {
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("SHA-256");
+            byte[] buffer = new byte[64 * 1024];
+            int read;
+            while ((read = in.read(buffer)) != -1) {
+                md.update(buffer, 0, read);
+            }
+            byte[] digest = md.digest();
+            StringBuilder hex = new StringBuilder(digest.length * 2);
+            for (byte b : digest) {
+                hex.append(Character.forDigit((b >> 4) & 0xf, 16));
+                hex.append(Character.forDigit(b & 0xf, 16));
+            }
+            return hex.toString();
+        } catch (java.security.NoSuchAlgorithmException e) {
+            throw new IOException("SHA-256 unavailable", e);
+        }
+    }
+
     static void copyFile(File from, File to) throws IOException {
         ensureParentDirectory(to);
         try (

package/android/src/main/java/cn/reactnative/modules/update/UpdateModuleImpl.java

@@ -258,6 +258,19 @@ public class UpdateModuleImpl {
      * Validated at write time — a corrupt config would otherwise silently
      * disable the native check forever with no signal.
      */
+    public static void markJsCheckCompleted(
+        final UpdateContext updateContext,
+        final String config,
+        final Promise promise
+    ) {
+        if (config == null || config.isEmpty()) {
+            promise.reject(ErrorCodes.INVALID_OPTIONS, "config must be a non-empty string");
+            return;
+        }
+        NativeCheckOrchestrator.markJsCheckCompleted(config);
+        promise.resolve(true);
+    }
+
     public static void syncNativeConfig(
         final UpdateContext updateContext,
         final String config,
@@ -313,7 +326,20 @@ public class UpdateModuleImpl {
         if (!isValidHashInfo(info)) {
             throw new IllegalArgumentException("invalid json string");
         }
-        updateContext.setKv("hash_" + hash, info);
+        try {
+            updateContext.setKv("hash_" + hash, info);
+        } catch (IllegalStateException e) {
+            // Distinguish "could not persist" from "malformed input": JS
+            // classifies the former as FILE_OPERATION_FAILED.
+            throw new PersistenceException(e);
+        }
+    }
+
+    /** A state write that did not reach disk (SharedPreferences commit false). */
+    static final class PersistenceException extends RuntimeException {
+        PersistenceException(Throwable cause) {
+            super(String.valueOf(cause.getMessage()), cause);
+        }
     }
 
     public static void setLocalHashInfo(
@@ -325,7 +351,12 @@ public class UpdateModuleImpl {
         StateSerialRunner.run(promise, ErrorCodes.INVALID_HASH_INFO, "setLocalHashInfo", new StateSerialRunner.Operation() {
             @Override
             public void run() {
-                setLocalHashInfoInternal(updateContext, hash, info);
+                try {
+                    setLocalHashInfoInternal(updateContext, hash, info);
+                } catch (PersistenceException e) {
+                    promise.reject(ErrorCodes.FILE_OPERATION_FAILED, "setLocalHashInfo failed", e);
+                    return;
+                }
                 promise.resolve(true);
             }
         });

package/android/src/main/java/cn/reactnative/modules/update/UpdateModuleSupport.java

@@ -16,6 +16,7 @@ final class UpdateModuleSupport {
         String currentVersion = updateContext.getCurrentVersion();
         constants.put("currentVersion", currentVersion);
         constants.put("currentVersionInfo", updateContext.getKv("hash_" + currentVersion));
+        constants.put("currentBundleSha256", updateContext.currentBundleSha256(currentVersion));
         constants.put("buildTime", updateContext.getBuildTime());
         constants.put("isUsingBundleUrl", updateContext.getIsUsingBundleUrl());
 

package/android/src/newarch/cn/reactnative/modules/update/UpdateModule.java

@@ -98,6 +98,11 @@ public class UpdateModule extends NativePushySpec {
         UpdateModuleImpl.getNativeCheckCache(updateContext, promise);
     }
 
+    @Override
+    public void markJsCheckCompleted(String config, Promise promise) {
+        UpdateModuleImpl.markJsCheckCompleted(updateContext, config, promise);
+    }
+
     @Override
     public void setLocalHashInfo(String hash, String info, Promise promise) {
         UpdateModuleImpl.setLocalHashInfo(updateContext, hash, info, promise);

package/android/src/oldarch/cn/reactnative/modules/update/UpdateModule.java

@@ -100,6 +100,11 @@ public class UpdateModule extends ReactContextBaseJavaModule {
         UpdateModuleImpl.getNativeCheckCache(updateContext, promise);
     }
 
+    @ReactMethod
+    public void markJsCheckCompleted(String config, Promise promise) {
+        UpdateModuleImpl.markJsCheckCompleted(updateContext, config, promise);
+    }
+
     @ReactMethod
     public void setLocalHashInfo(String hash, String info) {
         UpdateModuleImpl.setLocalHashInfo(updateContext, hash, info);

package/cpp/patch_core/archive_limits.h

@@ -0,0 +1,38 @@
+#ifndef PUSHY_PATCH_CORE_ARCHIVE_LIMITS_H_
+#define PUSHY_PATCH_CORE_ARCHIVE_LIMITS_H_
+
+// Single source of truth for the resource caps applied to an update package
+// before and while it is unpacked. A corrupt or hostile archive must be able
+// to cost at most a bounded amount of disk, memory and time — never a full
+// disk or a zip bomb. The caps are generous for real packages (a large full
+// bundle with assets is tens of MB) and exist purely as damage bounds.
+//
+// Mirrors that cannot include this header MUST stay in sync by hand:
+//   - android/.../ArchiveLimits.java
+//   - harmony/pushy/src/main/ets/ArchiveLimits.ts
+// iOS (RCTPushy.mm) includes this header directly.
+
+namespace pushy {
+namespace archive_limits {
+
+// Downloaded archive (Content-Length up front, streamed bytes as backstop).
+constexpr long long kMaxArchiveBytes = 512LL * 1024 * 1024;
+// Sum of every entry's uncompressed size.
+constexpr long long kMaxTotalUncompressedBytes = 2048LL * 1024 * 1024;
+// A single entry's uncompressed size.
+constexpr long long kMaxEntryBytes = 512LL * 1024 * 1024;
+// Number of entries in one archive.
+constexpr long long kMaxEntries = 20000;
+// Per-entry uncompressed/compressed ratio, checked only above
+// kRatioCheckMinBytes (tiny highly-compressible files are legitimate).
+constexpr long long kMaxCompressionRatio = 100;
+constexpr long long kRatioCheckMinBytes = 1LL * 1024 * 1024;
+// __diff.json is parsed fully in memory.
+constexpr long long kMaxManifestBytes = 16LL * 1024 * 1024;
+// Free disk required beyond the bytes about to be written.
+constexpr long long kFreeDiskMarginBytes = 64LL * 1024 * 1024;
+
+}  // namespace archive_limits
+}  // namespace pushy
+
+#endif  // PUSHY_PATCH_CORE_ARCHIVE_LIMITS_H_

package/cpp/patch_core/install_record.h

@@ -0,0 +1,36 @@
+#ifndef PUSHY_PATCH_CORE_INSTALL_RECORD_H_
+#define PUSHY_PATCH_CORE_INSTALL_RECORD_H_
+
+// The completion record every platform writes into a version directory once
+// an install fully succeeded, and reads back before trusting that directory.
+//
+//   <root>/<hash>/.pushy-complete
+//   {"schema":1,"versionHash":"<hash>","bundleSha256":"<hex>","artifactSha256":"<hex>"}
+//
+// - Written by the SDK only (archives may not ship a `.pushy-*` entry), as
+//   the LAST step of a two-phase install: unpack/patch into
+//   <root>/<hash>.staging, write the record there, then atomically rename
+//   the staging directory to <root>/<hash>.
+// - versionHash must equal the directory name; bundleSha256 is the digest of
+//   the final index.bundlejs (bundle.harmony.js on Harmony) and is
+//   re-verified at switchVersion time; artifactSha256 is the digest of the
+//   downloaded archive (diagnostics / CDN corruption attribution).
+// - Legacy: an EMPTY file is a completed install written by SDK < 10.53
+//   (no digests); it stays trusted for presence, nothing to verify.
+//
+// Mirrors that cannot include this header MUST stay in sync by hand:
+//   - android/.../InstallRecord.java
+//   - harmony/pushy/src/main/ets/InstallRecord.ts
+// iOS (RCTPushy.mm) includes this header directly.
+
+namespace pushy {
+namespace install_record {
+
+constexpr int kSchema = 1;
+constexpr const char* kFileName = ".pushy-complete";
+constexpr const char* kStagingSuffix = ".staging";
+
+}  // namespace install_record
+}  // namespace pushy
+
+#endif  // PUSHY_PATCH_CORE_INSTALL_RECORD_H_

package/cpp/update_flow_core/flow_json.h

@@ -53,6 +53,7 @@ class Value {
   bool IsUndefined() const { return kind_ == Kind::Undefined; }
   bool IsArray() const { return kind_ == Kind::Array; }
   bool IsObject() const { return kind_ == Kind::Object; }
+  bool IsBool() const { return kind_ == Kind::Bool; }
   bool IsNumber() const { return kind_ == Kind::Number; }
   bool IsString() const { return kind_ == Kind::String; }
 

package/cpp/update_flow_core/update_flow_core.cpp

@@ -148,6 +148,15 @@ Value OrderEndpointCandidates(const Value& endpoints, double randomSample) {
 
 Value BuildCheckRequestBody(const Value& input) {
   Value body = Value::Object();
+  // Caller extras go in FIRST: they may add fields but never override the
+  // identity fields the server keys its decision on (mirrors the TS
+  // `{ ...extra, packageVersion, hash, ... }` spread, including key order).
+  const Value& extra = input.Get("extra");
+  if (extra.IsObject()) {
+    for (const auto& member : extra.members()) {
+      body.Set(member.first, member.second);
+    }
+  }
   body.Set("packageVersion", input.Get("packageVersion"));
   body.Set("hash", input.Get("currentVersion"));
   body.Set("buildTime", input.Get("buildTime"));
@@ -155,20 +164,27 @@ Value BuildCheckRequestBody(const Value& input) {
   const Value& diffV = input.Get("supportedDiffVersion");
   if (diffV.Truthy()) {
     body.Set("diffV", diffV);
+  } else {
+    body.Remove("diffV");
   }
   const Value& bundleHash = input.Get("bundleHash");
   if (bundleHash.Truthy()) {
     body.Set("bundleHash", bundleHash);
-  }
-  const Value& extra = input.Get("extra");
-  if (extra.IsObject()) {
-    for (const auto& member : extra.members()) {
-      body.Set(member.first, member.second);
-    }
+  } else {
+    body.Remove("bundleHash");
   }
   if (input.Get("isDev").Truthy()) {
     body.Remove("buildTime");
   }
+  // Transitional dual form (mirrors the TS side): nested copy of the caller
+  // extras next to the legacy root-level spread.
+  if (extra.IsObject() && !extra.members().empty()) {
+    Value nested = Value::Object();
+    for (const auto& member : extra.members()) {
+      nested.Set(member.first, member.second);
+    }
+    body.Set("extra", std::move(nested));
+  }
   return body;
 }
 
@@ -280,12 +296,30 @@ bool ShouldActivateAfterDownload(const Value& info,
          info.Get("config").Get("forceBoot").Truthy();
 }
 
+bool IsValidCheckResult(const Value& root) {
+  if (!root.IsObject()) {
+    return false;
+  }
+  const Value& upToDate = root.Get("upToDate");
+  const Value& update = root.Get("update");
+  const Value& expired = root.Get("expired");
+  const Value& paused = root.Get("paused");
+  return upToDate.IsBool() || update.IsBool() || expired.IsBool() ||
+         paused.IsString();
+}
+
+bool IsValidCheckResponse(const std::string& responseText) {
+  bool ok = false;
+  Value root = flowjson::Parse(responseText, &ok);
+  return ok && IsValidCheckResult(root);
+}
+
 Value HandleCheckResponse(const std::string& responseText,
                           const Value& identity, bool isDev,
                           const std::string& afterDownload) {
   bool ok = false;
   Value root = flowjson::Parse(responseText, &ok);
-  if (!ok || !root.IsObject()) {
+  if (!ok || !IsValidCheckResult(root)) {
     return DeclineDownload("invalidResponse");
   }
   Value resolved = ResolveCheckResult(root, identity);

package/cpp/update_flow_core/update_flow_core.h

@@ -56,6 +56,15 @@ flowjson::Value DecideDownload(const flowjson::Value& info,
 // JS, so activation cannot wait for it). Native-only; the device-local
 // rolledBackVersion guard in DecideDownload still wins, and the activated
 // version keeps the first_time crash-protection rollback.
+// Schema gate for a checkUpdate response. A valid response is a JSON object
+// carrying at least one verdict field of the expected type: `upToDate`,
+// `update` or `expired` (boolean), or `paused` (string). Anything else — an
+// array, `{"error": "..."}`, an HTML page that happened to parse — is a
+// failed endpoint and must not stop the endpoint fallback. Mirrors
+// src/updateFlowCore.ts isValidCheckResult.
+bool IsValidCheckResult(const flowjson::Value& root);
+bool IsValidCheckResponse(const std::string& responseText);
+
 bool ShouldActivateAfterDownload(const flowjson::Value& info,
                                  const std::string& afterDownload);
 

package/cpp/update_flow_core/update_flow_jni.cpp

@@ -104,6 +104,18 @@ Java_cn_reactnative_modules_update_NativeUpdateFlow_orderEndpointCandidates(
                             endpoints, randomSample)));
 }
 
+extern "C" JNIEXPORT jboolean JNICALL
+Java_cn_reactnative_modules_update_NativeUpdateFlow_isValidCheckResponse(
+    JNIEnv* env, jclass, jstring responseText) {
+  if (responseText == nullptr) {
+    return JNI_FALSE;
+  }
+  return updateflow::IsValidCheckResponse(
+             pushy::jni_util::JStringToString(env, responseText))
+             ? JNI_TRUE
+             : JNI_FALSE;
+}
+
 extern "C" JNIEXPORT jstring JNICALL
 Java_cn_reactnative_modules_update_NativeUpdateFlow_handleCheckResponse(
     JNIEnv* env, jclass, jstring responseText, jstring identityJson,

package/harmony/pushy/src/main/cpp/PushyTurboModule.cpp

@@ -67,6 +67,7 @@ PUSHY_ASYNC_METHOD(downloadAndInstallApk)
 // on Harmony. Every new spec method MUST be registered here.
 PUSHY_ASYNC_METHOD(syncNativeConfig)
 PUSHY_ASYNC_METHOD(getNativeCheckCache)
+PUSHY_ASYNC_METHOD(markJsCheckCompleted)
 PUSHY_ASYNC_METHOD(getBundleHash)
 PUSHY_ASYNC_METHOD(resetToPackagedBundle)
 
@@ -104,6 +105,7 @@ PushyTurboModule::PushyTurboModule(
   registerMethod("removeListeners", 1, HostFunction_removeListeners);
   registerMethod("syncNativeConfig", 1, HostFunction_syncNativeConfig);
   registerMethod("getNativeCheckCache", 0, HostFunction_getNativeCheckCache);
+  registerMethod("markJsCheckCompleted", 1, HostFunction_markJsCheckCompleted);
   registerMethod("getBundleHash", 0, HostFunction_getBundleHash);
   registerMethod(
       "resetToPackagedBundle", 0, HostFunction_resetToPackagedBundle);

package/harmony/pushy/src/main/cpp/pushy.cpp

@@ -896,6 +896,25 @@ bool ExportFunction(
 
 // sha256(Uint8Array | ArrayBuffer) -> 小写 hex。同步：bundleHash 的输入是
 // rawfile 里的 bundle(已整体读入内存,与 pdiff 的读法一致),哈希本身毫秒级。
+static napi_value MakeUtf8String(napi_env env, const std::string& value);
+
+// Streaming file digest (bounded memory) for the install record.
+static napi_value Sha256HexFile(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1] = {nullptr};
+  if (!GetArgCount(env, info, &argc, args) || argc < 1) {
+    ThrowError(env, "sha256HexFile: missing path argument");
+    return nullptr;
+  }
+  bool ok = false;
+  std::string path = GetString(env, args[0], &ok);
+  if (!ok) {
+    ThrowError(env, "sha256HexFile: path must be a string");
+    return nullptr;
+  }
+  return MakeUtf8String(env, pushy::digest::Sha256File(path));
+}
+
 static napi_value Sha256Hex(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1] = {nullptr};
@@ -1060,6 +1079,22 @@ static napi_value FlowOrderEndpointCandidates(napi_env env,
                             endpoints, sample)));
 }
 
+static napi_value FlowIsValidCheckResponse(napi_env env,
+                                           napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1] = {nullptr};
+  if (!GetArgCount(env, info, &argc, args) || argc < 1) {
+    ThrowError(env, "isValidCheckResponse: missing arguments");
+    return nullptr;
+  }
+  bool ok = false;
+  std::string response_text = GetString(env, args[0], &ok);
+  napi_value result = nullptr;
+  napi_get_boolean(env, ok && updateflow::IsValidCheckResponse(response_text),
+                   &result);
+  return result;
+}
+
 static napi_value FlowHandleCheckResponse(napi_env env,
                                           napi_callback_info info) {
   size_t argc = 3;
@@ -1099,10 +1134,12 @@ napi_value Init(napi_env env, napi_value exports) {
       !ExportFunction(env, exports, "applyPatchFromFileSource", ApplyPatchFromFileSource) ||
       !ExportFunction(env, exports, "cleanupOldEntries", CleanupOldEntries) ||
       !ExportFunction(env, exports, "sha256Hex", Sha256Hex) ||
+      !ExportFunction(env, exports, "sha256HexFile", Sha256HexFile) ||
       !ExportFunction(env, exports, "crc32", Crc32) ||
       !ExportFunction(env, exports, "getSupportedDiffVersion", GetSupportedDiffVersion) ||
       !ExportFunction(env, exports, "buildCheckRequestBody", FlowBuildCheckRequestBody) ||
       !ExportFunction(env, exports, "orderEndpointCandidates", FlowOrderEndpointCandidates) ||
+      !ExportFunction(env, exports, "isValidCheckResponse", FlowIsValidCheckResponse) ||
       !ExportFunction(env, exports, "handleCheckResponse", FlowHandleCheckResponse)) {
     return nullptr;
   }