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.

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.

alias clip='xclip -selection clipboard'

When you pipe to this, for example ls | clip, it will stick the output of the command ran into the clipboard without needing to manually copy the output.

#Create a dir and cd into it
mkcd() { mkdir -p "$@" && cd "$@"; }

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

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 gl='git log'
alias server-name-here='ssh server-name-here'

I have a bunch of the server aliases. I use those and gl the most.

alias gimme='git checkout'

on most of my systems I get tired of constantly lsing after a cd so I combine them:

cd(){
    cd $1 && ls
}

(excuse if this doesn’t work, I am writing this from memory)

I also wrote a function to access docker commands quicker on my Truenas system. If passed nothing, it enters the docker jailmaker system, else it passes the command to docker running inside the system.

docker () {
        if [[ "$1" == "" ]]; then
                jlmkr shell docker
                return
        else
                sudo systemd-run --pipe --machine docker docker "$@"
                return
        fi
}

I have a few similar shortcuts for programs inside jailmaker and long directories that I got sick of typing out.

$ which diffuc
diffuc: aliased to diff -uw --color=always

$ which grepnir
grepnir: aliased to grep -niIr

$ cat `which ts`
#!/bin/bash

if [ "$#" -lt 1 ]; then
                tmux list-sessions
                exit
fi

if ! tmux attach -t "$1"
then
                tmux new-session -s "$1"
fi

it’s somewhat vibe coded but the one i probably use the most is this one to swap between speakers and headset. the device name to look for is just put directly in there, it’d take some adjustment to run it on different machines. this is in my .bashrc:

# switch sinks
toggle_audio() {
  # Find headset sink ID dynamically
  headset_id=$(pactl list sinks short | grep "Plantronics" | awk '{print $1}')
  
  # Find speakers sink ID dynamically
  speakers_id=$(pactl list sinks short | grep "pci-0000_05_00.6" | awk '{print $1}')
  
  # Get current default sink
  current_sink=$(pactl get-default-sink)
  
  # Get current sink ID
  current_id=$(pactl list sinks short | grep "$current_sink" | awk '{print $1}')
  
  # Toggle between the two
  if [ "$current_id" = "$headset_id" ]; then
    pactl set-default-sink "$speakers_id"
    echo "Switched to speakers (Sink $speakers_id)"
  else
    pactl set-default-sink "$headset_id"
    echo "Switched to headset (Sink $headset_id)"
  fi
}

generally i try not to use too many custom things because for work i regularly work on all kinds of different servers and i’ve just been too lazy to set up some solution to keep it all in sync. someday…

i use

alias kimg='kitty +kitten icat' 

to display images in my terminal pretty simple but nice

I have a few interesting ones.

Download a video:

alias yt="yt-dlp -o '%(title)s-%(id)s.%(ext)s' "

Execute the previous command as root:

alias please='sudo $(fc -n -l -1)'

Delete all the Docker things. I do this surprisingly often:

alias docker-nuke="docker system prune --all --volumes --force"

This is a handy one for detecting a hard link

function is-hardlink {
  count=$(stat -c %h -- "${1}")
  if [ "${count}" -gt 1 ]; then
    echo "Yes.  There are ${count} links to this file."
  else
    echo "Nope.  This file is unique."
  fi
}

I run this one pretty much every day. Regardless of the distro I’m using, it Updates All The Things:

function up {
  if [[ $(command -v yay) ]]; then
    yay -Syu --noconfirm
    yay -Yc --noconfirm
  elif [[ $(command -v apt) ]]; then
    sudo apt update
    sudo apt upgrade -y
    sudo apt autoremove -y
  fi
  flatpak update --assumeyes
  flatpak remove --unused --assumeyes
}

I maintain an aliases file in GitLab with all the stuff I have in my environment if anyone is curious.

For docker: I’m not following best practices. I have a giant docker compose file for my entire home lab, this is how I update things:

alias dockpull="docker compose pull"
alias dockup="docker compose up -d --remove-orphans"

I made this one to find binaries in NixOs and other systems

get_bin_path() {
        paths=${2:-$PATH}
        for dr in $(echo $paths | tr ':' '\n') ; do
                if [ -f "$dr/$1" ] ; then
                        echo "$dr/$1"
                        return 0
                fi
        done
        return 1
}

Then I made this one to, if I have a shell o opened inside neovim it will tell the neovim process running the shell to open a file on it, instead of starting a new process

_nvim_con() {
        abs_path=$(readlink --canonicalize "$@" | sed s'| |\\ |'g)
        $(get_bin_path nvim) --server $NVIM --remote-send "<ESC>:edit $abs_path<CR>"
        exit
}

# start host and open file
_nvim_srv() {
        $(get_bin_path nvim) --listen $HOME/.cache/nvim/$$-server.pipe $@
}

if [ -n "$NVIM" ] ; then
        export EDITOR="_nvim_con"
else
        export EDITOR="_nvim_srv"
fi

Lastly this bit: which if it detects a file and a line number split by a : it will open the file and jump to the line

_open() {
        path_parts=$(readlink --canonicalize "$@" | sed s'| |\\ |'g | sed 's/:/\t/' )
        file=$(echo "$path_parts" | awk ' { print $1 }' )
        line=$(echo "$path_parts" | awk ' { print $2 }' )

        if [ -n "$line" ] ; then
                # has line number
                if [ -n "$NVIM" ] ; then
                        $(get_bin_path nvim) --server $NVIM --remote-send "<ESC>:edit $file<CR>:+$line<CR>"
                        exit
                else
                        $(get_bin_path nvim) --listen $HOME/.cache/nvim/$$-server.pipe $file "+:$line"
                fi
        else
                $EDITOR $file
        fi
}

alias nvim="_open"

all of my bash config is here