Shockingly, this works, it works elevated, and it works unpackaged

src/cascadia/Remoting/Microsoft.Terminal.RemotingLib.vcxproj

@@ -24,6 +24,9 @@
     <ClInclude Include="Peasant.h">
       <DependentUpon>Peasant.idl</DependentUpon>
     </ClInclude>
+    <ClInclude Include="WindowManager.h">
+      <DependentUpon>WindowManager  .idl</DependentUpon>
+    </ClInclude>
   </ItemGroup>
   <!-- ========================= Cpp Files ======================== -->
   <ItemGroup>
@@ -36,12 +39,16 @@
     <ClCompile Include="Peasant.cpp">
       <DependentUpon>Peasant.idl</DependentUpon>
     </ClCompile>
+    <ClCompile Include="WindowManager.cpp">
+      <DependentUpon>WindowManager.idl</DependentUpon>
+    </ClCompile>
     <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" />
   </ItemGroup>
   <!-- ========================= idl Files ======================== -->
   <ItemGroup>
     <Midl Include="Monarch.idl" />
     <Midl Include="Peasant.idl" />
+    <Midl Include="WindowManager.idl" />
   </ItemGroup>
   <!-- ========================= Misc Files ======================== -->
   <ItemGroup>

src/cascadia/Remoting/WindowManager.cpp

@@ -0,0 +1,67 @@
+#include "pch.h"
+#include "WindowManager.h"
+#include "MonarchFactory.h"
+
+#include "WindowManager.g.cpp"
+#include "../../types/inc/utils.hpp"
+
+using namespace winrt;
+using namespace winrt::Windows::Foundation;
+using namespace ::Microsoft::Console;
+
+namespace winrt::Microsoft::Terminal::Remoting::implementation
+{
+    WindowManager::WindowManager()
+    {
+        _RegisterAsMonarch();
+        _CreateMonarch();
+    }
+    WindowManager::~WindowManager()
+    {
+        // IMPORTANT! Tear down the registration as soon as we exit. If we're not a
+        // real peasant window (the monarch passed our commandline to someone else),
+        // then the monarch dies, we don't want our registration becoming the active
+        // monarch!
+        CoRevokeClassObject(_registrationHostClass);
+        _registrationHostClass = 0;
+    }
+
+    void WindowManager::ProposeCommandline()
+    {
+        _shouldCreateWindow = true;
+    }
+
+    bool WindowManager::ShouldCreateWindow()
+    {
+        return _shouldCreateWindow;
+    }
+
+    void WindowManager::_RegisterAsMonarch()
+    {
+        winrt::check_hresult(CoRegisterClassObject(Monarch_clsid,
+                                                   winrt::make<::MonarchFactory>().get(),
+                                                   CLSCTX_LOCAL_SERVER,
+                                                   REGCLS_MULTIPLEUSE,
+                                                   &_registrationHostClass));
+    }
+
+    void WindowManager::_CreateMonarch()
+    {
+        // Heads up! This only works because we're using
+        // "metadata-based-marshalling" for our WinRT types. THat means the OS is
+        // using the .winmd file we generate to figure out the proxy/stub
+        // definitions for our types automatically. This only works in the following
+        // cases:
+        //
+        // * If we're running unpackaged: the .winmd but be a sibling of the .exe
+        // * If we're running packaged: the .winmd must be in the package root
+        _monarch = create_instance<winrt::Microsoft::Terminal::Remoting::Monarch>(Monarch_clsid,
+                                                                                  CLSCTX_LOCAL_SERVER);
+    }
+
+    // bool AppHost::_ProposeCommandlineToMonarch()
+    // {
+    //     // returns true if we should create a new window
+    //     return true;
+    // }
+}

src/cascadia/Remoting/WindowManager.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "WindowManager.g.h"
+#include "Peasant.h"
+#include "Monarch.h"
+#include "../cascadia/inc/cppwinrt_utils.h"
+
+namespace winrt::Microsoft::Terminal::Remoting::implementation
+{
+    struct WindowManager : public WindowManagerT<WindowManager>
+    {
+        WindowManager();
+        ~WindowManager();
+
+        void ProposeCommandline();
+        bool ShouldCreateWindow();
+
+    private:
+        bool _shouldCreateWindow{ false };
+        DWORD _registrationHostClass{ 0 };
+        winrt::Microsoft::Terminal::Remoting::Monarch _monarch{ nullptr };
+
+        void _RegisterAsMonarch();
+        void _CreateMonarch();
+    };
+}
+
+namespace winrt::Microsoft::Terminal::Remoting::factory_implementation
+{
+    BASIC_FACTORY(WindowManager);
+}

src/cascadia/Remoting/WindowManager.idl

@@ -0,0 +1,12 @@
+
+
+namespace Microsoft.Terminal.Remoting
+{
+
+    [default_interface] runtimeclass WindowManager
+    {
+        WindowManager();
+        void ProposeCommandline();
+        Boolean ShouldCreateWindow { get; };
+    };
+}

src/cascadia/WindowsTerminal/AppHost.cpp

@@ -3,13 +3,12 @@
 
 #include "pch.h"
 #include "AppHost.h"
+// #include "MonarchFactory.h"
 #include "../types/inc/Viewport.hpp"
 #include "../types/inc/utils.hpp"
 #include "../types/inc/User32Utils.hpp"
 #include "resource.h"
 
