Implement the rest of the FTCS marks

src/cascadia/TerminalControl/ControlCore.cpp

@@ -2020,7 +2020,7 @@ namespace winrt::Microsoft::Terminal::Control::implementation
 
         // The version of this that only accepts a ScrollMark will automatically
         // set the start & end to the cursor position.
-        _terminal->AddMark(m, m.start, m.end);
+        _terminal->AddMark(m, m.start, m.end, true);
     }
     void ControlCore::ClearMark() { _terminal->ClearMark(); }
     void ControlCore::ClearAllMarks() { _terminal->ClearAllMarks(); }

src/cascadia/TerminalCore/Terminal.cpp

@@ -804,11 +804,20 @@ bool Terminal::SendCharEvent(const wchar_t ch, const WORD scanCode, const Contro
     // Then treat this line like it's a prompt mark.
     if (_autoMarkPrompts && vkey == VK_RETURN && !_inAltBuffer())
     {
-        DispatchTypes::ScrollMark mark;
-        mark.category = DispatchTypes::MarkCategory::Prompt;
-        // Don't set the color - we'll automatically use the DEFAULT_FOREGROUND
-        // color for any MarkCategory::Prompt marks without one set.
-        AddMark(mark);
+        // * If we have a current prompt:
+        //   - Then we did know that the prompt started, (we may have also
+        //     already gotten a MarkCommandStart sequence). The user has pressed
+        //     enter, and we're treating that like the prompt has now ended.
+        //     - Perform a FTCS_COMMAND_EXECUTED, so that we start marking this
+        //       as output.
+        //     - This enables CMD to have full FTCS support, even though there's
+        //       no point in CMD to insert a "preexec" hook
+        // * Else: We don't have a prompt. We don't know anything else, but we
+        //   can set the whole line as the prompt, no command, and start the
+        //   command_executed now.
+        //
+        // Fortunately, MarkOutputStart will do all this logic for us!
+        MarkOutputStart();
     }
 
     // Unfortunately, the UI doesn't give us both a character down and a
@@ -1251,8 +1260,20 @@ void Terminal::_AdjustCursorPosition(const til::point proposedPosition)
         {
             for (auto& mark : _scrollMarks)
             {
+                // Move the mark up
                 mark.start.y -= rowsPushedOffTopOfBuffer;
+
+                // If the mark had sub-regions, then move those pointers too
+                if (mark.commandEnd.has_value())
+                {
+                    (*mark.commandEnd).y -= rowsPushedOffTopOfBuffer;
+                }
+                if (mark.outputEnd.has_value())
+                {
+                    (*mark.outputEnd).y -= rowsPushedOffTopOfBuffer;
+                }
             }
+
             _scrollMarks.erase(std::remove_if(_scrollMarks.begin(),
                                               _scrollMarks.end(),
                                               [](const VirtualTerminal::DispatchTypes::ScrollMark& m) { return m.start.y < 0; }),
@@ -1542,9 +1563,11 @@ void Terminal::_updateUrlDetection()
     }
 }
 
+// NOTE: This is the version of AddMark that comes from the UI. The VT api call into this too.
 void Terminal::AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark,
                        const til::point& start,
-                       const til::point& end)
+                       const til::point& end,
+                       const bool fromUi)
 {
     if (_inAltBuffer())
     {
@@ -1555,11 +1578,21 @@ void Terminal::AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes:
     m.start = start;
     m.end = end;
 
-    _scrollMarks.push_back(m);
+    if (fromUi)
+    {
+        _scrollMarks.insert(_scrollMarks.begin(), m);
+    }
+    else
+    {
+        _scrollMarks.push_back(m);
+    }
 
     // Tell the control that the scrollbar has somehow changed. Used as a
     // workaround to force the control to redraw any scrollbar marks
     _NotifyScrollEvent();
+
+    // DON'T set _currentPrompt. The VT impl will do that for you. We don't want
+    // UI-driven marks to set that.
 }
 
 void Terminal::ClearMark()
@@ -1576,13 +1609,14 @@ void Terminal::ClearMark()
         start = til::point{ GetSelectionAnchor() };
         end = til::point{ GetSelectionEnd() };
     }
+    auto inSelection = [&start, &end](const DispatchTypes::ScrollMark& m) {
+        return (m.start >= start && m.start <= end) ||
+               (m.end >= start && m.end <= end);
+    };
 
     _scrollMarks.erase(std::remove_if(_scrollMarks.begin(),
                                       _scrollMarks.end(),
-                                      [&start, &end](const auto& m) {
-                                          return (m.start >= start && m.start <= end) ||
-                                                 (m.end >= start && m.end <= end);
-                                      }),
+                                      inSelection),
                        _scrollMarks.end());
 
     // Tell the control that the scrollbar has somehow changed. Used as a

src/cascadia/TerminalCore/Terminal.hpp

@@ -103,7 +103,8 @@ class Microsoft::Terminal::Core::Terminal final :
     const std::vector<Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark>& GetScrollMarks() const noexcept;
     void AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark,
                  const til::point& start,
