Improved details for build and pull (#40596)

craigloewen-msft · web-flow · commit 6b39b6dad37d · 2026-05-28T13:25:13.000-07:00
* Improved details for build and pull
diff --git a/src/shared/inc/stringshared.h b/src/shared/inc/stringshared.h
@@ -825,6 +825,30 @@ struct CaseInsensitiveCompare
     }
 };
 
+inline std::wstring FormatBytes(uint64_t bytes)
+{
+    constexpr double c_kB = 1000.0;
+    constexpr double c_MB = 1000.0 * 1000.0;
+    constexpr double c_GB = 1000.0 * 1000.0 * 1000.0;
+
+    if (bytes >= static_cast<uint64_t>(c_GB))
+    {
+        return std::format(L"{:.2f} GB", bytes / c_GB);
+    }
+    else if (bytes >= static_cast<uint64_t>(c_MB))
+    {
+        return std::format(L"{:.2f} MB", bytes / c_MB);
+    }
+    else if (bytes >= static_cast<uint64_t>(c_kB))
+    {
+        return std::format(L"{:.2f} KB", bytes / c_kB);
+    }
+    else
+    {
+        return std::format(L"{} B", bytes);
+    }
+}
+
 } // namespace wsl::shared::string
 
 template <>
diff --git a/src/windows/inc/docker_schema.h b/src/windows/inc/docker_schema.h
@@ -584,8 +584,10 @@ struct BuildKitStatus
 {
     std::string id;
     std::string vertex;
+    int64_t current{};
+    int64_t total{};
 
-    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(BuildKitStatus, id, vertex);
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(BuildKitStatus, id, vertex, current, total);
 };
 
 struct BuildKitLog
