Ensure a terminal requesting FG rights actually has them

src/cascadia/TerminalControl/ControlCore.cpp

@@ -1696,6 +1696,27 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         }
     }
 
+    // Method Description:
+    // - When the control gains focus, it needs to tell ConPTY about this.
+    //   Usually, these sequences are reserved for applications that
+    //   specifically request SET_FOCUS_EVENT_MOUSE, ?1004h. ConPTY uses this
+    //   sequence REGARDLESS to communicate if the control was focused or not.
+    // - Even if a client application disables this mode, the Terminal & conpty
+    //   should always request this from the hosting terminal (and just ignore
+    //   internally to ConPTY).
+    // - Full support for this sequence is tracked in GH#11682.
+    // - This is related to work done for GH#2988.
+    void ControlCore::GotFocus()
+    {
+        _connection.WriteInput(L"\x1b[I");
+    }
+
+    // See GotFocus.
+    void ControlCore::LostFocus()
+    {
+        _connection.WriteInput(L"\x1b[O");
+    }
+
     bool ControlCore::_isBackgroundTransparent()
     {
         // If we're:

src/cascadia/TerminalControl/ControlCore.h

@@ -81,6 +81,9 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         void PasteText(const winrt::hstring& hstr);
         bool CopySelectionToClipboard(bool singleLine, const Windows::Foundation::IReference<CopyFormat>& formats);
 
+        void GotFocus();
+        void LostFocus();
+
         void ToggleShaderEffects();
         void AdjustOpacity(const double adjustment);
         void ResumeRendering();

src/cascadia/TerminalControl/ControlInteractivity.cpp

@@ -111,6 +111,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
             THROW_IF_FAILED(_uiaEngine->Enable());
         }
 
+        _core->GotFocus();
+
         _updateSystemParameterSettings();
     }
 
@@ -120,6 +122,8 @@ namespace winrt::Microsoft::Terminal::Control::implementation
         {
             THROW_IF_FAILED(_uiaEngine->Disable());
         }
+
+        _core->LostFocus();
     }
 
     // Method Description

src/host/CursorBlinker.cpp

@@ -82,8 +82,10 @@ void CursorBlinker::TimerRoutine(SCREEN_INFORMATION& ScreenInfo) const noexcept
     auto& cursor = buffer.GetCursor();
     auto& gci = ServiceLocator::LocateGlobals().getConsoleInformation();
     auto* const pAccessibilityNotifier = ServiceLocator::LocateAccessibilityNotifier();
+    const bool inConpty{ gci.IsInVtIoMode() };
 
-    if (!WI_IsFlagSet(gci.Flags, CONSOLE_HAS_FOCUS))
+    // GH#2988: ConPTY can now be focused, but it doesn't need to do any of this work either.
+    if (inConpty || !WI_IsFlagSet(gci.Flags, CONSOLE_HAS_FOCUS))
     {
         goto DoScroll;
     }

src/server/IoDispatchers.cpp

@@ -456,7 +456,22 @@ PCONSOLE_API_MSG IoDispatchers::ConsoleHandleConnectionRequest(_In_ PCONSOLE_API
         return pReceiveMsg;
     }
 
-    gci.ProcessHandleList.ModifyConsoleProcessFocus(WI_IsFlagSet(gci.Flags, CONSOLE_HAS_FOCUS));
+    // For future code archeologists: GH#2988
+    //
+    // Here, the console calls ConsoleControl(ConsoleSetForeground,...) with a
+    // flag depending on if the console is focused or not. This is surprisingly
+    // load bearing. This allows windows spawned by console processes to bring
+    // themselves to the foreground _when the console is focused_.
+    // (Historically, this is also called in the WndProc, when focus changes).
+    //
+    // Notably, before 2022, ConPTY was _never_ focused, so windows could never
+    // bring themselves to the foreground when run from a ConPTY console. We're
+    // not blanket granting the SetForeground right to all console apps when run
+    // in ConPTY. It's the responsibility of the hosting terminal emulator to
+    // always tell ConPTY when a particular instance is focused.
+    const bool hasFocus{ WI_IsFlagSet(gci.Flags, CONSOLE_HAS_FOCUS) };
+    const auto grantSetForeground{ hasFocus };
+    gci.ProcessHandleList.ModifyConsoleProcessFocus(grantSetForeground);
 
     // Create the handles.
 

src/terminal/adapter/IInteractDispatch.hpp

@@ -42,5 +42,7 @@ namespace Microsoft::Console::VirtualTerminal
                                 const size_t col) = 0;
 
         virtual bool IsVtInputEnabled() const = 0;
+
+        virtual bool FocusChanged(const bool focused) const = 0;
     };
 }

src/terminal/adapter/InteractDispatch.cpp

@@ -181,3 +181,75 @@ bool InteractDispatch::IsVtInputEnabled() const
 {
     return _pConApi->IsVtInputEnabled();
 }
