You may not use your gksu.sh with file. mediainfo, and the like.

So that, one desktop launcher, and one script which can be modified for the current needs.
You can simply uncomment the command you need.
NOTE: Filenames and paths with spaces should be supported.

If it is about security, then

Exec=gksu.sh /usr/bin/apt-get install %f

Linux Mint has two different apt

/usr/bin/apt
/usr/local/bin/apt

_https://github.com/linuxmint/mintsystem/blob/master/usr/local/bin/apt

This is not acceptable. It should be like this:

Terminal=false

There are many experts on security, on sound, on ALSA, and on everything else, who cannot write a simple script and cannot compile anything. Such "universal experts", as a rule, have affinity to censorship. This affinity can manifest in various ways, from individual tendencies to participate in online content moderation to governmental actions that suppress certain forms of speech.

Because of pulseaudio, systemd, and pipewire, many users left Linux. As a result, the percentage of "universal experts" on Linux forums has significantly increased. They know little about Linux, but they can censor everything.

The problem is that such "universal experts" tend to overestimate their knowledge and underestimate their ignorance. To protect their overblown ego from the reality that challenges it, they have to censor everything they do not understand. That is why, they often attempt to censor jokes. For the same reason, they hate AI and strive to abolish it. Though there might also be economic reasons for AI hate. The "universal experts" may feel that they can be replaced by AI in the same way as Luddites were replaced by machines during the Industrial Revolution. They have to fear AI, because they do not trust their ability to think. To be enslaved by fear, one must relinquish trust in his God-given ability to think.

1. a very simple bash script (e.g., three lines of code)

If you don't know how .desktops can work, you may be convinced you need a script.

[Desktop Entry]
Type=Action
Comment=Install local .deb package
Name=Install Package
Icon=info
Terminal=true
Profiles=on_file;

[X-Action-Profile on_file]
Exec=gksu.sh apt-get install %f
MimeTypes=application/x-debian-package;

The same method can be used to run media files with CLI aps, e.g., aplay, mplayer, ffplay and the like, or with scripts (e.g, to resample waves with pcm_conv).

when packages get in a real mess it also lacks the full features of apt to unbreak things.

Since apt is a sort of "unstable wrapper", it may lacks the full features of apt-get to unbreak things.

For example:

mate-terminal -e <command>

To install a "local .deb" with dependencies, you can use apt or apt-get

apt-get does not need a gui, it can be used as is.

Exec=deb-installer %f

and this would be the base of the deb-installer that is pretty much a glorified yad confirmation dialog

#!/bin/sh

###############################################################################
# yes these variables for the dialog are empty, whoever does take the time to #
# build this thing proper ought to fill them, maybe even use gettext for      #
# internationalization and stuff                                              #
###############################################################################

# action image
act_image=""
# action title
text_title=""
# action message
text_msg=""
# window title in taskbar/titlebar
title_var=""
# action button text
btn_act=""
# message on success
success_msg=""
# message on cancel
cancel_msg=""

u_true=0
u_false=1

# return type: unix command boolean
# return values:
#     True : u_true
#     False: u_false
# usage: yad_confirm_dialog
yad_confirm_dialog () {
    # function's return value
    # defaulting to false just to be safe
    retval="$u_false"

    text="
    <span><big><b>${text_title}</b></big></span>

    ${text_msg}
    "
    btn_cancel="$(gettext "$myname" "$btn_cancel")"
    cancel_img="gnome-info"
    yad \
        --image "$act_image" \
        --text "$text" \
        --buttons-layout=center \
        --skip-taskbar \
        --sticky \
        --undecorated \
        --title="$title_var" \
        --on-top \
        --button="$btn_act" \
        --button="${btn_cancel}:1" \
        --center

    ret=$?

    case "$ret" in
        0|70)
            notify-send -i "$act_image" "$title_var" "$success_msg"
            retval="$u_true"
            ;;
        1|252)
            notify-send -i "$cancel_img" "$title_var" "$cancel_msg"
            retval="$u_false""
            ;;
    esac

    return "$retval"
}

main () {
    yad_confirm_dialog
    ret=$?
    if [ "$ret" -eq "$u_true" ]; then
        $0 "install" "$1"
    fi
}

install_software () {
    apt update
    apt install "$1" -y
    ret=$?
    return "$ret"
}

case "$1" in
    install)
        shift
        # are we root?
        if [ ! "$( id -u )" -eq 0 ]; then
            install_software "$1"
        else
            has_tty=""
            if tty | grep -qF -e "dev/tty" -e "dev/pts"; then
                has_tty=1
            fi
            if [ -n "$has_tty" ]; then
                sudo "$0" "install" "$1"
            else
                # prefer sudo with sudo_askpass over pkexec
                if [ -n "$SUDO_ASKPASS" ]; then
                    sudo -A "$0" "install" "$1"
                else
                    pkexec sudo "$0" "install" "$1"
                fi
            fi
        fi
    ;;
    *)
        main "$@"
    ;;
esac

Try "su" to root, then "apt" or "dpkg".

It seems that you do not know how to write a simple script.

Well I haven't taken a sip yet today from the waterfall of secret esoteric knowledge, so my dementia lacks the mystic sauce of enlightenment to keep it at bay, perhaps you need to wall-of-text me some more of that deep deep lore that ChatGPT has bestowed upon thee.

It seems that you do not know how to write a simple script.

Vuu-do don't sudo.

1. bash script with one simple command inside

2. desktop launcher for it

Right click on a deb file and select "install deb".
It opens a terminal, and runs "sudo dpkg -i <your deb>" on it.

gksu is not needed.

"local .deb packages" can be installed with "dpkg" or with "apt" (together with dependencies, if available) similar to "gdebi".

another option would be to cobble a script with yad for the gui (lighter for setups that already use yad) and on the inside all it does is run apt-get commands to show the information of the .deb and installs it with apt-get install <full/path/to/package.deb>

That was my thought. gdebi is only about 1 mb so it's small, but i'm pretty sure a simple script for doing this with yad and apt-get would only be like 20-30k. Edit: Actually less than that the more I think about it, apt-get will do all the legwork checking for depends etc. Just need to use the right command, then a success dialog at the end, some error checks of course etc.

If you're just making a quick and dirty for yourself and don't need a safety net, you can do it as a right-click extension with just a .desktop, like maybe so (if you know for sure you already have all needed depends installed):

[Desktop Entry]
Type=Action
Comment=Install local .deb package
Name=Install Package
Icon=info
Profiles=on_file;

[X-Action-Profile on_file]
Exec=gksu.sh dpkg -i %f
MimeTypes=application/x-debian-package;

Before somebody asks again, gksu.sh is just my pkexec translator so I don't have to type a lot of extra crap when I make one of these.

What Are Principles of Ergonomics in UI Design?
_https://www.flowmapp.com/blog/qa/principles-of-ergonomics-in-ui-design

Another approach is to explain the user that Linux terminal may help against dementia.

The Linux terminal invokes a certain mode of thinking that helps to solve problems. The command-line interface (CLI) promotes a more structured and logical problem-solving approach by requiring users to be explicit and understand cause-and-effect relationships between commands and their outputs. This text-based interaction encourages a deep understanding of system operations, fosters skills in breaking down complex tasks, and develops a powerful efficiency in performing intricate operations that might be slower in a graphical interface.