Zen cmd fixes (#201)

* updated drop command to support namespaces
* fixed hash command error message
* fix output of status (and top) command
* Use ZEN_CONSOLE for output in zen commands
* changelog

14 files changed, 112 insertions, 81 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 18cbb84d0..f8bcd92fa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,10 @@
 - Improvement: Disk write pressure in GC log and cleaned up clutter in GC logging.
 - Improvement: Much improved performance, between 2x to 9x improvement under heavy load (excluding http service overhead). See https://github.com/EpicGames/zen/pull/200 for details.
 - Bugfix: Always store records or oplog entries before storing attachments to avoid GC finding unreferenced chunks i CidStore
+- Bugfix: Updated Zen `drop` command to support namespaces
+- Bugfix: Use ZEN_CONSOLE for output to console in Zen commands
+- Bugfix: Zen `status` command now shows info about found Zen instances
+- Bugfix: Zen `top` command now shows session id string
 - Changed: Reduced GC `INFO` spam by converting to `DEBUG` log messages
 - Changed: Use Iso8601 format for logging start and end message
 
diff --git a/zen/cmds/cache.cpp b/zen/cmds/cache.cpp
index f1b953af5..a4fe4da34 100644
--- a/zen/cmds/cache.cpp
+++ b/zen/cmds/cache.cpp
@@ -16,8 +16,8 @@ ZEN_THIRD_PARTY_INCLUDES_END
 DropCommand::DropCommand()
 {
 	m_Options.add_options()("h,help", "Print help");
+	m_Options.add_option("", "n", "namespace", "Namnspace name", cxxopts::value(m_NamespaceName), "<namespacename>");
 	m_Options.add_option("", "b", "bucket", "Bucket name", cxxopts::value(m_BucketName), "<bucketname>");
-	m_Options.add_option("", "", "positional", "Positional arguments", cxxopts::value(m_Positional), "");
 }
 
 DropCommand::~DropCommand() = default;
@@ -27,18 +27,31 @@ DropCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 {
 	ZEN_UNUSED(GlobalOptions, argc, argv);
 
-	m_Options.parse_positional({"bucket", "positional"});
+	m_Options.parse_positional({"namespace", "bucket"});
 	m_Options.parse(argc, argv);
 
-	ZEN_INFO("Dropping cache bucket '{}' from '{}'", m_BucketName, m_HostName);
+	if (m_NamespaceName.empty())
+	{
+		throw cxxopts::OptionParseException("Drop command requires a namespace");
+	}
 
 	cpr::Session Session;
-	Session.SetUrl({fmt::format("{}/z$/{}", m_HostName, m_BucketName)});
+	if (m_BucketName.empty())
+	{
+		ZEN_CONSOLE("Dropping cache namespace '{}' from '{}'", m_NamespaceName, m_HostName);
+		Session.SetUrl({fmt::format("{}/z$/{}", m_HostName, m_NamespaceName)});
+	}
+	else
+	{
+		ZEN_CONSOLE("Dropping cache bucket '{}/{}' from '{}'", m_NamespaceName, m_BucketName, m_HostName);
+		Session.SetUrl({fmt::format("{}/z$/{}/{}", m_HostName, m_NamespaceName, m_BucketName)});
+	}
+
 	cpr::Response Result = Session.Delete();
 
 	if (zen::IsHttpSuccessCode(Result.status_code))
 	{
-		ZEN_INFO("OK: dropped cache bucket '{}' from '{}'", m_BucketName, m_HostName);
+		ZEN_CONSOLE("OK: drop succeeded");
 
 		return 0;
 	}
diff --git a/zen/cmds/cache.h b/zen/cmds/cache.h
index 7e37ce914..1eb32eb99 100644
--- a/zen/cmds/cache.h
+++ b/zen/cmds/cache.h
@@ -14,8 +14,8 @@ public:
 	virtual cxxopts::Options* Options() override { return &m_Options; }
 
 private:
-	cxxopts::Options		 m_Options{"drop", "Drop one or more cache buckets"};
-	std::vector<std::string> m_Positional;
-	std::string				 m_BucketName;
-	std::string				 m_HostName{"http://localhost:1337"};
+	cxxopts::Options m_Options{"drop", "Drop one or more cache buckets"};
+	std::string		 m_NamespaceName;
+	std::string		 m_BucketName;
+	std::string		 m_HostName{"http://localhost:1337"};
 };
diff --git a/zen/cmds/copy.cpp b/zen/cmds/copy.cpp
index c9b40408e..f3ca242e3 100644
--- a/zen/cmds/copy.cpp
+++ b/zen/cmds/copy.cpp
@@ -91,7 +91,7 @@ CopyCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		CopyOptions.EnableClone = !m_NoClone;
 		zen::CopyFile(FromPath, ToPath, CopyOptions);
 
-		ZEN_INFO("Copy completed in {}", zen::NiceTimeSpanMs(Timer.GetElapsedTimeMs()));
+		ZEN_CONSOLE("Copy completed in {}", zen::NiceTimeSpanMs(Timer.GetElapsedTimeMs()));
 	}
 
 	return 0;