-                 const til::point& end);
+                 const til::point& end,
+                 const bool fromUi);
 
 #pragma region ITerminalApi
     // These methods are defined in TerminalApi.cpp
@@ -133,7 +134,10 @@ class Microsoft::Terminal::Core::Terminal final :
     void UseAlternateScreenBuffer() override;
     void UseMainScreenBuffer() override;
 
-    void AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark) override;
+    void MarkPrompt(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark) override;
+    void MarkCommandStart() override;
+    void MarkOutputStart() override;
+    void MarkCommandFinish(std::optional<unsigned int> error) override;
 
     bool IsConsolePty() const noexcept override;
     bool IsVtInputEnabled() const noexcept override;
@@ -399,6 +403,14 @@ class Microsoft::Terminal::Core::Terminal final :
     std::optional<KeyEventCodes> _lastKeyEventCodes;
 
     std::vector<Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark> _scrollMarks;
+    enum class PromptState : uint32_t
+    {
+        None = 0,
+        Prompt,
+        Command,
+        Output,
+    };
+    PromptState _currentPromptState{ PromptState::None };
 
     static WORD _ScanCodeFromVirtualKey(const WORD vkey) noexcept;
     static WORD _VirtualKeyFromScanCode(const WORD scanCode) noexcept;

src/cascadia/TerminalCore/TerminalApi.cpp

@@ -298,10 +298,104 @@ void Terminal::UseMainScreenBuffer()
     CATCH_LOG();
 }
 
-void Terminal::AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark)
+// NOTE: This is the version of AddMark that comes from VT
+void Terminal::MarkPrompt(const DispatchTypes::ScrollMark& mark)
 {
     const til::point cursorPos{ _activeBuffer().GetCursor().GetPosition() };
-    AddMark(mark, cursorPos, cursorPos);
+    AddMark(mark, cursorPos, cursorPos, false);
+
+    if (mark.category == DispatchTypes::MarkCategory::Prompt)
+    {
+        _currentPromptState = PromptState::Prompt;
+    }
+}
+
+void Terminal::MarkCommandStart()
+{
+    const til::point cursorPos{ _activeBuffer().GetCursor().GetPosition() };
+
+    if ((_currentPromptState == PromptState::Prompt) &&
+        (_scrollMarks.size() > 0))
+    {
+        // We were in the right state, and there's a previous mark to work
+        // with.
+        //
+        //We can just do the work below safely.
+    }
+    else
+    {
+        // If there was no last mark, or we're in a weird state,
+        // then abandon the current state, and just insert a new Prompt mark that
+        // start's & ends here, and got to State::Command.
+
+        DispatchTypes::ScrollMark mark;
+        mark.category = DispatchTypes::MarkCategory::Prompt;
+        AddMark(mark, cursorPos, cursorPos, false);
+    }
+    _scrollMarks.back().end = cursorPos;
+    _currentPromptState = PromptState::Command;
+}
+
+void Terminal::MarkOutputStart()
+{
+    const til::point cursorPos{ _activeBuffer().GetCursor().GetPosition() };
+
+    if ((_currentPromptState == PromptState::Command) &&
+        (_scrollMarks.size() > 0))
+    {
+        // We were in the right state, and there's a previous mark to work
+        // with.
+        //
+        //We can just do the work below safely.
+    }
+    else
+    {
+        // If there was no last mark, or we're in a weird state,
+        // then abandon the current state, and just insert a new Prompt mark that
+        // start's & ends here, and the command ends here, and go to State::Output.
+
+        DispatchTypes::ScrollMark mark;
+        mark.category = DispatchTypes::MarkCategory::Prompt;
+        AddMark(mark, cursorPos, cursorPos, false);
+    }
+    _scrollMarks.back().commandEnd = cursorPos;
+    _currentPromptState = PromptState::Output;
+}
+
+void Terminal::MarkCommandFinish(std::optional<unsigned int> error)
+{
+    const til::point cursorPos{ _activeBuffer().GetCursor().GetPosition() };
+    auto category = DispatchTypes::MarkCategory::Prompt;
+    if (error.has_value())
+    {
+        category = *error == 0u ?
+                       DispatchTypes::MarkCategory::Success :
+                       DispatchTypes::MarkCategory::Error;
+    }
+
+    if ((_currentPromptState == PromptState::Output) &&
+        (_scrollMarks.size() > 0))
+    {
+        // We were in the right state, and there's a previous mark to work
+        // with.
+        //
+        //We can just do the work below safely.
+    }
+    else
+    {
+        // If there was no last mark, or we're in a weird state, then abandon
+        // the current state, and just insert a new Prompt mark that start's &
+        // ends here, and the command ends here, AND the output ends here. and
+        // go to State::Output.
+
+        DispatchTypes::ScrollMark mark;
+        mark.category = DispatchTypes::MarkCategory::Prompt;
+        AddMark(mark, cursorPos, cursorPos, false);
+        _scrollMarks.back().commandEnd = cursorPos;
+    }
+    _scrollMarks.back().outputEnd = cursorPos;
+    _scrollMarks.back().category = category;
+    _currentPromptState = PromptState::None;
 }
 
 // Method Description:

