Merge remote-tracking branch 'origin/main' into de/zen-service-command

12 files changed, 197 insertions, 211 deletions

diff --git a/src/zenserver/admin/admin.cpp b/src/zenserver/admin/admin.cpp
index 847ed5a50..2888f5450 100644
--- a/src/zenserver/admin/admin.cpp
+++ b/src/zenserver/admin/admin.cpp
@@ -21,6 +21,7 @@
 #include <zenstore/gc.h>
 
 #include <zenstore/cache/structuredcachestore.h>
+#include <zenutil/workerpools.h>
 #include "config.h"
 #include "projectstore/projectstore.h"
 
@@ -41,31 +42,43 @@ GetStatsForDirectory(std::filesystem::path Dir)
 	if (!std::filesystem::exists(Dir))
 		return {};
 
-	FileSystemTraversal Traversal;
-
-	struct StatsTraversal : public FileSystemTraversal::TreeVisitor
+	struct StatsTraversal : public GetDirectoryContentVisitor
 	{
-		virtual void VisitFile(const std::filesystem::path& Parent, const path_view& File, uint64_t FileSize) override
+		virtual void AsyncVisitDirectory(const std::filesystem::path& RelativeRoot, DirectoryContent&& Content) override
 		{
-			ZEN_UNUSED(Parent, File);
-			++TotalFileCount;
-			TotalBytes += FileSize;
+			ZEN_UNUSED(RelativeRoot);
+
+			uint64_t FileCount = Content.FileNames.size();
+			uint64_t DirCount  = Content.DirectoryNames.size();
+			uint64_t FilesSize = 0;
+			for (uint64_t FileSize : Content.FileSizes)
+			{
+				FilesSize += FileSize;
+			}
+			TotalBytes += FilesSize;
+			TotalFileCount += FileCount;
+			TotalDirCount += DirCount;
 		}
-		virtual bool VisitDirectory(const std::filesystem::path&, const path_view&) override
+
+		std::atomic_uint64_t TotalBytes		= 0;
+		std::atomic_uint64_t TotalFileCount = 0;
+		std::atomic_uint64_t TotalDirCount	= 0;
+
+		DirStats GetStats()
 		{
-			++TotalDirCount;
-			return true;
+			return {.FileCount = TotalFileCount.load(), .DirCount = TotalDirCount.load(), .ByteCount = TotalBytes.load()};
 		}
+	} DirTraverser;
 
-		uint64_t TotalBytes		= 0;
-		uint64_t TotalFileCount = 0;
-		uint64_t TotalDirCount	= 0;
-
-		DirStats GetStats() { return {.FileCount = TotalFileCount, .DirCount = TotalDirCount, .ByteCount = TotalBytes}; }
-	};
+	Latch PendingWorkCount(1);
 
-	StatsTraversal DirTraverser;
-	Traversal.TraverseFileSystem(Dir, DirTraverser);
+	GetDirectoryContent(Dir,
+						DirectoryContentFlags::IncludeAllEntries | DirectoryContentFlags::IncludeFileSizes,
+						DirTraverser,
+						GetSmallWorkerPool(EWorkloadType::Burst),
+						PendingWorkCount);
+	PendingWorkCount.CountDown();
+	PendingWorkCount.Wait();
 
 	return DirTraverser.GetStats();
 }
diff --git a/src/zenserver/cache/httpstructuredcache.cpp b/src/zenserver/cache/httpstructuredcache.cpp
index b4dc4c7f0..b9a9ca380 100644
--- a/src/zenserver/cache/httpstructuredcache.cpp
+++ b/src/zenserver/cache/httpstructuredcache.cpp
@@ -24,7 +24,7 @@
 #include <zenutil/cache/cache.h>
 #include <zenutil/cache/cacherequests.h>
 #include <zenutil/cache/rpcrecording.h>
-#include <zenutil/jupiter.h>
+#include <zenutil/jupiter/jupiterclient.h>
 #include <zenutil/workerpools.h>
 
 #include "upstream/upstreamcache.h"
diff --git a/src/zenserver/config.cpp b/src/zenserver/config.cpp
index f3ad71356..809092378 100644
--- a/src/zenserver/config.cpp
+++ b/src/zenserver/config.cpp
@@ -63,7 +63,7 @@ ReadAllCentralManifests(const std::filesystem::path& SystemRoot)
 	std::vector<CbObject> Manifests;
 
 	DirectoryContent Content;
