WIP

# Conflicts:
#	src/cascadia/TerminalApp/AppLogic.cpp
#	src/cascadia/TerminalApp/AppLogic.h
#	src/cascadia/TerminalApp/AppLogic.idl
#	src/cascadia/TerminalApp/TerminalPage.h
#	src/cascadia/TerminalApp/TerminalWindow.cpp
#	src/cascadia/TerminalApp/TerminalWindow.h
#	src/cascadia/TerminalSettingsModel/GlobalAppSettings.cpp
#	src/cascadia/TerminalSettingsModel/GlobalAppSettings.h
#	src/cascadia/TerminalSettingsModel/GlobalAppSettings.idl
#	src/cascadia/WindowsTerminal/AppHost.cpp
#	src/cascadia/WindowsTerminal/AppHost.h

src/cascadia/Remoting/Monarch.cpp

@@ -666,6 +666,15 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
             // window.
             return winrt::make<Remoting::implementation::ProposeCommandlineResult>(false);
         }
+
+        for (const auto& arg : args.Commandline())
+        {
+            if (args == L"--headless")
+            {
+                _HeadlessMode = true;
+            }
+        }
+
         // If there's a valid ID returned, then let's try and find the peasant
         // that goes with it. Alternatively, if we were given a magic windowing
         // constant, we can use that to look up an appropriate peasant.

src/cascadia/Remoting/Monarch.h

@@ -81,6 +81,8 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         Windows::Foundation::Collections::IVectorView<winrt::Microsoft::Terminal::Remoting::PeasantInfo> GetPeasantInfos();
         Windows::Foundation::Collections::IVector<winrt::hstring> GetAllWindowLayouts();
 
+        WINRT_PROPERTY(bool, HeadlessMode, false);
+
         TYPED_EVENT(FindTargetWindowRequested, winrt::Windows::Foundation::IInspectable, winrt::Microsoft::Terminal::Remoting::FindTargetWindowArgs);
         TYPED_EVENT(ShowNotificationIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);
         TYPED_EVENT(HideNotificationIconRequested, winrt::Windows::Foundation::IInspectable, winrt::Windows::Foundation::IInspectable);

src/cascadia/Remoting/Monarch.idl

@@ -70,6 +70,8 @@ namespace Microsoft.Terminal.Remoting
         Windows.Foundation.Collections.IVectorView<PeasantInfo> GetPeasantInfos { get; };
         Windows.Foundation.Collections.IVector<String> GetAllWindowLayouts();
 
+        Boolean HeadlessMode { get; };
+
         event Windows.Foundation.TypedEventHandler<Object, FindTargetWindowArgs> FindTargetWindowRequested;
         event Windows.Foundation.TypedEventHandler<Object, Object> ShowNotificationIconRequested;
         event Windows.Foundation.TypedEventHandler<Object, Object> HideNotificationIconRequested;

src/cascadia/Remoting/ProposeCommandlineResult.h

@@ -33,6 +33,7 @@ namespace winrt::Microsoft::Terminal::Remoting::implementation
         WINRT_PROPERTY(Windows::Foundation::IReference<uint64_t>, Id);
         WINRT_PROPERTY(winrt::hstring, WindowName);
         WINRT_PROPERTY(bool, ShouldCreateWindow, true);
+        WINRT_PROPERTY(bool, HeadlessMode, false);
 
     public:
         ProposeCommandlineResult(bool shouldCreateWindow) :

src/cascadia/TerminalApp/AppCommandlineArgs.cpp

@@ -193,14 +193,20 @@ void AppCommandlineArgs::_buildParser()
     };
     _app.add_option_function<std::string>("--size", sizeCallback, RS_A(L"CmdSizeDesc"));
 
