Implement the rest of the FTCS marks

src/cascadia/TerminalCore/Terminal.cpp

@@ -821,11 +821,32 @@ 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 _currentPrompt:
+        //   - Then we did know that the prompt started, (we may have also
+        //     already gotten a CommandStart 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 like as the prompt, no command, and start the
+        //   command_executed now.
+
+        if (_currentPrompt)
+        {
+            OutputStart();
+        }
+        else
+        {
+            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);
+            _currentPrompt = &_scrollMarks.back();
+            OutputStart();
+        }
     }
 
     // Unfortunately, the UI doesn't give us both a character down and a
@@ -1268,8 +1289,16 @@ 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; }),
@@ -1559,6 +1588,7 @@ 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)
@@ -1577,6 +1607,9 @@ void Terminal::AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes:
     // 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()
@@ -1593,13 +1626,19 @@ 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);
+    };
+
+    if (_currentPrompt && inSelection(*_currentPrompt))
+    {
+        _currentPrompt = nullptr;
+    }
 
     _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
@@ -1608,6 +1647,7 @@ void Terminal::ClearMark()
 }
 void Terminal::ClearAllMarks()
 {
+    _currentPrompt = nullptr;
     _scrollMarks.clear();
     // Tell the control that the scrollbar has somehow changed. Used as a
     // workaround to force the control to redraw any scrollbar marks

src/cascadia/TerminalCore/Terminal.hpp

@@ -139,7 +139,9 @@ class Microsoft::Terminal::Core::Terminal final :
     void UseMainScreenBuffer() override;
 
     void AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark) override;
-
+    void CommandStart() override;
+    void OutputStart() override;
+    void CommandFinished(std::optional<unsigned int> error) override;
     bool IsConsolePty() const override;
     bool IsVtInputEnabled() const override;
     void NotifyAccessibilityChange(const til::rect& changedRect) override;
@@ -403,6 +405,7 @@ class Microsoft::Terminal::Core::Terminal final :
     std::optional<KeyEventCodes> _lastKeyEventCodes;
 
     std::vector<Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark> _scrollMarks;
+    Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark* _currentPrompt{ nullptr };
 
     static WORD _ScanCodeFromVirtualKey(const WORD vkey) noexcept;
     static WORD _VirtualKeyFromScanCode(const WORD scanCode) noexcept;

src/cascadia/TerminalCore/TerminalApi.cpp

@@ -298,10 +298,57 @@ void Terminal::UseMainScreenBuffer()
     CATCH_LOG();
 }
 
+// NOTE: This is the version of AddMark that comes from VT
 void Terminal::AddMark(const Microsoft::Console::VirtualTerminal::DispatchTypes::ScrollMark& mark)
 {
     const til::point cursorPos{ _activeBuffer().GetCursor().GetPosition() };
     AddMark(mark, cursorPos, cursorPos);
+    auto* last = &_scrollMarks.back();
+    if (last->category == Microsoft::Console::VirtualTerminal::DispatchTypes::MarkCategory::Prompt)
+    {
+        _currentPrompt = last;
+    }
+}
+
+void Terminal::CommandStart()
+{
+    if (_currentPrompt)
+    {
+        const til::point cursorPos{ _activeBuffer().GetCursor().GetPosition() };
+
+        // Move the end of this mark to the current cursor position. The prompt
+        // is between [mark.start, mark.end)
+        _currentPrompt->end = cursorPos;
+    }
+}
+
+void Terminal::OutputStart()
+{
+    if (_currentPrompt)
+    {
+        const til::point cursorPos{ _activeBuffer().GetCursor().GetPosition() };
+        // Mark the current cursor pos as the the end of the command. The command
+        // is between [mark.end, mark.commandEnd)
+        _currentPrompt->commandEnd = cursorPos;
+    }
+}
+
+void Terminal::CommandFinished(std::optional<unsigned int> error)
+{
+    if (_currentPrompt)
+    {
+        const til::point cursorPos{ _activeBuffer().GetCursor().GetPosition() };
+        // Mark the current cursor pos as the the end of the output. The command
+        // is between [mark.commandEnd, mark.outputEnd)
+        _currentPrompt->outputEnd = cursorPos;
+
+        if (error.has_value())
+        {
+            _currentPrompt->category = *error == 0u ?
+                                           DispatchTypes::MarkCategory::Success :
+                                           DispatchTypes::MarkCategory::Error;
+        }
+    }
 }
 
 // Method Description:

src/host/outputStream.cpp

@@ -486,3 +486,18 @@ void ConhostInternalGetSet::AddMark(const Microsoft::Console::VirtualTerminal::D
 {
     // Not implemented for conhost.
 }
+
+void ConhostInternalGetSet::CommandStart()
+{
+    // Not implemented for conhost.
+}
+
+void ConhostInternalGetSet::OutputStart()
+{
+    // Not implemented for conhost.
+}
+
+void ConhostInternalGetSet::CommandFinished(std::optional<unsigned int> /*error*/)
+{
+    // Not implemented for conhost.
+}

src/host/outputStream.hpp

@@ -75,6 +75,9 @@ 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 CommandStart() override;
+    void OutputStart() override;
+    void CommandFinished(std::optional<unsigned int> error) override;
 
 private:
     Microsoft::Console::IIoProvider& _io;

src/terminal/adapter/DispatchTypes.hpp

@@ -523,6 +523,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

@@ -78,5 +78,8 @@ 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 CommandStart() = 0;
+        virtual void OutputStart() = 0;
+        virtual void CommandFinished(std::optional<unsigned int> error) = 0;
     };
 }

src/terminal/adapter/adaptDispatch.cpp

@@ -2674,6 +2674,35 @@ bool AdaptDispatch::DoFinalTermAction(const std::wstring_view string)
         _api.AddMark(mark);
         return true;
     }
+    else if (action == L"B") // FTCS_COMMAND_START
+    {
+        _api.CommandStart();
+        return true;
+    }
+    else if (action == L"C") // FTCS_COMMAND_EXECUTED
+    {
+        _api.OutputStart();
+        return true;
+    }
+    else if (action == 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.CommandFinished(error);
+        return true;
+    }
 
     // When we add the rest of the FTCS sequences (GH#11000), we should add a
     // simple state machine here to track the most recently emitted mark from