diff --git a/src/windows/wslc/services/BuildImageCallback.cpp b/src/windows/wslc/services/BuildImageCallback.cpp
@@ -19,6 +19,15 @@ namespace wsl::windows::wslc::services {
 
 using wsl::windows::common::string::MultiByteToWide;
 
+namespace {
+    constexpr std::wstring_view c_escapeMoveCursorUpAndClear = L"\033[{}A\033[J";
+    constexpr std::wstring_view c_escapeBrightGreen = L"\033[92m";
+    constexpr std::wstring_view c_escapeResetAttributes = L"\033[0m";
+    constexpr std::wstring_view c_escapeHideCursorDim = L"\033[?25l\033[2m";
+    constexpr std::wstring_view c_escapeClearLineAndNewline = L"\033[K\n";
+    constexpr std::wstring_view c_escapeUndimShowCursor = L"\033[22m\033[?25h";
+} // namespace
+
 BuildImageCallback::~BuildImageCallback()
 try
 {
@@ -58,15 +67,26 @@ void BuildImageCallback::CollapseWindow()
 {
     if (m_displayedLines > 0)
     {
-        WriteTerminal(std::format(L"\033[{}A\033[J", m_displayedLines));
+        WriteTerminal(std::format(c_escapeMoveCursorUpAndClear, m_displayedLines));
         m_displayedLines = 0;
     }
 
     m_lines.clear();
     m_pendingLine.clear();
+    m_pullLines.clear();
 }
 
-HRESULT BuildImageCallback::OnProgress(LPCSTR status, LPCSTR id, ULONGLONG /*current*/, ULONGLONG /*total*/)
+void BuildImageCallback::RedrawIfNeeded()
+{
+    auto now = std::chrono::steady_clock::now();
+    if (now - m_lastRedraw >= c_redrawInterval)
+    {
+        Redraw();
+        m_lastRedraw = now;
+    }
+}
+
+HRESULT BuildImageCallback::OnProgress(LPCSTR status, LPCSTR id, ULONGLONG current, ULONGLONG total)
 try
 {
     if (status == nullptr || *status == '\0')
@@ -81,78 +101,90 @@ try
         return S_OK;
     }
 
+    const std::string_view idView = (id != nullptr) ? id : std::string_view{};
+    const bool isLog = (idView == "log");
+    const bool isPullProgress = (!idView.empty() && total > 0 && !isLog);
+
     if (m_verbose || !m_isConsole)
     {
-        wprintf(L"%hs", status);
+        // Skip pull progress updates when output is redirected, show only major steps
+        if (!isPullProgress)
+        {
+            wprintf(L"%hs", status);
+        }
         return S_OK;
     }
 
-    // Match the specific "log" sentinel sent by WSLCSession::BuildImage rather than
-    // accepting any non-empty id, so future or unrelated id usage defaults to permanent.
-    const bool isLog = (id != nullptr && std::string_view{id} == "log");
-
-    if (!isLog)
+    // Pull/download progress: update the per-entry map so Redraw can show each entry
+    // on a single line that updates in place.
+    if (isPullProgress)
     {
-        // Permanent line: collapse the scrolling window then print directly.
-        CollapseWindow();
-        WriteTerminal(MultiByteToWide(status));
+        m_pullLines[id] = status;
+        RedrawIfNeeded();
+
         return S_OK;
     }
 
-    // Log line: add to the scrolling window.
-    for (const char* p = status; *p != '\0'; ++p)
+    if (isLog)
     {
-        if (*p == '\n')
+        // Log line: add to the scrolling window.
+        for (const char* p = status; *p != '\0'; ++p)
         {
-            // Store with the trailing newline so the byte count matches what is replayed.
-            // Cap retained log output to avoid unbounded growth on very long builds.
-            m_allLines.push_back(m_pendingLine + '\n');
-            m_allLinesBytes += m_allLines.back().size();
-            while (m_allLinesBytes > c_maxAllLinesBytes && !m_allLines.empty())
+            if (*p == '\n')
             {
-                m_allLinesBytes -= m_allLines.front().size();
-                m_allLines.pop_front();
-            }
+                // Store with the trailing newline so the byte count matches what is replayed.
+                // Cap retained log output to avoid unbounded growth on very long builds.
+                m_allLines.push_back(m_pendingLine + '\n');
+                m_allLinesBytes += m_allLines.back().size();
+                while (m_allLinesBytes > c_maxAllLinesBytes && !m_allLines.empty())
+                {
+                    m_allLinesBytes -= m_allLines.front().size();
+                    m_allLines.pop_front();
+                }
 
-            m_lines.push_back(std::move(m_pendingLine));
-            m_pendingLine.clear();
-            if (m_lines.size() > c_maxDisplayLines)
-            {
-                m_lines.pop_front();
+                m_lines.push_back(std::move(m_pendingLine));
+                m_pendingLine.clear();
+                if (m_lines.size() > c_maxDisplayLines)
+                {
+                    m_lines.pop_front();
+                }
             }
-        }
-        else if (*p == '\r')
-        {
-            // \r\n is a line ending; standalone \r overwrites the current line.
-            if (*(p + 1) != '\n')
+            else if (*p == '\r')
             {
-                // Flush a throttled redraw before clearing so \r-based progress
-                // updates are visible even when batched in a single OnProgress call.
-                auto now = std::chrono::steady_clock::now();
-                if (!m_pendingLine.empty() && now - m_lastRedraw >= c_redrawInterval)
+                // \r\n is a line ending; standalone \r overwrites the current line.
+                if (*(p + 1) != '\n')
                 {
-                    Redraw();
-                    m_lastRedraw = now;
+                    // Flush a throttled redraw before clearing so \r-based progress
+                    // updates are visible even when batched in a single OnProgress call.
+                    if (!m_pendingLine.empty())
+                    {
+                        RedrawIfNeeded();
+                    }
+                    m_pendingLine.clear();
                 }
-                m_pendingLine.clear();
+            }
+            else
+            {
+                m_pendingLine += *p;
             }
         }
-        else
-        {
-            m_pendingLine += *p;
-        }
-    }
 
-    // Throttle redraws to avoid blocking the server's IO loop with console writes
-    // during rapid output. Lines accumulate in the deque immediately; the display
-    // catches up at ~20fps.
-    auto now = std::chrono::steady_clock::now();
-    if (now - m_lastRedraw >= c_redrawInterval)
-    {
-        Redraw();
-        m_lastRedraw = now;
+        // Throttle redraws to avoid blocking the server's IO loop with console writes
+        // during rapid output. Lines accumulate in the deque immediately; the display
+        // catches up at ~20fps.
+        RedrawIfNeeded();
+
+        return S_OK;
     }
 
+    // Else is a build step
+    CollapseWindow();
+    auto wide = MultiByteToWide(status);
+    const auto bodyLength = wide.find_last_not_of(L"\r\n") + 1;
+    const auto newlines = wide.substr(bodyLength);
+    wide.resize(bodyLength);
+
+    WriteTerminal(std::format(L"{}{}{}{}", c_escapeBrightGreen, wide, c_escapeResetAttributes, newlines));
     return S_OK;
 }
 CATCH_RETURN();
@@ -167,27 +199,29 @@ void BuildImageCallback::Redraw()
     // to std::wstring::resize).
     const SHORT consoleWidth = std::max<SHORT>(0, info.srWindow.Right - info.srWindow.Left);
 
-    // Determine how many completed lines to show, leaving room for the pending line.
+    // Determine how many completed lines to show, leaving room for the pending line and pull progress.
     const bool showPending = !m_pendingLine.empty();
+    const SHORT pullCount = static_cast<SHORT>(m_pullLines.size());
     SHORT completedCount = static_cast<SHORT>(m_lines.size());
-    if (showPending && completedCount >= c_maxDisplayLines)
+    const SHORT reservedLines = (showPending ? 1 : 0) + pullCount;
+    if (completedCount + reservedLines > c_maxDisplayLines)
     {
-        completedCount = c_maxDisplayLines - 1;
+        completedCount = std::max<SHORT>(0, c_maxDisplayLines - reservedLines);
     }
-    const SHORT displayCount = completedCount + (showPending ? 1 : 0);
+    const SHORT displayCount = completedCount + reservedLines;
 
     // Build the entire frame in one buffer to minimize console writes. Hide the cursor
     // during the redraw so the user doesn't see it bouncing through the cursor movement,
     // then show it again at the final position. The dim attribute (\033[2m) renders the
     // scrolling lines de-emphasized regardless of the user's theme.
-    std::wstring buffer = L"\033[?25l\033[2m";
+    std::wstring buffer{c_escapeHideCursorDim};
 
     // Move cursor to the start of the display area and erase from there to the end of
     // the screen. \033[J handles the case where the new display is shorter than the
     // previous one (e.g. when \r clears the pending line without a replacement).
     if (m_displayedLines > 0)
     {
-        buffer += std::format(L"\033[{}A\033[J", m_displayedLines);
+        buffer += std::format(c_escapeMoveCursorUpAndClear, m_displayedLines);
     }
 
     auto appendLine = [&](const std::string& line) {
@@ -197,7 +231,7 @@ void BuildImageCallback::Redraw()
             wline.resize(consoleWidth);
         }
         buffer += wline;
-        buffer += L"\033[K\n";
+        buffer += c_escapeClearLineAndNewline;
     };
 
     // Print completed lines (skip older ones if we need room for the pending line).
