scripts/sh
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

addet sh scripts

Browse source
This commit is contained in:
piecka 2025-02-25 10:58:12 +01:00
parent b7645b88b1
commit b900716d24
20 changed files with 3760 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

180
installs/docker.sh Executable file
View file

@ -0,0 +1,180 @@
#!/bin/sh -e
# ─< ANSI color codes >───────────────────────────────────────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
check_sudo() {
# check for $su
if [ "$USER" != "root" ]; then
if command -v sudo >/dev/null 2>&1; then
su="sudo"
else
echo "Are you sure you can handle this? You're not root and sudo cannot be found.. [y/n]"
read -r sud </dev/tty
case $sud in
[Yy]) echo "All right, if anything breaks, it's on you" ;;
[Nn])
echo "All right, you're good. Try to install 'sudo'"
exit 1
;;
*)
echo "Invalid choice. Exiting."
exit 1
;;
esac
su=""
fi
else
su=""
fi
echo "--- check_sudo done --- echo '$su' |"
}
# ─< Distribution detection and installation >────────────────────────────────────────
check_dist() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# ─< Convert $ID and $ID_LIKE to lowercase >──────────────────────────────────────────────
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) _ubuntu ;;
debian) _debian ;;
fedora) _fedora ;;
# alpine) _alpine ;;
arch | manjaro | garuda | endeavour) _arch ;;
opensuse*) inst_opensuse ;;
*)
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
_debian
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
_ubuntu
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
_arch
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
_fedora
# elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
# _opensuse
else
echo_error "Unsupported distribution: $ID"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
_debian() {
clear
echo_info "executing debian"
sleep 2
$su apt-get update &&
$su apt-get install -y ca-certificates curl &&
$su install -m 0755 -d /etc/apt/keyrings &&
$su curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc &&
$su chmod a+r /etc/apt/keyrings/docker.asc &&
sleep 0.5
if [ "$VERSION_CODENAME" == "trixie" ]; then
VERSION_CODENAME="bookworm"
fi
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | $su tee /etc/apt/sources.list.d/docker.list >/dev/null
clear &&
echo_info "Addet repository. Updating and installing now.."
sleep 1
$su apt-get update
$su apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
}
_ubuntu() {
clear
echo_info "executing ubuntu"
sleep 2
$su apt-get update &&
$su apt-get install -y ca-certificates curl &&
$su install -m 0755 -d /etc/apt/keyrings &&
$su curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc &&
$su chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | $su tee /etc/apt/sources.list.d/docker.list >/dev/null
clear &&
echo_info "Addet repository. Updating and installing now.."
sleep 0.5
$su apt-get update
$su apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
}
_fedora() {
clear
echo_info "executing fedora"
sleep 2
$su dnf -y install dnf-plugins-core
$su dnf config-manager --add-repo https://download.docker.com/linux/fedora/docker-ce.repo
$su dnf install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
}
_arch() {
clear
echo_info "executing arch"
sleep 2
$su pacman -S docker docker-compose --noconfirm
}
init_docker() {
if command -v docker >/dev/null 2>&1; then
echo_info "Docker was installed correctly. Do you want to add $(whoami) to the docker group? (y/n)"
read -r dgroup </dev/tty
case "$dgroup" in
[Yy])
$su usermod -aG docker "$(whoami)"
;;
esac
sleep 1
$su systemctl enable --now docker
echo_info "$(whoami) is now part of the docker group. Restart your session to enable the changes. Also docker was addet as a service. Should autostart from now on."
else
echo_error "Something went wrong!"
fi
}
main() {
if check_sudo; then
# if check_dist; then
# init_docker
# else
# echo_error "No distro found.. At least thats what the error says.."
# fi
check_dist && init_docker
else
echo_error "Sudo check was failing hard..!"
fi
}
main </dev/tty

152
installs/flatpak.sh Executable file
View file

@ -0,0 +1,152 @@
#!/bin/sh -e
# ANSI color codes
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─< Silent execution >─────────────────────────────────────────────────────────────────
silentexec() {
"$@" >/dev/null 2>&1
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# Check if the user is root and set sudo variable if necessary
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_note "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_note "Root access confirmed."
_sudo=""
fi
}
flatpak_init() {
if command_exists flatpak; then
echo_info "Flatpak exists, initializing flathub repository!"
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
else
echo_error "Flatpak was not found!"
fi
}
inst_arch() {
echo_note "Using Arch script, btw!"
if command_exists yay; then
i_arch="yay"
elif command_exists paru; then
i_arch="paru"
elif command_exists pacman; then
i_arch="$_sudo pacman"
fi
if [ -n "$i_arch" ]; then
i_arch -S flatpak
else
echo_error "No packager for installation found.. (not even pacman...)"
fi
}
inst_debian() {
echo_note "Using Debian script!"
if command_exists nala; then
$_sudo nala update
$_sudo nala install flatpak -y
elif command_exists apt-get; then
echo_info "Couldn't find nala, falling back to apt-get"
$_sudo apt-get update
$_sudo apt-get install flatpak -y
fi
}
inst_ubuntu() {
echo_note "Using Ubuntu script!"
if command_exists nala; then
$_sudo nala update
$_sudo nala install flatpak -y
elif command_exists apt-get; then
echo_info "Couldn't find nala, falling back to apt-get"
$_sudo apt-get update
$_sudo apt-get install flatpak -y
fi
}
# ─< Distribution detection and installation >────────────────────────────────────────
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# Convert $ID and $ID_LIKE to lowercase
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) inst_ubuntu ;;
debian) inst_debian ;;
fedora) inst_fedora ;;
alpine) inst_alpine ;;
arch | manjaro | garuda | endeavour) inst_arch ;;
opensuse*) inst_opensuse ;;
*)
# Use standard [ ] syntax for string matching
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
inst_debian
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
inst_ubuntu
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
inst_arch
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
inst_fedora
elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
inst_opensuse
else
echo_error "Unsupported distribution: $ID"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
install_flatpak() {
check_root &&
get_packager &&
flatpak_init
}
install_flatpak

310
installs/ghostty.sh Normal file
View file

@ -0,0 +1,310 @@
#!/bin/sh
# ╭───────────────╮
# │ env functions │
# ╰───────────────╯
# ───────────────────────────────────< ANSI color codes >───────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─────────────< Check if the user is root and set sudo variable if necessary >─────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ──────────────────────< Check if the given command exists silently >──────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
_cd() {
cd "$1" || echo_error "Could not cd into $1!"
}
# ─< Distribution detection and installation >────────────────────────────────────────
# checks for variable dist={debian,ubuntu,fedora,arch,suse}
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# ─< Convert $ID and $ID_LIKE to lowercase >──────────────────────────────────────────────
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop | linuxmint | elementary) dist="ubuntu" ;;
debian | kali | zorin | parrot | deepin | raspbian | devuan) dist="debian" ;;
fedora | nobara | rhel | centos) dist="fedora" ;;
arch | manjaro | garuda | endeavour | artix) dist="arch" ;;
opensuse*) dist="suse" ;;
*)
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
dist="debian"
echo_note "Detected Debian-based distribution"
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
dist="ubuntu"
echo_note "Detected Ubuntu-based distribution"
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
dist="arch"
echo_note "Detected Arch-based distribution"
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
dist="fedora"
echo_note "Detected Fedora-based distribution"
elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
dist="suse"
echo_note "Detected SUSE-based distribution"
else
echo_error "Unsupported distribution: $ID"
echo_note "Please report this issue with your distribution details"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
# ╭────────────────────────────────────╮
# │ insert your scripts/functions here │
# ╰────────────────────────────────────╯
# ─────────────────────────────────────< dependencies >─────────────────────────────────────
deps_common="git curl tar"
deps_arch="$deps_common gtk4 libadwaita"
deps_deb="$deps_common libgtk-4-dev libadwaita-1-dev"
deps_fedora="$deps_common gtk4-devel zig libadwaita-devel"
deps_suse="$deps_common gtk4-tools libadwaita-devel pkgconf-pkg-config zig"
checkDeps=""
checkDeps() {
get_packager
case "$dist" in
debian | ubuntu)
pkg="apt-get"
echo "Detected packagemanager ${RED}${pkg}"
echo_info "Updating sources.."
$_sudo apt-get update
echo_info "Checking dependencies now.."
sleep 3
for dep in $deps_deb; do
if ! command_exists $dep; then
echo_info "Installing $dep.."
$_sudo apt-get install "$dep" --assume-yes </dev/tty
fi
done
checkDeps="done"
;;
fedora)
pkg="dnf"
echo "Detected packagemanager ${RED}${pkg}"
echo_info "Updating sources.."
$_sudo dnf update
echo_info "Checking dependencies now.."
sleep 3
for dep in $deps_fedora; do
if ! command_exists $dep; then
echo_info "Installing $dep.."
$_sudo dnf install "$dep" </dev/tty
fi
done
checkDeps="done"
;;
suse)
pkg="zypper"
echo "Detected packagemanager ${RED}${pkg}"
echo_info "Updating sources.."
$_sudo zypper refresh
echo_info "Checking dependencies now.."
sleep 3
for dep in $deps_suse; do
if ! command_exists $dep; then
echo_info "Installing $dep.."
$_sudo zypper install "$dep" -y </dev/tty
fi
done
checkDeps="done"
;;
arch)
pkg="pacman"
echo "Detected packagemanager ${RED}${pkg}"
echo_info "Updating sources.."
$_sudo pacman -Syy
echo_info "Checking dependencies now.."
sleep 3
for dep in $deps_arch; do
if ! command_exists $dep; then
echo_info "Installing $dep.."
$_sudo pacman -S "$dep" --noconfirm </dev/tty
fi
done
checkDeps="done"
;;
*)
echo "Something went wrong with your Distribution ${RED}${dist}"
;;
esac
echo_note "Distributional dependence check complete"
}
checkZig() {
if ! command_exists zig; then
echo_warning "Zig was not found, trying to install it now.."
sleep 3
case "$dist" in
arch)
$_sudo pacman -S zig --noconfirm
;;
suse)
$_sudo zypper install zig
;;
*)
installZig
;;
esac
else
echo_note "Zig was already found on the system.."
fi
}
installZig() {
if ! command_exists curl; then
echo_error "Most basic things (like curl) are not there!"
echo_error "Aborting now!"
exit 1
fi
if [ -h /bin/zig ] && [ ! -x /bin/zig ]; then
echo_warning "Found zig at /bin/zig, removing it now.."
$_sudo rm -rf /bin/zig
fi
# zigDir=$(mktemp -d)
zigDir="$HOME/.local/zig"
if [ ! -d $zigDir ]; then
echo_note "Zig build directory getting setup.."
mkdir $zigDir
fi
cd "$zigDir" || echo_error "$zigDir is not a valid directory!"
echo_info "Downloading zig 13.0.. This could take a while.."
curl -fsSL https://ziglang.org/download/0.13.0/zig-linux-x86_64-0.13.0.tar.xz -o zig.tar.xz || echo_error "Could not download zig 13.0.."
echo_info "Uncompressing archive.."
sleep 1
tar -xf ./zig.tar.xz
echo_info "Linking zig for the installation.."
mv zig-* zig >/dev/null 2>&1
$_sudo ln -rs ./zig/zig /bin/zig
}
cloneGhostty() {
if [ ! "$checkDeps" = "done" ]; then
echo_error "Dependencies are not installed, aborting now!"
exit 1
fi
# buildDir=$(mktemp -d)
buildDir="$HOME/.local/ghostty-build"
if [ -d "$buildDir" ] && [ -n "$(ls -A "$buildDir")" ]; then
echo_warning "Ghostty build directory already exists at ${buildDir}, do you want to remove it? (y/n)"
read -r removeBuildDir </dev/tty
case "$removeBuildDir" in
[yY]) $_sudo rm -rf "$buildDir" ;;
*)
echo_error "Aborting now!"
exit 1
;;
esac
else
mkdir -p "$buildDir"
fi
echo_info "Cloning ghostty repository now.."
git clone https://github.com/ghostty-org/ghostty.git "$buildDir" || echo_error "Could not clone ghostty repository!"
_cd "$buildDir"
echo_info "Preparations are done!"
buildGhostty
}
buildGhostty() {
echo_info "Building ghostty now.."
zig build -p /usr -Doptimize=ReleaseFast
}
ErrorExit() {
echo_error "Fatal error!"
echo_error "${1}"
echo_error "Exiting now!"
exit 1
}
# ───────────────────────────────< main function to execute >───────────────────────────────
main() {
if check_root; then
checkDeps || ErrorExit "Step 1/3"
checkZig || ErrorExit "Step 2/3"
cloneGhostty || ErrorExit "Step 3/3"
else
echo_error "Something went terribly wrong!"
fi
}
main </dev/tty

