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

batman

Browse source
This commit is contained in:
pika 2025-04-14 09:22:15 +02:00
commit cc8ffcfcc2
38 changed files with 6046 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
bash/README.md Normal file
View file

@ -0,0 +1,2 @@
# bash

190
bash/arch-hyprland.sh Normal file
View file

@ -0,0 +1,190 @@
#!/bin/bash -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
# ERROR: -- Message
echo_error() {
printf "${BOLD}${RED}ERROR: ${NC}${RED}%s${NC}\n" "$1" >&2
}
# INFO: -- Message
echo_info() {
printf "${BOLD}${CYAN}INFO: ${NC}${CYAN}%s${NC}\n" "$1"
}
# WARNING: -- Message
echo_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
# NOTE: -- Message
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() {
$_sudo pacman -Sy
if command_exists paru; then
_install() { paru -S --noconfirm "$@"; }
elif command_exists yay; then
_install() { yay -S --noconfirm "$@"; }
elif command_exists pacman; then
_install() { "$_sudo" pacman -S --noconfirm "$@"; }
fi
}
check_deps() {
deps=(
"hyprland"
"hyprpicker"
"hyprlang"
"hyprutils"
"hyprwayland-scanner"
"xdg-desktop-portal-hyprland"
"$BarOfChoise"
"${MenuOfChoise[@]}"
"swww"
"wlogout"
"libnotify"
)
for dependency in "${deps[@]}"; do
if ! command_exists "$dependency"; then
echo_note "Installing $dependency.."
_install "$dependency" || echo_error "Error installing $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_menu() {
echo_note "Which menu do you want to install?"
echo_note "[r]ofi, [t]tofi, [b]oth"
read -r askMenu </dev/tty
case "$askMenu" in
[rR] | rofi)
MenuOfChoise="rofi"
;;
[tT] | tofi)
MenuOfChoise="tofi"
;;
[bB] | both)
MenuOfChoise=("tofi" "rofi")
;;
*)
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
local gitDir=""
echo_note "What is your preferred git directory?"
read -r gitDir </dev/tty
if [ ! -d "$gitDir" ]; then
mkdir -p "$gitDir"
fi
if [[ ! -d "$gitDir/dotfiles" ]]; then
git clone --recursive --depth=1 https://git.k4li.de/dotfiles/hyprdots.git "$gitDir/dotfiles"
cd "$gitDir/dotfiles" || echo_error "Directory of choise doesnt work.."
make
else
git clone --recursive --depth=1 https://git.k4li.de/dotfiles/hyprdots.git "$gitDir/dotfiles/hyprdots" || echo_error "this directory is not empty.."
cd "$gitDir/dotfiles/hyprdots" || echo_error "Directory of choise doesnt work.."
make
fi
;;
esac
fi
}
# ───────────────────────────────< 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
ask_menu
check_deps
ask_dotfiles
}
if ! command_exists hyprland; then
main
else
echo_warning "Hyprland is already installed!"
fi

106
bash/bash_tui.sh Executable file
View file

@ -0,0 +1,106 @@
#!/bin/bash
# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Menu options
declare -a options=(
"Dotfiles"
"CLI Tool Installation"
"Sudo-Options"
"Optimizations"
"Exit"
)
# declare -a options="Dotfiles CLI_Tool_Installation Sudo-Options Optimizations Exit"
# Function to print colored text
print_color() {
printf "%b%s%b\n" "$1" "$2" "$NC"
}
# Function to display the menu
display_menu() {
clear
print_color "$BLUE" "=== Environment Setup Menu ==="
for i in "${!options[@]}"; do
if [[ $i -eq $selected ]]; then
print_color "$GREEN" "> ${options[$i]}"
else
echo " ${options[$i]}"
fi
done
}
# Function to handle dotfiles setup
dotfiles_setup() {
print_color "$YELLOW" "Setting up dotfiles..."
# Add your dotfiles setup logic here
sleep 2
}
# Function to handle CLI tool installation
cli_tool_installation() {
print_color "$YELLOW" "Installing CLI tools..."
# Add your CLI tool installation logic here
sleep 2
}
# Function to handle optimizations
optimizations() {
print_color "$YELLOW" "Performing optimizations..."
# Add your optimization logic here
sleep 2
}
sudo_options() {
if [[ -e /etc/sudoers ]]; then
echo "Defaults pwfeedback" | tee -a /etc/sudoers
echo "Defaults insults" | tee -a /etc/sudoers
else
echo_error "There is no /etc/sudoers file."
fi
}
# Main menu loop
main_menu() {
local selected=0
local key=""
while true; do
display_menu
# Read a single character
read -rsn1 key
case $key in
A | k) # Up arrow or k
((selected--))
if [[ $selected -lt 0 ]]; then
selected=$((${#options[@]} - 1))
fi
;;
B | j) # Down arrow or j
((selected++))
if [[ $selected -ge ${#options[@]} ]]; then
selected=0
fi
;;
"") # Enter key
case $selected in
0) dotfiles_setup ;;
1) cli_tool_installation ;;
2) sudo_options ;;
3) optimizations ;;
4) exit 0 ;;
esac
;;
esac
done
}
# Start the main menu
main_menu </dev/tty

