react-native-update 10.38.3 → 10.38.4

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

@@ -0,0 +1,856 @@
+#include <napi/native_api.h>
+#include <js_native_api.h>
+#include <js_native_api_types.h>
+
+#include <string>
+#include <vector>
+
+#include "archive_patch_core.h"
+#include "patch_core.h"
+#include "state_core.h"
+
+extern "C" {
+#include "hpatch.h"
+}
+
+namespace {
+
+enum class StateOperation {
+  kSwitchVersion = 1,
+  kMarkSuccess = 2,
+  kRollback = 3,
+  kClearFirstTime = 4,
+  kClearRollbackMark = 5,
+  kResolveLaunch = 6,
+};
+
+constexpr const char* kDefaultBundlePatchEntryName = "index.bundlejs.patch";
+
+void ThrowError(napi_env env, const std::string& message) {
+  napi_throw_error(env, nullptr, message.c_str());
+}
+
+bool GetArgCount(
+    napi_env env,
+    napi_callback_info info,
+    size_t* argc,
+    napi_value* args) {
+  return napi_get_cb_info(env, info, argc, args, nullptr, nullptr) == napi_ok;
+}
+
+bool GetValueType(
+    napi_env env,
+    napi_value value,
+    napi_valuetype* out_type) {
+  return napi_typeof(env, value, out_type) == napi_ok;
+}
+
+bool IsNullOrUndefined(napi_env env, napi_value value) {
+  napi_valuetype type = napi_undefined;
+  if (!GetValueType(env, value, &type)) {
+    return true;
+  }
+  return type == napi_undefined || type == napi_null;
+}
+
+std::string GetString(napi_env env, napi_value value, bool* ok) {
+  if (ok != nullptr) {
+    *ok = false;
+  }
+  if (value == nullptr || IsNullOrUndefined(env, value)) {
+    if (ok != nullptr) {
+      *ok = true;
+    }
+    return std::string();
+  }
+
+  napi_valuetype type = napi_undefined;
+  if (!GetValueType(env, value, &type) || type != napi_string) {
+    ThrowError(env, "Expected string");
+    return std::string();
+  }
+
+  size_t length = 0;
+  if (napi_get_value_string_utf8(env, value, nullptr, 0, &length) != napi_ok) {
+    ThrowError(env, "Failed to read string");
+    return std::string();
+  }
+
+  std::string result(length, '\0');
+  size_t written = 0;
+  if (napi_get_value_string_utf8(
+          env, value, result.data(), length + 1, &written) != napi_ok) {
+    ThrowError(env, "Failed to read string");
+    return std::string();
+  }
+  result.resize(written);
+  if (ok != nullptr) {
+    *ok = true;
+  }
+  return result;
+}
+
+bool GetInt32(napi_env env, napi_value value, int32_t* out_value) {
+  if (value == nullptr || out_value == nullptr) {
+    ThrowError(env, "Expected number");
+    return false;
+  }
+  napi_valuetype type = napi_undefined;
+  if (!GetValueType(env, value, &type) || type != napi_number) {
+    ThrowError(env, "Expected number");
+    return false;
+  }
+  if (napi_get_value_int32(env, value, out_value) != napi_ok) {
+    ThrowError(env, "Failed to read number");
+    return false;
+  }
+  return true;
+}
+
+bool GetBoolean(napi_env env, napi_value value, bool* out_value) {
+  if (out_value == nullptr) {
+    ThrowError(env, "Expected boolean");
+    return false;
+  }
+  if (value == nullptr || IsNullOrUndefined(env, value)) {
+    *out_value = false;
+    return true;
+  }
+  napi_valuetype type = napi_undefined;
+  if (!GetValueType(env, value, &type) || type != napi_boolean) {
+    ThrowError(env, "Expected boolean");
+    return false;
+  }
+  bool result = false;
+  if (napi_get_value_bool(env, value, &result) != napi_ok) {
+    ThrowError(env, "Failed to read boolean");
+    return false;
+  }
+  *out_value = result;
+  return true;
+}
+
+bool HasNamedProperty(napi_env env, napi_value object, const char* name, bool* out_has) {
+  if (out_has == nullptr) {
+    ThrowError(env, "Internal error");
+    return false;
+  }
+  bool has = false;
+  if (napi_has_named_property(env, object, name, &has) != napi_ok) {
+    ThrowError(env, std::string("Failed to read property ") + name);
+    return false;
+  }
+  *out_has = has;
+  return true;
+}
+
+bool GetNamedProperty(
+    napi_env env,
+    napi_value object,
+    const char* name,
+    napi_value* out_value) {
+  if (out_value == nullptr) {
+    ThrowError(env, "Internal error");
+    return false;
+  }
+  if (napi_get_named_property(env, object, name, out_value) != napi_ok) {
+    ThrowError(env, std::string("Failed to read property ") + name);
+    return false;
+  }
+  return true;
+}
+
+bool GetOptionalStringProperty(
+    napi_env env,
+    napi_value object,
+    const char* name,
+    std::string* out_value) {
+  bool has = false;
+  if (!HasNamedProperty(env, object, name, &has)) {
+    return false;
+  }
+  if (!has) {
+    out_value->clear();
+    return true;
+  }
+
+  napi_value property = nullptr;
+  if (!GetNamedProperty(env, object, name, &property)) {
+    return false;
+  }
+
+  bool ok = false;
+  *out_value = GetString(env, property, &ok);
+  return ok;
+}
+
+bool GetOptionalBoolProperty(
+    napi_env env,
+    napi_value object,
+    const char* name,
+    bool default_value,
+    bool* out_value) {
+  bool has = false;
+  if (!HasNamedProperty(env, object, name, &has)) {
+    return false;
+  }
+  if (!has) {
+    *out_value = default_value;
+    return true;
+  }
+
+  napi_value property = nullptr;
+  if (!GetNamedProperty(env, object, name, &property)) {
+    return false;
+  }
+  return GetBoolean(env, property, out_value);
+}
+
+bool GetStringArray(
+    napi_env env,
+    napi_value value,
+    std::vector<std::string>* out_values) {
+  out_values->clear();
+  if (value == nullptr || IsNullOrUndefined(env, value)) {
+    return true;
+  }
+
+  bool is_array = false;
+  if (napi_is_array(env, value, &is_array) != napi_ok || !is_array) {
+    ThrowError(env, "Expected string array");
+    return false;
+  }
+
+  uint32_t length = 0;
+  if (napi_get_array_length(env, value, &length) != napi_ok) {
+    ThrowError(env, "Failed to read array length");
+    return false;
+  }
+
+  out_values->reserve(length);
+  for (uint32_t index = 0; index < length; ++index) {
+    napi_value item = nullptr;
+    if (napi_get_element(env, value, index, &item) != napi_ok) {
+      ThrowError(env, "Failed to read array item");
+      return false;
+    }
+    bool ok = false;
+    out_values->push_back(GetString(env, item, &ok));
+    if (!ok) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool GetOptionalStringArrayProperty(
+    napi_env env,
+    napi_value object,
+    const char* name,
+    std::vector<std::string>* out_values) {
+  bool has = false;
+  if (!HasNamedProperty(env, object, name, &has)) {
+    return false;
+  }
+  if (!has) {
+    out_values->clear();
+    return true;
+  }
+
+  napi_value property = nullptr;
+  if (!GetNamedProperty(env, object, name, &property)) {
+    return false;
+  }
+  return GetStringArray(env, property, out_values);
+}
+
+bool GetObject(napi_env env, napi_value value) {
+  if (value == nullptr || IsNullOrUndefined(env, value)) {
+    return true;
+  }
+  napi_valuetype type = napi_undefined;
+  if (!GetValueType(env, value, &type) || type != napi_object) {
+    ThrowError(env, "Expected object");
+    return false;
+  }
+  return true;
+}
+
+pushy::state::State ReadState(napi_env env, napi_value value, bool* ok) {
+  if (ok != nullptr) {
+    *ok = false;
+  }
+  pushy::state::State state;
+  if (value == nullptr || IsNullOrUndefined(env, value)) {
+    if (ok != nullptr) {
+      *ok = true;
+    }
+    return state;
+  }
+  if (!GetObject(env, value)) {
+    return state;
+  }
+
+  if (!GetOptionalStringProperty(env, value, "packageVersion", &state.package_version) ||
+      !GetOptionalStringProperty(env, value, "buildTime", &state.build_time) ||
+      !GetOptionalStringProperty(env, value, "currentVersion", &state.current_version) ||
+      !GetOptionalStringProperty(env, value, "lastVersion", &state.last_version) ||
+      !GetOptionalBoolProperty(env, value, "firstTime", false, &state.first_time) ||
+      !GetOptionalBoolProperty(env, value, "firstTimeOk", true, &state.first_time_ok) ||
+      !GetOptionalStringProperty(env, value, "rolledBackVersion", &state.rolled_back_version)) {
+    return state;
+  }
+
+  if (ok != nullptr) {
+    *ok = true;
+  }
+  return state;
+}
+
+napi_value NewBoolean(napi_env env, bool value) {
+  napi_value result = nullptr;
+  napi_get_boolean(env, value, &result);
+  return result;
+}
+
+napi_value NewString(napi_env env, const std::string& value) {
+  napi_value result = nullptr;
+  napi_create_string_utf8(env, value.c_str(), value.size(), &result);
+  return result;
+}
+
+void SetStringProperty(
+    napi_env env,
+    napi_value object,
+    const char* name,
+    const std::string& value) {
+  if (value.empty()) {
+    return;
+  }
+  napi_set_named_property(env, object, name, NewString(env, value));
+}
+
+void SetBoolProperty(
+    napi_env env,
+    napi_value object,
+    const char* name,
+    bool value) {
+  napi_set_named_property(env, object, name, NewBoolean(env, value));
+}
+
+napi_value NewStateResult(
+    napi_env env,
+    const pushy::state::State& state,
+    bool changed,
+    const std::string& stale_version_to_delete,
+    const std::string& load_version,
+    bool did_rollback,
+    bool consumed_first_time) {
+  napi_value result = nullptr;
+  napi_create_object(env, &result);
+
+  SetStringProperty(env, result, "packageVersion", state.package_version);
+  SetStringProperty(env, result, "buildTime", state.build_time);
+  SetStringProperty(env, result, "currentVersion", state.current_version);
+  SetStringProperty(env, result, "lastVersion", state.last_version);
+  SetBoolProperty(env, result, "firstTime", state.first_time);
+  SetBoolProperty(env, result, "firstTimeOk", state.first_time_ok);
+  SetStringProperty(env, result, "rolledBackVersion", state.rolled_back_version);
+  SetBoolProperty(env, result, "changed", changed);
+  SetStringProperty(env, result, "staleVersionToDelete", stale_version_to_delete);
+  SetStringProperty(env, result, "loadVersion", load_version);
+  SetBoolProperty(env, result, "didRollback", did_rollback);
+  SetBoolProperty(env, result, "consumedFirstTime", consumed_first_time);
+  return result;
+}
+
+napi_value NewArchivePatchPlanResult(
+    napi_env env,
+    const pushy::archive_patch::ArchivePatchPlan& plan) {
+  napi_value result = nullptr;
+  napi_create_object(env, &result);
+  SetStringProperty(env, result, "mergeSourceSubdir", plan.merge_source_subdir);
+  SetBoolProperty(env, result, "enableMerge", plan.enable_merge);
+  return result;
+}
+
+napi_value NewCopyGroupArray(
+    napi_env env,
+    const std::vector<pushy::archive_patch::CopyGroup>& groups) {
+  napi_value result = nullptr;
+  napi_create_array_with_length(env, groups.size(), &result);
+  for (size_t index = 0; index < groups.size(); ++index) {
+    napi_value group = nullptr;
+    napi_create_object(env, &group);
+    SetStringProperty(env, group, "from", groups[index].from);
+
+    napi_value to_paths = nullptr;
+    napi_create_array_with_length(env, groups[index].to_paths.size(), &to_paths);
+    for (size_t target_index = 0; target_index < groups[index].to_paths.size();
+         ++target_index) {
+      napi_set_element(
+          env,
+          to_paths,
+          target_index,
+          NewString(env, groups[index].to_paths[target_index]));
+    }
+    napi_set_named_property(env, group, "toPaths", to_paths);
+    napi_set_element(env, result, index, group);
+  }
+  return result;
+}
+
+pushy::patch::PatchManifest BuildManifest(
+    const std::vector<std::string>& copy_froms,
+    const std::vector<std::string>& copy_tos,
+    const std::vector<std::string>& deletes) {
+  pushy::patch::PatchManifest manifest;
+  for (size_t index = 0; index < copy_froms.size(); ++index) {
+    manifest.copies.push_back(
+        pushy::patch::CopyOperation{copy_froms[index], copy_tos[index]});
+  }
+  manifest.deletes = deletes;
+  return manifest;
+}
+
+napi_value HdiffPatch(napi_env env, napi_callback_info info) {
+  napi_value args[2] = {nullptr, nullptr};
+  size_t argc = 2;
+  if (!GetArgCount(env, info, &argc, args) || argc < 2) {
+    ThrowError(env, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  bool is_typed_array = false;
+  if (napi_is_typedarray(env, args[0], &is_typed_array) != napi_ok || !is_typed_array) {
+    ThrowError(env, "First argument must be a TypedArray");
+    return nullptr;
+  }
+
+  uint8_t* origin_ptr = nullptr;
+  size_t origin_length = 0;
+  if (napi_get_typedarray_info(
+          env,
+          args[0],
+          nullptr,
+          &origin_length,
+          reinterpret_cast<void**>(&origin_ptr),
+          nullptr,
+          nullptr) != napi_ok) {
+    ThrowError(env, "Failed to get origin buffer");
+    return nullptr;
+  }
+
+  if (napi_is_typedarray(env, args[1], &is_typed_array) != napi_ok || !is_typed_array) {
+    ThrowError(env, "Second argument must be a TypedArray");
+    return nullptr;
+  }
+
+  uint8_t* patch_ptr = nullptr;
+  size_t patch_length = 0;
+  if (napi_get_typedarray_info(
+          env,
+          args[1],
+          nullptr,
+          &patch_length,
+          reinterpret_cast<void**>(&patch_ptr),
+          nullptr,
+          nullptr) != napi_ok) {
+    ThrowError(env, "Failed to get patch buffer");
+    return nullptr;
+  }
+
+  hpatch_singleCompressedDiffInfo patch_info;
+  if (!((origin_length == 0) || origin_ptr) || !patch_ptr || patch_length == 0) {
+    ThrowError(env, "Corrupt patch");
+    return nullptr;
+  }
+  if (kHPatch_ok != hpatch_getInfo_by_mem(&patch_info, patch_ptr, patch_length)) {
+    ThrowError(env, "Error info in hpatch");
+    return nullptr;
+  }
+  if (origin_length != patch_info.oldDataSize) {
+    ThrowError(env, "Error oldDataSize in hpatch");
+    return nullptr;
+  }
+
+  size_t new_size = static_cast<size_t>(patch_info.newDataSize);
+  if (sizeof(size_t) != sizeof(hpatch_StreamPos_t) &&
+      new_size != patch_info.newDataSize) {
+    ThrowError(env, "Error newDataSize in hpatch");
+    return nullptr;
+  }
+
+  void* output_data = nullptr;
+  napi_value result = nullptr;
+  if (napi_create_arraybuffer(env, new_size, &output_data, &result) != napi_ok) {
+    ThrowError(env, "Failed to create result buffer");
+    return nullptr;
+  }
+
+  if (kHPatch_ok != hpatch_by_mem(
+                       origin_ptr,
+                       origin_length,
+                       static_cast<uint8_t*>(output_data),
+                       new_size,
+                       patch_ptr,
+                       patch_length,
+                       &patch_info)) {
+    ThrowError(env, "hpatch");
+    return nullptr;
+  }
+
+  return result;
+}
+
+napi_value SyncStateWithBinaryVersion(napi_env env, napi_callback_info info) {
+  napi_value args[3] = {nullptr, nullptr, nullptr};
+  size_t argc = 3;
+  if (!GetArgCount(env, info, &argc, args) || argc < 3) {
+    ThrowError(env, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  bool ok = false;
+  const std::string package_version = GetString(env, args[0], &ok);
+  if (!ok) {
+    return nullptr;
+  }
+  const std::string build_time = GetString(env, args[1], &ok);
+  if (!ok) {
+    return nullptr;
+  }
+  const pushy::state::State state = ReadState(env, args[2], &ok);
+  if (!ok) {
+    return nullptr;
+  }
+
+  const pushy::state::BinaryVersionSyncResult result =
+      pushy::state::SyncBinaryVersion(state, package_version, build_time);
+  return NewStateResult(env, result.state, result.changed, std::string(), std::string(), false, false);
+}
+
+napi_value RunStateCore(napi_env env, napi_callback_info info) {
+  napi_value args[5] = {nullptr, nullptr, nullptr, nullptr, nullptr};
+  size_t argc = 5;
+  if (!GetArgCount(env, info, &argc, args) || argc < 2) {
+    ThrowError(env, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  int32_t operation = 0;
+  if (!GetInt32(env, args[0], &operation)) {
+    return nullptr;
+  }
+
+  bool ok = false;
+  const pushy::state::State state = ReadState(env, args[1], &ok);
+  if (!ok) {
+    return nullptr;
+  }
+
+  std::string string_arg;
+  if (argc >= 3) {
+    string_arg = GetString(env, args[2], &ok);
+    if (!ok) {
+      return nullptr;
+    }
+  }
+
+  bool flag_a = false;
+  bool flag_b = false;
+  if (argc >= 4 && !GetBoolean(env, args[3], &flag_a)) {
+    return nullptr;
+  }
+  if (argc >= 5 && !GetBoolean(env, args[4], &flag_b)) {
+    return nullptr;
+  }
+
+  switch (static_cast<StateOperation>(operation)) {
+    case StateOperation::kSwitchVersion:
+      return NewStateResult(
+          env,
+          pushy::state::SwitchVersion(state, string_arg),
+          false,
+          std::string(),
+          std::string(),
+          false,
+          false);
+    case StateOperation::kMarkSuccess: {
+      const pushy::state::MarkSuccessResult result = pushy::state::MarkSuccess(state);
+      return NewStateResult(
+          env,
+          result.state,
+          false,
+          result.stale_version_to_delete,
+          std::string(),
+          false,
+          false);
+    }
+    case StateOperation::kRollback: {
+      const pushy::state::State next = pushy::state::Rollback(state);
+      return NewStateResult(
+          env, next, false, std::string(), next.current_version, true, false);
+    }
+    case StateOperation::kClearFirstTime:
+      return NewStateResult(
+          env,
+          pushy::state::ClearFirstTime(state),
+          false,
+          std::string(),
+          std::string(),
+          false,
+          false);
+    case StateOperation::kClearRollbackMark:
+      return NewStateResult(
+          env,
+          pushy::state::ClearRollbackMark(state),
+          false,
+          std::string(),
+          std::string(),
+          false,
+          false);
+    case StateOperation::kResolveLaunch: {
+      const pushy::state::LaunchDecision decision =
+          pushy::state::ResolveLaunchState(state, flag_a, flag_b);
+      return NewStateResult(
+          env,
+          decision.state,
+          false,
+          std::string(),
+          decision.load_version,
+          decision.did_rollback,
+          decision.consumed_first_time);
+    }
+  }
+
+  ThrowError(env, "Unknown state operation");
+  return nullptr;
+}
+
+napi_value BuildArchivePatchPlan(napi_env env, napi_callback_info info) {
+  napi_value args[6] = {nullptr, nullptr, nullptr, nullptr, nullptr, nullptr};
+  size_t argc = 6;
+  if (!GetArgCount(env, info, &argc, args) || argc < 5) {
+    ThrowError(env, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  int32_t patch_type = 0;
+  if (!GetInt32(env, args[0], &patch_type)) {
+    return nullptr;
+  }
+
+  std::vector<std::string> entry_names;
+  std::vector<std::string> copy_froms;
+  std::vector<std::string> copy_tos;
+  std::vector<std::string> deletes;
+  if (!GetStringArray(env, args[1], &entry_names) ||
+      !GetStringArray(env, args[2], &copy_froms) ||
+      !GetStringArray(env, args[3], &copy_tos) ||
+      !GetStringArray(env, args[4], &deletes)) {
+    return nullptr;
+  }
+  if (copy_froms.size() != copy_tos.size()) {
+    ThrowError(env, "copyFroms and copyTos length mismatch");
+    return nullptr;
+  }
+
+  std::string bundle_patch_entry_name = kDefaultBundlePatchEntryName;
+  if (argc >= 6) {
+    bool ok = false;
+    const std::string candidate = GetString(env, args[5], &ok);
+    if (!ok) {
+      return nullptr;
+    }
+    if (!candidate.empty()) {
+      bundle_patch_entry_name = candidate;
+    }
+  }
+
+  const pushy::patch::PatchManifest manifest =
+      BuildManifest(copy_froms, copy_tos, deletes);
+  pushy::archive_patch::ArchivePatchPlan plan;
+  const pushy::patch::Status status = pushy::archive_patch::BuildArchivePatchPlan(
+      static_cast<pushy::archive_patch::ArchivePatchType>(patch_type),
+      manifest,
+      entry_names,
+      &plan,
+      bundle_patch_entry_name);
+  if (!status.ok) {
+    ThrowError(env, status.message);
+    return nullptr;
+  }
+
+  return NewArchivePatchPlanResult(env, plan);
+}
+
+napi_value BuildCopyGroups(napi_env env, napi_callback_info info) {
+  napi_value args[2] = {nullptr, nullptr};
+  size_t argc = 2;
+  if (!GetArgCount(env, info, &argc, args) || argc < 2) {
+    ThrowError(env, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  std::vector<std::string> copy_froms;
+  std::vector<std::string> copy_tos;
+  if (!GetStringArray(env, args[0], &copy_froms) ||
+      !GetStringArray(env, args[1], &copy_tos)) {
+    return nullptr;
+  }
+  if (copy_froms.size() != copy_tos.size()) {
+    ThrowError(env, "copyFroms and copyTos length mismatch");
+    return nullptr;
+  }
+
+  const pushy::patch::PatchManifest manifest =
+      BuildManifest(copy_froms, copy_tos, std::vector<std::string>());
+  std::vector<pushy::archive_patch::CopyGroup> groups;
+  const pushy::patch::Status status =
+      pushy::archive_patch::BuildCopyGroups(manifest, &groups);
+  if (!status.ok) {
+    ThrowError(env, status.message);
+    return nullptr;
+  }
+
+  return NewCopyGroupArray(env, groups);
+}
+
+napi_value ApplyPatchFromFileSource(napi_env env, napi_callback_info info) {
+  napi_value args[1] = {nullptr};
+  size_t argc = 1;
+  if (!GetArgCount(env, info, &argc, args) || argc < 1) {
+    ThrowError(env, "Wrong number of arguments");
+    return nullptr;
+  }
+  if (!GetObject(env, args[0])) {
+    return nullptr;
+  }
+
+  std::vector<std::string> copy_froms;
+  std::vector<std::string> copy_tos;
+  std::vector<std::string> deletes;
+  std::string source_root;
+  std::string target_root;
+  std::string origin_bundle_path;
+  std::string bundle_patch_path;
+  std::string bundle_output_path;
+  std::string merge_source_subdir;
+  bool enable_merge = true;
+
+  if (!GetOptionalStringArrayProperty(env, args[0], "copyFroms", &copy_froms) ||
+      !GetOptionalStringArrayProperty(env, args[0], "copyTos", &copy_tos) ||
+      !GetOptionalStringArrayProperty(env, args[0], "deletes", &deletes) ||
+      !GetOptionalStringProperty(env, args[0], "sourceRoot", &source_root) ||
+      !GetOptionalStringProperty(env, args[0], "targetRoot", &target_root) ||
+      !GetOptionalStringProperty(env, args[0], "originBundlePath", &origin_bundle_path) ||
+      !GetOptionalStringProperty(env, args[0], "bundlePatchPath", &bundle_patch_path) ||
+      !GetOptionalStringProperty(env, args[0], "bundleOutputPath", &bundle_output_path) ||
+      !GetOptionalStringProperty(env, args[0], "mergeSourceSubdir", &merge_source_subdir) ||
+      !GetOptionalBoolProperty(env, args[0], "enableMerge", true, &enable_merge)) {
+    return nullptr;
+  }
+  if (copy_froms.size() != copy_tos.size()) {
+    ThrowError(env, "copyFroms and copyTos length mismatch");
+    return nullptr;
+  }
+
+  pushy::patch::FileSourcePatchOptions options;
+  options.manifest = BuildManifest(copy_froms, copy_tos, deletes);
+  options.source_root = source_root;
+  options.target_root = target_root;
+  options.origin_bundle_path = origin_bundle_path;
+  options.bundle_patch_path = bundle_patch_path;
+  options.bundle_output_path = bundle_output_path;
+  options.merge_source_subdir = merge_source_subdir;
+  options.enable_merge = enable_merge;
+
+  const pushy::patch::Status status =
+      pushy::patch::ApplyPatchFromFileSource(options);
+  if (!status.ok) {
+    ThrowError(env, status.message);
+    return nullptr;
+  }
+
+  napi_value undefined_value = nullptr;
+  napi_get_undefined(env, &undefined_value);
+  return undefined_value;
+}
+
+napi_value CleanupOldEntries(napi_env env, napi_callback_info info) {
+  napi_value args[4] = {nullptr, nullptr, nullptr, nullptr};
+  size_t argc = 4;
+  if (!GetArgCount(env, info, &argc, args) || argc < 4) {
+    ThrowError(env, "Wrong number of arguments");
+    return nullptr;
+  }
+
+  bool ok = false;
+  const std::string root_dir = GetString(env, args[0], &ok);
+  if (!ok) {
+    return nullptr;
+  }
+  const std::string keep_current = GetString(env, args[1], &ok);
+  if (!ok) {
+    return nullptr;
+  }
+  const std::string keep_previous = GetString(env, args[2], &ok);
+  if (!ok) {
+    return nullptr;
+  }
+  int32_t max_age_days = 0;
+  if (!GetInt32(env, args[3], &max_age_days)) {
+    return nullptr;
+  }
+
+  const pushy::patch::Status status = pushy::patch::CleanupOldEntries(
+      root_dir,
+      keep_current,
+      keep_previous,
+      max_age_days);
+  if (!status.ok) {
+    ThrowError(env, status.message);
+    return nullptr;
+  }
+
+  napi_value undefined_value = nullptr;
+  napi_get_undefined(env, &undefined_value);
+  return undefined_value;
+}
+
+bool ExportFunction(
+    napi_env env,
+    napi_value exports,
+    const char* name,
+    napi_callback callback) {
+  napi_value fn = nullptr;
+  if (napi_create_function(env, name, NAPI_AUTO_LENGTH, callback, nullptr, &fn) !=
+      napi_ok) {
+    ThrowError(env, std::string("Unable to create function ") + name);
+    return false;
+  }
+
+  if (napi_set_named_property(env, exports, name, fn) != napi_ok) {
+    ThrowError(env, std::string("Unable to export function ") + name);
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+napi_value Init(napi_env env, napi_value exports) {
+  if (!ExportFunction(env, exports, "hdiffPatch", HdiffPatch) ||
+      !ExportFunction(env, exports, "syncStateWithBinaryVersion", SyncStateWithBinaryVersion) ||
+      !ExportFunction(env, exports, "runStateCore", RunStateCore) ||
+      !ExportFunction(env, exports, "buildArchivePatchPlan", BuildArchivePatchPlan) ||
+      !ExportFunction(env, exports, "buildCopyGroups", BuildCopyGroups) ||
+      !ExportFunction(env, exports, "applyPatchFromFileSource", ApplyPatchFromFileSource) ||
+      !ExportFunction(env, exports, "cleanupOldEntries", CleanupOldEntries)) {
+    return nullptr;
+  }
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)