src/host/outputStream.cpp

@@ -482,7 +482,22 @@ void ConhostInternalGetSet::NotifyAccessibilityChange(const til::rect& changedRe
     }
 }
 
-void ConhostInternalGetSet::AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& /*mark*/)
+void ConhostInternalGetSet::MarkPrompt(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& /*mark*/)
+{
+    // Not implemented for conhost.
+}
+
+void ConhostInternalGetSet::MarkCommandStart()
+{
+    // Not implemented for conhost.
+}
+
+void ConhostInternalGetSet::MarkOutputStart()
+{
+    // Not implemented for conhost.
+}
+
+void ConhostInternalGetSet::MarkCommandFinish(std::optional<unsigned int> /*error*/)
 {
     // Not implemented for conhost.
 }

src/host/outputStream.hpp

@@ -74,7 +74,10 @@ class ConhostInternalGetSet final : public Microsoft::Console::VirtualTerminal::
 
     void NotifyAccessibilityChange(const til::rect& changedRect) override;
 
-    void AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark) override;
+    void MarkPrompt(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark) override;
+    void MarkCommandStart() override;
+    void MarkOutputStart() override;
+    void MarkCommandFinish(std::optional<unsigned int> error) override;
 
 private:
     Microsoft::Console::IIoProvider& _io;

src/terminal/adapter/DispatchTypes.hpp

@@ -530,6 +530,9 @@ namespace Microsoft::Console::VirtualTerminal::DispatchTypes
         std::optional<til::color> color;
         til::point start;
         til::point end; // exclusive
+        std::optional<til::point> commandEnd;
+        std::optional<til::point> outputEnd;
+
         MarkCategory category{ MarkCategory::Info };
         // Other things we may want to think about in the future are listed in
         // GH#11000

src/terminal/adapter/ITerminalApi.hpp

@@ -77,6 +77,9 @@ namespace Microsoft::Console::VirtualTerminal
 
         virtual void NotifyAccessibilityChange(const til::rect& changedRect) = 0;
 
-        virtual void AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark) = 0;
+        virtual void MarkPrompt(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark) = 0;
+        virtual void MarkCommandStart() = 0;
+        virtual void MarkOutputStart() = 0;
+        virtual void MarkCommandFinish(std::optional<unsigned int> error) = 0;
     };
 }

src/terminal/adapter/adaptDispatch.cpp

@@ -2995,7 +2995,7 @@ bool AdaptDispatch::DoITerm2Action(const std::wstring_view string)
     {
         DispatchTypes::ScrollMark mark;
         mark.category = DispatchTypes::MarkCategory::Prompt;
-        _api.AddMark(mark);
+        _api.MarkPrompt(mark);
         return true;
     }
     return false;
@@ -3034,14 +3034,52 @@ bool AdaptDispatch::DoFinalTermAction(const std::wstring_view string)
     }
 
     const auto action = til::at(parts, 0);
-
-    if (action == L"A") // FTCS_PROMPT
+    if (action.size() == 1)
     {
-        // Simply just mark this line as a prompt line.
-        DispatchTypes::ScrollMark mark;
-        mark.category = DispatchTypes::MarkCategory::Prompt;
-        _api.AddMark(mark);
-        return true;
+        switch (til::at(action, 0))
+        {
+        case L'A': // FTCS_PROMPT
+        {
+            // Simply just mark this line as a prompt line.
+            DispatchTypes::ScrollMark mark;
+            mark.category = DispatchTypes::MarkCategory::Prompt;
+            _api.MarkPrompt(mark);
+            return true;
+        }
+        case L'B': // FTCS_COMMAND_START
+        {
+            _api.MarkCommandStart();
+            return true;
+        }
+        case L'C': // FTCS_COMMAND_EXECUTED
+        {
+            _api.MarkOutputStart();
+            return true;
+        }
+        case L'D': // FTCS_COMMAND_FINISHED
+        {
+            std::optional<unsigned int> error = std::nullopt;
+            if (parts.size() >= 2)
+            {
+                const auto errorString = til::at(parts, 1);
+
+                // If we fail to parse the code, then it was gibberish, or it might
+                // have just started with "-". Either way, let's just treat it as an
+                // error and move on.
+                //
+                // We know that "0" will be successfully parsed, and that's close enough.
+                unsigned int parsedError = 0;
+                error = Utils::StringToUint(errorString, parsedError) ? parsedError :
+                                                                        static_cast<unsigned int>(-1);
+            }
+            _api.MarkCommandFinish(error);
+            return true;
+        }
+        default:
+        {
+            return false;
+        }
+        }
     }
 
     // When we add the rest of the FTCS sequences (GH#11000), we should add a