starred/terminal
1
0
Fork 0
mirror of https://github.com/microsoft/terminal.git synced 2026-09-23 23:45:08 +00:00
Code Issues 19.0k Packages Projects Releases 20 Wiki Activity

Feature Request - Scripts Panel #2198

New Issue
Closed
opened 2026-01-30 22:49:18 +00:00 by claunia · 8 comments
claunia commented 2026-01-30 22:49:18 +00:00
Owner
Copy Link

Originally created by @nick22985 on GitHub (Jun 25, 2019).

Type the same commands multiple times or using external files from the terminal application to launch scripts. This feature would solve the problem of users alt tabbing allot of the time to run scripts where it could be in built in the terminal as an added option to make a side panel appear or something similar to that to show scripts and run them.

I want a panel to have toggle or an additional option so you can have a panel or something similar to be attached to the terminal so that you can run scripts from terminal and do not have to go into windows and search for scripts. This would kind of be like the the powershell ISE commands panel that you can toggle on but it would be for multiple terminals and you can set what you want to run their and the commands or scripts that you run all the time.

PowerShell ISE

Originally created by @nick22985 on GitHub (Jun 25, 2019). Type the same commands multiple times or using external files from the terminal application to launch scripts. This feature would solve the problem of users alt tabbing allot of the time to run scripts where it could be in built in the terminal as an added option to make a side panel appear or something similar to that to show scripts and run them. I want a panel to have toggle or an additional option so you can have a panel or something similar to be attached to the terminal so that you can run scripts from terminal and do not have to go into windows and search for scripts. This would kind of be like the the powershell ISE commands panel that you can toggle on but it would be for multiple terminals and you can set what you want to run their and the commands or scripts that you run all the time. ![PowerShell ISE](https://user-images.githubusercontent.com/43774713/60091968-25ae3b80-9789-11e9-8f18-3cae8e1f3486.PNG)
claunia commented 2026-01-30 22:49:20 +00:00
Author
Owner
Copy Link

@JushBJJ commented on GitHub (Jun 25, 2019):

panes are comimg into the terminal soon, well its already within the code, its just unfinished

@JushBJJ commented on GitHub (Jun 25, 2019): panes are comimg into the terminal soon, well its already within the code, its just unfinished
claunia commented 2026-01-30 22:49:20 +00:00
Author
Owner
Copy Link

@JushBJJ commented on GitHub (Jun 25, 2019):

#1000

@JushBJJ commented on GitHub (Jun 25, 2019): #1000
claunia commented 2026-01-30 22:49:20 +00:00
Author
Owner
Copy Link

@zadjii-msft commented on GitHub (Jul 2, 2019):

Actually, I'm gonna re-open this. This is a not terrible idea for an extension, similar to #644

@zadjii-msft commented on GitHub (Jul 2, 2019): Actually, I'm gonna re-open this. This is a not terrible idea for an extension, similar to #644
claunia commented 2026-01-30 22:49:20 +00:00
Author
Owner
Copy Link

@zadjii-msft commented on GitHub (Sep 18, 2021):

Adding some other comments from other duped threads:

@ThatWionGuy in #5273:

There are many commands that I either use frequently and some I use only once and a while but not frequently enough to memorize them. It would be nice if there was a way to store these and then access them from the terminal app to be executed when needed. A perfect example of this is the command to see all globally installed npm packages:

npm list -g --depth 0

I do this at least once a month which is just long enough to forget the exact line, so then I have to open Google and search for the command again, copy it and paste it into the terminal, which takes up time I should be using for other things.

The best way to keep a user engaged is to keep them from having to leave your app. By providing a way to quickly execute commands inside the terminal app, you allow users to be more productive and spend less time changing apps.

General Idea

What I am thinking would be an aside on the left or right of the window. Would be hidden by default but able to be shown through the main menu or keyboard shortcut. Could be called Favorites, Shortcuts or Quick List the naming is completely up to you, but for consistency and ease of explanation I will refer to it as "favorites" through the rest of this proposal.

It would display these favorite commands where the user could just click on one of them and the app would input the command into the active terminal. The panel would be scoped to the current active terminal i.e. a cmd terminal would show the favorites for cmd, and if the user switched to a powershell terminal then the favorites would switch to powershell favorites.

windows-terminal-favorites
Image is a wireframe not a polished UI

Proposed technical implementation details (optional)

Management of these favorites could be accomplished in the profiles section of the settings file, so no need to make a fancy GUI to manage the favorites. It could be structured something like this:

...
"profiles" : 
    [
        {
            ...,
            "favorites" : [
                 {
                     "name" : "List global npm packages",
                     "command" : "npm list -g --depth 0",
                     "auto-run" : false
                 }
            ],
        },
        ...
    ]
    ...
}