diff --git a/zen/cmds/dedup.cpp b/zen/cmds/dedup.cpp
index 7f735571c..2b599c307 100644
--- a/zen/cmds/dedup.cpp
+++ b/zen/cmds/dedup.cpp
@@ -71,22 +71,22 @@ DedupCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 	if (!SourceGood)
 	{
-		ZEN_INFO("Source directory '{}' does not support deduplication", m_DedupSource);
+		ZEN_ERROR("Source directory '{}' does not support deduplication", m_DedupSource);
 
 		return 0;
 	}
 
 	if (!TargetGood)
 	{
-		ZEN_INFO("Target directory '{}' does not support deduplication", m_DedupTarget);
+		ZEN_ERROR("Target directory '{}' does not support deduplication", m_DedupTarget);
 
 		return 0;
 	}
 
-	ZEN_INFO("Performing dedup operation between {} and {}, size threshold {}",
-			 m_DedupSource,
-			 m_DedupTarget,
-			 zen::NiceBytes(m_SizeThreshold));
+	ZEN_CONSOLE("Performing dedup operation between {} and {}, size threshold {}",
+				m_DedupSource,
+				m_DedupTarget,
+				zen::NiceBytes(m_SizeThreshold));
 
 	using DirEntryList_t = std::list<std::filesystem::directory_entry>;
 
@@ -109,8 +109,8 @@ DedupCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 	std::filesystem::recursive_directory_iterator DirEnd;
 
-	ZEN_INFO("Gathering file info from source: '{}'", m_DedupSource);
-	ZEN_INFO("Gathering file info from target: '{}'", m_DedupTarget);
+	ZEN_CONSOLE("Gathering file info from source: '{}'", m_DedupSource);
+	ZEN_CONSOLE("Gathering file info from target: '{}'", m_DedupTarget);
 
 	{
 		zen::Stopwatch Timer;
@@ -129,13 +129,13 @@ DedupCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 				}
 			});
 
-		ZEN_INFO("Gathered {} candidates across {} size buckets. Elapsed: {}",
-				 CandidateCount,
-				 FileSizeMap.size(),
-				 zen::NiceTimeSpanMs(Timer.GetElapsedTimeMs()));
+		ZEN_CONSOLE("Gathered {} candidates across {} size buckets. Elapsed: {}",
+					CandidateCount,
+					FileSizeMap.size(),
+					zen::NiceTimeSpanMs(Timer.GetElapsedTimeMs()));
 	}
 
-	ZEN_INFO("Sorting buckets by size");
+	ZEN_CONSOLE("Sorting buckets by size");
 
 	zen::Stopwatch Timer;
 
@@ -163,7 +163,7 @@ DedupCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 	std::sort(begin(SizeLists), end(SizeLists), [](const SizeList& Lhs, const SizeList& Rhs) { return Lhs.Size > Rhs.Size; });
 
-	ZEN_INFO("Bucket summary:");
+	ZEN_CONSOLE("Bucket summary:");
 
 	std::vector<size_t> BucketId;
 	std::vector<size_t> BucketOffsets;