632
installs/hyprland.sh Normal file
View file

@ -0,0 +1,632 @@
#!/bin/sh -e
# ╭───────────────╮
# │ env functions │
# ╰───────────────╯
# ───────────────────────────────────< ANSI color codes >───────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─────────────< Check if the user is root and set sudo variable if necessary >─────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ──────────────────────< Check if the given command exists silently >──────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ╭────────────────────────────────────╮
# │ insert your scripts/functions here │
# ╰────────────────────────────────────╯
hyprSlim="hyprland hyprland-protocols hyprwayland-scanner libhyprcursor-dev wayland-utils wayland-protocols wl-clipboard nwg-look xdg-desktop-portal-hyprland liblz4"
hyprAdvanced="$menu pavucontrol pamixer btop bluez wlogout wob"
OPTIONAL_SCREENSHOT="grimshot slurp swappy"
OPTIONAL_SCREENRECORD="wf-recorder"
OPTIONAL_AUDIO="pulseaudio pavucontrol"
OPTIONAL_NOTIFY="sway-notification-center libnotify"
OPTIONAL_UTILS="brightnessctl network-manager-gnome gnome-keyring swayidle playerctl"
OPTIONAL_FILES="xdg-user-dirs nautilus gvfs"
OPTIONAL_SDDM_DEPS="qml6-module-qtquick-controls qml6-module-qtquick-effects sddm"
BUILD_DEPS="git gcc make cmake meson ninja-build pkg-config"
RUST_DEPS="cargo rustc" # Separate rust dependencies
askThings() {
echo_note "Do you want to install hyprland? (y/N)"
read -r askHyprland </dev/tty
case "$askHyprland" in
[yY]) askHyprland="true" ;;
*)
echo_error "Aborting now!"
exit 1
;;
esac
echo_note "What bar do you want to install? (available: [w]aybar, [h]yprpanel, [g]Bar)"
read -r askBar </dev/tty
case "$askBar" in
[Ww] | waybar)
bar="waybar"
;;
[Hh] | hyprpanel)
bar="hyprpanel"
;;
[Gg] | gBar | gbar)
bar="gBar"
;;
esac
echo_info "Set bar to $bar"
echo_note "Do you want to install [r]ofi or [t]ofi?: "
read -r askRofi </dev/tty
case "$askRofi" in
[tT] | tofi)
menu="tofi"
;;
[rR] | rofi)
menu="rofi"
;;
*)
menu="rofi"
;;
esac
echo_info "Set menu to $menu"
echo_note "Doy you want to install sddm with minimal dependency theme? [catppucchin-mocha] (Y/n) :"
read -r askSddm </dev/tty
case "$askSddm" in
[nN]) ;;
*)
hyprAdvanced="$hyprAdvanced $OPTIONAL_SDDM_DEPS"
sddm_minimal="true"
;;
esac
echo_info "Installing - $OPTIONAL_SDDM_DEPS - for sddm"
# Optional packages section
echo_note "Would you like to install screenshot tools ($OPTIONAL_SCREENSHOT)? (Y/n)"
read -r askScreenshot </dev/tty
case "$askScreenshot" in
[nN]) ;;
*) hyprAdvanced="$hyprAdvanced $OPTIONAL_SCREENSHOT" ;;
esac
echo_note "Would you like to install screen recording tools ($OPTIONAL_SCREENRECORD)? (Y/n)"
read -r askRecord </dev/tty
case "$askRecord" in
[nN]) ;;
*) hyprAdvanced="$hyprAdvanced $OPTIONAL_SCREENRECORD" ;;
esac
echo_note "Would you like to install audio tools ($OPTIONAL_AUDIO)? (Y/n)"
read -r askAudio </dev/tty
case "$askAudio" in
[nN]) ;;
*) hyprAdvanced="$hyprAdvanced $OPTIONAL_AUDIO" ;;
esac
echo_note "Would you like to install notification daemon ($OPTIONAL_NOTIFY)? (Y/n)"
read -r askNotify </dev/tty
case "$askNotify" in
[nN]) ;;
*) hyprAdvanced="$hyprAdvanced $OPTIONAL_NOTIFY" ;;
esac
echo_note "Would you like to install utility tools ($OPTIONAL_UTILS)? (Y/n)"
read -r askUtils </dev/tty
case "$askUtils" in
[nN]) ;;
*) hyprAdvanced="$hyprAdvanced $OPTIONAL_UTILS" ;;
esac
echo_note "Would you like to install additional file management tools ($OPTIONAL_FILES)? (Y/n)"
read -r askFiles </dev/tty
case "$askFiles" in
[nN]) ;;
*) hyprAdvanced="$hyprAdvanced $OPTIONAL_FILES" ;;
esac
}
buildBar() {
echo "..installing ${RED}${bar}${NC}"
case "$bar" in
waybar)
$_sudo $pkg install -y $bar </dev/tty
;;
gBar) ;;
hyprpanel) ;;
esac
}
instTools() {
case "$pkg" in
pacman)
aur="yay paru"
for i in $aur; do
if command_exists $i; then
echo "..using ${RED}$i${NC}"
pkgAur=$i
fi
done
if [ -z $pkgAur ]; then
echo_error "No aur helper present! You first have to install either yay or paru!"
exit 1
fi
if [ "$bar" = "hyprpanel" ]; then
if command_exists $pkgAur; then
echo_info "Installing hyprpanel..."
$pkgAur -S ags-hyprpanel-git --noconfirm </dev/tty
fi
elif [ "$bar" = "gBar" ]; then
if command_exists $pkgAur; then
echo_info "Installing gBar..."
$pkgAur -S gbar-git --noconfirm </dev/tty
fi
fi
;;
*)
buildBar
;;
esac
}
get_package_name() {
_package="$1"
case "$pkg" in
pacman)
echo_info "Getting package names..."
case "$_package" in
# Core/Slim
libhyprcursor-dev) echo "hyprcursor-git" ;;
xdg-desktop-portal-hyprland) echo "xdg-desktop-portal-hyprland" ;;
wayland-utils) echo "wayland-utils" ;;
nwg-look) echo "nwg-look-bin" ;;
# Advanced
btop) echo "btop" ;;
pamixer) echo "pamixer" ;;
wlogout) echo "wlogout" ;;
wob) echo "wob" ;;
# sddm
qml6-module-qtquick-*) echo "kirigami" ;;
# Screenshot
grim) echo "grim" ;;
slurp) echo "slurp" ;;
swappy) echo "swappy" ;;
# Screen recording
wf-recorder) echo "wf-recorder" ;;
# Audio
pipewire) echo "pipewire" ;;
wireplumber) echo "wireplumber" ;;
pipewire-alsa) echo "pipewire-alsa" ;;
pipewire-pulse) echo "pipewire-pulse" ;;
# Notification
sway-notification-center) echo "sway-notification-center" ;;
libnotify) echo "libnotify" ;;
# Utils
brightnessctl) echo "brightnessctl" ;;
network-manager-gnome) echo "network-manager-applet" ;;
gnome-keyring) echo "gnome-keyring" ;;
swayidle) echo "swayidle" ;;
playerctl) echo "playerctl" ;;
# Files
xdg-user-dirs) echo "xdg-user-dirs" ;;
gvfs) echo "gvfs" ;;
liblz4) echo "lz4" ;;
*) echo "$_package" ;;
esac
;;
apt-get)
case "$_package" in
# Core/Slim
hyprland) echo "hyprland" ;;
libhyprcursor-dev) echo "libhyprcursor-dev" ;;
nwg-look) echo "nwg-look" ;;
# Advanced
pamixer) echo "pamixer" ;;
wob) echo "wob" ;;
# sddm
qml6-module-qtquick-controls) echo "qml6-module-qtquick-controls" ;;
qml6-module-qtquick-effects) echo "qml6-module-qtquick-effects" ;;
# Screenshot
grim) echo "grim" ;;
slurp) echo "slurp" ;;
swappy) echo "swappy" ;;
# Screen recording
wf-recorder) echo "wf-recorder" ;;
# Audio
pipewire) echo "pipewire" ;;
wireplumber) echo "wireplumber" ;;
pipewire-alsa) echo "pipewire-alsa" ;;
pipewire-pulse) echo "pipewire-pulse" ;;
# Notification
sway-notification-center) echo "sway-notification-center" ;;
libnotify) echo "libnotify-bin" ;;
# Utils
brightnessctl) echo "brightnessctl" ;;
network-manager-gnome) echo "network-manager-gnome" ;;
gnome-keyring) echo "gnome-keyring" ;;
swayidle) echo "swayidle" ;;
playerctl) echo "playerctl" ;;
# Files
xdg-user-dirs) echo "xdg-user-dirs" ;;
gvfs) echo "gvfs" ;;
liblz4) echo "liblz4-dev" ;;
*) echo "$_package" ;;
esac
;;
dnf)
case "$_package" in
# Core/Slim
libhyprcursor-dev) echo "hyprcursor-devel" ;;
xdg-desktop-portal-hyprland) echo "xdg-desktop-portal-hyprland" ;;
nwg-look) echo "nwg-look" ;;
# Advanced
wlogout) echo "wlogout" ;;
# sddm
qml6-module-qtquick-controls) echo "qml6-module-qtquick-controls" ;;
qml6-module-qtquick-effects) echo "qml6-module-qtquick-effects" ;;
# Screenshot
grim) echo "grim" ;;
slurp) echo "slurp" ;;
swappy) echo "swappy" ;;
# Screen recording
wf-recorder) echo "wf-recorder" ;;
# Audio
pipewire) echo "pipewire" ;;
wireplumber) echo "wireplumber" ;;
pipewire-alsa) echo "pipewire-alsa" ;;
pipewire-pulse) echo "pipewire-pulseaudio" ;;
# Notification
sway-notification-center) echo "sway-notification-center" ;;
libnotify) echo "libnotify" ;;
# Utils
brightnessctl) echo "brightnessctl" ;;
network-manager-gnome) echo "nm-connection-editor" ;;
gnome-keyring) echo "gnome-keyring" ;;
swayidle) echo "swayidle" ;;
playerctl) echo "playerctl" ;;
# Files
xdg-user-dirs) echo "xdg-user-dirs" ;;
gvfs) echo "gvfs" ;;
liblz4) echo "lz4-devel" ;;
*) echo "$_package" ;;
esac
;;
zypper)
case "$_package" in
# Core/Slim
libhyprcursor-dev) echo "hyprcursor-devel" ;;
# Advanced
pamixer) echo "pamixer" ;;
wob) echo "wob" ;;
# sddm
qml6-module-qtquick-controls) echo "qml6-module-qtquick-control" ;;
qml6-module-qtquick-effects) echo "qml6-module-qtquick-effects" ;;
# Screenshot
grim) echo "grim" ;;
slurp) echo "slurp" ;;
swappy) echo "swappy" ;;
# Screen recording
wf-recorder) echo "wf-recorder" ;;
# Audio
pipewire) echo "pipewire" ;;
wireplumber) echo "wireplumber" ;;
pipewire-alsa) echo "pipewire-alsa" ;;
pipewire-pulse) echo "pipewire-pulseaudio" ;;
# Notification
sway-notification-center) echo "sway-notification-center" ;;
libnotify) echo "libnotify" ;;
# Utils
brightnessctl) echo "brightnessctl" ;;
network-manager-gnome) echo "NetworkManager-gnome" ;;
gnome-keyring) echo "gnome-keyring" ;;
swayidle) echo "swayidle" ;;
playerctl) echo "playerctl" ;;
# Files
xdg-user-dirs) echo "xdg-user-dirs" ;;
gvfs) echo "gvfs" ;;
liblz4) echo "liblz4-devel" ;;
*) echo "$_package" ;;
esac
;;
esac
}
# Add this function to check for Rust toolchain
check_rust() {
for tool in $RUST_DEPS; do
if ! command_exists "$tool"; then
case $pkg in
pacman)
echo_info "Updating package database..."
$_sudo pacman -Sy
echo_info "Installing Rust toolchain..."
$_sudo pacman -S rust cargo --noconfirm </dev/tty
;;
apt-get)
echo_info "Updating package database..."
$_sudo apt-get update
echo_info "Installing Rust toolchain..."
$_sudo apt-get install rustc cargo -y </dev/tty
;;
dnf)
echo_info "Updating package database..."
$_sudo dnf install rust cargo -y </dev/tty
;;
zypper)
echo_info "Updating package database..."
$_sudo zypper install rust cargo -y </dev/tty
;;
esac
return $?
fi
done
return 0
}
# Modify build_swww to check for Rust first
build_swww() {
echo_info "Building swww from source..."
# Check for Rust toolchain
if ! check_rust; then
echo_error "Failed to install Rust toolchain"
failed_builds="$failed_builds swww"
return 1
fi
# Store current directory
current_dir=$(pwd)
# Create temporary build directory
build_dir=$(mktemp -d)
trap "$_sudo rm -rf $build_dir" EXIT
cd "$build_dir" || exit 1
# Clone and build swww
if git clone https://github.com/Horus645/swww.git; then
cd swww || exit 1
if cargo build --release; then
echo_info "Installing swww..."
$_sudo cp target/release/swww /usr/local/bin/
$_sudo cp target/release/swww-daemon /usr/local/bin/
echo_note "swww installed successfully!"
else
echo_error "Failed to build swww"
failed_builds="$failed_builds swww"
fi
else
echo_error "Failed to clone swww repository"
failed_builds="$failed_builds swww"
fi
# Cleanup and return to original directory
cd "$current_dir" || exit 1
rm -rf "$build_dir"
}
# Modify instDeps() to use the new check_rust function
instDeps() {
pkgManager="apt-get pacman dnf zypper"
for i in $pkgManager; do
if command_exists $i; then
echo "..using ${RED}$i${NC}"
pkg=$i
fi
done
# First install build dependencies if we need to build swww
if ! command_exists swww; then
echo_info "Installing build dependencies for swww..."
case $pkg in
pacman)
echo_info "Updating package database..."
$_sudo pacman -Sy
echo_info "Installing build dependencies..."
$_sudo pacman -S $BUILD_DEPS --noconfirm </dev/tty
echo_info "Installing swww..."
$_sudo pacman -S swww -y </dev/tty
;;
apt-get | dnf)
echo_info "Updating package database..."
$_sudo $pkg update
echo_info "Installing build dependencies..."
$_sudo $pkg install $BUILD_DEPS -y </dev/tty
build_swww
;;
zypper)
echo_info "Updating package database..."
$_sudo zypper install $BUILD_DEPS -y </dev/tty
echo_info "Installing swww..."
$_sudo zypper install swww -y </dev/tty
;;
esac
fi
# Continue with normal package installation
transformed_deps=""
for dep in $deps; do
transformed_deps="$transformed_deps $(get_package_name "$dep")"
done
deps="$transformed_deps"
echo_info "Installing dependencies..."
case $pkg in
pacman)
if [ "$sddm_minimal" = "true" ]; then
$_sudo pacman -S sddm --noconfirm </dev/tty
fi
for d in $deps; do
if ! command_exists "$d"; then
$_sudo pacman -S "$d" --noconfirm </dev/tty
fi
done
# $_sudo pacman -S $deps --noconfirm </dev/tty
;;
apt-get)
if [ "$sddm_minimal" = "true" ]; then
$_sudo "$pkg" install sddm --no-install-recommends </dev/tty
fi
for d in $deps; do
if ! command_exists "$d"; then
$_sudo $pkg install "$d" --assume-yes </dev/tty
fi
done
;;
*)
for d in $deps; do
if ! command_exists "$d"; then
$_sudo $pkg install "$d" -y </dev/tty
fi
done
;;
esac
}
checkDependencies() {
deps=""
cd="$hyprSlim $hyprAdvanced"
for f in $cd; do
if ! command_exists $f; then
deps="$deps $f"
fi
done
}
cloneDotfiles() {
echo_info "Which dotfiles do you want to clone? ([p]ika's config, or just type the link to your own repo)"
read -r askDotfiles2 </dev/tty
case "$askDotfiles2" in
[pP])
echo_info "Cloning pika's config..."
git clone --recursive --depth=1 https://git.k4li.de/dotfiles/hyprdots.git $HOME/git/hyprdots || echo_error "Failed to clone dotfiles!" && exit 1
cd $HOME/git/hyprdots || echo_error "Failed to clone dotfiles!" && exit 1
echo_info "Installing dotfiles..."
make </dev/tty || echo_error "Failed to install dotfiles!" && exit 1
echo_info "Dotfiles installed successfully!"
;;
*)
echo_info "Cloning dotfiles from $askDotfiles2..."
git clone --recursive --depth=1 $askDotfiles2 $HOME/git/hyprdots
cd $HOME/git/hyprdots || echo_error "Failed to clone dotfiles!" && exit 1
echo_info "Your dotfiles have been saved to $HOME/git/hyprdots"
echo_info "You can now install your dotfiles how you want to!"
;;
esac
}
checkConfig() {
dirs="hypr $menu $bar"
for i in $dirs; do
if [ ! -d "$HOME/.config/$i" ]; then
echo_warning "Config directory $i not found!"
echo_note "Do you want to clone some dotfiles? (y/N)"
read -r askDotfiles </dev/tty
case "$askDotfiles" in
[yY])
echo_info "Cloning dotfiles..."
cloneDotfiles
;;
[nN])
echo_note "Skipping dotfiles installation..."
;;
esac
fi
done
}
# ───────────────────────────────< main function to execute >───────────────────────────────
main() {
if check_root; then
askThings
if [ "$askHyprland" = "true" ]; then
checkDependencies
instDeps
instTools
checkConfig
fi
else
echo_error "Something went terribly wrong!"
fi
}
main