Property Type Usage
name string What shows up in the aside panel
command string What to inject into the terminal when clicked
auto-run (optional) boolean Whether to run the command or just input into the terminal. Default to false.
Since the user enters them in the profile settings there is no need to manage whether the command is actually a windows cmd, valid powershell or valid bash command... it is up to the user to put the favorites into the correct profile, correct order and to put valid commands. Terminal app would just display the list of favorites sorted by array order, based on the currently active profile and inject/execute the commands when they were clicked. Also since they are defined in the profiles the look and feel of the aside could match the profiles theme.

There would also need to be some kind of message to display if there are no current favorites for a profile. Something like "You currently have no favorites for this profile." and maybe a link to add a favorite which would open the settings file with a new favorite stubbed out.

The injection/execution could easily be accomplished in a variety of ways depending on the level of access to the underlying terminal that the app has (I will be honest, I have not looked into the code a lot) But even if you had to do it via sending the keystrokes to the underlying terminal and if auto-run is true sending a Enter Key at the end would be basically no different than the app typing the command for the user.

I am really not trying to completely design it out for you... just trying to give a general feature proposal so if you think of a better design and do it completely different I would not be offended, just wish that a feature like this existed.

Possible future enhancements

Initially just displaying the list, allowing injection/execution of the commands on click and management through the settings would allow this feature to be functional and useful to users. But if desired, future enhancements could be added that would only provide better usability such as:

  • Change sort order by drag and drop in aside.
  • Add new favorite via GUI (Dialog, or integrated UI)
  • Add new favorite from last executed command.
  • Group Commands into collapsible sections for better organization.
  • Support executing multiple commands on a single click.

Again these would be nice to haves later, but in no way necessary to provide a usable feature that provides value to the user.

_ @zadjii-msft in #5273 _:

I think this is an excellent extension idea. It's actually something I've been toying around with for a long time, but you've actually written up lots of the ideas I've had 😅.

I'm going to mark this up as an extension, and toss it onto the backlog.

I've personally been working on a tool that does a lot of similar things to what you're requesting, just straight from the commandline as opposed to as a part of the UI.

image

You can check it out over at zadjii/keep. Admittedly, I only update it when I feel the itch, and it only works for CMD, but it works for me ¯\_(ツ)_/¯

</shameless self-plug>

My own personal goal is to get the Terminal to a place where I can integrate a bunch of the features from that helper tool more directly into the UI. I've been thinking of doing it with a combination of:

One way or not, this is an excellent addition to my collection of extension ideas. Thanks!

_ @MrGolden1 in #11270 _:

I think this is very useful that there would be an option for saved commands/scripts in windows terminal.

for instance I need to ssh to a server several times a day or set a vpn at beginning of my work. or there is maybe many commands that we use hardly and we don't memorize them, such as resting database, special git command, changing an option in OS and many other things ....
It would be great if we could pick the command we want from an easy accessible place inside of windows terminal. Add, remove, titling, editing before run, pin, most recent and most used commands can be good options for it too.

Proposed technical implementation details (optional)

This picture is just for visualize my idea. (I found nothing better than windows clipboard :))
image

There is a panel such this that commands are listed in.

Thanks in advanced.