-	GetDirectoryContent(SystemRoot / "States", DirectoryContent::IncludeFilesFlag, Content);
+	GetDirectoryContent(SystemRoot / "States", DirectoryContentFlags::IncludeFiles, Content);
 
 	for (std::filesystem::path& File : Content.Files)
 	{
diff --git a/src/zenserver/objectstore/objectstore.cpp b/src/zenserver/objectstore/objectstore.cpp
index 530efbc97..b0212ab07 100644
--- a/src/zenserver/objectstore/objectstore.cpp
+++ b/src/zenserver/objectstore/objectstore.cpp
@@ -376,7 +376,7 @@ HttpObjectStoreService::ListBucket(zen::HttpRouterRequest& Request, const std::s
 			Writer.BeginArray("Contents"sv);
 		}
 
-		void VisitFile(const fs::path& Parent, const path_view& File, uint64_t FileSize) override
+		void VisitFile(const fs::path& Parent, const path_view& File, uint64_t FileSize, uint32_t) override
 		{
 			const fs::path FullPath		= Parent / fs::path(File);
 			fs::path	   RelativePath = fs::relative(FullPath, BucketPath);
@@ -390,7 +390,7 @@ HttpObjectStoreService::ListBucket(zen::HttpRouterRequest& Request, const std::s
 			Writer.EndObject();
 		}
 
-		bool VisitDirectory(const std::filesystem::path&, const path_view&) override { return false; }
+		bool VisitDirectory(const std::filesystem::path&, const path_view&, uint32_t) override { return false; }
 
 		CbObject GetResult()
 		{
diff --git a/src/zenserver/projectstore/buildsremoteprojectstore.cpp b/src/zenserver/projectstore/buildsremoteprojectstore.cpp
index 0fe37449f..302b81729 100644
--- a/src/zenserver/projectstore/buildsremoteprojectstore.cpp
+++ b/src/zenserver/projectstore/buildsremoteprojectstore.cpp
@@ -6,8 +6,10 @@
 #include <zencore/compress.h>
 #include <zencore/fmtutils.h>
 
-#include <zenhttp/auth/authmgr.h>
-#include <zenutil/jupiter.h>
+#include <zenhttp/httpclientauth.h>
+
+#include <zenutil/jupiter/jupiterclient.h>
+#include <zenutil/jupiter/jupitersession.h>
 
 namespace zen {
 
@@ -18,7 +20,7 @@ static const std::string_view OplogContainerPartName = "oplogcontainer"sv;
 class BuildsRemoteStore : public RemoteProjectStore
 {
 public:
-	BuildsRemoteStore(Ref<CloudCacheClient>&&	   CloudClient,
+	BuildsRemoteStore(Ref<JupiterClient>&&		   InJupiterClient,
 					  std::string_view			   Namespace,
 					  std::string_view			   Bucket,
 					  const Oid&				   BuildId,
@@ -26,7 +28,7 @@ public:
 					  bool						   ForceDisableBlocks,
 					  bool						   ForceDisableTempBlocks,
 					  const std::filesystem::path& TempFilePath)
-	: m_CloudClient(std::move(CloudClient))
+	: m_JupiterClient(std::move(InJupiterClient))
 	, m_Namespace(Namespace)
 	, m_Bucket(Bucket)
 	, m_BuildId(BuildId)
@@ -50,7 +52,7 @@ public:
 				.UseTempBlockFiles = m_UseTempBlocks,
 				.AllowChunking	   = true,
 				.ContainerName	   = fmt::format("{}/{}/{}", m_Namespace, m_Bucket, m_BuildId),
-				.Description = fmt::format("[cloud] {} as {}/{}/{}"sv, m_CloudClient->ServiceUrl(), m_Namespace, m_Bucket, m_BuildId)};
+				.Description = fmt::format("[cloud] {} as {}/{}/{}"sv, m_JupiterClient->ServiceUrl(), m_Namespace, m_Bucket, m_BuildId)};
 	}
 
 	virtual Stats GetStats() const override
@@ -68,18 +70,18 @@ public:
 	{
 		ZEN_ASSERT(m_OplogBuildPartId == Oid::Zero);
 
-		CloudCacheSession Session(m_CloudClient.Get());
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
 
 		IoBuffer Payload = m_MetaData;
 		Payload.SetContentType(ZenContentType::kCbObject);
-		CloudCacheResult PutResult = Session.PutBuild(m_Namespace, m_Bucket, m_BuildId, Payload);
+		JupiterResult PutResult = Session.PutBuild(m_Namespace, m_Bucket, m_BuildId, Payload);
 		AddStats(PutResult);
 
 		CreateContainerResult Result{ConvertResult(PutResult)};
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed creating oplog build to {}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_BuildId,
@@ -92,7 +94,7 @@ public:
 	virtual SaveResult SaveContainer(const IoBuffer& Payload) override
 	{
 		ZEN_ASSERT(m_OplogBuildPartId != Oid::Zero);
-		CloudCacheSession  Session(m_CloudClient.Get());
+		JupiterSession	   Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
 		PutBuildPartResult PutResult =
 			Session.PutBuildPart(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId, OplogContainerPartName, Payload);
 		AddStats(PutResult);
@@ -101,7 +103,7 @@ public:
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed saving oplog container build part to {}/{}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_BuildId,
@@ -115,9 +117,9 @@ public:
 	virtual SaveAttachmentResult SaveAttachment(const CompositeBuffer& Payload, const IoHash& RawHash, Block&& Block) override
 	{
 		ZEN_ASSERT(m_OplogBuildPartId != Oid::Zero);
-		CloudCacheSession Session(m_CloudClient.Get());
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
 
-		CloudCacheResult PutResult =
+		JupiterResult PutResult =
 			Session.PutBuildBlob(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId, RawHash, ZenContentType::kCompressedBinary, Payload);
 		AddStats(PutResult);
 
@@ -125,7 +127,7 @@ public:
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed saving oplog attachment to {}/{}/{}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_BuildId,
@@ -176,14 +178,14 @@ public:
 
 			IoBuffer MetaPayload = Writer.Save().GetBuffer().AsIoBuffer();
 			MetaPayload.SetContentType(ZenContentType::kCbObject);
-			CloudCacheResult PutMetaResult =
+			JupiterResult PutMetaResult =
 				Session.PutBlockMetadata(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId, RawHash, MetaPayload);
 			AddStats(PutMetaResult);
 			RemoteProjectStore::Result MetaDataResult = ConvertResult(PutMetaResult);
 			if (MetaDataResult.ErrorCode)
 			{
 				ZEN_WARN("Failed saving block attachment meta data to {}/{}/{}/{}/{}/{}. Reason: '{}'",
-						 m_CloudClient->ServiceUrl(),
+						 m_JupiterClient->ServiceUrl(),
 						 m_Namespace,
 						 m_Bucket,
 						 m_BuildId,
@@ -215,7 +217,7 @@ public:
 		ZEN_UNUSED(RawHash);
 		ZEN_ASSERT(m_OplogBuildPartId != Oid::Zero);
 
-		CloudCacheSession		Session(m_CloudClient.Get());
+		JupiterSession			Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
 		FinalizeBuildPartResult FinalizeRefResult =
 			Session.FinalizeBuildPart(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId, RawHash);
 		AddStats(FinalizeRefResult);
@@ -224,7 +226,7 @@ public:
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed finalizing oplog container build part to {}/{}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_BuildId,
@@ -233,14 +235,14 @@ public:
 		}
 		else if (Result.Needs.empty())
 		{
-			CloudCacheResult FinalizeBuildResult = Session.FinalizeBuild(m_Namespace, m_Bucket, m_BuildId);
+			JupiterResult FinalizeBuildResult = Session.FinalizeBuild(m_Namespace, m_Bucket, m_BuildId);
 			AddStats(FinalizeBuildResult);
 			FinalizeBuildResult.ElapsedSeconds += FinalizeRefResult.ElapsedSeconds;
 			Result = {ConvertResult(FinalizeBuildResult)};
 			if (Result.ErrorCode)
 			{
 				Result.Reason = fmt::format("Failed finalizing oplog container build to {}/{}/{}/{}. Reason: '{}'",
-											m_CloudClient->ServiceUrl(),
+											m_JupiterClient->ServiceUrl(),
 											m_Namespace,
 											m_Bucket,
 											m_BuildId,
@@ -254,14 +256,14 @@ public:
 	{
 		ZEN_ASSERT(m_OplogBuildPartId == Oid::Zero);
 
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  GetBuildResult = Session.GetBuild(m_Namespace, m_Bucket, m_BuildId);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  GetBuildResult = Session.GetBuild(m_Namespace, m_Bucket, m_BuildId);
 		AddStats(GetBuildResult);
 		LoadContainerResult Result{ConvertResult(GetBuildResult)};
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed fetching oplog container build from {}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_BuildId,
@@ -273,7 +275,7 @@ public:
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
 			Result.Reason	 = fmt::format("The build {}/{}/{}/{} payload is not formatted as a compact binary object"sv,
-										   m_CloudClient->ServiceUrl(),
+										   m_JupiterClient->ServiceUrl(),
 										   m_Namespace,
 										   m_Bucket,
 										   m_BuildId);
@@ -284,7 +286,7 @@ public:
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
 			Result.Reason	 = fmt::format("The build {}/{}/{}/{} payload does not contain a 'parts' object"sv,
-										   m_CloudClient->ServiceUrl(),
+										   m_JupiterClient->ServiceUrl(),
 										   m_Namespace,
 										   m_Bucket,
 										   m_BuildId);
@@ -295,7 +297,7 @@ public:
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
 			Result.Reason	 = fmt::format("The build {}/{}/{}/{} payload 'parts' object does not contain a '{}' entry"sv,
-										   m_CloudClient->ServiceUrl(),
+										   m_JupiterClient->ServiceUrl(),
 										   m_Namespace,
 										   m_Bucket,
 										   m_BuildId,
@@ -303,7 +305,7 @@ public:
 			return Result;
 		}
 
-		CloudCacheResult GetBuildPartResult = Session.GetBuildPart(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId);
+		JupiterResult GetBuildPartResult = Session.GetBuildPart(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId);
 		AddStats(GetBuildPartResult);
 		Result = {ConvertResult(GetBuildResult)};
 		Result.ElapsedSeconds += GetBuildResult.ElapsedSeconds;
@@ -311,7 +313,7 @@ public:
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
 			Result.Reason	 = fmt::format("Failed fetching oplog build part from {}/{}/{}/{}/{}. Reason: '{}'",
-										   m_CloudClient->ServiceUrl(),
+										   m_JupiterClient->ServiceUrl(),
 										   m_Namespace,
 										   m_Bucket,
 										   m_BuildId,
@@ -325,7 +327,7 @@ public:
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
 			Result.Reason = fmt::format("The build part for oplog container {}/{}/{}/{}/{} is not formatted as a compact binary object"sv,
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_BuildId,
@@ -339,15 +341,15 @@ public:
 	virtual GetKnownBlocksResult GetKnownBlocks() override
 	{
 		ZEN_ASSERT(m_OplogBuildPartId != Oid::Zero);
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  FindResult = Session.FindBlocks(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  FindResult = Session.FindBlocks(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId);
 		AddStats(FindResult);
 		GetKnownBlocksResult Result{ConvertResult(FindResult)};
 		if (Result.ErrorCode)
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
 			Result.Reason	 = fmt::format("Failed listing know blocks for {}/{}/{}/{}/{}. Reason: '{}'",
-										   m_CloudClient->ServiceUrl(),
+										   m_JupiterClient->ServiceUrl(),
 										   m_Namespace,
 										   m_Bucket,
 										   m_BuildId,
@@ -360,7 +362,7 @@ public:
 		{
 			Result.ErrorCode = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError);
 			Result.Reason	 = fmt::format("The block list {}/{}/{}/{} is not formatted as a compact binary object"sv,
-										   m_CloudClient->ServiceUrl(),
+										   m_JupiterClient->ServiceUrl(),
 										   m_Namespace,
 										   m_Bucket,
 										   m_BuildId,
@@ -392,15 +394,15 @@ public:
 	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash) override
 	{
 		ZEN_ASSERT(m_OplogBuildPartId != Oid::Zero);
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  GetResult = Session.GetBuildBlob(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId, RawHash, m_TempFilePath);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  GetResult = Session.GetBuildBlob(m_Namespace, m_Bucket, m_BuildId, m_OplogBuildPartId, RawHash, m_TempFilePath);
 		AddStats(GetResult);
 
 		LoadAttachmentResult Result{ConvertResult(GetResult), std::move(GetResult.Response)};
 		if (GetResult.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed fetching oplog attachment from {}/{}/{}&{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_BuildId,
@@ -429,7 +431,7 @@ public:
 	}
 
 private:
-	void AddStats(const CloudCacheResult& Result)
+	void AddStats(const JupiterResult& Result)
 	{
 		m_SentBytes.fetch_add(gsl::narrow<uint64_t>(Result.SentBytes));
 		m_ReceivedBytes.fetch_add(gsl::narrow<uint64_t>(Result.ReceivedBytes));
@@ -445,7 +447,7 @@ private:
 		m_RequestCount.fetch_add(1);
 	}
 
-	static Result ConvertResult(const CloudCacheResult& Response)
+	static Result ConvertResult(const JupiterResult& Response)
 	{
 		std::string Text;
 		int32_t		ErrorCode = 0;
@@ -482,7 +484,7 @@ private:
 		return {.ErrorCode = ErrorCode, .ElapsedSeconds = Response.ElapsedSeconds, .Reason = Response.Reason, .Text = Text};
 	}
 
-	Ref<CloudCacheClient> m_CloudClient;
+	Ref<JupiterClient>	  m_JupiterClient;
 	const std::string	  m_Namespace;
 	const std::string	  m_Bucket;
 	const Oid			  m_BuildId;
@@ -510,44 +512,35 @@ CreateBuildsRemoteStore(const BuildsRemoteStoreOptions& Options, const std::file
 		// Assume https URL
 		Url = fmt::format("https://{}"sv, Url);
 	}
-	CloudCacheClientOptions ClientOptions{.Name			  = "Remote store"sv,
-										  .ServiceUrl	  = Url,
-										  .ConnectTimeout = std::chrono::milliseconds(2000),
-										  .Timeout		  = std::chrono::milliseconds(1800000),
-										  .AssumeHttp2	  = Options.AssumeHttp2,
-										  .AllowResume	  = true,
-										  .RetryCount	  = 4};
+	JupiterClientOptions ClientOptions{.Name		   = "Remote store"sv,
+									   .ServiceUrl	   = Url,
+									   .ConnectTimeout = std::chrono::milliseconds(2000),
+									   .Timeout		   = std::chrono::milliseconds(1800000),
+									   .AssumeHttp2	   = Options.AssumeHttp2,
+									   .AllowResume	   = true,
+									   .RetryCount	   = 4};
 	// 1) openid-provider if given (assumes oidctoken.exe -Zen true has been run with matching Options.OpenIdProvider
 	// 2) Access token as parameter in request
 	// 3) Environment variable (different win vs linux/mac)
 	// 4) Default openid-provider (assumes oidctoken.exe -Zen true has been run with matching Options.OpenIdProvider
 
-	std::unique_ptr<CloudCacheTokenProvider> TokenProvider;
+	std::function<HttpClientAccessToken()> TokenProvider;
 	if (!Options.OpenIdProvider.empty())
 	{
-		TokenProvider =
-			CloudCacheTokenProvider::CreateFromCallback([&AuthManager = Options.AuthManager, OpenIdProvider = Options.OpenIdProvider]() {
-				AuthMgr::OpenIdAccessToken Token = AuthManager.GetOpenIdAccessToken(OpenIdProvider.empty() ? "Default" : OpenIdProvider);
-				return CloudCacheAccessToken{.Value = Token.AccessToken, .ExpireTime = Token.ExpireTime};
-			});
+		TokenProvider = httpclientauth::CreateFromOpenIdProvider(Options.AuthManager, Options.OpenIdProvider);
 	}
 	else if (!Options.AccessToken.empty())
 	{
-		TokenProvider = CloudCacheTokenProvider::CreateFromCallback([AccessToken = "Bearer " + Options.AccessToken]() {
-			return CloudCacheAccessToken{.Value = AccessToken, .ExpireTime = GcClock::TimePoint::max()};
-		});
+		TokenProvider = httpclientauth::CreateFromStaticToken(Options.AccessToken);
 	}
 	else
 	{
-		TokenProvider = CloudCacheTokenProvider::CreateFromCallback([&AuthManager = Options.AuthManager]() {
-			AuthMgr::OpenIdAccessToken Token = AuthManager.GetOpenIdAccessToken("Default");
-			return CloudCacheAccessToken{.Value = Token.AccessToken, .ExpireTime = Token.ExpireTime};
-		});
+		TokenProvider = httpclientauth::CreateFromDefaultOpenIdProvider(Options.AuthManager);
 	}
 
-	Ref<CloudCacheClient> CloudClient(new CloudCacheClient(ClientOptions, std::move(TokenProvider)));
+	Ref<JupiterClient> Client(new JupiterClient(ClientOptions, std::move(TokenProvider)));
 
-	std::shared_ptr<RemoteProjectStore> RemoteStore = std::make_shared<BuildsRemoteStore>(std::move(CloudClient),
+	std::shared_ptr<RemoteProjectStore> RemoteStore = std::make_shared<BuildsRemoteStore>(std::move(Client),
 																						  Options.Namespace,
 																						  Options.Bucket,
 																						  Options.BuildId,
diff --git a/src/zenserver/projectstore/httpprojectstore.h b/src/zenserver/projectstore/httpprojectstore.h
index 13810bd66..8e74c57a5 100644
--- a/src/zenserver/projectstore/httpprojectstore.h
+++ b/src/zenserver/projectstore/httpprojectstore.h
@@ -3,13 +3,13 @@
 #pragma once
 
 #include <zencore/stats.h>
-#include <zenhttp/auth/authmgr.h>
 #include <zenhttp/httpserver.h>
 #include <zenhttp/httpstats.h>
 #include <zenstore/cidstore.h>
 
 namespace zen {
 
+class AuthMgr;
 class ProjectStore;
 
 //////////////////////////////////////////////////////////////////////////
diff --git a/src/zenserver/projectstore/jupiterremoteprojectstore.cpp b/src/zenserver/projectstore/jupiterremoteprojectstore.cpp
index 5a42b2f50..e906127ff 100644
--- a/src/zenserver/projectstore/jupiterremoteprojectstore.cpp
+++ b/src/zenserver/projectstore/jupiterremoteprojectstore.cpp
@@ -5,8 +5,10 @@
 #include <zencore/compress.h>
 #include <zencore/fmtutils.h>
 
-#include <zenhttp/auth/authmgr.h>
-#include <zenutil/jupiter.h>
+#include <zenhttp/httpclientauth.h>
+
+#include <zenutil/jupiter/jupiterclient.h>
+#include <zenutil/jupiter/jupitersession.h>
 
 namespace zen {
 
@@ -15,7 +17,7 @@ using namespace std::literals;
 class JupiterRemoteStore : public RemoteProjectStore
 {
 public:
-	JupiterRemoteStore(Ref<CloudCacheClient>&&		CloudClient,
+	JupiterRemoteStore(Ref<JupiterClient>&&			InJupiterClient,
 					   std::string_view				Namespace,
 					   std::string_view				Bucket,
 					   const IoHash&				Key,
@@ -23,7 +25,7 @@ public:
 					   bool							ForceDisableBlocks,
 					   bool							ForceDisableTempBlocks,
 					   const std::filesystem::path& TempFilePath)
-	: m_CloudClient(std::move(CloudClient))
+	: m_JupiterClient(std::move(InJupiterClient))
 	, m_Namespace(Namespace)
 	, m_Bucket(Bucket)
 	, m_Key(Key)
@@ -47,7 +49,7 @@ public:
 				.AllowChunking	   = true,
 				.ContainerName	   = fmt::format("{}/{}/{}", m_Namespace, m_Bucket, m_Key),
 				.Description	   = fmt::format("[cloud] {} as {}/{}/{}{}"sv,
-											 m_CloudClient->ServiceUrl(),
+											 m_JupiterClient->ServiceUrl(),
 											 m_Namespace,
 											 m_Bucket,
 											 m_Key,
@@ -73,15 +75,15 @@ public:
 
 	virtual SaveResult SaveContainer(const IoBuffer& Payload) override
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
-		PutRefResult	  PutResult = Session.PutRef(m_Namespace, m_Bucket, m_Key, Payload, ZenContentType::kCbObject);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		PutRefResult   PutResult = Session.PutRef(m_Namespace, m_Bucket, m_Key, Payload, ZenContentType::kCbObject);
 		AddStats(PutResult);
 
 		SaveResult Result{ConvertResult(PutResult), {PutResult.Needs.begin(), PutResult.Needs.end()}, PutResult.RawHash};
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed saving oplog container to {}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_Key,
@@ -92,15 +94,15 @@ public:
 
 	virtual SaveAttachmentResult SaveAttachment(const CompositeBuffer& Payload, const IoHash& RawHash, Block&&) override
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  PutResult = Session.PutCompressedBlob(m_Namespace, RawHash, Payload);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  PutResult = Session.PutCompressedBlob(m_Namespace, RawHash, Payload);
 		AddStats(PutResult);
 
 		SaveAttachmentResult Result{ConvertResult(PutResult)};
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed saving oplog attachment to {}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										RawHash,
 										Result.Reason);
@@ -125,7 +127,7 @@ public:
 
 	virtual FinalizeResult FinalizeContainer(const IoHash& RawHash) override
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
+		JupiterSession	  Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
 		FinalizeRefResult FinalizeRefResult = Session.FinalizeRef(m_Namespace, m_Bucket, m_Key, RawHash);
 		AddStats(FinalizeRefResult);
 
@@ -133,7 +135,7 @@ public:
 		if (Result.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed finalizing oplog container to {}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										m_Key,
@@ -162,8 +164,8 @@ public:
 				{.ErrorCode = static_cast<int>(HttpResponseCode::NoContent), .ElapsedSeconds = LoadResult.ElapsedSeconds}};
 		}
 
-		CloudCacheSession	   Session(m_CloudClient.Get());
-		CloudCacheExistsResult ExistsResult =
+		JupiterSession		Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterExistsResult ExistsResult =
 			Session.CompressedBlobExists(m_Namespace, std::set<IoHash>(BlockHashes.begin(), BlockHashes.end()));
 		AddStats(ExistsResult);
 
@@ -172,7 +174,7 @@ public:
 			return GetKnownBlocksResult{{.ErrorCode		 = ExistsResult.ErrorCode,
 										 .ElapsedSeconds = LoadResult.ElapsedSeconds + ExistsResult.ElapsedSeconds,
 										 .Reason		 = fmt::format("Failed checking attachment existance in {}/{}. Reason: '{}'",
-															   m_CloudClient->ServiceUrl(),
+															   m_JupiterClient->ServiceUrl(),
 															   m_Namespace,
 															   ExistsResult.Reason)}};
 		}
@@ -201,15 +203,15 @@ public:
 
 	virtual LoadAttachmentResult LoadAttachment(const IoHash& RawHash) override
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  GetResult = Session.GetCompressedBlob(m_Namespace, RawHash, m_TempFilePath);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  GetResult = Session.GetCompressedBlob(m_Namespace, RawHash, m_TempFilePath);
 		AddStats(GetResult);
 
 		LoadAttachmentResult Result{ConvertResult(GetResult), std::move(GetResult.Response)};
 		if (GetResult.ErrorCode)
 		{
 			Result.Reason = fmt::format("Failed fetching oplog attachment from {}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										RawHash,
 										Result.Reason);
@@ -237,14 +239,14 @@ public:
 private:
 	LoadContainerResult LoadContainer(const IoHash& Key)
 	{
-		CloudCacheSession Session(m_CloudClient.Get());
-		CloudCacheResult  GetResult = Session.GetRef(m_Namespace, m_Bucket, Key, ZenContentType::kCbObject);
+		JupiterSession Session(m_JupiterClient->Logger(), m_JupiterClient->Client());
+		JupiterResult  GetResult = Session.GetRef(m_Namespace, m_Bucket, Key, ZenContentType::kCbObject);
 		AddStats(GetResult);
 		if (GetResult.ErrorCode || !GetResult.Success)
 		{
 			LoadContainerResult Result{ConvertResult(GetResult)};
 			Result.Reason = fmt::format("Failed fetching oplog container from {}/{}/{}/{}. Reason: '{}'",
-										m_CloudClient->ServiceUrl(),
+										m_JupiterClient->ServiceUrl(),
 										m_Namespace,
 										m_Bucket,
 										Key,
@@ -259,7 +261,7 @@ private:
 				RemoteProjectStore::Result{.ErrorCode	   = gsl::narrow<int32_t>(HttpResponseCode::InternalServerError),
 										   .ElapsedSeconds = GetResult.ElapsedSeconds,
 										   .Reason = fmt::format("The ref {}/{}/{}/{} is not formatted as a compact binary object"sv,
-																 m_CloudClient->ServiceUrl(),
+																 m_JupiterClient->ServiceUrl(),
 																 m_Namespace,
 																 m_Bucket,
 																 Key)},
@@ -268,7 +270,7 @@ private:
 		return LoadContainerResult{ConvertResult(GetResult), std::move(ContainerObject)};
 	}
 
-	void AddStats(const CloudCacheResult& Result)
+	void AddStats(const JupiterResult& Result)
 	{
 		m_SentBytes.fetch_add(gsl::narrow<uint64_t>(Result.SentBytes));
 		m_ReceivedBytes.fetch_add(gsl::narrow<uint64_t>(Result.ReceivedBytes));
@@ -284,7 +286,7 @@ private:
 		m_RequestCount.fetch_add(1);
 	}
 
-	static Result ConvertResult(const CloudCacheResult& Response)
+	static Result ConvertResult(const JupiterResult& Response)
 	{
 		std::string Text;
 		int32_t		ErrorCode = 0;
@@ -321,7 +323,7 @@ private:
 		return {.ErrorCode = ErrorCode, .ElapsedSeconds = Response.ElapsedSeconds, .Reason = Response.Reason, .Text = Text};
 	}
 
-	Ref<CloudCacheClient> m_CloudClient;
+	Ref<JupiterClient>	  m_JupiterClient;
 	const std::string	  m_Namespace;
 	const std::string	  m_Bucket;
 	const IoHash		  m_Key;
@@ -348,44 +350,35 @@ CreateJupiterRemoteStore(const JupiterRemoteStoreOptions& Options, const std::fi
 		// Assume https URL
 		Url = fmt::format("https://{}"sv, Url);
 	}
-	CloudCacheClientOptions ClientOptions{.Name			  = "Remote store"sv,
-										  .ServiceUrl	  = Url,
-										  .ConnectTimeout = std::chrono::milliseconds(2000),
-										  .Timeout		  = std::chrono::milliseconds(1800000),
-										  .AssumeHttp2	  = Options.AssumeHttp2,
-										  .AllowResume	  = true,
-										  .RetryCount	  = 4};
+	JupiterClientOptions ClientOptions{.Name		   = "Remote store"sv,
+									   .ServiceUrl	   = Url,
+									   .ConnectTimeout = std::chrono::milliseconds(2000),
+									   .Timeout		   = std::chrono::milliseconds(1800000),
+									   .AssumeHttp2	   = Options.AssumeHttp2,
+									   .AllowResume	   = true,
+									   .RetryCount	   = 4};
 	// 1) openid-provider if given (assumes oidctoken.exe -Zen true has been run with matching Options.OpenIdProvider
 	// 2) Access token as parameter in request
 	// 3) Environment variable (different win vs linux/mac)
 	// 4) Default openid-provider (assumes oidctoken.exe -Zen true has been run with matching Options.OpenIdProvider
 
-	std::unique_ptr<CloudCacheTokenProvider> TokenProvider;
+	std::function<HttpClientAccessToken()> TokenProvider;
 	if (!Options.OpenIdProvider.empty())
 	{
-		TokenProvider =
-			CloudCacheTokenProvider::CreateFromCallback([&AuthManager = Options.AuthManager, OpenIdProvider = Options.OpenIdProvider]() {
-				AuthMgr::OpenIdAccessToken Token = AuthManager.GetOpenIdAccessToken(OpenIdProvider.empty() ? "Default" : OpenIdProvider);
-				return CloudCacheAccessToken{.Value = Token.AccessToken, .ExpireTime = Token.ExpireTime};
-			});
+		TokenProvider = httpclientauth::CreateFromOpenIdProvider(Options.AuthManager, Options.OpenIdProvider);
 	}
 	else if (!Options.AccessToken.empty())
 	{
-		TokenProvider = CloudCacheTokenProvider::CreateFromCallback([AccessToken = "Bearer " + Options.AccessToken]() {
-			return CloudCacheAccessToken{.Value = AccessToken, .ExpireTime = GcClock::TimePoint::max()};
-		});
+		TokenProvider = httpclientauth::CreateFromStaticToken(Options.AccessToken);
 	}
 	else
 	{
-		TokenProvider = CloudCacheTokenProvider::CreateFromCallback([&AuthManager = Options.AuthManager]() {
-			AuthMgr::OpenIdAccessToken Token = AuthManager.GetOpenIdAccessToken("Default");
-			return CloudCacheAccessToken{.Value = Token.AccessToken, .ExpireTime = Token.ExpireTime};
-		});
+		TokenProvider = httpclientauth::CreateFromDefaultOpenIdProvider(Options.AuthManager);
 	}
 
-	Ref<CloudCacheClient> CloudClient(new CloudCacheClient(ClientOptions, std::move(TokenProvider)));
+	Ref<JupiterClient> Client(new JupiterClient(ClientOptions, std::move(TokenProvider)));
 
-	std::shared_ptr<RemoteProjectStore> RemoteStore = std::make_shared<JupiterRemoteStore>(std::move(CloudClient),
+	std::shared_ptr<RemoteProjectStore> RemoteStore = std::make_shared<JupiterRemoteStore>(std::move(Client),
 																						   Options.Namespace,
 																						   Options.Bucket,
 																						   Options.Key,
diff --git a/src/zenserver/projectstore/projectstore.cpp b/src/zenserver/projectstore/projectstore.cpp
index 9e9fc0e77..46a236af9 100644
--- a/src/zenserver/projectstore/projectstore.cpp
+++ b/src/zenserver/projectstore/projectstore.cpp
@@ -3506,7 +3506,7 @@ ProjectStore::Project::ScanForOplogs() const
 	if (Project::Exists(m_OplogStoragePath))
 	{
 		DirectoryContent DirContent;
-		GetDirectoryContent(m_OplogStoragePath, DirectoryContent::IncludeDirsFlag, DirContent);
+		GetDirectoryContent(m_OplogStoragePath, DirectoryContentFlags::IncludeDirs, DirContent);
 		Oplogs.reserve(DirContent.Directories.size());
 		for (const std::filesystem::path& DirPath : DirContent.Directories)
 		{
@@ -3859,7 +3859,7 @@ ProjectStore::DiscoverProjects()
 	}
 
 	DirectoryContent DirContent;
-	GetDirectoryContent(m_ProjectBasePath, DirectoryContent::IncludeDirsFlag, DirContent);
+	GetDirectoryContent(m_ProjectBasePath, DirectoryContentFlags::IncludeDirs, DirContent);
 
 	for (const std::filesystem::path& DirPath : DirContent.Directories)
 	{
@@ -3965,7 +3965,7 @@ ProjectStore::StorageSize() const
 		if (std::filesystem::exists(m_ProjectBasePath))
 		{
 			DirectoryContent ProjectsFolderContent;
-			GetDirectoryContent(m_ProjectBasePath, DirectoryContent::IncludeDirsFlag, ProjectsFolderContent);
+			GetDirectoryContent(m_ProjectBasePath, DirectoryContentFlags::IncludeDirs, ProjectsFolderContent);
 
 			for (const std::filesystem::path& ProjectBasePath : ProjectsFolderContent.Directories)
 			{
@@ -3974,7 +3974,7 @@ ProjectStore::StorageSize() const
 				{
 					Result.DiskSize += Project::TotalSize(ProjectBasePath);
 					DirectoryContent DirContent;
-					GetDirectoryContent(ProjectBasePath, DirectoryContent::IncludeDirsFlag, DirContent);
+					GetDirectoryContent(ProjectBasePath, DirectoryContentFlags::IncludeDirs, DirContent);
 					for (const std::filesystem::path& OplogBasePath : DirContent.Directories)
 					{
 						Result.DiskSize += Oplog::TotalSize(OplogBasePath);
diff --git a/src/zenserver/upstream/upstreamcache.cpp b/src/zenserver/upstream/upstreamcache.cpp
index 3e1d1fbd6..e438a840a 100644
--- a/src/zenserver/upstream/upstreamcache.cpp
+++ b/src/zenserver/upstream/upstreamcache.cpp
@@ -14,13 +14,14 @@
 #include <zencore/timer.h>
 #include <zencore/trace.h>
 
-#include <zenhttp/auth/authmgr.h>
+#include <zenhttp/httpclientauth.h>
 #include <zenhttp/packageformat.h>
 
 #include <zenstore/cache/structuredcachestore.h>
 #include <zenstore/cidstore.h>
 
-#include <zenutil/jupiter.h>
+#include <zenutil/jupiter/jupiterclient.h>
+#include <zenutil/jupiter/jupitersession.h>
 
 #include "cache/httpstructuredcache.h"
 #include "diag/logging.h"
@@ -87,7 +88,7 @@ namespace detail {
 	class JupiterUpstreamEndpoint final : public UpstreamEndpoint
 	{
 	public:
-		JupiterUpstreamEndpoint(const CloudCacheClientOptions& Options, const UpstreamAuthConfig& AuthConfig, AuthMgr& Mgr)
+		JupiterUpstreamEndpoint(const JupiterClientOptions& Options, const UpstreamAuthConfig& AuthConfig, AuthMgr& Mgr)
 		: m_AuthMgr(Mgr)
 		, m_Log(zen::logging::Get("upstream"))
 		{
@@ -95,30 +96,27 @@ namespace detail {
 			m_Info.Name = Options.Name;
 			m_Info.Url	= Options.ServiceUrl;
 
-			std::unique_ptr<CloudCacheTokenProvider> TokenProvider;
+			std::function<HttpClientAccessToken()> TokenProvider;
 
 			if (AuthConfig.OAuthUrl.empty() == false)
 			{
-				TokenProvider = CloudCacheTokenProvider::CreateFromOAuthClientCredentials(
+				TokenProvider = httpclientauth::CreateFromOAuthClientCredentials(
 					{.Url = AuthConfig.OAuthUrl, .ClientId = AuthConfig.OAuthClientId, .ClientSecret = AuthConfig.OAuthClientSecret});
 			}
-			else if (AuthConfig.OpenIdProvider.empty() == false)
+			else if (!AuthConfig.OpenIdProvider.empty())
 			{
-				TokenProvider =
-					CloudCacheTokenProvider::CreateFromCallback([this, ProviderName = std::string(AuthConfig.OpenIdProvider)]() {
-						AuthMgr::OpenIdAccessToken Token = m_AuthMgr.GetOpenIdAccessToken(ProviderName);
-						return CloudCacheAccessToken{.Value = Token.AccessToken, .ExpireTime = Token.ExpireTime};
-					});
+				TokenProvider = httpclientauth::CreateFromOpenIdProvider(m_AuthMgr, AuthConfig.OpenIdProvider);
+			}
+			else if (!AuthConfig.AccessToken.empty())
+			{
+				TokenProvider = httpclientauth::CreateFromStaticToken(AuthConfig.AccessToken);
 			}
 			else
 			{
-				CloudCacheAccessToken AccessToken{.Value	  = std::string(AuthConfig.AccessToken),
-												  .ExpireTime = CloudCacheAccessToken::TimePoint::max()};
-
-				TokenProvider = CloudCacheTokenProvider::CreateFromStaticToken(AccessToken);
+				TokenProvider = httpclientauth::CreateFromDefaultOpenIdProvider(m_AuthMgr);
 			}
 
-			m_Client = new CloudCacheClient(Options, std::move(TokenProvider));
+			m_Client = new JupiterClient(Options, std::move(TokenProvider));
 		}
 
 		virtual ~JupiterUpstreamEndpoint() {}
@@ -136,8 +134,8 @@ namespace detail {
 					return {.State = UpstreamEndpointState::kOk};
 				}
 
-				CloudCacheSession	   Session(m_Client);
-				const CloudCacheResult Result = Session.Authenticate();
+				JupiterSession		Session(m_Client->Logger(), m_Client->Client());
+				const JupiterResult Result = Session.Authenticate();
 
 				if (Result.Success)
 				{
@@ -162,20 +160,11 @@ namespace detail {
 			}
 		}
 
-		std::string_view GetActualDdcNamespace(CloudCacheSession& Session, std::string_view Namespace)
-		{
-			if (Namespace == ZenCacheStore::DefaultNamespace)
-			{
-				return Session.Client().DefaultDdcNamespace();
-			}
-			return Namespace;
-		}
-
-		std::string_view GetActualBlobStoreNamespace(CloudCacheSession& Session, std::string_view Namespace)
+		std::string_view GetActualBlobStoreNamespace(std::string_view Namespace)
 		{
 			if (Namespace == ZenCacheStore::DefaultNamespace)
 			{
-				return Session.Client().DefaultBlobStoreNamespace();
+				return m_Client->DefaultBlobStoreNamespace();
 			}
 			return Namespace;
 		}
@@ -192,10 +181,10 @@ namespace detail {
 
 			try
 			{
-				CloudCacheSession Session(m_Client);
-				CloudCacheResult  Result;
+				JupiterSession Session(m_Client->Logger(), m_Client->Client());
+				JupiterResult  Result;
 
-				std::string_view BlobStoreNamespace = GetActualBlobStoreNamespace(Session, Namespace);
+				std::string_view BlobStoreNamespace = GetActualBlobStoreNamespace(Namespace);
 
 				if (Type == ZenContentType::kCompressedBinary)
 				{
@@ -211,7 +200,7 @@ namespace detail {
 							int		 NumAttachments = 0;
 
 							CacheRecord.IterateAttachments([&](CbFieldView AttachmentHash) {
-								CloudCacheResult AttachmentResult = Session.GetCompressedBlob(BlobStoreNamespace, AttachmentHash.AsHash());
+								JupiterResult AttachmentResult = Session.GetCompressedBlob(BlobStoreNamespace, AttachmentHash.AsHash());
 								Result.ReceivedBytes += AttachmentResult.ReceivedBytes;
 								Result.SentBytes += AttachmentResult.SentBytes;
 								Result.ElapsedSeconds += AttachmentResult.ElapsedSeconds;
@@ -251,7 +240,7 @@ namespace detail {
 							CbObject CacheRecord = LoadCompactBinaryObject(Result.Response);
 
 							CacheRecord.IterateAttachments([&](CbFieldView AttachmentHash) {
-								CloudCacheResult AttachmentResult = Session.GetCompressedBlob(BlobStoreNamespace, AttachmentHash.AsHash());
+								JupiterResult AttachmentResult = Session.GetCompressedBlob(BlobStoreNamespace, AttachmentHash.AsHash());
 								Result.ReceivedBytes += AttachmentResult.ReceivedBytes;
 								Result.SentBytes += AttachmentResult.SentBytes;
 								Result.ElapsedSeconds += AttachmentResult.ElapsedSeconds;
@@ -312,7 +301,7 @@ namespace detail {
 		{
 			ZEN_TRACE_CPU("Upstream::Jupiter::GetCacheRecords");
 
-			CloudCacheSession	   Session(m_Client);
+			JupiterSession		   Session(m_Client->Logger(), m_Client->Client());
 			GetUpstreamCacheResult Result;
 
 			for (CacheKeyRequest* Request : Requests)
@@ -324,9 +313,8 @@ namespace detail {
 				double ElapsedSeconds = 0.0;
 				if (!Result.Error)
 				{
-					std::string_view BlobStoreNamespace = GetActualBlobStoreNamespace(Session, Namespace);
-					CloudCacheResult RefResult =
-						Session.GetRef(BlobStoreNamespace, CacheKey.Bucket, CacheKey.Hash, ZenContentType::kCbObject);
+					std::string_view BlobStoreNamespace = GetActualBlobStoreNamespace(Namespace);
+					JupiterResult RefResult = Session.GetRef(BlobStoreNamespace, CacheKey.Bucket, CacheKey.Hash, ZenContentType::kCbObject);
 					AppendResult(RefResult, Result);
 					ElapsedSeconds = RefResult.ElapsedSeconds;
 
@@ -339,7 +327,7 @@ namespace detail {
 						{
 							Record = LoadCompactBinaryObject(RefResult.Response);
 							Record.IterateAttachments([&](CbFieldView AttachmentHash) {
-								CloudCacheResult BlobResult = Session.GetCompressedBlob(BlobStoreNamespace, AttachmentHash.AsHash());
+								JupiterResult BlobResult = Session.GetCompressedBlob(BlobStoreNamespace, AttachmentHash.AsHash());
 								AppendResult(BlobResult, Result);
 
 								m_Status.SetFromErrorCode(BlobResult.ErrorCode, BlobResult.Reason);
@@ -377,9 +365,9 @@ namespace detail {
 
 			try
 			{
-				CloudCacheSession	   Session(m_Client);
-				std::string_view	   BlobStoreNamespace = GetActualBlobStoreNamespace(Session, Namespace);
-				const CloudCacheResult Result			  = Session.GetCompressedBlob(BlobStoreNamespace, ValueContentId);
+				JupiterSession		Session(m_Client->Logger(), m_Client->Client());
+				std::string_view	BlobStoreNamespace = GetActualBlobStoreNamespace(Namespace);
+				const JupiterResult Result			   = Session.GetCompressedBlob(BlobStoreNamespace, ValueContentId);
 
 				m_Status.SetFromErrorCode(Result.ErrorCode, Result.Reason);
 
@@ -410,7 +398,7 @@ namespace detail {
 		{
 			ZEN_TRACE_CPU("Upstream::Jupiter::GetCacheChunks");
 
-			CloudCacheSession	   Session(m_Client);
+			JupiterSession		   Session(m_Client->Logger(), m_Client->Client());
 			GetUpstreamCacheResult Result;
 
 			for (CacheChunkRequest* RequestPtr : CacheChunkRequests)
@@ -424,8 +412,8 @@ namespace detail {
 				bool   IsCompressed	  = false;
 				if (!Result.Error)
 				{
-					std::string_view	   BlobStoreNamespace = GetActualBlobStoreNamespace(Session, Namespace);
-					const CloudCacheResult BlobResult =
+					std::string_view	BlobStoreNamespace = GetActualBlobStoreNamespace(Namespace);
+					const JupiterResult BlobResult =
 						Request.ChunkId == IoHash::Zero
 							? Session.GetInlineBlob(BlobStoreNamespace, Request.Key.Bucket, Request.Key.Hash, Request.ChunkId)
 							: Session.GetCompressedBlob(BlobStoreNamespace, Request.ChunkId);
@@ -465,7 +453,7 @@ namespace detail {
 		{
 			ZEN_TRACE_CPU("Upstream::Jupiter::GetCacheValues");
 
-			CloudCacheSession	   Session(m_Client);
+			JupiterSession		   Session(m_Client->Logger(), m_Client->Client());
 			GetUpstreamCacheResult Result;
 
 			for (CacheValueRequest* RequestPtr : CacheValueRequests)
@@ -479,9 +467,9 @@ namespace detail {
 				bool   IsCompressed	  = false;
 				if (!Result.Error)
 				{
-					std::string_view	   BlobStoreNamespace = GetActualBlobStoreNamespace(Session, Namespace);
-					IoHash				   PayloadHash;
-					const CloudCacheResult BlobResult =
+					std::string_view	BlobStoreNamespace = GetActualBlobStoreNamespace(Namespace);
+					IoHash				PayloadHash;
+					const JupiterResult BlobResult =
 						Session.GetInlineBlob(BlobStoreNamespace, Request.Key.Bucket, Request.Key.Hash, PayloadHash);
 					ElapsedSeconds = BlobResult.ElapsedSeconds;
 					Payload		   = BlobResult.Response;
@@ -545,14 +533,14 @@ namespace detail {
 
 			try
 			{
-				CloudCacheSession Session(m_Client);
+				JupiterSession Session(m_Client->Logger(), m_Client->Client());
 
 				if (CacheRecord.Type == ZenContentType::kBinary)
 				{
-					CloudCacheResult Result;
+					JupiterResult Result;
 					for (uint32_t Attempt = 0; Attempt < MaxAttempts && !Result.Success; Attempt++)
 					{
-						std::string_view BlobStoreNamespace = GetActualBlobStoreNamespace(Session, CacheRecord.Namespace);
+						std::string_view BlobStoreNamespace = GetActualBlobStoreNamespace(CacheRecord.Namespace);
 						Result								= Session.PutRef(BlobStoreNamespace,
 												 CacheRecord.Key.Bucket,
 												 CacheRecord.Key.Hash,
@@ -634,7 +622,7 @@ namespace detail {
 		virtual UpstreamEndpointStats& Stats() override { return m_Stats; }
 
 	private:
-		static void AppendResult(const CloudCacheResult& Result, GetUpstreamCacheResult& Out)
+		static void AppendResult(const JupiterResult& Result, GetUpstreamCacheResult& Out)
 		{
 			Out.Success &= Result.Success;
 			Out.Bytes += gsl::narrow<int64_t>(Result.ReceivedBytes);
@@ -647,7 +635,7 @@ namespace detail {
 		};
 
 		PutUpstreamCacheResult PerformStructuredPut(
-			CloudCacheSession&																				 Session,
+			JupiterSession&																					 Session,
 			std::string_view																				 Namespace,
 			const CacheKey&																					 Key,
 			IoBuffer																						 ObjectBuffer,
@@ -657,7 +645,7 @@ namespace detail {
 			int64_t TotalBytes			= 0ull;
 			double	TotalElapsedSeconds = 0.0;
 
-			std::string_view BlobStoreNamespace = GetActualBlobStoreNamespace(Session, Namespace);
+			std::string_view BlobStoreNamespace = GetActualBlobStoreNamespace(Namespace);
 			const auto		 PutBlobs			= [&](std::span<IoHash> ValueContentIds, std::string& OutReason) -> bool {
 				for (const IoHash& ValueContentId : ValueContentIds)
 				{
@@ -667,7 +655,7 @@ namespace detail {
 						return false;
 					}
 
-					CloudCacheResult BlobResult;
+					JupiterResult BlobResult;
 					for (int32_t Attempt = 0; Attempt < MaxAttempts && !BlobResult.Success; Attempt++)
 					{
 						BlobResult = Session.PutCompressedBlob(BlobStoreNamespace, ValueContentId, BlobBuffer);
@@ -762,12 +750,12 @@ namespace detail {
 
 		LoggerRef Log() { return m_Log; }
 
-		AuthMgr&				 m_AuthMgr;
-		LoggerRef				 m_Log;
-		UpstreamEndpointInfo	 m_Info;
-		UpstreamStatus			 m_Status;
-		UpstreamEndpointStats	 m_Stats;
-		RefPtr<CloudCacheClient> m_Client;
+		AuthMgr&			  m_AuthMgr;
+		LoggerRef			  m_Log;
+		UpstreamEndpointInfo  m_Info;
+		UpstreamStatus		  m_Status;
+		UpstreamEndpointStats m_Stats;
+		RefPtr<JupiterClient> m_Client;
 	};
 
 	class ZenUpstreamEndpoint final : public UpstreamEndpoint
@@ -2131,7 +2119,7 @@ UpstreamEndpoint::CreateZenEndpoint(const ZenStructuredCacheClientOptions& Optio
 }
 
 std::unique_ptr<UpstreamEndpoint>
-UpstreamEndpoint::CreateJupiterEndpoint(const CloudCacheClientOptions& Options, const UpstreamAuthConfig& AuthConfig, AuthMgr& Mgr)
+UpstreamEndpoint::CreateJupiterEndpoint(const JupiterClientOptions& Options, const UpstreamAuthConfig& AuthConfig, AuthMgr& Mgr)
 {
 	return std::make_unique<detail::JupiterUpstreamEndpoint>(Options, AuthConfig, Mgr);
 }
diff --git a/src/zenserver/upstream/upstreamcache.h b/src/zenserver/upstream/upstreamcache.h
index bb0193e4e..26e5decac 100644
--- a/src/zenserver/upstream/upstreamcache.h
+++ b/src/zenserver/upstream/upstreamcache.h
@@ -26,8 +26,8 @@ class CbPackage;
 class CbObjectWriter;
 class CidStore;
 class ZenCacheStore;
-struct CloudCacheClientOptions;
-class CloudCacheTokenProvider;
+struct JupiterClientOptions;
+class JupiterAccessTokenProvider;
 struct ZenStructuredCacheClientOptions;
 
 struct UpstreamEndpointStats
@@ -128,9 +128,9 @@ public:
 
 	static std::unique_ptr<UpstreamEndpoint> CreateZenEndpoint(const ZenStructuredCacheClientOptions& Options);
 
-	static std::unique_ptr<UpstreamEndpoint> CreateJupiterEndpoint(const CloudCacheClientOptions& Options,
-																   const UpstreamAuthConfig&	  AuthConfig,
-																   AuthMgr&						  Mgr);
+	static std::unique_ptr<UpstreamEndpoint> CreateJupiterEndpoint(const JupiterClientOptions& Options,
+																   const UpstreamAuthConfig&   AuthConfig,
+																   AuthMgr&					   Mgr);
 };
 
 /**
diff --git a/src/zenserver/upstream/upstreamservice.cpp b/src/zenserver/upstream/upstreamservice.cpp
index 3d4a0f823..1dcbdb604 100644
--- a/src/zenserver/upstream/upstreamservice.cpp
+++ b/src/zenserver/upstream/upstreamservice.cpp
@@ -2,7 +2,6 @@
 #include <upstream/upstreamservice.h>
 
 #include <upstream/upstreamcache.h>
-#include <zenhttp/auth/authmgr.h>
 
 #include <zencore/compactbinarybuilder.h>
 #include <zencore/string.h>
diff --git a/src/zenserver/zenserver.cpp b/src/zenserver/zenserver.cpp
index 9c27aa5c8..f84bc0b00 100644
--- a/src/zenserver/zenserver.cpp
+++ b/src/zenserver/zenserver.cpp
@@ -26,7 +26,7 @@
 #include <zenstore/cidstore.h>
 #include <zenstore/scrubcontext.h>
 #include <zenstore/workspaces.h>
-#include <zenutil/jupiter.h>
+#include <zenutil/jupiter/jupiterclient.h>
 #include <zenutil/workerpools.h>
 #include <zenutil/zenserverprocess.h>
 
@@ -599,12 +599,12 @@ ZenServer::InitializeStructuredCache(const ZenServerOptions& ServerOptions)
 		{
 			std::string_view EndpointName = UpstreamConfig.JupiterConfig.Name.empty() ? "Jupiter"sv : UpstreamConfig.JupiterConfig.Name;
 
-			auto Options = CloudCacheClientOptions{.Name			   = EndpointName,
-												   .ServiceUrl		   = UpstreamConfig.JupiterConfig.Url,
-												   .DdcNamespace	   = UpstreamConfig.JupiterConfig.DdcNamespace,
-												   .BlobStoreNamespace = UpstreamConfig.JupiterConfig.Namespace,
-												   .ConnectTimeout = std::chrono::milliseconds(UpstreamConfig.ConnectTimeoutMilliseconds),
-												   .Timeout		   = std::chrono::milliseconds(UpstreamConfig.TimeoutMilliseconds)};
+			auto Options = JupiterClientOptions{.Name				= EndpointName,
+												.ServiceUrl			= UpstreamConfig.JupiterConfig.Url,
+												.DdcNamespace		= UpstreamConfig.JupiterConfig.DdcNamespace,
+												.BlobStoreNamespace = UpstreamConfig.JupiterConfig.Namespace,
+												.ConnectTimeout		= std::chrono::milliseconds(UpstreamConfig.ConnectTimeoutMilliseconds),
+												.Timeout			= std::chrono::milliseconds(UpstreamConfig.TimeoutMilliseconds)};
 
 			auto AuthConfig = UpstreamAuthConfig{.OAuthUrl			= UpstreamConfig.JupiterConfig.OAuthUrl,
 												 .OAuthClientId		= UpstreamConfig.JupiterConfig.OAuthClientId,