@@ -220,10 +220,10 @@ DedupCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 	for (size_t i = 0; i < BucketOffsets.size(); ++i)
 	{
-		ZEN_INFO("  Bucket {} : {}, {} candidates", zen::NiceBytes(BucketId[i]), zen::NiceBytes(BucketSizes[i]), BucketFileCounts[i]);
+		ZEN_CONSOLE("  Bucket {} : {}, {} candidates", zen::NiceBytes(BucketId[i]), zen::NiceBytes(BucketSizes[i]), BucketFileCounts[i]);
 	}
 
-	ZEN_INFO("Total : {}, {} candidates", zen::NiceBytes(TotalFileSizes), TotalFileCount);
+	ZEN_CONSOLE("Total : {}, {} candidates", zen::NiceBytes(TotalFileSizes), TotalFileCount);
 
 	std::string CurrentNice;
 
@@ -234,7 +234,7 @@ DedupCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		if (CurNice != CurrentNice)
 		{
 			CurrentNice = CurNice;
-			ZEN_INFO("Now scanning bucket: {}", CurrentNice);
+			ZEN_CONSOLE("Now scanning bucket: {}", CurrentNice);
 		}
 
 		std::unordered_map<zen::BLAKE3, const std::filesystem::directory_entry*, zen::BLAKE3::Hasher> DedupMap;
@@ -299,7 +299,7 @@ DedupCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		Size.DirEntries->clear();
 	}
 
-	ZEN_INFO("Elapsed: {} Deduped: {}", zen::NiceTimeSpanMs(Timer.GetElapsedTimeMs()), zen::NiceBytes(DupeBytes));
+	ZEN_CONSOLE("Elapsed: {} Deduped: {}", zen::NiceTimeSpanMs(Timer.GetElapsedTimeMs()), zen::NiceBytes(DupeBytes));
 
 	return 0;
 }
diff --git a/zen/cmds/exportproject.cpp b/zen/cmds/exportproject.cpp
index 36d37bb60..8c7c6821b 100644
--- a/zen/cmds/exportproject.cpp
+++ b/zen/cmds/exportproject.cpp
@@ -88,7 +88,7 @@ ExportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 
 	cpr::Session Session;
 	{
-		ZEN_INFO("Requesting project '{}' from '{}'", m_ProjectName, m_HostName);
+		ZEN_CONSOLE("Requesting project '{}' from '{}'", m_ProjectName, m_HostName);
 
 		std::string ProjectRequest = fmt::format("{}/{}", UrlBase, m_ProjectName);
 		Session.SetUrl({ProjectRequest});
@@ -119,7 +119,7 @@ ExportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 	std::vector<zen::CbPackage>							 OplogResponses;
 	for (const std::string& OplogName : m_OplogNames)
 	{
-		ZEN_INFO("Requesting oplog '{}/{}' from '{}' to '{}'", m_ProjectName, OplogName, m_HostName, m_TargetPath);
+		ZEN_CONSOLE("Requesting oplog '{}/{}' from '{}' to '{}'", m_ProjectName, OplogName, m_HostName, m_TargetPath);
 
 		std::string GetOplogArchiveRequest = fmt::format("{}/{}/oplog/{}/archive", UrlBase, m_ProjectName, OplogName);
 		Session.SetUrl({GetOplogArchiveRequest});
@@ -139,12 +139,12 @@ ExportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 		zen::IoHash		  Checksum = Result["checksum"sv].AsHash();
 		zen ::CbArrayView Entries  = Result["entries"sv].AsArrayView();
 
-		ZEN_INFO("Exporting {} ops for oplog '{}/{}' with checksum '{}' to '{}'",
-				 Entries.Num(),
-				 m_ProjectName,
-				 OplogName,
-				 Checksum,
-				 m_TargetPath);
+		ZEN_CONSOLE("Exporting {} ops for oplog '{}/{}' with checksum '{}' to '{}'",
+					Entries.Num(),
+					m_ProjectName,
+					OplogName,
+					Checksum,
+					m_TargetPath);
 		{
 			zen::BasicFile OpStore;
 			OpStore.Open(GetOplogPath(m_TargetPath, OplogName), zen::BasicFile::Mode::kTruncate);
@@ -190,7 +190,7 @@ ExportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 			}
 		}
 
-		ZEN_INFO("Exported {} ops referencing {} chunks for {}", Entries.Num(), Attachments.size(), OplogName);
+		ZEN_CONSOLE("Exported {} ops referencing {} chunks for {}", Entries.Num(), Attachments.size(), OplogName);
 	}
 
 	size_t		   ChunkCount = AllAttachments.size();