+
+// Method Description:
+// - Inform the console that the window is focused. This is used by ConPTY.
+//   Terminals can send ConPTY a FocusIn/FocusOut sequence on the input pipe,
+//   which will end up here. This will update the console's internal tracker if
+//   it's focused or not, as to match the end-terminal's state.
+// - Used to call ConsoleControl(ConsoleSetForeground,...).
+// - Full support for this sequence is tracked in GH#11682.
+// Arguments:
+// - focused: if the terminal is now focused
+// Return Value:
+// - true always.
+bool InteractDispatch::FocusChanged(const bool focused) const
+{
+    auto& g = ServiceLocator::LocateGlobals();
+    auto& gci = g.getConsoleInformation();
+
+    if (gci.IsInVtIoMode())
+    {
+        bool shouldActuallyFocus = false;
+
+        // From https://github.com/microsoft/terminal/pull/12799#issuecomment-1086289552
+        // Make sure that the process that's telling us it's focused, actually
+        // _is_ in the FG. We don't want to allow malicious.exe to say "yep I'm
+        // in the foreground, also, here's a popup" if it isn't actually in the
+        // FG.
+        if (focused)
+        {
+            if (const auto psuedoHwnd{ ServiceLocator::LocatePseudoWindow() })
+            {
+                // They want focus, we found a pseudo hwnd.
+
+                // Note: ::GetParent(psuedoHwnd) will return 0. GetAncestor works though.
+                // GA_PARENT and GA_ROOT seemingly return the same thing for
+                // Terminal. We're going with GA_ROOT since it seems
+                // semantically more correct here.
+                if (const auto ownerHwnd{ ::GetAncestor(psuedoHwnd, GA_ROOT) })
+                {
+                    // We have an owner from a previous call to ReparentWindow
+
+                    if (const auto currentFgWindow{ ::GetForegroundWindow() })
+                    {
+                        // There is a window in the foreground (it's possible there
+                        // isn't one)
+
+                        // Get the PID of the current FG window, and compare with our owner's PID.
+                        DWORD currentFgPid{ 0 };
+                        DWORD ownerPid{ 0 };
+                        GetWindowThreadProcessId(currentFgWindow, &currentFgPid);
+                        GetWindowThreadProcessId(ownerHwnd, &ownerPid);
+
+                        if (ownerPid == currentFgPid)
+                        {
+                            // Huzzah, the app that owns us is actually the FG
+                            // process. They're allowed to grand FG rights.
+                            shouldActuallyFocus = true;
+                        }
+                    }
+                }
+            }
+        }
+
+        WI_UpdateFlag(gci.Flags, CONSOLE_HAS_FOCUS, shouldActuallyFocus);
+        gci.ProcessHandleList.ModifyConsoleProcessFocus(shouldActuallyFocus);
+    }
+    // Does nothing outside of ConPTY. If there's a real HWND, then the HWND is solely in charge.
+
+    // Theoretically, this could be propagated as a focus event as well, to the
+    // input buffer. That should be considered when implementing GH#11682.
+
+    return true;
+}

src/terminal/adapter/InteractDispatch.hpp

@@ -35,6 +35,8 @@ namespace Microsoft::Console::VirtualTerminal
 
         bool IsVtInputEnabled() const override;
 
+        bool FocusChanged(const bool focused) const override;
+
     private:
         std::unique_ptr<ConGetSet> _pConApi;
     };

src/terminal/parser/InputStateMachineEngine.cpp

@@ -362,9 +362,14 @@ bool InputStateMachineEngine::ActionCsiDispatch(const VTID id, const VTParameter
     // win32-input-mode, and if they did, then we'll just translate the
     // INPUT_RECORD back to the same sequence we say here later on, when the
     // client reads it.
+    //
+    // Focus events in conpty are special, so don't flush those through either.
+    // See GH#12799, GH#12900 for details
     if (_pDispatch->IsVtInputEnabled() &&
         _pfnFlushToInputQueue &&
-        id != CsiActionCodes::Win32KeyboardInput)
+        id != CsiActionCodes::Win32KeyboardInput &&
+        id != CsiActionCodes::FocusIn &&
+        id != CsiActionCodes::FocusOut)
     {
         return _pfnFlushToInputQueue();
     }
@@ -426,6 +431,12 @@ bool InputStateMachineEngine::ActionCsiDispatch(const VTID id, const VTParameter
     case CsiActionCodes::DTTERM_WindowManipulation:
         success = _pDispatch->WindowManipulation(parameters.at(0), parameters.at(1), parameters.at(2));
         break;
+    case CsiActionCodes::FocusIn:
+        success = _pDispatch->FocusChanged(true);
+        break;
+    case CsiActionCodes::FocusOut:
+        success = _pDispatch->FocusChanged(false);
+        break;
     case CsiActionCodes::Win32KeyboardInput:
     {
         // Use WriteCtrlKey here, even for keys that _aren't_ control keys,

src/terminal/parser/InputStateMachineEngine.hpp

@@ -58,6 +58,8 @@ namespace Microsoft::Console::VirtualTerminal
         ArrowLeft = VTID("D"),
         Home = VTID("H"),
         End = VTID("F"),
+        FocusIn = VTID("I"),
+        FocusOut = VTID("O"),
         MouseDown = VTID("<M"),
         MouseUp = VTID("<m"),
         Generic = VTID("~"), // Used for a whole bunch of possible keys

src/terminal/parser/ut_parser/InputEngineTest.cpp

@@ -332,6 +332,8 @@ class Microsoft::Console::VirtualTerminal::TestInteractDispatch final : public I
 
     virtual bool IsVtInputEnabled() const override;
 
+    virtual bool FocusChanged(const bool focused) const override;
+
 private:
     std::function<void(std::deque<std::unique_ptr<IInputEvent>>&)> _pfnWriteInputCallback;
     TestState* _testState; // non-ownership pointer
@@ -399,6 +401,11 @@ bool TestInteractDispatch::IsVtInputEnabled() const
     return true;
 }
 
+bool TestInteractDispatch::FocusChanged(const bool /*focused*/) const
+{
+    return false;
+}
+
 void InputEngineTest::C0Test()
 {
     auto pfn = std::bind(&TestState::TestInputCallback, &testState, std::placeholders::_1);