@zadjii-msft commented on GitHub (Sep 18, 2021): Adding some other comments from other duped threads: _@ThatWionGuy in #5273_: > There are many commands that I either use frequently and some I use only once and a while but not frequently enough to memorize them. It would be nice if there was a way to store these and then access them from the terminal app to be executed when needed. A perfect example of this is the command to see all globally installed npm packages: > > ```shell > npm list -g --depth 0 > ``` > > I do this at least once a month which is just long enough to forget the exact line, so then I have to open Google and search for the command again, copy it and paste it into the terminal, which takes up time I should be using for other things. > > The best way to keep a user engaged is to keep them from having to leave your app. By providing a way to quickly execute commands inside the terminal app, you allow users to be more productive and spend less time changing apps. > > ## General Idea > What I am thinking would be an aside on the left or right of the window. Would be hidden by default but able to be shown through the main menu or keyboard shortcut. Could be called Favorites, Shortcuts or Quick List the naming is completely up to you, but for consistency and ease of explanation I will refer to it as "favorites" through the rest of this proposal. > > It would display these favorite commands where the user could just click on one of them and the app would input the command into the active terminal. The panel would be scoped to the current active terminal i.e. a cmd terminal would show the favorites for cmd, and if the user switched to a powershell terminal then the favorites would switch to powershell favorites. > > ![windows-terminal-favorites](https://user-images.githubusercontent.com/3865442/78712096-b0f25b00-78dd-11ea-81f0-dae798174f32.png) > _Image is a wireframe not a polished UI_ > > # Proposed technical implementation details (optional) > Management of these favorites could be accomplished in the profiles section of the settings file, so no need to make a fancy GUI to manage the favorites. It could be structured something like this: > > ```json > ... > "profiles" : > [ > { > ..., > "favorites" : [ > { > "name" : "List global npm packages", > "command" : "npm list -g --depth 0", > "auto-run" : false > } > ], > }, > ... > ] > ... > } > ``` > > Property Type Usage > name string What shows up in the aside panel > command string What to inject into the terminal when clicked > auto-run (optional) boolean Whether to run the command or just input into the terminal. Default to false. > Since the user enters them in the profile settings there is no need to manage whether the command is actually a windows cmd, valid powershell or valid bash command... it is up to the user to put the favorites into the correct profile, correct order and to put valid commands. Terminal app would just display the list of favorites sorted by array order, based on the currently active profile and inject/execute the commands when they were clicked. Also since they are defined in the profiles the look and feel of the aside could match the profiles theme. > > There would also need to be some kind of message to display if there are no current favorites for a profile. Something like "You currently have no favorites for this profile." and maybe a link to add a favorite which would open the settings file with a new favorite stubbed out. > > The injection/execution could easily be accomplished in a variety of ways depending on the level of access to the underlying terminal that the app has (I will be honest, I have not looked into the code a lot) But even if you had to do it via sending the keystrokes to the underlying terminal and if `auto-run` is true sending a Enter Key at the end would be basically no different than the app typing the command for the user. > > I am really not trying to completely design it out for you... just trying to give a general feature proposal so if you think of a better design and do it completely different I would not be offended, just wish that a feature like this existed. > > # Possible future enhancements > Initially just displaying the list, allowing injection/execution of the commands on click and management through the settings would allow this feature to be functional and useful to users. But if desired, future enhancements could be added that would only provide better usability such as: > > * Change sort order by drag and drop in aside. > * Add new favorite via GUI (Dialog, or integrated UI) > * Add new favorite from last executed command. > * Group Commands into collapsible sections for better organization. > * Support executing multiple commands on a single click. > > Again these would be nice to haves later, but in no way necessary to provide a usable feature that provides value to the user. <hr> _ @zadjii-msft in #5273 _: > I think this is an _excellent_ extension idea. It's actually something I've been toying around with for a long time, but you've actually written up lots of the ideas I've had 😅. > > I'm going to mark this up as an extension, and toss it onto the backlog. > > <shameless self-plug> > I've personally been working on a tool that does a lot of similar things to what you're requesting, just straight from the commandline as opposed to as a part of the UI. ![image](https://user-images.githubusercontent.com/18356694/78796811-75f33480-797c-11ea-8811-aad5c7671206.png) > > You can check it out over at [zadjii/keep](https://github.com/zadjii/keep). Admittedly, I only update it when I feel the itch, and it only works for CMD, but it works for me ¯\\\_(ツ)_/¯ > > </shameless self-plug> > > My own personal goal is to get the Terminal to a place where I can integrate a bunch of the features from that helper tool more directly into the UI. I've been thinking of doing it with a combination of: > > * [Scenario: Add support for 3rd-party extensions #4000](https://github.com/microsoft/terminal/issues/4000) - to support extensions at all > * [Feature Request: Command Palette #2046](https://github.com/microsoft/terminal/issues/2046) - to provide a UI for running these commands easily > * #I-cant-remember-which - to use a `ShortcutAction` to send input to the attached commandline app > > One way or not, this is an excellent addition to my collection of extension ideas. Thanks! <hr> _ @MrGolden1 in #11270 _: > I think this is very useful that there would be an option for saved commands/scripts in windows terminal. > > for instance I need to ssh to a server several times a day or set a vpn at beginning of my work. or there is maybe many commands that we use hardly and we don't memorize them, such as resting database, special git command, changing an option in OS and many other things .... > It would be great if we could pick the command we want from an easy accessible place inside of windows terminal. Add, remove, titling, editing before run, pin, most recent and most used commands can be good options for it too. > > # Proposed technical implementation details (optional) > This picture is just for visualize my idea. (I found nothing better than windows clipboard :)) > ![image](https://user-images.githubusercontent.com/41590281/133887525-6bfb8bce-d8f4-4093-9e72-1aa8c09fa3d5.png) > > There is a panel such this that commands are listed in. > > Thanks in advanced.
claunia commented 2026-01-30 22:49:20 +00:00
Author
Owner
Copy Link