@@ -236,7 +236,7 @@ ExportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 		});
 	};
 
-	ZEN_INFO("Exporting {} chunks from '{}' to '{}'", AllAttachments.size(), m_HostName, m_TargetPath);
+	ZEN_CONSOLE("Exporting {} chunks from '{}' to '{}'", AllAttachments.size(), m_HostName, m_TargetPath);
 	for (size_t ChunkIndex = 0; const zen::CbAttachment& Attachment : AllAttachments)
 	{
 		ChunkEntry& Chunk					= ChunkEntries[ChunkIndex];
@@ -309,7 +309,7 @@ ExportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 
 	ChunkStoreIndex.Write(ChunkEntries.data(), ChunkEntries.size() * sizeof(ChunkEntry), sizeof(ChunksHeader));
 
-	ZEN_INFO("Exported {} chunks from '{}' to '{}'", AllAttachments.size(), m_HostName, m_TargetPath);
+	ZEN_CONSOLE("Exported {} chunks from '{}' to '{}'", AllAttachments.size(), m_HostName, m_TargetPath);
 
 	return 0;
 }
diff --git a/zen/cmds/hash.cpp b/zen/cmds/hash.cpp
index 59dea5a5d..95f960e29 100644
--- a/zen/cmds/hash.cpp
+++ b/zen/cmds/hash.cpp
@@ -70,11 +70,11 @@ HashCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	bool valid = m_ScanDirectory.length();
 
 	if (!valid)
-		throw cxxopts::OptionParseException("Chunk command requires a directory to scan");
+		throw cxxopts::OptionParseException("Hash command requires a directory to scan");
 
 	// Gather list of files to process
 
-	ZEN_INFO("Gathering files from {}", m_ScanDirectory);
+	ZEN_CONSOLE("Gathering files from {}", m_ScanDirectory);
 
 	struct FileEntry
 	{
@@ -96,7 +96,7 @@ HashCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		}
 	}
 
-	ZEN_INFO("Gathered {} files, total size {}", FileList.size(), zen::NiceBytes(FileBytes));
+	ZEN_CONSOLE("Gathered {} files, total size {}", FileList.size(), zen::NiceBytes(FileBytes));
 
 	Concurrency::combinable<uint64_t> TotalBytes;
 
@@ -129,8 +129,8 @@ HashCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	TotalBytes.combine_each([&](size_t Total) { TotalByteCount += Total; });
 
 	const uint64_t ElapsedMs = Timer.GetElapsedTimeMs();
-	ZEN_INFO("Scanned {} files in {}", FileList.size(), zen::NiceTimeSpanMs(ElapsedMs));
-	ZEN_INFO("Total bytes {} ({})", zen::NiceBytes(TotalByteCount), zen::NiceByteRate(TotalByteCount, ElapsedMs));
+	ZEN_CONSOLE("Scanned {} files in {}", FileList.size(), zen::NiceTimeSpanMs(ElapsedMs));
+	ZEN_CONSOLE("Total bytes {} ({})", zen::NiceBytes(TotalByteCount), zen::NiceByteRate(TotalByteCount, ElapsedMs));
 
 	InternalFile Output;
 