157
bash/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
bash/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

3
bash/fix.sh Normal file
View file

@ -0,0 +1,3 @@
#!/usr/bin/env bash
sudo reflector --verbose --latest 10 --sort rate --save /etc/pacman.d/mirrorlist

378
bash/games/2048.sh Executable file
View file

@ -0,0 +1,378 @@
#!/usr/bin/env bash
#important variables
declare -ia board # array that keeps track of game status
declare -i pieces # number of pieces present on board
declare -i score=0 # score variable
declare -i flag_skip # flag that prevents doing more than one operation on
# single field in one step
declare -i moves # stores number of possible moves to determine if player lost
# the game
declare ESC=$'\e' # escape byte
declare header="Bash 2048 v1.1 (https://github.com/mydzor/bash2048)"
declare -i start_time=$(date +%s)
#default config
declare -i board_size=4
declare -i target=2048
declare -i reload_flag=0
declare config_dir="$HOME/.bash2048"
#for colorizing numbers
declare -a colors
colors[2]=33 # yellow text
colors[4]=32 # green text
colors[8]=34 # blue text
colors[16]=36 # cyan text
colors[32]=35 # purple text
colors[64]="33m\033[7" # yellow background
colors[128]="32m\033[7" # green background
colors[256]="34m\033[7" # blue background
colors[512]="36m\033[7" # cyan background
colors[1024]="35m\033[7" # purple background
colors[2048]="31m\033[7" # red background (won with default target)
exec 3>/dev/null # no logging by default
trap "end_game 0 1" INT #handle INT signal
#simplified replacement of seq command
function _seq {
local cur=1
local max
local inc=1
case $# in
1) let max=$1 ;;
2)
let cur=$1
let max=$2
;;
3)
let cur=$1
let inc=$2
let max=$3
;;
esac
while test $max -ge $cur; do
printf "$cur "
let cur+=inc
done
}
# print currect status of the game, last added pieces are marked red
function print_board {
clear
printf "$header pieces=$pieces target=$target score=$score\n"
printf "Board status:\n" >&3
printf "\n"
printf '/------'
for l in $(_seq 1 $index_max); do
printf '+------'
done
printf '\\\n'
for l in $(_seq 0 $index_max); do
printf '|'
for m in $(_seq 0 $index_max); do
if let ${board[l * $board_size + m]}; then
if let '(last_added==(l*board_size+m))|(first_round==(l*board_size+m))'; then
printf '\033[1m\033[31m %4d \033[0m|' ${board[l * $board_size + m]}
else
printf "\033[1m\033[${colors[${board[l * $board_size + m]}]}m %4d\033[0m |" ${board[l * $board_size + m]}
fi
printf " %4d |" ${board[l * $board_size + m]} >&3
else
printf ' |'
printf ' |' >&3
fi
done
let l==$index_max || {
printf '\n|------'
for l in $(_seq 1 $index_max); do
printf '+------'
done
printf '|\n'
printf '\n' >&3
}
done
printf '\n\\------'
for l in $(_seq 1 $index_max); do
printf '+------'
done
printf '/\n'
}
# Generate new piece on the board
# inputs:
# $board - original state of the game board
# $pieces - original number of pieces
# outputs:
# $board - new state of the game board
# $pieces - new number of pieces
function generate_piece {
while true; do
let pos=RANDOM%fields_total
let board[$pos] || {
let value=RANDOM%10?2:4
board[$pos]=$value
last_added=$pos
printf "Generated new piece with value $value at position [$pos]\n" >&3
break
}
done
let pieces++
}
# perform push operation between two pieces
# inputs:
# $1 - push position, for horizontal push this is row, for vertical column
# $2 - recipient piece, this will hold result if moving or joining
# $3 - originator piece, after moving or joining this will be left empty
# $4 - direction of push, can be either "up", "down", "left" or "right"
# $5 - if anything is passed, do not perform the push, only update number
# of valid moves
# $board - original state of the game board
# outputs:
# $change - indicates if the board was changed this round
# $flag_skip - indicates that recipient piece cannot be modified further
# $board - new state of the game board
function push_pieces {
case $4 in
"up")
let "first=$2*$board_size+$1"
let "second=($2+$3)*$board_size+$1"
;;
"down")
let "first=(index_max-$2)*$board_size+$1"
let "second=(index_max-$2-$3)*$board_size+$1"
;;
"left")
let "first=$1*$board_size+$2"
let "second=$1*$board_size+($2+$3)"
;;
"right")
let "first=$1*$board_size+(index_max-$2)"
let "second=$1*$board_size+(index_max-$2-$3)"
;;
esac
let ${board[$first]} || {
let ${board[$second]} && {
if test -z $5; then
board[$first]=${board[$second]}
let board[$second]=0
let change=1
printf "move piece with value ${board[$first]} from [$second] to [$first]\n" >&3
else
let moves++
fi
return
}
return
}
let ${board[$second]} && let flag_skip=1
let "${board[$first]}==${board[second]}" && {
if test -z $5; then
let board[$first]*=2
let "board[$first]==$target" && end_game 1
let board[$second]=0
let pieces-=1
let change=1
let score+=${board[$first]}
printf "joined piece from [$second] with [$first], new value=${board[$first]}\n" >&3
else
let moves++
fi
}
}
function apply_push {
printf "\n\ninput: $1 key\n" >&3
for i in $(_seq 0 $index_max); do
for j in $(_seq 0 $index_max); do
flag_skip=0
let increment_max=index_max-j
for k in $(_seq 1 $increment_max); do
let flag_skip && break
push_pieces $i $j $k $1 $2
done
done
done
}
function check_moves {
let moves=0
apply_push up fake
apply_push down fake
apply_push left fake
apply_push right fake
}
function key_react {
let change=0
read -d '' -sn 1
test "$REPLY" = "$ESC" && {
read -d '' -sn 1 -t1
test "$REPLY" = "[" && {
read -d '' -sn 1 -t1
case $REPLY in
A) apply_push up ;;
B) apply_push down ;;
C) apply_push right ;;
D) apply_push left ;;
esac
}
} || {
case $REPLY in
k) apply_push up ;;
j) apply_push down ;;
l) apply_push right ;;
h) apply_push left ;;
w) apply_push up ;;
s) apply_push down ;;
d) apply_push right ;;
a) apply_push left ;;
esac
}
}
function save_game {
rm -rf "$config_dir"
mkdir "$config_dir"
echo "${board[@]}" >"$config_dir/board"
echo "$board_size" >"$config_dir/board_size"
echo "$pieces" >"$config_dir/pieces"
echo "$target" >"$config_dir/target"
# echo "$log_file" > "$config_dir/log_file"
echo "$score" >"$config_dir/score"
echo "$first_round" >"$config_dir/first_round"
}
function reload_game {
printf "Loading saved game...\n" >&3
if test ! -d "$config_dir"; then
return
fi
board=($(cat "$config_dir/board"))
board_size=($(cat "$config_dir/board_size"))
board=($(cat "$config_dir/board"))
pieces=($(cat "$config_dir/pieces"))
first_round=($(cat "$config_dir/first_round"))
target=($(cat "$config_dir/target"))
score=($(cat "$config_dir/score"))
fields_total=board_size*board_size
index_max=board_size-1
}
function end_game {
# count game duration
end_time=$(date +%s)
let total_time=end_time-start_time
print_board
printf "Your score: $score\n"
printf "This game lasted "
$(date --version >/dev/null 2>&1)
if [[ "$?" -eq 0 ]]; then
date -u -d @${total_time} +%T
else
date -u -r ${total_time} +%T
fi
stty echo
let $1 && {
printf "Congratulations you have achieved $target\n"
exit 0
}
let test -z $2 && {
read -n1 -p "Do you want to overwrite saved game? [y|N]: "
test "$REPLY" = "Y" || test "$REPLY" = "y" && {
save_game
printf "\nGame saved. Use -r option next to load this game.\n"
exit 0
}
test "$REPLY" = "" && {
printf "\nGame not saved.\n"
exit 0
}
}
printf "\nYou have lost, better luck next time.\033[0m\n"
exit 0
}
function help {
cat <<END_HELP
Usage: $1 [-b INTEGER] [-t INTEGER] [-l FILE] [-r] [-h]
-b specify game board size (sizes 3-9 allowed)
-t specify target score to win (needs to be power of 2)
-l log debug info into specified file
-r reload the previous game
-h this help
END_HELP
}
#parse commandline options
while getopts "b:t:l:rh" opt; do
case $opt in
b)
board_size="$OPTARG"
let '(board_size>=3)&(board_size<=9)' || {
printf "Invalid board size, please choose size between 3 and 9\n"
exit -1
}
;;
t)
target="$OPTARG"
printf "obase=2;$target\n" | bc | grep -e '^1[^1]*$'
let $? && {
printf "Invalid target, has to be power of two\n"
exit -1
}
;;
r) reload_flag="1" ;;
h)
help $0
exit 0
;;
l) exec 3>$OPTARG ;;
\?)
printf "Invalid option: -"$opt", try $0 -h\n" >&2
exit 1
;;
:)
printf "Option -"$opt" requires an argument, try $0 -h\n" >&2
exit 1
;;
esac
done
#init board
let fields_total=board_size*board_size
let index_max=board_size-1
for i in $(_seq 0 $fields_total); do board[$i]="0"; done
let pieces=0
generate_piece
first_round=$last_added
generate_piece
#load saved game if flag is set
if test $reload_flag = "1"; then
reload_game
fi
while true; do
print_board
key_react
let change && generate_piece
first_round=-1
let pieces==fields_total && {
check_moves
let moves==0 && end_game 0 #lose the game
}
done

