react-native-update 10.59.2 → 10.60.0

package/cpp/update_flow_core/native_round.cpp

@@ -0,0 +1,326 @@
+#include "native_round.h"
+
+#include <cmath>
+#include <utility>
+
+#include "../patch_core/hbc_transform_wire.h"
+#include "../patch_core/obscured_text.h"
+#include "native_config.h"
+#include "update_flow_core.h"
+
+namespace flowcore {
+
+using flowjson::Value;
+
+namespace {
+
+// Stored encoded (see obscured_text.h).
+const std::string& QueryPath() {
+  static const std::string value = pushy::text::Reveal("7514fcd4ad805d55263e08fc99");
+  return value;
+}
+const std::string& InfoForceBoot() {
+  static const std::string value =
+      pushy::text::Reveal("3c18e6d2aba9674a360d19ead5a695");
+  return value;
+}
+
+// The lists NextQueryStep walks, in order; the state's "list" names the
+// current one ("" once the query is over).
+const char kEndpoints[] = "endpoints";
+const char kQueryUrls[] = "queryUrls";
+const char kRemote[] = "remote";
+
+bool HasPrefixIgnoringAsciiCase(const std::string& text, const char* prefix) {
+  size_t i = 0;
+  for (; prefix[i] != '\0'; i++) {
+    if (i >= text.size()) {
+      return false;
+    }
+    char c = text[i];
+    if (c >= 'A' && c <= 'Z') {
+      c = static_cast<char>(c - 'A' + 'a');
+    }
+    if (c != prefix[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IsHttpsUrl(const std::string& url) {
+  return HasPrefixIgnoringAsciiCase(url, "https://");
+}
+
+bool IsCleartextUrl(const std::string& url) {
+  return HasPrefixIgnoringAsciiCase(url, "http://");
+}
+
+std::string StripTrailingSlashes(std::string url) {
+  while (!url.empty() && url.back() == '/') {
+    url.pop_back();
+  }
+  return url;
+}
+
+Value StringOr(const Value& value, const char* fallback) {
+  return value.IsString() ? value : Value::String(fallback);
+}
+
+// A non-negative integral state counter; anything else reads as 0.
+size_t Counter(const Value& value) {
+  const double number = value.AsNumber();
+  if (!value.IsNumber() || !std::isfinite(number) || number < 0) {
+    return 0;
+  }
+  return number >= 1e15 ? static_cast<size_t>(1e15)
+                        : static_cast<size_t>(number);
+}
+
+// { packageVersion, currentVersion, uuid, rolledBackVersion } — what
+// HandleResponse keys its decision on.
+Value Identity(const Value& config, const Value& env) {
+  const Value& configured = config.Get("packageVersion");
+  Value identity = Value::Object();
+  identity.Set("packageVersion",
+               configured.IsString() && !configured.AsString().empty()
+                   ? configured
+                   : env.Get("packageVersion"));
+  identity.Set("currentVersion", env.Get("currentVersion"));
+  identity.Set("uuid", StringOr(env.Get("uuid"), ""));
+  identity.Set("rolledBackVersion", env.Get("rolledBackVersion"));
+  return identity;
+}
+
+std::string RequestBody(const Value& config, const Value& env) {
+  const Value identity = Identity(config, env);
+  Value cInfo = Value::Object();
+  cInfo.Set("rnu", StringOr(config.Get("rnu"), ""));
+  cInfo.Set("rn", StringOr(config.Get("rn"), ""));
+  cInfo.Set("os", env.Get("os"));
+  cInfo.Set("uuid", identity.Get("uuid"));
+  Value input = Value::Object();
+  input.Set("packageVersion", identity.Get("packageVersion"));
+  input.Set("currentVersion", env.Get("currentVersion"));
+  input.Set("buildTime", env.Get("buildTime"));
+  input.Set("cInfo", std::move(cInfo));
+  input.Set("supportedDiffVersion",
+            Value::Number(pushy::hbc::kSupportedDiffVersion));
+  input.Set("bundleHash", env.Get("bundleHash"));
+  return flowjson::Stringify(BuildRequestBody(input));
+}
+
+bool Contains(const Value& list, const std::string& text) {
+  for (const Value& entry : list.elements()) {
+    if (entry.AsString() == text) {
+      return true;
+    }
+  }
+  return false;
+}
+
+Value PlanAttempts(const Value& attempts, bool hasOrigin, bool httpsOnly) {
+  Value planned = Value::Array();
+  for (const Value& attempt : attempts.elements()) {
+    // diff patches the running version; with none running it cannot apply.
+    if (attempt.Get("type").AsString() == "diff" && !hasOrigin) {
+      continue;
+    }
+    Value urls = Value::Array();
+    for (const Value& url : attempt.Get("urls").elements()) {
+      if (url.IsString() && !url.AsString().empty() &&
+          !(httpsOnly && IsCleartextUrl(url.AsString()))) {
+        urls.Push(url);
+      }
+    }
+    if (urls.Size() > 0) {
+      Value kept = Value::Object();
+      kept.Set("type", attempt.Get("type"));
+      kept.Set("urls", std::move(urls));
+      planned.Push(std::move(kept));
+    }
+  }
+  return planned;
+}
+
+Value VersionInfo(const Value& info) {
+  Value hashInfo = Value::Object();
+  for (const char* key : {"name", "description", "metaInfo"}) {
+    if (info.Get(key).IsString()) {
+      hashInfo.Set(key, info.Get(key));
+    }
+  }
+  // A forceBoot activation is the brick-rescue path: JS reports it once
+  // this version survives to markSuccess. Only the server's directive counts
+  // — a silent-strategy activation is ordinary delivery.
+  if (info.Get("config").Get("forceBoot").Truthy()) {
+    hashInfo.Set(InfoForceBoot(), Value::Bool(true));
+  }
+  return hashInfo;
+}
+
+}  // namespace
+
+bool IsHttpsOnly(const Value& endpoints) {
+  if (endpoints.elements().empty()) {
+    return false;
+  }
+  for (const Value& endpoint : endpoints.elements()) {
+    if (!endpoint.IsString() || !IsHttpsUrl(endpoint.AsString())) {
+      return false;
+    }
+  }
+  return true;
+}
+
+Value PrepareRound(const std::string& configJson, const Value& env,
+                   double randomSample) {
+  RunnableConfig gate = ParseRunnableConfig(configJson);
+  if (!gate.runnable() || !env.IsObject()) {
+    return Value::Undefined();
+  }
+  const Value& config = gate.config;
+  const Value& queryUrls = config.Get(kQueryUrls);
+  Value query = Value::Object();
+  query.Set("appKey", Value::String(gate.appKey));
+  query.Set("httpsOnly", Value::Bool(IsHttpsOnly(config.Get(kEndpoints))));
+  query.Set(kEndpoints,
+            OrderEndpointCandidates(config.Get(kEndpoints), randomSample));
+  query.Set(kQueryUrls, queryUrls.IsArray() ? queryUrls : Value::Array());
+  query.Set("list", Value::String(kEndpoints));
+  query.Set("next", Value::Number(0));
+  query.Set("tried", Value::Array());
+  query.Set("spent", Value::Number(0));
+
+  Value round = Value::Object();
+  round.Set("body", Value::String(RequestBody(config, env)));
+  round.Set("query", std::move(query));
+  return round;
+}
+
+Value NextQueryStep(const Value& previous, const Value& responseText) {
+  if (!previous.IsObject()) {
+    return Value::Undefined();
+  }
+  Value state = previous;
+  if (state.Get("url").IsString()) {
+    const bool post = state.Get("post").Truthy();
+    state.Remove("url");
+    state.Remove("post");
+    if (responseText.IsString()) {
+      if (post && IsValidResponse(responseText.AsString())) {
+        state.Set("found", Value::Bool(true));
+      } else if (!post) {
+        bool ok = false;
+        Value remote = flowjson::Parse(responseText.AsString(), &ok);
+        if (ok && remote.IsArray()) {
+          state.Set("list", Value::String(kRemote));
+          state.Set(kRemote, std::move(remote));
+          state.Set("next", Value::Number(0));
+        }
+      }
+    }
+  }
+  if (state.Get("found").Truthy()) {
+    return state;
+  }
+  const bool httpsOnly = state.Get("httpsOnly").Truthy();
+  for (;;) {
+    const std::string list = state.Get("list").AsString();
+    if (list != kEndpoints && list != kQueryUrls && list != kRemote) {
+      state.Set("list", Value::String(""));
+      return state;
+    }
+    const bool isListOfLists = list == kQueryUrls;
+    const Value& entries = state.Get(list);
+    size_t next = Counter(state.Get("next"));
+    std::string target;
+    while (target.empty() && next < entries.Size()) {
+      const Value& entry = entries.At(next++);
+      if (!entry.IsString()) {
+        continue;
+      }
+      if (isListOfLists) {
+        target = entry.AsString();
+        continue;
+      }
+      std::string base = StripTrailingSlashes(entry.AsString());
+      if (base.empty() || Contains(state.Get("tried"), base)) {
+        continue;
+      }
+      // A remotely injected endpoint must not downgrade an https
+      // configuration to plaintext.
+      if (list == kRemote && httpsOnly && !IsHttpsUrl(base)) {
+        continue;
+      }
+      target = std::move(base);
+    }
+    state.Set("next", Value::Number(static_cast<double>(next)));
+    if (target.empty()) {
+      // The configured endpoints are followed by the list discovery; a
+      // fetched remote list (or running out of lists) ends the query.
+      state.Set("list", Value::String(list == kEndpoints ? kQueryUrls : ""));
+      state.Set("next", Value::Number(0));
+      continue;
+    }
+    const size_t spent = Counter(state.Get("spent"));
+    if (spent >= static_cast<size_t>(kMaxQueryRequests)) {
+      state.Set("list", Value::String(""));
+      return state;
+    }
+    state.Set("spent", Value::Number(static_cast<double>(spent + 1)));
+    if (isListOfLists) {
+      state.Set("url", Value::String(target));
+      state.Set("post", Value::Bool(false));
+    } else {
+      Value tried = state.Get("tried").IsArray() ? state.Get("tried")
+                                                 : Value::Array();
+      tried.Push(Value::String(target));
+      state.Set("tried", std::move(tried));
+      state.Set("url", Value::String(target + QueryPath() +
+                                     state.Get("appKey").AsString()));
+      state.Set("post", Value::Bool(true));
+    }
+    return state;
+  }
+}
+
+Value HandleRoundResponse(const std::string& responseText,
+                          const std::string& configJson, const Value& env,
+                          const std::string& requestBody,
+                          double responseAtSeconds) {
+  bool ok = false;
+  const Value config = flowjson::Parse(configJson, &ok);
+  if (!ok || !config.IsObject() || !env.IsObject()) {
+    return Value::Undefined();
+  }
+  const Value& afterDownload = config.Get("afterDownload");
+  const Value decision = HandleResponse(
+      responseText, Identity(config, env), false,
+      afterDownload.IsString() ? afterDownload.AsString() : std::string());
+
+  Value round = Value::Object();
+  round.Set("action", decision.Get("action"));
+  if (decision.Get("action").AsString() == "download") {
+    round.Set("hash", decision.Get("hash"));
+    round.Set("attempts",
+              PlanAttempts(decision.Get("attempts"),
+                           env.Get("currentVersion").Truthy(),
+                           IsHttpsOnly(config.Get(kEndpoints))));
+    round.Set("activate", decision.Get("activate"));
+    round.Set("hashInfo", VersionInfo(decision.Get("info")));
+  } else {
+    round.Set("reason", decision.Get("reason"));
+  }
+  // Scoped to the exact request and config that produced the response (§10.3);
+  // freshness is anchored to the response's arrival.
+  Value cache = Value::Object();
+  cache.Set("ts", Value::Number(responseAtSeconds));
+  cache.Set("body", Value::String(responseText));
+  cache.Set("request", Value::String(requestBody));
+  cache.Set("config", Value::String(configJson));
+  round.Set("cache", Value::String(flowjson::Stringify(cache)));
+  return round;
+}
+
+}  // namespace flowcore

package/cpp/update_flow_core/native_round.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <string>
+
+#include "flow_json.h"
+
+// The pure steps of the native cold-start round (NATIVE_CHECKUPDATE_DESIGN
+// §10), one implementation for the Android, iOS and Harmony orchestrators:
+// what to send, which endpoint to ask next, and everything a commit needs
+// from the answer. HTTP, timeouts, locks, downloads and persistence stay
+// native. JS has no counterpart (its client builds its own request through
+// src/updateFlowCore.ts buildCheckRequestBody, which BuildRequestBody
+// mirrors); tests/native-round-vectors.json pins this layer.
+//
+// `config` is the persisted config text (already through
+// ParseRunnableConfig). `env` is what the platform knows about this launch,
+// as a JSON object:
+//   packageVersion     the binary's package version
+//   currentVersion     the running version exactly as the platform's JS
+//                      constant reports it (Android null, iOS absent,
+//                      Harmony "" when none), so the request matches the one
+//                      JS builds and JS can reuse the response cache
+//   uuid               missing -> ""
+//   rolledBackVersion  the launch-path rollback snapshot
+//   buildTime          passed through
+//   os                 "<platform> <Platform.Version>", as JS cInfo.os
+//   bundleHash         omitted from the request when empty
+// Keep the core internal to whichever binary links it (see podspec Core).
+#pragma GCC visibility push(hidden)
+
+namespace flowcore {
+
+// Total HTTP requests one query may issue: endpoint queries and remote list
+// fetches alike.
+constexpr int kMaxQueryRequests = 8;
+
+// {"body": "<checkUpdate request text>", "query": <first NextQueryStep
+// state>}. The body is BuildRequestBody over the config and env: a non-empty
+// string config.packageVersion overrides env.packageVersion, cInfo.rnu/rn are
+// the config's strings ("" otherwise), diffV is this core's
+// kSupportedDiffVersion. randomSample ∈ [0, 1) picks the first endpoint
+// (OrderEndpointCandidates). Undefined when the config is not runnable or
+// env is not an object.
+flowjson::Value PrepareRound(const std::string& configJson,
+                             const flowjson::Value& env, double randomSample);
+
+// One step of the sequential endpoint fallback (§5.1). Pass the previous
+// state and the text the request it named returned (Undefined when it failed
+// or none was made). The result is the next state, with
+//   "url" (and "post"): issue that request — a POST of the round's body for
+//       an endpoint query, a GET for a remote endpoint list — then call again;
+//   "found": true: the text just passed in is the valid check response;
+//   neither: no endpoint answered; the query is over.
+// Policy: the configured endpoints in sampled order, then the first
+// queryUrls list that fetches and parses as a JSON array, whose entries are
+// queried in turn (one list is enough). Bases are stripped of trailing '/'
+// and asked once each; entries that are not strings are skipped; a remote
+// entry must be https when every configured endpoint is (IsHttpsOnly), so the
+// network cannot downgrade the round. A response counts only when
+// IsValidResponse accepts it. At most kMaxQueryRequests requests. Undefined
+// for a state that is not an object.
+flowjson::Value NextQueryStep(const flowjson::Value& state,
+                              const flowjson::Value& responseText);
+
+// Every configured endpoint is an https URL (ASCII case-insensitive); false
+// for an empty or missing list.
+bool IsHttpsOnly(const flowjson::Value& endpoints);
+
+// HandleResponse for the round, plus what each commit needs:
+//   {action: "none", reason, cache}
+//   {action: "download", hash, attempts, activate, hashInfo, cache}
+// attempts are planned for this device: no diff attempt without a running
+// version (env.currentVersion falsy), no cleartext http:// URL when the
+// config IsHttpsOnly; strategies left without a URL are dropped. hashInfo is
+// the version info to persist next to the download (the JS side's
+// setLocalHashInfo): the info's string name/description/metaInfo, plus
+// forceBootRescue when the server's config.forceBoot is truthy (the same
+// truthiness that activates it). cache is the response-cache text JS reuses
+// ({ts, body, request, config}). afterDownload is the config's string
+// (otherwise ""). Undefined when the config is not a JSON object or env is
+// not an object.
+flowjson::Value HandleRoundResponse(const std::string& responseText,
+                                    const std::string& configJson,
+                                    const flowjson::Value& env,
+                                    const std::string& requestBody,
+                                    double responseAtSeconds);
+
+}  // namespace flowcore
+
+#pragma GCC visibility pop

package/cpp/update_flow_core/update_flow_core.h

@@ -81,8 +81,8 @@ bool ShouldActivateAfterDownload(const flowjson::Value& info,
                                  const std::string& afterDownload);
 
 // Composes Parse → ResolveResult → DecideDownload: one call from the
-// raw checkUpdate response text to a download decision, so the platform
-// orchestrators contain no decision logic at all. identity is the union of
+// raw checkUpdate response text to a download decision (the native round
+// reaches it through HandleRoundResponse, native_round.h). identity is the union of
 // both composed functions' needs: { packageVersion, currentVersion?, uuid,
 // rolledBackVersion? }. afterDownload is the client's persisted activation
 // policy; a download decision carries `activate` (ShouldActivateAfterDownload

package/harmony/hvigor-plugin.ts

@@ -156,26 +156,18 @@ export function reactNativeUpdatePlugin() {
         console.log(`Build time written to ${metaFilePath} (${buildMode})`);
       };
 
-      if (typeof safeNode.registerTask === 'function') {
-        try {
-          safeNode.registerTask({
-            name: TASK_NAME,
-            run: writeMeta,
-            dependencies: ['default@PreBuild'],
-            postDependencies: ['default@ProcessResource'],
-          });
-          return;
-        } catch (e) {
-          console.warn(
-            `reactNativeUpdatePlugin: task registration failed (${
-              e instanceof Error ? e.message : String(e)
-            }), writing meta.json at apply time`,
-          );
-        }
+      if (typeof safeNode.registerTask !== 'function') {
+        throw new Error(
+          'reactNativeUpdatePlugin: this hvigor cannot register build tasks; ' +
+            'apply the plugin from a module hvigorfile with hvigor 5 or later.',
+        );
       }
-      // Very old hvigor without task registration: keep the previous
-      // behaviour (write at apply time), still only for assemble builds.
-      writeMeta();
+      safeNode.registerTask({
+        name: TASK_NAME,
+        run: writeMeta,
+        dependencies: ['default@PreBuild'],
+        postDependencies: ['default@ProcessResource'],
+      });
     },
   };
 }

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

@@ -7,38 +7,31 @@ set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 set(CMAKE_VERBOSE_MAKEFILE on)
 
+# The shared native sources are compiled in place from the repository root
+# (or the npm package root, which ships cpp/ and the android/jni submodules).
 set(REPO_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../../../../../)
-set(STAGED_NATIVE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/android-generated)
-set(ANDROID_JNI_DIR ${REPO_ROOT}/android/jni)
-if(NOT EXISTS ${ANDROID_JNI_DIR}/hpatch.c)
-    set(ANDROID_JNI_DIR ${STAGED_NATIVE_DIR}/jni)
-endif()
 set(PATCH_CORE_DIR ${REPO_ROOT}/cpp/patch_core)
-if(NOT EXISTS ${PATCH_CORE_DIR}/patch_core.cpp)
-    set(PATCH_CORE_DIR ${STAGED_NATIVE_DIR}/patch_core)
-endif()
 set(UPDATE_FLOW_CORE_DIR ${REPO_ROOT}/cpp/update_flow_core)
-if(NOT EXISTS ${UPDATE_FLOW_CORE_DIR}/update_flow_core.cpp)
-    set(UPDATE_FLOW_CORE_DIR ${STAGED_NATIVE_DIR}/update_flow_core)
-endif()
+set(HPATCH_DIR ${REPO_ROOT}/cpp/hpatch)
+set(HDIFFPATCH_DIR ${REPO_ROOT}/android/jni/HDiffPatch)
+set(LZMA_DIR ${REPO_ROOT}/android/jni/lzma)
 
 # Always compile from source. A prebuilt-import branch used to live here, but
 # it had no symbol verification: a stale libs/<abi>/librnpushy.so missing a
 # newly added export (e.g. getSupportedDiffVersion) would silently ship and
 # crash getConstants at runtime.
-set(HDIFFPATCH_DIR ${ANDROID_JNI_DIR}/HDiffPatch)
-set(LZMA_DIR ${ANDROID_JNI_DIR}/lzma)
+#
+# The platform-neutral cores are picked up by directory (non-recursive, so
+# tests/ stays out; the Android JNI glue lives in cpp/android_jni), so a new
+# core source needs no edit here. CONFIGURE_DEPENDS re-globs on every build.
+file(GLOB CORE_SOURCES CONFIGURE_DEPENDS
+     ${PATCH_CORE_DIR}/*.cpp
+     ${UPDATE_FLOW_CORE_DIR}/*.cpp
+     ${HPATCH_DIR}/*.c
+)
 set(HDP_SOURCES
      ${CMAKE_CURRENT_SOURCE_DIR}/pushy.cpp
-     ${PATCH_CORE_DIR}/archive_patch_core.cpp
-     ${PATCH_CORE_DIR}/digest.cpp
-     ${PATCH_CORE_DIR}/hbc_transform.cpp
-     ${PATCH_CORE_DIR}/hbc_transform_wire.cpp
-     ${PATCH_CORE_DIR}/patch_core.cpp
-     ${PATCH_CORE_DIR}/state_core.cpp
-     ${UPDATE_FLOW_CORE_DIR}/flow_json.cpp
-     ${UPDATE_FLOW_CORE_DIR}/update_flow_core.cpp
-     ${ANDROID_JNI_DIR}/hpatch.c
+     ${CORE_SOURCES}
      ${HDIFFPATCH_DIR}/libHDiffPatch/HPatch/patch.c
      ${HDIFFPATCH_DIR}/file_for_patch.c
      ${LZMA_DIR}/C/LzmaDec.c
@@ -49,14 +42,12 @@ add_library(rnpushy SHARED
     ${HDP_SOURCES}
 )
 
+# pushy.cpp includes the cores by name; the cores themselves (and hpatch's
+# HDiffPatch/lzma includes) resolve file-relative.
 target_include_directories(rnpushy PRIVATE
      ${CMAKE_CURRENT_SOURCE_DIR}
      ${PATCH_CORE_DIR}
      ${UPDATE_FLOW_CORE_DIR}
-     ${ANDROID_JNI_DIR}
-     ${HDIFFPATCH_DIR}
-     ${HDIFFPATCH_DIR}/libHDiffPatch/HPatch
-     ${LZMA_DIR}/C
 )
 
 target_link_libraries(rnpushy PUBLIC

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

@@ -22,8 +22,8 @@
  * SOFTWARE.
  */
 
-#ifndef GEO_LOCATION_PACKAGE_H
-#define GEO_LOCATION_PACKAGE_H
+#ifndef PUSHY_PACKAGE_H
+#define PUSHY_PACKAGE_H
 
 #include "RNOH/Package.h"
 #include "PushyTurboModule.h"