diff --git a/zen/cmds/importproject.cpp b/zen/cmds/importproject.cpp
index d6c48cdeb..f92e8fcc0 100644
--- a/zen/cmds/importproject.cpp
+++ b/zen/cmds/importproject.cpp
@@ -65,7 +65,7 @@ ImportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 	cpr::Session Session;
 
 	{
-		ZEN_INFO("Requesting project '{}' from '{}'", m_ProjectName, m_HostName);
+		ZEN_CONSOLE("Requesting project '{}' from '{}'", m_ProjectName, m_HostName);
 
 		zen::BasicFile ProjectStore;
 		ProjectStore.Open(ExportProjectCommand::GetProjectPath(m_SourcePath, m_ProjectName), zen::BasicFile::Mode::kRead);
@@ -113,7 +113,7 @@ ImportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 
 	for (const std::string& OplogName : m_OplogNames)
 	{
-		ZEN_INFO("Importing oplog '{}/{}' from '{}' to '{}'", m_ProjectName, OplogName, m_SourcePath, m_HostName);
+		ZEN_CONSOLE("Importing oplog '{}/{}' from '{}' to '{}'", m_ProjectName, OplogName, m_SourcePath, m_HostName);
 		std::string GetOplogRequest = fmt::format("{}/{}/oplog/{}", UrlBase, m_ProjectName, OplogName);
 		Session.SetUrl(GetOplogRequest);
 		cpr::Response OplogResponse = Session.Get();
@@ -149,11 +149,11 @@ ImportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 					 sizeof(ExportProjectCommand::OplogEntry) * OplogHeader.OpCount,
 					 sizeof(ExportProjectCommand::OplogHeader));
 
-		ZEN_INFO("Constructing oplog with {} ops with checksum '{}' for '{}/{}'",
-				 OpEntries.size(),
-				 OplogHeader.Checksum,
-				 m_ProjectName,
-				 OplogName);
+		ZEN_CONSOLE("Constructing oplog with {} ops with checksum '{}' for '{}/{}'",
+					OpEntries.size(),
+					OplogHeader.Checksum,
+					m_ProjectName,
+					OplogName);
 		zen::IoHashStream	Hasher;
 		zen::CbObjectWriter Request;
 		Request.BeginArray("entries"sv);
@@ -179,7 +179,7 @@ ImportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 		zen::CbPackage RequestPackage;
 		RequestPackage.SetObject(Request.Save());
 
-		ZEN_INFO("Assembling {} attachments", ChunksHeader->ChunkCount);
+		ZEN_CONSOLE("Assembling {} attachments", ChunksHeader->ChunkCount);
 		std::vector<zen::CbAttachment> Attachments;
 		Attachments.reserve(ChunksHeader->ChunkCount);
 		uint32_t	  ReadBlockIndex = 0;
@@ -213,12 +213,12 @@ ImportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 		}
 		RequestPackage.AddAttachments(Attachments);
 
-		ZEN_INFO("Sending oplog with {} ops and {} attachments for '{}/{}' to {}",
-				 OpEntries.size(),
-				 ChunksHeader->ChunkCount,
-				 m_ProjectName,
-				 OplogName,
-				 m_HostName);
+		ZEN_CONSOLE("Sending oplog with {} ops and {} attachments for '{}/{}' to {}",
+					OpEntries.size(),
+					ChunksHeader->ChunkCount,
+					m_ProjectName,
+					OplogName,
+					m_HostName);
 		std::vector<zen::IoBuffer>	   RequestPayload = zen::FormatPackageMessage(RequestPackage, zen::FormatFlags::kAllowLocalReferences);
 		std::vector<zen::SharedBuffer> Parts;
 		Parts.reserve(RequestPayload.size());
@@ -240,7 +240,7 @@ ImportProjectCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** a
 			return 1;
 		}
 
-		ZEN_INFO("Imported {} ops and {} chunks", OpEntries.size(), ChunksHeader->ChunkCount);
+		ZEN_CONSOLE("Imported {} ops and {} chunks", OpEntries.size(), ChunksHeader->ChunkCount);
 	}
 	return 0;
 }