50
bash/games/wordle.sh Executable file
View file

@ -0,0 +1,50 @@
words=($(grep '^\w\w\w\w\w$' /usr/share/dict/words | tr '[a-z]' '[A-Z]'))
actual=${words[$(($RANDOM % ${#words[@]}))]} end=false guess_count=0 max_guess=6
if [[ $1 == "unlimit" ]]; then
max_guess=999999
fi
while [[ $end != true ]]; do
guess_count=$(($guess_count + 1))
if [[ $guess_count -le $max_guess ]]; then
echo "Enter your guess ($guess_count / $max_guess):"
read guess
guess=$(echo $guess | tr '[a-z]' '[A-Z]')
if [[ " ${words[*]} " =~ " $guess " ]]; then
output="" remaining=""
if [[ $actual == $guess ]]; then
echo "You guessed right!"
for ((i = 0; i < ${#actual}; i++)); do
output+="\033[30;102m ${guess:$i:1} \033[0m"
done
printf "$output\n"
end=true
else
for ((i = 0; i < ${#actual}; i++)); do
if [[ "${actual:$i:1}" != "${guess:$i:1}" ]]; then
remaining+=${actual:$i:1}
fi
done
for ((i = 0; i < ${#actual}; i++)); do
if [[ "${actual:$i:1}" != "${guess:$i:1}" ]]; then
if [[ "$remaining" == *"${guess:$i:1}"* ]]; then
output+="\033[30;103m ${guess:$i:1} \033[0m"
remaining=${remaining/"${guess:$i:1}"/}
else
output+="\033[30;107m ${guess:$i:1} \033[0m"
fi
else
output+="\033[30;102m ${guess:$i:1} \033[0m"
fi
done
printf "$output\n"
fi
else
echo "Please enter a valid word with 5 letters!"
guess_count=$(($guess_count - 1))
fi
else
echo "You lose! The word is:"
echo $actual
end=true
fi
done

246
bash/gitsetup.sh Executable file
View file

@ -0,0 +1,246 @@
#!/bin/bash
# Get the current git config list
gc_ls="$(git config --list)"
# ANSI color codes
RED='\033[0;31m'
CYAN='\033[0;36m'
YELLOW='\033[0;33m'
GREEN='\033[0;32m'
BLUE='\033[0;34m'
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_warning() {
printf "${BOLD}${YELLOW}WARNING: ${NC}${YELLOW}%s${NC}\n" "$1"
}
echo_gls() {
printf "${BOLD}${YELLOW}%s${NC}\n" "$1"
}
echo_note() {
printf "${BOLD}${LIGHT_GREEN}NOTE: ${NC}${LIGHT_GREEN}%s${NC}\n" "$1"
}
# Function to print colored text
print_color() {
printf "%b%s%b\n" "$1" "$2" "$NC"
}
# Check if the given command exists silently
command_exists() {
command -v "$@" >/dev/null 2>&1
}
# Function to install a package if `curl` is available
if command_exists curl; then
install_pkg() {
sh -c "$(curl -sSL https://git.k4li.de/pika/scripts/raw/branch/main/bash/snippets/install_pkg.sh)" -- "$@"
}
else
echo_error "curl is not installed, universal install disabled!"
fi
# Function for barebones Git setup
gitBareBonesSetup() {
echo_gls "Please enter your username: "
read -r g_username
echo_gls "Please enter your email: "
read -r g_mail
echo_gls "Please enter your default branch name <e.g. main>"
read -r g_branch
git config --global user.name "$g_username"
git config --global user.email "$g_mail"
git config --global init.defaultBranch "$g_branch"
echo_note "Barebones Git setup complete!"
read </dev/tty
}
# Function for extended Git configuration
gitExtendedSetup() {
echo_gls "Please enter the default branch name (e.g., main): "
read -r g_branch
echo_gls "Please enter your preferred text editor (e.g., vim, nano, code): "
read -r g_editor
# Set default branch name
git config --global init.defaultBranch "$g_branch"
# Set preferred text editor
git config --global core.editor "$g_editor"
# Set some common aliases
git config --global alias.co "checkout"
git config --global alias.br "branch"
git config --global alias.ci "commit"
git config --global alias.st "status"
# Set default push behavior to simple (to avoid issues with push)
git config --global push.default simple
# Enable credential caching for 15 minutes (900 seconds)
git config --global credential.helper "cache --timeout=900"
# Add a global .gitignore file (optional)
echo_gls "Do you have a global .gitignore file? If so, please provide the path (or leave blank to skip): "
read -r g_gitignore
if [ -n "$g_gitignore" ] && [ -f "$g_gitignore" ]; then
git config --global core.excludesfile "$g_gitignore"
echo_note "Global .gitignore file set to $g_gitignore"
else
echo_warning "Skipping global .gitignore configuration!"
fi
echo_note "Extended Git setup complete!"
read </dev/tty
}
gitChangeMail() {
echo_gls "Please enter the new e-Mail: "
read -e -r new_mail
git config --global user.email "$new_mail"
echo_note "Email updated to $new_mail"
read </dev/tty
}
gitChangeUsername() {
currentName="$(git config --get user.name)"
echo_warning "Do you really want to change your username? (current username is $currentName) (y/N): "
read -e -r confirm
if [[ "$currentName" -eq ^"yY" ]]; then
echo_gls "Please enter the new Username: "
read -r new_username
git config --global user.name "$new_username"
echo_note "Username updated to $new_username"
read </dev/tty
fi
}
gitCredentialsAddAuthToken() {
local CREDENTIALS_FILE="$HOME/.git-credentials"
echo_gls "Enter the domain/server (e.g. git.k4li.de):"
read -r g_domain
echo_gls "Enter your username:"
read -r g_user
echo_gls "Enter your authentication token:"
read -r g_token # The '-s' flag hides input for privacy
# Append the new credentials to the file
echo "https://$g_user:$g_token@$g_domain" >>"$CREDENTIALS_FILE"
echo "Credentials added for $g_domain in $CREDENTIALS_FILE"
git config --global credential.helper store
chmod 600 "$HOME/.git-credentials"
read </dev/tty
}
# Display the current Git configuration
showGitConfig() {
echo_gls "This is your current git-config:"
echo_gls "─────────────────────────────────────────────────"
# Loop through each line of the git config list and format it nicely
printf "%s\n" "$gc_ls" | while IFS='=' read -r key value; do
# Extract section/category name (before the first period)
category="${key%%.*}"
# Extract setting name (after the first period)
setting="${key#*.}"
# Use different colors and styles for category and setting names
printf "${BOLD}${CYAN}%-20s${NC}: ${LIGHT_GREEN}%-30s${NC} ${YELLOW}%s${NC}\n" "$category" "$setting" "$value"
done
echo_gls "─────────────────────────────────────────────────"
read </dev/tty
}
# Main menu loop
main_menu() {
local selected=0
local key=""
while true; do
display_menu
# Read a single character
read -rsn1 key
case $key in
A | k) # Up arrow or k
((selected--))
if [[ $selected -lt 0 ]]; then
selected=$((${#options[@]} - 1))
fi
;;
B | j) # Down arrow or j
((selected++))
if [[ $selected -ge ${#options[@]} ]]; then
selected=0
fi
;;
q) # q for quit
exit 0
;;
"") # Enter key
case $selected in
0) gitBareBonesSetup ;;
1) gitExtendedSetup ;;
2) gitChangeMail ;;
3) gitChangeUsername ;;
4) gitCredentialsAddAuthToken ;;
5) showGitConfig ;;
6) exit 0 ;;
esac
;;
esac
done
}
# Menu options
declare -a options=(
"BareBones setup"
"Extended setup"
"Change e-Mail"
"Change username"
"Activate git-credentials and add Authentication token for any git server"
"Show the current git config"
"Exit"
)
# Function to display the menu
display_menu() {
clear
print_color "$BLUE" "=== Git setup tui ==="
echo_note "(navigate with j/k or up/down arrows - q to quit)"
for i in "${!options[@]}"; do
if [[ $i -eq $selected ]]; then
print_color "$GREEN" "> ${options[$i]}"
else
echo " ${options[$i]}"
fi
done
}
# Main function
main() {
if command_exists git; then
main_menu </dev/tty
else
install_pkg git && main
fi
}
main

160
bash/installs/forgejo-runner.sh Executable file
View file

@ -0,0 +1,160 @@
#!/usr/bin/env bash
# ─< 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() {
local message="${RED}$1${NC}\n"
printf "$message" >&2
_STORED_ERRORS="${_STORED_ERRORS}${message}"
}
echo_warning() {
local message="${YELLOW}$1${NC}\n"
printf "$message"
_STORED_WARNINGS="${_STORED_WARNINGS}${message}"
}
echo_info() {
local message="${CYAN}$1${NC}\n"
printf "$message"
_STORED_INFOS="${_STORED_INFOS}${message}"
}
echo_note() {
local 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() {
local 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
}
_exit() {
display_stored_messages
exit 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
}
getRunner() {
# ╭─────────────────────────────────────────────────────────╮
# │ should output something like this │
# │ ╭─────────────────────────────────────────────────────╮ │
# │ │ Good signature from "Forgejo <contact@forgejo.org>" │ │
# │ │ aka "Forgejo Releases <release@forgejo.org>" │ │
# │ ╰─────────────────────────────────────────────────────╯ │
# ╰─────────────────────────────────────────────────────────╯
#
# ─< get the runner version >─────────────────────────────────────────────────────────────
export RUNNER_VERSION=$(curl -X 'GET' https://data.forgejo.org/api/v1/repos/forgejo/runner/releases/latest | jq .name -r | cut -c 2-)
# ─< get the runner binary >──────────────────────────────────────────────────────────────
wget -O forgejo-runner https://code.forgejo.org/forgejo/runner/releases/download/v${RUNNER_VERSION}/forgejo-runner-${RUNNER_VERSION}-linux-amd64
# ─< make it executable >─────────────────────────────────────────────────────────────────
chmod +x forgejo-runner
# ─< get the verification hashes >────────────────────────────────────────────────────────
wget -O forgejo-runner.asc https://code.forgejo.org/forgejo/runner/releases/download/v${RUNNER_VERSION}/forgejo-runner-${RUNNER_VERSION}-linux-amd64.asc
gpg --keyserver keys.openpgp.org --recv EB114F5E6C0DC2BCDD183550A4B61A2DC5923710
gpg --verify forgejo-runner.asc forgejo-runner
}
userCreation() {
$_sudo useradd --create-home runner
$_sudo usermod -aG docker runner
}
envCheck() {
if ! command_exists curl; then
echo_error "You have no curl installed"
_exit
fi
if ! command_exists wget; then
echo_error "You have no wget installed"
_exit
fi
if ! command_exists docker; then
echo_warning "Sorry, you have no docker installed.."
_exit
fi
if command_exists forgejo-runner; then
echo_warning "forgejo-runner binary is already callable.."
_exit
fi
}
if envCheck; then
getRunner
if ! grep -iq "runner" /etc/passwd; then
userCreation
fi
forgejo-runner generate-config >config.yml && $_sudo rsync -avP config.yml /home/runner/config.yml
fi

357
bash/postinstall.sh Executable file
View file

@ -0,0 +1,357 @@
{
#!/bin/sh
# ╭──────────────╮
# │ 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() {
pkger=""
for pkg in apt-get dnf pacman apk zypper; do
if command_exists $pkg; then
printf "Using ${RED}${pkg}${NC} method.."
pkger="$pkg"
# break
return 0
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.."
$_sudo apt update
if ! command_exists sudo; then
echo_note "Installing sudo"
apt 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 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 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() {
if ! checkPkg; then
return 1
fi
echo_info "Installing base packages..."
case "$pkger" in
apt-get)
echo_info "apt-get"
aptBase
;;
dnf)
echo_info "dnf"
dnfBase
;;
pacman)
echo_info "pacman"
pacmanBase
;;
zypper)
echo_info "zypper"
zypperBase
;;
apk) ;;
esac
}
optimize_os() {
if ! checkPkg; then
return 1
fi
echo_info "Running OS optimizations..."
# debug
echo_error "PCK=$pkg PKGER=$pkger"
case "$pkg" in
apt-get)
aptOptimize
;;
dnf)
echo_warning "Currently, there are no optimizations for the fedora distribution."
;;
pacman)
echo_warning "Currently, there are no optimizations for the arch distribution."
;;
zypper)
echo_warning "Currently, there are no optimizations for the openSUSE distribution."
;;
apk)
echo_warning "Currently, there are no optimizations for the Alpine 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
bash/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

38
bash/setup/hlpush.sh Executable file
View file

@ -0,0 +1,38 @@
#!/usr/bin/env bash
# ─< 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"
}
main() {
local dir="/opt/docker"
cd $dir || echo_error "Can't navigate to $dir"
git add .
git commit -m "Automatic push on $(date)"
git push
}
main

152
bash/setup/homelapGitSetup.sh Executable file
View file

@ -0,0 +1,152 @@
#!/usr/bin/env bash
# ─< 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
}
check_root
gitUserSetup() {
local g_username="server-agent"
local g_mail="info@team-pieck.de"
local g_branch="main"
local g_domain="git.k4li.de"
local CREDENTIALS_FILE="$HOME/.git-credentials"
git config --global user.name "$g_username"
git config --global user.email "$g_mail"
git config --global init.defaultBranch "$g_branch"
if [[ ! -e "$CREDENTIALS_FILE" ]]; then
echo_note "Enter your authentication token:"
read -r -s g_token </dev/tty # The '-s' flag hides input for privacy
# Append the new credentials to the file
echo "https://$g_username:$g_token@$g_domain" >>"$CREDENTIALS_FILE"
echo "Credentials added for $g_domain in $CREDENTIALS_FILE"
git config --global credential.helper store
chmod 600 "$HOME/.git-credentials"
fi
}
gitDirSetup() {
cd /opt/docker || echo_error "could not cd /opt/docker"
if $_sudo ping -w2 10.255.255.1; then
local location="hl"
elif $_sudo ping -w2 10.69.69.2; then
location="vps"
fi
git init .
git branch -m main
if git remote add origin "https://git.k4li.de/homelab/${location}-$(hostname)"; then
git add .
git commit -m "Initial script commit"
git push -u origin main
else
echo_error 'Failed setting the git repo up with git remote add "$(hostname)" "https://git.k4li.de/homelab/${location}-$(hostname).git"'
fi
}
set_cronjob() {
# Configuration
CRON_COMMAND="/opt/scripts/hlpush.sh"
CRON_SCHEDULE="0 3,15 * * *"
CRON_LOG="./cronjobs.log"
CRON_ENTRY="$CRON_SCHEDULE $CRON_COMMAND >> $CRON_LOG 2>&1"
# Check for existing entry
EXISTING_ENTRIES=$(crontab -l 2>/dev/null)
# Add entry if not exists
if ! echo "$EXISTING_ENTRIES" | grep -qF "$CRON_ENTRY"; then
# Create temporary cron file
TMPFILE=$(mktemp)
# Preserve existing entries
[ -n "$EXISTING_ENTRIES" ] && echo "$EXISTING_ENTRIES" >"$TMPFILE"
# Add header and new entry
echo -e "\n# Daily 3AM/3PM job added $(date)" >>"$TMPFILE"
echo "$CRON_ENTRY" >>"$TMPFILE"
# Install new cron file
crontab "$TMPFILE"
rm -f "$TMPFILE"
echo_info "Success: Cronjob installed"
echo_note "Verify with: crontab -l"
else
echo_warning "Notice: Cronjob already exists"
exit 0
fi
}
if ! command_exists git; then
return 1
echo_error "You don't have git installed!"
fi
gitUserSetup
if [[ -d /opt/docker/ ]]; then
gitDirSetup
fi
if [[ -d /opt/scripts/bash ]]; then
set_cronjob
else
if command_exists curl; then
curl -o /opt/scripts/hlpush.sh https://git.k4li.de/scripts/bash/raw/branch/main/setup/hlpush.sh
fi
fi

