I alias traditional stuff to better, usually drop-in versions of that thing on computers that have the better thing. I often forget which systems have the better thing, so this helps me get the better experience if I was able to install it at some point. For example I alias cat to bat, or top to htop, or dig to drill, etc.

This tmux wrapper is remarkably convenient:

Usage:

# Usage: t [session-name]
#
# With no arguments:
#   Lists existing tmux sessions, or prints "[No sessions]" if none exist.
#
# With a session name:
#   Attempts to attach to the named tmux session.
#   If the session does not exist, creates a new session with that name.
#
# Examples:
#   t            # Lists all tmux sessions
#   t dev        # Attaches to "dev" session or creates it if it doesn't exist

function t {
	if [[ -z $1 ]]; then
		tmux ls 2> /dev/null || echo "[No sessions]"
	else
		tmux attach -t $@ 2> /dev/null
		if [[ $? -ne 0 ]]; then
			tmux new -s $@
		fi
	fi
}

alias fuck='sudo $(history -p \!\!)'

jmpd(jump directory): fuzzy finds and opens directory with fzf

# fish shell
function jmpd
    set _selection $(fzf --walker=dir);
    if test -n "$_selection"
        cd "$_selection";
    end
end

g-push

git push origin `git branch --show`

I have a collection of about 8 machines around the house (a lot of Raspberry Pi) that I ssh around to from various points.

I have setup scripts named: ssp1 ssp2 ssba ss2p etc. to ssh into the various machines, and of course shared public ssh keys among them to skip the password prompt. So, yes, once you are “in” one machine in my network, if you know this, you are “in” all of them, but… it’s bloody convenient.

I wrote a script called please. You input please followed by any other command (e.g. please git clone, please wget blahblah) and a robotic voice will say “affirmative,” then the command will run, and when it completes, the robotic voice reads out the exit code (e.g. “completed successfully” or “failed with status 1” etc.)

This is useful for when you have a command that takes a long time and you want to be alerted when it’s finished. And it’s a gentleman.

I use Clevis to auto-unlock my encrypted root partition with my TPM; this means when my boot partition is updated (E.G a kernel update), I have to update the PCR register values in my TPM. I do it with my little script /usr/bin/update_pcr:

#!/bin/bash
clevis luks regen -d /dev/nvme1n1p3 -s 1 tpm2

I run it with sudo and this handles it for me. The only issue is I can’t regenerate the binding immediately after the update; I have to reboot, manually enter my password to decrypt the drive, and then do it.

Now, if I were really fancy and could get it to correctly update the TPM binding immediately after the update, I would have something like an apt package shim with a hook that does it seamlessly. Honestly, I’m surprised that distributions haven’t developed robust support for this; the technology is clearly available (I’m using it), but no one seems to have made a user-friendly way for the common user to have TPM encryption in the installer.

Not exactly a single script, but I use scm breeze for git stuff. Has a ton of QoL features for working with git

https://github.com/scmbreeze/scm_breeze

On MacOS, to open the current directory in Finder: alias f='open -a Finder .'

Hey OP, consider using $XDG_RUNTIME_DIR instead of /tmp. It’s now the more proper place for these kinds of things to avoid permission issues, although I’m sure you’re on a single user system like most people. I have clipboard actions set to download with yt-dlp :)

My favorite aliases are:

alias dff='findmnt -D -t nosquashfs,notmpfs,nodevtmpfs,nofuse.portal,nocifs,nofuse.kio-fuse'

alias lt='ls -t | less'

here we go:

dedup:

#!/usr/bin/awk -f
!x[$0]++

this removes duplicate lines, preserving line order

iter:

#!/usr/bin/bash
if [[ "${@}" =~ /$ ]]; then
    xargs -rd '\n' -I {} "${@}"{}
else
    xargs -rd '\n' -I {} "${@}" {}
fi

This executes a command for each line. It can also be used to compare two directories, ie:

du -sh * > sizes; ls | iter du -sh ../kittens/ > sizes2

fadeout:

#!/bin/bash
# I use this to fade out layered brown noise that I play at a volume of 130%
# This takes about 2 minutes to run, and the volume is at zero several seconds before it's done.
# ################
# DBUS_SESSION_BUS_ADDRESS is needed so that playerctl can find the dbus to use MPRIS so it can control mpv
export DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/1000/bus"
# ################
for i in {130..0}
do
    volume=$(echo "scale=3;$i/100" | bc)
    sleep 2.3
    playerctl --player=mpv volume $volume
done

lbn:

#!/bin/bash
#lbn_pid=$(cat ~/.local/state/lbn.pid)
if pgrep -fl layered_brown
then
	pkill -f layered_brown
else
	export DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/1000/bus"
	mpv -ao pulse ~/layered_brown_noise.mp3 >>lbn.log 2>&1 &
	sleep 3
	playerctl -p mpv volume 1.3 >>lbn.log 2>&1 &
fi

This plays “layered brown noise” by crysknife. It’s a great sleep aid.

here are some aliases:

alias m='mpc random off; mpc clear'
alias mpcc='ncmpcpp'
alias thesaurus='dict -d moby-thesaurus'
alias wtf='dict -d vera'
alias tvplayer='mpv -fs --geometry=768x1366+1366+0'

Here is on that I actually don’t use, but want to use it in scripts. It is meant to be used by piping it. It’s simple branch with user interaction. I don’t even know if there is a standard program doing exactly that already.

# usage: yesno [prompt]
# example:
#   yesno && echo yes
#   yesno Continue? && echo yes || echo no
yesno() {
    local prompt
    local answer
    if [[ "${#}" -gt 0 ]]; then
        prompt="${*} "
    fi
    read -rp "${prompt}[y/n]: " answer
    case "${answer}" in
    [Yy0]*) return 0 ;;
    [Nn1]*) return 1 ;;
    *) return 2 ;;
    esac
}

One of favorites cds to the root of a project directory from a subdirectory,

# Changes to top-level directory of git repository.
alias gtop="cd \$(git rev-parse --show-toplevel)"

I often want to know the status code of a curl request, but I don’t want that extra information to mess with the response body that it prints to stdout.

What to do?

Render an image instead, of course!

curlcat takes the same params as curl, but it uses iTerm2’s imgcat tool to draw an “HTTP Cat” of the status code.

It even sends the image to stderr instead of stdout, so you can still pipe curlcat to jq or something.

#!/usr/bin/env zsh

stdoutfile=$( mktemp )
curl -sw "\n%{http_code}" $@ > $stdoutfile
exitcode=$?

if [[ $exitcode == 0 ]]; then
  statuscode=$( cat $stdoutfile | tail -1 )

  if [[ ! -f $HOME/.httpcat$statuscode ]]; then
    curl -so $HOME/.httpcat$statuscode https://http.cat/$statuscode
  fi

  imgcat $HOME/.httpcat$statuscode 1>&2
fi

cat $stdoutfile | ghead -n -1

exit $exitcode

Note: This is macOS-specific, as written, but as long as your terminal supports images, you should be able to adapt it just fine.