diff --git a/zen/cmds/print.cpp b/zen/cmds/print.cpp
index abfb8eee9..067dc844a 100644
--- a/zen/cmds/print.cpp
+++ b/zen/cmds/print.cpp
@@ -19,7 +19,7 @@ PrintCbObject(CbObject Object)
 {
 	zen::StringBuilder<1024> ObjStr;
 	zen::CompactBinaryToJson(Object, ObjStr);
-	zen::ConsoleLog().info("{}", ObjStr);
+	ZEN_CONSOLE("{}", ObjStr);
 }
 
 static void
@@ -72,7 +72,7 @@ PrintCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 	if (Fc.ErrorCode)
 	{
-		zen::ConsoleLog().error("Failed to read file '{}': {}", m_Filename, Fc.ErrorCode.message());
+		ZEN_ERROR("Failed to read file '{}': {}", m_Filename, Fc.ErrorCode.message());
 
 		return 1;
 	}
@@ -83,7 +83,7 @@ PrintCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	uint64_t RawSize;
 	if (CompressedBuffer::ValidateCompressedHeader(Data, RawHash, RawSize))
 	{
-		zen::ConsoleLog().info("Compressed binary: size {}, raw size {}, hash: {}", Data.GetSize(), RawSize, RawHash);
+		ZEN_CONSOLE("Compressed binary: size {}, raw size {}, hash: {}", Data.GetSize(), RawSize, RawHash);
 	}
 	else if (IsPackageMessage(Data))
 	{
@@ -92,8 +92,8 @@ PrintCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		CbObject					  Object	  = Package.GetObject();
 		std::span<const CbAttachment> Attachments = Package.GetAttachments();
 
-		zen::ConsoleLog().info("Package - {} attachments, object hash {}", Package.GetAttachments().size(), Package.GetObjectHash());
-		zen::ConsoleLog().info("");
+		ZEN_CONSOLE("Package - {} attachments, object hash {}", Package.GetAttachments().size(), Package.GetObjectHash());
+		ZEN_CONSOLE("");
 
 		int AttachmentIndex = 1;
 
@@ -124,16 +124,12 @@ PrintCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 				AttachmentType = "null";
 			}
 
-			zen::ConsoleLog().info("Attachment #{} : {}, {}, size {}",
-								   AttachmentIndex,
-								   Attachment.GetHash(),
-								   AttachmentType,
-								   AttachmentSize);
+			ZEN_CONSOLE("Attachment #{} : {}, {}, size {}", AttachmentIndex, Attachment.GetHash(), AttachmentType, AttachmentSize);
 
 			++AttachmentIndex;
 		}
 
-		zen::ConsoleLog().info("---8<---");
+		ZEN_CONSOLE("---8<---");
 
 		PrintCbObject(Object);
 	}
@@ -143,9 +139,7 @@ PrintCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	}
 	else
 	{
-		zen::ConsoleLog().error("Data in file '{}' does not appear to be compact binary (validation error {:#x})",
-								m_Filename,
-								uint32_t(Result));
+		ZEN_ERROR("Data in file '{}' does not appear to be compact binary (validation error {:#x})", m_Filename, uint32_t(Result));
 
 		return 1;
 	}
@@ -196,11 +190,11 @@ PrintPackageCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** ar
 	{
 		zen::StringBuilder<1024> ObjStr;
 		zen::CompactBinaryToJson(Package.GetObject(), ObjStr);
-		zen::ConsoleLog().info("{}", ObjStr);
+		ZEN_CONSOLE("{}", ObjStr);
 	}
 	else
 	{
-		zen::ConsoleLog().error("error: malformed package?");
+		ZEN_ERROR("error: malformed package?");
 	}
 
 	return 0;
diff --git a/zen/cmds/run.cpp b/zen/cmds/run.cpp
index 86e67b391..6e04d7ebf 100644
--- a/zen/cmds/run.cpp
+++ b/zen/cmds/run.cpp
@@ -175,7 +175,7 @@ RunCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	cpr::Response JobResponse =
 		cpr::Post(cpr::Url("http://localhost:13337/exec/jobs"), cpr::Body((const char*)MemOut.Data(), MemOut.Size()));
 
-	ZEN_INFO("job exec: {}", JobResponse.status_code);
+	ZEN_CONSOLE("job exec: {}", JobResponse.status_code);
 
 	return 0;
 }