-#include <winrt/Microsoft.Terminal.TerminalControl.h>
-
 using namespace winrt::Windows::UI;
 using namespace winrt::Windows::UI::Composition;
 using namespace winrt::Windows::UI::Xaml;
@@ -25,17 +24,26 @@ static constexpr short KeyPressed{ gsl::narrow_cast<short>(0x8000) };
 
 AppHost::AppHost() noexcept :
     _app{},
+    _windowManager{},
     _logic{ nullptr }, // don't make one, we're going to take a ref on app's
     _window{ nullptr }
 {
     _logic = _app.Logic(); // get a ref to app's logic
 
-    _useNonClientArea = _logic.GetShowTabsInTitlebar();
+    _windowManager.ProposeCommandline();
+    // _RegisterAsMonarch();
+    // _CreateMonarch();
+    _shouldCreateWindow = _windowManager.ShouldCreateWindow();
+    if (!_shouldCreateWindow)
+    {
+        return;
+    }
 
     // If there were commandline args to our process, try and process them here.
     // Do this before AppLogic::Create, otherwise this will have no effect
-    _HandleCommandlineArgs();
+    _HandleCommandlineArgs(); // TODO:MG <-- This probably needs to move into _ProposeCommandlineToMonarch
 
+    _useNonClientArea = _logic.GetShowTabsInTitlebar();
     if (_useNonClientArea)
     {
         _window = std::make_unique<NonClientIslandWindow>(_logic.GetRequestedTheme());
@@ -65,6 +73,7 @@ AppHost::AppHost() noexcept :
 AppHost::~AppHost()
 {
     // destruction order is important for proper teardown here
+
     _window = nullptr;
     _app.Close();
     _app = nullptr;
@@ -462,3 +471,27 @@ void AppHost::_WindowMouseWheeled(const til::point coord, const int32_t delta)
         }
     }
 }
+
+bool AppHost::HasWindow()
+{
+    return _shouldCreateWindow;
+}
+
+// void AppHost::_RegisterAsMonarch()
+// {
+//     winrt::check_hresult(CoRegisterClassObject(Monarch_clsid,
+//                                         winrt::make<::MonarchFactory>().get(),
+//                                         CLSCTX_LOCAL_SERVER,
+//                                         REGCLS_MULTIPLEUSE,
+//                                         &_registrationHostClass));
+// }
+
+// void AppHost::_CreateMonarch()
+// {
+// }
+
+// bool AppHost::_ProposeCommandlineToMonarch()
+// {
+//     // returns true if we should create a new window
+//     return true;
+// }

src/cascadia/WindowsTerminal/AppHost.h

@@ -3,9 +3,6 @@
 
 #include "pch.h"
 
-#include <winrt/TerminalApp.h>
-#include <winrt/Microsoft.Terminal.Settings.Model.h>
-
 #include "NonClientIslandWindow.h"
 
 class AppHost
@@ -20,12 +17,17 @@ class AppHost
     bool OnDirectKeyEvent(const uint32_t vkey, const uint8_t scanCode, const bool down);
     void SetTaskbarProgress(const winrt::Windows::Foundation::IInspectable& sender, const winrt::Windows::Foundation::IInspectable& args);
 
+    bool HasWindow();
+
 private:
     bool _useNonClientArea;
 
     std::unique_ptr<IslandWindow> _window;
     winrt::TerminalApp::App _app;
     winrt::TerminalApp::AppLogic _logic;
+    bool _shouldCreateWindow{ false };
+    // DWORD _registrationHostClass{ 0 };
+    winrt::Microsoft::Terminal::Remoting::WindowManager _windowManager{ nullptr };
 
     void _HandleCommandlineArgs();
 
@@ -43,4 +45,8 @@ class AppHost
     void _RaiseVisualBell(const winrt::Windows::Foundation::IInspectable& sender,
                           const winrt::Windows::Foundation::IInspectable& arg);
     void _WindowMouseWheeled(const til::point coord, const int32_t delta);
+
+    // void _RegisterAsMonarch();
+    // void _CreateMonarch();
+    // bool _ProposeCommandlineToMonarch();
 };

src/cascadia/WindowsTerminal/main.cpp

@@ -124,6 +124,10 @@ int __stdcall wWinMain(HINSTANCE, HINSTANCE, LPWSTR, int)
     // Terminal App. This MUST BE constructed before the Xaml manager as TermApp
     // provides an implementation of Windows.UI.Xaml.Application.
     AppHost host;
+    if (!host.HasWindow())
+    {
+        return 0;
+    }
 
     // Initialize the xaml content. This must be called AFTER the
     // WindowsXamlManager is initialized.

src/cascadia/WindowsTerminal/pch.h

@@ -61,6 +61,11 @@ Module Name:
 #include <winrt/Windows.UI.Xaml.Controls.h>
 #include <winrt/Windows.ui.xaml.media.h>
 
+#include <winrt/TerminalApp.h>
+#include <winrt/Microsoft.Terminal.Settings.Model.h>
+#include <winrt/Microsoft.Terminal.Remoting.h>
+#include <winrt/Microsoft.Terminal.TerminalControl.h>
+
 #include <wil/resource.h>
 #include <wil/win32_helpers.h>