97
installs/hyprpanel.sh Normal file
View file

@ -0,0 +1,97 @@
#!/bin/sh -c
# ─< ANSI color codes >───────────────────────────────────────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─< Check if the user is root and set sudo variable if necessary >───────────────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
inst_arch() {
dependencies="aylurs-gtk-shell grimblast hyprpicker"
if command_exists curl; then
if [ ! -d "$HOME/.bun" ]; then
echo_info "Downloading bun and linking it.."
curl -fsSL https://bun.sh/install | bash && $_sudo ln -s $HOME/.bun/bin/bun /usr/local/bin/bun
else
echo_note "Bun is already installed"
fi
$_sudo pacman -S pipewire libgtop bluez bluez-utils btop networkmanager dart-sass wl-clipboard brightnessctl swww python gnome-bluetooth-3.0 pacman-contrib power-profiles-daemon gvfs --noconfirm
if command_exists yay; then
echo_info "Using yay to install $dependencies"
yay -S --noconfirm $dependencies
elif command_exists paru; then
echo_info "Using paru to install $dependencies"
paru -S --noconfirm $dependencies
else
echo_error "No aur helper found.. Cannot continue!"
exit 1
fi
else
echo_warning "No curl was found, cannot continue!"
exit 1
fi
}
clone_to_ags() {
if [ ! -d "$HOME/.config/ags" ]; then
if command_exists git; then
git clone --depth=1 https://github.com/Jas-SinghFSU/HyprPanel "$HOME/.config/ags"
else
echo_error "There was no git found, cannot continue!"
exit 1
fi
else
echo_note "ags is already present, try running 'ags' in your terminal"
fi
}
main() {
if check_root; then
inst_arch
clone_to_ags
fi
}
main

