Make a VTApiRoutines servicer that does minimal translations instead of environmental simulation for some output methods.

src/host/CommandListPopup.cpp

@@ -342,7 +342,7 @@ void CommandListPopup::_drawList()
         WriteCoord.Y += 1i16;
     }
 
-    auto& api = Microsoft::Console::Interactivity::ServiceLocator::LocateGlobals().api;
+    auto api = Microsoft::Console::Interactivity::ServiceLocator::LocateGlobals().api;
 
     WriteCoord.Y = _region.Top + 1i16;
     SHORT i = std::max(gsl::narrow<SHORT>(_bottomIndex - Height() + 1), 0i16);
@@ -379,7 +379,7 @@ void CommandListPopup::_drawList()
 
         WriteCoord.X = _region.Left + 1i16;
 
-        LOG_IF_FAILED(api.WriteConsoleOutputCharacterAImpl(_screenInfo,
+        LOG_IF_FAILED(api->WriteConsoleOutputCharacterAImpl(_screenInfo,
                                                            { CommandNumberPtr, CommandNumberLength },
                                                            WriteCoord,
                                                            CommandNumberLength));
@@ -417,7 +417,7 @@ void CommandListPopup::_drawList()
 
         WriteCoord.X = gsl::narrow<SHORT>(WriteCoord.X + CommandNumberLength);
         size_t used;
-        LOG_IF_FAILED(api.WriteConsoleOutputCharacterWImpl(_screenInfo,
+        LOG_IF_FAILED(api->WriteConsoleOutputCharacterWImpl(_screenInfo,
                                                            { command.data(), lStringLength },
                                                            WriteCoord,
                                                            used));

src/host/VtApiRoutines.cpp

@@ -0,0 +1,691 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+
+#include "precomp.h"
+#include "VtApiRoutines.h"
+#include "../interactivity/inc/ServiceLocator.hpp"
+#include "../types/inc/convert.hpp"
+
+using namespace Microsoft::Console::Interactivity;
+
+VtApiRoutines::VtApiRoutines() :
+    m_inputCodepage(ServiceLocator::LocateGlobals().getConsoleInformation().CP),
+    m_outputCodepage(ServiceLocator::LocateGlobals().getConsoleInformation().OutputCP),
+    m_inputMode(),
+    m_outputMode(),
+    m_pUsualRoutines(),
+    m_pVtEngine()
+{
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4100) // unreferenced param
+
+void VtApiRoutines::GetConsoleInputCodePageImpl(ULONG& codepage) noexcept
+{
+    codepage = m_inputCodepage;
+    return;
+}
+
+void VtApiRoutines::GetConsoleOutputCodePageImpl(ULONG& codepage) noexcept
+{
+    codepage = m_outputCodepage;
+    return;
+}
+
+void VtApiRoutines::GetConsoleInputModeImpl(InputBuffer& context,
+                                            ULONG& mode) noexcept
+{
+    mode = m_inputMode;
+    return;
+}
+
+void VtApiRoutines::GetConsoleOutputModeImpl(SCREEN_INFORMATION& context,
+                                             ULONG& mode) noexcept
+{
+    mode = m_outputMode;
+    return;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleInputModeImpl(InputBuffer& context,
+                                                             const ULONG mode) noexcept
+{
+    m_inputMode = mode;
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleOutputModeImpl(SCREEN_INFORMATION& context,
+                                                              const ULONG Mode) noexcept
+{
+    m_outputMode = Mode;
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetNumberOfConsoleInputEventsImpl(const InputBuffer& context,
+                                                                       ULONG& events) noexcept
+{
+    events = 0; // one per character that we have ready to return... or 0.
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::PeekConsoleInputAImpl(IConsoleInputObject& context,
+                                                           std::deque<std::unique_ptr<IInputEvent>>& outEvents,
+                                                           const size_t eventsToRead,
+                                                           INPUT_READ_HANDLE_DATA& readHandleState,
+                                                           std::unique_ptr<IWaitRoutine>& waiter) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::PeekConsoleInputWImpl(IConsoleInputObject& context,
+                                                           std::deque<std::unique_ptr<IInputEvent>>& outEvents,
+                                                           const size_t eventsToRead,
+                                                           INPUT_READ_HANDLE_DATA& readHandleState,
+                                                           std::unique_ptr<IWaitRoutine>& waiter) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleInputAImpl(IConsoleInputObject& context,
+                                                           std::deque<std::unique_ptr<IInputEvent>>& outEvents,
+                                                           const size_t eventsToRead,
+                                                           INPUT_READ_HANDLE_DATA& readHandleState,
+                                                           std::unique_ptr<IWaitRoutine>& waiter) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleInputWImpl(IConsoleInputObject& context,
+                                                           std::deque<std::unique_ptr<IInputEvent>>& outEvents,
+                                                           const size_t eventsToRead,
+                                                           INPUT_READ_HANDLE_DATA& readHandleState,
+                                                           std::unique_ptr<IWaitRoutine>& waiter) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleAImpl(IConsoleInputObject& context,
+                                                      gsl::span<char> buffer,
+                                                      size_t& written,
+                                                      std::unique_ptr<IWaitRoutine>& waiter,
+                                                      const std::string_view initialData,
+                                                      const std::wstring_view exeName,
+                                                      INPUT_READ_HANDLE_DATA& readHandleState,
+                                                      const HANDLE clientHandle,
+                                                      const DWORD controlWakeupMask,
+                                                      DWORD& controlKeyState) noexcept
+{
+    return m_pUsualRoutines->ReadConsoleAImpl(context, buffer, written, waiter, initialData, exeName, readHandleState, clientHandle, controlWakeupMask, controlKeyState);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleWImpl(IConsoleInputObject& context,
+                                                      gsl::span<char> buffer,
+                                                      size_t& written,
+                                                      std::unique_ptr<IWaitRoutine>& waiter,
+                                                      const std::string_view initialData,
+                                                      const std::wstring_view exeName,
+                                                      INPUT_READ_HANDLE_DATA& readHandleState,
+                                                      const HANDLE clientHandle,
+                                                      const DWORD controlWakeupMask,
+                                                      DWORD& controlKeyState) noexcept
+{
+    return m_pUsualRoutines->ReadConsoleWImpl(context, buffer, written, waiter, initialData, exeName, readHandleState, clientHandle, controlWakeupMask, controlKeyState);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleAImpl(IConsoleOutputObject& context,
+                                                       const std::string_view buffer,
+                                                       size_t& read,
+                                                       bool requiresVtQuirk,
+                                                       std::unique_ptr<IWaitRoutine>& waiter) noexcept
+{
+    if (CP_UTF8 == m_outputCodepage)
+    {
+        (void)m_pVtEngine->WriteTerminalUtf8(buffer);
+
+    }
+    else
+    {
+        (void)m_pVtEngine->WriteTerminalW(ConvertToW(m_outputCodepage, buffer));
+    }
+
+    (void)m_pVtEngine->_Flush();
+    read = buffer.size();
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleWImpl(IConsoleOutputObject& context,
+                                                       const std::wstring_view buffer,
+                                                       size_t& read,
+                                                       bool requiresVtQuirk,
+                                                       std::unique_ptr<IWaitRoutine>& waiter) noexcept
+{
+    (void)m_pVtEngine->WriteTerminalW(buffer);
+    (void)m_pVtEngine->_Flush();
+    read = buffer.size();
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleLangIdImpl(LANGID& langId) noexcept
+{
+    return m_pUsualRoutines->GetConsoleLangIdImpl(langId);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::FillConsoleOutputAttributeImpl(IConsoleOutputObject& OutContext,
+                                                                    const WORD attribute,
+                                                                    const size_t lengthToWrite,
+                                                                    const COORD startingCoordinate,
+                                                                    size_t& cellsModified) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::FillConsoleOutputCharacterAImpl(IConsoleOutputObject& OutContext,
+                                                                     const char character,
+                                                                     const size_t lengthToWrite,
+                                                                     const COORD startingCoordinate,
+                                                                     size_t& cellsModified) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::FillConsoleOutputCharacterWImpl(IConsoleOutputObject& OutContext,
+                                                                     const wchar_t character,
+                                                                     const size_t lengthToWrite,
+                                                                     const COORD startingCoordinate,
+                                                                     size_t& cellsModified,
+                                                                     const bool enablePowershellShim) noexcept
+{
+    return S_OK;
+}
+
+//// Process based. Restrict in protocol side?
+//HRESULT GenerateConsoleCtrlEventImpl(const ULONG ProcessGroupFilter,
+//                                             const ULONG ControlEvent);
+
+void VtApiRoutines::SetConsoleActiveScreenBufferImpl(SCREEN_INFORMATION& newContext) noexcept
+{
+    return;
+}
+
+void VtApiRoutines::FlushConsoleInputBuffer(InputBuffer& context) noexcept
+{
+    return;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleInputCodePageImpl(const ULONG codepage) noexcept
+{
+    m_inputCodepage = codepage;
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleOutputCodePageImpl(const ULONG codepage) noexcept
+{
+    m_outputCodepage = codepage;
+    return S_OK;
+}
+
+void VtApiRoutines::GetConsoleCursorInfoImpl(const SCREEN_INFORMATION& context,
+                                             ULONG& size,
+                                             bool& isVisible) noexcept
+{
+    return;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleCursorInfoImpl(SCREEN_INFORMATION& context,
+                                                              const ULONG size,
+                                                              const bool isVisible) noexcept
+{
+    return S_OK;
+}
+
+//// driver will pare down for non-Ex method
+void VtApiRoutines::GetConsoleScreenBufferInfoExImpl(const SCREEN_INFORMATION& context,
+                                                     CONSOLE_SCREEN_BUFFER_INFOEX& data) noexcept
+{
+    return m_pUsualRoutines->GetConsoleScreenBufferInfoExImpl(context, data);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleScreenBufferInfoExImpl(SCREEN_INFORMATION& context,
+                                                                      const CONSOLE_SCREEN_BUFFER_INFOEX& data) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleScreenBufferSizeImpl(SCREEN_INFORMATION& context,
+                                                                    const COORD size) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleCursorPositionImpl(SCREEN_INFORMATION& context,
+                                                                  const COORD position) noexcept
+{
+    return S_OK;
+}
+
+void VtApiRoutines::GetLargestConsoleWindowSizeImpl(const SCREEN_INFORMATION& context,
+                                                    COORD& size) noexcept
+{
+    return;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ScrollConsoleScreenBufferAImpl(SCREEN_INFORMATION& context,
+                                                                    const SMALL_RECT& source,
+                                                                    const COORD target,
+                                                                    std::optional<SMALL_RECT> clip,
+                                                                    const char fillCharacter,
+                                                                    const WORD fillAttribute) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ScrollConsoleScreenBufferWImpl(SCREEN_INFORMATION& context,
+                                                                    const SMALL_RECT& source,
+                                                                    const COORD target,
+                                                                    std::optional<SMALL_RECT> clip,
+                                                                    const wchar_t fillCharacter,
+                                                                    const WORD fillAttribute,
+                                                                    const bool enableCmdShim) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleTextAttributeImpl(SCREEN_INFORMATION& context,
+                                                                 const WORD attribute) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleWindowInfoImpl(SCREEN_INFORMATION& context,
+                                                              const bool isAbsolute,
+                                                              const SMALL_RECT& windowRect) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleOutputAttributeImpl(const SCREEN_INFORMATION& context,
+                                                                    const COORD origin,
+                                                                    gsl::span<WORD> buffer,
+                                                                    size_t& written) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleOutputCharacterAImpl(const SCREEN_INFORMATION& context,
+                                                                     const COORD origin,
+                                                                     gsl::span<char> buffer,
+                                                                     size_t& written) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleOutputCharacterWImpl(const SCREEN_INFORMATION& context,
+                                                                     const COORD origin,
+                                                                     gsl::span<wchar_t> buffer,
+                                                                     size_t& written) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleInputAImpl(InputBuffer& context,
+                                                            const gsl::span<const INPUT_RECORD> buffer,
+                                                            size_t& written,
+                                                            const bool append) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleInputWImpl(InputBuffer& context,
+                                                            const gsl::span<const INPUT_RECORD> buffer,
+                                                            size_t& written,
+                                                            const bool append) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleOutputAImpl(SCREEN_INFORMATION& context,
+                                                             gsl::span<CHAR_INFO> buffer,
+                                                             const Microsoft::Console::Types::Viewport& requestRectangle,
+                                                             Microsoft::Console::Types::Viewport& writtenRectangle) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleOutputWImpl(SCREEN_INFORMATION& context,
+                                                             gsl::span<CHAR_INFO> buffer,
+                                                             const Microsoft::Console::Types::Viewport& requestRectangle,
+                                                             Microsoft::Console::Types::Viewport& writtenRectangle) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleOutputAttributeImpl(IConsoleOutputObject& OutContext,
+                                                                     const gsl::span<const WORD> attrs,
+                                                                     const COORD target,
+                                                                     size_t& used) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleOutputCharacterAImpl(IConsoleOutputObject& OutContext,
+                                                                      const std::string_view text,
+                                                                      const COORD target,
+                                                                      size_t& used) noexcept
+{
+    if (m_outputCodepage == CP_UTF8)
+    {
+        (void)m_pVtEngine->_CursorPosition(target);
+        (void)m_pVtEngine->WriteTerminalUtf8(text);
+        (void)m_pVtEngine->_Flush();
+        return S_OK;
+    }
+    else
+    {
+        return WriteConsoleOutputCharacterWImpl(OutContext, ConvertToW(m_outputCodepage, text), target, used);
+    }
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::WriteConsoleOutputCharacterWImpl(IConsoleOutputObject& OutContext,
+                                                                      const std::wstring_view text,
+                                                                      const COORD target,
+                                                                      size_t& used) noexcept
+{
+    (void)m_pVtEngine->_CursorPosition(target);
+    (void)m_pVtEngine->WriteTerminalW(text);
+    (void)m_pVtEngine->_Flush();
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleOutputAImpl(const SCREEN_INFORMATION& context,
+                                                            gsl::span<CHAR_INFO> buffer,
+                                                            const Microsoft::Console::Types::Viewport& sourceRectangle,
+                                                            Microsoft::Console::Types::Viewport& readRectangle) noexcept
+{
+    CHAR_INFO fill;
+    fill.Attributes = FOREGROUND_INTENSITY | FOREGROUND_RED | BACKGROUND_GREEN;
+    fill.Char.AsciiChar = '?';
+
+    std::fill(buffer.begin(), buffer.end(), fill);
+
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ReadConsoleOutputWImpl(const SCREEN_INFORMATION& context,
+                                                            gsl::span<CHAR_INFO> buffer,
+                                                            const Microsoft::Console::Types::Viewport& sourceRectangle,
+                                                            Microsoft::Console::Types::Viewport& readRectangle) noexcept
+{
+    CHAR_INFO fill;
+    fill.Attributes = FOREGROUND_INTENSITY | FOREGROUND_RED | BACKGROUND_GREEN;
+    fill.Char.UnicodeChar = UNICODE_REPLACEMENT;
+
+    std::fill(buffer.begin(), buffer.end(), fill);
+
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleTitleAImpl(gsl::span<char> title,
+                                                          size_t& written,
+                                                          size_t& needed) noexcept
+{
+    written = 0;
+    needed = 0;
+
+    if (!title.empty())
+    {
+        title.front() = ANSI_NULL;
+    }
+
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleTitleWImpl(gsl::span<wchar_t> title,
+                                                          size_t& written,
+                                                          size_t& needed) noexcept
+{
+    written = 0;
+    needed = 0;
+
+    if (!title.empty())
+    {
+        title.front() = UNICODE_NULL;
+    }
+
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleOriginalTitleAImpl(gsl::span<char> title,
+                                                                  size_t& written,
+                                                                  size_t& needed) noexcept
+{
+    written = 0;
+    needed = 0;
+
+    if (!title.empty())
+    {
+        title.front() = ANSI_NULL;
+    }
+
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleOriginalTitleWImpl(gsl::span<wchar_t> title,
+                                                                  size_t& written,
+                                                                  size_t& needed) noexcept
+{
+    written = 0;
+    needed = 0;
+
+    if (!title.empty())
+    {
+        title.front() = UNICODE_NULL;
+    }
+
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleTitleAImpl(const std::string_view title) noexcept
+{
+    return SetConsoleTitleWImpl(ConvertToW(m_inputCodepage, title));
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleTitleWImpl(const std::wstring_view title) noexcept
+{
+    (void)m_pVtEngine->UpdateTitle(title);
+    (void)m_pVtEngine->_Flush();
+    return S_OK;
+}
+
+void VtApiRoutines::GetNumberOfConsoleMouseButtonsImpl(ULONG& buttons) noexcept
+{
+    buttons = 2;
+    return;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleFontSizeImpl(const SCREEN_INFORMATION& context,
+                                                            const DWORD index,
+                                                            COORD& size) noexcept
+{
+    size.X = 8;
+    size.Y = 12;
+    return S_OK;
+}
+
+//// driver will pare down for non-Ex method
+[[nodiscard]] HRESULT VtApiRoutines::GetCurrentConsoleFontExImpl(const SCREEN_INFORMATION& context,
+                                                                 const bool isForMaximumWindowSize,
+                                                                 CONSOLE_FONT_INFOEX& consoleFontInfoEx) noexcept
+{
+    return S_OK;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleDisplayModeImpl(SCREEN_INFORMATION& context,
+                                                               const ULONG flags,
+                                                               COORD& newSize) noexcept
+{
+    return S_OK;
+}
+
+void VtApiRoutines::GetConsoleDisplayModeImpl(ULONG& flags) noexcept
+{
+    flags = 0;
+    return;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::AddConsoleAliasAImpl(const std::string_view source,
+                                                          const std::string_view target,
+                                                          const std::string_view exeName) noexcept
+{
+    return m_pUsualRoutines->AddConsoleAliasAImpl(source, target, exeName);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::AddConsoleAliasWImpl(const std::wstring_view source,
+                                                          const std::wstring_view target,
+                                                          const std::wstring_view exeName) noexcept
+{
+    return m_pUsualRoutines->AddConsoleAliasWImpl(source, target, exeName);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasAImpl(const std::string_view source,
+                                                          gsl::span<char> target,
+                                                          size_t& written,
+                                                          const std::string_view exeName) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasAImpl(source, target, written, exeName);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasWImpl(const std::wstring_view source,
+                                                          gsl::span<wchar_t> target,
+                                                          size_t& written,
+                                                          const std::wstring_view exeName) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasWImpl(source, target, written, exeName);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasesLengthAImpl(const std::string_view exeName,
+                                                                  size_t& bufferRequired) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasesLengthAImpl(exeName, bufferRequired);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasesLengthWImpl(const std::wstring_view exeName,
+                                                                  size_t& bufferRequired) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasesLengthWImpl(exeName, bufferRequired);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasExesLengthAImpl(size_t& bufferRequired) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasExesLengthAImpl(bufferRequired);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasExesLengthWImpl(size_t& bufferRequired) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasExesLengthWImpl(bufferRequired);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasesAImpl(const std::string_view exeName,
+                                                            gsl::span<char> alias,
+                                                            size_t& written) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasesAImpl(exeName, alias, written);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasesWImpl(const std::wstring_view exeName,
+                                                            gsl::span<wchar_t> alias,
+                                                            size_t& written) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasesWImpl(exeName, alias, written);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasExesAImpl(gsl::span<char> aliasExes,
+                                                              size_t& written) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasExesAImpl(aliasExes, written);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleAliasExesWImpl(gsl::span<wchar_t> aliasExes,
+                                                              size_t& written) noexcept
+{
+    return m_pUsualRoutines->GetConsoleAliasExesWImpl(aliasExes, written);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ExpungeConsoleCommandHistoryAImpl(const std::string_view exeName) noexcept
+{
+    return m_pUsualRoutines->ExpungeConsoleCommandHistoryAImpl(exeName);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::ExpungeConsoleCommandHistoryWImpl(const std::wstring_view exeName) noexcept
+{
+    return m_pUsualRoutines->ExpungeConsoleCommandHistoryWImpl(exeName);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleNumberOfCommandsAImpl(const std::string_view exeName,
+                                                                     const size_t numberOfCommands) noexcept
+{
+    return m_pUsualRoutines->SetConsoleNumberOfCommandsAImpl(exeName, numberOfCommands);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleNumberOfCommandsWImpl(const std::wstring_view exeName,
+                                                                     const size_t numberOfCommands) noexcept
+{
+    return m_pUsualRoutines->SetConsoleNumberOfCommandsWImpl(exeName, numberOfCommands);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleCommandHistoryLengthAImpl(const std::string_view exeName,
+                                                                         size_t& length) noexcept
+{
+    return m_pUsualRoutines->GetConsoleCommandHistoryLengthAImpl(exeName, length);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleCommandHistoryLengthWImpl(const std::wstring_view exeName,
+                                                                         size_t& length) noexcept
+{
+    return m_pUsualRoutines->GetConsoleCommandHistoryLengthWImpl(exeName, length);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleCommandHistoryAImpl(const std::string_view exeName,
+                                                                   gsl::span<char> commandHistory,
+                                                                   size_t& written) noexcept
+{
+    return m_pUsualRoutines->GetConsoleCommandHistoryAImpl(exeName, commandHistory, written);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::GetConsoleCommandHistoryWImpl(const std::wstring_view exeName,
+                                                                   gsl::span<wchar_t> commandHistory,
+                                                                   size_t& written) noexcept
+{
+    return m_pUsualRoutines->GetConsoleCommandHistoryWImpl(exeName, commandHistory, written);
+}
+
+void VtApiRoutines::GetConsoleWindowImpl(HWND& hwnd) noexcept
+{
+    hwnd = ServiceLocator::LocatePseudoWindow();
+    return;
+}
+
+void VtApiRoutines::GetConsoleSelectionInfoImpl(CONSOLE_SELECTION_INFO& consoleSelectionInfo) noexcept
+{
+    consoleSelectionInfo = { 0 };
+    return;
+}
+
+void VtApiRoutines::GetConsoleHistoryInfoImpl(CONSOLE_HISTORY_INFO& consoleHistoryInfo) noexcept
+{
+    m_pUsualRoutines->GetConsoleHistoryInfoImpl(consoleHistoryInfo);
+    return;
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetConsoleHistoryInfoImpl(const CONSOLE_HISTORY_INFO& consoleHistoryInfo) noexcept
+{
+    return m_pUsualRoutines->SetConsoleHistoryInfoImpl(consoleHistoryInfo);
+}
+
+[[nodiscard]] HRESULT VtApiRoutines::SetCurrentConsoleFontExImpl(IConsoleOutputObject& context,
+                                                                 const bool isForMaximumWindowSize,
+                                                                 const CONSOLE_FONT_INFOEX& consoleFontInfoEx) noexcept
+{
+    return S_OK;
+}
+
+#pragma warning(pop)

src/host/VtApiRoutines.h

@@ -0,0 +1,388 @@
+/*++
+Copyright (c) Microsoft Corporation
+Licensed under the MIT license.
+
+Module Name:
+- VtApiRoutines.h
+
+Abstract:
+- This file defines the interface to respond to all API calls by using VT on behalf of the client
+
+Author:
+- Michael Niksa (miniksa) 26-Jul-2021
+
+Revision History:
+- Adapted from original items in srvinit.cpp, getset.cpp, directio.cpp, stream.cpp
+--*/
+
+#pragma once
+
+#include "../server/IApiRoutines.h"
+#include "../renderer/vt/Xterm256Engine.hpp"
+
+class VtApiRoutines : public IApiRoutines
+{
+public:
+    VtApiRoutines();
+
+#pragma region ObjectManagement
+    /*HRESULT CreateInitialObjects(_Out_ InputBuffer** const ppInputObject,
+    _Out_ SCREEN_INFORMATION** const ppOutputObject);
+    */
+
+#pragma endregion
+
+#pragma region L1
+    void GetConsoleInputCodePageImpl(ULONG& codepage) noexcept override;
+
+    void GetConsoleOutputCodePageImpl(ULONG& codepage) noexcept override;
+
+    void GetConsoleInputModeImpl(InputBuffer& context,
+                                 ULONG& mode) noexcept override;
+
+    void GetConsoleOutputModeImpl(SCREEN_INFORMATION& context,
+                                  ULONG& mode) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleInputModeImpl(InputBuffer& context,
+                                                  const ULONG mode) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleOutputModeImpl(SCREEN_INFORMATION& context,
+                                                   const ULONG Mode) noexcept override;
+
+    [[nodiscard]] HRESULT GetNumberOfConsoleInputEventsImpl(const InputBuffer& context,
+                                                            ULONG& events) noexcept override;
+
+    [[nodiscard]] HRESULT PeekConsoleInputAImpl(IConsoleInputObject& context,
+                                                std::deque<std::unique_ptr<IInputEvent>>& outEvents,
+                                                const size_t eventsToRead,
+                                                INPUT_READ_HANDLE_DATA& readHandleState,
+                                                std::unique_ptr<IWaitRoutine>& waiter) noexcept override;
+
+    [[nodiscard]] HRESULT PeekConsoleInputWImpl(IConsoleInputObject& context,
+                                                std::deque<std::unique_ptr<IInputEvent>>& outEvents,
+                                                const size_t eventsToRead,
+                                                INPUT_READ_HANDLE_DATA& readHandleState,
+                                                std::unique_ptr<IWaitRoutine>& waiter) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleInputAImpl(IConsoleInputObject& context,
+                                                std::deque<std::unique_ptr<IInputEvent>>& outEvents,
+                                                const size_t eventsToRead,
+                                                INPUT_READ_HANDLE_DATA& readHandleState,
+                                                std::unique_ptr<IWaitRoutine>& waiter) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleInputWImpl(IConsoleInputObject& context,
+                                                std::deque<std::unique_ptr<IInputEvent>>& outEvents,
+                                                const size_t eventsToRead,
+                                                INPUT_READ_HANDLE_DATA& readHandleState,
+                                                std::unique_ptr<IWaitRoutine>& waiter) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleAImpl(IConsoleInputObject& context,
+                                           gsl::span<char> buffer,
+                                           size_t& written,
+                                           std::unique_ptr<IWaitRoutine>& waiter,
+                                           const std::string_view initialData,
+                                           const std::wstring_view exeName,
+                                           INPUT_READ_HANDLE_DATA& readHandleState,
+                                           const HANDLE clientHandle,
+                                           const DWORD controlWakeupMask,
+                                           DWORD& controlKeyState) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleWImpl(IConsoleInputObject& context,
+                                           gsl::span<char> buffer,
+                                           size_t& written,
+                                           std::unique_ptr<IWaitRoutine>& waiter,
+                                           const std::string_view initialData,
+                                           const std::wstring_view exeName,
+                                           INPUT_READ_HANDLE_DATA& readHandleState,
+                                           const HANDLE clientHandle,
+                                           const DWORD controlWakeupMask,
+                                           DWORD& controlKeyState) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleAImpl(IConsoleOutputObject& context,
+                                            const std::string_view buffer,
+                                            size_t& read,
+                                            bool requiresVtQuirk,
+                                            std::unique_ptr<IWaitRoutine>& waiter) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleWImpl(IConsoleOutputObject& context,
+                                            const std::wstring_view buffer,
+                                            size_t& read,
+                                            bool requiresVtQuirk,
+                                            std::unique_ptr<IWaitRoutine>& waiter) noexcept override;
+
+#pragma region ThreadCreationInfo
+    [[nodiscard]] HRESULT GetConsoleLangIdImpl(LANGID& langId) noexcept override;
+#pragma endregion
+
+#pragma endregion
+
+#pragma region L2
+
+    [[nodiscard]] HRESULT FillConsoleOutputAttributeImpl(IConsoleOutputObject& OutContext,
+                                                         const WORD attribute,
+                                                         const size_t lengthToWrite,
+                                                         const COORD startingCoordinate,
+                                                         size_t& cellsModified) noexcept override;
+
+    [[nodiscard]] HRESULT FillConsoleOutputCharacterAImpl(IConsoleOutputObject& OutContext,
+                                                          const char character,
+                                                          const size_t lengthToWrite,
+                                                          const COORD startingCoordinate,
+                                                          size_t& cellsModified) noexcept override;
+
+    [[nodiscard]] HRESULT FillConsoleOutputCharacterWImpl(IConsoleOutputObject& OutContext,
+                                                          const wchar_t character,
+                                                          const size_t lengthToWrite,
+                                                          const COORD startingCoordinate,
+                                                          size_t& cellsModified,
+                                                          const bool enablePowershellShim = false) noexcept override;
+
+    //// Process based. Restrict in protocol side?
+    //HRESULT GenerateConsoleCtrlEventImpl(const ULONG ProcessGroupFilter,
+    //                                             const ULONG ControlEvent);
+
+    void SetConsoleActiveScreenBufferImpl(SCREEN_INFORMATION& newContext) noexcept override;
+
+    void FlushConsoleInputBuffer(InputBuffer& context) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleInputCodePageImpl(const ULONG codepage) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleOutputCodePageImpl(const ULONG codepage) noexcept override;
+
+    void GetConsoleCursorInfoImpl(const SCREEN_INFORMATION& context,
+                                  ULONG& size,
+                                  bool& isVisible) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleCursorInfoImpl(SCREEN_INFORMATION& context,
+                                                   const ULONG size,
+                                                   const bool isVisible) noexcept override;
+
+    //// driver will pare down for non-Ex method
+    void GetConsoleScreenBufferInfoExImpl(const SCREEN_INFORMATION& context,
+                                          CONSOLE_SCREEN_BUFFER_INFOEX& data) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleScreenBufferInfoExImpl(SCREEN_INFORMATION& context,
+                                                           const CONSOLE_SCREEN_BUFFER_INFOEX& data) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleScreenBufferSizeImpl(SCREEN_INFORMATION& context,
+                                                         const COORD size) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleCursorPositionImpl(SCREEN_INFORMATION& context,
+                                                       const COORD position) noexcept override;
+
+    void GetLargestConsoleWindowSizeImpl(const SCREEN_INFORMATION& context,
+                                         COORD& size) noexcept override;
+
+    [[nodiscard]] HRESULT ScrollConsoleScreenBufferAImpl(SCREEN_INFORMATION& context,
+                                                         const SMALL_RECT& source,
+                                                         const COORD target,
+                                                         std::optional<SMALL_RECT> clip,
+                                                         const char fillCharacter,
+                                                         const WORD fillAttribute) noexcept override;
+
+    [[nodiscard]] HRESULT ScrollConsoleScreenBufferWImpl(SCREEN_INFORMATION& context,
+                                                         const SMALL_RECT& source,
+                                                         const COORD target,
+                                                         std::optional<SMALL_RECT> clip,
+                                                         const wchar_t fillCharacter,
+                                                         const WORD fillAttribute,
+                                                         const bool enableCmdShim = false) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleTextAttributeImpl(SCREEN_INFORMATION& context,
+                                                      const WORD attribute) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleWindowInfoImpl(SCREEN_INFORMATION& context,
+                                                   const bool isAbsolute,
+                                                   const SMALL_RECT& windowRect) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleOutputAttributeImpl(const SCREEN_INFORMATION& context,
+                                                         const COORD origin,
+                                                         gsl::span<WORD> buffer,
+                                                         size_t& written) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleOutputCharacterAImpl(const SCREEN_INFORMATION& context,
+                                                          const COORD origin,
+                                                          gsl::span<char> buffer,
+                                                          size_t& written) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleOutputCharacterWImpl(const SCREEN_INFORMATION& context,
+                                                          const COORD origin,
+                                                          gsl::span<wchar_t> buffer,
+                                                          size_t& written) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleInputAImpl(InputBuffer& context,
+                                                 const gsl::span<const INPUT_RECORD> buffer,
+                                                 size_t& written,
+                                                 const bool append) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleInputWImpl(InputBuffer& context,
+                                                 const gsl::span<const INPUT_RECORD> buffer,
+                                                 size_t& written,
+                                                 const bool append) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleOutputAImpl(SCREEN_INFORMATION& context,
+                                                  gsl::span<CHAR_INFO> buffer,
+                                                  const Microsoft::Console::Types::Viewport& requestRectangle,
+                                                  Microsoft::Console::Types::Viewport& writtenRectangle) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleOutputWImpl(SCREEN_INFORMATION& context,
+                                                  gsl::span<CHAR_INFO> buffer,
+                                                  const Microsoft::Console::Types::Viewport& requestRectangle,
+                                                  Microsoft::Console::Types::Viewport& writtenRectangle) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleOutputAttributeImpl(IConsoleOutputObject& OutContext,
+                                                          const gsl::span<const WORD> attrs,
+                                                          const COORD target,
+                                                          size_t& used) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleOutputCharacterAImpl(IConsoleOutputObject& OutContext,
+                                                           const std::string_view text,
+                                                           const COORD target,
+                                                           size_t& used) noexcept override;
+
+    [[nodiscard]] HRESULT WriteConsoleOutputCharacterWImpl(IConsoleOutputObject& OutContext,
+                                                           const std::wstring_view text,
+                                                           const COORD target,
+                                                           size_t& used) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleOutputAImpl(const SCREEN_INFORMATION& context,
+                                                 gsl::span<CHAR_INFO> buffer,
+                                                 const Microsoft::Console::Types::Viewport& sourceRectangle,
+                                                 Microsoft::Console::Types::Viewport& readRectangle) noexcept override;
+
+    [[nodiscard]] HRESULT ReadConsoleOutputWImpl(const SCREEN_INFORMATION& context,
+                                                 gsl::span<CHAR_INFO> buffer,
+                                                 const Microsoft::Console::Types::Viewport& sourceRectangle,
+                                                 Microsoft::Console::Types::Viewport& readRectangle) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleTitleAImpl(gsl::span<char> title,
+                                               size_t& written,
+                                               size_t& needed) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleTitleWImpl(gsl::span<wchar_t> title,
+                                               size_t& written,
+                                               size_t& needed) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleOriginalTitleAImpl(gsl::span<char> title,
+                                                       size_t& written,
+                                                       size_t& needed) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleOriginalTitleWImpl(gsl::span<wchar_t> title,
+                                                       size_t& written,
+                                                       size_t& needed) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleTitleAImpl(const std::string_view title) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleTitleWImpl(const std::wstring_view title) noexcept override;
+
+#pragma endregion
+
+#pragma region L3
+    void GetNumberOfConsoleMouseButtonsImpl(ULONG& buttons) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleFontSizeImpl(const SCREEN_INFORMATION& context,
+                                                 const DWORD index,
+                                                 COORD& size) noexcept override;
+
+    //// driver will pare down for non-Ex method
+    [[nodiscard]] HRESULT GetCurrentConsoleFontExImpl(const SCREEN_INFORMATION& context,
+                                                      const bool isForMaximumWindowSize,
+                                                      CONSOLE_FONT_INFOEX& consoleFontInfoEx) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleDisplayModeImpl(SCREEN_INFORMATION& context,
+                                                    const ULONG flags,
+                                                    COORD& newSize) noexcept override;
+
+    void GetConsoleDisplayModeImpl(ULONG& flags) noexcept override;
+
+    [[nodiscard]] HRESULT AddConsoleAliasAImpl(const std::string_view source,
+                                               const std::string_view target,
+                                               const std::string_view exeName) noexcept override;
+
+    [[nodiscard]] HRESULT AddConsoleAliasWImpl(const std::wstring_view source,
+                                               const std::wstring_view target,
+                                               const std::wstring_view exeName) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasAImpl(const std::string_view source,
+                                               gsl::span<char> target,
+                                               size_t& written,
+                                               const std::string_view exeName) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasWImpl(const std::wstring_view source,
+                                               gsl::span<wchar_t> target,
+                                               size_t& written,
+                                               const std::wstring_view exeName) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasesLengthAImpl(const std::string_view exeName,
+                                                       size_t& bufferRequired) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasesLengthWImpl(const std::wstring_view exeName,
+                                                       size_t& bufferRequired) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasExesLengthAImpl(size_t& bufferRequired) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasExesLengthWImpl(size_t& bufferRequired) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasesAImpl(const std::string_view exeName,
+                                                 gsl::span<char> alias,
+                                                 size_t& written) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasesWImpl(const std::wstring_view exeName,
+                                                 gsl::span<wchar_t> alias,
+                                                 size_t& written) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasExesAImpl(gsl::span<char> aliasExes,
+                                                   size_t& written) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleAliasExesWImpl(gsl::span<wchar_t> aliasExes,
+                                                   size_t& written) noexcept override;
+
+#pragma region CMDext Private API
+
+    [[nodiscard]] HRESULT ExpungeConsoleCommandHistoryAImpl(const std::string_view exeName) noexcept override;
+
+    [[nodiscard]] HRESULT ExpungeConsoleCommandHistoryWImpl(const std::wstring_view exeName) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleNumberOfCommandsAImpl(const std::string_view exeName,
+                                                          const size_t numberOfCommands) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleNumberOfCommandsWImpl(const std::wstring_view exeName,
+                                                          const size_t numberOfCommands) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleCommandHistoryLengthAImpl(const std::string_view exeName,
+                                                              size_t& length) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleCommandHistoryLengthWImpl(const std::wstring_view exeName,
+                                                              size_t& length) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleCommandHistoryAImpl(const std::string_view exeName,
+                                                        gsl::span<char> commandHistory,
+                                                        size_t& written) noexcept override;
+
+    [[nodiscard]] HRESULT GetConsoleCommandHistoryWImpl(const std::wstring_view exeName,
+                                                        gsl::span<wchar_t> commandHistory,
+                                                        size_t& written) noexcept override;
+
+#pragma endregion
+
+    void GetConsoleWindowImpl(HWND& hwnd) noexcept override;
+
+    void GetConsoleSelectionInfoImpl(CONSOLE_SELECTION_INFO& consoleSelectionInfo) noexcept override;
+
+    void GetConsoleHistoryInfoImpl(CONSOLE_HISTORY_INFO& consoleHistoryInfo) noexcept override;
+
+    [[nodiscard]] HRESULT SetConsoleHistoryInfoImpl(const CONSOLE_HISTORY_INFO& consoleHistoryInfo) noexcept override;
+
+    [[nodiscard]] HRESULT SetCurrentConsoleFontExImpl(IConsoleOutputObject& context,
+                                                      const bool isForMaximumWindowSize,
+                                                      const CONSOLE_FONT_INFOEX& consoleFontInfoEx) noexcept override;
+
+#pragma endregion
+
+    IApiRoutines* m_pUsualRoutines;
+    UINT& m_inputCodepage;
+    UINT& m_outputCodepage;
+    ULONG m_inputMode;
+    ULONG m_outputMode;
+    Microsoft::Console::Render::Xterm256Engine* m_pVtEngine;
+};

src/host/VtIo.cpp

@@ -13,6 +13,8 @@
 #include "input.h" // ProcessCtrlEvents
 #include "output.h" // CloseConsoleProcessState
 
+#include "VtApiRoutines.h"
+
 using namespace Microsoft::Console;
 using namespace Microsoft::Console::Render;
 using namespace Microsoft::Console::VirtualTerminal;
@@ -46,6 +48,10 @@ VtIo::VtIo() :
     {
         ioMode = VtIoMode::XTERM_256;
     }
+    else if (VtMode == XTERM_256_STRING_PT)
+    {
+        ioMode = VtIoMode::XTERM_256_PT;
+    }
     else if (VtMode == XTERM_STRING)
     {
         ioMode = VtIoMode::XTERM;
@@ -136,8 +142,9 @@ VtIo::VtIo() :
     {
         return S_FALSE;
     }
+    auto& globals = ServiceLocator::LocateGlobals();
 
-    const CONSOLE_INFORMATION& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
+    const CONSOLE_INFORMATION& gci = globals.getConsoleInformation();
 
     try
     {
@@ -153,6 +160,27 @@ VtIo::VtIo() :
                                                                 gci.GetWindowSize().Y);
             switch (_IoMode)
             {
+            case VtIoMode::XTERM_256_PT:
+            {
+                auto xtermEngine = std::make_unique<Xterm256Engine>(std::move(_hOutput),
+                                                                    initialViewport);
+
+                auto vtapi = new VtApiRoutines();
+                vtapi->m_pVtEngine = xtermEngine.get();
+                if (globals.api)
+                {
+                    vtapi->m_pUsualRoutines = globals.api;
+                }
+                else
+                {
+                    vtapi->m_pUsualRoutines = new ApiRoutines();
+                }
+
+                globals.api = vtapi;
+
+                _pVtRenderEngine = std::move(xtermEngine);
+                break;
+            }
             case VtIoMode::XTERM_256:
                 _pVtRenderEngine = std::make_unique<Xterm256Engine>(std::move(_hOutput),
                                                                     initialViewport);

src/host/globals.h

@@ -68,7 +68,7 @@ public:
 
     bool IsHeadless() const;
 
-    ApiRoutines api;
+    IApiRoutines* api;
 
     bool handoffTarget = false;
 

src/host/lib/hostlib.vcxproj

@@ -8,9 +8,15 @@
     <TargetName>ConhostV2Lib</TargetName>
     <ConfigurationType>StaticLibrary</ConfigurationType>
   </PropertyGroup>
+  <ItemGroup>
+    <ClCompile Include="..\VtApiRoutines.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="..\VtApiRoutines.h" />
+  </ItemGroup>
   <Import Project="$(SolutionDir)src\common.build.pre.props" />
   <!-- DONT ADD NEW FILES HERE, ADD THEM TO host-common.vcxitems -->
   <Import Project="$(SolutionDir)src\host\host-common.vcxitems" />
   <!-- Careful reordering these. Some default props (contained in these files) are order sensitive. -->
   <Import Project="$(SolutionDir)src\common.build.post.props" />
-</Project>
+</Project>

src/host/lib/hostlib.vcxproj.filters

@@ -183,6 +183,9 @@
     <ClCompile Include="..\ScreenBufferRenderTarget.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\VtApiRoutines.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\precomp.h">
@@ -356,6 +359,9 @@
     <ClInclude Include="..\ScreenBufferRenderTarget.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\VtApiRoutines.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Natvis Include="$(SolutionDir)tools\ConsoleTypes.natvis" />

src/host/outputStream.cpp

@@ -110,7 +110,7 @@ ConhostInternalGetSet::ConhostInternalGetSet(_In_ IIoProvider& io) :
 // - true if successful (see DoSrvGetConsoleScreenBufferInfo). false otherwise.
 bool ConhostInternalGetSet::GetConsoleScreenBufferInfoEx(CONSOLE_SCREEN_BUFFER_INFOEX& screenBufferInfo) const
 {
-    ServiceLocator::LocateGlobals().api.GetConsoleScreenBufferInfoExImpl(_io.GetActiveOutputBuffer(), screenBufferInfo);
+    ServiceLocator::LocateGlobals().api->GetConsoleScreenBufferInfoExImpl(_io.GetActiveOutputBuffer(), screenBufferInfo);
     return true;
 }
 
@@ -122,7 +122,7 @@ bool ConhostInternalGetSet::GetConsoleScreenBufferInfoEx(CONSOLE_SCREEN_BUFFER_I
 // - true if successful (see DoSrvSetConsoleScreenBufferInfo). false otherwise.
 bool ConhostInternalGetSet::SetConsoleScreenBufferInfoEx(const CONSOLE_SCREEN_BUFFER_INFOEX& screenBufferInfo)
 {
-    return SUCCEEDED(ServiceLocator::LocateGlobals().api.SetConsoleScreenBufferInfoExImpl(_io.GetActiveOutputBuffer(), screenBufferInfo));
+    return SUCCEEDED(ServiceLocator::LocateGlobals().api->SetConsoleScreenBufferInfoExImpl(_io.GetActiveOutputBuffer(), screenBufferInfo));
 }
 
 // Routine Description:
@@ -135,7 +135,7 @@ bool ConhostInternalGetSet::SetConsoleCursorPosition(const COORD position)
 {
     auto& info = _io.GetActiveOutputBuffer();
     const auto clampedPosition = info.GetTextBuffer().ClampPositionWithinLine(position);
-    return SUCCEEDED(ServiceLocator::LocateGlobals().api.SetConsoleCursorPositionImpl(info, clampedPosition));
+    return SUCCEEDED(ServiceLocator::LocateGlobals().api->SetConsoleCursorPositionImpl(info, clampedPosition));
 }
 
 // Method Description:
@@ -233,7 +233,7 @@ bool ConhostInternalGetSet::PrivateWriteConsoleInputW(std::deque<std::unique_ptr
 // - true if successful (see DoSrvSetConsoleWindowInfo). false otherwise.
 bool ConhostInternalGetSet::SetConsoleWindowInfo(const bool absolute, const SMALL_RECT& window)
 {
-    return SUCCEEDED(ServiceLocator::LocateGlobals().api.SetConsoleWindowInfoImpl(_io.GetActiveOutputBuffer(), absolute, window));
+    return SUCCEEDED(ServiceLocator::LocateGlobals().api->SetConsoleWindowInfoImpl(_io.GetActiveOutputBuffer(), absolute, window));
 }
 
 // Routine Description:

src/host/popup.cpp

@@ -169,7 +169,7 @@ void Popup::_DrawPrompt(const UINT id)
     }
 
     size_t used;
-    LOG_IF_FAILED(ServiceLocator::LocateGlobals().api.WriteConsoleOutputCharacterWImpl(_screenInfo,
+    LOG_IF_FAILED(ServiceLocator::LocateGlobals().api->WriteConsoleOutputCharacterWImpl(_screenInfo,
                                                                                        text,
                                                                                        WriteCoord,
                                                                                        used));

src/host/sources.inc

@@ -95,6 +95,7 @@ SOURCES = \
     ..\CommandListPopup.cpp \
     ..\CopyFromCharPopup.cpp \
     ..\CopyToCharPopup.cpp \
+    ..\VtApiRoutines.cpp \
 
 
 # -------------------------------------

src/host/srvinit.cpp

@@ -57,6 +57,7 @@ try
     Globals.uiWindowsCP = GetACP();
 
     Globals.pFontDefaultList = new RenderFontDefaults();
+    Globals.api = new ApiRoutines();
 
     FontInfoBase::s_SetFontDefaultList(Globals.pFontDefaultList);
 
@@ -883,7 +884,7 @@ DWORD WINAPI ConsoleIoThread(LPVOID lpParameter)
     auto& globals = ServiceLocator::LocateGlobals();
 
     CONSOLE_API_MSG ReceiveMsg;
-    ReceiveMsg._pApiRoutines = &globals.api;
+    ReceiveMsg._pApiRoutines = globals.api;
     ReceiveMsg._pDeviceComm = globals.pDeviceComm;
     PCONSOLE_API_MSG ReplyMsg = nullptr;
 
@@ -895,7 +896,7 @@ DWORD WINAPI ConsoleIoThread(LPVOID lpParameter)
         std::unique_ptr<CONSOLE_API_MSG> capturedMessage{ static_cast<PCONSOLE_API_MSG>(lpParameter) };
 
         ReceiveMsg = *capturedMessage.get();
-        ReceiveMsg._pApiRoutines = &globals.api;
+        ReceiveMsg._pApiRoutines = globals.api;
         ReceiveMsg._pDeviceComm = globals.pDeviceComm;
         IoSorter::ServiceIoOperation(&ReceiveMsg, &ReplyMsg);
     }
@@ -923,7 +924,7 @@ DWORD WINAPI ConsoleIoThread(LPVOID lpParameter)
             ReplyMsg = nullptr;
             continue;
         }
-
+        ReceiveMsg._pApiRoutines = globals.api;
         IoSorter::ServiceIoOperation(&ReceiveMsg, &ReplyMsg);
     }
 

src/inc/VtIoModes.hpp

@@ -8,10 +8,12 @@ enum class VtIoMode
     INVALID,
     XTERM,
     XTERM_256,
-    XTERM_ASCII
+    XTERM_ASCII,
+    XTERM_256_PT
 };
 
 const wchar_t* const XTERM_STRING = L"xterm";
+const wchar_t* const XTERM_256_STRING_PT = L"xterm-256color-pt";
 const wchar_t* const XTERM_256_STRING = L"xterm-256color";
 const wchar_t* const XTERM_ASCII_STRING = L"xterm-ascii";
 const wchar_t* const DEFAULT_STRING = L"";

src/interactivity/win32/windowio.cpp

@@ -565,11 +565,11 @@ BOOL HandleSysKeyEvent(const HWND hWnd, const UINT Message, const WPARAM wParam,
     CONSOLE_FONT_INFOEX font = { 0 };
     font.cbSize = sizeof(font);
 
-    RETURN_IF_FAILED(globals.api.GetCurrentConsoleFontExImpl(screenInfo, false, font));
+    RETURN_IF_FAILED(globals.api->GetCurrentConsoleFontExImpl(screenInfo, false, font));
 
     font.dwFontSize.Y += delta;
 
-    RETURN_IF_FAILED(globals.api.SetCurrentConsoleFontExImpl(screenInfo, false, font));
+    RETURN_IF_FAILED(globals.api->SetCurrentConsoleFontExImpl(screenInfo, false, font));
 
     return S_OK;
 }

src/renderer/vt/Xterm256Engine.hpp

@@ -18,6 +18,8 @@ Author(s):
 
 #include "XtermEngine.hpp"
 
+class VtApiRoutines;
+
 namespace Microsoft::Console::Render
 {
     class Xterm256Engine : public XtermEngine
@@ -35,6 +37,8 @@ namespace Microsoft::Console::Render
 
         [[nodiscard]] HRESULT ManuallyClearScrollback() noexcept override;
 
+        friend class ::VtApiRoutines;
+
     private:
         [[nodiscard]] HRESULT _UpdateExtendedAttrs(const TextAttribute& textAttributes) noexcept;
         [[nodiscard]] HRESULT _UpdateHyperlinkAttr(const TextAttribute& textAttributes,

src/server/IApiRoutines.h

@@ -44,6 +44,8 @@ public:
 
 #pragma endregion
 
+    virtual ~IApiRoutines(){};
+
 #pragma region L1
     virtual void GetConsoleInputCodePageImpl(ULONG& codepage) noexcept = 0;
 

src/winconpty/winconpty.cpp

@@ -94,7 +94,7 @@ HRESULT _CreatePseudoConsole(const HANDLE hToken,
     RETURN_IF_WIN32_BOOL_FALSE(SetHandleInformation(signalPipeConhostSide.get(), HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT));
 
     // GH4061: Ensure that the path to executable in the format is escaped so C:\Program.exe cannot collide with C:\Program Files
-    const wchar_t* pwszFormat = L"\"%s\" --headless %s%s%s--width %hu --height %hu --signal 0x%x --server 0x%x";
+    const wchar_t* pwszFormat = L"\"%s\" --headless %s%s%s--width %hu --height %hu --signal 0x%x --server 0x%x --vtmode xterm-256color-pt";
     // This is plenty of space to hold the formatted string
     wchar_t cmd[MAX_PATH]{};
     const BOOL bInheritCursor = (dwFlags & PSEUDOCONSOLE_INHERIT_CURSOR) == PSEUDOCONSOLE_INHERIT_CURSOR;