@mws-rmain commented on GitHub (Nov 2, 2021):

The 'scripts panel' that starts this thread is great for indexing/retaining/invoking a massive library of scripts. Later suggestions are closer to my needs: frequently accessing a (more limited, but commonly used) set of commands or executables (batch files/shell scripts/python/etc.).

I'd like to see one step further in terms of simplification (since UI elements is on the roadmap for extensions): a generic toolbar which contains 'buttons' that are linked to specific commands or executables. The profile structure suggested in #5273 could be extended to support the configuration of the toolbar (also add an 'icon' for quick & easy locating of specific buttons). I'm thinking the end result would be something akin to Chrome's 'Bookmarks' toolbar. Once defined, your favorite commands are one click away!

As a next-level of difficulty, other elements could be added to add variability to toolbar items, such as a listbox to select one of several 'user profiles' when logging into ssh, or a textbox to enter a variable to pass on the command line to the script invoked by the associated button, etc.

@mws-rmain commented on GitHub (Nov 2, 2021): The 'scripts panel' that starts this thread is great for indexing/retaining/invoking a massive library of scripts. Later suggestions are closer to my needs: frequently accessing a (more limited, but commonly used) set of commands or executables (batch files/shell scripts/python/etc.). I'd like to see one step further in terms of simplification (since UI elements is on the roadmap for extensions): a generic toolbar which contains 'buttons' that are linked to specific commands or executables. The profile structure suggested in #5273 could be extended to support the configuration of the toolbar (also add an 'icon' for quick & easy locating of specific buttons). I'm thinking the end result would be something akin to Chrome's 'Bookmarks' toolbar. Once defined, your favorite commands are one click away! As a next-level of difficulty, other elements could be added to add variability to toolbar items, such as a listbox to select one of several 'user profiles' when logging into ssh, or a textbox to enter a variable to pass on the command line to the script invoked by the associated button, etc.
claunia commented 2026-01-30 22:49:21 +00:00
Author
Owner
Copy Link

@zadjii-msft commented on GitHub (Nov 9, 2021):

I'm thinking the end result would be something akin to Chrome's 'Bookmarks' toolbar