71
installs/install-blesh.sh Executable file
View file

@ -0,0 +1,71 @@
{
#!/bin/bash
# ─< Helper functions >─────────────────────────────────────────────────────────────────
echo_error() { echo -e "\033[0;1;31mError: \033[0;31m\t${*}\033[0m"; }
echo_binfo() { echo -e "\033[0;1;34mINFO:\033[0;34m\t${*}\033[0m"; }
echo_info() { echo -e "\033[0;1;35mInfo: \033[0;35m${*}\033[0m"; }
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─< Check root and set sudo variable if necessary >───────────────────────────────────────────────
check_root() {
if [[ "${EUID}" -ne 0 ]]; then
if command_exists sudo; then
echo_binfo "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_binfo "Root access confirmed."
_sudo=""
fi
}
install_pkg() {
bash -c "$(curl -sSL https://git.k4li.de/pika/scripts/raw/branch/main/bash/snippets/install_pkg.sh)" -- "$@"
}
i_blesh() {
dir="$(mktemp -d)"
local deps=("bash" "git" "make" "gawk")
for pkg in "${deps[@]}"; do
if ! command_exists "$pkg"; then
install_pkg "$pkg"
fi
done &&
git clone --recursive --depth 1 --shallow-submodules https://github.com/akinomyoga/ble.sh.git "$dir" &&
make -C "$dir" install PREFIX=$HOME/.local
}
cleanup() {
echo_info "Do you want to clear the temp dir ($dir/) which was created for installation? [Y|n]" && read -r ask_dir
case "$ask_dir" in
[Nn])
echo_info "All right, didn't clean anything!"
;;
[Yy] | *)
$_sudo command rm -rf "$dir/"
;;
esac
}
main() {
# Check root access and set _sudo
if ! check_root; then
return 1
fi
if [[ ! -f $HOME/.local/share/blesh/ble.sh ]]; then
i_blesh
cleanup
else
echo_info "Blesh is already installed"
fi
}
main
}

131
installs/neovide.sh Executable file
View file

@ -0,0 +1,131 @@
#!/bin/sh
# ─< ANSI color codes >───────────────────────────────────────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─< check if command exists silently >───────────────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─< Silent execution >─────────────────────────────────────────────────────────────────
silentexec() {
"$@" >/dev/null 2>&1
}
# ─< Check if the user is root and set _sudo variable if necessary >───────────────────────
checkRoot() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
installNeovide() {
if ! command_exists cargo; then
curl --proto '=https' --tlsv1.2 -sSf "https://sh.rustup.rs" | sh
"$HOME/.cargo/bin/cargo" install --git https://github.com/neovide/neovide
else
cargo install --git https://github.com/neovide/neovide
fi
if [ -e "$HOME/.cargo/bin/neovide" ]; then
$_sudo ln -rs "$HOME/.cargo/bin/neovide" /bin/neovide
fi
}
i_arch() {
deps="base-devel fontconfig freetype2 libglvnd sndio cmake git gtk3 python sdl2 vulkan-intel libxkbcommon-x11"
$_sudo pacman -Sy
for dep in $deps; do
if ! command_exists $dep; then
silentexec $_sudo pacman --noconfirm -S "$dep" || echo_error "Couldn't install $dep"
fi
done
}
i_debian() {
$_sudo apt-get update
deps="curl gnupg ca-certificates git gcc-multilib g++-multilib cmake libssl-dev pkg-config libfreetype6-dev libasound2-dev libexpat1-dev libxcb-composite0-dev libbz2-dev libsndio-dev freeglut3-dev libxmu-dev libxi-dev libfontconfig1-dev libxcursor-dev"
for dep in $deps; do
if ! command_exists $dep; then
silentexec $_sudo apt-get install --assume-yes "$dep" || echo_error "Couldn't install $dep"
fi
done
}
i_fedora() {
deps="fontconfig-devel freetype-devel libX11-xcb libX11-devel libstdc++-static libstdc++-devel"
$_sudo dnf update
for dep in $deps; do
if ! command_exists $dep; then
silentexec $_sudo dnf install "$dep" || echo_error "Couldn't install $dep"
fi
done
$_sudo dnf groupinstall "Development Tools" "Development Libraries"
$_sudo dnf install dnf-plugins-core
}
checkDistrosAndDependencies() {
if [ -f /etc/os-release ]; then
echo_info "Sourcing /etc/os-release to determine the distribution..."
. /etc/os-release
case "$ID" in
debian | ubuntu | kali | linuxmint | pop | elementary | zorin | kubuntu | neon | kdeneon | deepin | linuxlite | linuxmintdebian | linuxmintubuntu | linuxmintkali | linuxmintpop | linuxmintelementary | linuxmintzorin | linuxmintkubuntu | linuxmintneon | linuxmintkdeneon | linuxmintdeepin | linuxmintlinuxlite) i_debian ;;
arch | manjaro | endeavouros) i_arch ;;
fedora | centos | rhel | rocky | almalinux) i_fedora ;;
*)
case "$ID_LIKE" in
*debian*) i_debian ;;
*arch*) i_arch ;;
*fedora*) i_fedora ;;
*)
echo_error "Unsupported distribution: $ID"
exit 1
;;
esac
;;
esac
else
echo_error "No os-release file found under /etc/. Exiting now!"
exit 1
fi
}
main() {
if checkRoot; then
checkDistrosAndDependencies && installNeovide
fi
}
main

185
installs/neovim.sh Executable file
View file

@ -0,0 +1,185 @@
{
#!/bin/sh -e
# ANSI color codes
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# Check if the user is root and set sudo variable if necessary
check_root() {
if [ "$(id -u)" -ne 0 ]; then
echo_note "checked $(id -u)"
if command_exists sudo; then
echo_note "Checking sudo"
echo_warning "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
if [ -n "$_sudo" ]; then
echo_info "--- check_root done --- echo '$_sudo' |"
else
echo_warning "sudo variable is empty: $_sudo"
fi
}
# ─< Dependencies >─────────────────────────────────────────────────────────────────────
deps="git cargo meson luarocks pipx curl ripgrep make composer npm gcc g++ unzip zip"
# ─< Distribution-specific installation functions >─────────────────────────────────────
inst_ubuntu() {
$_sudo apt-get update
for _deps in $deps; do
$_sudo apt-get install -y "$_deps" </dev/tty
done
inst_generic
}
inst_debian() {
$_sudo apt-get update
for _deps in $deps; do
$_sudo apt-get install -y "$_deps" </dev/tty
done
inst_generic
}
inst_fedora() {
$_sudo dnf update </dev/tty
for _deps in $deps; do
$_sudo dnf install -y "$_deps" </dev/tty
done
$_sudo dnf install -y neovim
}
inst_arch() {
$_sudo pacman -Syu --noconfirm
for _deps in $deps; do
$_sudo pacman -S --noconfirm "$_deps"
done
$_sudo pacman -S --noconfirm --needet neovim
}
inst_opensuse() {
$_sudo zypper refresh
for _deps in $deps; do
$_sudo zypper in "$_deps"
done
$_sudo zypper in neovim
}
inst_alpine() {
$_sudo apk update
for _deps in $deps; do
$_sudo apk add "$_deps"
done
$_sudo apk add neovim
}
inst_generic() {
tempdir="$(mktemp -d)"
if [ ! -d "$HOME/.bin" ]; then
mkdir "$HOME/.bin"
fi
echo_info "Downloading neovim tar.."
curl -fsSL -o "$tempdir/nvim.tar.gz" https://github.com/neovim/neovim/releases/download/v0.10.2/nvim-linux64.tar.gz && cd "$tempdir"
tar -xf nvim.tar.gz
cp -r ./nvim-linux64 "$HOME/.bin"
inst_paths="/usr/bin /usr/share/bin $HOME/.local/bin"
for in_path in $inst_paths; do
if [ -d "$in_path" ]; then
echo_info "Installing into $in_path"
$_sudo ln -r -s "$HOME/.bin/nvim-linux64/bin/nvim" "$in_path"
fi
done
}
# ─< Distribution detection and installation >────────────────────────────────────────
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# Convert $ID and $ID_LIKE to lowercase
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) inst_ubuntu ;;
debian) inst_debian ;;
fedora) inst_fedora ;;
alpine) inst_alpine ;;
arch | manjaro | garuda | endeavour) inst_arch ;;
opensuse*) inst_opensuse ;;
*)
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
inst_debian
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
inst_ubuntu
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
inst_arch
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
inst_fedora
elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
inst_opensuse
else
echo_error "Unsupported distribution: $ID"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
# ─< Main function >─────────────────────────────────────────────────────────────────
main() {
echo_info "Starting Neovim installation script..."
get_packager
if command -v nvim >/dev/null 2>&1; then
echo_note "Neovim has been successfully installed!"
echo_info "Neovim version: $(nvim --version | head -n1)"
else
echo_error "Neovim installation failed."
exit 1
fi
}
# ─< Script execution >─────────────────────────────────────────────────────────────
check_root && main
}