-    _app.add_option("-w,--window",
-                    _windowTarget,
-                    RS_A(L"CmdWindowTargetArgDesc"));
+    auto windowTarget = _app.add_option("-w,--window",
+                                        _windowTarget,
+                                        RS_A(L"CmdWindowTargetArgDesc"));
 
     _app.add_option("-s,--saved",
                     _loadPersistedLayoutIdx,
                     RS_A(L"CmdSavedLayoutArgDesc"));
 
+    auto headless = _app.add_option("--headless",
+                                    _headless,
+                                    RS_A(L"CmdHeadlessArgDesc"));
+
+    _windowTarget->excludes(headless);
+
     // Subcommands
     _buildNewTabParser();
     _buildSplitPaneParser();
@@ -918,7 +924,7 @@ void AppCommandlineArgs::ValidateStartupCommands()
     // Only check over the actions list for the potential to add a new-tab
     // command if we are not starting for the purposes of receiving an inbound
     // handoff connection from the operating system.
-    if (!_isHandoffListener)
+    if (!_isHandoffListener && !_headless)
     {
         // If we parsed no commands, or the first command we've parsed is not a new
         // tab action, prepend a new-tab command to the front of the list.
@@ -1085,6 +1091,7 @@ void AppCommandlineArgs::FullResetState()
     _exitMessage = "";
     _shouldExitEarly = false;
     _isHandoffListener = false;
+    _isHandoffListener = false;
 
     _windowTarget = {};
 }

src/cascadia/TerminalApp/AppCommandlineArgs.h

@@ -124,12 +124,15 @@ private:
     std::optional<winrt::Microsoft::Terminal::Settings::Model::LaunchPosition> _position{ std::nullopt };
     std::optional<til::size> _size{ std::nullopt };
     bool _isHandoffListener{ false };
+
     std::vector<winrt::Microsoft::Terminal::Settings::Model::ActionAndArgs> _startupActions;
+
     std::string _exitMessage;
     bool _shouldExitEarly{ false };
 
     int _loadPersistedLayoutIdx{};
     std::string _windowTarget{};
+    bool _headless{ false };
     // Are you adding more args or attributes here? If they are not reset in _resetStateToDefault, make sure to reset them in FullResetState
 
     winrt::Microsoft::Terminal::Settings::Model::NewTerminalArgs _getNewTerminalArgs(NewTerminalSubcommand& subcommand);

src/cascadia/TerminalApp/AppLogic.cpp

@@ -703,6 +703,16 @@ namespace winrt::TerminalApp::implementation
                globals.MinimizeToNotificationArea();
     }
 
