src: use CP_UTF8 for wide file names on win32

`src/node_modules.cc` needs to be consistent with `src/node_file.cc` in
how it translates the utf8 strings to `std::wstring` otherwise we might
end up in situation where we can read the source code of imported
package from disk, but fail to recognize that it is an ESM (or CJS) and
cause runtime errors. This type of error is possible on Windows when the
path contains unicode characters and "Language for non-Unicode programs"
is set to "Chinese (Traditional, Taiwan)".

See: #58768

Author: indutny

src/node_file.cc

@@ -3173,29 +3173,6 @@ static void GetFormatOfExtensionlessFile(
 #define BufferValueToPath(str)                                                 \
   std::filesystem::path(ConvertToWideString(str.ToString(), CP_UTF8))
 
-std::string ConvertWideToUTF8(const std::wstring& wstr) {
-  if (wstr.empty()) return std::string();
-
-  int size_needed = WideCharToMultiByte(CP_UTF8,
-                                        0,
-                                        &wstr[0],
-                                        static_cast<int>(wstr.size()),
-                                        nullptr,
-                                        0,
-                                        nullptr,
-                                        nullptr);
-  std::string strTo(size_needed, 0);
-  WideCharToMultiByte(CP_UTF8,
-                      0,
-                      &wstr[0],
-                      static_cast<int>(wstr.size()),
-                      &strTo[0],
-                      size_needed,
-                      nullptr,
-                      nullptr);
-  return strTo;
-}
-
 #define PathToString(path) ConvertWideToUTF8(path.wstring());
 
 #else  // _WIN32

src/node_modules.cc

@@ -294,24 +294,38 @@ const BindingData::PackageConfig* BindingData::TraverseParent(
       break;
     }
 
+    // Check if the path ends with `/node_modules`
+    if (current_path.filename() == "node_modules") {
+      return nullptr;
+    }
+
+    std::string generic_path;
+#ifdef _WIN32
+    generic_path = ConvertWideToUTF8(current_path.generic_wstring());
+#else  // _WIN32
+    generic_path = current_path.generic_string();
+#endif  // _WIN32
+
     // Stop the search when the process doesn't have permissions
     // to walk upwards
     if (is_permissions_enabled &&
         !env->permission()->is_granted(
             env,
             permission::PermissionScope::kFileSystemRead,
-            current_path.generic_string())) [[unlikely]] {
-      return nullptr;
-    }
-
-    // Check if the path ends with `/node_modules`
-    if (current_path.generic_string().ends_with("/node_modules")) {
+            generic_path)) [[unlikely]] {
       return nullptr;
     }
 
     auto package_json_path = current_path / "package.json";
+
+    std::string package_json_path_str;
+#ifdef _WIN32
+    package_json_path_str = ConvertWideToUTF8(package_json_path.wstring());
+#else  // _WIN32
+    package_json_path_str = package_json_path.string();
+#endif  // _WIN32
     auto package_json =
-        GetPackageJSON(realm, package_json_path.string(), nullptr);
+        GetPackageJSON(realm, package_json_path_str, nullptr);
     if (package_json != nullptr) {
       return package_json;
     }
@@ -341,7 +355,7 @@ void BindingData::GetNearestParentPackageJSONType(
   std::filesystem::path path;
 
 #ifdef _WIN32
-  std::wstring wide_path = ConvertToWideString(path_value_str, GetACP());
+  std::wstring wide_path = ConvertToWideString(path_value_str, CP_UTF8);
   path = std::filesystem::path(wide_path);
 #else
   path = std::filesystem::path(path_value_str);

src/util-inl.h

@@ -731,6 +731,29 @@ inline std::wstring ConvertToWideString(const std::string& str,
                       size_needed);
   return wstrTo;
 }
+
+std::string ConvertWideToUTF8(const std::wstring& wstr) {
+  if (wstr.empty()) return std::string();
+
+  int size_needed = WideCharToMultiByte(CP_UTF8,
+                                        0,
+                                        &wstr[0],
+                                        static_cast<int>(wstr.size()),
+                                        nullptr,
+                                        0,
+                                        nullptr,
+                                        nullptr);
+  std::string strTo(size_needed, 0);
+  WideCharToMultiByte(CP_UTF8,
+                      0,
+                      &wstr[0],
+                      static_cast<int>(wstr.size()),
+                      &strTo[0],
+                      size_needed,
+                      nullptr,
+                      nullptr);
+  return strTo;
+}
 #endif  // _WIN32
 
 inline v8::MaybeLocal<v8::Object> NewDictionaryInstance(

src/util.h

@@ -1039,6 +1039,7 @@ class JSONOutputStream final : public v8::OutputStream {
 // case insensitive.
 inline bool IsWindowsBatchFile(const char* filename);
 inline std::wstring ConvertToWideString(const std::string& str, UINT code_page);
+inline std::string ConvertWideToUTF8(const std::wstring& wstr);
 #endif  // _WIN32
 
 // A helper to create a new instance of the dictionary template.