Add support for running a wt commandline in the curent window WITH A KEYBINDING

doc/cascadia/profiles.schema.json

@@ -63,6 +63,7 @@
         "openTabColorPicker",
         "renameTab",
         "commandPalette",
+        "wt",
         "unbound"
       ],
       "type": "string"
@@ -280,6 +281,23 @@
         }
       ]
     },
+    "WtAction": {
+      "description": "Arguments corresponding to a wt Action",
+      "allOf": [
+        { "$ref": "#/definitions/ShortcutAction" },
+        {
+          "properties": {
+            "action": { "type": "string", "pattern": "wt" },
+            "commandline": {
+              "type": "string",
+              "default": "",
+              "description": "a `wt` commandline to run in the current window"
+            }
+          }
+        }
+      ],
+      "required": [ "commandline" ]
+    },
     "Keybinding": {
       "additionalProperties": false,
       "properties": {
@@ -296,6 +314,7 @@
               { "$ref": "#/definitions/SplitPaneAction" },
               { "$ref": "#/definitions/OpenSettingsAction" },
               { "$ref": "#/definitions/SetTabColorAction" },
+              { "$ref": "#/definitions/WtAction" },
               { "type": "null" }
             ]
         },

src/cascadia/LocalTests_TerminalApp/CommandlineTest.cpp

@@ -4,7 +4,9 @@
 #include "pch.h"
 #include <WexTestClass.h>
 
+#include "../TerminalApp/TerminalPage.h"
 #include "../TerminalApp/AppCommandlineArgs.h"
+#include "../TerminalApp/ActionArgs.h"
 
 using namespace WEX::Logging;
 using namespace WEX::Common;
@@ -52,6 +54,10 @@ namespace TerminalAppLocalTests
 
         TEST_METHOD(CheckTypos);
 
+        TEST_METHOD(TestSimpleExecuteCommandlineAction);
+        TEST_METHOD(TestMultipleCommandExecuteCommandlineAction);
+        TEST_METHOD(TestInvalidExecuteCommandlineAction);
+
     private:
         void _buildCommandlinesHelper(AppCommandlineArgs& appArgs,
                                       const size_t expectedSubcommands,
@@ -1067,4 +1073,66 @@ namespace TerminalAppLocalTests
             VERIFY_ARE_EQUAL(L"C:\\", myArgs.TerminalArgs().StartingDirectory());
         }
     }
+
+    void CommandlineTest::TestSimpleExecuteCommandlineAction()
+    {
+        auto args = winrt::make_self<implementation::ExecuteCommandlineArgs>();
+        args->Commandline(L"new-tab");
+        auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args);
+        VERIFY_ARE_EQUAL(1u, actions.size());
+        auto actionAndArgs = actions.at(0);
+        VERIFY_ARE_EQUAL(ShortcutAction::NewTab, actionAndArgs.Action());
+        VERIFY_IS_NOT_NULL(actionAndArgs.Args());
+        auto myArgs = actionAndArgs.Args().try_as<NewTabArgs>();
+        VERIFY_IS_NOT_NULL(myArgs);
+        VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty());
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty());
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr);
+        VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty());
+    }
+
+    void CommandlineTest::TestMultipleCommandExecuteCommandlineAction()
+    {
+        auto args = winrt::make_self<implementation::ExecuteCommandlineArgs>();
+        args->Commandline(L"new-tab ; split-pane");
+        auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args);
+        VERIFY_ARE_EQUAL(2u, actions.size());
+        {
+            auto actionAndArgs = actions.at(0);
+            VERIFY_ARE_EQUAL(ShortcutAction::NewTab, actionAndArgs.Action());
+            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
+            auto myArgs = actionAndArgs.Args().try_as<NewTabArgs>();
+            VERIFY_IS_NOT_NULL(myArgs);
+            VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr);
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty());
+        }
+        {
+            auto actionAndArgs = actions.at(1);
+            VERIFY_ARE_EQUAL(ShortcutAction::SplitPane, actionAndArgs.Action());
+            VERIFY_IS_NOT_NULL(actionAndArgs.Args());
+            auto myArgs = actionAndArgs.Args().try_as<SplitPaneArgs>();
+            VERIFY_IS_NOT_NULL(myArgs);
+            VERIFY_IS_NOT_NULL(myArgs.TerminalArgs());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().Commandline().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().StartingDirectory().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().TabTitle().empty());
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().ProfileIndex() == nullptr);
+            VERIFY_IS_TRUE(myArgs.TerminalArgs().Profile().empty());
+        }
+    }
+
+    void CommandlineTest::TestInvalidExecuteCommandlineAction()
+    {
+        auto args = winrt::make_self<implementation::ExecuteCommandlineArgs>();
+        // -H and -V cannot be combined.
+        args->Commandline(L"split-pane -H -V");
+        auto actions = implementation::TerminalPage::ConvertExecuteCommandlineToActions(*args);
+        VERIFY_ARE_EQUAL(0u, actions.size());
+    }
 }