@@ -217,7 +251,13 @@ void BuildImageCallback::Redraw()
         appendLine(m_pendingLine);
     }
 
-    buffer += L"\033[22m\033[?25h";
+    // Render per-entry pull progress (each entry updates in place via the map).
+    for (const auto& [key, line] : m_pullLines)
+    {
+        appendLine(line);
+    }
+
+    buffer += c_escapeUndimShowCursor;
 
     WriteTerminal(buffer);
     m_displayedLines = displayCount;
diff --git a/src/windows/wslc/services/BuildImageCallback.h b/src/windows/wslc/services/BuildImageCallback.h
@@ -15,6 +15,7 @@ Module Name:
 #include "ChangeTerminalMode.h"
 #include "SessionService.h"
 #include <deque>
+#include <map>
 
 namespace wsl::windows::wslc::services {
 class DECLSPEC_UUID("3EDD5DBF-CA6C-4CF7-923A-AD94B6A732E5") BuildImageCallback
@@ -35,6 +36,7 @@ class DECLSPEC_UUID("3EDD5DBF-CA6C-4CF7-923A-AD94B6A732E5") BuildImageCallback
 
     void CollapseWindow();
     void Redraw();
+    void RedrawIfNeeded();
     // Use WriteConsoleW directly rather than wprintf: wprintf is noticeably slower for
     // the per-redraw scrolling display and produces visible flicker.
     void WriteTerminal(std::wstring_view content) const;
@@ -54,6 +56,8 @@ class DECLSPEC_UUID("3EDD5DBF-CA6C-4CF7-923A-AD94B6A732E5") BuildImageCallback
     std::string m_pendingLine;
     SHORT m_displayedLines = 0;
     std::chrono::steady_clock::time_point m_lastRedraw{};
+    // Per-entry pull progress lines, keyed by entry id. Updated in place by Redraw. std::map so order is consistent.
+    std::map<std::string, std::string> m_pullLines;
     // Captured at construction so the destructor can detect destruction during exception unwinding.
     int m_uncaughtExceptions = std::uncaught_exceptions();
 };