207
bash/setup/tuiDots.sh Executable file
View file

@ -0,0 +1,207 @@
#!/bin/bash
# ─< ANSI color codes >───────────────────────────────────────────────────────────────────
RED='\033[0;31m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
GREEN='\033[0;32m'
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
}
# Function to print colored text
print_color() {
printf "%b%s%b\n" "$1" "$2" "$NC"
}
# Function to return to the main menu
return_to_menu() {
echo_info "Returning to the main menu in 3 seconds..."
sleep 3
}
gitDir="$HOME/git/dotfiles"
dotRemote="https://git.k4li.de/dotfiles"
instRemote="https://git.k4li.de/scripts/sh/raw/branch/main/installs"
if [ ! -d "$gitDir" ]; then
print_color "$RED" "=== git dir created - $gitDir ==="
mkdir -p "$gitDir"
fi
d_="git curl"
for dependency in $d_; do
if ! command_exists "$dependency"; then
print_color "$RED" "You're missing some dependencies!"
print_color "$RED" "Install $dependency and start the script again"
exit 1
fi
done
# Function to display the menu
display_menu() {
clear
print_color "$BLUE" "=== Environment Setup Menu ==="
for i in "${!options[@]}"; do
if [[ $i -eq $selected ]]; then
print_color "$GREEN" "> ${options[$i]}"
else
echo " ${options[$i]}"
fi
done
}
# Function to handle dotfiles setup
nvimSetup() {
print_color "$YELLOW" "Setting up neovim..."
if [ ! -d "$HOME/.config/nvim" ]; then
echo_note "Installing into .config directly"
git clone --branch minimal --recurse-submodule --depth=1 "${dotRemote}/nvim.git" "$HOME/.config/nvim"
else
if [ -d "$gitDir/nvim" ]; then
cd "$gitDir/nvim" || {
echo_error "The given path - $gitDir/nvim - was not found!"
return 1
}
git pull --recurse-submodule
else
echo_note "Installing into $gitDir/nvim"
git clone --branch minimal --recurse-submodule --depth=1 "${dotRemote}/nvim.git" "$gitDir/nvim"
fi
fi
return_to_menu
}
# Function to handle CLI tool installation
nvimMinimalSetup() {
print_color "$YELLOW" "Setting up neovim minimal branch..."
if [ ! -d "$HOME/.config/nvim" ]; then
echo_note "Installing into .config directly"
git clone --branch minimal --recurse-submodule --depth=1 "${dotRemote}/nvim.git" "$HOME/.config/nvim"
else
if [ -d "$gitDir/nvim-minimal" ]; then
cd "$gitDir/nvim-minimal" || {
echo_error "The given path - $gitDir/nvim-minimal - was not found!"
return 1
}
git pull --recurse-submodule
else
echo_note "Installing into $gitDir/nvim-minimal"
git clone --branch minimal --recurse-submodule --depth=1 "${dotRemote}/nvim.git" "$gitDir/nvim-minimal"
fi
fi
return_to_menu
}
installStuff() {
echo_info "I want to install.."
read -r gitPackage </dev/tty
echo_note "Installing from $instRemote/$gitPackage"
curl -fsSL "${instRemote}/${gitPackage}.sh" | sh
return_to_menu
}
sudoOptions() {
if [[ -e /etc/sudoers ]]; then
echo "Defaults pwfeedback" | $_sudo tee -a /etc/sudoers
echo "Defaults insults" | $_sudo tee -a /etc/sudoers
else
echo_error "There is no /etc/sudoers file."
fi
return_to_menu
}
# Menu options
declare -a options=(
"Sudo-Options"
"neovim"
"neovim-minimal"
"Install.."
"Exit"
)
# Main menu loop
main_menu() {
local selected=0
local key=""
while true; do
display_menu
# Read a single character
read -rsn1 key
case $key in
q | Q)
exit 0
;;
A | k) # Up arrow or k
((selected--))
if [[ $selected -lt 0 ]]; then
selected=$((${#options[@]} - 1))
fi
;;
B | j) # Down arrow or j
((selected++))
if [[ $selected -ge ${#options[@]} ]]; then
selected=0
fi
;;
"" | l) # Enter key
case $selected in
0) sudoOptions ;;
1) nvimSetup ;;
2) nvimMinimalSetup ;;
3) installStuff ;;
4) exit 0 ;;
esac
;;
esac
done
}
# Start the main menu
check_root
main_menu </dev/tty

86
bash/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
bash/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