I know that GUI does not cover most of functionalities, for good reasons - being specialized to task (like files app), it provides more fine-grained experience.

Yet, I find that there are common commands which is terminal-only, or not faithfully implemented. for instance,

  • Commands like apt update/apt upgrade might be needed, as GUI may not allow enough interactions with it.
  • I heard some immutable distros require running commands for rollbacks.

These could cause some annoyance for those who want to avoid terminal unless necessary (including me). Hence, I bet there are terminal emulators which restricts what commands you could run, and above all, present them as buttons. This will make you recall the commonly used commands, and run them accordingly. Is there projects similar to what I describe? Thanks!

  • 1984@lemmy.today
    0·
    6 months ago

    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 share 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.

  • pivot_root@lemmy.world
    0·
    6 months ago

    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.

      • Telorand@reddthat.com
        0·
        5 months ago

        You should see if there’s a Windows equivalent (since it has the most market share by a country mile). If it does, use that for ideas, and improve upon it. If not, it may not be feasible or reasonable based on your goals.

    • WbrJr@lemmy.ml
      0·
      5 months ago

      I dont think you should habe to learn to usw the terminal in order to debug your operating system. If i would switch my mom to Linux, i dont want her to have to use the terminal. So making life easier for those people would grealty improve the appeal of Linux to tech noobs. By arguing we need the terminal for Linux, we gatekeep people from trying and using Linux, if they are afraid of technology

  • Chris Gerber@lemmy.world
    0·
    5 months ago

    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.

  • oo1@lemmings.worldEnglish
    0·
    6 months ago

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

  • AbouBenAdhem@lemmy.worldEnglish
    0·
    6 months ago

    Rather than creating a custom terminal, 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?

  • mkwt@lemmy.world
    0·
    6 months ago

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

  • refalo@programming.dev
    0·
    6 months ago

    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.

      • refalo@programming.dev
        0·
        6 months ago

        I don’t think there is one yet… it would need some kind of way to understand the possible options and parameters for any given CLI program, and without a standardized interface for that, error-prone scraping of --help or just hard-coding popular options is probably the best you could do. Hopefully it wouldn’t end up looking something like the Scratch programming IDE though.

        This reminds of jc which is kindof the opposite where it scrapes the output of common commands to present a more unified (JSON) syntax for other programs to consume and automate better.

        • someacnt_@lemmy.worldOP
          0·
          6 months ago

          Hmm, --help parsing can be screwy, I guess. Maybe there is a way through autocompletion machinery.

  • k4j8@lemmy.world
    0·
    6 months ago

    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.

    • Nibodhika@lemmy.world
      0·
      6 months ago

      As much as I love nushell it will ever be too early for beginners, POSIX compliance is a big problem there. They have their very good reasons to not be POSIX compliant, but someone starting out should familiarize themselves with the most common pattern first before jumping to something completely different that will prevent them from running code snippets they might find online.

  • nmtake@lemm.ee
    0·
    6 months ago

    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.)

    • someacnt_@lemmy.worldOP
      0·
      6 months ago

      I am using bash, which is indeed part of the problem. What emulator would you suggest, and how did you achieve it?

      • nmtake@lemm.ee
        0·
        6 months ago

        Bash should be fine. On typical Bash installation I think this will work (please try to understand each command line before you actually try):

        $ 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)

        For the next bash session you can refer only the two commands from the history with Up/Down/C-p/C-n.

  • boredsquirrel@slrpnk.net
    0·
    6 months ago

    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

  • Nibodhika@lemmy.world
    0·
    6 months ago

    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.

    • someacnt_@lemmy.worldOP
      0·
      6 months ago

      Yeah, I understand that this is difficult. But I am suggesting this considering lack of polish (ime) in commands.

      On the recalling, remembering entire commands is not the problematic one for me. Rather, I want a quick way to go with which apps do which.

      Also, terminals (that is, how most of the commands run) honestly do not look and feel good. I do think polished TUI could be a good solution, but they are not widespread.

  • gomp@lemmy.ml
    0·
    6 months ago

    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)

    • someacnt_@lemmy.worldOP
      0·
      6 months ago

      Calling it “terminal emulator” was a poor word usage on my end, yeah. I do not fear myself running command line though. I just want to avoid CLI.

  • brianorca@lemmy.world
    0·
    5 months ago

    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.

  • tunetardis@lemmy.caEnglish
    0·
    6 months ago

    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?

    • someacnt_@lemmy.worldOP
      0·
      6 months ago

      Seems like what I was roughly thinking of. I guess it fell into obscurity for good reasons, but I do think this kind of tool would be great for some edge-cases - that is, you cannot yet avoid terminal.

      • tunetardis@lemmy.caEnglish
        0·
        5 months ago

        The thing about the MPW Shell is it was sort of the only game in town if you actually wanted a command line with the classic Mac OS. (There’s an awesome little emulator called SheepShaver if you ever want to explore it btw.) Well, I suppose there was A/UX. I thought it was a miracle when that came out. You have to realize in those early days a good chunk of the operating system itself was actually baked in to ROM. (You had to do desperate things to squeeze a GUI out of such limited resources as existed back then!) So to this day I have no idea how they managed to spin off a 'nix despite that.

        Anyways. I wonder, if you made some sort of template format today, to what extent you could write some sort of conversion tool that would scrape a man page or whatever to rough it in and then you could tweak it to get what you want? man pages aren’t super standardized in their format I guess, so it’s probably more trouble than it’s worth. I like to use Python’s argparse when rolling out scripts myself, and its --help format is pretty rigid given that it’s algorithmically generated. Might be more plausible with something like that? I had a quick look just now to see if you can drill down into the argparse.ArgumentParser class itself to pull out the info more directly, but it seems a rather opaque thing that doesn’t expose public APIs for that. Oh well…