src/cascadia/LocalTests_TerminalApp/SettingsTests.cpp

@@ -76,6 +76,8 @@ namespace TerminalAppLocalTests
 
         TEST_METHOD(ValidateKeybindingsWarnings);
 
+        TEST_METHOD(ValidateExecuteCommandlineWarning);
+
         TEST_METHOD(ValidateLegacyGlobalsWarning);
 
         TEST_METHOD(TestTrailingCommas);
@@ -2254,6 +2256,57 @@ namespace TerminalAppLocalTests
         VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.at(3));
     }
 
+    void SettingsTests::ValidateExecuteCommandlineWarning()
+    {
+        Log::Comment(L"This test is affected by GH#6949, so we're just skipping it for now.");
+        Log::Result(WEX::Logging::TestResults::Skipped);
+        return;
+
+        // const std::string badSettings{ R"(
+        // {
+        //     "defaultProfile": "{6239a42c-2222-49a3-80bd-e8fdd045185c}",
+        //     "profiles": [
+        //         {
+        //             "name" : "profile0",
+        //             "guid": "{6239a42c-2222-49a3-80bd-e8fdd045185c}"
+        //         },
+        //         {
+        //             "name" : "profile1",
+        //             "guid": "{6239a42c-3333-49a3-80bd-e8fdd045185c}"
+        //         }
+        //     ],
+        //     "keybindings": [
+        //         { "name":null, "command": { "action": "wt" }, "keys": [ "ctrl+a" ] },
+        //         { "name":null, "command": { "action": "wt", "commandline":"" }, "keys": [ "ctrl+b" ] },
+        //         { "name":null, "command": { "action": "wt", "commandline":null }, "keys": [ "ctrl+c" ] }
+        //     ]
+        // })" };
+
+        // const auto settingsObject = VerifyParseSucceeded(badSettings);
+
+        // auto settings = CascadiaSettings::FromJson(settingsObject);
+
+        // VERIFY_ARE_EQUAL(0u, settings->_globals._keybindings->_keyShortcuts.size());
+
+        // for (const auto& warning : settings->_globals._keybindingsWarnings)
+        // {
+        //     Log::Comment(NoThrowString().Format(
+        //         L"warning:%d", warning));
+        // }
+        // VERIFY_ARE_EQUAL(3u, settings->_globals._keybindingsWarnings.size());
+        // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_globals._keybindingsWarnings.at(0));
+        // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_globals._keybindingsWarnings.at(1));
+        // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_globals._keybindingsWarnings.at(2));
+
+        // settings->_ValidateKeybindings();
+
+        // VERIFY_ARE_EQUAL(4u, settings->_warnings.size());
+        // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::AtLeastOneKeybindingWarning, settings->_warnings.at(0));
+        // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.at(1));
+        // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.at(2));
+        // VERIFY_ARE_EQUAL(::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter, settings->_warnings.at(3));
+    }
+
     void SettingsTests::ValidateLegacyGlobalsWarning()
     {
         const std::string badSettings{ R"(

src/cascadia/TerminalApp/ActionAndArgs.cpp

@@ -38,6 +38,7 @@ static constexpr std::string_view ToggleAlwaysOnTopKey{ "toggleAlwaysOnTop" };
 static constexpr std::string_view SetTabColorKey{ "setTabColor" };
 static constexpr std::string_view OpenTabColorPickerKey{ "openTabColorPicker" };
 static constexpr std::string_view RenameTabKey{ "renameTab" };
+static constexpr std::string_view ExecuteCommandlineKey{ "wt" };
 static constexpr std::string_view ToggleCommandPaletteKey{ "commandPalette" };
 
 static constexpr std::string_view ActionKey{ "action" };
@@ -89,6 +90,7 @@ namespace winrt::TerminalApp::implementation
         { UnboundKey, ShortcutAction::Invalid },
         { FindKey, ShortcutAction::Find },
         { RenameTabKey, ShortcutAction::RenameTab },
+        { ExecuteCommandlineKey, ShortcutAction::ExecuteCommandline },
         { ToggleCommandPaletteKey, ShortcutAction::ToggleCommandPalette },
     };
 
@@ -121,6 +123,8 @@ namespace winrt::TerminalApp::implementation
 
         { ShortcutAction::RenameTab, winrt::TerminalApp::implementation::RenameTabArgs::FromJson },
 
+        { ShortcutAction::ExecuteCommandline, winrt::TerminalApp::implementation::ExecuteCommandlineArgs::FromJson },
+
         { ShortcutAction::Invalid, nullptr },
     };
 
@@ -268,6 +272,7 @@ namespace winrt::TerminalApp::implementation
                 { ShortcutAction::SetTabColor, RS_(L"ResetTabColorCommandKey") },
                 { ShortcutAction::OpenTabColorPicker, RS_(L"OpenTabColorPickerCommandKey") },
                 { ShortcutAction::RenameTab, RS_(L"ResetTabNameCommandKey") },