I think we've actually got a good mental model on the team (if albeit not formally communicated) of how this is going to end up working. We've got our plan for action ID's, and customizing the dropdown with those action IDs (#1571). The "bookmarks bar" would just be the same kind of thing, with different UI. It's just another place that users can bind actions to a button. So opening specific profiles, running commands, all those could be bound to those buttons. (see also #2934, #4531)

Moving some relevant discussion from #6412:

I think there is important point that everyone is missing when telling us to rely on the shell completion functions. I want to be able to use snippets that are independent of the shell configuration. As an example, I often run awk '{ print $1 }' | while read... on server where I cannot create aliases or change any config, I would like to be able to type in 'a$1' for example and expand it to the predefined snippet. I'm often connecting to the systems where the completion is fully disabled and I run a lot of repetitive task that can't be scripted (terminal hijacking is always disabled). I'm really convinced this is a needed feature.

You could also theoretically create a command like:

{ "command": { "action": "sendInput", "input": "awk '{ print $1 }' | while read...\r" }, "keys":"ctrl+a", "name": "a$1" },

and then you could use the command palette to send that snippet really simply. So you'd just press Ctrl+Shift+P (to open the command palette),a,$,1,enter and it'd send that snippet to the terminal. Or leave out the \r to just input it on the prompt, but not submit. Kinda similar, and shell/backend agnostic.

@zadjii-msft commented on GitHub (Nov 9, 2021): > I'm thinking the end result would be something akin to Chrome's 'Bookmarks' toolbar I think we've actually got a good mental model on the team (if albeit not formally communicated) of how this is going to end up working. We've got our plan for action ID's, and customizing the dropdown with those action IDs (#1571). The "bookmarks bar" would just be the same kind of thing, with different UI. It's just another place that users can bind actions to a button. So opening specific profiles, running commands, all those could be bound to those buttons. (see also #2934, #4531) <hr> Moving some relevant discussion from #6412: > I think there is important point that everyone is missing when telling us to rely on the shell completion functions. I want to be able to use snippets that are independent of the shell configuration. As an example, I often run awk '{ print $1 }' | while read... on server where I cannot create aliases or change any config, I would like to be able to type in 'a$1' for example and expand it to the predefined snippet. I'm often connecting to the systems where the completion is fully disabled and I run a lot of repetitive task that can't be scripted (terminal hijacking is always disabled). I'm really convinced this is a needed feature. > You could also theoretically create a command like: > > ```js > { "command": { "action": "sendInput", "input": "awk '{ print $1 }' | while read...\r" }, "keys":"ctrl+a", "name": "a$1" }, > ``` > > and then you could use the command palette to send that snippet really simply. So you'd just press <kbd>Ctrl+Shift+P</kbd> (to open the command palette),<kbd>a</kbd>,<kbd>$</kbd>,<kbd>1</kbd>,<kbd>enter</kbd> and it'd send that snippet to the terminal. Or leave out the `\r` to just input it on the prompt, but not submit. Kinda similar, and shell/backend agnostic.
claunia commented 2026-01-30 22:49:21 +00:00
Author
Owner
Copy Link

@zadjii-msft commented on GitHub (Jun 14, 2022):

Note to self: I'm gonna start using this thread for the "input actions" mode of the command palette. I've had notes all over, but I'm copying bits here for tracking

see: #5400, #12857, and to a lesser extent #3121

Like, what if you just had a list of all your saved commands right there, to send to the terminal?

I reference #3121, since it would make sense to have these all relative to where the input currently is (right)?

  • Start with the previewable sendInput branch
  • Merge in the bits where the command palette could be positioned manually, from #6632 (dev/migrie/fhl/menu-complete-prototype)
  • Create a map of commands that only includes all the sendInputs
  • pump those into this flyout control
  • add savedCommands action to open that up

And then the many follow ups:

  • can we load that up with the MRU working directories of the terminal?
  • can we somehow pre-filter that with what's on the commandline, assuming that there's a FTCS mark indicating the start of the commandline? so, git c {savedCommands} would only show the things that start with "git c", and would only send ommit
  • #12857 saveInput action, accepts a name for the command, and a commandline for the input
    • Without a name, it opens a TeachingTip, like the window renamer
  • wt save [--name name] [commandline] to save a commandline as a sendInput action.
  • A crazy person would have sets of commands that could populate this menu:
    • the global ones in actions
    • the per-profile ones
    • the ones that are found by looking for a commands.json (or whatever) in the CWD of the shell (and upwards till /), for workspace-provided actions
  • more...
@zadjii-msft commented on GitHub (Jun 14, 2022): Note to self: I'm gonna start using this thread for the "input actions" mode of the command palette. I've had notes all over, but I'm copying bits here for tracking > see: #5400, #12857, and to a lesser extent #3121 > > Like, what if you just had a list of all your saved commands right there, to send to the terminal? > > I reference #3121, since it would make sense to have these all relative to where the input currently is (right)? * [x] Start with the previewable `sendInput` branch * [x] Merge in the bits where the command palette could be positioned manually, from #6632 ([`dev/migrie/fhl/menu-complete-prototype`](https://github.com/microsoft/terminal/compare/dev/migrie/fhl/menu-complete-prototype)) * [ ] Create a map of commands that only includes all the `sendInput`s * [x] pump those into this flyout control * [x] add `savedCommands` action to open that up And then the many follow ups: * [ ] can we load that up with the MRU working directories of the terminal? * [ ] can we somehow pre-filter that with what's on the commandline, assuming that there's a FTCS mark indicating the start of the commandline? so, `git c` {`savedCommands`} would only show the things that start with "git c", and would only send `ommit` * [ ] #12857 `saveInput` action, accepts a `name` for the command, and a `commandline` for the input * [ ] Without a `name`, it opens a TeachingTip, like the window renamer * [ ] `wt save [--name name] [commandline]` to save a commandline as a `sendInput` action. * [ ] A crazy person would have sets of commands that could populate this menu: - the global ones in `actions` - the per-profile ones - the ones that are found by looking for a `commands.json` (or whatever) in the CWD of the shell (and upwards till `/`), for workspace-provided actions * [ ] more...
claunia commented 2026-01-30 22:49:21 +00:00
Author
Owner
Copy Link

@swiffer commented on GitHub (Jun 25, 2023):

The Initial wireframes Look similar to what ist available in Warp (Warp Drive Workflows)

https://docs.warp.dev/features/warp-drive/workflows

Having These Concepts directly integrated into the terminal (ai as Well) feels really great!

@swiffer commented on GitHub (Jun 25, 2023): The Initial wireframes Look similar to what ist available in Warp (Warp Drive Workflows) https://docs.warp.dev/features/warp-drive/workflows Having These Concepts directly integrated into the terminal (ai as Well) feels really great!
Sign in to join this conversation.
No Branch/Tag Specified
Branches Tags
Labels
Clear labels
⛺ Reserved
A11yCO
A11yMAS
A11ySev1
A11ySev2
A11ySev3
A11yTTValidated
A11yUsable
A11yVoiceAccess
A11yWCAG
Area-Accessibility
Area-AtlasEngine
Area-AzureShell
Area-Build
Area-Build
Area-Chat
Area-CmdPal
Area-CodeHealth
Area-Commandline
Area-CookedRead
Area-DefApp
Area-Extensibility
Area-Fonts
Area-GroupPolicy
Area-i18n
Area-Input
Area-Interaction
Area-Interop
Area-Localization
Area-Output
Area-Performance
Area-Portable
Area-Quality
Area-Remoting
Area-Rendering
Area-Schema
Area-Server
Area-Settings
Area-SettingsUI
Area-ShellExtension
Area-ShellExtension
Area-ShellExtension
Area-Suggestions
Area-Suggestions
Area-TerminalConnection
Area-TerminalControl
Area-Theming
Area-UserInterface
Area-VT
Area-Windowing
Area-WPFControl
AutoMerge
Blocking-Ingestion
Culprit-Centennial
Culprit-WinUI
Disability-All
Disability-Blind
Disability-LowVision
Disability-Mobility
External-Blocked-WinUI3
Fixed
Gathering-Data
good first issue
HCL-E+D
HCL-WindowsTerminal
Help Wanted
Impact-Compatibility
Impact-Compliance
Impact-Correctness
Impact-Visual
In-PR
InclusionBacklog
InclusionBacklog-Windows TerminalWin32
InclusionCommitted-202206
Issue-Bug
Issue-Docs
Issue-Feature
Issue-Feature
Issue-Question
Issue-Samples
Issue-Scenario
Issue-Task
Needs-Attention
Needs-Author-Feedback
Needs-Bisect
Needs-Discussion
Needs-Repro
Needs-Tag-Fix
Needs-Tag-Fix
Needs-Triage
No-Recent-Activity
Priority-0
Priority-1
Priority-2
Priority-3
Product-Cmd.exe
Product-Colortool
Product-Colortool
Product-Colortool
Product-Conhost
Product-Conpty
Product-Meta
Product-Powershell
Product-Terminal
Product-WSL
pull-request
Mirrored from GitHub Pull Request
 Resolution-Answered
Resolution-By-Design
Resolution-Duplicate
Resolution-External
Resolution-Fix-Available
Resolution-Fix-Committed
Resolution-No-Repro
Resolution-Won't-Fix
Severity-Blocking
Severity-Crash
Severity-DataLoss
spam
this-will-be-a-breaking-change
Tracking-External
WindowsTerminal_Win32
Work-Item
zAskModeBug
zInbox-Bug
No Label A11yMAS Area-UserInterface Disability-All In-PR InclusionBacklog InclusionBacklog-Windows TerminalWin32 Issue-Feature Needs-Tag-Fix Product-Terminal WindowsTerminal_Win32
Milestone
No items
No Milestone
Projects
Clear projects
No project
Assignees
Clear assignees
claunia
No Assignees
1 Participants
Notifications
Due Date
No due date set.
Dependencies

No dependencies set.

Reference: starred/terminal#2198
Delete Branch "%!s()"

Deleting a branch is permanent. Although the deleted branch may continue to exist for a short time before it actually gets removed, it CANNOT be undone in most cases. Continue?