+    bool AppLogic::AllowHeadless()
+    {
+        if (!_loadedInitialSettings)
+        {
+            // Load settings if we haven't already
+            ReloadSettings();
+        }
+        return _settings.GlobalSettings().AllowHeadless();
+    }
+
     TerminalApp::TerminalWindow AppLogic::CreateNewWindow()
     {
         if (_settings == nullptr)

src/cascadia/TerminalApp/AppLogic.h

@@ -67,6 +67,7 @@ namespace winrt::TerminalApp::implementation
 
         Microsoft::Terminal::Settings::Model::Theme Theme();
         bool IsolatedMode();
+        bool AllowHeadless();
         bool RequestsTrayIcon();
 
         TerminalApp::TerminalWindow CreateNewWindow();

src/cascadia/TerminalApp/AppLogic.idl

@@ -46,6 +46,7 @@ namespace TerminalApp
         // Selected settings to expose
         Microsoft.Terminal.Settings.Model.Theme Theme { get; };
         Boolean IsolatedMode { get; };
+        Boolean AllowHeadless { get; };
         Boolean RequestsTrayIcon { get; };
 
         FindTargetWindowResult FindTargetWindow(String[] args);

src/cascadia/TerminalApp/Resources/en-US/Resources.resw

@@ -400,6 +400,9 @@
   <data name="CmdSavedLayoutArgDesc" xml:space="preserve">
     <value>This parameter is an internal implementation detail and should not be used.</value>
   </data>
+  <data name="CmdHeadlessArgDesc" xml:space="preserve">
+    <value>Forces this launch of the Terminal into headless mode. If there are no other actions specified on the command line, then this will start the Terminal without a visible window. If the Terminal is already running, force the currently running terminal into headless mode. In headless mode, closing all terminal windows does not close this terminal instance, unless you perform the "Quit the Terminal" action.</value>
+  </data>
   <data name="CmdWindowTargetArgDesc" xml:space="preserve">
     <value>Specify a terminal window to run the given commandline in. "0" always refers to the current window. </value>
   </data>

src/cascadia/TerminalSettingsModel/GlobalAppSettings.idl

@@ -99,6 +99,7 @@ namespace Microsoft.Terminal.Settings.Model
         INHERITABLE_SETTING(IVector<NewTabMenuEntry>, NewTabMenu);
         INHERITABLE_SETTING(Boolean, EnableColorSelection);
         INHERITABLE_SETTING(Boolean, IsolatedMode);
+        INHERITABLE_SETTING(Boolean, AllowHeadless);
 
         Windows.Foundation.Collections.IMapView<String, ColorScheme> ColorSchemes();
         void AddColorScheme(ColorScheme scheme);

src/cascadia/TerminalSettingsModel/MTSMSettings.h

@@ -64,6 +64,7 @@ Author(s):
     X(bool, TrimPaste, "trimPaste", true)                                                                                                                                                             \
     X(bool, EnableColorSelection, "experimental.enableColorSelection", false)                                                                                                                         \
     X(winrt::Windows::Foundation::Collections::IVector<Model::NewTabMenuEntry>, NewTabMenu, "newTabMenu", winrt::single_threaded_vector<Model::NewTabMenuEntry>({ Model::RemainingProfilesEntry{} })) \
+    X(bool, AllowHeadless, "compatibility.allowHeadless", false)                                                                                                                                      \
     X(bool, IsolatedMode, "compatibility.isolatedMode", false)
 
 #define MTSM_PROFILE_SETTINGS(X)                                                                                                                               \

src/cascadia/WindowsTerminal/WindowEmperor.cpp

@@ -181,7 +181,19 @@ void WindowEmperor::_windowExitedHandler(uint64_t senderID)
                       return w->Peasant().GetID() == senderID;
                   });
 
-    if (lockedWindows->size() == 0)
+    // When we run out of windows, exit our process if and only if:
+    // * We're not allowed to run headless OR
+    // * we've explicitly been told to "quit", which should fully exit the Terminal.
+    const bool noMoreWindows{ lockedWindows->size() == 0 };
+
+    // We're not allowed to run headless:
+    //
+    const bool quitWhenLastWindowExits{
+        (!_app.Logic().AllowHeadless() && !_manager.HeadlessMode()) ||
+        _app.Logic().IsolatedMode()
+    };
+    if (noMoreWindows &&
+        (_quitting || quitWhenLastWindowExits))
     {
         _close();
     }
@@ -276,6 +288,8 @@ void WindowEmperor::_numberOfWindowsChanged(const winrt::Windows::Foundation::II
 void WindowEmperor::_quitAllRequested(const winrt::Windows::Foundation::IInspectable&,
                                       const winrt::Microsoft::Terminal::Remoting::QuitAllRequestedArgs& args)
 {
+    _quitting = true;
+
     // Make sure that the current timer is destroyed so that it doesn't attempt
     // to run while we are in the middle of quitting.
     if (_getWindowLayoutThrottler.has_value())

src/cascadia/WindowsTerminal/WindowEmperor.h

@@ -51,6 +51,8 @@ private:
 
     std::unique_ptr<NotificationIcon> _notificationIcon;
 
+    bool _quitting{ false };
+
     void _windowStartedHandler(const std::shared_ptr<WindowThread>& sender);
     void _windowExitedHandler(uint64_t senderID);