+                { ShortcutAction::ExecuteCommandline, RS_(L"ExecuteCommandlineCommandKey") },
                 { ShortcutAction::ToggleCommandPalette, RS_(L"ToggleCommandPaletteCommandKey") },
             };
         }();

src/cascadia/TerminalApp/ActionArgs.cpp

@@ -17,6 +17,7 @@
 #include "OpenSettingsArgs.g.cpp"
 #include "SetTabColorArgs.g.cpp"
 #include "RenameTabArgs.g.cpp"
+#include "ExecuteCommandlineArgs.g.cpp"
 
 #include <LibraryResources.h>
 
@@ -258,4 +259,17 @@ namespace winrt::TerminalApp::implementation
         return RS_(L"ResetTabNameCommandKey");
     }
 
+    winrt::hstring ExecuteCommandlineArgs::GenerateName() const
+    {
+        // "Run commandline "{_Commandline}" in this window"
+        if (!_Commandline.empty())
+        {
+            return winrt::hstring{
+                fmt::format(std::wstring_view(RS_(L"ExecuteCommandlineCommandKey")),
+                            _Commandline.c_str())
+            };
+        }
+        return L"";
+    }
+
 }

src/cascadia/TerminalApp/ActionArgs.h

@@ -17,6 +17,7 @@
 #include "OpenSettingsArgs.g.h"
 #include "SetTabColorArgs.g.h"
 #include "RenameTabArgs.g.h"
+#include "ExecuteCommandlineArgs.g.h"
 
 #include "../../cascadia/inc/cppwinrt_utils.h"
 #include "Utils.h"
@@ -387,6 +388,39 @@ namespace winrt::TerminalApp::implementation
             return { *args, {} };
         }
     };
+
+    struct ExecuteCommandlineArgs : public ExecuteCommandlineArgsT<ExecuteCommandlineArgs>
+    {
+        ExecuteCommandlineArgs() = default;
+        GETSET_PROPERTY(winrt::hstring, Commandline, L"");
+
+        static constexpr std::string_view CommandlineKey{ "commandline" };
+
+    public:
+        hstring GenerateName() const;
+
+        bool Equals(const IActionArgs& other)
+        {
+            auto otherAsUs = other.try_as<ExecuteCommandlineArgs>();
+            if (otherAsUs)
+            {
+                return otherAsUs->_Commandline == _Commandline;
+            }
+            return false;
+        };
+        static FromJsonResult FromJson(const Json::Value& json)
+        {
+            // LOAD BEARING: Not using make_self here _will_ break you in the future!
+            auto args = winrt::make_self<ExecuteCommandlineArgs>();
+            JsonUtils::GetValueForKey(json, CommandlineKey, args->_Commandline);
+            if (args->_Commandline.empty())
+            {
+                return { nullptr, { ::TerminalApp::SettingsLoadWarnings::MissingRequiredParameter } };
+            }
+            return { *args, {} };
+        }
+    };
+
 }
 
 namespace winrt::TerminalApp::factory_implementation

src/cascadia/TerminalApp/ActionArgs.idl

@@ -115,4 +115,9 @@ namespace TerminalApp
     {
         String Title { get; };
     };
+
+    [default_interface] runtimeclass ExecuteCommandlineArgs : IActionArgs
+    {
+        String Commandline;
+    };
 }

src/cascadia/TerminalApp/AppActionHandlers.cpp

@@ -11,6 +11,7 @@ using namespace winrt::Windows::ApplicationModel::DataTransfer;
 using namespace winrt::Windows::UI::Xaml;
 using namespace winrt::Windows::UI::Text;
 using namespace winrt::Windows::UI::Core;
+using namespace winrt::Windows::Foundation::Collections;
 using namespace winrt::Windows::System;
 using namespace winrt::Microsoft::Terminal;
 using namespace winrt::Microsoft::Terminal::Settings;
@@ -334,4 +335,20 @@ namespace winrt::TerminalApp::implementation
         }
         args.Handled(true);
     }
+
+    void TerminalPage::_HandleExecuteCommandline(const IInspectable& /*sender*/,
+                                                 const TerminalApp::ActionEventArgs& actionArgs)
+    {
+        if (const auto& realArgs = actionArgs.ActionArgs().try_as<TerminalApp::ExecuteCommandlineArgs>())
+        {
+            auto actions = winrt::single_threaded_vector<winrt::TerminalApp::ActionAndArgs>(std::move(
+                TerminalPage::ConvertExecuteCommandlineToActions(realArgs)));
+
+            if (_startupActions.Size() != 0)
+            {
+                actionArgs.Handled(true);
+                _ProcessStartupActions(actions, false);
+            }
+        }
+    }
 }