208
installs/virt-manager.sh Executable file
View file

@ -0,0 +1,208 @@
#!/bin/sh
# ─< ANSI color codes >───────────────────────────────────────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m'
# ─< Initialize storage variables >───────────────────────────────────────────────────────
_STORED_ERRORS=""
_STORED_WARNINGS=""
_STORED_INFOS=""
_STORED_NOTES=""
# ─< echo functions that store and display messages >────────────────────────────
echo_error() {
message="${RED}$1${NC}\n"
printf "$message" >&2
_STORED_ERRORS="${_STORED_ERRORS}${message}"
}
echo_warning() {
message="${YELLOW}$1${NC}\n"
printf "$message"
_STORED_WARNINGS="${_STORED_WARNINGS}${message}"
}
echo_info() {
message="${CYAN}$1${NC}\n"
printf "$message"
_STORED_INFOS="${_STORED_INFOS}${message}"
}
echo_note() {
message="${LIGHT_GREEN}$1${NC}\n"
printf "$message"
_STORED_NOTES="${_STORED_NOTES}${message}"
}
# ─< Improved display function that only shows categories with content >──────────────────
display_stored_messages() {
has_messages=0
# ─< First check if we have any messages at all >─────────────────────────────────────────
if [ -z "$_STORED_ERRORS" ] && [ -z "$_STORED_WARNINGS" ] && [ -z "$_STORED_INFOS" ] && [ -z "$_STORED_NOTES" ]; then
return 0
fi
# ─< Now display each non-empty category with proper spacing >────────────────────────────
if [ -n "$_STORED_ERRORS" ]; then
printf "\n${BOLD}${RED}=== Errors ===${NC}\n"
printf "$_STORED_ERRORS"
has_messages=1
fi
if [ -n "$_STORED_WARNINGS" ]; then
[ "$has_messages" -eq 1 ] && printf "\n"
printf "${BOLD}${YELLOW}=== Warnings ===${NC}\n"
printf "$_STORED_WARNINGS"
has_messages=1
fi
if [ -n "$_STORED_INFOS" ]; then
[ "$has_messages" -eq 1 ] && printf "\n"
printf "${BOLD}${CYAN}=== Info ===${NC}\n"
printf "$_STORED_INFOS"
has_messages=1
fi
if [ -n "$_STORED_NOTES" ]; then
[ "$has_messages" -eq 1 ] && printf "\n"
printf "${BOLD}${LIGHT_GREEN}=== Notes ===${NC}\n"
printf "$_STORED_NOTES"
fi
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─< Check if the user is root and set $_sudo variable if necessary >───────────────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_binfo "User is not root. Using $_sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_binfo "Root access confirmed."
_sudo=""
fi
}
# ─< Distribution detection and installation >────────────────────────────────────────
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# ─< Convert $ID and $ID_LIKE to lowercase >──────────────────────────────────────────────
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) install_debian ;;
debian) install_debian ;;
fedora) install_fedora ;;
# alpine) inst_alpine ;;
arch | manjaro | garuda | endeavour) install_arch ;;
# opensuse*) inst_opensuse ;;
*)
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
install_debian
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
install_debian
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
inst_arch
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
install_fedora
# elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
# inst_opensuse
else
echo_error "Unsupported distribution: $ID"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
# Function to add user to the 'libvirt' group and start services
configure_libvirt() {
echo_note "Adding user to 'libvirt' group..."
$_sudo usermod -aG libvirt "$(whoami)"
echo_note "Starting and enabling libvirt service..."
if command -v systemctl &>/dev/null; then
$_sudo systemctl start libvirtd
$_sudo systemctl enable libvirtd
else
echo_warning "systemctl command not found, skipping service management."
fi
echo_note "Configuration complete. You might need to log out and log back in for group changes to take effect."
}
# Install packages for Debian/Ubuntu/Pop!_OS
install_debian() {
echo_info "Updating package list..."
$_sudo apt update -y
echo_info "Installing virt-manager, qemu-full, and related packages..."
$_sudo apt install -y virt-manager qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
echo_note "Installation complete on Debian/Ubuntu/Pop!_OS!"
}
# Install packages for Fedora
install_fedora() {
echo_info "Updating package list..."
$_sudo dnf check-update -y
echo_info "Installing virt-manager, qemu-full, and related packages..."
$_sudo dnf install -y virt-manager qemu-kvm libvirt libvirt-client bridge-utils
echo_note "Installation complete on Fedora!"
}
# Install packages for Arch Linux/Manjaro/EndeavourOS
install_arch() {
echo_info "Updating package list..."
$_sudo pacman -Syu --noconfirm
echo_info "Installing virt-manager, qemu-full, and related packages..."
$_sudo pacman -S --noconfirm virt-manager qemu-full libvirt dnsmasq bridge-utils
echo_note "Installation complete on Arch Linux/Manjaro/EndeavourOS!"
}
# Install packages for openSUSE
install_opensuse() {
echo_info "Updating package list..."
$_sudo zypper refresh
echo_info "Installing virt-manager, qemu-full, and related packages..."
$_sudo zypper install -y virt-manager qemu-kvm libvirt libvirt-client bridge-utils
echo_note "Installation complete on openSUSE!"
}
main() {
check_root &&
get_packager &&
configure_libvirt
display_stored_messages
}
main

187
installs/xmrig.sh Executable file
View file

@ -0,0 +1,187 @@
{
#!/bin/sh
# ANSI color codes
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# Check if the user is root and set sudo variable if necessary
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# < Distribution detection and installation >
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# < Convert $ID and $ID_LIKE to lowercase >
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) _install() {
$_sudo apt-get install "$@" --assume-yes
} ;;
debian) _install() {
$_sudo apt-get install "$@" --assume-yes
} ;;
fedora) _install() {
$_sudo dnf install "$@" -y
} ;;
alpine) _install() {
$_sudo apk add "$@"
} ;;
arch | manjaro | garuda | endeavour) _install() {
$_sudo pacman -S "$@" --noconfirm
} ;;
opensuse*) _install() { $_sudo zypper in "$@" -y; } ;;
*)
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
_install() { $_sudo apt-get install "$@" --assume-yes; }
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
_install() { $_sudo apt-get install "$@" --assume-yes; }
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
_install() { $_sudo pacman -S "$@" --noconfirm; }
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
_install() { $_sudo dnf install "$@" -y; }
elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
_install() { $_sudo zypper in "$@" -y; }
else
echo_error "Unsupported distribution: $ID"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
# Check if a command exists
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# Install dependencies
_dependencies() {
tools="git cmake make"
packages="libuv1-dev libssl-dev libhwloc-dev argon2"
for tool in $tools; do
if command_exists "$tool"; then
echo_note "$tool is already installed"
else
echo_info "Installing $tool.."
_install "$tool" || echo_error "Failed to install $tool"
fi
done
for package in $packages; do
echo_info "Installing $package"
_install "$package" || echo_error "Failed to install $package"
done
echo_note "Dependency check completed!"
}
# Clone the repository and prepare build directory
_git() {
xmrig_dir="$HOME/.bin/xmrig"
if [ -d "$xmrig_dir" ]; then
echo_warning "$xmrig_dir already exists. Skipping clone."
else
echo_info "Cloning xmrig repository to $xmrig_dir"
mkdir -p "$HOME/.bin"
if ! git clone --depth=1 https://github.com/xmrig/xmrig.git "$xmrig_dir"; then
echo_error "Failed to clone xmrig repository."
return 1
fi
fi
build_dir="$xmrig_dir/build"
mkdir -p "$build_dir" || {
echo_error "Failed to create build directory: $build_dir"
return 1
}
cd "$build_dir" || {
echo_error "Failed to navigate to build directory: $build_dir"
return 1
}
}
# Initialize and build the application
_appinit() {
echo_info "Running cmake .."
if ! cmake ..; then
echo_error "CMake failed."
return 1
fi
echo_info "Running make (this could take a while)"
if ! make; then
echo_error "Make failed."
return 1
fi
$_sudo ln -s ./xmrig /usr/bin/xmrig || "Link of application failed hard! Is not accessible at /usr/bin/xmrig"
}
# Main function
main() {
if ! check_root; then
echo_error "Root check failed. Exiting."
return 1
fi
if ! get_packager; then
echo_error "Failed to detect distribution or set packager."
return 1
fi
_dependencies || return 1
if _git; then
_appinit || echo_error "Build initialization failed."
else
echo_error "Failed during Git operations."
fi
}
main
}

149
installs/yazi.sh Normal file
View file

@ -0,0 +1,149 @@
{
#!/bin/sh -e
# ─< ANSI color codes >───────────────────────────────────────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─< Check if the user is root and set sudo variable if necessary >───────────────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
evalCargo() {
if [ -e "$HOME/.cargo/env" ]; then
echo_note "Using $HOME/.cargo/env.."
. "$HOME/.cargo/env"
fi
}
i_cargo() {
# if ! command_exists make || ! command_exists gcc; then
# echo_error "The script might run into issues, because of make and gcc not being installed. Please install it, and run the script again, if it fails!"
# fi
evalCargo
if command_exists cargo; then
echo_info "Installing yazi through cargo"
elif command_exists curl; then
echo_note "no cargo found, using curl to install rustup"
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
evalCargo
rustup update
evalCargo
echo_info "Installing yazi through cargo"
else
echo_warning "neither cargo, nor curl were found. Cannot continue!"
fi
cargo install --locked yazi-fm yazi-cli
c_yazi
}
i_arch() {
$_sudo pacman -S yazi --noconfirm
c_yazi
}
i_opensuse() {
$_sudo zypper install yazi
c_yazi
}
c_yazi() {
if [ -e "$HOME/.config/yazi/package.toml" ]; then
if command_exists ya; then
ya pack -i
fi
else
echo_warning "There was no yazi config found.. "
fi
}
# ─< Distribution detection and installation >────────────────────────────────────────
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# ─< Convert $ID and $ID_LIKE to lowercase >──────────────────────────────────────────────
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) i_cargo ;;
debian) i_cargo ;;
fedora) i_cargo ;;
alpine) i_cargo ;;
arch | manjaro | garuda | endeavour) i_arch ;;
opensuse*) i_opensuse ;;
*)
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
i_cargo
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
i_cargo
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
i_arch
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
i_cargo
elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
i_opensuse
else
echo_error "Unsupported distribution: $ID"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
main() {
if check_root; then
get_packager
fi
}
main
}