diff --git a/src/windows/wslc/services/ImageProgressCallback.cpp b/src/windows/wslc/services/ImageProgressCallback.cpp
@@ -84,23 +84,58 @@ std::wstring ImageProgressCallback::GenerateStatusLine(LPCSTR status, LPCSTR id,
     std::wstring line;
     if (total != 0)
     {
-        line = std::format(L"{} '{}': {}%", status, id, current * 100 / total);
+        constexpr int c_progressBarWidth = 30;
+
+        int filled = 0;
+        if (current >= total)
+        {
+            filled = c_progressBarWidth;
+        }
+        else
+        {
+            auto ratio = static_cast<long double>(current) / static_cast<long double>(total);
+            filled = static_cast<int>(ratio * c_progressBarWidth);
+        }
+
+        filled = std::clamp(filled, 0, c_progressBarWidth);
+
+        std::wstring bar;
+        bar.reserve(c_progressBarWidth);
+        bar.append(filled, L'=');
+        bar.append(L">");
+        bar.resize(c_progressBarWidth, L' ');
+
+        line = std::format(
+            L"{}: {} [{}] {}/{}", id, status, bar, wsl::shared::string::FormatBytes(current), wsl::shared::string::FormatBytes(total));
     }
     else if (current != 0)
     {
-        line = std::format(L"{} '{}': {}s", status, id, current);
+        line = std::format(L"{}: {} {}s", id, status, current);
     }
     else
     {
-        line = std::format(L"{} '{}'", status, id);
+        line = std::format(L"{}: {}", id, status);
     }
 
-    // Erase any previously written char on that line.
-    while (line.size() < info.dwSize.X)
+    // Use the visible window width (not the buffer width) to prevent wrapping.
+    const auto visibleWidth = std::max<SHORT>(0, info.srWindow.Right - info.srWindow.Left + 1);
+
+    // Truncate to console width to prevent wrapping that would break cursor repositioning.
+    if (line.size() > static_cast<size_t>(visibleWidth))
     {
-        line += L' ';
+        line.resize(visibleWidth);
+
+        // Avoid splitting a surrogate pair — if the last code unit is a high surrogate,
+        // drop it so we don't emit an invalid UTF-16 sequence.
+        if (!line.empty() && IS_HIGH_SURROGATE(line.back()))
+        {
+            line.pop_back();
+        }
     }
 
+    // Erase any previously written char on that line.
+    line.resize(visibleWidth, L' ');
+
     return line;
 }
 } // namespace wsl::windows::wslc::services
diff --git a/src/windows/wslcsession/WSLCSession.cpp b/src/windows/wslcsession/WSLCSession.cpp
