For example, synaptic is a long running front end for apt that has the buttons for update and upgrade.

Rather than creating a custom terminal app, could you create a user that only had permission to run the restricted commands, with a profile script that gets run at login and offers a menu of common tasks?

Interesting idea. If you really break it down, the “terminal with command buttons” is similar in concept to saving each of the commands as a script and putting those scripts in a directory to act as “buttons.”

I’ve also seen some programs such as Kopia, a backup tool, that provide a GUI with the equivalent terminal commands for what is bring done shown at the bottom.

I don’t think what you’re describing exists, probably because experts don’t need it and beginners would prefer a full GUI.

There is Nushell, which promises more helpful error responses for the terminal, but its too early for it to be targeted at beginners in my opinion.

I know that GUI does not cover most of functionalities

specialized to task

Yet, I find that there are common commands

present them as buttons

Congratulations you just reinvented the GUI while trying to get away from it at the same time.

Perhaps something a little more “in-between” the two might be a GUI that allows running arbitrary programs… something smarter than a launcher but more generic than a purpose-built function-limited interface… if such a thing can even exist.

I understand the desire to want to avoid the command line, but you’re severely restricting your ability to troubleshoot by doing so. Every operating system has a terminal and command line, and there’s going to be cases where you’ll want to drop into a shell to do something that has no GUI equivalent.

something like raspi-config ( i know that’s console based GUI, but it’s gui to me), or even the endevourOS launcher screen?

I bet that doesn’t exist: nobody would put work in a program that lets just restricts what you can do with zero usability advantages (ok someone might)

If you fear you might run unsafe commands just save whatever you are comfortable running in scripts and restrict yourself to run those instead of manually typing commands you don’t fully remember/understand.

BTW: topgrade will detect what needs updating in your system (your distro’s package manager, flatpak, python stuff, … whatever) and update all the things

BTW: “terminal emulator” is the program that shows you text in a window, the program that runs inside it and validates/interprets your commands is a “shell” (the one you are using is most probably bash)

Are you perhaps looking for something like this? Or something else.

That said, learning the terminal commands is a much better path. You'll develop a richer understanding of the various tools with repetition.

This reminds me of something from my ancient past. Back in the early-ish days of Apple, there was a development system called MPW (Macintosh Programmer’s Workshop) which included its own little kludgy shell.

The weird thing about it though was while you could enter commands on the command line like in any shell, you could prefix them with the word commando (presumably a portmanteau of “command” and “window”) and this window would pop up showing various buttons, checkboxes, etc. correponding to command line options. When you ok’d the window, it would generate the command line for you.

I’m rather hazy about how all this worked, but I think there was some sort of template language to define the window layout if you wanted to add commando support for your own tool? And presumeably, as you say, you could restrict what’s possible with the window interface as you deemed fit?

Just create GUI application for the things you want. There’s already lots of them.

Otherwise there’s always “–help”.

The thing is that there is no middle ground, the terminal you described would either have the problems of a GUI (limited interactivity) or the problems of a CLI (unintuitive).

If you do a button to do things you’ve removed option to do different things, if you ask them for text you’ve removed the intuitivity of a button. If you present less options you might not cover all cases, if you present more options it’s a regular terminal.

It seems that the issue you have is that you need a way to quickly redo commands you’ve done before and you need a good way to know what options you have. I have 2 CLI solutions for you.

1. If you press Ctrl+R and start typing a command it will auto-complete to the latest command you ran that matches

2. If you install zsh and grml-zsh-config and switch to zsh you will have a very powerful auto-complete that will allow you to press tab to auto-complete most parameters of most common operations.

I think it would be very awkward, because then you need to look for the right button, move your mouse to it, click it, and then start looking for the next button, click it and so on.

For simple scenarios where you just need to click install, the gui can be great, but I think it’s not good enough for most commands with flags and options.

Long ago I made such restricted shell with filtering the shell command history file then disabling command history logging. With some shell scripting, I think you can get more sophisticated version. What shell are you using? (Bash, Fish, Zsh, etc.)

$ cp ~/.bashrc ~/.bashrc.bak
$ cp ~/.bash_history ~/.bash_history.bak
$ printf 'set +o history' >> ~/.bashrc
$ printf "sudo apt update\nsudo apt upgrade\n" > .bash_history
$ (Press Ctrl+D to logout)

Sounds like YaST

I think you could get really happy with fish or at least bash history autocompletion.

A flexible command runner, easy to add new buttons, spawning a terminal window to show the results, would also be useful.

I agree on the issue

You could create a list of commands in a text file, and then pipe that into fzf. With a light wrapper that would allow you to type a portion of the command to select and execute it.

What about something like navi - github.com/denisidoro/navi. Basically an interactive cheat sheet that has commands pre-loaded (or that you can make yourself).

Coming back to this with thoughts. What you're describing sounds a lot like a menu tree.

"Press 1 to do this, 2 to do that, 3 to go to submenu A, 4 for B," etc. 1

"You have pressed 1. Do you want to turn on option ABC? [Y / n]" Y

"Do you want option QWERTY47? [Y/n]" N

"Are you sure you want to run notthebees --abc --no-qwerty47? [Y/n]" N

"Aborted."

It sounds like a standards problem waiting to happen because no two menus will be alike, but hey, things like this can and do exist, and setting one up isn't that hard, only time consuming.

This actually exists, but for a different operating system. The AS400 (aka iSeries) had a command line where programs had a standard way to specify parameters, so that pressing a prompt key (F4) would allow you to build the proper command line by filling a form. I do miss that, pity it doesn’t exist for Linux.