157
installs/ytgo.sh Normal file
View file

@ -0,0 +1,157 @@
#!/bin/sh
# ╭───────────────╮
# │ env functions │
# ╰───────────────╯
# ───────────────────────────────────< ANSI color codes >───────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─────────────< Check if the user is root and set sudo variable if necessary >─────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ──────────────────────< Check if the given command exists silently >──────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ╭────────────────────────────────────╮
# │ insert your scripts/functions here │
# ╰────────────────────────────────────╯
# ─< Distribution detection and installation >────────────────────────────────────────
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# ─< Convert $ID and $ID_LIKE to lowercase >──────────────────────────────────────────────
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) _install() {
$_sudo apt-get install --assume-yes "$@"
} ;;
debian) _install() {
$_sudo apt-get install --assume-yes "$@"
} ;;
fedora) _install() {
$_sudo dnf install -y "$@"
} ;;
alpine) inst_alpine ;;
arch | manjaro | garuda | endeavour) _install() {
$_sudo pacman -S --noconfirm "$@"
} ;;
opensuse*) inst_opensuse ;;
*)
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
_install() {
$_sudo apt-get install --assume-yes "$@"
}
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
_install() {
$_sudo apt-get install --assume-yes "$@"
}
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
_install() {
$_sudo pacman -S --noconfirm "$@"
}
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
_install() {
$_sudo dnf install -y "$@"
}
elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
inst_opensuse
else
echo_error "Unsupported distribution: $ID"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
_dependencies() {
get_packager
if [[ "$ID" == "arch" || "$ID_LIKE" == *"arch"* ]]; then
_deps="go git mpv yt-dlp"
else
_deps="golang git mpv yt-dlp"
fi
for dependency in $_deps; do
if ! command_exists "$dependency"; then
echo_info "Installing $dependency"
_install "$dependency" || echo_error "$dependency could not be installed!"
else
echo_note "$dependency - was already installed."
fi
done
}
_clone() {
tmpdir="$(mktemp --dir)"
repo="https://git.k4li.de/pika/ytgo.git"
cd "$tmpdir" || echo_error "$tmpdir is not a valid directory!"
git clone --depth=1 "$repo"
cd ytgo || echo_error "$tmpdir/ytgo is not a valid directory!"
}
_build() {
$_sudo make install
}
# ───────────────────────────────< main function to execute >───────────────────────────────
main() {
if check_root; then
_dependencies || echo_error "dependency function failed hard!"
_clone || echo_error "clone function failed hard!"
_build || echo_error "build function failed hard!"
else
echo_error "Something went terribly wrong!"
fi
}
main

76
logging.sh Normal file
View file

@ -0,0 +1,76 @@
#!/bin/sh
# POSIX-compliant color codes
RED='\033[0;31m'
YELLOW='\033[1;33m'
GREEN='\033[0;32m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
# Simple echo functions without any arrays or typeset
echo_error() {
printf "${RED}❌ %s${NC}\n" "$1" >&2
}
echo_warning() {
printf "${YELLOW}⚠️ %s${NC}\n" "$1"
}
echo_info() {
printf "${GREEN}ℹ️ %s${NC}\n" "$1"
}
echo_note() {
printf "${CYAN}📝 %s${NC}\n" "$1"
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
for i in which command; do
if command_exists $i; then
case $i in
command) command -v "$@" >/dev/null 2>&1 ;;
which) which "$@" >/dev/null 2>&1 ;;
esac
fi
done
}
_cd() {
cd "$1" || { echo_error "Cannot navigate to the directory: $1"; return 1; }
}
_exit() {
echo_error "There was an error, which caused the script to exit immediately"
echo_error "$1"
echo_error "Exiting now!"
exit 1
}
confirm_action() {
read -p "$1 - [y/n]: " confirm
case $confirm in
[yY] ) return 0 ;;
[nN] ) return 1 ;;
* ) echo_warning "Invalid input. Action cancelled." ; return 1 ;;
esac
}
create_dir() {
if [ ! -d "$1" ]; then
echo_info "Creating directory: $1"
mkdir -p "$1" || _exit "Failed to create directory $1"
else
echo_info "Directory $1 already exists"
fi
}
check_disk_space() {
threshold=1000000 # Minimum space in KB (e.g., 1GB)
available_space=$(df / | awk 'NR==2 {print $4}')
if [ "$available_space" -lt "$threshold" ]; then
echo_warning "Not enough disk space. Only $((available_space / 1024))MB remaining."
return 1
fi
echo_info "Sufficient disk space available."
}

203
setup/arch-hyprland.sh Normal file
View file

@ -0,0 +1,203 @@
#!/bin/sh
# ╭───────────────╮
# │ env functions │
# ╰───────────────╯
# ───────────────────────────────────< ANSI color codes >───────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─────────────< Check if the user is root and set sudo variable if necessary >─────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ─< Distribution detection and installation >────────────────────────────────────────
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) _install() { $_sudo apt-get install --assume-yes "$@"; } ;;
debian) _install() { $_sudo apt-get install --assume-yes "$@"; } ;;
fedora) _install() { $_sudo dnf install -y "$@"; } ;;
alpine) _install() { $_sudo apk add "$@"; } ;;
arch | manjaro | garuda | endeavour) _install() { $pkger -S --noconfirm "$@"; } ;;
opensuse*) _install() { $_sudo zypper in -y "$@"; } ;;
*)
if echo "$ID_LIKE" | grep -q "debian"; then
_install() { $_sudo apt-get install --assume-yes "$@"; }
elif echo "$ID_LIKE" | grep -q "ubuntu"; then
_install() { $_sudo apt-get install --assume-yes "$@"; }
elif echo "$ID_LIKE" | grep -q "arch"; then
_install() { $pkger -S --noconfirm "$@"; }
elif echo "$ID_LIKE" | grep -q "fedora"; then
_install() { $_sudo dnf install -y "$@"; }
elif echo "$ID_LIKE" | grep -q "suse"; then
_install() { $_sudo zypper in -y "$@"; }
else
echo_error "Unsupported distribution: $ID"
return 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
return 1
fi
}
# ──────────────────────< Check if the given command exists silently >──────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
check_aur() {
if ! command_exists yay; then
echo_error "Yay was not found.. looking for paru instead"
if ! command_exists paru; then
echo_error "No AUR helper found, please install before continuing!"
exit 1
else
echo_info "Found paru, using it.."
pkger="paru"
fi
exit 1
else
echo_info "Found yay, using it.."
pkger="yay"
fi
}
check_deps() {
deps="
hyprland
hyprpicker
hyprlang
hyprutils
hyprwayland-scanner
xdg-desktop-portal-hyprland
$BarOfChoise
swww
rofi
wlogout
libnotify
"
for dependency in $deps; do
if ! command_exists "$dependency"; then
echo_note "Installing $dependency.."
_install "$dependency"
else
echo_info "$dependency is already installed"
fi
done
}
ask_bar() {
echo_note "Which bar do you want to use?"
echo_note "[g]Bar, [H]yprpanel, [W]aybar"
read -r ask_bar </dev/tty
case "$ask_bar" in
g | G | gbar | gBar)
BarOfChoise="gBar"
;;
h | H | Hyprpanel | hyprpanel | hypr | Hypr)
BarOfChoise="ags-hyprpanel-git"
;;
w | W | waybar | Waybar)
BarOfChoise="waybar"
;;
*)
echo_error "You did not select something useful! Try again!"
ask_bar
;;
esac
}
ask_dotfiles() {
if [ ! -d "$HOME/.config/hypr" ]; then
echo_note "Do you want to install the custom pika hyprdots?"
echo_note "[Y/n]"
read -r ask_dotfiles </dev/tty
case "$ask_dotfiles" in
n | N)
echo_info "Finishing config now"
;;
*)
if ! command_exists git; then
_install git
fi
if [ ! -d "$HOME/git" ]; then
mkdir -p "$HOME/git"
fi
git clone --recursive --depth=1 https://git.k4li.de/dotfiles/hyprdots.git "$HOME/git/hyprdots"
cd "$HOME/git/hyprdots" || echo_error "Directory of choise doesnt work.."
make
;;
esac
fi
}
# ╭────────────────────────────────────╮
# │ insert your scripts/functions here │
# ╰────────────────────────────────────╯
# ───────────────────────────────< main function to execute >───────────────────────────────
main() {
if check_root; then
if check_aur; then
get_packager
fi
else
echo_error "Something went terribly wrong!"
exit 1
fi
ask_bar
check_deps
ask_dotfiles
}
if ! command_exists hyprland; then
main
else
echo_warning "Hyprland is already installed!"
fi

157
setup/debian-major.sh Normal file
View file