diff --git a/zen/cmds/status.cpp b/zen/cmds/status.cpp
index 10970e3c2..23c27f9f9 100644
--- a/zen/cmds/status.cpp
+++ b/zen/cmds/status.cpp
@@ -3,6 +3,9 @@
 #include "status.h"
 
 #include <zencore/logging.h>
+#include <zencore/string.h>
+#include <zencore/uid.h>
+#include <zenutil/zenserverprocess.h>
 
 namespace zen {
 
@@ -17,6 +20,21 @@ StatusCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 {
 	ZEN_UNUSED(GlobalOptions, argc, argv);
 
+	ZenServerState State;
+	if (!State.InitializeReadOnly())
+	{
+		ZEN_CONSOLE("no Zen state found");
+
+		return 0;
+	}
+
+	ZEN_CONSOLE("{:>5} {:>6} {:>24}", "port", "pid", "session");
+	State.Snapshot([&](const ZenServerState::ZenServerEntry& Entry) {
+		StringBuilder<25> SessionStringBuilder;
+		Entry.GetSessionId().ToString(SessionStringBuilder);
+		ZEN_CONSOLE("{:>5} {:>6} {:>24}", Entry.EffectiveListenPort, Entry.Pid, SessionStringBuilder.ToString());
+	});
+
 	return 0;
 }
 
diff --git a/zen/cmds/top.cpp b/zen/cmds/top.cpp
index 21e4dc60e..4fe8c9cdf 100644
--- a/zen/cmds/top.cpp
+++ b/zen/cmds/top.cpp
@@ -43,7 +43,9 @@ TopCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		}
 
 		State.Snapshot([&](const ZenServerState::ZenServerEntry& Entry) {
-			ZEN_CONSOLE("{:5} {:6} {:24}", Entry.EffectiveListenPort, Entry.Pid, Entry.GetSessionId());
+			StringBuilder<25> SessionStringBuilder;
+			Entry.GetSessionId().ToString(SessionStringBuilder);
+			ZEN_CONSOLE("{:>5} {:>6} {:>24}", Entry.EffectiveListenPort, Entry.Pid, SessionStringBuilder.ToString());
 		});
 
 		zen::Sleep(1000);
diff --git a/zen/cmds/up.cpp b/zen/cmds/up.cpp
index 17cba3794..9fa1cdd8c 100644
--- a/zen/cmds/up.cpp
+++ b/zen/cmds/up.cpp
@@ -36,7 +36,7 @@ UpCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	}
 	else
 	{
-		ZEN_INFO("zen server up");
+		ZEN_CONSOLE("zen server up");
 	}
 
 	return 0;
@@ -79,11 +79,11 @@ DownCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 		ZenServerInstance Server(ServerEnvironment);
 		Server.AttachToRunningServer(ListenPort);
 
-		ZEN_INFO("attached to server on port {}, requesting shutdown", ListenPort);
+		ZEN_CONSOLE("attached to server on port {}, requesting shutdown", ListenPort);
 
 		Server.Shutdown();
 
-		ZEN_INFO("shutdown complete");
+		ZEN_CONSOLE("shutdown complete");
 
 		return 0;
 	}
diff --git a/zen/zen.cpp b/zen/zen.cpp
index 792751d43..447c4f825 100644
--- a/zen/zen.cpp
+++ b/zen/zen.cpp
@@ -144,7 +144,7 @@ main(int argc, char** argv)
 //		{"chunk",		&ChunkCmd,		"Perform chunking"},
 		{"copy",		&CopyCmd,		"Copy file(s)"},
 		{"dedup",		&DedupCmd,		"Dedup files"},
-		{"drop",		&DropCmd,		"Drop cache bucket(s)"},
+		{"drop",		&DropCmd,		"Drop cache namespace or bucket"},
 		{"export-project",		&ExportProjectCmd,		"Export project store oplog"},
 		{"hash",		&HashCmd,		"Compute file hashes"},
 		{"import-project",		&ImportProjectCmd,		"Import project store oplog"},