@ -0,0 +1,157 @@
#!/bin/sh
# ╭───────────────╮
# │ env functions │
# ╰───────────────╯
# ───────────────────────────────────< ANSI color codes >───────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─────────────< Check if the user is root and set sudo variable if necessary >─────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ──────────────────────< Check if the given command exists silently >──────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ╭────────────────────────────────────╮
# │ insert your scripts/functions here │
# ╰────────────────────────────────────╯
full_update_and_upgrade() {
if command_exists apt-get; then
echo_info "Updating sources.."
$_sudo apt-get update || echo_error "Something went wrong, please check your connection and permissions!"
$_sudo apt-get upgrade --assume-yes || echo_error "Something went wrong, please check your connection and permissions!"
$_sudo apt-get full-upgrade --assume-yes || echo_error "Something went wrong, please check your connection and permissions!"
else
echo_error "The OS is not suitable for this script!"
fi
}
clean_and_full_upgrade() {
if command_exists apt-get; then
echo_info "Cleaning the environment.."
$_sudo apt-get clean --assume-yes
full_update_and_upgrade
else
echo_error "The OS is not suitable for this script!"
fi
}
post_clean() {
if command_exists apt-get; then
$_sudo apt-get autoremove --assume-yes
else
echo_error "The OS is not suitable for this script!"
fi
}
detect_version() {
. /etc/os-release
case "$VERSION_CODENAME" in
bookworm)
cur_os="bookworm"
tar_os="trixie"
;;
buster)
cur_os="buster"
tar_os="bullseye"
;;
bullseye)
cur_os="bullseye"
tar_os="bookworm"
;;
*)
echo_error "$VERSION_CODENAME is either not a debian version, or just simply not defined"
return 1
;;
esac
}
update_sources() {
# Create backup directory if it doesn't exist
BACKUP_DIR="/var/backups/apt-sources"
echo_info "Creating backup directory at $BACKUP_DIR..."
$_sudo mkdir -p "$BACKUP_DIR"
echo_info "Backing up current sources lists..."
$_sudo cp /etc/apt/sources.list "$BACKUP_DIR/sources.list.backup.$(date +%Y%m%d)"
echo_info "Updating sources from Bookworm to Trixie..."
# Replace bookworm with trixie in main sources.list
$_sudo sed -i "s/$cur_os/$tar_os/g" /etc/apt/sources.list
# Check and update any additional source files in sources.list.d
if [ -d "/etc/apt/sources.list.d" ]; then
for sourcefile in /etc/apt/sources.list.d/*.list; do
if [ -f "$sourcefile" ]; then
filename=$(basename "$sourcefile")
echo_info "Backing up and updating $sourcefile..."
$_sudo cp "$sourcefile" "$BACKUP_DIR/${filename}.backup.$(date +%Y%m%d)"
$_sudo sed -i "s/$cur_os/$tar_os/g" "$sourcefile"
fi
done
fi
echo_note "Sources have been updated to Trixie. Please run a full system update."
echo_warning "Make sure to review the changes and ensure all repositories are compatible with Trixie!"
echo_info "Backups stored in $BACKUP_DIR"
echo ""
__lsb_release__="$(lsb_release -a)"
echo_info "$__lsb_release__"
}
# ───────────────────────────────< main function to execute >───────────────────────────────
main() {
if check_root; then
full_update_and_upgrade
if detect_version; then
update_sources
fi
clean_and_full_upgrade
post_clean
else
echo_error "Something went terribly wrong!"
fi
}
main

110
setup/docker-network.sh Normal file
View file

@ -0,0 +1,110 @@
#!/bin/sh
# ╭───────────────╮
# │ env functions │
# ╰───────────────╯
# ───────────────────────────────────< ANSI color codes >───────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─────────────< Check if the user is root and set sudo variable if necessary >─────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ──────────────────────< Check if the given command exists silently >──────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ╭────────────────────────────────────╮
# │ insert your scripts/functions here │
# ╰────────────────────────────────────╯
# Function to initialize or update the Docker daemon configuration
dnetwork_init() {
if ! command_exists docker; then
echo_error "No docker was found! Cannot continue!"
return 1
fi
CONFIG_FILE="/etc/docker/daemon.json"
echo_info "Checking Docker daemon configuration..."
# Check if the configuration file exists
if [ ! -f "$CONFIG_FILE" ]; then
echo_warning "Docker daemon configuration file not found. Creating it."
${_sudo} mkdir -p /etc/docker
${_sudo} tee "$CONFIG_FILE" >/dev/null <<EOF
{
"default-address-pools": [
{
"base": "10.0.0.0/8",
"size": 24
}
]
}
EOF
echo_note "Configuration file created with default network."
else
# Check if the "default-address-pools" entry exists
if grep -q '"default-address-pools"' "$CONFIG_FILE"; then
echo_note "Docker daemon configuration already contains 'default-address-pools'. No changes made."
else
echo_warning "Adding 'default-address-pools' to existing configuration."
${_sudo} jq '. + {"default-address-pools": [{"base": "10.0.0.0/8", "size": 24}]}' "$CONFIG_FILE" | ${_sudo} tee "$CONFIG_FILE.tmp" >/dev/null
${_sudo} mv "$CONFIG_FILE.tmp" "$CONFIG_FILE"
echo_note "Default address pool added to configuration."
fi
fi
echo_info "Restarting Docker to apply changes..."
${_sudo} systemctl restart docker && echo_note "Docker restarted successfully." || echo_error "Failed to restart Docker."
}
# ───────────────────────────────< main function to execute >───────────────────────────────
main() {
if check_root; then
dnetwork_init
else
echo_error "Something went terribly wrong!"
fi
}
main

369
setup/postinstall.sh Executable file
View file

@ -0,0 +1,369 @@
{
#!/bin/sh -e
# ╭──────────────╮
# │ dependencies │
# ╰──────────────╯
deps="
7zip
bc
btop
exa
fzf
gawk
gdu
git
make
pv
ripgrep
rsync
stow
tmux
trash-cli
unzip
zoxide
zsh
"
# ╭─────────────╮
# │ ENVIRONMENT │
# ╰─────────────╯
# ANSI color codes
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m'
# Initialize storage variables
_STORED_ERRORS=""
_STORED_WARNINGS=""
_STORED_INFOS=""
_STORED_NOTES=""
# Modified echo functions that store and display messages
echo_error() {
message="${RED}$1${NC}\n"
printf "$message" >&2
_STORED_ERRORS="${_STORED_ERRORS}${message}"
}
echo_warning() {
message="${YELLOW}$1${NC}\n"
printf "$message"
_STORED_WARNINGS="${_STORED_WARNINGS}${message}"
}
echo_info() {
message="${CYAN}$1${NC}\n"
printf "$message"
_STORED_INFOS="${_STORED_INFOS}${message}"
}
echo_note() {
message="${LIGHT_GREEN}$1${NC}\n"
printf "$message"
_STORED_NOTES="${_STORED_NOTES}${message}"
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─────────────────────────────────────< get packager >─────────────────────────────────────
checkPkg() {
for pkg in apt-get dnf pacman apk zypper; do
if command_exists $pkg; then
printf "Using ${RED}${pkg}${NC} method.."
pkger="$pkg"
fi
done
}
# ─────────────────────────────────< check for root/sudo >───────────────────────────────
checkRoot() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo -E"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ╭─────╮
# │ apt │
# ╰─────╯
aptCommentCDinSources() {
# Path to sources.list
sources_file="/etc/apt/sources.list"
# Check if file exists
if [ ! -f "$sources_file" ]; then
echo_error "Error: $sources_file not found"
return 1
fi
# Comment out CD-ROM entries using sudo
$_sudo sed -i 's/^[[:space:]]*deb[[:space:]]\+cdrom:/#&/' "$sources_file"
echo_info "CD-ROM entries have been commented out in $sources_file"
}
aptBase() {
aptCommentCDinSources
echo_info "Updating sources.."
if ! $_sudo apt-get update; then
echo_error "Maybe you need a proxy?"
exit 1
fi
if ! command_exists sudo; then
echo_note "Installing sudo"
apt-get install sudo --assume-yes
fi
echo_note "Installing base packages: $deps"
for _deps in $deps; do
if ! command_exists "$_deps"; then
echo_info "Installing $_deps.."
if ! $_sudo apt-get install "$_deps" --assume-yes; then
echo_error "$_deps - failed to install!"
fi
else
echo_note "$_deps - was already installed!"
fi
done
}
aptOptimize() {
if command_exists nala; then
echo_info "Nala is already present, fetching mirros now! (This might take a minute or two, depending on your internet speed)"
$_sudo nala fetch --auto --assume-yes --https-only
else
echo_note "Nala is not installed on the system, do you want to install it now? (Y/n): "
read -r inst_nala </dev/tty
case "$inst_nala" in
N | n)
echo_warning "All right, continue without nala!"
;;
*)
echo_note "Installing nala.."
$_sudo apt-get install nala --assume-yes &&
echo_info "Fetching best mirrors"
$_sudo nala fetch --auto --assume-yes --https-only
;;
esac
fi
}
# ╭────────╮
# │ pacman │
# ╰────────╯
pacmanBase() {
if command_exists nano; then
if command_exists vim; then
echo_note "Removing nano, vim is backup"
$_sudo pacman -R nano --noconfirm
else
echo_note "Removing nano and installing vim as a backup"
$_sudo pacman -S vim --noconfirm
fi
fi
$_sudo pacman -S base-devel --noconfirm
echo_note "Installing base packages: $deps"
for _deps in $deps; do
if ! command_exists "$_deps"; then
if ! $_sudo pacman -S "$_deps" --noconfirm; then
echo_error "$_deps - failed to install"
fi
else
echo_note "$_deps - was already installed"
fi
done
}
# ╭─────╮
# │ dnf │
# ╰─────╯
dnfBase() {
echo_info "Updating sources.."
if ! $_sudo dnf update; then
echo_error "Maybe you need a proxy?"
exit 1
fi
echo_note "Installing base packages: $deps"
for _deps in $deps; do
if ! command_exists "$_deps"; then
echo_info "Installing $_deps.."
if ! $_sudo dnf install "$_deps"; then
echo_error "$_deps - failed to install!"
fi
else
echo_note "$_deps - was already installed!"
fi
done
}
# ╭────────╮
# │ zypper │
# ╰────────╯
zypperBase() {
echo_info "Updating sources.."
if ! $_sudo zypper ref; then
echo_error "Maybe you need a proxy?"
exit 1
fi
echo_note "Installing base packages: $deps"
for _deps in $deps; do
if ! command_exists "$_deps"; then
echo_info "Installing $_deps.."
if ! $_sudo zypper in "$_deps"; then
echo_error "$_deps - failed to install!"
fi
else
echo_note "$_deps - was already installed!"
fi
done
}
# ╭───────────╮
# │ FUNCTIONS │
# ╰───────────╯
envCheck() {
checkRoot
checkPkg
}
install_base() {
envCheck
echo_info "Installing base packages..."
case "$pkger" in
apt)
echo_info "apt"
aptBase
;;
dnf)
echo_info "dnf"
dnfBase
;;
pacman)
echo_info "pacman"
pacmanBase
;;
zypper)
echo_info "zypper"
zypperBase
;;
apk) ;;
esac
}
optimize_os() {
envCheck
echo_info "Running OS optimizations..."
case "$pkg" in
apt)
aptOptimize
;;
dnf)
echo_warning "Currently, there are no optimizations for your linux distribution."
;;
pacman)
echo_warning "Currently, there are no optimizations for your linux distribution."
;;
zypper)
echo_warning "Currently, there are no optimizations for your linux distribution."
;;
apk)
echo_warning "Currently, there are no optimizations for your linux distribution."
;;
esac
}
# setup_vpn() {
# echo_info "Setting up VPN..."
# # Add VPN setup logic here
# }
# ╭──────────╮
# │ ARGUMENTS │
# ╰──────────╯
show_help() {
echo "Usage: $0 [OPTIONS]"
echo " --install-base Install base packages"
echo " --optimize-os Optimize the OS"
echo " --all Uses all flags together"
# echo " --setup-vpn Setup VPN"
echo " --help Show this help message"
echo ""
echo "If you 'curl | sh' this script, then replace 'sh' with 'sh -s -- [OPTIONS]'"
printf "So for example ${CYAN} curl https://path/to/postinstall.sh | sh -s -- --all ${NC}"
}
# Default to no options
INSTALL_BASE=false
OPTIMIZE_OS=false
# SETUP_VPN=false
# Parse command-line arguments
while [ "$#" -gt 0 ]; do
case "$1" in
--install-base)
INSTALL_BASE=true
;;
--optimize-os)
OPTIMIZE_OS=true
;;
--all)
OPTIMIZE_OS=true
INSTALL_BASE=true
;;
# --setup-vpn)
# SETUP_VPN=true
# ;;
--help)
show_help
exit 0
;;
*)
echo_error "Unknown option: $1"
show_help
exit 1
;;
esac
shift
done
# Execute selected options
$OPTIMIZE_OS && optimize_os
$INSTALL_BASE && install_base
# $SETUP_VPN && setup_vpn
# If no options were provided, show help
if [ "$INSTALL_BASE" = false ] && [ "$OPTIMIZE_OS" = false ]; then # && [ "$SETUP_VPN" = false ]; then
show_help
exit 1
fi
}

143
setup/realmjoin.sh Normal file
View file

@ -0,0 +1,143 @@
#!/bin/sh -e
# ╭───────────────╮
# │ env functions │
# ╰───────────────╯
# ───────────────────────────────────< ANSI color codes >───────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ────────────────< function to check if the given command exists silently >────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─────────────< Check if the user is root and set sudo variable if necessary >─────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ─< Distribution detection and installation >────────────────────────────────────────
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) _install() { $_sudo apt-get install --assume-yes "$@"; } ;;
debian) _install() { $_sudo apt-get install --assume-yes "$@"; } ;;
fedora) _install() { $_sudo dnf install -y "$@"; } ;;
alpine) _install() { $_sudo apk add "$@"; } ;;
arch | manjaro | garuda | endeavour) _install() { $_sudo pacman -S --noconfirm "$@"; } ;;
opensuse*) _install() { $_sudo zypper in -y "$@"; } ;;
*)
if echo "$ID_LIKE" | grep -q "debian"; then
_install() { $_sudo apt-get install --assume-yes "$@"; }
elif echo "$ID_LIKE" | grep -q "ubuntu"; then
_install() { $_sudo apt-get install --assume-yes "$@"; }
elif echo "$ID_LIKE" | grep -q "arch"; then
_install() { $_sudo pacman -S --noconfirm "$@"; }
elif echo "$ID_LIKE" | grep -q "fedora"; then
_install() { $_sudo dnf install -y "$@"; }
elif echo "$ID_LIKE" | grep -q "suse"; then
_install() { $_sudo zypper in -y "$@"; }
else
echo_error "Unsupported distribution: $ID"
return 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
return 1
fi
}
# ──────────────────────────< define your functions/script here >────────────────────────
dependencies() {
_deps="krb5-user realmd sssd-tools sssd libnss-sss libpam-sss adcli"
for dependency in $_deps; do
if ! command_exists "$dependency"; then
echo_info "Installing $dependency.."
sleep 0.3
if ! _install "$dependency"; then
echo_error "$dependency - could not be installed!"
else
echo_note "$dependency - was installed successfully!"
fi
else
echo_note "$dependency is already installed."
fi
done
}
_join() {
domain="swu.dom"
echo_note "You are trying to connect to $domain.."
sleep 1
echo_note "Please enter an administrator user like this: [example-user]"
printf "Admin User: " >&2
read -r _admin </dev/tty
if [ -n "$_admin" ]; then
if realm join -v -U "$_admin@$domain" "$domain"; then
echo_note "Successfully joined domain $domain."
else
echo_error "Failed to join domain $domain."
return 1
fi
else
echo_error "Administrator username cannot be empty."
return 1
fi
}
# ───────────────────────────────< define the main function >───────────────────────────────
main() {
if check_root; then
get_packager &&
dependencies &&
_join
else
echo_error "Root privileges are required. Exiting."
return 1
fi
}
# ──────────────────────────────< execute the main function >────────────────────────────
main

86
setup/unattendet-upgrades.sh Normal file
View file

@ -0,0 +1,86 @@
#!/bin/sh -e
LOG_FILE="/var/log/unattended-upgrades-check.log"
# Colors
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
run_checks() {
echo_info "Checking if unattended-upgrades is active..."
if command_exists unattended-upgrades; then
# if dpkg-query -W -f='${Status}' unattended-upgrades 2>/dev/null | grep -q "install ok installed"; then
echo_note "unattended-upgrades is already installed."
else
echo_warning "unattended-upgrades is not installed. Attempting to install..."
if command_exists apt-get; then
if apt-get update && apt-get install --assume-yes unattended-upgrades; then
echo_note "unattended-upgrades successfully installed."
else
echo_error "Failed to install unattended-upgrades. Exiting."
exit 1
fi
else
echo_error "apt is not available on this system. Exiting."
exit 1
fi
fi
# Enable unattended-upgrades
UNATTENDED_UPGRADES_FILE="/etc/apt/apt.conf.d/50unattended-upgrades"
if [ -f "$UNATTENDED_UPGRADES_FILE" ]; then
echo_info "Configuring unattended upgrades in $UNATTENDED_UPGRADES_FILE"
# Add or modify configurations as needed
# Example: $_sudo sed -i 's/old_value/new_value/' "$UNATTENDED_UPGRADES_FILE"
else
echo_error "Unattended upgrades file not found!"
fi
}
run_setup() {
if command_exists unattended-upgrades; then
systemctl enable --now unattended-upgrades || echo_error "Something went wrong! Could not setup the service/autostart"
fi
}
# Main script
main() {
echo_info "Starting unattended-upgrades check script..."
if [ "$(id -u)" -ne 0 ]; then
echo_error "This script must be run as root. Please run with sudo."
exit 1
fi
run_checks
run_setup && echo_note "Script completed successfully!"
}
main

157
setup/updates.sh Executable file
View file

@ -0,0 +1,157 @@
#!/bin/sh
# ─< ANSI color codes >───────────────────────────────────────────────────────────────────
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
LIGHT_GREEN='\033[0;92m'
BOLD='\033[1m'
NC='\033[0m' # No Color
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# ─< Check if the given command exists silently >─────────────────────────────────────────
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# ─< Check if the user is root and set sudo variable if necessary >───────────────────────
check_root() {
if [ "$(id -u)" -ne 0 ]; then
if command_exists sudo; then
echo_info "User is not root. Using sudo for privileged operations."
_sudo="sudo"
else
echo_error "No sudo found and you're not root! Can't install packages."
return 1
fi
else
echo_info "Root access confirmed."
_sudo=""
fi
}
# ─< Distribution detection and installation >────────────────────────────────────────
get_packager() {
if [ -e /etc/os-release ]; then
echo_info "Detecting distribution..."
. /etc/os-release
# ─< Convert $ID and $ID_LIKE to lowercase >──────────────────────────────────────────────
ID=$(printf "%s" "$ID" | tr '[:upper:]' '[:lower:]')
ID_LIKE=$(printf "%s" "$ID_LIKE" | tr '[:upper:]' '[:lower:]')
case "$ID" in
ubuntu | pop) packager="apt" ;;
debian) packager="apt" ;;
fedora) packager="dnf" ;;
alpine) packager="apk" ;;
arch | manjaro | garuda | endeavour) packager="pacman" ;;
opensuse*) packager="zypper" ;;
*)
if [ "${ID_LIKE#*debian}" != "$ID_LIKE" ]; then
packager="apt"
elif [ "${ID_LIKE#*ubuntu}" != "$ID_LIKE" ]; then
packager="apt"
elif [ "${ID_LIKE#*arch}" != "$ID_LIKE" ]; then
packager="pacman"
elif [ "${ID_LIKE#*fedora}" != "$ID_LIKE" ]; then
packager="dnf"
elif [ "${ID_LIKE#*suse}" != "$ID_LIKE" ]; then
packager="zypper"
else
echo_error "Unsupported distribution: $ID"
exit 1
fi
;;
esac
else
echo_error "Unable to detect distribution. /etc/os-release not found."
exit 1
fi
}
_update() {
case "$packager" in
apt)
if command_exists nala; then
echo_note "Using nala to update packages.. Please be patient.."
sleep 1
$_sudo nala update
$_sudo nala upgrade -y
$_sudo nala autoremove -y
$_sudo apt-get autoclean -y
else
echo_note "Using nala to update packages.. Please be patient.."
sleep 1
$_sudo apt-get update
$_sudo apt-get upgrade -y
$_sudo apt-get autoremove -y
$_sudo apt-get autoclean -y
fi
;;
dnf)
echo_note "Using dnf to update packages.. Please be patient.."
sleep 1
$_sudo dnf update
;;
pacman)
echo_note "Using pacman to update packages.. Please be patient.."
sleep 1
$_sudo pacman -Syu --noconfirm
;;
apk)
echo_note "Using apk to update packages.. Please be patient.."
sleep 1
$_sudo apk update
$_sudo apk upgrade
;;
zypper)
echo_note "Using zypper to update packages.. Please be patient.."
sleep 1
$_sudo zypper dup
;;
*)
if [ -z "$packager" ]; then
echo_error "The packager variable is not declared.."
else
echo_error "$packager is not a known packager.."
fi
;;
esac
}
_flatpak() {
if command_exists flatpak; then
echo_info "Trying to update flatpaks.."
sleep 1
flatpak update
else
echo_note "No flatpaks found"
fi
}
main() {
check_root
sleep 1
if get_packager; then
_update
_flatpak
fi
}
main